உண்மையான எண்களுடன் பணிபுரியும் நுணுக்கங்கள்

1. உண்மையான எண்களை வட்டமிடுதல்

நாம் ஏற்கனவே விவாதித்தபடி, ஒரு மாறிக்கு ஒரு உண்மையான எண் ஒதுக்கப்படும்போது int, ​​​​அது எப்போதும் அருகிலுள்ள சிறிய முழு எண்ணாக வட்டமிடப்படும் - பகுதியளவு பகுதி வெறுமனே நிராகரிக்கப்படுகிறது.

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

இதற்கும் இதே போன்ற பல சூழ்நிலைகளுக்கும், ஜாவா கிளாஸைக் கொண்டுள்ளது Math, அதில் round(), ceil(), மற்றும் floor()முறைகள் உள்ளன.

Math.round()முறை

இந்த Math.round()முறை ஒரு எண்ணை அருகிலுள்ள முழு எண்ணுக்குச் சுற்றுகிறது:

long x = Math.round(real_number)

ஆனால் இங்கே மற்றொரு நுணுக்கம் உள்ளது: இந்த முறை ஒரு longமுழு எண்ணை வழங்குகிறது (ஒரு அல்ல int). உண்மையான எண்கள் மிகப் பெரியதாக இருக்கும் என்பதால், ஜாவாவின் படைப்பாளிகள் ஜாவாவின் மிகப்பெரிய முழு எண் வகையைப் பயன்படுத்த முடிவு செய்தனர்: long.

அதன்படி, ஒரு புரோகிராமர் முடிவை ஒரு மாறிக்கு ஒதுக்க விரும்பினால் int, அவர் சாத்தியமான தரவு இழப்பை ஏற்றுக்கொள்கிறார் என்று தொகுப்பாளரிடம் வெளிப்படையாகக் குறிப்பிட வேண்டும் (அதன் விளைவாக வரும் எண் ஒரு வகைக்கு பொருந்தவில்லை என்றால் int).

int x = (int) Math.round(real_number)

எடுத்துக்காட்டுகள்:

int x = (int) Math.round(4.1);

4

int x = (int) Math.round(4.5);

5

int x = (int) Math.round(4.9);

5

Math.ceil()முறை

இந்த Math.ceil()முறை ஒரு எண்ணை முழு எண்ணாகச் சுற்றுகிறது. இங்கே உதாரணங்கள்:

int x = (int) Math.ceil(4.1);

5

int x = (int) Math.ceil(4.5);

5

int x = (int) Math.ceil(4.9);

5

Math.floor()முறை

இந்த Math.floor()முறை ஒரு எண்ணை முழு எண்ணாகச் சுற்றுகிறது. இங்கே உதாரணங்கள்:

int x = (int) Math.floor(4.1);

4

int x = (int) Math.floor(4.5);

4

int x = (int) Math.floor(4.9);

4

நிச்சயமாக, ஒரு எண்ணை முழு எண்ணாகக் குறைக்கும்போது , ​​ஒரு வகை காஸ்ட் ஆபரேட்டரைப் பயன்படுத்துவது எளிது:(int)

int x = (int) 4.9

4

இந்த பெயர்களை நினைவில் கொள்வது உங்களுக்கு கடினமாக இருந்தால், ஒரு சிறிய ஆங்கில பாடம் உதவும்:

• Mathகணிதம் என்று பொருள்
• Roundசுற்று என்று பொருள்
• Ceilingஉச்சவரம்பு என்று பொருள்
• Floorதரை என்று பொருள்

2. மிதக்கும் புள்ளி எண்கள் எவ்வாறு கட்டமைக்கப்படுகின்றன

வகை முதல் வரையிலான doubleவரம்பில் மதிப்புகளைச் சேமிக்க முடியும் . இந்த பெரிய அளவிலான மதிப்புகள் (வகையுடன் ஒப்பிடும்போது ) முழு எண் வகைகளை விட வகை (அத்துடன் ) முற்றிலும் மாறுபட்ட உள் அமைப்பைக் கொண்டிருப்பதன் மூலம் விளக்கப்படுகிறது . உள்நாட்டில், வகை அதன் மதிப்பை இரண்டு எண்களாக குறியாக்குகிறது: முதலாவது மன்டிசா என்றும், இரண்டாவது அடுக்கு என்றும் அழைக்கப்படுகிறது .-1.7*10308+1.7*10308intdoublefloatdouble

எங்களிடம் எண் இருப்பதாக வைத்துக்கொள்வோம் 123456789, அதை ஒரு மாறி சேமிக்கிறோம் double. நாம் செய்யும் போது, ​​எண் க்கு மாற்றப்படுகிறது , மேலும் உள்நாட்டில் வகை இரண்டு எண்களை சேமிக்கிறது - மற்றும் . முக்கியத்துவம் வாய்ந்தது ("எண்ணின் குறிப்பிடத்தக்க பகுதி" அல்லது மன்டிசா) சிவப்பு நிறத்தில் சிறப்பிக்கப்படுகிறது, அதே சமயம் அடுக்கு நீல நிறத்தில் சிறப்பிக்கப்படுகிறது.1.23456789*108double234567898

இந்த அணுகுமுறை மிகப் பெரிய எண்கள் மற்றும் மிகச் சிறிய எண்கள் இரண்டையும் சேமிப்பதை சாத்தியமாக்குகிறது. ஆனால் எண்ணின் பிரதிநிதித்துவம் 8 பைட்டுகளுக்கு (64 பிட்கள்) மட்டுப்படுத்தப்பட்டிருப்பதாலும், சில பிட்கள் அதிவேகத்தை (அத்துடன் மன்டிசாவின் அடையாளம் மற்றும் அதிவேகத்தின் அடையாளம்) சேமிக்கப் பயன்படுத்தப்படுவதாலும் , மாண்டிசாவைக் குறிக்க அதிகபட்ச இலக்கங்கள் உள்ளன. 15 ஆகும் .

உண்மையான எண்கள் எவ்வாறு கட்டமைக்கப்படுகின்றன என்பதற்கான மிகவும் எளிமையான விளக்கமாகும்.

3. உண்மையான எண்களுடன் பணிபுரியும் போது துல்லியம் இழப்பு

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

இந்த கடைசி உண்மை புதிய புரோகிராமர்களுக்கு கொஞ்சம் மனதைக் கவரும்.

இலிருந்து கழித்தால் கிடைக்கும் .1/109109109

 1000000000.000000000;
-         0.000000001;
 1000000000.000000000;

நாம் என்ன சொல்ல முடியும், நிரலாக்கமானது கணிதம் போன்றது அல்ல.

4. நிஜ எண்களை ஒப்பிடும் போது பிட்ஃபால்

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

உதாரணமாக:

double a = 1000000000.0;
double b = 0.000000001;
double c = a - b;

மேலே உள்ள எடுத்துக்காட்டில், சமமாக aஇருக்கக்கூடாது c, ஆனால் அவை.

அல்லது மற்றொரு உதாரணத்தை எடுத்துக் கொள்வோம்:

double a = 1.00000000000000001;
double b = 1.00000000000000002;

5. பற்றி ஒரு சுவாரஸ்யமான உண்மைstrictfp

ஜாவாவில் ஒரு சிறப்புத் strictfpதிறவுச்சொல் உள்ளது ( ஸ்டிரிக்ட் ஃபிலோட்டிங் பி களிம்பு ) , இது மற்ற நிரலாக்க மொழிகளில் இல்லை. உங்களுக்கு ஏன் இது தேவை என்று தெரியுமா? மிதக்கும் புள்ளி எண்கள் கொண்ட செயல்பாடுகளின் துல்லியத்தை இது மோசமாக்குகிறது . அது எப்படி உருவானது என்பதற்கான கதை இதோ: