గణిత తరగతి

1. జావాలో త్రికోణమితి విధులు

Mathమేము ఇంతకు ముందు రౌండింగ్ సంఖ్యలను అధ్యయనం చేసినప్పుడు, మేము తరగతి మరియు దానిలోని కొన్ని పద్ధతులతో పరిచయం పొందాము . మేము ఇప్పుడు ఈ తరగతిని మరింత వివరంగా పరిశీలిస్తాము.

పేరు సూచించినట్లుగా, Mathక్లాస్ ప్రోగ్రామర్లు ఎక్కువగా ఉపయోగించే గణిత కార్యకలాపాలకు సంబంధించిన పద్ధతులను కలిగి ఉంటుంది. ఇక్కడ అత్యంత ఆసక్తికరమైనవి ఉన్నాయి:

double sin(double d)

double cos(double d)

double tan(double d)

double asin(double d)

double acos(double d)

double atan(double d)

double sinh(double d)

double cosh(double d)

double tanh(double d)

, మరియు పద్ధతులు రేడియన్లలో వ్యక్తీకరించబడిన కోణాన్ని తీసుకుంటాయి. కోణాన్ని డిగ్రీల నుండి రేడియన్‌లకు మార్చడానికి మరియు దీనికి విరుద్ధంగా, తరగతి రెండు ప్రత్యేక పద్ధతులను అందిస్తుంది:Math.sin()Math.cos()Math.tan()Math

double toRadians(double angdeg)

double toDegrees(double angrad)

మార్గం ద్వారా, పద్ధతులతో పాటు, తరగతికి రెండు స్థిరమైన వేరియబుల్స్Math కూడా ఉన్నాయి (తరగతి యొక్క స్టాటిక్ ఫీల్డ్‌లు):

double Math.PI

double Math.E

మీరు మీ స్వంత గేమ్‌లను వ్రాయాలని, గ్రాఫిక్‌లతో పని చేయాలని లేదా మ్యాప్‌లో మార్గం యొక్క పొడవును లెక్కించాలని నిర్ణయించుకుంటే ఈ అన్ని విధులు మీకు చాలా ఉపయోగకరంగా ఉంటాయి.

ఉదాహరణకు, మీరు గణించాలనుకుంటే sin(45°), దీన్ని ఎలా చేయాలో ఇక్కడ ఉంది:

Math.sin( Math.toRadians(45) )

ఇక్కడ ఒక ఉదాహరణ:

public class Main
{
   public static int N = 10;

   public static void drawValue(double y)
   {
     int value = (int) (y * N) + N;
     for (int i = 0; i < 2 * N; i++)
     {
       char c = i == N ? '|': '.';
       if (i == value)
         c = '*';
       System.out.print(c);
     }
     System.out.println();
   }

   public static void main(String[] args)
   {
     for (int i = 0; i < 10 * N; i++)
     {
       double x = i * 1.0 / N;
       double y = Math.sin(x);
       drawValue(y);
     }
   }
}

2. జావాలో బీజగణిత విధులు

చాలా సందర్భాలలో, ప్రోగ్రామర్‌కు హైస్కూల్ గణితం సరిపోతుంది: సైన్స్ మరియు కొసైన్‌లు కూడా కోడ్‌లో చాలా అరుదుగా కనిపిస్తాయి. ఆటలు, మ్యాప్‌లు లేదా గేమ్ ఇంజిన్‌లతో పనిచేసేటప్పుడు చాలా తరచుగా అవి అవసరమవుతాయి. 90% మంది ప్రోగ్రామర్లు దీనిని ఎప్పుడూ ఎదుర్కోరు.

కానీ జ్యామితితో పాటు, ప్రోగ్రామర్లు కొన్నిసార్లు బీజగణిత విధులను ఉపయోగించాల్సి ఉంటుంది. మరియు, వాస్తవానికి, Mathతరగతి అత్యంత సాధారణమైన వాటిని కలిగి ఉంటుంది:

double sqrt(double a)

double cbrt(double a)

double pow(double a, double b)

double exp(double a)

double log(double a)

double log10(double a)

double log1p(double x)

double expm1(double x)

మీకు సంఖ్య యొక్క స్క్వేర్ లేదా క్యూబ్ రూట్ కావాలంటే, sqrt(a)మరియు cbrt(a)పద్ధతులు మీ సేవలో ఉన్నాయి.

వర్గమూలాన్ని ఈ క్రింది విధంగా లెక్కించవచ్చు:

Math.sqrt(2)

మీరు అధిక శక్తి యొక్క మూలాన్ని పొందాలనుకుంటే, ఎక్స్‌పోనెన్షియేషన్ పద్ధతిని ఉపయోగించండి: aశక్తికి ¼నాల్గవ మూలం మొదలైనవి.

Math.pow(2, 0.25)

log(a)సంవర్గమానాలు మరియు ఘాతాంకాలకు, (సహజ సంవర్గమానం) మరియు exp(x)(ఘాతాంక) పద్ధతులు ఉన్నాయి . బేస్-10 సంవర్గమానాన్ని లెక్కించడానికి, మనకు log10(a).

మీరు సంఖ్య యొక్క సంవర్గమానాన్ని bఆధారం చేయాలనుకుంటే a, ఈ సాధారణ సూత్రాన్ని ఉపయోగించండి:loga(b) = ln(b) / ln(a)

ఉపయోగకరమైన పద్ధతులు

మీరు చాలా చిన్న విలువలతో కూడిన గణనలను నిర్వహిస్తుంటే x, చివరి రెండు విధులు — log1p()మరియు expm1()— మీకు ఉపయోగకరంగా ఉండవచ్చు.

చాలా చిన్న మరియు చాలా పెద్ద వేరియబుల్స్‌ని జోడించేటప్పుడు double, చాలా చిన్న విలువలు చాలా తక్కువగా ఉన్నవిగా విస్మరించబడి (విస్మరించబడ్డాయి) మీరు తరచుగా కనుగొంటారు. వాస్తవానికి, మీరు log()మరియు exp()పద్ధతులను ఉపయోగిస్తే ఇది జరుగుతుంది. దీనిని పరిష్కరించడానికి, ప్రోగ్రామర్లు "చిన్న ముఖ్యమైన భాగాన్ని" మాత్రమే తిరిగి ఇచ్చే ఫంక్షన్‌లతో ముందుకు వచ్చారు.

ఉదాహరణ:

మీరు సహజ సంవర్గమానాన్ని గణించాలనుకుంటున్నారని అనుకుందాం 1 + x, ఎక్కడ xఉంది . మీరు ఈ సంఖ్యను పద్ధతికి పంపలేరు , ఎందుకంటే మీరు జోడించినట్లయితే మరియు , మీరు పొందుతారు . సంఖ్యలను జోడించినప్పుడు అది పూర్తిగా విస్మరించబడేంత చిన్న సంఖ్య.10-20log()110-20110-20

గణితంలో తరచుగా log()సంఖ్యల సంఖ్యను గణించడం జరుగుతుంది కాబట్టి 1, ప్రోగ్రామర్లు ఈ సమస్యను అధిగమించడానికి ఒక మార్గాన్ని కనుగొన్నారు: సంఖ్యను పద్ధతికి పంపే బదులు, నుండి దాని తేడాను మాత్రమే పాస్ చేయండి 1.

3. కనిష్ట మరియు గరిష్ట

మరో రెండు ఉపయోగకరమైన విధులు min(a, b)మరియు max(a, b). మీరు బహుశా ఇప్పటికే ఊహించినట్లుగా, మొదటిది కనీసం రెండు సంఖ్యలను అందిస్తుంది:

Math.min(a, b)

మరియు రెండవది గరిష్టంగా రెండు సంఖ్యలను అందిస్తుంది:

Math.max(a, b)

ifమీరు ఎల్లప్పుడూ టెర్నరీ ఆపరేటర్‌ని వ్రాయవచ్చు లేదా ఉపయోగించగలిగినప్పుడు మాకు ఈ ఫంక్షన్‌లు ఎందుకు అవసరం (a < b ? a: b)?

ఇదంతా కోడ్ యొక్క రీడబిలిటీ గురించి. కొన్నిసార్లు మీ కోడ్ స్టేట్‌మెంట్‌లతో ఓవర్‌లోడ్ చేయబడుతుంది ifమరియు మీరు మరింత కాంపాక్ట్ సంజ్ఞామానాన్ని ఉపయోగించాలనుకుంటున్నారు. పోల్చి చూద్దాం:

int x = 0;
if (x-5+y*20 < x*x+y*y)
   x = x-5+y*20;
else
   x = x*x+y*y;

int x = x-5+y*20 < x*x+y*y ? x-5+y*20 : x*x+y*y;

int a = x-5+y*20;
int b = x*x+y*y;
int x = a < b ? a : b;

int x = Math.min(x-5+y*20, x*x+y*y);

4. కనిష్ట మరియు గరిష్ట అనేక సంఖ్యలు

min()మరియు పద్ధతులను ఉపయోగించడానికి మరొక గొప్ప మార్గం ఉంది max().

అనేక సంఖ్యలు లేదా వేరియబుల్స్ యొక్క కనిష్ట (లేదా గరిష్ట) లెక్కించేందుకు. ఈ పద్ధతులకు నెస్టెడ్ కాల్స్ చేయడం చాలా సౌకర్యవంతంగా ఉంటుంది.

కనిష్ట 3 సంఖ్యలను ఎలా కనుగొనాలో ఇక్కడ ఉంది:

Math.min(a, Math.min(b, c))

అయితే ఏంటి? ఇది చాలా సౌకర్యవంతంగా ఉంటుంది: కనీసం రెండు సంఖ్యలను లెక్కించండి, ఆపై ఈ సంఖ్య యొక్క కనిష్టాన్ని మరియు మూడవ సంఖ్యను తిరిగి ఇవ్వండి.

కనిష్టంగా నాలుగు సంఖ్యలు ఒకే విధంగా పొందబడతాయి:

Math.min(a, Math.min(b, Math.min(с, d)))

మేము ఈ సూత్రాన్ని కొంచెం స్పష్టంగా వ్రాయగలము:

Math.min(Math.min(a, b), Math.min(c, d))

ఇది అన్ని పద్ధతి కోసం అదే పని చేస్తుంది max().

if-elseఆపరేటర్ లేదా టెర్నరీ ఆపరేటర్‌ని ఉపయోగించడం వలన ఈ కోడ్ స్నిప్పెట్‌లు కొంచెం గజిబిజిగా ఉంటాయి. కానీ min()మరియు max()పద్ధతులను ఉపయోగించడం కేవలం ఖచ్చితమైనది.