require 'bigdecimal'
a=BigDecimal::new("0.123456789123456789")
b=BigDecimal("123456.78912345678",40)
c=a+b
�ȉ��̃��\�b�h�ȊO�ɂ��A(C �ł͂Ȃ�) Ruby �\�[�X�̌`��
����Ă�����̂�����܂��B�Ⴆ�A
�Ƃ��邱�ƂŁAsin �� cos �Ƃ����������g�p�ł���悤�ɂȂ�܂��B
�g�p���@�ȂǁA�ڍׂ� math.rb �̓��e���Q�Ƃ��ĉ������B
���̑��AFloat �Ƃ̑��ݕϊ��Ȃǂ̃��\�b�h�� util.rb �ŃT�|�[�g����Ă��܂��B
���p����ɂ�
require "bigdecimal/math.rb"
�̂悤�ɂ��܂��B�ڍׂ� util.rb �̓��e���Q�Ƃ��ĉ������B
require "bigdecimal/util.rb"
�V���� BigDecimal �I�u�W�F�N�g�����܂��B
a=BigDecimal::new(s[,n]) �܂���
a=BigDecimal(s[,n])
s �͐�����\�����鏉���l����Ŏw�肵�܂��B �X�y�[�X�͖�������܂��B�܂��A���f�ł��Ȃ��������o���������_�� ������͏I���������̂Ƃ݂Ȃ���܂��B n �͕K�v�ȗL�������ia �̍ő�L�������j�𐮐��Ŏw�肵�܂��B n �� 0 �܂��͏ȗ����ꂽ�Ƃ��́An �̒l�� s �̗L�������Ƃ݂Ȃ���܂��B s �̗L��������� n ���������Ƃ��� n=0 �̂Ƃ��Ɠ����ł��B a �̍ő�L�������� n ����傢�l���̗p����܂��B �ő�L�������͈ȉ��̂悤�Ȋ���Z�����s����Ƃ����ɈӖ��������܂��B�������A�X�̉��Z�ɂ�����ő�L������ n �̎�舵���͏����̃o�[�W������ ��ύX�����\��������܂��B
BigDecimal("1") / BigDecimal("3") # => 0.3333333333 33E0 BigDecimal("1",10) / BigDecimal("3",10) # => 0.3333333333 3333333333 33333333E0
f = BigDecimal.mode(s[,v])
BigDecimal�̎��s���ʂ𐧌䂵�܂��B��Q�������ȗ��A�܂��� nil ���w�肷��� ����̐ݒ�l���߂�܂��B
�ȉ��̎g�p���@����`����Ă��܂��B[��O����]
�v�Z���ʂ���(NaN)��[���ɂ�鏜�Z�ɂȂ����Ƃ��̏������`���邱�Ƃ��ł��܂��B
f = BigDecimal::mode(BigDecimal::EXCEPTION_NaN,flag)EXCEPTION_NaN �͌��ʂ� NaN �ɂȂ����Ƃ��̎w��ł��B
f = BigDecimal::mode(BigDecimal::EXCEPTION_INFINITY,flag)
f = BigDecimal::mode(BigDecimal::EXCEPTION_UNDERFLOW,flag)
f = BigDecimal::mode(BigDecimal::EXCEPTION_OVERFLOW,flag)
f = BigDecimal::mode(BigDecimal::EXCEPTION_ZERODIVIDE,flag)
f = BigDecimal::mode(BigDecimal::EXCEPTION_ALL,flag)
EXCEPTION_INFINITY �͌��ʂ�������(�}Infinity)�ɂȂ����Ƃ��̎w��ł��B
EXCEPTION_UNDERFLOW �͎w�������A���_�[�t���[����Ƃ��̎w��ł��B
EXCEPTION_OVERFLOW �͎w�������I�[�o�[�t���[����Ƃ��̎w��ł��B
EXCEPTION_ZERODIVIDE �̓[���ɂ�銄��Z�����s�����Ƃ��̎w��ł��B
EXCEPTION_ALL �́A�\�ȑS�Ăɑ��Ĉꊇ���Đݒ肷��Ƃ��Ɏg�p���܂��B
flag �� true �̂Ƃ��́A�w�肵����ԂɂȂ����Ƃ��ɗ�O�s����悤�ɂȂ�܂��B
flag �� false�i�f�t�H���g�j�Ȃ�A��O�͔��s����܂���B�v�Z���ʂ͈ȉ��̂悤�ɂȂ�܂��B
EXCEPTION_NaN �̂Ƃ��A��(NaN)EXCEPTION_INFINITY�AEXCEPTION_OVERFLOW�AEXCEPTION_ZERODIVIDE �͍��̂Ƃ��듯���ł��B
EXCEPTION_INFINITY �̂Ƃ��A����(+ or -Infinity)
EXCEPTION_UNDERFLOW �̂Ƃ��A�[��
EXCEPTION_OVERFLOW �̂Ƃ��A+Infinity �� -Infinity
EXCEPTION_ZERODIVIDE �̂Ƃ��A+Infinity �� -Infinity
�߂�l�́A�ݒ��̒l�ł��B�u�l�v�̈Ӗ��́A�Ⴆ�� BigDecimal::EXCEPTION_NaN�Ɓu�l�v�� & �� �[���ȊO�Ȃ�� EXCEPTION_NaN���ݒ肳��Ă���Ƃ����Ӗ��ł��B[�ۂߏ����w��]
�v�Z�r���̊ۂߑ���̎w�肪�ł��܂��B
f = BigDecimal::mode(BigDecimal::ROUND_MODE,flag)�̌`���Ŏw�肵�܂��B
�����ŁAflag �͈ȉ�(���ʓ��͑Ή�����C���X�^���X���\�b�h)�̈���w�肵�܂��B�߂�l�͎w���� flag �̒l�ł��B ��Q������ nil ���w�肷��ƁA����̐ݒ�l���Ԃ�܂��B mode ���\�b�h�ł͊ۂߑ���̈ʒu�����[�U���w�肷�邱�Ƃ͂ł��܂���B �ۂߑ���ƈʒu�������Ő��䂵�����ꍇ�� BigDecimal::limit �� truncate/round/ceil/floor�A add/sub/mult/div �Ƃ������C���X�^���X���\�b�h���g�p���ĉ������B
ROUND_UP �S�Đ�グ�܂��B ROUND_DOWN �S�Đ�̂Ă܂�(truncate)�B ROUND_HALF_UP �l�̌ܓ����܂�(�f�t�H���g)�B ROUND_HALF_DOWN �̘Z�����܂��B ROUND_HALF_EVEN �l�̘Z�����܂��B�T�̎��͏�ʂP������̎��̂J��グ�܂�(Banker's rounding)�B ROUND_CEILING ���l�̑傫�����ɌJ��グ�܂�(ceil)�B ROUND_FLOOR ���l�̏��������ɌJ�艺���܂�(floor)�B
���������BigDecimal�I�u�W�F�N�g�̍ő包����n���ɐ������܂��B �߂�l�͐ݒ肷��O�̒l�ł��B�ݒ�l�̃f�t�H���g�l�͂O�ŁA�����������Ƃ����Ӗ��ł��B n ���w�肵�Ȃ��A�܂��� n �� nil �̏ꍇ�́A����̍ő包�����Ԃ�܂��B
�v�Z�s����ԂɁA�����̌������������ɑ����Ă��܂��悤�ȏꍇ limit �ŗ\�ߌ����𐧌��ł��܂��B���̏ꍇ BigDecimal.mode �Ŏw�肳�ꂽ �ۂߏ��������s����܂��B �������A�C���X�^���X���\�b�h (truncate/round/ceil/floor/add/sub/mult/div) �� ���������� limit ���D�悳��܂��B
mf = BigDecimal::limit(n)
Ruby �� Float �N���X���ێ��ł���L�������̐���Ԃ��܂��Bdouble_fig�͈ȉ��� C �v���O�����̌��ʂƓ����ł��B
p BigDecimal::double_fig # ==> 20 (depends on the CPU etc.)
double v = 1.0; int double_fig = 0; while(v + 1.0 > 1.0) { ++double_fig; v /= 10; }
�����Ŏg�p������̒l�ł��B������ 32 �r�b�g�̏����n�ł�10000�ł��B
b = BigDecimal::BASE
���Z�ic = a + b�j
c �̐��x�ɂ��Ắu�v�Z���x�ɂ����v���Q�Ƃ��Ă��������B
���Z�ic = a - b�j�A�܂��͕������]�ic = -a�j
c �̐��x�ɂ��Ắu�v�Z���x�ɂ����v���Q�Ƃ��Ă��������B
��Z(c = a * b)
c�̐��x��(a�̐��x)+(b�̐��x)���x�ł��B
�ڂ����́u�v�Z���x�ɂ����v���Q�Ƃ��Ă��������B
���Z(c = a / b)
c �̐��x�ɂ��Ắu�v�Z���x�ɂ����v���Q�Ƃ��Ă��������B
�ȉ��̂悤�Ɏg�p���܂��B
c = a.add(b,n)
c = a + b ���ő�� n ���܂Ōv�Z���܂��B
a + b �̐��x�� n ���傫���Ƃ��� BigDecimal.mode �Ŏw�肳�ꂽ���@�Ŋۂ߂��܂��B
n ���[���Ȃ� + �Ɠ����ł��B
�ȉ��̂悤�Ɏg�p���܂��B
c = a.sub(b,n)
c = a - b ���ő�� n ���܂Ōv�Z���܂��B
a - b �̐��x�� n ���傫���Ƃ��� BigDecimal.mode �Ŏw�肳�ꂽ���@�Ŋۂ߂��܂��B
n ���[���Ȃ� - �Ɠ����ł��B
�ȉ��̂悤�Ɏg�p���܂��B
c = a.mult(b,n)
c = a * b ���ő�� n ���܂Ōv�Z���܂��B
a * b �̐��x�� n ���傫���Ƃ��� BigDecimal.mode �Ŏw�肳�ꂽ���@�Ŋۂ߂��܂��B
n ���[���Ȃ� * �Ɠ����ł��B
�ȉ��̂悤�Ɏg�p���܂��B
c = a.div(b,n)
c = a / b ���ő�� n ���܂Ōv�Z���܂��B a / b �̐��x�� n ���傫���Ƃ��� BigDecimal.mode �Ŏw�肳�ꂽ���@�Ŋۂ߂��܂��B
n ���[���Ȃ� / �Ɠ����ł��B
n ���ȗ����ꂽ�Ƃ��� Float#div �Ɠ��l�Ɍ��ʂ�����(BigDecimal)�ɂȂ�܂��B
a �̏����_�ȉ��̐�̂āB
c = a.fix
a �̐��������̐�̂āB
c = a.frac
c = a.floor
a �ȉ��̍ő吮���iBigDecimal �l�j��Ԃ��܂��B�ȉ��̂悤�Ɉ��� n ��^���邱�Ƃ��ł��܂��B
c = BigDecimal("1.23456").floor # ==> 1 c = BigDecimal("-1.23456").floor # ==> -2
n>=0 �Ȃ�A�����_�ȉ� n+1 �ʂ̐����𑀍삵�܂�(�����_�ȉ����A�ő� n ���ɂ��܂�)�B
n �����̂Ƃ��͏����_�ȏ� n ���ڂ𑀍삵�܂�(�����_�ʒu���獶�ɏ��Ȃ��Ƃ� n �� 0 �����т܂�)�B
c = BigDecimal("1.23456").floor(4) # ==> 1.2345 c = BigDecimal("15.23456").floor(-1) # ==> 10.0
c = a.ceil
a �ȏ�̐����̂����A�ł��������������v�Z���A���̒l�iBigDecimal �l�j��Ԃ��܂��B�ȉ��̂悤�Ɉ�����^���āA�����_�ȉ� n+1 �ʂ̐����𑀍삷�邱�Ƃ��ł��܂��B
c = BigDecimal("1.23456").ceil # ==> 2 c = BigDecimal("-1.23456").ceil # ==> -1
n>=0 �Ȃ�A�����_�ȉ� n+1 �ʂ̐����𑀍삵�܂�(�����_�ȉ����A�ő� n ���ɂ��܂�)�B
n �����̂Ƃ��͏����_�ȏ� n ���ڂ��𑀍삵�܂�(�����_�ʒu���獶�ɏ��Ȃ��Ƃ� n �� 0 �����т܂�)�B
c = BigDecimal("1.23456").ceil(4) # ==> 1.2346 c = BigDecimal("15.23456").ceil(-1) # ==> 20.0
c = a.round
�N���X���\�b�h BigDecimal::mode(BigDecimal::ROUND_MODE,flag) �Ŏw�肵�� ROUND_MODE �ɏ]���Ċۂߑ�������s���܂��B BigDecimal::mode(BigDecimal::ROUND_MODE,flag) �ʼn����w�肹���A���A���� ���w�肵�Ȃ��ꍇ�́u�����_�ȉ����ʂ̐����l�̌ܓ����Đ����iBigDecimal �l�j�v�ɂ��܂��B
�ȉ��̂悤�Ɉ�����^���āA�����_�ȉ� n+1 �ʂ̐����𑀍삷�邱�Ƃ��ł��܂��B
c = BigDecimal("1.23456").round # ==> 1 c = BigDecimal("-1.23456").round # ==> -1
n �����̎��́A�����_�ȉ� n+1 �ʂ̐������ۂ߂܂�(�����_�ȉ����A�ő� n ���ɂ��܂�)�B
n �����̂Ƃ��͏����_�ȏ� n ���ڂ��ۂ߂܂�(�����_�ʒu���獶�ɏ��Ȃ��Ƃ� n �� 0 �����т܂�)�B�Q�Ԗڂ̈������w�肷��ƁABigDecimal#mode �̎w������āA�w�肳�ꂽ���@�� �ۂߑ�������s���܂��B
c = BigDecimal("1.23456").round(4) # ==> 1.2346 c = BigDecimal("15.23456").round(-1) # ==> 20.0
c = BigDecimal("1.23456").round(3,BigDecimal::ROUND_HALF_EVEN) # ==> 1.234 c = BigDecimal("1.23356").round(3,BigDecimal::ROUND_HALF_EVEN) # ==> 1.234
c = a.truncate
�����_�ȉ��̐����̂ĂĐ����iBigDecimal �l�j�ɂ��܂��B
�ȉ��̂悤�Ɉ�����^���āA�����_�ȉ� n+1 �ʂ̐����𑀍삷�邱�Ƃ��ł��܂��B
n �����̎��́A�����_�ȉ� n+1 �ʂ̐������̂Ă܂�(�����_�ȉ����A�ő� n ���ɂ��܂�)�B n �����̂Ƃ��͏����_�ȏ� n ���ڂ��𑀍삵�܂�(�����_�ʒu���獶�ɏ��Ȃ��Ƃ� n �� 0 �����т܂�)�B
c = BigDecimal("1.23456").truncate(4) # ==> 1.2345 c = BigDecimal("15.23456").truncate(-1) # ==> 10.0
���̐�Βl
c = a.abs
�����_�ȉ����̂ĂĐ����ɕϊ����܂��B
i = a.to_i
i �͒l�ɉ����� Fixnum �� Bignum �ɂȂ�܂��B a �� Infinity �� NaN �̂Ƃ��Ai �� nil �ɂȂ�܂��B
Float �I�u�W�F�N�g�ɕϊ����܂��B ��肫�ߍׂ����l���K�v�Ȃ�� split ���\�b�h�𗘗p���� ���������B
������ɕϊ����܂�(�f�t�H���g�� "0.xxxxxEn" �̌`�ɂȂ�܂��j�B���� n �ɐ��̐������w�肳�ꂽ�Ƃ��́A�����_�ŕ������鍶�E�������A���ꂼ�� n ���� �ɋŋ��܂��B
BigDecimal("1.23456").to_s # ==> "0.123456E1"���� n �ɐ��̐�����\����������w�肷�邱�Ƃ��ł��܂��B
BigDecimal("0.1234567890123456789").to_s(10) # ==> "0.1234567890 123456789E0"������̍ŏ��� '+'�i�܂��� ' '�j��t����ƁA�l�����̏ꍇ�A�擪�� '+'�i�܂��� ' '�j���t���܂� �i���̏ꍇ�́A��� '-' ���t���܂��B�j�B
BigDecimal("0.1234567890123456789").to_s("10") # ==> "0.1234567890 123456789E0"����ɕ�����̍Ō�� E(�܂��� e) �� F(�܂��� f) ���w�肷�邱�ƂŁA�ȉ��̂悤�� �\���`����ύX���邱�Ƃ��ł��܂��B
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"
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"
�w�����𐮐��l�ŕԂ��܂��B n = a.exponent
�� a �̒l�� 0.xxxxxxx*10**n ���Ӗ����܂��B
n,m = a.precs
a �̗L������ (n) �ƍő�L������ (m) �̔z���Ԃ��܂��B
�l����(sign > 0)�A��(sign < 0)�A���̑�(sigh==0)�ł��邩�̏���Ԃ��܂��B n = a.sign
�Ƃ����Ƃ� n �̒l�� a ���ȉ��̂Ƃ����Ӗ����܂��B
() �̒��̐����́A���ۂ̒l�ł�(�u�����\���v���Q��)�B
n = BigDecimal::SIGN_NaN(0) : a �� NaN
n = BigDecimal::SIGN_POSITIVE_ZERO(1) : a �� +0
n = BigDecimal::SIGN_NEGATIVE_ZERO(-1) : a �� -0
n = BigDecimal::SIGN_POSITIVE_FINITE(2) : a �͐��̒l
n = BigDecimal::SIGN_NEGATIVE_FINITE(-2) : a �͕��̒l
n = BigDecimal::SIGN_POSITIVE_INFINITE(3) : a ��+Infinity
n = BigDecimal::SIGN_NEGATIVE_INFINITE(-3) : a ��-Infinity
a.nan? �� a ��NaN�̂Ƃ��^��Ԃ��܂��B
a.infinite? �� a ��+���̂Ƃ� 1 �A-���̂Ƃ��� -1�A����ȊO�̂Ƃ��� nil ��Ԃ��܂��B
a.finite? �� a �����܂��� NaN �łȂ��Ƃ��^��Ԃ��܂��B
a �� 0 �Ȃ� true �ɂȂ�܂��B
c = a.zero?
a �� 0 �Ȃ� nil�A0 �ȊO�Ȃ� a ���̂��̂��Ԃ�܂��B
c = a.nonzero?
BigDecimal �l�� 0.xxxxxxx*10**n �ƕ\�������Ƃ��ɁA�����iNaN�̂Ƃ��� 0�A����ȊO��+1��-1�ɂȂ�܂��j�A ���������̕�����i"xxxxxxx"�j�ƁA��i10�j�A�X�Ɏw�� n ��z��� �Ԃ��܂��B
a=BigDecimal::new("3.14159265")
f,x,y,z = a.split
�Ƃ���ƁAf=+1�Ax="314159265"�Ay=10�Az=1�ɂȂ�܂��B
�]���āA
s = "0."+x
b = f*(s.to_f)*(y**z)
�� Float �ɕϊ����邱�Ƃ��ł��܂��B
�f�o�b�O�o�͂Ɏg�p����܂��B
p a=BigDecimal::new("3.14",10)
�Ƃ���ƁA[0x112344:'0.314E1',4(12)]�̂悤�ɏo�͂���܂��B �ŏ���16�i���̓I�u�W�F�N�g�̃A�h���X�A���� '0.314E1' �͒l�A ����4�͌��݂̗L������(�\������傫�����Ƃ�����܂�)�A �Ō�̓I�u�W�F�N�g����蓾��ő包���ɂȂ�܂��B
a �� n ����v�Z���܂��B���͐����B
c = a ** n
���ʂƂ��� c �̗L������ a �� n �{�ȏ�ɂȂ�̂Œ��ӁB
** �Ɠ����ŁAa �� n ����v�Z���܂��B���͐����B
c = a.power(n)
���ʂƂ��� c �̗L������ a �� n �{�ȏ�ɂȂ�̂Œ��ӁB
a�̗L���� n ���̕������in �̕������ł͂���܂���j�� �j���[�g���@�Ōv�Z���܂��B
c = a.sqrt(n)
�ڍׂ͑Ή����� Float �̊e���\�b�h���Q�Ƃ��ĉ������B
a==b �Ȃ� 0�Aa > b �Ȃ� 1�Aa < b �Ȃ� -1 �ɂȂ�܂��B
c = a <=> b
a = BigDecimal.E(20)
c = a * "0.123456789123456789123456789" # ������ BigDecimal �ɕϊ����Ă���v�Z
��������\�������Ƃ��āA"Infinity"�A"+Infinity"�A"-Infinity"�A"NaN"
���g�p�ł��܂�(�啶���E����������ʂ��܂�)�B�������Amode ���\�b�h�� false ��
�w�肵���ꍇ�͗�O���������܂��B
a = BigDecimal.E(20)
c = "0.123456789123456789123456789" * a # �G���[
�K�v��������Ƃ͎v���܂��A�ǂ����Ă��ƌ����l��
String �I�u�W�F�N�g���p�������V���ȃN���X���쐬���Ă���A
���̃N���X�� coerce ���T�|�[�g���Ă��������B
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 {
unsigned long MaxPrec; // �ő吸�x(frac[]�̔z��T�C�Y)
unsigned long Prec; // ���x(frac[]�̎g�p�T�C�Y)
short sign; // �ȉ��̂悤�ɕ������̏�Ԃ��`���܂��B
// ==0 : NaN
// 1 : +0
// -1 : -0
// 2 : ���̒l
// -2 : ���̒l
// 3 : +Infinity
// -3 : -Infinity
unsigned short flag; // �e��̐���t���b�O
int exponent; // �w�����̒l(������*BASE**exponent)
unsigned long frac[1]; // �������̔z��(��)
} Real;
�Ⴆ�� 1234.56784321 �Ƃ���������(BASE=10000�Ȃ�)0.1234 5678 4321*(10000)**1�ł����� frac[0]=1234�Afrac[1]=5678�Afrac[2]=4321�A Prec=3�Asign=2�Aexponent=1 �ƂȂ�܂��BMaxPrec�� Prec ���傫��������ł����܂��܂���Bflag �� �g�p���@�͎����Ɉˑ����ē����Ŏg�p����܂��B
file = File::open(....,"r")
s = BigDecimal::new("0")
while line = file.gets
s = s + line
end
���̗��2�i���ł��ƌ덷�����荞�މ\��������܂��B
�Ⴆ�� 0.1 ��2�i�ŕ\������� 0.1 = b1*2**(-1)+b1*2**(-2)+b3*2**(-3)+b4*2**(-4)....
�Ɩ����ɑ����Ă��܂��܂�(b1=0,b2=0,b3=0,b4=1...)�B������ bn(n=1,2,3,...) ��
2�i��\������ 0 �� 1 �̐�����ł��B�]���āA�ǂ����őł���K�v������܂��B
�����ŕϊ��덷������܂��B�������A������ēx10�i�\�L�ɂ��Ĉ������悤��
�ꍇ�͓K�Ȋۂߑ���i�l�̌ܓ��j�ɂ���čĂ� "0.1" �ƕ\������܂��B�������A
�����ł͐��m�� 0.1 �ł͂���܂���B
�����̃��\�b�h�͐擪(�ō�)�̐�������̌������w��ł��܂��B
BigDecimal("2").div(3,12) # 2.0/3.0 => 0.6666666666 67E0
�����̃��\�b�h�͏����_����̑��Έʒu���w�肵�Č��������肵�܂��B
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