I have an [XSD] that requires me to use a BigDecimal for a lat/lon.  I currently have the lat/lon as doubles, and convert them to BigDecimal, but I am only required to use about 12 places of precision.  I have not been able to figure out how to set that.  Can anyone help me with this?

[XSD]: https://en.wikipedia.org/wiki/XSD

Set specific precision of a BigDecimal


I want to set scale of two BigDecimal numbers `a` and `b` . as in this example :

    BigDecimal a = new BigDecimal(&quot;2.6E-1095&quot;);
            BigDecimal b = new BigDecimal(&quot;2.7E-1105&quot;);
            int i = 112, j=1;
    
            BigDecimal aa = a.setScale(i+j);
            BigDecimal bb = b.setScale(i+j);

and when i run i have this exception:

    java.lang.ArithmeticException: Rounding necessary
    	at java.math.BigDecimal.divideAndRound(BigDecimal.java:1439)
    	at java.math.BigDecimal.setScale(BigDecimal.java:2394)
    	at java.math.BigDecimal.setScale(BigDecimal.java:2437)

Why rounding is necessary ?  if i don&#39;t want to make around, what is solution please ?

Thanks

Rounding necessary with BigDecimal numbers

How can I compare if `BigDecimal` value is greater than zero?

Compare if BigDecimal is greater than zero

I tried the following,
   

       double doubleVal = 1.745;
       double doubleVal1 = 0.745;
       BigDecimal bdTest = new BigDecimal(  doubleVal);
       BigDecimal bdTest1 = new BigDecimal(  doubleVal1 );
       bdTest = bdTest.setScale(2, BigDecimal.ROUND_HALF_UP);
       bdTest1 = bdTest1.setScale(2, BigDecimal.ROUND_HALF_UP);
       System.out.println(&quot;bdTest:&quot;+bdTest); //1.75
       System.out.println(&quot;bdTest1:&quot;+bdTest1);//0.74    problemmmm ????????????  

but got weird results. Why?

How to round 0.745 to 0.75 using BigDecimal.ROUND_HALF_UP?

How to convert from float to bigDecimal  in java?

How to convert from float to bigDecimal in java?

I have custom `DecimalFormat` in Edittext&#39;s addTextChangedListener method, everything is  working perfectly but when I change language (locale) my addTextChangedListener is not working.

    double answer = inputDouble * counterToDouble;
    DecimalFormat df = new DecimalFormat(&quot;##.########&quot;);
    // df=(DecimalFormat)numberFormat;

    df.setRoundingMode(RoundingMode.DOWN);
    answer = Double.parseDouble(df.format(answer));

    unicoinsAmmount.setText(String.valueOf(df.format(answer)));

I searched about my problem and found a `NumberFormat` solution:

    NumberFormat numberFormat = NumberFormat.getNumberInstance(Locale.US);

but I don&#39;t know how I can use this code.

Change DecimalFormat locale

I have the following code in Java;

    BigDecimal price; // assigned elsewhere

	if (price.compareTo(new BigDecimal(&quot;0.00&quot;)) == 0) {
		return true;
	}

What is the best way to write the if condition?

How to check if BigDecimal variable == 0 in java?

I&#39;m trying to round BigDecimal values up, to two decimal places.

I&#39;m using

    BigDecimal rounded = value.round(new MathContext(2, RoundingMode.CEILING));
    logger.trace(&quot;rounded {} to {}&quot;, value, rounded);

but it doesn&#39;t do what I want consistently:

    rounded 0.819 to 0.82
    rounded 1.092 to 1.1
    rounded 1.365 to 1.4 // should be 1.37
    rounded 2.730 to 2.8 // should be 2.74
    rounded 0.819 to 0.82

I don&#39;t care about significant digits, I just want two decimal places. How do I do this with BigDecimal? Or is there another class/library better suited to this?

Rounding BigDecimal to *always* have two decimal places

I have this little crazy method that converts BigDecimal values into nice and readable Strings.

    private String formatBigDecimal(BigDecimal bd){
        DecimalFormat df = new DecimalFormat();
        df.setMinimumFractionDigits(3);
        df.setMaximumFractionDigits(3);
        df.setMinimumIntegerDigits(1);
        df.setMaximumIntegerDigits(3);
        df.setGroupingSize(20);
        return df.format(bd);
    }

It however, also produces a so called grouping separator `&quot;,&quot;` that makes all my values come out like this:

    xxx,xxx

I do need the separator to be a dot or a point and not a comma. 
Does anybody have a clue of how to accomplish this little feat?

I have read [this][1] and in particular [this][2] to death now but I cannot find a way to get this done.
Am I approaching this the wrong way? Is there a much more elegant way of doing this? Maybe even a solution that accounts for different local number representations, since the comma would be perfect by European standards.

  [1]: http://developer.android.com/reference/java/math/BigDecimal.html
  [2]: http://developer.android.com/reference/java/text/DecimalFormat.html

How to change the decimal separator of DecimalFormat from comma to dot/point?

I have a collection of BigDecimals (in this example, a `LinkedList`) that I would like to add together. Is it possible to use streams for this?

I noticed the `Stream` class has several methods

    Stream::mapToInt
    Stream::mapToDouble
    Stream::mapToLong

Each of which has a convenient `sum()` method. But, as we know, `float` and `double` arithmetic is almost always a bad idea.

So, is there a convenient way to sum up BigDecimals?

This is the code I have so far.

    public static void main(String[] args) {
        LinkedList&lt;BigDecimal&gt; values = new LinkedList&lt;&gt;();
        values.add(BigDecimal.valueOf(.1));
        values.add(BigDecimal.valueOf(1.1));
        values.add(BigDecimal.valueOf(2.1));
        values.add(BigDecimal.valueOf(.1));
        
        // Classical Java approach
        BigDecimal sum = BigDecimal.ZERO;
        for(BigDecimal value : values) {
            System.out.println(value);
            sum = sum.add(value);
        }
        System.out.println(&quot;Sum = &quot; + sum);
        
        // Java 8 approach
        values.forEach((value) -&gt; System.out.println(value));
        System.out.println(&quot;Sum = &quot; + values.stream().mapToDouble(BigDecimal::doubleValue).sum());
        System.out.println(values.stream().mapToDouble(BigDecimal::doubleValue).summaryStatistics().toString());
    }

As you can see, I am summing up the BigDecimals using `BigDecimal::doubleValue()`, but this is (as expected) not precise.


**Post-answer edit for posterity:**

Both answers were extremely helpful. I wanted to add a little: my real-life scenario does not involve a collection of raw `BigDecimal`s, they are wrapped in an invoice. But, I was able to modify Aman Agnihotri&#39;s answer to account for this by using the `map()` function for stream:

    public static void main(String[] args) {
        
        LinkedList&lt;Invoice&gt; invoices = new LinkedList&lt;&gt;();
        invoices.add(new Invoice(&quot;C1&quot;, &quot;I-001&quot;, BigDecimal.valueOf(.1), BigDecimal.valueOf(10)));
        invoices.add(new Invoice(&quot;C2&quot;, &quot;I-002&quot;, BigDecimal.valueOf(.7), BigDecimal.valueOf(13)));
        invoices.add(new Invoice(&quot;C3&quot;, &quot;I-003&quot;, BigDecimal.valueOf(2.3), BigDecimal.valueOf(8)));
        invoices.add(new Invoice(&quot;C4&quot;, &quot;I-004&quot;, BigDecimal.valueOf(1.2), BigDecimal.valueOf(7)));
        
        // Classical Java approach
        BigDecimal sum = BigDecimal.ZERO;
        for(Invoice invoice : invoices) {
            BigDecimal total = invoice.unit_price.multiply(invoice.quantity);
            System.out.println(total);
            sum = sum.add(total);
        }
        System.out.println(&quot;Sum = &quot; + sum);
        
        // Java 8 approach
        invoices.forEach((invoice) -&gt; System.out.println(invoice.total()));
        System.out.println(&quot;Sum = &quot; + invoices.stream().map((x) -&gt; x.total()).reduce((x, y) -&gt; x.add(y)).get());
    }
    
    static class Invoice {
        String company;
        String invoice_number;
        BigDecimal unit_price;
        BigDecimal quantity;

        public Invoice() {
            unit_price = BigDecimal.ZERO;
            quantity = BigDecimal.ZERO;
        }

        public Invoice(String company, String invoice_number, BigDecimal unit_price, BigDecimal quantity) {
            this.company = company;
            this.invoice_number = invoice_number;
            this.unit_price = unit_price;
            this.quantity = quantity;
        }
        
        public BigDecimal total() {
            return unit_price.multiply(quantity);
        }

        public void setUnit_price(BigDecimal unit_price) {
            this.unit_price = unit_price;
        }

        public void setQuantity(BigDecimal quantity) {
            this.quantity = quantity;
        }

        public void setInvoice_number(String invoice_number) {
            this.invoice_number = invoice_number;
        }

        public void setCompany(String company) {
            this.company = company;
        }

        public BigDecimal getUnit_price() {
            return unit_price;
        }

        public BigDecimal getQuantity() {
            return quantity;
        }

        public String getInvoice_number() {
            return invoice_number;
        }

        public String getCompany() {
            return company;
        }
    }

Adding up BigDecimals using Streams

Consider the simple test class:

    import java.math.BigDecimal;

    /**
     * @author The Elite Gentleman
     *
     */
    public class Main {
    
    	/**
    	 * @param args
    	 */
    	public static void main(String[] args) {
    		// TODO Auto-generated method stub
    		BigDecimal x = new BigDecimal(&quot;1&quot;);
    		BigDecimal y = new BigDecimal(&quot;1.00&quot;);
    		System.out.println(x.equals(y));
    		System.out.println(x.compareTo(y) == 0 ? &quot;true&quot;: &quot;false&quot;);
    	}
    
    }

You can (consciously) say that `x` is equal to `y` (not object reference), but when you run the program, the following result shows:

    false
    true

Question: What&#39;s the difference between `compareTo()` and `equals()` in `BigDecimal` that `compareTo` can determine that `x` is equal to `y`?

PS: I see that BigDecimal has an `inflate()` method on `equals()` method. What does `inflate()` do actually?




BigDecimal equals() versus compareTo()

I want to do some simple sums with some currency values expressed in `BigDecimal` type. 

    BigDecimal test = new BigDecimal(0);
    System.out.println(test);
    test.add(new BigDecimal(30));
    System.out.println(test);
    test.add(new BigDecimal(45));
    System.out.println(test);

Obviously I do not understand well the `BigDecimal` arithmetics, see output behind.

    Test
    0
    0
    0

 Can anyone help me out?


Addition for BigDecimal

What is the difference between this two call? (Is there any?)

    // 1.
    new BigDecimal(&quot;3.53456&quot;).round(new MathContext(4, RoundingMode.HALF_UP));
    // 2.
    new BigDecimal(&quot;3.53456&quot;).setScale(4, RoundingMode.HALF_UP);

BigDecimal setScale and round

How to set thousands separator in Java?  
I have String representation of a BigDecimal that I want to format with a thousands separator and return as String.


How to set thousands separator in Java?

I have Hibernate method which returns me a BigDecimal.
I have another API method to which I need to pass that number but it accepts Integer as parameter. I cannot change return types or variable types of both methods. 

Now how to convert the BigDecimal into Integer and pass it to second method?

Is there a way out of this?


Converting BigDecimal to Integer

I have a domain class with unitPrice set as BigDecimal data type. Now I am trying to create a method to compare price but it seems like I can&#39;t have comparison operators in BigDecimal data type. Do I have to change data type or is there other way around?

How to use comparison operators like &gt;, =, &lt; on BigDecimal

I&#39;ve been trying to convert a value of seconds (in a BigDecimal variable) to a string in an editText like &quot;1 hour 22 minutes 33 seconds&quot; or something of the kind. 

I&#39;ve tried this:

    String sequenceCaptureTime = &quot;&quot;;
    BigDecimal roundThreeCalc = new BigDecimal(&quot;0&quot;);
    BigDecimal hours = new BigDecimal(&quot;0&quot;);
    BigDecimal myremainder = new BigDecimal(&quot;0&quot;);
    BigDecimal minutes = new BigDecimal(&quot;0&quot;);
    BigDecimal seconds = new BigDecimal(&quot;0&quot;);
    BigDecimal var3600 = new BigDecimal(&quot;3600&quot;);
    BigDecimal var60 = new BigDecimal(&quot;60&quot;);

(I have a roundThreeCalc which is the value in seconds so I try to convert it here.)

    hours = (roundThreeCalc.divide(var3600));
    myremainder = (roundThreeCalc.remainder(var3600));
    minutes = (myremainder.divide(var60));
    seconds = (myremainder.remainder(var60));
    sequenceCaptureTime =  hours.toString() + minutes.toString() + seconds.toString();

Then I set the editText to sequnceCaptureTime String.
But that didn&#39;t work. It force closed the app every time. I am totally out of my depth here, any help is greatly appreciated. Happy coding! 

Convert seconds value to hours minutes seconds?

I&#39;m trying to read some BigDecimal values from the string. Let&#39;s say I have this String: &quot;1,000,000,000.999999999999999&quot; and I want to get a BigDecimal out of it. What is the way to do it?

First of all, I don&#39;t like the solutions using string replaces (replacing commas etc.). I think there should be some neat formatter to do that job for me.

I&#39;ve found a DecimalFormatter class, however as it operates through double - huge amounts of precision are lost.

So, how can I do it?

Safe String to BigDecimal conversion

Why does the following code raise the exception shown below?

    BigDecimal a = new BigDecimal(&quot;1.6&quot;);
    BigDecimal b = new BigDecimal(&quot;9.2&quot;);
    a.divide(b) // results in the following exception.

Exception:

    java.lang.ArithmeticException: Non-terminating decimal expansion; no exact representable decimal result.

ArithmeticException: &quot;Non-terminating decimal expansion; no exact representable decimal result&quot;

I have a `BigDecimal` field `amount` which represents money, and I need to print its value in the browser in a format like `$123.00`, `$15.50`, `$0.33`.

How can I do that?

(The only simple solution which I see myself is getting `floatValue` from `BigDecimal` and then using `NumberFormat` to make two-digit precision for the fraction part).

How to print formatted BigDecimal values?

I came across two ways of getting BigDecimal object out of a double d.

 1. `new BigDecimal(d)`
 2. `BigDecimal.valueOf(d)`

Which would be a better approach? Would `valueOf` create a new object?

In general (not just BigDecimal), what is recommended - new or valueOf?


BigDecimal - to use new or valueOf

I need the following results

    100.12 -&gt; 100.00
    100.44 -&gt; 100.00
    100.50 -&gt; 101.00
    100.75 -&gt; 101.00

`.round()` or `.setScale()` ? How do I go about this?

Java BigDecimal: Round to the nearest whole value

I understand that BigDecimal is recommended best practice for representing monetary values in Java. What do you use? Is there a better library that you prefer to use instead?

Representing Monetary Values in Java

In Java, I want to take a double value and convert it to a `BigDecimal` and print out its String value to a certain precision.  

    import java.math.BigDecimal;
    public class Main {
        public static void main(String[] args) {
            double d=-.00012;
            System.out.println(d+&quot;&quot;); //This prints -1.2E-4
           
            double c=47.48000;
            BigDecimal b = new BigDecimal(c);
            System.out.println(b.toString()); 
            //This prints 47.47999999999999687361196265555918216705322265625 
        }
    }

It prints this huge thing:

&gt; 47.47999999999999687361196265555918216705322265625

and not

&gt;47.48

The reason I&#39;m doing the `BigDecimal` conversion is sometimes the double value will contain a lot of decimal places (i.e. `-.000012`) and the when converting the double to a String will produce scientific notation `-1.2E-4`.  I want to store the String value in non-scientific notation. 

I want to have BigDecimal always have two units of precision like this: &quot;47.48&quot;.  Can BigDecimal restrict precision on conversion to string?


Convert double to BigDecimal and set BigDecimal Precision

I&#39;m using BigDecimal for my numbers in my application, for example, with JPA. I did a bit of researching about the terms &#39;precision&#39; and &#39;scale&#39; but I don&#39;t understand what are they exactly.

Can anyone explain me the meaning of &#39;precision&#39; and &#39;scale&#39; for a BigDecimal value?

    @Column(precision = 11, scale = 2)

Thanks!

BigDecimal, precision and scale

I’m looking for a good arbitrary precision math library in C or C++. Could you please give me some advices or suggestions?

The primary requirements:

1. It **must** handle arbitrarily big integers—my primary interest is on integers. In case that you don’t know what the word arbitrarily big means, imagine something like 100000! (the factorial of 100000).

2. The precision **must not need** to be specified during library initialization or object creation. The precision should **only** be constrained by the available resources of the system.

3. It **should** utilize the full power of the platform, and should handle “small” numbers natively. That means on a 64-bit platform, calculating (2^33&#160;+ 2^32) should use the available 64-bit CPU instructions. The library **should not** calculate this in the same way as it does with (2^66&#160;+ 2^65) on the same platform.

4. It **must** efficiently handle addition&#160;(`+`), subtraction&#160;(`-`), multiplication&#160;(`*`), integer division&#160;(`/`), remainder&#160;(`%`), power&#160;(`**`), increment&#160;(`++`), decrement&#160;(`--`), GCD, factorial, and other common integer arithmetic calculations. The ability to handle functions like square root and logarithm that do not produce integer results is a plus. The ability to handle [symbolic computations](http://en.wikipedia.org/wiki/Symbolic_computation) is even better.

Here are what I found so far:

1. **Java**&#39;s **[BigInteger](http://java.sun.com/javase/6/docs/api/java/math/BigInteger.html)** and **[BigDecimal](http://java.sun.com/javase/6/docs/api/java/math/BigDecimal.html)** class: I have been using these so far. I have read the source code, but I don’t understand the math underneath. It may be based on theories and algorithms that I have never learnt.

2. The built-in integer type or in core libraries of **[bc](http://www.gnu.org/software/bc/manual/html_mono/bc.html)**, **[Python](http://docs.python.org/release/3.1.2/reference/lexical_analysis.html#integer-literals)**, **Ruby**, **Haskell**, **Lisp**, **Erlang**, **OCaml**, **PHP**, some other languages: I have used some of these, but I have no idea which library they are using, or which kind of implementation they are using.

What I have already known:

1. Using `char` for decimal digits and `char*` for decimal strings, and do calculations on the digits using a `for`-loop.

2. Using `int` (or `long int`, or `long long`) as a basic “unit” and an array of that type as an arbitrary long integer, and do calculations on the elements using a `for`-loop.

3. Using an integer type to store a decimal digit (or a few digits) as **[BCD (Binary-coded decimal)](http://en.wikipedia.org/wiki/Binary-coded_decimal)**.

4. **[Booth’s multiplication algorithm](http://en.wikipedia.org/wiki/Booth%27s_multiplication_algorithm)**.

What I don’t know:

1. Printing the binary array mentioned above in decimal without using naive methods. An example of a naive method: (1)&#160;add the bits from the lowest to the highest: 1, 2, 4, 8, 16, 32, … (2)&#160;use a `char*`-string mentioned above to store the intermediate decimal results).

What I appreciate:

1. Good comparisons on **[GMP](http://gmplib.org/)**, **[MPFR](http://www.mpfr.org/)**, **[decNumber](http://speleotrove.com/decimal/decnumber.html)** (or other libraries that are good in your opinion).

2. Good suggestions on books and articles that I should read. For example, an illustration with figures on how a **non-naive** binary-to-decimal conversion algorithm works would be good. The article “**[Binary to Decimal Conversion in Limited Precision](http://www.cs.uiowa.edu/~jones/bcd/decimal.html)**” by Douglas&#160;W. Jones is an example of a good article.

3. Any help in general.

Please **do not** answer this question if you think that using `double` (or `long double`, or `long long double`) can solve this problem easily. If you do think so, you don’t understand the issue in question.

What are the best (portable) cross-platform arbitrary-precision math libraries?

I have a BigDecimal number and i consider only 2 decimal places of it so i truncate it using:

    bd = bd.setScale(2, BigDecimal.ROUND_DOWN)

Now I want to print it as String but removing the decimal part if it is 0, for example:

1.00 -&gt; 1

1.50 -&gt; 1.5

1.99 -&gt; 1.99

I tried using a Formatter, formatter.format but i always get the 2 decimal digits.

How can I do this? Maybe working on the string from bd.toPlainString()?



Format a BigDecimal as String with max 2 decimal digits, removing 0 on decimal part

I am reading a currency from `XML` into Java. 

    String currency = &quot;135.69&quot;;
When I convert this to `BigDecimal` I get:

     System.out.println(new BigDecimal(135.69));
Output:

    135.68999999999999772626324556767940521240234375.

Why is it that it outputs this many numbers? How can I avoid this? All I want is for it to output 135.69.

Convert string to BigDecimal in java

When storing latitudes/longitudes which are typically of the format: 44.087585 (i.e. max 2 numbers before the dot and 6dp) do I need to bother with bigdecimals?

Java double vs BigDecimal for latitude/longitude

I was testing boundary conditions on some code involving a `BigDecimal`, and I noticed that when a `BigDecimal` is initialized with the String `&quot;1e2147483647&quot;` it behaves unexpectedly. It seems to have a value between `0` and `1e-2147483647`. When I try calling `intValue()`, I get a `NegativeArraySizeException`. I should note that `2147483647` is the max value of an integer on my system. Am I doing something wrong, or is this a problem with `BigDecimal`?

    BigDecimal test = new BigDecimal(&quot;1e2147483647&quot;);
    
    test.compareTo(new BigDecimal(0));  //Returns 1
    test.compareTo(new BigDecimal(&quot;1e-2147483647&quot;));  //Returns -1
    test.intValue();  //Throws NegativeArraySizeException

Java BigDecimal Possible Overflow Bug

I was trying to make my own class for currencies using longs, but apparently I should use `BigDecimal` instead. Could someone help me get started? What would be the best way to use `BigDecimal`s for dollar currencies, like making it at least but no more than 2 decimal places for the cents, etc. The API for `BigDecimal` is huge, and I don&#39;t know which methods to use. Also, `BigDecimal` has better precision, but isn&#39;t that all lost if it passes through a `double`? if I do new `BigDecimal(24.99)`, how will it be different than using a `double`? Or should I use the constructor that uses a `String` instead?

Using BigDecimal to work with currencies

I have to calculate some floating point variables and my colleague suggest me to use `BigDecimal` instead of `double` since it will be more precise. But I want to know what it is and how to make most out of `BigDecimal`?

Double vs. BigDecimal?

I have a BigDecimal object and i want to convert it to string.
The problem is that my value got fraction and i get a huge number (in length) and i only need the original number in string for example:
for

    BigDecimal bd = new BigDecimal(10.0001)
    System.out.println(bd.toString());
    System.out.println(bd.toPlainString());
**the output is:**

    10.000099999999999766941982670687139034271240234375
    10.000099999999999766941982670687139034271240234375

and i need the out put to be exactly the number `10.0001` in string

BigDecimal to string

I need to remove trailing zeros from `BigDecimal` along with `RoundingMode.HALF_UP`. For instance,

    Value        Output
    
    15.3456  &lt;=&gt; 15.35
    15.999   &lt;=&gt; 16            //No trailing zeros.
    15.99    &lt;=&gt; 15.99
    15.0051  &lt;=&gt; 15.01
    15.0001  &lt;=&gt; 15           //No trailing zeros.
    15.000000&lt;=&gt; 15           //No trailing zeros.
    15.00    &lt;=&gt; 15           //No trailing zeros.

[`stripTrailingZeros()`][1] works but it returns scientific notations in situations like,

    new BigDecimal(&quot;600.0&quot;).setScale(2, RoundingMode.HALF_UP).stripTrailingZeros();

In this case, it returns `6E+2`. I need this in a custom converter in JSF where it might be ugly for end users. So, what is the proper way of doing this?


  [1]: https://docs.oracle.com/javase/8/docs/api/java/math/BigDecimal.html#stripTrailingZeros--

Removing trailing zeros from BigDecimal in Java

How do you multiply a BigDecimal by an integer in Java? I tried this but its not correct.

    import java.math.BigDecimal;
    import java.math.MathContext;
    
    public class Payment {
        int itemCost;
        int totalCost = 0;
        
        public BigDecimal calculateCost(int itemQuantity,BigDecimal itemPrice){
            itemCost = itemPrice.multiply(itemQuantity);
            totalCost = totalCost + itemCost;
        return totalCost;
       }

How to multiply a BigDecimal by an integer in Java

I want a function to convert *Bigdecimal* `10.12 for 10.12345` and `10.13 for 10.12556`.
But no function is satisfying both conversion in same time.Please help to achieve this.

Below is what I tried.&lt;br&gt;
With value 10.12345:

    BigDecimal a = new BigDecimal(&quot;10.12345&quot;);
    
    a.setScale(2, BigDecimal.ROUND_UP)
    a.setScale(2, BigDecimal.ROUND_CEILING)
    a.setScale(2, BigDecimal.ROUND_DOWN)
    a.setScale(2, BigDecimal.ROUND_FLOOR)
    a.setScale(2, BigDecimal.ROUND_HALF_DOWN)
    a.setScale(2, BigDecimal.ROUND_HALF_EVEN)
    a.setScale(2, BigDecimal.ROUND_HALF_UP)

Output :

    10.12345::10.13
    10.12345::10.13
    10.12345::10.12
    10.12345::10.12
    10.12345::10.12
    10.12345::10.12
    10.12345::10.12
With value 10.12556:

    BigDecimal b = new BigDecimal(&quot;10.12556&quot;);
    
    b.setScale(2, BigDecimal.ROUND_UP)
    b.setScale(2, BigDecimal.ROUND_CEILING)
    b.setScale(2, BigDecimal.ROUND_DOWN)
    b.setScale(2, BigDecimal.ROUND_FLOOR)
    b.setScale(2, BigDecimal.ROUND_HALF_DOWN)
    b.setScale(2, BigDecimal.ROUND_HALF_EVEN)
    b.setScale(2, BigDecimal.ROUND_HALF_UP)

Output :

    10.12556::10.13
    10.12556::10.13
    10.12556::10.12
    10.12556::10.12
    10.12556::10.12
    10.12556::10.12
    10.12556::10.12




Rounding Bigdecimal values with 2 Decimal Places

In Java, I&#39;m working with the `BigDecimal` class and part of my code requires me to extract the fractional part from it.  `BigDecimal` does not appear to have any built in methods to help me get the number after the decimal point of a `BigDecimal`.

For example:

    BigDecimal bd = new BigDecimal(&quot;23452.4523434&quot;);

I want to extract the `4523434` from the number represented above.  What&#39;s the best way to do it?


Java, extract just the fractional part of a BigDecimal?

Can we compute the square root of a `BigDecimal` in Java by using only the Java API and not a custom-made 100-line algorithm?

Square root of BigDecimal in Java

I write currency trading applications for living, so I have to work with monetary values (it&#39;s a shame that Java still doesn&#39;t have decimal float type and has nothing to support arbitrary-precision monetary calculations). &quot;Use BigDecimal!&quot; — you might say. I do. But now I have some code where performance **is** an issue, and BigDecimal is more than 1000 times (!) slower than `double` primitives.

The calculations are very simple: what the system does is calculating `a = (1/b) * c` many many times (where `a`, `b` and `c` are fixed-point values). The problem, however, lies with this `(1/b)`. I can&#39;t use fixed point arithmetic because there is no fixed point. And `BigDecimal result = a.multiply(BigDecimal.ONE.divide(b).multiply(c)` is not only ugly, but sluggishly slow.

What can I use to replace BigDecimal? I need at least 10x performance increase. I found otherwise excellent [JScience library][1] which has arbitrary-precision arithmetics, but it&#39;s even slower than BigDecimal.

Any suggestions?


  [1]: http://www.jscience.org &quot;JScience&quot;

What to do with Java BigDecimal performance?

What is an **efficient** way of determining whether a `BigDecimal` is an integer value in the mathematical sense?

At present I have the following code:

    private boolean isIntegerValue(BigDecimal bd) {
        boolean ret;
        
        try {
            bd.toBigIntegerExact();
            ret = true;
        } catch (ArithmeticException ex) {
            ret = false;
        }

        return ret;
    }

... but would like to avoid the object creation overhead if possible.

Previously I was using `bd.longValueExact()` which would avoid creating an object if the `BigDecimal` was using its compact representation internally, but obviously would fail if the value was too big to fit into a long.


Check if BigDecimal is an integer in Java

I want to use assert between 2 two decimal, I use this:

    BigDecimal bd1 = new BigDecimal (1000);
    BigDecimal bd2 = new BigDecimal (1000);
    org.junit.Assert.assertSame (bd1,bd2);

but the JUnit log shows:

    expected &lt;1000&gt; was not: &lt;1000&gt;

JUnit Assert with BigDecimal

Recently I tried understanding the use of **java.math.MathContext** but failed to understand properly. Is it used for rounding in `java.math.BigDecimal`. If yes why does not it round the decimal digits but even mantissa part.

From API docs, I came to know that it follows the standard specified in `ANSI X3.274-1996` and `ANSI X3.274-1996/AM 1-2000` specifications but I did not get them to read online.

Please let me know if you have any idea on this.





Use of java.math.MathContext

Actually, I&#39;ve found possible solution 

    //returns true
    new BigDecimal(&quot;5.50&quot;).doubleValue() == new BigDecimal(&quot;5.5&quot;).doubleValue()

Of course, it can be improved with something like `Math.abs (v1 - v2) &lt; EPS` to make the comparison more robust, but the question is whether this technique acceptable or is there a better solution?

If someone knows why java designers decided to implement BigDecimal&#39;s equals in that way, it would be interesting to read.

Why BigDecimal(&quot;5.50&quot;) not equals to BigDecimal(&quot;5.5&quot;) and how to work around this issue?

I have this String: 10,692,467,440,017.120 (it&#39;s an amount).

I want to parse it to a BigDecimal. The problem is that I have tried both DecimalFormat and NumbeFormat in vain.

How can I parse a String to BigDecimal?

`BigDecimal` is a class in the `java.math` package that has a lot of benefits for handling big numbers of a certain scale. Is there an equivalent class or data type in c# with this feature.

What is the equivalent of the Java BigDecimal class in C#?

When dealing with real world monetary values, I am advised to use BigDecimal instead of Double.But I have not got a convincing explanation except, &quot;It is normally done that way&quot;.

Can you please throw light on this question?

Java:Why should we use BigDecimal instead of Double in the real world?

My code sample:

    import java.math.*; 
    
    public class x
    {
      public static void main(String[] args)
      {
    	BigDecimal a = new BigDecimal(&quot;1&quot;);
    	BigDecimal b = new BigDecimal(&quot;3&quot;);
    	BigDecimal c = a.divide(b, BigDecimal.ROUND_HALF_UP);
    	System.out.println(a+&quot;/&quot;+b+&quot; = &quot;+c);
      }
    }

The result is:
`1/3 = 0`

What am I doing wrong?

How can I divide properly using BigDecimal

I am performing a simple multiplication with BigDecimal and I have found some strange behaviour when multiplying by zero (multiplying by zero is correct in this use-case).

Basic maths tells me that anything multiplied by zero will equal zero (see:[Zero Product Property][1] and [Multiplication Properties][2])

However, the following code will consistently fail with the same error:

    assertEquals(new BigDecimal(0), new BigDecimal(22.3).multiply(new BigDecimal(0)));


&gt;     java.lang.AssertionError: 
&gt;     Expected :0
&gt;     Actual   :0E-48

Is this an inaccuracy with BigDecimal or is there some niche branch of maths that I&#39;m missing somewhere?

Notes: JDK 1.6.0_27 running in IntelliJ 11

  [1]: http://en.wikipedia.org/wiki/Zero-product_property
  [2]: http://en.wikipedia.org/wiki/Multiplication#Properties

BigDecimal multiply by zero

I am looking for the best way to convert a Number to a BigDecimal.

Is this good enough?

    Number number;
    BigDecimal big = new BigDecimal(number.toString());

Can we lose precision with the `toString()` method ?

All Bigdecimal Solutions on Gang of Coders

Total of 49 Bigdecimal Solutions