Java floating point Exact Calculation

(1) Precise Floating Point Calculation
There has always been a problem in the Three-flow Integration Project of Shengli Oilfield, that is, the amount of materials and the actual amount calculated in each report must be a fraction of the money, which is different from the actual amount, this makes customers feel uncomfortable because we use the Double Floating Point Type of Java to define the material amount, and we often need to perform some operations in report statistics, however, the calculation of Floating Point Numbers (double and float) in Java is not accurate. See the following example:

1. System. Out. println (0.05 + 0.01 );
2. System. Out. println (1.0-0.42 );
3. System. Out. println (4.015*100 );
4. System. Out. println (123.3/100 );

Copy code

What is your expected output? The actual output is as follows:

1. 0.060000000000000005
2. 0.5800000000000001
3. 401.49999999999994
4. 1.2329999999999999

Copy code

This problem is very serious. If you have 123.3 yuan to buy goods, but the computer thinks you only have 123.29999999999999 yuan, the money is not enough, and the computer refuses to trade.
(2) Rounding
Can it be rounded in? Of course we can. In our habits, we will think like this, But rounding means an error, and commercial operations may mean an error. At the same time, Java does not provide a rounding method that retains the specified number of digits, only one math is provided. round (double D) and math. the round (float f) method returns the long integer and integer values respectively. The round method cannot be set to retain a few decimal places. We can only keep two digits as follows ):

1. Public double round (double value ){
2. Return math. Round (value * 100)/100.0;
3. }

Copy code

But unfortunately, the above Code does not work normally. If you pass 4.015 to this method, it will return 4.01 instead of 4.02, as shown in the preceding figure.

1. 4.015*100 = 401.49999999999994

Copy code

Therefore, this method cannot meet our requirements for accurate rounding.
Another method is to use Java. text. decimalformat, but there are also problems. The format adopts the round_half_down round mode (the round mode is described below). For example, if 4.025 is reserved, the two decimal places will be 4.02, because. 025 distance from "Nearest Neighbor "(. 02 and. 03) the length is equal, and the rounding down is. 02. If it is 4.0251, the two decimal places reserved are 4.03.

1. System. Out. println (New java. Text. decimalformat ("0.00"). Format (4.025 ));
2. System. Out. println (New java. Text. decimalformat ("0.00"). Format (4.0251 ));

Copy code

The output is

1. 4.02
2. 4.03

Copy code

(3) floating point output (Scientific note)
If the Java floating point value is greater than 9999999.0, it is automatically converted to scientific notation. Let's look at the following example:

1. System. Out. println (999999999.04 );
2. System. Out. println (99999999.04 );
3. System. Out. println (10000000.01 );
4. System. Out. println (9999999.04 );

Copy code

The output result is as follows:

1. 9.9999999904e8
2. 9.999999904e7
3. 1.20.00001e7
4. 9999999.04

Copy code

However, sometimes we do not need to use the scientific notation to convert it into a string, and cannot directly use tostring () or other methods to convert it.
About bigdecimal

Bigdecimal is a constant, any-precision signed decimal number object provided by Java. It provides four constructors, two of which are constructed using biginteger, which we don't care about here, we will focus on the two constructors constructed with double and string (for more information about biginteger, see j2se API documentation ).

1. Bigdecimal (double Val)
2. Translates a double into a bigdecimal.
3. Bigdecimal (string Val)
4. Translates the string representation of a bigdecimal into a bigdecimal.

Copy code

