వాక్యనిర్మాణం
రెట్టింపు NS ( రెట్టింపు ఆధారం, రెట్టింపు exp);
ది NS() ఫంక్షన్ లో నిర్వచించబడింది గణితం. h శీర్షిక ఫైల్.
వాదనలు
ఈ ఫంక్షన్ రెండు వాదనలు తీసుకుంటుంది, ఆధారం మరియు exp, యొక్క విలువను లెక్కించడానికి ఆధారం శక్తికి పెంచబడింది exp . ఇక్కడ ఆధారం మరియు exp రెండూ రెట్టింపు.
తిరిగి విలువలు
విజయంపై, ది NS() ఫంక్షన్ విలువను అందిస్తుంది ఆధారం శక్తికి పెంచబడింది exp .
విలువ ఉంటే exp 0, ది NS() ఫంక్షన్ రిటర్న్స్ 1.
ఒకవేళ ఆధారం ప్రతికూలంగా ఉంది మరియు exp సమగ్రమైనది కాదు, ది NS() ఫంక్షన్ రిటర్న్స్ NaN (సంఖ్య- A- సంఖ్య).
ఉదాహరణలు
// ఉదాహరణ 1..సి#చేర్చండి
#చేర్చండి
intప్రధాన()
{
intఫలితం;
ఫలితం= (int) NS (3,5);
printf (' nపౌ (3,5) => %d ',ఫలితం);
printf (' nపౌ (3, -5) => %lf ', NS (3, -5));
printf (' nపౌ (-3, -5) => %lf ', NS (-3, -5));
printf (' nపౌ (3,5.1) => %lf ', NS (3,5.1));
printf (' nపౌ (-3,5.1) => %lf ', NS (-3,5.1));
printf (' nపౌ (-3, -5.1) => %lf n', NS (-3, -5.1));
తిరిగి 0;
}
Example1.c లో, మేము అవుట్‌పుట్‌ను చూశాము NS() ఫంక్షన్ ఇక్కడ మేము ఉపయోగిస్తాము -లమ్ గణిత లైబ్రరీలో లింక్ చేయడానికి కమాండ్ లైన్ పరామితి. పంక్తులు 10 నుండి 13 వరకు, మేము ఊహించిన విధంగా అవుట్‌పుట్ పొందాము. 14 మరియు 15 పంక్తుల కోసం, మేము పొందాము -నన్ (సంఖ్య కాదు) ఎందుకంటే రెండవ వాదన సమగ్రమైనది కాదు.
బిట్ షిఫ్టింగ్ ఉపయోగించి ఘాతాంకం
మేము ఘాతాంకాన్ని 2 యొక్క శక్తికి లెక్కించాలనుకుంటే, మేము బిట్ షిఫ్టింగ్ ఉపయోగించి చేయవచ్చు.
M ద్వారా ఎడమ షిఫ్ట్ మొదటి టర్మ్ మరియు 2 పవర్ m కి సమానం.
ఎన్<< m = n*పౌ (2, m)
M ద్వారా కుడి షిఫ్ట్ అనేది మొదటి టర్మ్ యొక్క విభజన మరియు పవర్ m కి సమానం.
n >> m = n/పౌ (2, m)
M పాజిటివ్‌గా ఉన్నప్పుడు మాత్రమే ఇది పని చేస్తుంది.
// ఉదాహరణ 2.సి#చేర్చండి
intప్రధాన()
{
printf (' n1<%d',1<<3);
printf (' n5<%d',5<<3);
printf (' n-5<%d', -53 => %డి', 40 >> 3);
printf (' n40>>3 => %డి', 40 >> 3);
printf (' n-40>>3 => %d n', -40 >> 3);
రిటర్న్ 0;
}
Example2.c లో, బిట్ షిఫ్ట్ ఆపరేటర్‌ను ఎక్స్‌పోనెంట్ పవర్ 2 కి ఎలా ఉపయోగించవచ్చో చూశాము. కోడ్ సంక్లిష్టతను తగ్గించడానికి ఇది చాలా ఉపయోగకరంగా ఉంటుంది.
వినియోగదారు నిర్వచించిన ఫంక్షన్ ఉపయోగించి ఘాతాంకం
ఘాతాలను లెక్కించడానికి మేము వినియోగదారు నిర్వచించిన ఫంక్షన్‌ను వ్రాయవచ్చు. Example3.c లో, మేము వినియోగదారు నిర్వచించిన ఫంక్షన్‌ను వ్రాస్తాము ఘాతాంకం (), ఇది టైప్ ఫ్లోట్ యాంట్ పూర్ణాంకం ఆధారంగా రెండు ఆర్గ్యుమెంట్‌లను తీసుకుంటుంది.
// ఉదాహరణ 3. సి#చేర్చండి
తేలుతాయిఘాతాంకం(తేలుతాయిఆధారం, int exp )
{
తేలుతాయిఫలితం=1.0;
తేలుతాయిi;
ఉంటే( exp < 0)
{
exp = -1 * exp ;
కోసం(i=1;i<= exp ;i++)
ఫలితం=ఫలితం*ఆధారం;
ఫలితం= 1.0/ఫలితం;
}
లేకపోతే
{
కోసం(i=1;i%f', ఘాతాంకం (3,0));
printf ('నెక్సొనెంట్(3, -5) => %f', ఘాతాంకం (3, -5));
printf ('నెక్సొనెంట్(-3, -5) => %f', ఘాతాంకం (-3, -5));
రిటర్న్ 0;
}
Example3.c యూజర్ నిర్వచించిన ఫంక్షన్ యొక్క అవుట్‌పుట్‌ను మేము చూశాము ఘాతాంకం () . ఘాతాంకం సమగ్రంగా ఉన్నప్పుడు ఈ ఫంక్షన్ పని చేస్తుంది. నిజమైన ఘాతాంకం కోసం, మేము దీనిని ఉపయోగించాలి NS() ఫంక్షన్
ముగింపు
ఈ ఆర్టికల్లో, మేము దీనిని ఉపయోగించడం చూశాము NS() ఫంక్షన్ మరియు బిట్ షిఫ్టింగ్ C భాషలో ఘాతాంకం ఎలా లెక్కించబడుతుందో ఆపరేటర్. ఘాతాంకాలను లెక్కించడానికి మా స్వంత ఫంక్షన్ ఎలా రాయాలో కూడా నేర్చుకున్నాము. ఇప్పుడు మన సి ప్రోగ్రామ్‌లో ఈ టెక్నిక్‌లను ఎలాంటి సందేహం లేకుండా ఉపయోగించవచ్చు.