BigInteger ۽ BigDecimal

جاوا ۾، هڪ ايپليڪيشن طبقن مان ٺهيل آهي، ۽ ڪلاس طريقن ۽ متغيرن مان ٺهيل آهن. متغير، موڙ ۾، ورهايل آهن پرائمري ۽ حوالن ۾. جاوا ۾ 8 قسم جا متغير آهن ۽، boolean۽، کي ڇڏي char، انهن کي هيٺين قسمن ۾ ورهايو ويو آهي:

• انگ اکر: byte, short, intand long;
• سچل پوائنٽ (جنهن کي حقيقي نمبر پڻ سڏيو ويندو آهي): float۽ double.

انهن ننڍڙن گروهن جي اندر، فرق صرف انهن قدرن جي حدن ۾ موجود آهي، جن کي شامل ڪري سگهجي ٿو (۽، مطابق، اهڙي قسم جي متغير جي قبضي واري جاءِ مختلف ٿي سگهي ٿي). انٽيجر جو سڀ کان وڏو قسم آهي long، جنهن جي حد -9223372036854775808 کان 9223372036854775807 تائين آهي. سچل پوائنٽ نمبرن مان، double1.7e-308 کان 1.7e+308 جي حد سان. توھان ھن مضمون ۾ حقيقي انگن بابت وڌيڪ پڙھي سگھو ٿا . پر ڇا جيڪڏهن اسان کي انهن نمبرن کي ذخيرو ڪرڻ جي ضرورت آهي جيڪي قابل قبول حد کان وڏا آهن؟ انهي حالت ۾، اسان کي ضرورت پوندي BigInteger۽ BigDecimal.

جاوا ۾ BigInteger

جاوا ڪلاس BigIntegerهڪ اينالاگ طور استعمال ڪيو ويندو آهي ثالث-ڊگھائي انٽيگر ويلز لاءِ جنهن ۾ 64-bit ڊگھي حد نه هوندي آهي. ان کان علاوه، اهو طبقي جو اولاد آهي Number، جهڙوڪ عددي سادي قسمن لاء معياري لفافن - Integer, Long, Byte, Double, وغيره - تنهن ڪري ان ۾ طريقن جي عمل درآمد ڪئي وئي آهي جيڪي سادي قسمن ڏانهن ويندا آهن:

BigInteger value = new BigInteger("32145");

int intValue = value.intValue();//32145

long longValue = value.longValue();//32145

double doubleValue = value.doubleValue();//32145.0

فوري طور تي اسان هڪ اهڙي شئي جي تخليق کي ڏسون ٿا جيڪو BigIntegerاسان جي قيمت سان تعمير ڪندڙ ڏانهن منتقل ڪيو وڃي ٿو، پر اسٽرنگ فارميٽ ۾. اهو قابل ذڪر آهي ته هن وٽ هڪ کان وڌيڪ ڊزائنر آهن، پر سڀني موقعن لاء. جيڪڏهن پرائمري قسمون ڊيٽا جي مڪمل مقدار کي گڏ نه ڪن BigInteger، ڊيٽا کي ان ابتدائي قسم جي حد تائين ڪٽيو ويندو. پر ساڳئي وقت، انهن طريقن جا اينالاگ آهن ( intValueExact()، longValueExact()وغيره)، فرق صرف اهو آهي ته جيڪڏهن سادو قسم جنهن ۾ تبديلي ٿي رهي آهي ڊيٽا جي حد کي ترتيب نه ڏئي، هڪ ArithmeticException اڇلايو ويندو آهي .

BigInteger Constants

اندروني استعمال لاء، ڪلاس ۾ مستقل آهن:

BigInteger.ZERO
BigInteger.ONE
BigInteger.TEN

اهي مسلسل شيون آهن BigIntegerقدر سان، ترتيب سان 0، 1۽ 10.

BigInteger طريقا

هن طبقي جي مکيه خاصيتن مان هڪ آهي ته اهو طريقن سان ڀريل آهي جيڪي جاوا ۾ معياري رياضياتي عملن کي لاڳو ڪن ٿا. مثال طور:

• مجموعي آپريشن:

  BigInteger firstValue = new BigInteger("37995");
  BigInteger secondValue = new BigInteger("35466");
  BigInteger resultValue =  firstValue.add(secondValue);//73461

• ضرب عمل:

  BigInteger firstValue = new BigInteger("37995");
  BigInteger secondValue = new BigInteger("35466");
  BigInteger resultValue =  firstValue.multiply(secondValue);//1347530670

• باقي ڳولهڻ جا عمل جڏهن هڪ عدد کي ٻئي نمبر سان ورهايو وڃي:

  BigInteger firstValue = new BigInteger("37995");
  BigInteger secondValue = new BigInteger("35466");
  BigInteger resultValue =  firstValue.remainder(secondValue);//2529

• ھڪڙي عدد جو پورو قدر حاصل ڪرڻ (جيڪو آھي، ماڊل، غير دستخط ٿيل):

  BigInteger firstValue = new BigInteger("-37995");
  BigInteger resultValue =  firstValue.abs();//37995

وڌيڪ پيچيده (مخصوص) آپريشن جا طريقا پڻ آھن:

• موڊ حساب سان آپريشن :

  BigInteger firstValue = new BigInteger("-34");
  BigInteger secondValue = new BigInteger("5");
  BigInteger resultValue = firstValue.mod(secondValue); //1

ھن فنڪشن جا ڪيترائي مختلف قسم آھن:

• بي ترتيب نمبر حاصل ڪرڻ ۽ بٽ جو تعداد بيان ڪرڻ جو نتيجو قدر استعمال ڪندو:

  BigInteger firstValue = BigInteger.probablePrime(8, new Random());//211
  BigInteger secondValue = BigInteger.probablePrime(16, new Random());//42571

• bitwise شفٽ آپريشن (هي >> n)

  کاٻي پاسي ڦيرايو:

  BigInteger firstValue = new BigInteger("5");
  BigInteger firstResultValue = firstValue.shiftLeft(3);//40

  ساڄي طرف ڦيرايو:

  BigInteger secondValue = new BigInteger("34");
  BigInteger secondResultValue = secondValue.shiftRight(2); //8

يقينن، اهو بهتر آهي ته دستاويز ۾ طريقن جي مڪمل فهرست کي ڏسڻ لاء .

جاوا ۾ BigDecimal

جڏهن اسان کي گهربل ڊيگهه جي حقيقي تعداد جي ضرورت آهي، جاوا ڪلاس استعمال ڪيو ويندو آهي - BigDecimal. ضابطي جي طور تي، ان جي بدران ماليات سان ڪم ڪرڻ لاء استعمال ڪيو ويندو آهي double، جيئن ته اهو وڌيڪ حسب ضرورت اختيار ڏئي ٿو. پسند ڪريو ۽ BigInteger, BigDecimalهڪ طبقي جو اولاد آهي Number۽ طريقا آهن جيڪي ڪنهن شئي جي قيمت کي مخصوص ابتدائي قسم جي طور تي واپس ڪن ٿا:

BigDecimal value = new BigDecimal(35563.3);

long longValue = value.longValue();//35563

double doubleValue = value.doubleValue();//35563.3

جيئن اسان ڏسي سگهون ٿا ته جڏهن گھٽجي ٿو long، صرف انٽيجر حصو رهي ٿو، ۽ ڊيسيمل جايون رد ڪيون ويون آهن.

بگ ڊيسيمل تعمير ڪندڙ

اسان تعمير ڪندڙن تي ويجھو نظر وجهنداسين BigDecimal، ڇو ته ڪلاس ۾ انھن جو تمام گھڻو وسيع انتخاب آھي. اهڙا تعمير ڪندڙ آهن جيڪي توهان کي مختلف طريقن سان هڪ اعتراض جي قيمت مقرر ڪرڻ جي اجازت ڏين ٿا (پاس ڪندي int، long, double, Stringand even BigInteger)، ۽ اهڙا آهن جيڪي ان جي اجازت ڏين ٿا. ٺھيل اعتراض جي سيٽنگون سيٽ ڪريو (گول ڪرڻ جا طريقا، ڊيسيمل جڳھن جو تعداد):

BigDecimal firstValue = new BigDecimal("455656.545");//455656.545

هتي سڀ ڪجهه واضح آهي، اسان سڌو سنئون سيٽ ڪيو قيمت ۽ عددن جي جڳهن جو تعداد جيڪو اسان ڏسڻ چاهيون ٿا.

BigDecimal secondValue = new BigDecimal(3445.54);//3445.5399999999999636202119290828704833984375