Bigdecimal (double) refers to the construction of a double type decimal number as a bigdecimal object instance.
Bigdecimal (string) is to construct a bigdecimal object represented by string as a bigdecimal object instance.
In practice, we define floating point numbers as double or float, but the bigdecimal (double) API document has the following sentence:
Note: The results of this constructor can be somewhat unpredictable. one might assume that new bigdecimal (. 1) is exactly equal. 1, but it is actually equal. 10000000000000000555111512312578 27021181583404541015625. this is so because
. 1 cannot be represented exactly as a double (or, for that matter, as a binary fraction of any finite length ). thus, the long value that is being passed in to the constructor is not exactly equal. 1, appearances notwithstanding.
The (string) constructor, on the other hand, is perfectly predictable: New bigdecimal (". 1 ") is exactly equal. 1, as one wocould CT. therefore, it is generally recommended that the (string) constructor be used in preference to this one
The following is a simple explanation of this passage:
Note: The constructor may have unpredictable results. Someone may imagine new bigdecimal (. 1) equal. 1 is correct, but it is actually equal. 1000000000000000055511151231257827021181583404541015625, that's why. 1 cannot be exactly represented by a double. Therefore, the long value put into the constructor is not exactly equal. 1, although the appearance looks equal.
However, the (string) constructor is completely predictable. New bigdecimal (". 1 ") exact equals as expected. 1. Therefore, the (string) constructor is recommended first.
See the following results:

1. System. Out. println (New bigdecimal (123456789.02). tostring ());
2. System. Out. println (New bigdecimal ("123456789.02"). tostring ());

Copy code

Output:

1. 123456789.01999999582767486572265625
2. 123456789.02

Copy code

Now we know that if exact calculation is required, you must use string to create bigdecimal!
Implementation Scheme

Now we know how to solve this problem. In principle, we use the bigdecimal (string) constructor. We recommend that you use data involving floating point numbers such as amounts in commercial application development, all are defined as string, which can be defined as character fields in the database. When you need to use this data for computation, use bigdecimal (string) to construct a bigdecimal object for computation to ensure accurate data computation. It also avoids the emergence of scientific notation. If scientific notation is not a burden in applications, you can consider defining it as a floating point type.

Here we provide a tool class that defines the addition, subtraction, multiplication, division, and rounding of floating point numbers. For reference.
Source File mathextend. Java:

