వాస్తవ సంఖ్యలతో పని చేసే సూక్ష్మ నైపుణ్యాలు

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వేరియబుల్‌గా నిల్వ చేయండి. మనం చేసినప్పుడు, ఆ సంఖ్య కు మార్చబడుతుంది మరియు అంతర్గతంగా రకం రెండు సంఖ్యలను నిల్వ చేస్తుంది — మరియు . Significand ("సంఖ్యలో ముఖ్యమైన భాగం" లేదా mantissa) ఎరుపు రంగులో హైలైట్ చేయబడింది, అయితే ఘాతాంకం నీలం రంగులో హైలైట్ చేయబడింది.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కీవర్డ్ ఉంది ( స్ట్రిక్ట్ ఫ్ లోటింగ్ పి ఆయింట్ ), ఇది ఇతర ప్రోగ్రామింగ్ భాషలలో కనిపించదు. మరియు మీకు ఇది ఎందుకు అవసరమో మీకు తెలుసా? ఇది ఫ్లోటింగ్ పాయింట్ సంఖ్యలతో కార్యకలాపాల యొక్క ఖచ్చితత్వాన్ని మరింత దిగజార్చుతుంది . ఇది ఎలా జరిగిందనే దాని కథ ఇక్కడ ఉంది: