You have two BigDecimal numbers both of which require over a 1000 decimal places. Trying to set the scale to only have 113 decimal places means you will lose precision and therefore you need to round. 

You can use the setScale methods that take a RoundingMode to prevent the exception but not the rounding.

Try to use roudingMode of setScale method.&lt;br&gt;

Some thing like:

    BigDecimal aa = a.setScale(i+j, BigDecimal.ROUND_HALF_DOWN);



Rounding is necessary.  

In [javadoc for BigDecimal][1], it says `BigDecimal` is represented as (unscaledValue &#215; 10&lt;sup&gt;-scale&lt;/sup&gt;), where `unscaledValue` is an arbitatrily long integer and scale is a 32-bit integer.

2.6*10&lt;sup&gt;-1095&lt;/sup&gt; requires a scale of at least 1096 to represent accurately. It can not be represented accurately with (any integer)*10&lt;sup&gt;-113&lt;/sup&gt;. Therefore, you need to providing a `roundingMode`.


  [1]: http://docs.oracle.com/javase/8/docs/api/java/math/BigDecimal.html

Usually, an OCaml program can be written with or without objects. When is it most beneficial to use objects, and when should they be avoided? 

When should objects be used in OCaml?

Does the typical `malloc` (for x86-64 platform and Linux OS) naively lock a mutex at the beginning and release it when done, or does it lock a mutex in a more clever way at a finer level, so that lock contention is reduced? If it indeed does it the second way, how does it do it?

How does malloc work in a multithreaded environment?


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

I want to set scale of two BigDecimal numbers <code>a</code> and <code>b</code> . as in this example :
<pre><code class="hljs language-ini">BigDecimal a = new BigDecimal("2.6E-1095");
 BigDecimal b = new BigDecimal("2.7E-1105");
 int i = 112, j=1;

 BigDecimal aa = a.setScale(i+j);
 BigDecimal bb = b.setScale(i+j);
</code></pre>
and when i run i have this exception:
<pre><code class="hljs language-css">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)
</code></pre>
Why rounding is necessary ? if i don't want to make around, what is solution please ?
Thanks

In the documentation of Android [TextureView](http://developer.android.com/reference/android/view/TextureView.html) it says that you can use a TextureView to play video: 
But I cant seem to find any example of how to do this. Does anyone know? 

I need to use a `textureView` because I want to animate the video. I want to play a video in .3gp/.mp4 format, not video from the Camera :)

Any help would be appreciated..


UPDATE:

Solution is posted as a community wiki answer


Playing video on TextureView

if some one can explain what this annotation do and when exactly we use it :

    @Transactional(propagation=Propagation.REQUIRED)

Thanks



@Transactional(propagation=Propagation.REQUIRED)

Which advantages/disadvantages we can get by making ArrayList (or other Collection) final? I still can add to ArrayList new elements, remove elements and update it. But what is effect making it&#39;s final? 

what is the sense of final ArrayList?

Does a Java Set retain order?  A method is returning a Set to me and supposedly the data is ordered but iterating over the Set, the data is unordered.  Is there a better way to manage this? Does the method need to be changed to return something other than a Set?

Java Set retain order?

I have the method below.

	public Profile readUser(String email){
		EntityManager em = EMF.get().createEntityManager();
		return em.find(Profile.class, email);
	}

Is the above usage of entity manager okay? Or It is necessary to close em?Any suggestions please.

Should JPA Entity Manager be closed?

I was just re-reading [What’s New In Python 3.0][1] and it states:

&gt; The round() function rounding strategy and return type have changed.
&gt; Exact halfway cases are now rounded to the nearest even result instead
&gt; of away from zero. (For example, round(2.5) now returns 2 rather than
&gt; 3.)

and
the documentation for [round][2]:

&gt; For the built-in types supporting round(), values are rounded to the
&gt; closest multiple of 10 to the power minus n; if two multiples are
&gt; equally close, rounding is done toward the even choice


So, under **v2.7.3**:

    In [85]: round(2.5)
    Out[85]: 3.0
    
    In [86]: round(3.5)
    Out[86]: 4.0

as I&#39;d have expected. However, now under **v3.2.3**:

    In [32]: round(2.5)
    Out[32]: 2
    
    In [33]: round(3.5)
    Out[33]: 4

This seems counter-intuitive and contrary to what I understand about
rounding (and bound to trip up people). English isn&#39;t my native language but
until I read this I thought I knew what rounding meant :-/  I am sure
at the time v3 was introduced there must have been some discussion of
this, but I was unable to find a good reason in my search.

 1. Does anyone have insight into why this was changed to this?
 2. Are there any other mainstream programming languages (e.g., *C, C++, Java, Perl,* ..) that do this sort of (to  me inconsistent) rounding?

What am I missing here?

UPDATE: @Li-aungYip&#39;s comment re &quot;Banker&#39;s rounding&quot; gave me the right search term/keywords to search for and I found this SO question: https://stackoverflow.com/questions/311696/why-does-net-use-bankers-rounding-as-default, so I will be reading that carefully.



  [1]: http://docs.python.org/py3k/whatsnew/3.0.html
  [2]: http://docs.python.org/release/3.1.5/library/functions.html#round

Python 3.x rounding behavior

Is there a function that can truncate or round a Double?  At one point in my code I would like a number like: `1.23456789` to be rounded to `1.23`

Scala Doubles, and Precision

I need to round floating point numbers up to the nearest integer, even if the number after the point is less than 0.5.

For example,

 - 4.3 should be 5 (not 4)  
 - 4.8 should be 5

How can I do this in JavaScript?

Round a float up to the next integer in javascript

Using T-SQL and Microsoft SQL Server I would like to specify the number of decimal digits when I do a division between 2 integer numbers like:

    select 1/3

That currently returns `0`. I would like it to return `0,33`.

Something like:

    select round(1/3, -2)

But that doesn&#39;t work. How can I achieve the desired result?

How to get a float result by dividing two integer values using T-SQL?

I&#39;d like to round at most two decimal places, but *only if necessary*.

Input:

    10
    1.7777777
    9.1

Output:

    10
    1.78
    9.1

How can I do this in JavaScript?




How to round to at most 2 decimal places, if necessary

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 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

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 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 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;
       }

Content Type	Original Author	Original Content on Stackoverflow
Question	Mehdi	View Question on Stackoverflow
Solution 1 - Java	brain	View Answer on Stackoverflow
Solution 2 - Java	Akostha	View Answer on Stackoverflow
Solution 3 - Java	Haozhun	View Answer on Stackoverflow

Rounding necessary with BigDecimal numbers

Java Problem Overview

Java Solutions

Solution 1 - Java

Solution 2 - Java

Solution 3 - Java

How does malloc work in a multithreaded environment?

When should objects be used in OCaml?

Attributions