1. Import java. Math. bigdecimal;
2. Public class mathextend
3. {
4. // Default division operation precision
5. Private Static final int default_div_scale = 10;
7. /**
8. * Provides precise addition operations.
9. * @ Param V1
10. * @ Param v2
11. * @ Return the sum of the two parameters
12. */
13. Public static double add (double V1, double V2)
14. {
15. Bigdecimal b1 = new bigdecimal (double. tostring (V1 ));
16. Bigdecimal b2 = new bigdecimal (double. tostring (V2 ));
17. Return b1.add (B2). doublevalue ();
18. }
19. /**
20. * Provides accurate addition operations
21. * @ Param V1
22. * @ Param v2
23. * @ Return mathematical Addition of two parameters, returned in string format
24. */
25. Public static string add (string V1, string V2)
26. {
27. Bigdecimal b1 = new bigdecimal (V1 );
28. Bigdecimal b2 = new bigdecimal (V2 );
29. Return b1.add (B2). tostring ();
30. }
32. /**
33. * Provides precise subtraction operations.
34. * @ Param V1
35. * @ Param v2
36. * @ Return Difference Between Two Parameters
37. */
38. Public static double subtract (double V1, double V2)
39. {
40. Bigdecimal b1 = new bigdecimal (double. tostring (V1 ));
41. Bigdecimal b2 = new bigdecimal (double. tostring (V2 ));
42. Return b1.subtract (B2). doublevalue ();
43. }
45. /**
46. * Provides precise subtraction.
47. * @ Param V1
48. * @ Param v2
49. * @ Return: returns the mathematical difference between two parameters in string format.
50. */
51. Public static string subtract (string V1, string V2)
52. {
53. Bigdecimal b1 = new bigdecimal (V1 );
54. Bigdecimal b2 = new bigdecimal (V2 );
55. Return b1.subtract (B2). tostring ();
56. }
59. /**
60. * Provides precise multiplication.
61. * @ Param V1
62. * @ Param v2
63. * @ Return the product of two parameters
64. */
65. Public static double multiply (double V1, double V2)
66. {
67. Bigdecimal b1 = new bigdecimal (double. tostring (V1 ));
68. Bigdecimal b2 = new bigdecimal (double. tostring (V2 ));
69. Return b1.multiply (B2). doublevalue ();
70. }
72. /**
73. * Accurate Multiplication
74. * @ Param V1
75. * @ Param v2
76. * @ Return mathematical product of the two parameters, returned in string format
77. */
78. Public static string multiply (string V1, string V2)
79. {
80. Bigdecimal b1 = new bigdecimal (V1 );
81. Bigdecimal b2 = new bigdecimal (V2 );
82. Return b1.multiply (B2). tostring ();
83. }
85. /**
86. * Provides (relatively) accurate Division operations, accurate
87. * 10 digits after the decimal point, rounded to the next digit. round_half_even is used for rounding.
88. * @ Param V1
89. * @ Param v2
90. * @ Return parameter vendors
91. */
92. Public static double divide (double V1, double V2)
93. {
94. Return divide (V1, V2, default_div_scale );
95. }
97. /**
98. * Provides (relatively) accurate Division operations. In case of division, the scale parameter indicates
99. * Set the precision. The number is rounded down. Round_half_even is used for rounding.
100. * @ Param V1
101. * @ Param v2
102. * @ Param scale indicates the number of digits after the decimal point.
103. * @ Return parameter vendors
104. */
105. Public static double divide (double V1, double V2, int scale)
106. {
107. Return divide (V1, V2, scale, bigdecimal. round_half_even );
108. }
110. /**
111. * Provides (relatively) accurate Division operations. In case of division, the scale parameter indicates
112. * Set the precision. The number is rounded down. The rounding mode is specified by the user.
113. * @ Param V1
114. * @ Param v2
115. * @ Param scale indicates the number of digits after the decimal point.
116. * @ Param round_mode indicates the rounding mode specified by the user.
117. * @ Return parameter vendors
118. */
119. Public static double divide (double V1, double V2, int scale, int round_mode ){
120. If (scale <0)
121. {
122. Throw new illegalargumentexception ("the scale must be a positive integer or zero ");
123. }
124. Bigdecimal b1 = new bigdecimal (double. tostring (V1 ));
125. Bigdecimal b2 = new bigdecimal (double. tostring (V2 ));
126. Return b1.divide (B2, scale, round_mode). doublevalue ();
127. }
129. /**
130. * Provides (relatively) accurate Division operations, accurate
131. * 10 digits after the decimal point, rounded to the next digit. round_half_even is used for rounding.
132. * @ Param V1
133. * @ Param v2
134. * @ Return refers to the operator of two parameters, which are returned in string format.
135. */
136. Public static string divide (string V1, string V2)
137. {
138. Return divide (V1, V2, default_div_scale );
139. }
141. /**
142. * Provides (relatively) accurate Division operations. In case of division, the scale parameter indicates
143. * Set the precision. The number is rounded down. Round_half_even is used for rounding.
144. * @ Param V1
145. * @ Param v2
146. * @ Param scale indicates the number of digits after the decimal point.
147. * @ Return refers to the operator of two parameters, which are returned in string format.
148. */
149. Public static string divide (string V1, string V2, int scale)
150. {
151. Return divide (V1, V2, default_div_scale, bigdecimal. round_half_even );
152. }
154. /**
155. * Provides (relatively) accurate Division operations. In case of division, the scale parameter indicates
156. * Set the precision. The number is rounded down. The rounding mode is specified by the user.
157. * @ Param V1
158. * @ Param v2
159. * @ Param scale indicates the number of digits after the decimal point.
160. * @ Param round_mode indicates the rounding mode specified by the user.
161. * @ Return refers to the operator of two parameters, which are returned in string format.
162. */
163. Public static string divide (string V1, string V2, int scale, int round_mode)
164. {
165. If (scale <0)
166. {
167. Throw new illegalargumentexception ("the scale must be a positive integer or zero ");
168. }
169. Bigdecimal b1 = new bigdecimal (V1 );
170. Bigdecimal b2 = new bigdecimal (V2 );
171. Return b1.divide (B2, scale, round_mode). tostring ();
172. }
174. /**
175. * Provides precise decimal point rounding. The rounding mode adopts round_half_even.
176. * @ Param V refers to the number rounded up.
177. * @ Param scale: number of digits after the decimal point
178. * @ Return returns the result after rounding.
179. */
180. Public static double round (Double V, int scale)
181. {
182. Return round (v, scale, bigdecimal. round_half_even );
183. }
184. /**
185. * Provides precise rounding of decimal places.
186. * @ Param V refers to the number rounded up.
187. * @ Param scale: number of digits after the decimal point
188. * @ Param round_mode the specified rounding mode
189. * @ Return returns the result after rounding.
190. */
191. Public static double round (Double V, int scale, int round_mode)
192. {
193. If (scale <0)
194. {
195. Throw new illegalargumentexception ("the scale must be a positive integer or zero ");
196. }
197. Bigdecimal B = new bigdecimal (double. tostring (V ));
198. Return B. setscale (scale, round_mode). doublevalue ();
199. }
201. /**
202. * Provides precise decimal point rounding. The rounding mode adopts round_half_even.
203. * @ Param V refers to the number rounded up.
204. * @ Param scale: number of digits after the decimal point
205. * @ Return returns the result after rounding, in string format
206. */
207. Public static string round (string V, int scale)
208. {
209. Return round (v, scale, bigdecimal. round_half_even );
210. }
211. /**
212. * Provides precise rounding of decimal places.
213. * @ Param V refers to the number rounded up.
214. * @ Param scale: number of digits after the decimal point
215. * @ Param round_mode the specified rounding mode
216. * @ Return returns the result after rounding, in string format
217. */
218. Public static string round (string V, int scale, int round_mode)
219. {
220. If (scale <0)
221. {
222. Throw new illegalargumentexception ("the scale must be a positive integer or zero ");
223. }
224. Bigdecimal B = new bigdecimal (v );
225. Return B. setscale (scale, round_mode). tostring ();
226. }
227. }

