ஜாவாவில் Math.pow() முறையைப் பயன்படுத்துதல்

ஜாவா மொழியானது கணித செயல்பாடுகள் மற்றும் செயல்பாடுகளுக்கான விரிவான நூலகத்துடன் பொருத்தப்பட்டுள்ளது. இது "கணிதம்" வகுப்பு என்று அழைக்கப்படுகிறது, மேலும் இது java.lang தொகுப்பில் உள்ளது. கணித நூலகத்தில் அடிப்படை எண் செயல்பாடுகள், முக்கோணவியல், குறைந்தபட்ச-அதிகபட்சத்தைக் கண்டறிதல், சீரற்ற எண்களை உருவாக்குதல் மற்றும் மடக்கைச் செயல்பாடுகள் போன்ற முறைகள் உள்ளன. இன்றைய டுடோரியலில், அடிப்படை மற்றும் அடுக்குகளைப் பயன்படுத்தி எண்களின் சக்திகளைக் கணக்கிடப் பயன்படும் Math.pow() முறையில் கவனம் செலுத்துவோம் . ஆரம்பிக்கலாம். ^{'nth power of a' என்பதை கணித ரீதியாக n} என எழுதலாம். வெளிப்பாடுகளில் உள்ள விதிமுறைகளை பின்வருமாறு வரையறுக்கலாம். a - base n - exponent அடுக்குகளை கருத்தில் கொள்வோம். ஒரு பெருக்கல் செயல்பாடு எத்தனை முறை மீண்டும் மீண்டும் செய்யப்படுகிறது என்பதை நாம் அடையாளம் காணலாம். அடிப்படை என்பது தன்னால் பெருக்கப்படும் எண்ணாகும். இப்போது ஒரு எண்ணின் சக்தியைக் கணக்கிட எளிய ஜாவா முறையை உருவாக்குவோம். பின்வரும் எடுத்துக்காட்டில், நாம் powerFunction() முறையில் இரண்டு வாதங்களை அனுப்புகிறோம் , அவை முறையே அடிப்படை மற்றும் அடுக்கு ஆகும்.

public class Main {
 
   public static void main(String[] args) {
       int result = powerFunction(2, 5);
       System.out.println("2 raised to the power of 5 = " + result);
   }
 
   static int powerFunction(int base, int exponent) {
       int result = 1;
       for (int i = 0; i < exponent; i++) {
           result = base * result;
       }
       return result;
   }
}

மேலே உள்ள உதாரணக் குறியீட்டை இயக்கினால், அது 32ஐத் தரும். நாம் ஏன் அடிப்படை^எக்ஸ்போனென்ட் என்று எழுத முடியாது என்று நீங்கள் கற்பனை செய்து கொண்டிருக்கலாம். ஜாவாவில் எக்ஸ்போனென்சியேஷன் ஆபரேட்டர் இல்லாததால் அதைச் செய்ய முடியாது, அதை ஒற்றை வரி குறியீட்டில் பயன்படுத்தலாம். மேலே உள்ள குறியீட்டைக் கருத்தில் கொண்டு, இந்த முறையை எழுதுவதற்கு நாம் சிறிது நேரம் செலவிட வேண்டியிருந்தது என்பது தெளிவாகிறது. மேலும், நாம் அதிக சக்திகளைக் கணக்கிடப் போகிறோம் என்றால், நாம் லூப்களுக்குப் பயன்படுத்துவதால், இந்த கணக்கீடுகளை முடிக்க முறை கணிசமான அளவு நேரத்தை எடுக்கும். அதுமட்டுமின்றி, பின்னம் அடுக்குகளுடன் சக்தி கணக்கீடுகளைச் செய்வதிலிருந்து சுழல்கள் நம்மைத் தடுக்கும். இந்த முறைக்கு நல்ல கணக்கீட்டு சிக்கலானது இல்லை, ஏனெனில் தேர்வுமுறைக்கு அதிக இடம் இருப்பதால் மிகவும் சாதகமானதாக இல்லை. புரோகிராமர்களால் அடிக்கடி விரிவுபடுத்தல் மற்றும் பிற கணித செயல்பாடுகள் எவ்வாறு பயன்படுத்தப்படுகின்றன என்பதைக் கருத்தில் கொண்டு, அந்த நாளில் ஜாவாவின் டெவலப்பர்கள் கணித செயல்பாடுகளை எளிதாக்குவதற்கு அர்ப்பணிக்கப்பட்ட 'கணிதம்' என்ற நூலகத்தை உருவாக்கினர். எனவே, புதிதாக ஒரு பவர் செயல்பாட்டை எழுதுவதற்குப் பதிலாக, ஜாவா லாங் தொகுப்பில் சேர்க்கப்பட்டுள்ள இந்த நூலகத்தைப் பயன்படுத்திக் கொள்ளலாம்.

Math.pow முறை என்றால் என்ன, அதை எவ்வாறு பயன்படுத்துவது?

கணித நூலகத்தின் ஒரு முறையாக Math.pow ஐ java.lang தொகுப்பில் காணலாம். இது எண்களின் சக்தியைக் கணக்கிடப் பயன்படுகிறது, முழு எண்கள் மற்றும் இரட்டையர்கள். அதன் தொடரியலைக் கருத்தில் கொள்வோம்.

public static double pow(double base, double exponent)

நாம் தொடரியல் பார்க்க முடியும், java.lang.Math.pow() முறை இரண்டு வாதங்களை எடுக்கும். முதல் ஒன்று அடிப்படை மற்றும் இரண்டாவது அடுக்கு ஆகும். ^{இது அடிப்படை அடுக்குகளை} அதன் வெளியீடாக வழங்கும் . அதை எப்படி அழைப்பது என்று பார்ப்போம்.

Math.pow ஐப் பயன்படுத்தி ஜாவாவில் ஒரு எண்ணை ஒரு சக்தியாக உயர்த்துதல்

Math.pow ஐப் பயன்படுத்தி 5 ⁴ இன் மதிப்பைக் கண்டுபிடிப்போம் .

import java.lang.Math;
public class MyClass{
    public static void main(String []args){
       double answer = Math.pow(5, 4);
// java.lang.Math.pow() method
 
       System.out.println("5 raised to the power of 4 = " + answer);
    }    
}

வெளியீடு 625.0. நீங்கள் பார்க்க முடியும் என, இது இரட்டை மதிப்பு. நீங்கள் தசம புள்ளியால் தொந்தரவு செய்தால், பின்வரும் எண்ணை ஒரு முழு எண்ணில் வைப்பதன் மூலம் நாம் எளிதாக அதிலிருந்து விடுபடலாம். முக்கிய முறையின் உள்ளே முதல் வரியை மாற்றுகிறோம் என்பதை நினைவில் கொள்க.

 int answer = (int) Math.pow(5, 4);

இப்போது முடிவு 625. அடிப்படை மற்றும் அடுக்கு இரண்டிற்கும் பின்ன எண்களைப் பயன்படுத்தி விடை பெற முயற்சிப்போம். ^{1.25 4.5} இன் மதிப்பு என்ன என்று பார்ப்போம் .

import java.lang.Math;
 
public class MyClass {
 
   public static void main(String[] args) {
       double answer = Math.pow(1.25, 4.5);
// java.lang.Math.pow() method
 
       System.out.println("1.25 raised to the power of 4.5 = " + answer);
   }
}

இது 2.729575167846423 ஐ வெளியிடும். நீங்கள் கால்குலேட்டரைப் பயன்படுத்தினால், அது அதே பதிலைத் தருவதைக் காண்பீர்கள். அடுத்த பகுதிக்குச் செல்வதற்கு முன் இன்னும் ஒரு உதாரணத்தைப் பார்ப்போம். எண்ணை எதிர்மறை சக்தியாக உயர்த்தி முடிவுகளை ஒப்பிடுவோம். இந்த எடுத்துக்காட்டில், 4 ஐ அடிப்படையாகவும் -2 ஐ அடுக்குகளாகவும் எடுப்போம்.

import java.lang.Math;
 
public class MyClass{
 
     public static void main(String []args){
        double answer = Math.pow(4, -2);
// java.lang.Math.pow() method
 
        System.out.println(answer);
     }    
}

0.0625 வெளியீட்டைப் பெறுகிறோம்.

விரைவு உதாரணம்: உங்கள் பதிலை எவ்வாறு வட்டமிடுவது

^{சொல்லுங்கள், நாம் 1.25 4.5} இன் மதிப்பைக் கண்டுபிடிக்க வேண்டும் . பதில் 2.729575167846423. பெரும்பாலும் முடிவைச் சுற்றி வருவது அவசியம். நான்காவது தசம இடத்திற்கு துல்லியமான பதிலைப் பெற முயற்சிப்போம். அதை எப்படி செய்வது? நமக்கு முதல் 4 தசம இடங்கள் மட்டுமே தேவைப்பட்டால் என்ன செய்வது? அதற்கு java.lang.Math.round முறையைப் பயன்படுத்தலாம் . இருப்பினும், Math.round மதிப்பை அருகிலுள்ள முழு எண்ணுக்குச் சுற்றி வருவதால், நாம் அதை தசம இடங்களின் எண்ணிக்கையால் பெருக்க வேண்டும், பின்னர் வட்டமிட்டு மீண்டும் வகுக்க வேண்டும்.

import java.lang.Math;
 
public class MyClass{
 
     public static void main(String []args){
        double answer = Math.pow(1.25, 4.5);
        answer = Math.round(answer*100.0)/100.0;
        
        System.out.println(answer);
     }
     
}

வெளியீடு 2.73.

Math.pow ஐ சரியாக பயன்படுத்துவது எப்படி

நாம் java.lang.Math.pow முறையைப் பயன்படுத்தும்போது , ​​​​சில விஷயங்களை மனதில் கொள்ள வேண்டும்.

1. அடுக்கு அளவுரு பூஜ்ஜியமாக இருந்தால், வெளியீடு 1.0 ஆக இருக்கும். ஏனென்றால், எந்த எண்ணுக்கும் பூஜ்ஜியத்தின் சக்தி ஒன்று என வரையறுக்கப்படுகிறது.
2. அடுக்கு அளவுரு ஒன்று என்றால், வெளியீடு அடிப்படை அளவுருவாக இருக்கும். ஏனென்றால், நீங்கள் எந்த எண்ணையும் 1-ன் சக்திக்கு உயர்த்தினால், அதன் முடிவு அடித்தளத்தைப் போலவே இருக்கும்.
3. அடிப்படை எதிர்மறை/நேர்மறை பூஜ்ஜியமாகவும், அடுக்கு அளவுரு எதிர்மறை எண்ணாகவும் இருந்தால், முடிவு முடிவிலி. (எதிர்மறை பூஜ்ஜியங்கள் பூஜ்ஜியத்திற்கும் சிறிய பிரதிநிதித்துவம் செய்யக்கூடிய எதிர்மறை பூஜ்ஜியமற்ற எண்ணுக்கும் இடையில் உள்ள எண்களின் ரவுண்டிங் காரணமாக ஏற்படலாம்).
4. அடுக்கு அளவுரு NaN எனில், வெளியீடு NaN ஆகவும் இருக்கும்.

இந்த 3 வது சூழ்நிலை ஏற்படக்கூடிய ஒரு நிகழ்வைக் கருத்தில் கொள்வோம்.

import java.lang.Math;
 
public class MyClass{
 
     public static void main(String []args){         
        double base = 5;
        double exponent = Double.NaN;
 
        double answer = Math.pow(base, exponent);
 
        System.out.println(answer);
     }     
}

இது NaN ஐ வெளியிடும். எனவே, உங்கள் குறியீடு NaN இல் விளைந்தால், அடுக்கு வாதம் NaN ஆக உள்ளதா என்பதைச் சரிபார்ப்பது நல்லது. NaN என்றால் என்ன என்று நீங்கள் யோசித்தால், அது 'எண் அல்ல' என்று பொருள்படும் மற்றும் மதிப்பு வரையறுக்கப்படவில்லை என்பதைக் குறிக்கிறது. உங்கள் பயன்பாடுகளில் பயன்படுத்த, lang.Math.pow() ஐப் பயன்படுத்த நீங்கள் இப்போது தயாராகிவிட்டீர்கள் என்று நாங்கள் நம்புகிறோம் .

முடிவுரை

java.lang.Math.pow () முறையானது முழு எண்கள் மற்றும் பின்ன மதிப்புகள் ஆகிய இரண்டு எண்களின் சக்தியையும் எளிதாகக் கண்டறிய சிறந்த வழியாகும். நீங்களே எழுதக்கூடிய ஒரு முறையைப் போலன்றி, இது மிகவும் உகந்ததாக உள்ளது மற்றும் நேர-முக்கியமான பயன்பாடுகளின் வரம்பிற்கு மிகவும் பொருத்தமானது. இது எல்லா முடிவுகளையும் இரட்டிப்பாக வெளியிடுகிறது என்றாலும், எடுத்துக்காட்டில் செய்ததைப் போல மதிப்பை எப்போதும் முழு எண்ணாக மாற்றலாம். மேலும், எங்கள் வசதிக்காக, java.lang.Math நூலகம் முடிவை விருப்பமான தசம இடங்களுக்குச் சுற்றும் முறைகளை வழங்குகிறது.