java.math.BigDecimal source code

1 module java.math.BigDecimal;
2 
3 import java.lang.all;
4 import java.math.BigInteger;
5 
6 class BigDecimal : Number {
7     static int ROUND_CEILING;
8     static int ROUND_DOWN;
9     static int ROUND_FLOOR;
10     static int ROUND_HALF_DOWN;
11     static int ROUND_HALF_EVEN;
12     static int ROUND_HALF_UP;
13     static int ROUND_UNNECESSARY;
14     static int ROUND_UP;
15 
16     private BigInteger intVal;
17     private int scale_;
18     private int intCompact;
19     private int precision;
20     private static const MAX_BIGINT_BITS = 62;
21 
22     this(BigInteger val){
23         implMissing(__FILE__, __LINE__);
24     }
25     this(BigInteger unscaledVal, int scale_){
26         this.intVal = unscaledVal;
27         this.scale_ = scale_;
28     }
29     this(double val){
30         if (double.nan is val || double.infinity is val )
31             throw new NumberFormatException("Infinite or NaN");
32 
33         // Translate the double into sign, exponent and significand, according
34         // to the formulae in JLS, Section 20.10.22.
35         long valBits = *cast(long*) & val;
36         int sign = ((valBits >> 63)==0 ? 1 : -1);
37         int exponent = cast(int) ((valBits >> 52) & 0x7ffL);
38         long significand = (exponent==0 ? (valBits & ((1L<<52) - 1)) << 1
39                             : (valBits & ((1L<<52) - 1)) | (1L<<52));
40         exponent -= 1075;
41         // At this point, val == sign * significand * 2**exponent.
42 
43         /*
44          * Special case zero to supress nonterminating normalization
45          * and bogus scale calculation.
46          */
47         if (significand == 0) {
48             intVal = cast(BigInteger) BigInteger.ZERO;
49             intCompact = 0;
50             precision = 1;
51             return;
52         }
53 
54         // Normalize
55         while((significand & 1) == 0) {    //  i.e., significand is even
56             significand >>= 1;
57             exponent++;
58         }
59 
60         // Calculate intVal and scale
61         intVal = BigInteger.valueOf(sign*significand);
62         if (exponent < 0) {
63             intVal = intVal.multiply(BigInteger.valueOf(5).pow(-exponent));
64             scale_ = -exponent;
65         } else if (exponent > 0) {
66             intVal = intVal.multiply(BigInteger.valueOf(2).pow(exponent));
67         }
68         if (intVal.bitLength() <= MAX_BIGINT_BITS) {
69             intCompact = cast(int)intVal.longValue();
70         }
71     }
72     this(String val){
73         implMissing(__FILE__, __LINE__);
74     }
75     BigDecimal abs(){
76         implMissing(__FILE__, __LINE__);
77         return null;
78     }
79     BigDecimal add(BigDecimal val){
80         implMissing(__FILE__, __LINE__);
81         return null;
82     }
83     int compareTo(BigDecimal val){
84         implMissing(__FILE__, __LINE__);
85         return 0;
86     }
87     int compareTo(Object o){
88         implMissing(__FILE__, __LINE__);
89         return 0;
90     }
91     BigDecimal divide(BigDecimal val, int roundingMode){
92         implMissing(__FILE__, __LINE__);
93         return null;
94     }
95     BigDecimal divide(BigDecimal val, int scale_, int roundingMode){
96         implMissing(__FILE__, __LINE__);
97         return null;
98     }
99     override
100     double doubleValue(){
101         implMissing(__FILE__, __LINE__);
102         return 0;
103     }
104     bool equals(Object x){
105         implMissing(__FILE__, __LINE__);
106         return 0;
107     }
108     override
109     float floatValue(){
110         implMissing(__FILE__, __LINE__);
111         return 0;
112     }
113     int hashCode(){
114         implMissing(__FILE__, __LINE__);
115         return 0;
116     }
117     override
118     int intValue(){
119         implMissing(__FILE__, __LINE__);
120         return 0;
121     }
122     override
123     long longValue(){
124         implMissing(__FILE__, __LINE__);
125         return 0;
126     }
127     BigDecimal max(BigDecimal val){
128         implMissing(__FILE__, __LINE__);
129         return null;
130     }
131     BigDecimal min(BigDecimal val){
132         implMissing(__FILE__, __LINE__);
133         return null;
134     }
135     BigDecimal movePointLeft(int n){
136         implMissing(__FILE__, __LINE__);
137         return null;
138     }
139     BigDecimal movePointRight(int n){
140         implMissing(__FILE__, __LINE__);
141         return null;
142     }
143     BigDecimal multiply(BigDecimal val){
144         implMissing(__FILE__, __LINE__);
145         return null;
146     }
147     BigDecimal negate(){
148         implMissing(__FILE__, __LINE__);
149         return null;
150     }
151     int scale(){
152         implMissing(__FILE__, __LINE__);
153         return this.scale_;
154     }
155     BigDecimal setScale(int scale_){
156         implMissing(__FILE__, __LINE__);
157         return null;
158     }
159     BigDecimal setScale(int scale_, int roundingMode){
160         implMissing(__FILE__, __LINE__);
161         return null;
162     }
163     int signum(){
164         implMissing(__FILE__, __LINE__);
165         return 0;
166     }
167     BigDecimal subtract(BigDecimal val){
168         implMissing(__FILE__, __LINE__);
169         return null;
170     }
171     BigInteger toBigInteger(){
172         implMissing(__FILE__, __LINE__);
173         return null;
174     }
175     override
176     String toString(){
177         implMissing(__FILE__, __LINE__);
178         return null;
179     }
180     BigInteger unscaledValue(){
181         implMissing(__FILE__, __LINE__);
182         return null;
183     }
184     static BigDecimal valueOf(long val){
185         implMissing(__FILE__, __LINE__);
186         return null;
187     }
188     static BigDecimal valueOf(long unscaledVal, int scale_){
189         implMissing(__FILE__, __LINE__);
190         return null;
191     }
192 }
193