bigdecimal 2.0.0 → 4.1.3

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
@@ -1,19 +1,40 @@
1
- # frozen_string_literal: false
1
+ # frozen_string_literal: true
2
2
  require 'bigdecimal'
3
3
 
4
4
  #
5
5
  #--
6
6
  # Contents:
7
7
  # sqrt(x, prec)
8
+ # cbrt(x, prec)
9
+ # hypot(x, y, prec)
8
10
  # sin (x, prec)
9
11
  # cos (x, prec)
10
- # atan(x, prec) Note: |x|<1, x=0.9999 may not converge.
12
+ # tan (x, prec)
13
+ # asin(x, prec)
14
+ # acos(x, prec)
15
+ # atan(x, prec)
16
+ # atan2(y, x, prec)
17
+ # sinh (x, prec)
18
+ # cosh (x, prec)
19
+ # tanh (x, prec)
20
+ # asinh(x, prec)
21
+ # acosh(x, prec)
22
+ # atanh(x, prec)
23
+ # log2 (x, prec)
24
+ # log10(x, prec)
25
+ # log1p(x, prec)
26
+ # expm1(x, prec)
27
+ # erf (x, prec)
28
+ # erfc(x, prec)
29
+ # gamma(x, prec)
30
+ # lgamma(x, prec)
31
+ # frexp(x)
32
+ # ldexp(x, exponent)
11
33
  # PI (prec)
12
34
  # E (prec) == exp(1.0,prec)
13
35
  #
14
36
  # where:
15
- # x ... BigDecimal number to be computed.
16
- # |x| must be small enough to get convergence.
37
+ # x, y ... BigDecimal number to be computed.
17
38
  # prec ... Number of digits to be obtained.
18
39
  #++
19
40
  #
@@ -25,8 +46,8 @@ require 'bigdecimal'
25
46
  #
26
47
  # include BigMath
27
48
  #
28
- # a = BigDecimal((PI(100)/2).to_s)
29
- # puts sin(a,100) # => 0.99999999999999999999......e0
49
+ # a = BigDecimal((PI(49)/2).to_s)
50
+ # puts sin(a,100) # => 0.9999999999...9999999986e0
30
51
  #
31
52
  module BigMath
32
53
  module_function
@@ -37,13 +58,118 @@ module BigMath
37
58
  # Computes the square root of +decimal+ to the specified number of digits of
38
59
  # precision, +numeric+.
39
60
  #
40
- # BigMath.sqrt(BigDecimal('2'), 16).to_s
41
- # #=> "0.1414213562373095048801688724e1"
61
+ # BigMath.sqrt(BigDecimal('2'), 32).to_s
62
+ # #=> "0.14142135623730950488016887242097e1"
42
63
  #
43
64
  def sqrt(x, prec)
65
+ prec = BigDecimal::Internal.coerce_validate_prec(prec, :sqrt)
66
+ x = BigDecimal::Internal.coerce_to_bigdecimal(x, prec, :sqrt)
44
67
  x.sqrt(prec)
45
68
  end
46
69
 
70
+
71
+ # Returns [sign, reduced_x] where reduced_x is in -pi/2..pi/2
72
+ # and satisfies sin(x) = sign * sin(reduced_x)
73
+ # If add_half_pi is true, adds pi/2 to x before reduction.
74
+ # Precision of pi is adjusted to ensure reduced_x has the required precision.
75
+ private_class_method def _sin_periodic_reduction(x, prec, add_half_pi: false) # :nodoc:
76
+ return [1, x] if -Math::PI/2 <= x && x <= Math::PI/2 && !add_half_pi
77
+
78
+ mod_prec = prec + BigDecimal::Internal::EXTRA_PREC
79
+ pi_extra_prec = [x.exponent, 0].max + BigDecimal::Internal::EXTRA_PREC
80
+ while true
81
+ pi = PI(mod_prec + pi_extra_prec)
82
+ half_pi = pi / 2
83
+ div, mod = (add_half_pi ? x + pi : x + half_pi).divmod(pi)
84
+ mod -= half_pi
85
+ if mod.zero? || mod_prec + mod.exponent <= 0
86
+ # mod is too small to estimate required pi precision
87
+ mod_prec = mod_prec * 3 / 2 + BigDecimal::Internal::EXTRA_PREC
88
+ elsif mod_prec + mod.exponent < prec
89
+ # Estimate required precision of pi
90
+ mod_prec = prec - mod.exponent + BigDecimal::Internal::EXTRA_PREC
91
+ else
92
+ return [div % 2 == 0 ? 1 : -1, mod.mult(1, prec)]
93
+ end
94
+ end
95
+ end
96
+
97
+ private_class_method def _sin_binary_splitting(x, prec) # :nodoc:
98
+ return x if x.zero?
99
+ x2 = x.mult(x, prec)
100
+ # Find k that satisfies x2**k / (2k+1)! < 10**(-prec)
101
+ log10 = Math.log(10)
102
+ logx = BigDecimal::Internal.float_log(x.abs)
103
+ step = (1..).bsearch { |k| Math.lgamma(2 * k + 1)[0] - 2 * k * logx > prec * log10 }
104
+ # Construct denominator sequence for binary splitting
105
+ # sin(x) = x*(1-x2/(2*3)*(1-x2/(4*5)*(1-x2/(6*7)*(1-x2/(8*9)*(1-...)))))
106
+ ds = (1..step).map {|i| -(2 * i) * (2 * i + 1) }
107
+ x.mult(1 + BigDecimal::Internal.taylor_sum_binary_splitting(x2, ds, prec), prec)
108
+ end
109
+
110
+ private_class_method def _sin_around_zero(x, prec) # :nodoc:
111
+ # Divide x into several parts
112
+ # sin(x.xxxxxxxx...) = sin(x.xx + 0.00xx + 0.0000xxxx + ...)
113
+ # Calculate sin of each part and restore sin(0.xxxxxxxx...) using addition theorem.
114
+ sin = BigDecimal(0)
115
+ cos = BigDecimal(1)
116
+ n = 2
117
+ while x != 0 do
118
+ partial_x = x.truncate(n)
119
+ x -= partial_x
120
+ s = _sin_binary_splitting(partial_x, prec)
121
+ c = (1 - s * s).sqrt(prec)
122
+ sin, cos = (sin * c).add(cos * s, prec), (cos * c).sub(sin * s, prec)
123
+ n *= 2
124
+ end
125
+ sin.clamp(BigDecimal(-1), BigDecimal(1))
126
+ end
127
+
128
+ # call-seq:
129
+ # cbrt(decimal, numeric) -> BigDecimal
130
+ #
131
+ # Computes the cube root of +decimal+ to the specified number of digits of
132
+ # precision, +numeric+.
133
+ #
134
+ # BigMath.cbrt(BigDecimal('2'), 32).to_s
135
+ # #=> "0.12599210498948731647672106072782e1"
136
+ #
137
+ def cbrt(x, prec)
138
+ prec = BigDecimal::Internal.coerce_validate_prec(prec, :cbrt)
139
+ x = BigDecimal::Internal.coerce_to_bigdecimal(x, prec, :cbrt)
140
+ return BigDecimal::Internal.nan_computation_result if x.nan?
141
+ return BigDecimal::Internal.infinity_computation_result * x.infinite? if x.infinite?
142
+ return BigDecimal(0) if x.zero?
143
+
144
+ x = -x if neg = x < 0
145
+ ex = x.exponent / 3
146
+ x = x._decimal_shift(-3 * ex)
147
+ y = BigDecimal(Math.cbrt(x.to_f), 0)
148
+ BigDecimal::Internal.newton_loop(prec + BigDecimal::Internal::EXTRA_PREC) do |p|
149
+ y = (2 * y + x.div(y, p).div(y, p)).div(3, p)
150
+ end
151
+ y._decimal_shift(ex).mult(neg ? -1 : 1, prec)
152
+ end
153
+
154
+ # call-seq:
155
+ # hypot(x, y, numeric) -> BigDecimal
156
+ #
157
+ # Returns sqrt(x**2 + y**2) to the specified number of digits of
158
+ # precision, +numeric+.
159
+ #
160
+ # BigMath.hypot(BigDecimal('1'), BigDecimal('2'), 32).to_s
161
+ # #=> "0.22360679774997896964091736687313e1"
162
+ #
163
+ def hypot(x, y, prec)
164
+ prec = BigDecimal::Internal.coerce_validate_prec(prec, :hypot)
165
+ x = BigDecimal::Internal.coerce_to_bigdecimal(x, prec, :hypot)
166
+ y = BigDecimal::Internal.coerce_to_bigdecimal(y, prec, :hypot)
167
+ return BigDecimal::Internal.nan_computation_result if x.nan? || y.nan?
168
+ return BigDecimal::Internal.infinity_computation_result if x.infinite? || y.infinite?
169
+ prec2 = prec + BigDecimal::Internal::EXTRA_PREC
170
+ sqrt(x.mult(x, prec2) + y.mult(y, prec2), prec)
171
+ end
172
+
47
173
  # call-seq:
48
174
  # sin(decimal, numeric) -> BigDecimal
49
175
  #
@@ -52,40 +178,16 @@ module BigMath
52
178
  #
53
179
  # If +decimal+ is Infinity or NaN, returns NaN.
54
180
  #
55
- # BigMath.sin(BigMath.PI(5)/4, 5).to_s
56
- # #=> "0.70710678118654752440082036563292800375e0"
181
+ # BigMath.sin(BigMath.PI(5)/4, 32).to_s
182
+ # #=> "0.70710807985947359435812921837984e0"
57
183
  #
58
184
  def sin(x, prec)
59
- raise ArgumentError, "Zero or negative precision for sin" if prec <= 0
60
- return BigDecimal("NaN") if x.infinite? || x.nan?
61
- n = prec + BigDecimal.double_fig
62
- one = BigDecimal("1")
63
- two = BigDecimal("2")
64
- x = -x if neg = x < 0
65
- if x > (twopi = two * BigMath.PI(prec))
66
- if x > 30
67
- x %= twopi
68
- else
69
- x -= twopi while x > twopi
70
- end
71
- end
72
- x1 = x
73
- x2 = x.mult(x,n)
74
- sign = 1
75
- y = x
76
- d = y
77
- i = one
78
- z = one
79
- while d.nonzero? && ((m = n - (y.exponent - d.exponent).abs) > 0)
80
- m = BigDecimal.double_fig if m < BigDecimal.double_fig
81
- sign = -sign
82
- x1 = x2.mult(x1,n)
83
- i += two
84
- z *= (i-one) * i
85
- d = sign * x1.div(z,m)
86
- y += d
87
- end
88
- neg ? -y : y
185
+ prec = BigDecimal::Internal.coerce_validate_prec(prec, :sin)
186
+ x = BigDecimal::Internal.coerce_to_bigdecimal(x, prec, :sin)
187
+ return BigDecimal::Internal.nan_computation_result if x.infinite? || x.nan?
188
+ n = prec + BigDecimal::Internal::EXTRA_PREC
189
+ sign, x = _sin_periodic_reduction(x, n)
190
+ _sin_around_zero(x, n).mult(sign, prec)
89
191
  end
90
192
 
91
193
  # call-seq:
@@ -96,40 +198,87 @@ module BigMath
96
198
  #
97
199
  # If +decimal+ is Infinity or NaN, returns NaN.
98
200
  #
99
- # BigMath.cos(BigMath.PI(4), 16).to_s
100
- # #=> "-0.999999999999999999999999999999856613163740061349e0"
201
+ # BigMath.cos(BigMath.PI(16), 32).to_s
202
+ # #=> "-0.99999999999999999999999999999997e0"
101
203
  #
102
204
  def cos(x, prec)
103
- raise ArgumentError, "Zero or negative precision for cos" if prec <= 0
104
- return BigDecimal("NaN") if x.infinite? || x.nan?
105
- n = prec + BigDecimal.double_fig
106
- one = BigDecimal("1")
107
- two = BigDecimal("2")
108
- x = -x if x < 0
109
- if x > (twopi = two * BigMath.PI(prec))
110
- if x > 30
111
- x %= twopi
112
- else
113
- x -= twopi while x > twopi
114
- end
115
- end
116
- x1 = one
117
- x2 = x.mult(x,n)
118
- sign = 1
119
- y = one
120
- d = y
121
- i = BigDecimal("0")
122
- z = one
123
- while d.nonzero? && ((m = n - (y.exponent - d.exponent).abs) > 0)
124
- m = BigDecimal.double_fig if m < BigDecimal.double_fig
125
- sign = -sign
126
- x1 = x2.mult(x1,n)
127
- i += two
128
- z *= (i-one) * i
129
- d = sign * x1.div(z,m)
130
- y += d
205
+ prec = BigDecimal::Internal.coerce_validate_prec(prec, :cos)
206
+ x = BigDecimal::Internal.coerce_to_bigdecimal(x, prec, :cos)
207
+ return BigDecimal::Internal.nan_computation_result if x.infinite? || x.nan?
208
+ n = prec + BigDecimal::Internal::EXTRA_PREC
209
+ sign, x = _sin_periodic_reduction(x, n, add_half_pi: true)
210
+ _sin_around_zero(x, n).mult(sign, prec)
211
+ end
212
+
213
+ # call-seq:
214
+ # tan(decimal, numeric) -> BigDecimal
215
+ #
216
+ # Computes the tangent of +decimal+ to the specified number of digits of
217
+ # precision, +numeric+.
218
+ #
219
+ # If +decimal+ is Infinity or NaN, returns NaN.
220
+ #
221
+ # BigMath.tan(BigDecimal("0.0"), 4).to_s
222
+ # #=> "0.0"
223
+ #
224
+ # BigMath.tan(BigMath.PI(24) / 4, 32).to_s
225
+ # #=> "0.99999999999999999999999830836025e0"
226
+ #
227
+ def tan(x, prec)
228
+ prec = BigDecimal::Internal.coerce_validate_prec(prec, :tan)
229
+ prec2 = prec + BigDecimal::Internal::EXTRA_PREC
230
+ sin(x, prec2).div(cos(x, prec2), prec)
231
+ end
232
+
233
+ # call-seq:
234
+ # asin(decimal, numeric) -> BigDecimal
235
+ #
236
+ # Computes the arcsine of +decimal+ to the specified number of digits of
237
+ # precision, +numeric+.
238
+ #
239
+ # If +decimal+ is NaN, returns NaN.
240
+ #
241
+ # BigMath.asin(BigDecimal('0.5'), 32).to_s
242
+ # #=> "0.52359877559829887307710723054658e0"
243
+ #
244
+ def asin(x, prec)
245
+ prec = BigDecimal::Internal.coerce_validate_prec(prec, :asin)
246
+ x = BigDecimal::Internal.coerce_to_bigdecimal(x, prec, :asin)
247
+ raise Math::DomainError, "Out of domain argument for asin" if x < -1 || x > 1
248
+ return BigDecimal::Internal.nan_computation_result if x.nan?
249
+
250
+ prec2 = prec + BigDecimal::Internal::EXTRA_PREC
251
+ cos = (1 - x**2).sqrt(prec2)
252
+ if cos.zero?
253
+ PI(prec2).div(x > 0 ? 2 : -2, prec)
254
+ else
255
+ atan(x.div(cos, prec2), prec)
131
256
  end
