java - কীভাবে জাভাতে দশমিক স্থানগুলিতে একটি সংখ্যা বৃত্তাকার করবেন





decimal rounding digits (25)


শুধু যদি কেউ এখনও এই সাহায্য প্রয়োজন। এই সমাধান আমার জন্য পুরোপুরি কাজ করে।

private String withNoTrailingZeros(final double value, final int nrOfDecimals) {
return new BigDecimal(String.valueOf(value)).setScale(nrOfDecimals,  BigDecimal.ROUND_HALF_UP).stripTrailingZeros().toPlainString();

}

পছন্দসই আউটপুট সঙ্গে একটি String করে।

আমি যা চাই তা হল ডাবল-স্ট্রিং-র একটি স্ট্রিং যা অর্ধেক পদ্ধতি ব্যবহার করে রাউন্ডগুলিকে রূপান্তর করার একটি পদ্ধতি - অর্থাৎ যদি দশমিক বৃত্তাকার করা হয় 5 হয় তবে এটি সর্বদা পূর্ববর্তী সংখ্যা পর্যন্ত ঘোরাবে। এটি বেশিরভাগ ক্ষেত্রেই বেশিরভাগ মানুষের প্রত্যাশা পূরণের আদর্শ পদ্ধতি।

আমি শুধুমাত্র উল্লেখযোগ্য সংখ্যক অক্ষর প্রদর্শন করতে চাই - অর্থাত্ কোন পূর্ববর্তী শূন্যতা নেই।

আমি String.format পদ্ধতি ব্যবহার করার জন্য এটি করার একটি পদ্ধতি জানি:

String.format("%.5g%n", 0.912385);

আয়:

0.91239

যা দুর্দান্ত, তবে এটি সর্বদা 5 দশমিক স্থানগুলির সাথে সংখ্যা প্রদর্শন করে, এমনকি যদি এটি উল্লেখযোগ্য না হয়:

String.format("%.5g%n", 0.912300);

আয়:

0.91230

DecimalFormatter ব্যবহার করার আরেকটি পদ্ধতি হল:

DecimalFormat df = new DecimalFormat("#.#####");
df.format(0.912385);

আয়:

0.91238

তবে আপনি দেখতে পারেন যে এটি অর্ধ-এমনকি বৃত্তাকার ব্যবহার করে। পূর্ববর্তী অঙ্ক এমনকি যদি এটি বৃত্তাকার হবে। আমি যা চাই তা হল:

0.912385 -> 0.91239
0.912300 -> 0.9123

জাভা এই অর্জন করার সেরা উপায় কি?




new BigDecimal(String.valueOf(double)).setScale(yourScale, BigDecimal.ROUND_HALF_UP);

আপনি একটি BigDecimal । এটির স্ট্রিংটি পেতে, শুধুমাত্র BigDecimal এর স্ট্রিং পদ্ধতিতে কল করুন, বা একটি সাধারণ বিন্যাসের স্ট্রিং জন্য জাভা 5+ এর toPlainString পদ্ধতিটি কল করুন।

নমুনা প্রোগ্রাম:

package trials;
import java.math.BigDecimal;

public class Trials {

    public static void main(String[] args) {
        int yourScale = 10;
        System.out.println(BigDecimal.valueOf(0.42344534534553453453-0.42324534524553453453).setScale(yourScale, BigDecimal.ROUND_HALF_UP));
    }



যদি আপনি প্রকৃতপক্ষে গণনার জন্য দশমিক সংখ্যা চান (এবং কেবলমাত্র আউটপুটের জন্য নয়), বাইনারি-ভিত্তিক ভাসমান বিন্দু ফর্ম্যাটটি ডবল ব্যবহার করবেন না।

Use BigDecimal or any other decimal-based format.

আমি গণনার জন্য BigDecimal ব্যবহার করি, কিন্তু মনে রাখবেন এটি আপনার সাথে ডিল করা সংখ্যাগুলির আকারের উপর নির্ভরশীল। আমার বেশিরভাগ বাস্তবায়নের মধ্যে, আমি লংয়ের দ্বিগুণ বা পূর্ণসংখ্যা থেকে পার্সিং খুঁজে পাই যা খুব বড় সংখ্যা গণনার জন্য যথেষ্ট।

প্রকৃতপক্ষে, আমি সম্প্রতি ###################################################################################################### ############### অক্ষর (উদাহরণ হিসাবে)।




অনুমান value একটি double , আপনি করতে পারেন:

(double)Math.round(value * 100000d) / 100000d

যে 5 ডিজিটাল স্পষ্টতা জন্য। জিরো সংখ্যা দশমিক সংখ্যা নির্দেশ করে।




ধরুন আপনার আছে

double d = 9232.129394d;

আপনি BigDecimal ব্যবহার করতে পারেন

BigDecimal bd = new BigDecimal(d).setScale(2, RoundingMode.HALF_EVEN);
d = bd.doubleValue();

অথবা BigDecimal ছাড়া

d = Math.round(d*100)/100.0d;

উভয় সমাধান সঙ্গে d == 9232.13




আপনি যদি স্ট্রিং হিসাবে ফলাফল চান তবে আপনি কী ব্যবহার করতে পারেন সেটির একটি সারসংক্ষেপ এখানে দেওয়া হয়েছে:

  1. DecimalFormat#setRoundingMode() :

    DecimalFormat df = new DecimalFormat("#.#####");
    df.setRoundingMode(RoundingMode.HALF_UP);
    String str1 = df.format(0.912385)); // 0.91239
  2. BigDecimal#setScale()

    String str2 = new BigDecimal(0.912385)
        .setScale(5, BigDecimal.ROUND_HALF_UP)
        .toString();

আপনি ফলাফল হিসাবে double চান তাহলে আপনি কি লাইব্রেরি ব্যবহার করতে পারেন এখানে একটি পরামর্শ। আমি স্ট্রিং রূপান্তরের জন্য এটি সুপারিশ করব না, যদিও দ্বিগুণ আপনি ঠিক কি চান তা উপস্থাপন করতে সক্ষম হবেন না (উদাহরণস্বরূপ here ):

  1. Apache কমন্স ম্যাথ থেকে যথার্থতা

    double rounded = Precision.round(0.912385, 5, BigDecimal.ROUND_HALF_UP);
  2. কল্ট থেকে Functions

    double rounded = Functions.round(0.00001).apply(0.912385)
  3. ওয়েকা থেকে ব্যবহার করে

    double rounded = Utils.roundDouble(0.912385, 5)



আপনি যদি দশমিক বা 5 নম্বর সংখ্যা বিবেচনা করেন। এই প্রশ্নের উত্তর আপনার prob সমাধান হতে পারে।

    double a = 123.00449;
    double roundOff1 = Math.round(a*10000)/10000.00;
    double roundOff2 = Math.round(roundOff1*1000)/1000.00;
    double roundOff = Math.round(roundOff2*100)/100.00;

    System.out.println("result:"+roundOff);

আউটপুট হবে: 123.0 1
এটি লুপ এবং recursive ফাংশন সঙ্গে সমাধান করা যেতে পারে।




সাধারণত, গোলাকার স্কেলিং দ্বারা সম্পন্ন করা হয়: round(num / p) * p

/**
 * MidpointRounding away from zero ('arithmetic' rounding)
 * Uses a half-epsilon for correction. (This offsets IEEE-754
 * half-to-even rounding that was applied at the edge cases).
 */
double RoundCorrect(double num, int precision) {
    double c = 0.5 * EPSILON * num;
//  double p = Math.pow(10, precision); //slow
    double p = 1; while (precision--> 0) p *= 10;
    if (num < 0)
        p *= -1;
    return Math.round((num + c) * p) / p;
}

// testing edge cases
RoundCorrect(1.005, 2);   // 1.01 correct
RoundCorrect(2.175, 2);   // 2.18 correct
RoundCorrect(5.015, 2);   // 5.02 correct

RoundCorrect(-1.005, 2);  // -1.01 correct
RoundCorrect(-2.175, 2);  // -2.18 correct
RoundCorrect(-5.015, 2);  // -5.02 correct



এটি ব্যবহার করে দেখুন: org.apache.commons.math3.util.priscision.round (ডাবল x, int স্কেল)

দেখুন: http://commons.apache.org/proper/commons-math/apidocs/org/apache/commons/math3/util/Precision.html

অ্যাপাচি কমন্স গণিত গ্রন্থাগারের হোমপেজটি হল: http://commons.apache.org/proper/commons-math/index.html

এই পদ্ধতির অভ্যন্তরীণ আনুমানিকতা হল:

public static double round(double x, int scale) {
    return round(x, scale, BigDecimal.ROUND_HALF_UP);
}

public static double round(double x, int scale, int roundingMethod) {
    try {
        return (new BigDecimal
               (Double.toString(x))
               .setScale(scale, roundingMethod))
               .doubleValue();
    } catch (NumberFormatException ex) {
        if (Double.isInfinite(x)) {
            return x;
        } else {
            return Double.NaN;
        }
    }
}



আপনি নিম্নলিখিত ইউটিলিটি পদ্ধতি ব্যবহার করতে পারেন-

public static double round(double valueToRound, int numberOfDecimalPlaces)
{
    double multipicationFactor = Math.pow(10, numberOfDecimalPlaces);
    double interestedInZeroDPs = valueToRound * multipicationFactor;
    return Math.round(interestedInZeroDPs) / multipicationFactor;
}






আমি DecimalFormat --- বা বিকল্পভাবে BigDecimal ব্যবহার করার জন্য নির্বাচিত উত্তর দিয়ে একমত।

প্রথমে নীচের আপডেট পড়ুন দয়া করে!

তবে যদি আপনি double মানটি org.apache.commons.math3.util.Precision.round(..) এবং double মান ফলাফল পেতে চান তবে আপনি উপরে বর্ণিত org.apache.commons.math3.util.Precision.round(..) ব্যবহার করতে পারেন। বাস্তবায়ন BigDecimal ব্যবহার BigDecimal , ধীর এবং আবর্জনা সৃষ্টি করে।

DoubleRounder জ লাইব্রেরিতে DoubleRounder ইউটিলিটির দ্বারা একই রকম কিন্তু দ্রুত এবং আবর্জনা-মুক্ত পদ্ধতি সরবরাহ করা হয়:

 double a = DoubleRounder.round(2.0/3.0, 3);
 double b = DoubleRounder.round(2.0/3.0, 3, RoundingMode.DOWN);
 double c = DoubleRounder.round(1000.0d, 17);
 double d = DoubleRounder.round(90080070060.1d, 9);
 System.out.println(a);
 System.out.println(b);
 System.out.println(c);
 System.out.println(d);

আউটপুট হবে

 0.667
 0.666
 1000.0
 9.00800700601E10

দেখুন https://github.com/tools4j/decimal4j/wiki/DoubleRounder-Utility

Disclaimer: আমি decimal4j প্রকল্প জড়িত করছি।

হালনাগাদ: @ ইওরফেক নির্দেশ করেছেন যে ডাবলআউন্ডার কখনও কখনও প্রতিক্রিয়াশীল ফলাফল প্রদান করে। কারণ এটি গাণিতিকভাবে সঠিক গোলাকার সঞ্চালন করে। উদাহরণস্বরূপ DoubleRounder.round(256.025d, 2) 256.02 পর্যন্ত বৃত্তাকার করা হবে কারণ 256.025 ডি হিসাবে প্রতিনিধিত্বকৃত দ্বিগুণ মানটি যুক্তিসঙ্গত মান 256.025 এর চেয়ে কিছুটা ছোট এবং এটিকে বৃত্তাকার করা হবে।

নোট:

  • এই আচরণটি BigDecimal(double) কন্সট্রাকটরটির সমান অনুরূপ (তবে valueOf(double) জন্য নয় valueOf(double) স্ট্রিং কন্সট্রাকটর ব্যবহার করে)।
  • সমস্যাটিকে প্রথমে উচ্চতর স্পষ্টতাতে ডাবল বৃত্তাকার ধাপে সঙ্কুচিত করা যেতে পারে, তবে এটি জটিল এবং আমি এখানে বিশদে যাচ্ছি না

এই পোস্টে উল্লিখিত কারণগুলির জন্য এবং উপরের সবকিছুর জন্য আমি DoubleRounder ব্যবহার করার সুপারিশ করতে পারি না




@ মিলহাউস: বৃত্তাকার জন্য দশমিক বিন্যাস চমৎকার:

আপনি ব্যবহার করতে পারেন

DecimalFormat df = new DecimalFormat("#.00000");
df.format(0.912385);

আপনি পিছনে 0 এর আছে তা নিশ্চিত করার জন্য।

আমি যোগ করব যে এই পদ্ধতিটি প্রকৃত সংখ্যাসূচক, বৃত্তাকার প্রক্রিয়া প্রদানের ক্ষেত্রে খুব ভাল - কেবলমাত্র দৃশ্যমান নয়, তবে প্রক্রিয়াকরণের সময়ও।

Hypothetical: আপনি একটি GUI প্রোগ্রামে একটি বৃত্তাকার প্রক্রিয়া বাস্তবায়ন করতে হবে। ফলাফল আউটপুট সঠিকতা / নির্ভুলতা পরিবর্তন করতে কেবল ক্যাটেট বিন্যাস পরিবর্তন করুন (অর্থাৎ বন্ধনীগুলির মধ্যে)। সুতরাং যে:

DecimalFormat df = new DecimalFormat("#0.######");
df.format(0.912385);

আউটপুট হিসাবে ফিরে আসবে: 0.912385

DecimalFormat df = new DecimalFormat("#0.#####");
df.format(0.912385);

আউটপুট হিসাবে ফিরে আসবে: 0.91239

DecimalFormat df = new DecimalFormat("#0.####");
df.format(0.912385);

আউটপুট হিসাবে ফিরে আসবে: 0.9124

[সম্পাদন করুন: যদি ক্যারেট বিন্যাসটিও তাই হয় ("# 0 ############") এবং আপনি দশমিক লিখুন, যেমন 3.1415926, আর্গুমেন্টের কারণে, ডেসিমালফরম্যাট কোনও আবর্জনা উত্পাদন করে না ( উদাহরণস্বরূপ পিছনে জিরো) এবং ফিরে আসবে: 3.1415926 .. যদি আপনি যে ভাবে প্রবণ। অনুমিত, এটি কিছু dev এর পছন্দ করার জন্য একটু শব্দের অর্থ - কিন্তু হেই, এটি প্রক্রিয়াকরণের সময় কম মেমরি পদাঙ্ক পেয়েছে এবং বাস্তবায়ন করা খুব সহজ।]

তাই মূলত, দশমিক ফরম্যাটের সৌন্দর্য হল যে এটি একই সাথে স্ট্রিং চেহারাটি পরিচালনা করে - পাশাপাশি গোলাকার নির্ভুলতা সেটের স্তর। Ergo: আপনি এক কোড বাস্তবায়ন মূল্য জন্য দুটি সুবিধা পাবেন। ;)




DecimalFormat আউটপুট সেরা উপায়, কিন্তু আমি এটা পছন্দ করি না। আমি সর্বদা এই সব সময়, কারণ এটি ডবল মান ফেরত। তাই আমি শুধু আউটপুট চেয়ে এটি ব্যবহার করতে পারেন।

Math.round(selfEvaluate*100000d.0)/100000d.0;

অথবা

Math.round(selfEvaluate*100000d.0)*0.00000d1;

যদি আপনার বড় দশমিক স্থান মান দরকার হয়, তবে আপনি পরিবর্তে BigDecimal ব্যবহার করতে পারেন। যাইহোক .0 গুরুত্বপূর্ণ। এটি ছাড়া 0.33333d5 এর বৃত্তান্ত 0.33333 এবং শুধুমাত্র 9 ডিজিটগুলি মঞ্জুরি দেয়। .0 ছাড়া দ্বিতীয় ফাংশন 0.30000 রিটার্ন 0.30000000000000004 সমস্যা আছে।




আপনি ব্যবহার করতে পারেন

DecimalFormat df = new DecimalFormat("#.00000");
df.format(0.912385);

আপনি পিছনে 0 এর আছে তা নিশ্চিত করার জন্য।




আমি এখানে এসেছিলাম কিভাবে একটি সংখ্যা বৃত্তাকার একটি সহজ উত্তর চাই। এটি যে একটি সম্পূরক উত্তর প্রদান করা হয়।

কিভাবে জাভা একটি সংখ্যা বৃত্তাকার

সবচেয়ে সাধারণ ক্ষেত্রে Math.round() ব্যবহার করা হয়।

Math.round(3.7) // 4

সংখ্যা নিকটতম সম্পূর্ণ সংখ্যা গোলাকার হয়। একটি .5 মান বৃত্তাকার আপ হয়। যদি আপনি তার থেকে ভিন্ন বৃত্তাকার আচরণ প্রয়োজন, তবে আপনি অন্য Math ফাংশনগুলির একটি ব্যবহার করতে পারেন। নীচের তুলনা দেখুন।

round

উপরে বর্ণিত হিসাবে, এই রাউন্ড নিকটতম সম্পূর্ণ সংখ্যা। .5 দশমিক বৃত্তাকার আপ। এই পদ্ধতি একটি int ফিরে।

Math.round(3.0); // 3
Math.round(3.1); // 3
Math.round(3.5); // 4
Math.round(3.9); // 4

Math.round(-3.0); // -3
Math.round(-3.1); // -3
Math.round(-3.5); // -3 *** careful here ***
Math.round(-3.9); // -4

ceil

কোন দশমিক মান পরবর্তী পূর্ণসংখ্যা পর্যন্ত বৃত্তাকার হয়। এটা সিল আইএন যায়। এই পদ্ধতি একটি double ফেরত।

Math.ceil(3.0); // 3.0
Math.ceil(3.1); // 4.0
Math.ceil(3.5); // 4.0
Math.ceil(3.9); // 4.0

Math.ceil(-3.0); // -3.0
Math.ceil(-3.1); // -3.0
Math.ceil(-3.5); // -3.0
Math.ceil(-3.9); // -3.0

floor

কোন দশমিক মান পরবর্তী পূর্ণসংখ্যা নিচে বৃত্তাকার হয়। এই পদ্ধতি একটি double ফেরত।

Math.floor(3.0); // 3.0
Math.floor(3.1); // 3.0
Math.floor(3.5); // 3.0
Math.floor(3.9); // 3.0

Math.floor(-3.0); // -3.0
Math.floor(-3.1); // -4.0
Math.floor(-3.5); // -4.0
Math.floor(-3.9); // -4.0

rint

এটি দশমিক মানগুলির নিকটতম পূর্ণসংখ্যাতে বৃত্তাকার অনুরূপ। যাইহোক, round বিপরীত, .5 এমনকি পূর্ণসংখ্যা বৃত্তাকার মান। এই পদ্ধতি একটি double ফেরত।

Math.rint(3.0); // 3.0
Math.rint(3.1); // 3.0
Math.rint(3.5); // 4.0 ***
Math.rint(3.9); // 4.0
Math.rint(4.5); // 4.0 ***
Math.rint(5.5); // 6.0 ***

Math.rint(-3.0); // -3.0
Math.rint(-3.1); // -3.0
Math.rint(-3.5); // -4.0 ***
Math.rint(-3.9); // -4.0
Math.rint(-4.5); // -4.0 ***
Math.rint(-5.5); // -6.0 ***



রিয়েল এর জাভা কিভাবে এই posts , যা জাভা 1.6 এর আগে সংস্করণগুলির জন্য উপযুক্ত।

BigDecimal bd = new BigDecimal(Double.toString(d));
bd = bd.setScale(decimalPlace, BigDecimal.ROUND_HALF_UP);
return bd.doubleValue();



নীচের কোড স্নিপেট দেখায় কিভাবে এন ডিজিট প্রদর্শন করতে হয়। কৌশলটি পরিবর্তনশীল পিপি 1 থেকে n zeros দ্বারা সেট করা হয়। নীচের উদাহরণে, পরিবর্তনশীল পিপি মানের 5 শূন্য আছে, তাই 5 সংখ্যা প্রদর্শিত হবে।

double pp = 10000;

double myVal = 22.268699999999967;
String needVal = "22.2687";

double i = (5.0/pp);

String format = "%10.4f";
String getVal = String.format(format,(Math.round((myVal +i)*pp)/pp)-i).trim();



যেখানে আপনি চান ডিপি = দশমিক জায়গা, এবং মান একটি ডবল।

    double p = Math.pow(10d, dp);

    double result = Math.round(value * p)/p;



এটি অর্জন করতে আমরা এই ফর্ম্যাটটি ব্যবহার করতে পারি:

 DecimalFormat df = new DecimalFormat("#.00");
 String resultado = df.format(valor)

বা:

DecimalFormat df = new DecimalFormat("0.00"); :

সবসময় দুটি দশমিক পেতে এই পদ্ধতি ব্যবহার করুন:

   private static String getTwoDecimals(double value){
      DecimalFormat df = new DecimalFormat("0.00"); 
      return df.format(value);
    }

এই মান নির্ধারণ করা:

91.32
5.22
11.5
1.2
2.6

পদ্ধতি ব্যবহার করে আমরা এই ফলাফল পেতে পারি:

91.32
5.22
11.50
1.20
2.60

ডেমো অনলাইন।




setRoundingMode ব্যবহার করুন, RoundingMode অর্ধ-এমনকি রাউন্ড দিয়ে আপনার সমস্যাটি পরিচালনা করার জন্য স্পষ্টভাবে সেট করুন, তারপরে আপনার প্রয়োজনীয় আউটপুটের জন্য বিন্যাস প্যাটার্নটি ব্যবহার করুন।

উদাহরণ:

DecimalFormat df = new DecimalFormat("#.####");
df.setRoundingMode(RoundingMode.CEILING);
for (Number n : Arrays.asList(12, 123.12345, 0.23, 0.1, 2341234.212431324)) {
    Double d = n.doubleValue();
    System.out.println(df.format(d));
}

আউটপুট দেয়:

12
123.1235
0.23
0.1
2341234.2125



অন্য কেউ যেমন উল্লেখ করেছেন, সঠিক উত্তরটি DecimalFormat বা BigDecimal ব্যবহার করা হয়। ভাসমান-বিন্দুতে দশমিক স্থান নেই তাই আপনি সম্ভবত প্রথম স্থানে তাদের নির্দিষ্ট সংখ্যায় রাউন্ড / টুকরা করতে পারবেন না। আপনি একটি দশমিক রেডিক্স কাজ করতে হবে, এবং যে দুটি ক্লাস কি।

আমি এই কোডটি এই থ্রেডের সমস্ত উত্তরগুলির প্রতি পাল্টা উদাহরণ হিসাবে পোস্ট করছি এবং প্রকৃতপক্ষে স্ট্যাক ওভারফ্লো (এবং অন্য কোথাও) যা গুণমানের অনুসরণ করে ট্রানকেশন অনুসরণ করে গুণমানের সুপারিশ করে। নিম্নলিখিত কোডটি 92% এরও বেশি ক্ষেত্রে ভুল আউটপুট তৈরি করে কেন তা ব্যাখ্যা করার জন্য এই কৌশলটির সমর্থকদের উপর এটির উপস্থিতি রয়েছে।

public class RoundingCounterExample
{

    static float roundOff(float x, int position)
    {
        float a = x;
        double temp = Math.pow(10.0, position);
        a *= temp;
        a = Math.round(a);
        return (a / (float)temp);
    }

    public static void main(String[] args)
    {
        float a = roundOff(0.0009434f,3);
        System.out.println("a="+a+" (a % .001)="+(a % 0.001));
        int count = 0, errors = 0;
        for (double x = 0.0; x < 1; x += 0.0001)
        {
            count++;
            double d = x;
            int scale = 2;
            double factor = Math.pow(10, scale);
            d = Math.round(d * factor) / factor;
            if ((d % 0.01) != 0.0)
            {
                System.out.println(d + " " + (d % 0.01));
                errors++;
            }
        }
        System.out.println(count + " trials " + errors + " errors");
    }
}

এই প্রোগ্রাম আউটপুট:

10001 trials 9251 errors

সম্পাদন করুন: নিচের কিছু মন্তব্যের সমাধান করার জন্য আমি মডিউলাস ক্রিয়াকলাপের জন্য BigDecimal এবং new MathContext(16) ব্যবহার করে পরীক্ষার লুপের মডুলাস অংশটি BigDecimal new MathContext(16) :

public static void main(String[] args)
{
    int count = 0, errors = 0;
    int scale = 2;
    double factor = Math.pow(10, scale);
    MathContext mc = new MathContext(16, RoundingMode.DOWN);
    for (double x = 0.0; x < 1; x += 0.0001)
    {
        count++;
        double d = x;
        d = Math.round(d * factor) / factor;
        BigDecimal bd = new BigDecimal(d, mc);
        bd = bd.remainder(new BigDecimal("0.01"), mc);
        if (bd.multiply(BigDecimal.valueOf(100)).remainder(BigDecimal.ONE, mc).compareTo(BigDecimal.ZERO) != 0)
        {
            System.out.println(d + " " + bd);
            errors++;
        }
    }
    System.out.println(count + " trials " + errors + " errors");
}

ফলাফল:

10001 trials 4401 errors



আপনি DecimalFormat ক্লাস ব্যবহার করতে পারেন।

double d = 3.76628729;

DecimalFormat newFormat = new DecimalFormat("#.##");
double twoDecimal =  Double.valueOf(newFormat.format(d));



একটি সংক্ষিপ্ত সমাধান:

   public static double round(double value, int precision) {
      int scale = (int) Math.pow(10, precision);
      return (double) Math.round(value * scale) / scale;
  }

এছাড়াও দেখুন, https://.com/a/22186845/212950 এই jpdymond জন্য jpdymond ধন্যবাদ।




উল্লেখ্য যে এই পদ্ধতিটি আরও পক্ষপাতী এবং পরবর্তী nextInt পদ্ধতির চেয়ে কম কার্যকরী, https://.com/a/738651/360211

এটি সম্পন্ন করার জন্য একটি আদর্শ প্যাটার্ন হল:

Min + (int)(Math.random() * ((Max - Min) + 1))

Java মথ লাইব্রেরী ফাংশন Math.random () পরিসীমাতে একটি দ্বিগুণ মান তৈরি করে [0,1) । লক্ষ্য করুন এই পরিসীমা 1 অন্তর্ভুক্ত না।

প্রথম মানগুলির একটি নির্দিষ্ট পরিসর পেতে, আপনাকে যে পরিমাণ মানগুলি আচ্ছাদিত করতে চান তার পরিধি পরিধি দ্বারা গুণ করতে হবে।

Math.random() * ( Max - Min )

এটি পরিসীমা [0,Max-Min) একটি মান প্রদান করে, যেখানে 'সর্বোচ্চ-মাইন' অন্তর্ভুক্ত করা হয় না।

উদাহরণস্বরূপ, যদি আপনি চান [5,10) , আপনি ব্যবহার করতে হলে পাঁচটি পূর্ণসংখ্যা মান আবরণ করতে হবে

Math.random() * 5

এটি পরিসীমা [0,5) তে একটি মান প্রদান করবে, যেখানে 5 টি অন্তর্ভুক্ত করা হবে না।

এখন আপনি এই পরিসীমাটিকে যে সীমাবদ্ধ করছেন তার উপরে সরাতে হবে। আপনি ন্যূনতম মান যোগ করে এই কাজ।

Min + (Math.random() * (Max - Min))

আপনি এখন পরিসীমা [Min,Max) একটি মান পাবেন। আমাদের উদাহরণ অনুসরণ করে, [5,10) মানে:

5 + (Math.random() * (10 - 5))

কিন্তু, এটি এখনও Max অন্তর্ভুক্ত করে না এবং আপনি একটি ডবল মান পেয়েছেন। Max মানটি অন্তর্ভুক্ত করার জন্য, আপনাকে আপনার পরিসীমা প্যারামিটারে 1 যোগ করতে হবে (Max - Min) এবং তারপরে একটি int তে কাস্ট করে দশমিক অংশটি টানতে হবে। এই মাধ্যমে সম্পন্ন করা হয়:

Min + (int)(Math.random() * ((Max - Min) + 1))

এবং সেখানে আপনি এটা আছে। পরিসীমা [Min,Max] , অথবা প্রতি উদাহরণে [5,10] র্যান্ডম পূর্ণসংখ্যা মান:

5 + (int)(Math.random() * ((10 - 5) + 1))






java decimal rounding digits