Software: Apache/2.2.22 (Debian). PHP/5.6.36 

uname -a: Linux h05.hvosting.ua 4.9.110-amd64 #3 SMP Sun Nov 4 16:27:09 UTC 2018 x86_64 

uid=1389(h33678) gid=1099(h33678) groups=1099(h33678),502(mgrsecure) 

Safe-mode: OFF (not secure)

/usr/share/doc/libruby1.9.1/bigdecimal/   drwxr-xr-x
Free 1.32 GB of 7.22 GB (18.23%)
                            Encoder    Tools    Proc.    FTP brute    Sec.    SQL    PHP-code    Update    Feedback    Self remove    Logout    

Viewing file:     bigdecimal_en.html (30.07 KB)      -rw-r--r--

BigDecimal(Variable Precision Floating Library for Ruby)

• http://www.ruby-lang.org/en/:Official Ruby page(English).
• http://kahori.com/ruby/ring/:Mutually linked pages relating to Ruby(Japanese).

Contents

• Introduction
• Usage and methods
• Infinity,NaN,Zero
• Internal structure
• Binary or decimal number representation
• Resulting number of significant digits

Installation

   require 'bigdecimal'
   a=BigDecimal::new("0.123456789123456789")
   b=BigDecimal("123456.78912345678",40)
   c=a+b

require "bigdecimal/math.rb"

require "bigdecimal/util.rb"

• +

addition(c = a + b)
For the resulting number of significant digits of c,see Resulting number of significant digits.

• -

subtraction (c = a - b) or negation (c = -a)
For the resulting number of significant digits of c,see Resulting number of significant digits.

• *

multiplication(c = a * b)
For the resulting number of significant digits of c,see Resulting number of significant digits.

• /

division(c = a / b)
For the resulting number of significant digits of c,see Resulting number of significant digits.

• add(b,n)

c = a.add(b,n)
c = a.add(b,n) performs c = a + b.
If n is less than the actual significant digits of a + b, then c is rounded properly according to the BigDecimal.limit.
If n is zero,then the result is the same as +'s.

• sub(b,n)

c = a.sub(b,n)
c = a.sub(b,n) performs c = a - b.
If n is less than the actual significant digits of a - b, then c is rounded properly according to the BigDecimal.limit.
If n is zero,then the result is the same as -'s.

• mult(b,n)

c = a.mult(b,n)
c = a.mult(b,n) performs c = a * b.
If n is less than the actual significant digits of a * b, then c is rounded properly according to the BigDecimal.limit.
If n is zero,then the result is the same as *'s.

• div(b[,n])

c = a.div(b,n)
c = a.div(b,n) performs c = a / b.
If n is less than the actual significant digits of a / b, then c is rounded properly according to the BigDecimal.limit.
If n is zero,then the result is the same as /'s. If n is not given,then the result will be an integer(BigDecimal) like Float#div.

• fix

c = a.fix
returns integer part of a.


• frac

c = a.frac
returns fraction part of a.


• floor[(n)]

c = a.floor
returns the maximum integer value (in BigDecimal) which is less than or equal to a.

 c = BigDecimal("1.23456").floor  #  ==> 1
 c = BigDecimal("-1.23456").floor #  ==> -2