132
- y
257
+ end
258
+
259
+ # call-seq:
260
+ # acos(decimal, numeric) -> BigDecimal
261
+ #
262
+ # Computes the arccosine of +decimal+ to the specified number of digits of
263
+ # precision, +numeric+.
264
+ #
265
+ # If +decimal+ is NaN, returns NaN.
266
+ #
267
+ # BigMath.acos(BigDecimal('0.5'), 32).to_s
268
+ # #=> "0.10471975511965977461542144610932e1"
269
+ #
270
+ def acos(x, prec)
271
+ prec = BigDecimal::Internal.coerce_validate_prec(prec, :acos)
272
+ x = BigDecimal::Internal.coerce_to_bigdecimal(x, prec, :acos)
273
+ raise Math::DomainError, "Out of domain argument for acos" if x < -1 || x > 1
274
+ return BigDecimal::Internal.nan_computation_result if x.nan?
275
+
276
+ prec2 = prec + BigDecimal::Internal::EXTRA_PREC
277
+ return (PI(prec2) / 2).sub(asin(x, prec2), prec) if x < 0
278
+ return PI(prec2).div(2, prec) if x.zero?
279
+
280
+ sin = (1 - x**2).sqrt(prec2)
281
+ atan(sin.div(x, prec2), prec)
133
282
  end
134
283
 
135
284
  # call-seq:
@@ -140,35 +289,389 @@ module BigMath
140
289
  #
141
290
  # If +decimal+ is NaN, returns NaN.
142
291
  #
143
- # BigMath.atan(BigDecimal('-1'), 16).to_s
144
- # #=> "-0.785398163397448309615660845819878471907514682065e0"
292
+ # BigMath.atan(BigDecimal('-1'), 32).to_s
293
+ # #=> "-0.78539816339744830961566084581988e0"
145
294
  #
146
295
  def atan(x, prec)
147
- raise ArgumentError, "Zero or negative precision for atan" if prec <= 0
148
- return BigDecimal("NaN") if x.nan?
149
- pi = PI(prec)
296
+ prec = BigDecimal::Internal.coerce_validate_prec(prec, :atan)
297
+ x = BigDecimal::Internal.coerce_to_bigdecimal(x, prec, :atan)
298
+ return BigDecimal::Internal.nan_computation_result if x.nan?
299
+ n = prec + BigDecimal::Internal::EXTRA_PREC
300
+ return PI(n).div(2 * x.infinite?, prec) if x.infinite?
301
+
150
302
  x = -x if neg = x < 0
151
- return pi.div(neg ? -2 : 2, prec) if x.infinite?
152
- return pi / (neg ? -4 : 4) if x.round(prec) == 1
153
- x = BigDecimal("1").div(x, prec) if inv = x > 1
154
- x = (-1 + sqrt(1 + x**2, prec))/x if dbl = x > 0.5
155
- n = prec + BigDecimal.double_fig
156
- y = x
157
- d = y
158
- t = x
159
- r = BigDecimal("3")
160
- x2 = x.mult(x,n)
161
- while d.nonzero? && ((m = n - (y.exponent - d.exponent).abs) > 0)
162
- m = BigDecimal.double_fig if m < BigDecimal.double_fig
163
- t = -t.mult(x2,n)
164
- d = t.div(r,m)
165
- y += d
166
- r += 2
303
+ x = BigDecimal(1).div(x, n) if inv = x < -1 || x > 1
304
+
305
+ # Solve tan(y) - x = 0 with Newton's method
306
+ # Repeat: y -= (tan(y) - x) * cos(y)**2
307
+ y = BigDecimal(Math.atan(x.to_f), 0)
308
+ BigDecimal::Internal.newton_loop(n) do |p|
309
+ s = sin(y, p)
310
+ c = (1 - s * s).sqrt(p)
311
+ y = y.sub(c * (s.sub(c * x.mult(1, p), p)), p)
167
312
  end
168
- y *= 2 if dbl
169
- y = pi / 2 - y if inv
170
- y = -y if neg
171
- y
313
+ y = PI(n) / 2 - y if inv
314
+ y.mult(neg ? -1 : 1, prec)
315
+ end
316
+
317
+ # call-seq:
318
+ # atan2(decimal, decimal, numeric) -> BigDecimal
319
+ #
320
+ # Computes the arctangent of y and x to the specified number of digits of
321
+ # precision, +numeric+.
322
+ #
323
+ # BigMath.atan2(BigDecimal('-1'), BigDecimal('1'), 32).to_s
324
+ # #=> "-0.78539816339744830961566084581988e0"
325
+ #
326
+ def atan2(y, x, prec)
327
+ prec = BigDecimal::Internal.coerce_validate_prec(prec, :atan2)
328
+ x = BigDecimal::Internal.coerce_to_bigdecimal(x, prec, :atan2)
329
+ y = BigDecimal::Internal.coerce_to_bigdecimal(y, prec, :atan2)
330
+ return BigDecimal::Internal.nan_computation_result if x.nan? || y.nan?
331
+
332
+ if x.infinite? || y.infinite?
333
+ one = BigDecimal(1)
334
+ zero = BigDecimal(0)
335
+ x = x.infinite? ? (x > 0 ? one : -one) : zero
336
+ y = y.infinite? ? (y > 0 ? one : -one) : y.sign * zero
337
+ end
338
+
339
+ return x.sign >= 0 ? BigDecimal(0) : y.sign * PI(prec) if y.zero?
340
+
341
+ y = -y if neg = y < 0
342
+ xlarge = y.abs < x.abs
343
+ prec2 = prec + BigDecimal::Internal::EXTRA_PREC
344
+ if x > 0
345
+ v = xlarge ? atan(y.div(x, prec2), prec) : PI(prec2) / 2 - atan(x.div(y, prec2), prec2)
346
+ else
347
+ v = xlarge ? PI(prec2) - atan(-y.div(x, prec2), prec2) : PI(prec2) / 2 + atan(x.div(-y, prec2), prec2)
348
+ end
349
+ v.mult(neg ? -1 : 1, prec)
350
+ end
351
+
352
+ # call-seq:
353
+ # sinh(decimal, numeric) -> BigDecimal
354
+ #
355
+ # Computes the hyperbolic sine of +decimal+ to the specified number of digits of
356
+ # precision, +numeric+.
357
+ #
358
+ # If +decimal+ is NaN, returns NaN.
359
+ #
360
+ # BigMath.sinh(BigDecimal('1'), 32).to_s
361
+ # #=> "0.11752011936438014568823818505956e1"
362
+ #
363
+ def sinh(x, prec)
364
+ prec = BigDecimal::Internal.coerce_validate_prec(prec, :sinh)
365
+ x = BigDecimal::Internal.coerce_to_bigdecimal(x, prec, :sinh)
366
+ return BigDecimal::Internal.nan_computation_result if x.nan?
367
+ return BigDecimal::Internal.infinity_computation_result * x.infinite? if x.infinite?
368
+
369
+ prec2 = prec + BigDecimal::Internal::EXTRA_PREC
370
+ prec2 -= x.exponent if x.exponent < 0
371
+ e = exp(x, prec2)
372
+ (e - BigDecimal(1).div(e, prec2)).div(2, prec)
373
+ end
374
+
375
+ # call-seq:
376
+ # cosh(decimal, numeric) -> BigDecimal
377
+ #
378
+ # Computes the hyperbolic cosine of +decimal+ to the specified number of digits of
379
+ # precision, +numeric+.
380
+ #
381
+ # If +decimal+ is NaN, returns NaN.
382
+ #
383
+ # BigMath.cosh(BigDecimal('1'), 32).to_s
384
+ # #=> "0.15430806348152437784779056207571e1"
385
+ #
386
+ def cosh(x, prec)
387
+ prec = BigDecimal::Internal.coerce_validate_prec(prec, :cosh)
388
+ x = BigDecimal::Internal.coerce_to_bigdecimal(x, prec, :cosh)
389
+ return BigDecimal::Internal.nan_computation_result if x.nan?
390
+ return BigDecimal::Internal.infinity_computation_result if x.infinite?
391
+
392
+ prec2 = prec + BigDecimal::Internal::EXTRA_PREC
393
+ e = exp(x, prec2)
394
+ (e + BigDecimal(1).div(e, prec2)).div(2, prec)
395
+ end
396
+
397
+ # call-seq:
398
+ # tanh(decimal, numeric) -> BigDecimal
399
+ #
400
+ # Computes the hyperbolic tangent of +decimal+ to the specified number of digits of
401
+ # precision, +numeric+.
402
+ #
403
+ # If +decimal+ is NaN, returns NaN.
404
+ #
405
+ # BigMath.tanh(BigDecimal('1'), 32).to_s
406
+ # #=> "0.76159415595576488811945828260479e0"
407
+ #
408
+ def tanh(x, prec)
409
+ prec = BigDecimal::Internal.coerce_validate_prec(prec, :tanh)
410
+ x = BigDecimal::Internal.coerce_to_bigdecimal(x, prec, :tanh)
411
+ return BigDecimal::Internal.nan_computation_result if x.nan?
412
+ return BigDecimal(x.infinite?) if x.infinite?
413
+
414
+ prec2 = prec + BigDecimal::Internal::EXTRA_PREC + [-x.exponent, 0].max
415
+ e = exp(x, prec2)
416
+ einv = BigDecimal(1).div(e, prec2)
417
+ (e - einv).div(e + einv, prec)
418
+ end
419
+
420
+ # call-seq:
421
+ # asinh(decimal, numeric) -> BigDecimal
422
+ #
423
+ # Computes the inverse hyperbolic sine of +decimal+ to the specified number of digits of
424
+ # precision, +numeric+.
425
+ #
426
+ # If +decimal+ is NaN, returns NaN.
427
+ #
428
+ # BigMath.asinh(BigDecimal('1'), 32).to_s
429
+ # #=> "0.88137358701954302523260932497979e0"
430
+ #
431
+ def asinh(x, prec)
432
+ prec = BigDecimal::Internal.coerce_validate_prec(prec, :asinh)
433
+ x = BigDecimal::Internal.coerce_to_bigdecimal(x, prec, :asinh)
434
+ return BigDecimal::Internal.nan_computation_result if x.nan?
435
+ return BigDecimal::Internal.infinity_computation_result * x.infinite? if x.infinite?
436
+ return -asinh(-x, prec) if x < 0
437
+
438
+ sqrt_prec = prec + [-x.exponent, 0].max + BigDecimal::Internal::EXTRA_PREC
439
+ log(x + sqrt(x**2 + 1, sqrt_prec), prec)
440
+ end
441
+
442
+ # call-seq:
443
+ # acosh(decimal, numeric) -> BigDecimal
444
+ #
445
+ # Computes the inverse hyperbolic cosine of +decimal+ to the specified number of digits of
446
+ # precision, +numeric+.
447
+ #
448
+ # If +decimal+ is NaN, returns NaN.
449
+ #
450
+ # BigMath.acosh(BigDecimal('2'), 32).to_s
451
+ # #=> "0.1316957896924816708625046347308e1"
452
+ #
453
+ def acosh(x, prec)
454
+ prec = BigDecimal::Internal.coerce_validate_prec(prec, :acosh)
455
+ x = BigDecimal::Internal.coerce_to_bigdecimal(x, prec, :acosh)
456
+ raise Math::DomainError, "Out of domain argument for acosh" if x < 1
457
+ return BigDecimal::Internal.infinity_computation_result if x.infinite?
458
+ return BigDecimal::Internal.nan_computation_result if x.nan?
459
+
460
+ log(x + sqrt(x**2 - 1, prec + BigDecimal::Internal::EXTRA_PREC), prec)
461
+ end
462
+
463
+ # call-seq:
464
+ # atanh(decimal, numeric) -> BigDecimal
465
+ #
466
+ # Computes the inverse hyperbolic tangent of +decimal+ to the specified number of digits of
467
+ # precision, +numeric+.
468
+ #
469
+ # If +decimal+ is NaN, returns NaN.
470
+ #
471
+ # BigMath.atanh(BigDecimal('0.5'), 32).to_s
472
+ # #=> "0.54930614433405484569762261846126e0"
473
+ #
474
+ def atanh(x, prec)
475
+ prec = BigDecimal::Internal.coerce_validate_prec(prec, :atanh)
476
+ x = BigDecimal::Internal.coerce_to_bigdecimal(x, prec, :atanh)
477
+ raise Math::DomainError, "Out of domain argument for atanh" if x < -1 || x > 1
478
+ return BigDecimal::Internal.nan_computation_result if x.nan?
479
+ return BigDecimal::Internal.infinity_computation_result if x == 1
480
+ return -BigDecimal::Internal.infinity_computation_result if x == -1
481
+
482
+ prec2 = prec + BigDecimal::Internal::EXTRA_PREC
483
+ (log(x + 1, prec2) - log(1 - x, prec2)).div(2, prec)
484
+ end
485
+
486
+ # call-seq:
487
+ # BigMath.log2(decimal, numeric) -> BigDecimal
488
+ #
489
+ # Computes the base 2 logarithm of +decimal+ to the specified number of
490
+ # digits of precision, +numeric+.
491
+ #
492
+ # If +decimal+ is zero or negative, raises Math::DomainError.
493
+ #
494
+ # If +decimal+ is positive infinity, returns Infinity.
495
+ #
496
+ # If +decimal+ is NaN, returns NaN.
497
+ #
498
+ # BigMath.log2(BigDecimal('3'), 32).to_s
499
+ # #=> "0.15849625007211561814537389439478e1"
500
+ #
501
+ def log2(x, prec)
502
+ prec = BigDecimal::Internal.coerce_validate_prec(prec, :log2)
503
+ x = BigDecimal::Internal.coerce_to_bigdecimal(x, prec, :log2)
504
+ return BigDecimal::Internal.nan_computation_result if x.nan?
505
+ return BigDecimal::Internal.infinity_computation_result if x.infinite? == 1
506
+
507
+ prec2 = prec + BigDecimal::Internal::EXTRA_PREC * 3 / 2
508
+ v = log(x, prec2).div(log(BigDecimal(2), prec2), prec2)
509
+ # Perform half-up rounding to calculate log2(2**n)==n correctly in every rounding mode
510
+ v = v.round(prec + BigDecimal::Internal::EXTRA_PREC - (v.exponent < 0 ? v.exponent : 0), BigDecimal::ROUND_HALF_UP)
511
+ v.mult(1, prec)
512
+ end
513
+
514
+ # call-seq:
515
+ # BigMath.log10(decimal, numeric) -> BigDecimal
516
+ #
517
+ # Computes the base 10 logarithm of +decimal+ to the specified number of
518
+ # digits of precision, +numeric+.
519
+ #
520
+ # If +decimal+ is zero or negative, raises Math::DomainError.
521
+ #
522
+ # If +decimal+ is positive infinity, returns Infinity.
523
+ #
524
+ # If +decimal+ is NaN, returns NaN.
525
+ #
526
+ # BigMath.log10(BigDecimal('3'), 32).to_s
527
+ # #=> "0.47712125471966243729502790325512e0"
528
+ #
529
+ def log10(x, prec)
530
+ prec = BigDecimal::Internal.coerce_validate_prec(prec, :log10)
531
+ x = BigDecimal::Internal.coerce_to_bigdecimal(x, prec, :log10)
532
+ return BigDecimal::Internal.nan_computation_result if x.nan?
533
+ return BigDecimal::Internal.infinity_computation_result if x.infinite? == 1
534
+
535
+ prec2 = prec + BigDecimal::Internal::EXTRA_PREC * 3 / 2
536
+ v = log(x, prec2).div(log(BigDecimal(10), prec2), prec2)
537
+ # Perform half-up rounding to calculate log10(10**n)==n correctly in every rounding mode
538
+ v = v.round(prec + BigDecimal::Internal::EXTRA_PREC - (v.exponent < 0 ? v.exponent : 0), BigDecimal::ROUND_HALF_UP)
539
+ v.mult(1, prec)
540
+ end
541
+
542
+ # call-seq:
543
+ # BigMath.log1p(decimal, numeric) -> BigDecimal
544
+ #
545
+ # Computes log(1 + decimal) to the specified number of digits of precision, +numeric+.
546
+ #
547
+ # BigMath.log1p(BigDecimal('0.1'), 32).to_s
548
+ # #=> "0.95310179804324860043952123280765e-1"
549
+ #
550
+ def log1p(x, prec)
551
+ prec = BigDecimal::Internal.coerce_validate_prec(prec, :log1p)
552
+ x = BigDecimal::Internal.coerce_to_bigdecimal(x, prec, :log1p)
553
+ raise Math::DomainError, 'Out of domain argument for log1p' if x < -1
554
+
555
+ return log(x + 1, prec)
556
+ end
557
+
558
+ # call-seq:
559
+ # BigMath.expm1(decimal, numeric) -> BigDecimal
560
+ #
561
+ # Computes exp(decimal) - 1 to the specified number of digits of precision, +numeric+.
562
+ #
563
+ # BigMath.expm1(BigDecimal('0.1'), 32).to_s
564
+ # #=> "0.10517091807564762481170782649025e0"
565
+ #
566
+ def expm1(x, prec)
567
+ prec = BigDecimal::Internal.coerce_validate_prec(prec, :expm1)
568
+ x = BigDecimal::Internal.coerce_to_bigdecimal(x, prec, :expm1)
569
+ return BigDecimal(-1) if x.infinite? == -1
570
+
571
+ exp_prec = prec
572
+ if x < -1
573
+ # log10(exp(x)) = x * log10(e)
574
+ lg_e = 0.4342944819032518
575
+ exp_prec = prec + (lg_e * x).ceil + BigDecimal::Internal::EXTRA_PREC
576
+ elsif x < 1
577
+ exp_prec = prec - x.exponent + BigDecimal::Internal::EXTRA_PREC
578
+ else
579
+ exp_prec = prec
580
+ end
581
+
582
+ return BigDecimal(-1) if exp_prec <= 0
583
+
584
+ exp(x, exp_prec).sub(1, prec)
585
+ end
586
+
587
+ # call-seq:
588
+ # erf(decimal, numeric) -> BigDecimal
589
+ #
590
+ # Computes the error function of +decimal+ to the specified number of digits of
591
+ # precision, +numeric+.
592
+ #
593
+ # If +decimal+ is NaN, returns NaN.
594
+ #
595
+ # BigMath.erf(BigDecimal('1'), 32).to_s
596
+ # #=> "0.84270079294971486934122063508261e0"
597
+ #
598
+ def erf(x, prec)
599
+ require 'bigdecimal/math/erf'
600
+ Erf.erf(x, prec)
601
+ end
602
+
603
+ # call-seq:
604
+ # erfc(decimal, numeric) -> BigDecimal
605
+ #
606
+ # Computes the complementary error function of +decimal+ to the specified number of digits of
607
+ # precision, +numeric+.
608
+ #
609
+ # If +decimal+ is NaN, returns NaN.
610
+ #
611
+ # BigMath.erfc(BigDecimal('10'), 32).to_s
612
+ # #=> "0.20884875837625447570007862949578e-44"
613
+ #
614
+ def erfc(x, prec)
615
+ require 'bigdecimal/math/erf'
616
+ Erf.erfc(x, prec)
617
+ end
618
+
619
+ # call-seq:
620
+ # BigMath.gamma(decimal, numeric) -> BigDecimal
621
+ #
622
+ # Computes the gamma function of +decimal+ to the specified number of
623
+ # digits of precision, +numeric+.
624
+ #
625
+ # BigMath.gamma(BigDecimal('0.5'), 32).to_s
626
+ # #=> "0.17724538509055160272981674833411e1"
627
+ #
628
+ def gamma(x, prec)
629
+ require 'bigdecimal/math/gamma'
630
+ Gamma.gamma(x, prec)
631
+ end
632
+
633
+ # call-seq:
634
+ # BigMath.lgamma(decimal, numeric) -> [BigDecimal, Integer]
635
+ #
636
+ # Computes the natural logarithm of the absolute value of the gamma function
637
+ # of +decimal+ to the specified number of digits of precision, +numeric+ and its sign.
638
+ #
639
+ # BigMath.lgamma(BigDecimal('0.5'), 32)
640
+ # #=> [0.57236494292470008707171367567653e0, 1]
641
+ #
642
+ def lgamma(x, prec)
643
+ require 'bigdecimal/math/gamma'
644
+ Gamma.lgamma(x, prec)
645
+ end
646
+
647
+ # call-seq:
648
+ # frexp(x) -> [BigDecimal, Integer]
649
+ #
650
+ # Decomposes +x+ into a normalized fraction and an integral power of ten.
651
+ #
652
+ # BigMath.frexp(BigDecimal(123.456))
653
+ # #=> [0.123456e0, 3]
654
+ #
655
+ def frexp(x)
656
+ x = BigDecimal::Internal.coerce_to_bigdecimal(x, 0, :frexp)
657
+ return [x, 0] unless x.finite?
658
+
659
+ exponent = x.exponent
660
+ [x._decimal_shift(-exponent), exponent]
661
+ end
662
+
663
+ # call-seq:
664
+ # ldexp(fraction, exponent) -> BigDecimal
665
+ #
666
+ # Inverse of +frexp+.
667
+ # Returns the value of fraction * 10**exponent.
668
+ #
669
+ # BigMath.ldexp(BigDecimal("0.123456e0"), 3)
670
+ # #=> 0.123456e3
671
+ #
672
+ def ldexp(x, exponent)
673
+ x = BigDecimal::Internal.coerce_to_bigdecimal(x, 0, :ldexp)
674
+ x.finite? ? x._decimal_shift(exponent) : x
172
675
  end
173
676
 
174
677
  # call-seq:
@@ -177,43 +680,24 @@ module BigMath
177
680
  # Computes the value of pi to the specified number of digits of precision,
178
681
  # +numeric+.
179
682
  #
180
- # BigMath.PI(10).to_s
181
- # #=> "0.3141592653589793238462643388813853786957412e1"
683
+ # BigMath.PI(32).to_s
684
+ # #=> "0.31415926535897932384626433832795e1"
182
685
  #
183
686
  def PI(prec)
184
- raise ArgumentError, "Zero or negative precision for PI" if prec <= 0
185
- n = prec + BigDecimal.double_fig
186
- zero = BigDecimal("0")
187
- one = BigDecimal("1")
188
- two = BigDecimal("2")
189
-
190
- m25 = BigDecimal("-0.04")
191
- m57121 = BigDecimal("-57121")
192
-
193
- pi = zero
194
-
195
- d = one
196
- k = one
197
- t = BigDecimal("-80")
198
- while d.nonzero? && ((m = n - (pi.exponent - d.exponent).abs) > 0)
199
- m = BigDecimal.double_fig if m < BigDecimal.double_fig
200
- t = t*m25
201
- d = t.div(k,m)
202
- k = k+two
203
- pi = pi + d
204
- end
205
-
206
- d = one
207
- k = one
208
- t = BigDecimal("956")
209
- while d.nonzero? && ((m = n - (pi.exponent - d.exponent).abs) > 0)
210
- m = BigDecimal.double_fig if m < BigDecimal.double_fig
211
- t = t.div(m57121,n)
212
- d = t.div(k,m)
213
- pi = pi + d
214
- k = k+two
687
+ # Gauss–Legendre algorithm
688
+ prec = BigDecimal::Internal.coerce_validate_prec(prec, :PI)
689
+ n = prec + BigDecimal::Internal::EXTRA_PREC
690
+ a = BigDecimal(1)
691
+ b = BigDecimal(0.5, 0).sqrt(n)
692
+ s = BigDecimal(0.25, 0)
693
+ t = 1
694
+ while a != b && (a - b).exponent > 1 - n
695
+ c = (a - b).div(2, n)
696
+ a, b = (a + b).div(2, n), (a * b).sqrt(n)
697
+ s = s.sub(c * c * t, n)
698
+ t *= 2
215
699
  end
216
- pi
700
+ (a * b).div(s, prec)
217
701
  end
218
702
 
219
703
  # call-seq:
@@ -222,11 +706,11 @@ module BigMath
222
706
  # Computes e (the base of natural logarithms) to the specified number of
223
707
  # digits of precision, +numeric+.
224
708
  #
225
- # BigMath.E(10).to_s
226
- # #=> "0.271828182845904523536028752390026306410273e1"
709
+ # BigMath.E(32).to_s
710
+ # #=> "0.27182818284590452353602874713527e1"
227
711
  #
228
712
  def E(prec)
229
- raise ArgumentError, "Zero or negative precision for E" if prec <= 0
230
- BigMath.exp(1, prec)
713
+ prec = BigDecimal::Internal.coerce_validate_prec(prec, :E)
714
+ exp(1, prec)
231
715
  end
232
716
  end