1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
|
/* __ *\
** ________ ___ / / ___ Scala API **
** / __/ __// _ | / / / _ | (c) 2007-2008, LAMP/EPFL **
** __\ \/ /__/ __ |/ /__/ __ | http://scala-lang.org/ **
** /____/\___/_/ |_/____/_/ | | **
** |/ **
\* */
// $Id$
package scala
import java.math.{BigDecimal => BigDec}
/**
* @author Stephane Micheloud
* @version 1.0
*/
object BigDecimal {
@serializable
object RoundingMode extends Enumeration {
type RoundingMode = Value
val ROUND_UP, ROUND_DOWN, ROUND_CEILING, ROUND_FLOOR, ROUND_HALF_UP,
ROUND_HALF_DOWN, ROUND_HALF_EVEN, ROUND_UNNECESSARY = Value
}
private val minCached = -512
private val maxCached = 512
private lazy val cache = new Array[BigDecimal](maxCached - minCached + 1)
/** Constructs a <code>BigDecimal</code> whose value is equal to that of the
* specified <code>Integer</code> value.
*
* @param i the specified integer value
* @return the constructed <code>BigDecimal</code>
*/
def apply(i: Int): BigDecimal =
if (minCached <= i && i <= maxCached) {
val offset = i - minCached
var n = cache(offset)
if (n eq null) { n = new BigDecimal(BigDec.valueOf(i)); cache(offset) = n }
n
} else new BigDecimal(BigDec.valueOf(i))
/** Constructs a <code>BigDecimal</code> whose value is equal to that of the
* specified long value.
*
* @param l the specified long value
* @return the constructed <code>BigDecimal</code>
*/
def apply(l: Long): BigDecimal =
if (minCached <= l && l <= maxCached) apply(l.toInt)
else new BigDecimal(BigDec.valueOf(l))
/** Constructs a <code>BigDecimal</code> whose value is equal to that of the
* specified double value.
*
* @param d the specified <code>Double</code> value
* @return the constructed <code>BigDecimal</code>
*/
def apply(d: Double): BigDecimal =
new BigDecimal(new BigDec(d))
/** Translates a character array representation of a <code>BigDecimal</code>
* into a <code>BigDecimal</code>.
*/
def apply(x: Array[Char]): BigDecimal =
new BigDecimal(new BigDec(x.toString))
/** Translates the decimal String representation of a <code>BigDecimal</code>
* into a <code>BigDecimal</code>.
*/
def apply(x: String): BigDecimal =
new BigDecimal(new BigDec(x))
/** Constructs a <code>BigDecimal</code> whose value is equal to that of the
* specified <code>BigInt</code> value.
*
* @param x the specified <code>BigInt</code> value
* @return the constructed <code>BigDecimal</code>
*/
def apply(x: BigInt): BigDecimal =
new BigDecimal(new BigDec(x.bigInteger))
/** Implicit conversion from <code>Int</code> to <code>BigDecimal</code>. */
implicit def int2bigDecimal(i: Int): BigDecimal = apply(i)
/** Implicit conversion from <code>Long</code> to <code>BigDecimal</code>. */
implicit def long2bigDecimal(l: Long): BigDecimal = apply(l)
/** Implicit conversion from <code>Double</code> to <code>BigDecimal</code>. */
implicit def double2bigDecimal(d: Double): BigDecimal = apply(d)
/** Implicit conversion from BigDecimal to <code>Ordered</code>. */
implicit def bigDecimal2ordered(x: BigDecimal): Ordered[BigDecimal] =
new Ordered[BigDecimal] with Proxy {
def self: Any = x
def compare(y: BigDecimal): Int = x.bigDecimal.compareTo(y.bigDecimal)
}
}
/**
* @author Stephane Micheloud
* @version 1.0
*/
@serializable
class BigDecimal(val bigDecimal: BigDec) extends java.lang.Number {
import BigDecimal.RoundingMode._
/** Returns the hash code for this BigDecimal. */
override def hashCode(): Int = this.bigDecimal.hashCode()
/** Compares this BigDecimal with the specified value for equality.
*/
override def equals(that: Any): Boolean = that match {
case that: BigDecimal => this equals that
case that: java.lang.Double => this.bigDecimal.doubleValue == that.doubleValue
case that: java.lang.Float => this.bigDecimal.floatValue == that.floatValue
case that: java.lang.Number => this equals BigDecimal(that.longValue)
case that: java.lang.Character => this equals BigDecimal(that.charValue.asInstanceOf[Int])
case _ => false
}
/** Compares this BigDecimal with the specified BigDecimal for equality.
*/
def equals (that: BigDecimal): Boolean =
this.bigDecimal.compareTo(that.bigDecimal) == 0
/** Compares this BigDecimal with the specified BigDecimal
*/
def compare (that: BigDecimal): Int = this.bigDecimal.compareTo(that.bigDecimal)
/** Less-than-or-equals comparison of BigDecimals
*/
def <= (that: BigDecimal): Boolean = this.bigDecimal.compareTo(that.bigDecimal) <= 0
/** Greater-than-or-equals comparison of BigDecimals
*/
def >= (that: BigDecimal): Boolean = this.bigDecimal.compareTo(that.bigDecimal) >= 0
/** Less-than of BigDecimals
*/
def < (that: BigDecimal): Boolean = this.bigDecimal.compareTo(that.bigDecimal) < 0
/** Greater-than comparison of BigDecimals
*/
def > (that: BigDecimal): Boolean = this.bigDecimal.compareTo(that.bigDecimal) > 0
/** Addition of BigDecimals
*/
def + (that: BigDecimal): BigDecimal =
new BigDecimal(this.bigDecimal.add(that.bigDecimal))
/** Subtraction of BigDecimals
*/
def - (that: BigDecimal): BigDecimal =
new BigDecimal(this.bigDecimal.subtract(that.bigDecimal))
/** Multiplication of BigDecimals
*/
def * (that: BigDecimal): BigDecimal =
new BigDecimal(this.bigDecimal.multiply(that.bigDecimal))
/** Division of BigDecimals
*/
def / (that: BigDecimal): BigDecimal =
new BigDecimal(this.bigDecimal.divide(that.bigDecimal))
/** Returns the minimum of this and that
*/
def min (that: BigDecimal): BigDecimal =
new BigDecimal(this.bigDecimal.min(that.bigDecimal))
/** Returns the maximum of this and that
*/
def max (that: BigDecimal): BigDecimal =
new BigDecimal(this.bigDecimal.max(that.bigDecimal))
/** Returns a BigDecimal whose value is the negation of this BigDecimal
*/
def unary_- : BigDecimal = new BigDecimal(this.bigDecimal.negate())
/** Returns the absolute value of this BigDecimal
*/
def abs: BigDecimal = new BigDecimal(this.bigDecimal.abs())
/** Returns the sign of this BigDecimal, i.e.
* -1 if it is less than 0,
* +1 if it is greater than 0
* 0 if it is equal to 0
*/
def signum: Int = this.bigDecimal.signum()
/** Returns the scale of this <code>BigDecimal</code>.
*/
def scale: Int = this.bigDecimal.scale()
/** Returns a <code>BigDecimal</code> whose scale is the specified value, and whose value is
* numerically equal to this BigDecimal's.
*/
def setScale(scale: Int): BigDecimal =
new BigDecimal(this.bigDecimal setScale scale)
def setScale(scale: Int, mode: RoundingMode): BigDecimal =
new BigDecimal(this.bigDecimal.setScale(scale, mode.id))
/** Converts this BigDecimal to a <tt>byte</tt>.
* If the BigDecimal is too big to fit in a byte, only the low-order 8 bits are returned.
* Note that this conversion can lose information about the overall magnitude of the
* BigDecimal value as well as return a result with the opposite sign.
*/
override def byteValue = intValue.toByte
/** Converts this BigDecimal to a <tt>short</tt>.
* If the BigDecimal is too big to fit in a byte, only the low-order 16 bits are returned.
* Note that this conversion can lose information about the overall magnitude of the
* BigDecimal value as well as return a result with the opposite sign.
*/
override def shortValue = intValue.toShort
/** Converts this BigDecimal to a <tt>char</tt>.
* If the BigDecimal is too big to fit in a char, only the low-order 16 bits are returned.
* Note that this conversion can lose information about the overall magnitude of the
* BigDecimal value and that it always returns a positive result.
*/
def charValue = intValue.toChar
/** Converts this BigDecimal to an <tt>int</tt>.
* If the BigDecimal is too big to fit in a char, only the low-order 32 bits
* are returned. Note that this conversion can lose information about the
* overall magnitude of the BigDecimal value as well as return a result with
* the opposite sign.
*/
def intValue = this.bigDecimal.intValue
/** Converts this BigDecimal to a <tt>Long</tt>.
* If the BigDecimal is too big to fit in a char, only the low-order 64 bits
* are returned. Note that this conversion can lose information about the
* overall magnitude of the BigDecimal value as well as return a result with
* the opposite sign.
*/
def longValue = this.bigDecimal.longValue
/** Converts this BigDecimal to a <tt>float</tt>.
* if this BigDecimal has too great a magnitude to represent as a float,
* it will be converted to <code>Float.NEGATIVE_INFINITY</code> or
* <code>Float.POSITIVE_INFINITY</code> as appropriate.
*/
def floatValue = this.bigDecimal.floatValue
/** Converts this BigDecimal to a <tt>Double</tt>.
* if this BigDecimal has too great a magnitude to represent as a float,
* it will be converted to <code>Float.NEGATIVE_INFINITY</code> or
* <code>Float.POSITIVE_INFINITY</code> as appropriate.
*/
def doubleValue = this.bigDecimal.doubleValue
/** Converts this <code>BigDecimal</code> to a BigInteger.
*/
def toBigInt(): BigInt = new BigInt(this.bigDecimal.toBigInteger())
/** Returns the decimal String representation of this BigDecimal.
*/
override def toString(): String = this.bigDecimal.toString()
}
|