As shown in the following example,an optional integer argument (n) specifying the position of the target digit can be given.
If n> 0,then the (n+1)th digit counted from the decimal point in fraction part is processed(resulting number of fraction part digits is less than or equal to n).
If n<0,then the n-th digit counted from the decimal point in integer part is processed(at least n 0's are placed from the decimal point to left).

 c = BigDecimal("1.23456").floor(4)   #  ==> 1.2345
 c = BigDecimal("15.23456").floor(-1) #  ==> 10.0

• ceil[(n)]

c = a.ceil
returns the minimum integer value (in BigDecimal) which is greater than or equal to a.

 c = BigDecimal("1.23456").ceil  #  ==> 2
 c = BigDecimal("-1.23456").ceil #  ==> -1

As shown in the following example,an optional integer argument (n) specifying the position of the target digit can be given.
If n>0,then the (n+1)th digit counted from the decimal point in fraction part is processed(resulting number of fraction part digits is less than or equal to n).
If n<0,then the n-th digit counted from the decimal point in integer part is processed(at least n 0's are placed from the decimal point to left).

 c = BigDecimal("1.23456").ceil(4)   # ==> 1.2346
 c = BigDecimal("15.23456").ceil(-1) # ==> 20.0

• round[(n[,b])]

c = a.round
round a to the nearest 1(default)ÅD


 c = BigDecimal("1.23456").round  #  ==> 1
 c = BigDecimal("-1.23456").round #  ==> -1

The rounding operation changes according to BigDecimal::mode(BigDecimal::ROUND_MODE,flag) if specified. As shown in the following example,an optional integer argument (n) specifying the position of the target digit can be given.
If n>0,then the (n+1)th digit counted from the decimal point in fraction part is processed(resulting number of fraction part digits is less than or equal to n).
If n<0,then the n-th digit counted from the decimal point in integer part is processed(at least n 0's are placed from the decimal point to left).

c = BigDecimal::new("1.23456").round(4)   #  ==> 1.2346
c = BigDecimal::new("15.23456").round(-1) #  ==> 20.0

Rounding operation can be specified by setting the second optional argument b with the valid ROUND_MODE.


c = BigDecimal::new("1.23456").round(3,BigDecimal::ROUND_HALF_EVEN)   #  ==> 1.234
c = BigDecimal::new("1.23356").round(3,BigDecimal::ROUND_HALF_EVEN)   #  ==> 1.234

• truncate[(n)]

c = a.truncate
truncate a to the nearest 1ÅD
As shown in the following example,an optional integer argument (n) specifying the position of the target digit can be given.
If n>0,then the (n+1)th digit counted from the decimal point in fraction part is processed(resulting number of fraction part digits is less than or equal to n).
If n<0,then the n-th digit counted from the decimal point in integer part is processed(at least n 0's are placed from the decimal point to left).

c = BigDecimal::new("1.23456").truncate(4)   #  ==> 1.2345
c = BigDecimal::new("15.23456").truncate(-1) #  ==> 10.0

• abs

c = a.abs
returns an absolute value of a.


• to_i

changes a to an integer.
i = a.to_i
i becomes to Fixnum or Bignum. If a is Infinity or NaN,then i becomes to nil.

• to_s[(n)]

converts to string(default results look like "0.xxxxxEn").

BigDecimal("1.23456").to_s  #  ==> "0.123456E1"

If n(>0) is given,then a space is inserted to each of two parts divided by the decimal point after every n digits for readability.

BigDecimal("0.1234567890123456789").to_s(10)   #  ==> "0.1234567890 123456789E0"

n can be a string representing a positive integer number.

BigDecimal("0.1234567890123456789").to_s("10") #  ==> "0.1234567890 123456789E0"

If the first character is '+'(or ' '),then '+'(or ' ') will be set before value string when the value is positive.

BigDecimal("0.1234567890123456789").to_s(" 10") #  ==> " 0.1234567890 123456789E0"
BigDecimal("0.1234567890123456789").to_s("+10") #  ==> "+0.1234567890 123456789E0"
BigDecimal("-0.1234567890123456789").to_s("10") #  ==> "-0.1234567890 123456789E0"

At the end of the string,'E'(or 'e') or 'F'(or 'f') can be specified to change number representation.

BigDecimal("1234567890.123456789").to_s("E")  #  ==> "0.1234567890123456789E10"
BigDecimal("1234567890.123456789").to_s("F")  #  ==> "1234567890.123456789"
BigDecimal("1234567890.123456789").to_s("5E") #  ==> "0.12345 67890 12345 6789E10"
BigDecimal("1234567890.123456789").to_s("5F") #  ==> "12345 67890.12345 6789"

• exponent

returns an integer holding exponent value of a.
n = a.exponent
means a = 0.xxxxxxx*10**n.

• precs

n,m = a.precs
precs returns number of significant digits (n) and maximum number of significant digits (m) of a.

• to_f

Creates a new Float object having (nearly) the same value. Use split method if you want to convert by yourself.

• sign

n = a.sign
returns positive value if a > 0,negative value if a < 0, otherwise zero if a == 0.
where the value of n means that a is:
n = BigDecimal::SIGN_NaN(0) : a is NaN
n = BigDecimal::SIGN_POSITIVE_ZERO(1) : a is +0
n = BigDecimal::SIGN_NEGATIVE_ZERO(-1) : a is -0
n = BigDecimal::SIGN_POSITIVE_FINITE(2) : a is positive
n = BigDecimal::SIGN_NEGATIVE_FINITE(-2) : a is negative
n = BigDecimal::SIGN_POSITIVE_INFINITE(3) : a is +Infinity
n = BigDecimal::SIGN_NEGATIVE_INFINITE(-3) : a is -Infinity
The value in () is the actual value,see (Internal structure.


• nan?

a.nan? returns True when a is NaN.

• infinite?

a.infinite? returns 1 when a is Infinity, -1 when a is -Infinity, nil otherwise.

• finite?

a.finite? returns true when a is neither Infinity nor NaN.

• zero?

c = a.zero?
returns true if a is equal to 0,otherwise returns false


• nonzero?

c = a.nonzero?
returns nil if a is 0,otherwise returns a itself.


• split

decomposes a BigDecimal value to 4 parts. All 4 parts are returned as an array.
Parts consist of a sign(0 when the value is NaN,+1 for positive and -1 for negative value), a string representing fraction part,base value(always 10 currently),and an integer(Fixnum) for exponent respectively. a=BigDecimal::new("3.14159265")
f,x,y,z = a.split
where f=+1,x="314159265",y=10 and z=1
therefore,you can translate BigDecimal value to Float as:
s = "0."+x
b = f*(s.to_f)*(y**z)


• inspect

is used for debugging output.
p a=BigDecimal::new("3.14",10)
should produce output like "#<0x112344:'0.314E1',4(12)%gt;". where "0x112344" is the address, '0.314E1' is the value,4 is the number of the significant digits, and 12 is the maximum number of the significant digits the object can hold.

• sqrt

c = a.sqrt(n)
computes square root value of a with significant digit number n at least.


• **

c = a ** n
returns the value of a powered by n. n must be an integer.


• power

The same as ** method.
c = a.power(n)
returns the value of a powered by n(c=a**n). n must be an integer.


• divmod,quo,modulo,%,remainder

See,corresponding methods in Float class.

• <=>

c = a <=> b
returns 0 if a==b,1 if a > b,and returns -1 if a < b.

• ==
• ===
same as ==,used in case statement.
• !=
• <
• <=
• >
• >=

About 'coerce'

1.Both A and B are BigDecimal objects

A op B is normally performed.

2.A is the BigDecimal object but B is other than BigDecimal object

Operation is performed,after B is translated to corresponding BigDecimal object(because BigDecimal supports coerce method).

3.A is not the BigDecimal object but B is BigDecimal object

If A has coerce method,then B will translate A to corresponding BigDecimal object and the operation is performed,otherwise an error occures.

  a = BigDecimal.E(20)
  c = a * "0.123456789123456789123456789" # A String is changed to BigDecimal object.

  a = BigDecimal.E(20)
  c = "0.123456789123456789123456789" * a # ERROR

 require "bigdecimal"
 aa  = %w(1 -1 +0.0 -0.0 +Infinity -Infinity NaN)
 ba  = %w(1 -1 +0.0 -0.0 +Infinity -Infinity NaN)
 opa = %w(+ - * / <=> > >=  < == != <=)
 for a in aa
  for b in ba
    for op in opa
      x = BigDecimal::new(a)
      y = BigDecimal::new(b)
      eval("ans= x #{op} y;print a,' ',op,' ',b,' ==> ',ans.to_s,\"\n\"")
    end
  end
 end

  typedef struct {
     VALUE  obj;     /* Back pointer(VALUE) for Ruby object.         */
     unsigned long MaxPrec; /* The size of the array frac[]          */
     unsigned long Prec;    /* Current size of frac[] actually used. */
     short    sign;         /* Attribute of the value.  */
                            /*  ==0 : NaN               */
                            /*    1 : +0                */
                            /*   -1 : -0                */
                            /*    2 : Positive number   */
                            /*   -2 : Negative number   */
                            /*    3 : +Infinity         */
                            /*   -3 : -Infinity         */
     unsigned short flag;   /* Control flag             */
     int      exponent;     /* Exponent value(0.xxxx*BASE**exponent) */
     unsigned long frac[1]; /* An array holding mantissa(Variable)   */
  } Real;

    0.1234 5678 4321*(10000)**1

 BigDecimal("2").div(3,12) # 2.0/3.0 => 0.6666666666 67E0

 BigDecimal("6.66666666666666").round(12) # => 0.6666666666 667E1

#!/usr/local/bin/ruby

require "bigdecimal"
#
# Calculates 3.1415.... (the number of times that a circle's diameter
# will fit around the circle) using J. Machin's formula.
#
def big_pi(sig) # sig: Number of significant figures
  exp    = -sig
  pi     = BigDecimal::new("0")
  two    = BigDecimal::new("2")
  m25    = BigDecimal::new("-0.04")
  m57121 = BigDecimal::new("-57121")

  u = BigDecimal::new("1")
  k = BigDecimal::new("1")
  w = BigDecimal::new("1")
  t = BigDecimal::new("-80")
  while (u.nonzero? && u.exponent >= exp)
    t   = t*m25
    u   = t.div(k,sig)
    pi  = pi + u
    k   = k+two
  end

  u = BigDecimal::new("1")
  k = BigDecimal::new("1")
  w = BigDecimal::new("1")
  t = BigDecimal::new("956")
  while (u.nonzero? && u.exponent >= exp )
    t   = t.div(m57121,sig)
    u   = t.div(k,sig)
    pi  = pi + u
    k   = k+two
  end
  pi
end

if $0 == __FILE__
  if ARGV.size == 1
    print "PI("+ARGV[0]+"):\n"
    p big_pi(ARGV[0].to_i)
  else
    print "TRY: ruby pi.rb 1000 \n"
  end
end