Class: BigDecimal

43
44
45

# File 'opal/stdlib/bigdecimal.rb', line 43
def initialize(initial, digits = 0)
 @bignumber = JS .new (BigNumber, initial)
end

41
42
43

# File 'opal/stdlib/bigdecimal.rb', line 41
def bignumber
 @bignumber
end

28
29
30
31

# File 'opal/stdlib/bigdecimal.rb', line 28
def self.limit(digits = nil)
 @digits = digits if digits
 @digits
end

33
34
35
36
37
38
39

# File 'opal/stdlib/bigdecimal.rb', line 33
def self.mode(mode, value = nil)
 case mode
 when ROUND_MODE 
 @round_mode = value if value
 @round_mode || ROUND_HALF_UP 
 end
end

70
71
72
73

# File 'opal/stdlib/bigdecimal.rb', line 70
def <(other)
 return false if nan? || other && other.nan?
 super
end

75
76
77
78

# File 'opal/stdlib/bigdecimal.rb', line 75
def <=(other)
 return false if nan? || other && other.nan?
 super
end

60
61
62
63
64
65
66
67
68

# File 'opal/stdlib/bigdecimal.rb', line 60
def <=>(other)
 result = case other
 when self.class
 bignumber.JS.comparedTo(other.bignumber)
 when Number
 bignumber.JS.comparedTo(other)
 end
 `#{result} === null ? nil : #{result}`
end

47
48
49
50
51
52
53
54
55
56

# File 'opal/stdlib/bigdecimal.rb', line 47
def ==(other)
 case other
 when self.class
 bignumber.JS.equals(other.bignumber)
 when Number
 bignumber.JS.equals(other)
 else
 false
 end
end

80
81
82
83

# File 'opal/stdlib/bigdecimal.rb', line 80
def >(other)
 return false if nan? || other && other.nan?
 super
end

85
86
87
88

# File 'opal/stdlib/bigdecimal.rb', line 85
def >=(other)
 return false if nan? || other && other.nan?
 super
end

90
91
92

# File 'opal/stdlib/bigdecimal.rb', line 90
def abs
 self.class.new(bignumber.JS.abs)
end

94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112

# File 'opal/stdlib/bigdecimal.rb', line 94
def add(other, digits = 0)
 if digits.nil?
 raise TypeError, 'wrong argument type nil (expected Fixnum)'
 end
 if digits < 0
 raise ArgumentError, 'argument must be positive'
 end
 other, _ = coerce(other)
 result = bignumber.JS.plus(other.bignumber)
 if digits > 0
 result = result.JS.toDigits(digits, self.class.mode(ROUND_MODE ))
 end
 self.class.new(result)
end

116
117
118
119
120
121
122
123
124
125
126
127
128

# File 'opal/stdlib/bigdecimal.rb', line 116
def ceil(n = nil)
 unless bignumber.JS.isFinite
 raise FloatDomainError, "Computation results to 'Infinity'"
 end
 if n.nil?
 bignumber.JS.round(0, ROUND_CEILING ).JS .toNumber
 elsif n >= 0
 self.class.new(bignumber.JS.round(n, ROUND_CEILING ))
 else
 self.class.new(bignumber.JS.round(0, ROUND_CEILING ))
 end
end

130
131
132
133
134
135
136
137
138
139

# File 'opal/stdlib/bigdecimal.rb', line 130
def coerce(other)
 case other
 when self.class
 [other, self]
 when Number
 [self.class.new(other), self]
 else
 raise TypeError, "#{other.class} can't be coerced into #{self.class}"
 end
end

141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163

# File 'opal/stdlib/bigdecimal.rb', line 141
def div(other, digits = nil)
 return self / other if digits == 0
 other, _ = coerce(other)
 if nan? || other.nan?
 raise FloatDomainError, "Computation results to 'NaN'(Not a Number)"
 end
 if digits.nil?
 if other.zero?
 raise ZeroDivisionError, 'divided by 0'
 end
 if infinite?
 raise FloatDomainError, "Computation results to 'Infinity'"
 end
 return self.class.new(bignumber.JS.dividedToIntegerBy(other.bignumber))
 end
 self.class.new(bignumber.JS.dividedBy(other.bignumber).JS .round(digits, self.class.mode(ROUND_MODE )))
end

165
166
167

# File 'opal/stdlib/bigdecimal.rb', line 165
def finite?
 bignumber.JS.isFinite
end

169
170
171
172

# File 'opal/stdlib/bigdecimal.rb', line 169
def infinite?
 return nil if finite? || nan?
 bignumber.JS.isNegative ? -1 : 1
end

174
175
176
177

# File 'opal/stdlib/bigdecimal.rb', line 174
def minus(other)
 other, _ = coerce(other)
 self.class.new(bignumber.JS.minus(other.bignumber))
end

181
182
183
184
185
186
187
188
189

# File 'opal/stdlib/bigdecimal.rb', line 181
def mult(other, digits = nil)
 other, _ = coerce(other)
 if digits.nil?
 return self.class.new(bignumber.JS.times(other.bignumber))
 end
 self.class.new(bignumber.JS.times(other.bignumber).JS .round(digits, self.class.mode(ROUND_MODE )))
end

193
194
195

# File 'opal/stdlib/bigdecimal.rb', line 193
def nan?
 bignumber.JS.isNaN
end

197
198
199
200

# File 'opal/stdlib/bigdecimal.rb', line 197
def quo(other)
 other, _ = coerce(other)
 self.class.new(bignumber.JS.dividedBy(other.bignumber))
end

204
205
206
207
208
209
210
211

# File 'opal/stdlib/bigdecimal.rb', line 204
def sign
 if bignumber.JS.isNaN
 return SIGN_NaN 
 end
 if bignumber.JS.isZero
 return bignumber.JS.isNegative ? SIGN_NEGATIVE_ZERO  : SIGN_POSITIVE_ZERO 
 end
end

213
214
215
216

# File 'opal/stdlib/bigdecimal.rb', line 213
def sub(other, precision)
 other, _ = coerce(other)
 self.class.new(bignumber.JS.minus(other.bignumber))
end

218
219
220

# File 'opal/stdlib/bigdecimal.rb', line 218
def to_f
 bignumber.JS.toNumber
end

222
223
224

# File 'opal/stdlib/bigdecimal.rb', line 222
def to_s(s = '')
 bignumber.JS.toString
end

226
227
228

# File 'opal/stdlib/bigdecimal.rb', line 226
def zero?
 bignumber.JS.isZero
end