Copy code

Introduction to the bigdecimal round mode:

Bigdecimal defines the rounding mode, which is used only when Division operations or rounding are performed. For more information, see j2se API documentation.
Static int
Round_ceiling
Rounding mode to Round towards positive infinity.
Round to positive infinity
Static int
Round_down
Rounding mode to Round towards zero.
Round to zero
Static int
Round_floor
Rounding mode to Round towards negative infinity.
Round to negative infinity
Static int
Round_half_down
Rounding mode to Round towards "Nearest Neighbor" unless both neighbors are equidistant, in which case round down.
Round to the nearest side, unless the two sides (distance) are equal. If so, round down. For example, 1.55 retains a decimal number and returns 1.5.
Static int
Round_half_even
Rounding mode to Round towards the "Nearest Neighbor" unless both neighbors are equidistant, in which case, Round towards the even neighbor.
Round to the nearest side (distance), unless the two sides (distance) are equal. If so, use round_half_up if the reserved digits are odd. If the reserved digits are even, use round_half_down.
Static int
Round_half_up
Rounding mode to Round towards "Nearest Neighbor" unless both neighbors are equidistant, in which case round up.
Round to the nearest side (distance), unless the two sides (distance) are equal, if so, round up, 1.55 retains a decimal number and returns 1.6
Static int
Round_unnecessary
Rounding mode to assert that the requested operation has an exact result, hence no rounding is necessary.
The calculation result is accurate, and the rounding mode is not required.
Static int
Round_up
Rounding mode to round away from zero.
Round to the direction away from 0