Extended maintenance of Ruby versions 1.8.7 and 1.9.2 will end on July 31, 2014. Read more

In Files

  • bigdecimal/lib/bigdecimal/math.rb

Class/Module Index [+]

Quicksearch

BigMath

Provides mathematical functions.

Example:

require "bigdecimal"
require "bigdecimal/math"

include BigMath

a = BigDecimal((PI(100)/2).to_s)
puts sin(a,100) # -> 0.10000000000000000000......E1

Public Instance Methods

E(prec) click to toggle source

Computes e (the base of natural logarithms) to the specified number of digits of precision.

 
               # File bigdecimal/lib/bigdecimal/math.rb, line 258
def E(prec)
  raise ArgumentError, "Zero or negative precision for E" if prec <= 0
  n    = prec + BigDecimal.double_fig
  one  = BigDecimal("1")
  y  = one
  d  = y
  z  = one
  i  = 0
  while d.nonzero? && ((m = n - (y.exponent - d.exponent).abs) > 0)
    m = BigDecimal.double_fig if m < BigDecimal.double_fig
    i += 1
    z *= i
    d  = one.div(z,m)
    y += d
  end
  y
end
            
PI(prec) click to toggle source

Computes the value of pi to the specified number of digits of precision.

 
               # File bigdecimal/lib/bigdecimal/math.rb, line 218
def PI(prec)
  raise ArgumentError, "Zero or negative argument for PI" if prec <= 0
  n      = prec + BigDecimal.double_fig
  zero   = BigDecimal("0")
  one    = BigDecimal("1")
  two    = BigDecimal("2")

  m25    = BigDecimal("-0.04")
  m57121 = BigDecimal("-57121")

  pi     = zero

  d = one
  k = one
  w = one
  t = BigDecimal("-80")
  while d.nonzero? && ((m = n - (pi.exponent - d.exponent).abs) > 0)
    m = BigDecimal.double_fig if m < BigDecimal.double_fig
    t   = t*m25
    d   = t.div(k,m)
    k   = k+two
    pi  = pi + d
  end

  d = one
  k = one
  w = one
  t = BigDecimal("956")
  while d.nonzero? && ((m = n - (pi.exponent - d.exponent).abs) > 0)
    m = BigDecimal.double_fig if m < BigDecimal.double_fig
    t   = t.div(m57121,n)
    d   = t.div(k,m)
    pi  = pi + d
    k   = k+two
  end
  pi
end
            
atan(x, prec) click to toggle source

Computes the arctangent of x to the specified number of digits of precision.

If x is NaN, returns NaN.

 
               # File bigdecimal/lib/bigdecimal/math.rb, line 121
def atan(x, prec)
  raise ArgumentError, "Zero or negative precision for atan" if prec <= 0
  return BigDecimal("NaN") if x.nan?
  pi = PI(prec)
  x = -x if neg = x < 0
  return pi.div(neg ? -2 : 2, prec) if x.infinite?
  return pi / (neg ? -4 : 4) if x.round(prec) == 1
  x = BigDecimal("1").div(x, prec) if inv = x > 1
  x = (-1 + sqrt(1 + x**2, prec))/x if dbl = x > 0.5
  n    = prec + BigDecimal.double_fig
  y = x
  d = y
  t = x
  r = BigDecimal("3")
  x2 = x.mult(x,n)
  while d.nonzero? && ((m = n - (y.exponent - d.exponent).abs) > 0)
    m = BigDecimal.double_fig if m < BigDecimal.double_fig
    t = -t.mult(x2,n)
    d = t.div(r,m)
    y += d
    r += 2
  end
  y *= 2 if dbl
  y = pi / 2 - y if inv
  y = -y if neg
  y
end
            
cos(x, prec) click to toggle source

Computes the cosine of x to the specified number of digits of precision.

If x is infinite or NaN, returns NaN.

 
               # File bigdecimal/lib/bigdecimal/math.rb, line 85
def cos(x, prec)
  raise ArgumentError, "Zero or negative precision for cos" if prec <= 0
  return BigDecimal("NaN") if x.infinite? || x.nan?
  n    = prec + BigDecimal.double_fig
  one  = BigDecimal("1")
  two  = BigDecimal("2")
  x = -x if x < 0
  if x > (twopi = two * BigMath.PI(prec))
    if x > 30
      x = twopi
    else
      x -= twopi while x > twopi
    end
  end
  x1 = one
  x2 = x.mult(x,n)
  sign = 1
  y = one
  d = y
  i = BigDecimal("0")
  z = one
  while d.nonzero? && ((m = n - (y.exponent - d.exponent).abs) > 0)
    m = BigDecimal.double_fig if m < BigDecimal.double_fig
    sign = -sign
    x1  = x2.mult(x1,n)
    i  += two
    z  *= (i-one) * i
    d   = sign * x1.div(z,m)
    y  += d
  end
  y
end
            
exp(x, prec) click to toggle source

Computes the value of e (the base of natural logarithms) raised to the power of x, to the specified number of digits of precision.

If x is infinite or NaN, returns NaN.

BigMath::exp(BigDecimal.new(‘1’), 10).to_s -> “0.271828182845904523536028752390026306410273E1”

 
               # File bigdecimal/lib/bigdecimal/math.rb, line 156
def exp(x, prec)
  raise ArgumentError, "Zero or negative precision for exp" if prec <= 0
  return BigDecimal("NaN") if x.infinite? || x.nan?
  n    = prec + BigDecimal.double_fig
  one  = BigDecimal("1")
  x = -x if neg = x < 0
  x1 = one
  y  = one
  d  = y
  z  = one
  i  = 0
  while d.nonzero? && ((m = n - (y.exponent - d.exponent).abs) > 0)
    m = BigDecimal.double_fig if m < BigDecimal.double_fig
    x1  = x1.mult(x,n)
    i += 1
    z *= i
    d  = x1.div(z,m)
    y += d
  end
  if neg
    one.div(y, prec)
  else
    y.round(prec - y.exponent)
  end
end
            
log(x, prec) click to toggle source

Computes the natural logarithm of x to the specified number of digits of precision.

Returns x if x is infinite or NaN.

 
               # File bigdecimal/lib/bigdecimal/math.rb, line 187
def log(x, prec)
  raise ArgumentError, "Zero or negative argument for log" if x <= 0 || prec <= 0
  return x if x.infinite? || x.nan?
  one = BigDecimal("1")
  two = BigDecimal("2")
  n  = prec + BigDecimal.double_fig
  if (expo = x.exponent) < 0 || expo >= 3
    x = x.mult(BigDecimal("1E#{-expo}"), n)
  else
    expo = nil
  end
  x  = (x - one).div(x + one,n)
  x2 = x.mult(x,n)
  y  = x
  d  = y
  i = one
  while d.nonzero? && ((m = n - (y.exponent - d.exponent).abs) > 0)
    m = BigDecimal.double_fig if m < BigDecimal.double_fig
    x  = x2.mult(x,n)
    i += two
    d  = x.div(i,m)
    y += d
  end
  y *= two
  if expo
    y += log(BigDecimal("10"),prec) * BigDecimal(expo.to_s)
  end
  y
end
            
sin(x, prec) click to toggle source

Computes the sine of x to the specified number of digits of precision.

If x is infinite or NaN, returns NaN.

 
               # File bigdecimal/lib/bigdecimal/math.rb, line 49
def sin(x, prec)
  raise ArgumentError, "Zero or negative precision for sin" if prec <= 0
  return BigDecimal("NaN") if x.infinite? || x.nan?
  n    = prec + BigDecimal.double_fig
  one  = BigDecimal("1")
  two  = BigDecimal("2")
  x = -x if neg = x < 0
  if x > (twopi = two * BigMath.PI(prec))
    if x > 30
      x = twopi
    else
      x -= twopi while x > twopi
    end
  end
  x1   = x
  x2   = x.mult(x,n)
  sign = 1
  y    = x
  d    = y
  i    = one
  z    = one
  while d.nonzero? && ((m = n - (y.exponent - d.exponent).abs) > 0)
    m = BigDecimal.double_fig if m < BigDecimal.double_fig
    sign = -sign
    x1  = x2.mult(x1,n)
    i  += two
    z  *= (i-one) * i
    d   = sign * x1.div(z,m)
    y  += d
  end
  neg ? -y : y
end
            
sqrt(x,prec) click to toggle source

Computes the square root of x to the specified number of digits of precision.

BigDecimal.new('2').sqrt(16).to_s

-> "0.14142135623730950488016887242096975E1"
 
               # File bigdecimal/lib/bigdecimal/math.rb, line 42
def sqrt(x,prec)
  x.sqrt(prec)
end
            

Commenting is here to help enhance the documentation. For example, code samples, or clarification of the documentation.

If you have questions about Ruby or the documentation, please post to one of the Ruby mailing lists. You will get better, faster, help that way.

If you wish to post a correction of the docs, please do so, but also file bug report so that it can be corrected for the next release. Thank you.

If you want to help improve the Ruby documentation, please visit Documenting-ruby.org.

blog comments powered by Disqus