ھن ٺاھيندڙ جا نتيجا بلڪل غير متوقع ٿي سگھن ٿا، ڇاڪاڻ⁠تہ اسان ڊبل بيان ڪري رھيا آھيون، جيڪو پنھنجي فطرت جي لحاظ کان ھڪڙو غير معمولي قسم آھي. تنهن ڪري، اهو عام طور تي استعمال ڪرڻ جي صلاح ڏني وئي آهي هڪ تعمير ڪندڙ String.

BigDecimal thirdValue = new BigDecimal(3445.554645675444, MathContext.DECIMAL32);//3445.555

اسان سيٽ ڪيو double، پر ساڳئي وقت اسان هڪ پيرا ميٽر پڻ مقرر ڪيو آهي جيڪو بيان ڪري ٿو گول جي اصول (جنهن ۾ ڊيسيمل هنڌن جو تعداد ۽ گول ڪرڻ لاء الگورتھم).

char[] arr = new String("455656.545").toCharArray();

BigDecimal fourthValue = new BigDecimal(arr, 2, 6);//5656.5

اسان ڪردارن جو هڪ سلسلو مقرر ڪريون ٿا جنهن عنصر مان اسان اعتراض لاءِ قيمتون وٺون ٿا ۽ انهن مان ڪيترا عنصر وٺون ٿا.

BigDecimal fifthValue = new BigDecimal(new BigInteger("44554"), 3);//44.554

اسان اڳ ۾ ئي موجود اعتراض وٺي BigInteger، decimal هنڌن جو تعداد مقرر.

بگ ڊيسيمل طريقا

ڪلاس ۾ BigDecimalمختلف رياضياتي عملن جا طريقا به شامل آھن، پر BigIntegerان ۾ بٽس سان ڪم ڪرڻ جا طريقا نه آھن، جھڙوڪ. پر ان جي باوجود، مکيه خصوصيت BigDecimalسچل پوائنٽ نمبرن سان ڪم ڪرڻ ۾ لچڪدار آهي. اچو ته ڪجهه ٽيڪنڪ تي نظر رکون جيڪي اسان کي حقيقي انگن اکرن کي ماهر ڪرڻ جي طاقت ڏين ٿيون:

• اسان کي درستي حاصل ٿئي ٿي (نمبر جو تعداد):

  BigDecimal value = new BigDecimal("454334.34334");
  int result = value.precision();//11

• decimal هنڌن جو تعداد ۽ rounding قاعدو مقرر ڪريو:

  BigDecimal firstValue = new BigDecimal(3445.544445);
  
  BigDecimal secondValue = firstValue.setScale(3,BigDecimal.ROUND_CEILING);//3445.545

  هيٺ اسين گولن جي ضابطن کي ترتيب ڏيڻ لاءِ مستقلن تي ويجھو نظر وجهنداسين.

• divide BigDecimalby other BigDecimal, جڏهن ته decimal جڳهن جي گهربل تعداد ۽ rounding قاعدي کي اشارو ڪندي:

  BigDecimal firstValue = new BigDecimal("455656.545");
  
  BigDecimal secondValue = new BigDecimal(3445.544445);
  
  BigDecimal result = firstValue.divide(secondValue, 2,RoundingMode.DOWN);//132.24

• اعشاري نقطي کي ساڄي/ کاٻي هنڌن جي مخصوص تعداد ذريعي منتقل ڪرڻ:

  BigDecimal value = new BigDecimal("455656.545");
  BigDecimal firstResult = value.movePointRight (2);//45565654.5
  BigDecimal secondResult = value.movePointLeft (2);//4556.56545

• ٽرم ٽريلنگ صفر:

  BigDecimal value = new BigDecimal("45056.5000");
  BigDecimal result = value.stripTrailingZeros();//45056.5

  جيڪڏهن اسان وٽ حقيقي حصي ۾ سڀئي صفر آهن ۽ پوري حصي ۾ پڻ صفر آهن (يا اسان وٽ ڪو به ڊيسيمل جڳهه ناهي)، پوء:

  BigDecimal value = new BigDecimal("450000.000");
  BigDecimal result = value.stripTrailingZeros();//4.5E+5

BigDecimal rounding قاعدا

گول ڪرڻ جا قاعدا مقرر ڪرڻ لاءِ، اندر BigDecimalاسان خاص ڪنسٽنٽ ڏسي سگھون ٿا جيڪي بيان ڪن ٿا گول ڪرڻ واري الگورتھم: ROUND_UP- صفر کان گول ڪرڻ، حقيقي حصي ڏانھن گول ڪرڻ:

BigDecimal firstValue = new BigDecimal("2.578");
BigDecimal firstResult =  firstValue.setScale(1, BigDecimal.ROUND_UP );//2.6
BigDecimal secondValue = new BigDecimal("-2.578");
BigDecimal secondResult = secondValue.setScale(1, BigDecimal.ROUND_UP );//-2.5

ROUND_DOWN- صفر کي گول ڪرڻ، يعني حقيقي حصي کي ٽوڙڻ:

BigDecimal firstValue = new BigDecimal("2.578");
BigDecimal firstResult =  firstValue.setScale(1, BigDecimal.ROUND_DOWN  );//2.5
BigDecimal secondValue = new BigDecimal("-2.578");
BigDecimal secondResult = secondValue.setScale(1, BigDecimal.ROUND_DOWN  );//-2.6

ROUND_CEILING- مثبت لامحدود ڏانهن گول ڪرڻ. اهو آهي، جيڪڏهن اسان جو نمبر مثبت آهي، پوء -> ROUND_UP، جيڪڏهن منفي، پوء ->ROUND_DOWN

BigDecimal firstValue = new BigDecimal("2.578");
BigDecimal firstResult =  firstValue.setScale(1, BigDecimal.ROUND_CEILING);//2.6
BigDecimal secondValue = new BigDecimal("-2.578");
BigDecimal secondResult = secondValue.setScale(1, BigDecimal.ROUND_CEILING);//-2.5

ROUND_FLOOR- منفي لامحدود کي گول ڪرڻ، اهو آهي، جيڪڏهن اسان جو نمبر مثبت آهي، پوء -> ROUND_DOWN، جيڪڏهن منفي، پوء ->ROUND_UP

BigDecimal firstValue = new BigDecimal("2.578");
BigDecimal firstResult =  firstValue.setScale(1, BigDecimal.ROUND_FLOOR);//2.5
BigDecimal secondValue = new BigDecimal("-2.578");
BigDecimal secondResult = secondValue.setScale(1, BigDecimal.ROUND_FLOOR);//-2.6

غور هيٺ قدر جي لاءِ، اسان هن ويجھي نمبر تي غور ڪنداسين هڪ ٽٽل اعشاري واري جڳهه سان غور هيٺ ڏنل نمبر جي ويجهي پاڙيسري طور. مثال طور، 2.43 2.5 کان 2.4 جي ويجهو هوندو، پر 2.48 2.5 جي ويجهو هوندو. ROUND_HALF_DOWN- "ويجھي پاڙيسري" ڏانھن گول ڪرڻ. جيڪڏهن ٻئي پاڙيسري هڪ خاص قدر کان برابر آهن، پوء گول کان صفر ڪيو ويندو آهي. برابر فاصلو آهي، مثال طور، جڏهن انگ گول ڪيو پيو وڃي 5، ۽ اهو ساڳيو فاصلو 0 ۽ 10 کان آهي):

BigDecimal firstValue = new BigDecimal("2.58");
BigDecimal firstResult =  firstValue.setScale(1, BigDecimal.ROUND_HALF_DOWN );//2.6
BigDecimal secondValue = new BigDecimal("2.55");
BigDecimal secondResult = secondValue.setScale(1, BigDecimal.ROUND_HALF_DOWN );//2.5

ROUND_HALF_UP- موڊ "ويجھي پاڙيسري" ڏانھن گول ڪرڻ لاء. جيڪڏهن ٻئي پاڙيسري برابر آهن، گولنگ اپ ڪيو ويندو آهي (هي ساڳيو گول آهي جيڪو اسان کي اسڪول ۾ سيکاريو ويو هو):

BigDecimal firstValue = new BigDecimal("2.53");
BigDecimal firstResult =  firstValue.setScale(1, BigDecimal.ROUND_HALF_UP  );//2.5
BigDecimal secondValue = new BigDecimal("2.55");
BigDecimal secondResult = secondValue.setScale(1, BigDecimal.ROUND_HALF_UP  );//2.6

ROUND_HALF_EVEN- ”ويجھي پاڙيسري“ کي گول ڪرڻ جيڪڏھن ٻئي پاڙيسري برابر ناھن. انهي صورت ۾، جيڪڏهن انگ گول ڪيو پيو وڃي ته هڪ بي جوڙ نمبر کان اڳ آهي، اهو گول ڪيو ويندو آهي، ۽ جيڪڏهن اهو برابر آهي، اهو گول ڪيو ويندو آهي:

BigDecimal firstValue = new BigDecimal("2222.2225");
BigDecimal secondValue = firstValue.setScale(3,BigDecimal.ROUND_HALF_EVEN );//2222.222

اسان اهو نتيجو حاصل ڪريون ٿا ڇاڪاڻ ته جڏهن گول ڪرڻ، 5 پوئين نمبر 2 تي نظر اچي ٿو، ۽ اهو ڏسي ٿو ته اهو برابر آهي، گول هيٺ. پر جيڪڏهن:

BigDecimal firstValue = new BigDecimal("2222.22255");
BigDecimal secondValue = firstValue.setScale(3,BigDecimal.ROUND_HALF_EVEN );//2222.223

اهو گول مٿي وڃي ٿو، ڇاڪاڻ ته آخري 5 پوئين قيمت تي نظر اچي ٿو ۽ هڪ بي جوڙ نمبر ڏسي ٿو. نتيجي طور، انگ 6 تائين گول ڪيو ويو آهي، جنهن کان پوء ايندڙ 6 پڻ گول ڪيو ويندو آهي. پر ڇهه هاڻي کاٻي پاسي واري انگ کي نه ڏسندا آهن، ڇاڪاڻ ته انگ واضح طور تي مٿي طرف ويجھو آهي، ۽ نتيجي طور آخري 2 کي 1 کان وڌايو ويو آهي. ROUND_UNNECESSARY- اهو چيڪ ڪرڻ لاء استعمال ڪيو ويو ته انگ کي گول ڪرڻ جي ضرورت ناهي. اهو آهي، اسان چيڪ ڪريون ٿا ته انگ ۾ گهربل تعداد آهي decimal جڳهن جو:

BigDecimal firstValue = new BigDecimal("2.55");
BigDecimal firstResult =  firstValue.setScale(2, BigDecimal.ROUND_UNNECESSARY);//2.55

هتي سڀ ڪجهه ٺيڪ آهي، قدر ۾ ٻه عدد آهن ۽ اسان چيڪ ڪريون ٿا ته ڊيسيمل پوائنٽ کان پوءِ فقط ٻه عدد آهن. پر جيڪڏهن:

BigDecimal secondValue = new BigDecimal("2.55");
BigDecimal secondResult = secondValue.setScale(1, BigDecimal.ROUND_UNNECESSARY);

پوءِ اسان حاصل ڪريون ٿا - ArithmeticException، ڇاڪاڻ ته قيمت جي جانچ ڪئي پئي وڃي decimal جڳهن جي مخصوص تعداد کان وڌيڪ. پر جيڪڏهن اسان ٻه ڊيسيمل جايون چيڪ ڪريون، پر حقيقت ۾ اتي هڪ آهي، ته پوءِ استثنا نه اڇلايو ويندو، ۽ غائب انگن اکرن کي صرف صفر سان پورو ڪيو ويندو:

BigDecimal thirdValue = new BigDecimal("2.5");
BigDecimal thirdResult = thirdValue.setScale(3, BigDecimal.ROUND_UNNECESSARY   );//2.500

مان اهو به نوٽ ڪرڻ چاهيان ٿو ته y BigDecimal۾ مستقل برابر آهي مستقل BigInteger ZERO، ONE۽ TEN. هتي دستاويز جي لنڪ آهي . ۽ آخر ۾: جيئن توهان شايد محسوس ڪيو آهي، جڏهن شيون سان آپريشن ڪندا آهيون BigInteger۽ BigDecimal، اسان پراڻن کي تبديل نه ڪندا آهيون، پر هميشه نوان حاصل ڪندا آهيون. اهو اسان کي ٻڌائي ٿو ته اهي آهن immutable، يعني، انهن جي ٺهڻ کان پوءِ اڻ مٽجڻ وارا آهن، جهڙوڪ String. ٻين لفظن ۾، انهن جا سڀئي طريقا اعتراض جي اندروني حالت کي تبديل نٿا ڪري سگهن؛ وڌ ۾ وڌ، اهي هڪ نئين اعتراض کي واپس ڪري سگهن ٿا جيڪي اسان استعمال ڪري رهيا آهيون فنڪشن پاران بيان ڪيل پيٽرولن سان.