கணித வகுப்பு

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()முறைகளைப் பயன்படுத்துவது சரியானது.