Class: BigDecimal

Inherits:
Numeric show all
Defined in:
opal/stdlib/bigdecimal.rb,
opal/stdlib/bigdecimal.rb,
opal/stdlib/bigdecimal/bignumber.js.rb

Constant Summary

ROUND_MODE = 
256
ROUND_UP =

NOTE: the numeric values of the ROUND_* constants follow BigNumber.js, they are NOT the same as MRI

0
ROUND_DOWN = 
1
ROUND_CEILING = 
2
ROUND_FLOOR = 
3
ROUND_HALF_UP = 
4
ROUND_HALF_DOWN = 
5
ROUND_HALF_EVEN = 
6
SIGN_NaN = 
0
SIGN_POSITIVE_ZERO = 
1
SIGN_NEGATIVE_ZERO = 
-1
SIGN_POSITIVE_FINITE = 
2
SIGN_NEGATIVE_FINITE = 
-2
SIGN_POSITIVE_INFINITE = 
3
SIGN_NEGATIVE_INFINITE = 
-3

Instance Attribute Summary collapse

Class Method Summary collapse

Instance Method Summary collapse

Methods inherited from Numeric

#to_json, #to_n

Constructor Details

#initialize(initial, digits = 0) ⇒ BigDecimal

Returns a new instance of BigDecimal



43
44
45
 
# File 'opal/stdlib/bigdecimal.rb', line 43

def initialize(initial, digits = 0)
  @bignumber = JS.new(BigNumber, initial)
end

Instance Attribute Details

#bignumber ⇒ Object (readonly)

Returns the value of attribute bignumber



41
42
43
 
# File 'opal/stdlib/bigdecimal.rb', line 41

def bignumber
  @bignumber
end

Class Method Details

.limit(digits = nil) ⇒ Object 



28
29
30
31
 
# File 'opal/stdlib/bigdecimal.rb', line 28

def self.limit(digits = nil)
  @digits = digits if digits
  @digits
end

.mode(mode, value = nil) ⇒ Object 



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

Instance Method Details

#<(other) ⇒ Object 



70
71
72
73
 
# File 'opal/stdlib/bigdecimal.rb', line 70

def <(other)
  return false if nan? || other && other.nan?
  super
end

#<=(other) ⇒ Object 



75
76
77
78
 
# File 'opal/stdlib/bigdecimal.rb', line 75

def <=(other)
  return false if nan? || other && other.nan?
  super
end

#<=>(other) ⇒ Object 



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

#==(other) ⇒ Object Also known as: === 



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

#>(other) ⇒ Object 



80
81
82
83
 
# File 'opal/stdlib/bigdecimal.rb', line 80

def >(other)
  return false if nan? || other && other.nan?
  super
end

#>=(other) ⇒ Object 



85
86
87
88
 
# File 'opal/stdlib/bigdecimal.rb', line 85

def >=(other)
  return false if nan? || other && other.nan?
  super
end

#abs ⇒ Object 



90
91
92
 
# File 'opal/stdlib/bigdecimal.rb', line 90

def abs
  self.class.new(bignumber.JS.abs)
end

#add(other, digits = 0) ⇒ Object Also known as: + 



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

#ceil(n = nil) ⇒ Object 



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

#coerce(other) ⇒ Object 



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

#div(other, digits = nil) ⇒ Object 



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

#finite? ⇒ Boolean

Returns:



165
166
167
 
# File 'opal/stdlib/bigdecimal.rb', line 165

def finite?
  bignumber.JS.isFinite
end

#infinite? ⇒ Boolean

Returns:



169
170
171
172
 
# File 'opal/stdlib/bigdecimal.rb', line 169

def infinite?
  return nil if finite? || nan?
  bignumber.JS.isNegative ? -1 : 1
end

#minus(other) ⇒ Object Also known as: - 



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

#mult(other, digits = nil) ⇒ Object Also known as: * 



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

#nan? ⇒ Boolean

Returns:



193
194
195
 
# File 'opal/stdlib/bigdecimal.rb', line 193

def nan?
  bignumber.JS.isNaN
end

#quo(other) ⇒ Object Also known as: / 



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

#sign ⇒ Object 



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

#sub(other, precision) ⇒ Object 



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

#to_f ⇒ Object 



218
219
220
 
# File 'opal/stdlib/bigdecimal.rb', line 218

def to_f
  bignumber.JS.toNumber
end

#to_s(s = '') ⇒ Object 



222
223
224
 
# File 'opal/stdlib/bigdecimal.rb', line 222

def to_s(s = '')
  bignumber.JS.toString
end

#zero? ⇒ Boolean

Returns:



226
227
228
 
# File 'opal/stdlib/bigdecimal.rb', line 226

def zero?
  bignumber.JS.isZero
end