జావాలో Math.pow() పద్ధతిని ఉపయోగించడం

జావా భాష గణిత విధులు మరియు కార్యకలాపాల కోసం సమగ్ర లైబ్రరీతో అమర్చబడింది. దీనిని "గణిత" తరగతి అని పిలుస్తారు మరియు ఇది java.lang ప్యాకేజీలో నివసిస్తుంది. గణిత లైబ్రరీ ప్రాథమిక సంఖ్యా కార్యకలాపాలు, త్రికోణమితి, కనిష్ట-గరిష్టాన్ని కనుగొనడం, యాదృచ్ఛిక సంఖ్యలను ఉత్పత్తి చేయడం మరియు లాగరిథమిక్ కార్యకలాపాల కోసం పద్ధతులను కలిగి ఉంటుంది. నేటి ట్యుటోరియల్‌లో, మేము Math.pow() పద్ధతిపై దృష్టి పెడతాము, ఇది బేస్ మరియు ఘాతాంకాన్ని ఉపయోగించి సంఖ్యల శక్తులను లెక్కించడానికి ఉపయోగించబడుతుంది. ప్రారంభిద్దాం. ^{'a యొక్క nth పవర్' అనే వ్యక్తీకరణను గణితశాస్త్రంలో n} గా వ్రాయవచ్చు. మేము వ్యక్తీకరణలలోని నిబంధనలను ఈ క్రింది విధంగా నిర్వచించవచ్చు. a - బేస్ n - ఘాతాంకం ఘాతాంకాన్ని పరిశీలిద్దాం. గుణకారం ఆపరేషన్ ఎన్నిసార్లు పునరావృతం చేయబడుతుందో మనం దానిని గుర్తించగలము. ఆధారం అనేది దాని ద్వారా గుణించబడే సంఖ్య. సంఖ్య యొక్క శక్తిని లెక్కించడానికి ఇప్పుడు మనం ఒక సాధారణ జావా పద్ధతిని సృష్టిద్దాం. దయచేసి ఈ క్రింది ఉదాహరణలో, మేము పవర్‌ఫంక్షన్() పద్ధతిలో రెండు ఆర్గ్యుమెంట్‌లను పంపుతున్నామని , అవి వరుసగా బేస్ మరియు ఎక్స్‌పోనెంట్ అని గమనించండి.

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 లైబ్రరీ ఫలితాన్ని దశాంశ స్థానాలకు ప్రాధాన్యతనిచ్చే సంఖ్యకు రౌండ్ చేయడానికి పద్ధతులను అందిస్తుంది.