தொடரியல்
இரட்டை என். எஸ் ( இரட்டை அடித்தளம், இரட்டை exp);
தி என். எஸ்() செயல்பாடு வரையறுக்கப்பட்டுள்ளது கணிதம். h தலைப்பு கோப்பு.
வாதங்கள்
இந்த செயல்பாடு இரண்டு வாதங்களை எடுக்கிறது, அடித்தளம் மற்றும் exp, மதிப்பை கணக்கிட அடித்தளம் சக்திக்கு உயர்த்தப்பட்டது exp . இங்கே அடித்தளம் மற்றும் exp இரண்டும் இரட்டை.
திரும்ப மதிப்புகள்
வெற்றி குறித்து, தி என். எஸ்() செயல்பாடு அதன் மதிப்பை வழங்குகிறது அடித்தளம் சக்திக்கு உயர்த்தப்பட்டது exp .
மதிப்பு என்றால் exp 0, தி என். எஸ்() செயல்பாடு திரும்ப 1.
என்றால் அடித்தளம் எதிர்மறை மற்றும் exp ஒருங்கிணைந்ததல்ல, தி என். எஸ்() செயல்பாடு திரும்பும் NaN (எண்-எ-எண்).
எடுத்துக்காட்டுகள்
// உதாரணம் 1. சி#சேர்க்கிறது
#சேர்க்கிறது
intமுக்கிய()
{
intவிளைவாக;
விளைவாக= (int) என். எஸ் (3,5);
printf (' nபவு (3,5) => %d ',விளைவாக);
printf (' nபவு (3, -5) => %lf ', என். எஸ் (3, -5));
printf (' nபவு (-3, -5) => %lf ', என். எஸ் (-3, -5));
printf (' nபவு (3,5.1) => %lf ', என். எஸ் (3,5.1));
printf (' nபவு (-3,5.1) => %lf ', என். எஸ் (-3,5.1));
printf (' nபவு (-3, -5.1) => %lf n', என். எஸ் (-3, -5.1));
திரும்ப 0;
}
Example1.c இல், இதன் வெளியீட்டைப் பார்த்தோம் என். எஸ்() செயல்பாடு இங்கே நாம் பயன்படுத்துகிறோம் -எல்எம் கணித நூலகத்தில் இணைக்க கட்டளை வரி அளவுரு. 10 முதல் 13 வரிகள் வரை, எதிர்பார்த்தபடி வெளியீடு கிடைத்துள்ளது. 14 மற்றும் 15 வரிகளுக்கு, நமக்கு கிடைத்துள்ளது -நான் (எண் அல்ல) ஏனெனில் இரண்டாவது வாதம் ஒருங்கிணைந்ததல்ல.
பிட் ஷிஃப்டிங்கைப் பயன்படுத்தி அடுக்கு
நாம் அதிவேகத்தை 2 சக்திக்கு கணக்கிட விரும்பினால், பிட் ஷிஃப்டிங்கைப் பயன்படுத்தி அதைச் செய்யலாம்.
மீ மூலம் இடப்பெயர்ச்சி முதல் காலத்திற்கு சமம் மற்றும் சக்தி 2 க்கு சமம்.
என்<< m = n*பவு (2, மீ)
மீ மூலம் சரியான மாற்றம் முதல் காலத்தின் பிரிவுக்கு சமம் மற்றும் சக்தி 2 க்கு சமம்.
n >> மீ = n/பவு (2, மீ)
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;
மிதக்கநான்;
என்றால்( exp < 0)
{
exp = -1 * exp ;
க்கான(நான்=1;நான்<= exp ;நான்++)
விளைவாக=விளைவாக*அடித்தளம்;
விளைவாக= 1.0/விளைவாக;
}
வேறு
{
க்கான(நான்=1;நான்%எஃப்', அடுக்கு (3,0));
printf (' nexponent(3, -5) => %எஃப்', அடுக்கு (3, -5));
printf (' nexponent(-3, -5) => %எஃப்', அடுக்கு (-3, -5));
திரும்ப 0;
}
உதாரணம் 3. சி பயனர் வரையறுக்கப்பட்ட செயல்பாட்டின் வெளியீட்டைப் பார்த்தோம் அடுக்கு () . அடுக்கு ஒருங்கிணைந்த போது இந்த செயல்பாடு வேலை. உண்மையான அடுக்குக்கு, நாம் பயன்படுத்த வேண்டும் என். எஸ்() செயல்பாடு
முடிவுரை
இந்த கட்டுரையில், இதைப் பயன்படுத்துவதை நாங்கள் பார்த்தோம் என். எஸ்() செயல்பாடு மற்றும் பிட் ஷிஃப்டிங் ஆபரேட்டர் எப்படி C மொழியில் அடுக்கு கணக்கிட முடியும். அடுக்குகளை கணக்கிட எங்கள் சொந்த செயல்பாட்டை எவ்வாறு எழுதுவது என்பதையும் நாங்கள் கற்றுக்கொண்டோம். இப்போது இந்த நுட்பங்களை நாம் எந்த சந்தேகமும் இல்லாமல் எங்கள் சி திட்டத்தில் பயன்படுத்தலாம்.