Lines Matching +defs:math +defs:sqrt
49 package require math::bignum
52 catch {namespace delete ::math::bigfloat}
56 # it is using the package math::bignum
57 namespace eval ::math::bigfloat {
66 set zero [::math::bignum::fromstr 0]
68 set one [::math::bignum::fromstr 1]
70 set two [::math::bignum::fromstr 2]
72 set three [::math::bignum::fromstr 3]
74 set four [::math::bignum::fromstr 4]
76 set five [::math::bignum::fromstr 5]
78 set ten [::math::bignum::fromstr 10]
112 # To learn how it is done in practice, take a look at ::math::bigfloat::_asin
121 proc ::math::bigfloat::abs {number} {
125 return [::math::bignum::abs $number]
128 lset number 1 [::math::bignum::abs [lindex $number 1]]
136 proc ::math::bigfloat::acos {x} {
150 if {[::math::bignum::sign $entier]} {
155 # has to be a bit smaller than 1 ; by using that trick : acos(x)=asin(sqrt(1-x^2))
156 # we can limit the entry of the Taylor development below 1/sqrt(2)
158 # x > sqrt(2)/2 : trying to make _asin converge quickly
163 set fone [list F [::math::bignum::lshift 1 $precision] \
174 # acos(x) = asin(sqrt(1 - x^2))
176 # x> sqrt(2)/2 so x^2 > 1/2 so 1-x^2<1/2
177 set x [sqrt [sub $fone [mul $x $x]]]
178 # the parameter named x is smaller than sqrt(2)/2
182 # x<sqrt(2)/2 here too
190 proc ::math::bigfloat::add {a b} {
195 return [::math::bignum::add $a $b]
215 set integerA [::math::bignum::lshift $integerA $diff]
216 set deltaA [::math::bignum::lshift $deltaA $diff]
217 set integerA [::math::bignum::add $integerA $integerB]
218 set deltaA [::math::bignum::add $deltaA $deltaB]
222 return [normalize [list F [::math::bignum::add $integerA $integerB] \
223 $expA [::math::bignum::add $deltaA $deltaB]]]
226 set integerB [::math::bignum::lshift $integerB $diff]
227 set deltaB [::math::bignum::lshift $deltaB $diff]
228 set integerB [::math::bignum::add $integerA $integerB]
229 set deltaB [::math::bignum::add $deltaB $deltaA]
239 proc ::math::bigfloat::addInt2Float {a b} {
252 set integerA [::math::bignum::lshift $integerA $shift]
253 set deltaA [::math::bignum::lshift $deltaA $shift]
254 set integerA [::math::bignum::add $integerA $b]
260 return [normalize [list F [::math::bignum::add $integerA $b] \
265 set b [::math::bignum::lshift $b [expr {-$expA}]]
266 set integerA [::math::bignum::add $integerA $b]
275 proc ::math::bigfloat::asin {x} {
290 if {[::math::bignum::sign $entier]} {
295 # now a little trick : asin(x)=Pi/2-asin(sqrt(1-x^2))
297 # to 1/sqrt(2)~0.7071
301 set fone [list F [::math::bignum::lshift 1 $precision] \
310 # asin(x)=Pi/2-asin(sqrt(1-x^2))
311 set x [sqrt [sub $fone [mul $x $x]]]
320 proc ::math::bigfloat::_asin {x} {
331 if {$precision+1<[::math::bignum::bits $mantissa]} {
342 set dt [::math::bignum::add 1 [intMulShift $mantissa $delta [expr {$precision-1}]]]
353 set delta [::math::bignum::add [::math::bignum::mul $delta $square] \
354 [::math::bignum::mul $dt [::math::bignum::add $delta $mantissa]]]
355 set delta [::math::bignum::add 1 [::math::bignum::rshift [::math::bignum::div \
356 [::math::bignum::mul $delta $num] $denom] $precision]]
361 set mantissa [::math::bignum::div $mantissa $denom]
366 set mantissa_temp [::math::bignum::div $mantissa $i]
367 set delta_temp [::math::bignum::add 1 [::math::bignum::div $delta $i]]
370 while {![::math::bignum::iszero $mantissa_temp]} {
373 set result [::math::bignum::add $result $mantissa_temp]
374 set delta_final [::math::bignum::add $delta_final $delta_temp]
378 set num [::math::bignum::add $num $two]
379 set i [::math::bignum::add $i $two]
380 set denom [::math::bignum::add $denom $two]
382 set delta [::math::bignum::add [::math::bignum::mul $delta $square] \
383 [::math::bignum::mul $dt [::math::bignum::add $delta $mantissa]]]
384 set delta [::math::bignum::add 1 [::math::bignum::rshift [::math::bignum::div \
385 [::math::bignum::mul $delta $num] $denom] $precision]]
387 set mantissa [::math::bignum::div [::math::bignum::mul $mantissa $num] $denom]
388 set mantissa_temp [::math::bignum::div $mantissa $i]
389 set delta_temp [::math::bignum::add 1 [::math::bignum::div $delta $i]]
397 proc ::math::bigfloat::atan {x} {
414 if {[::math::bignum::sign $mantissa]} {
420 set float1 [list F [::math::bignum::lshift 1 $precision] -$precision $one]
452 # this command is called with x<sqrt(2)-1
454 # (sqrt(2)-1)^(2n-1)/(2n-1) has to be lower than 2^(-precision-n-1)
455 # (2n-1)*log(sqrt(2)-1)-log(2n-1)<-(precision+n+1)*log(2)
456 # 2n(log(sqrt(2)-1)-log(sqrt(2)))<-(precision-1)*log(2)+log(2n-1)+log(sqrt(2)-1)
457 # 2n*log(1-1/sqrt(2))<-(precision-1)*log(2)+log(2n-1)+log(2)/2
458 # 2n/sqrt(2)>(precision-3/2)*log(2)-log(2n-1)
460 # n*sqrt(2)>(precision-1.5)*log(2)+1-2n
461 # n*(sqrt(2)+2)>(precision-1.5)*log(2)+1
462 set n [expr {int((log(2)*($precision-1.5)+1)/(sqrt(2)+2)+1)}]
464 set mantissa [::math::bignum::lshift $mantissa $n]
465 set delta [::math::bignum::lshift $delta $n]
483 set delta_square [::math::bignum::lshift $delta 1]
488 set delta [::math::bignum::add 1 [::math::bignum::rshift [::math::bignum::add \
489 [::math::bignum::mul $delta_square $mantissa] \
490 [::math::bignum::mul $delta $square]] $precision]]
493 set t [::math::bignum::div $temp $divider]
494 set dt [::math::bignum::add 1 [::math::bignum::div $delta $divider]]
495 while {![::math::bignum::iszero $t]} {
496 set result [::math::bignum::add $result $t]
497 set delta_end [::math::bignum::add $delta_end $dt]
498 set divider [::math::bignum::add $divider $two]
499 set delta [::math::bignum::add 1 [::math::bignum::rshift [::math::bignum::add \
500 [::math::bignum::mul $delta_square [abs $temp]] [::math::bignum::mul $delta \
501 [::math::bignum::add $delta_square $square]]] $precision]]
503 set t [::math::bignum::div $temp $divider]
504 set dt [::math::bignum::add [::math::bignum::div $delta $divider] $one]
517 proc ::math::bigfloat::_atanfract {integer precision} {
542 set a [::math::bignum::div [::math::bignum::lshift 1 $precision] $integer]
551 set square [::math::bignum::mul $integer $integer]
556 set t [opp [::math::bignum::div $a $square]]
557 set u [::math::bignum::div $t $denom]
559 while {![::math::bignum::iszero $u]} {
560 set s [::math::bignum::add $s $u]
562 set denom [::math::bignum::add $denom $two]
564 set t [opp [::math::bignum::div $t $square]]
565 set u [::math::bignum::div $t $denom]
568 return [::math::bignum::rshift $s $n]
577 proc ::math::bigfloat::ceil {number} {
590 set sign [::math::bignum::sign $integer]
593 set try [::math::bignum::rshift $integer [expr {-$exp}]]
598 if {![equal [::math::bignum::lshift $try [expr {-$exp}]] $integer]} {
599 return [::math::bignum::add 1 $try]
609 proc ::math::bigfloat::checkFloat {args} {
622 proc ::math::bigfloat::checkNumber {args} {
636 proc ::math::bigfloat::compare {a b} {
638 return [::math::bignum::cmp $a $b]
642 return [expr {([::math::bignum::sign [lindex [sub $a $b] 1]])?-1:1}]
652 proc ::math::bigfloat::cos {x} {
664 set delta [::math::bignum::add [abs $n] $delta]
680 ::math::bignum::setsign integer $signe
692 proc ::math::bigfloat::_cos2 {x precision delta} {
695 set pis4 [::math::bignum::rshift $pi 2]
696 set pis2 [::math::bignum::rshift $pi 1]
697 if {[::math::bignum::cmp $x $pis4]>=0} {
699 set x [::math::bignum::sub $pis2 $x]
700 set delta [::math::bignum::add 1 $delta]
713 proc ::math::bigfloat::_cos {x precision delta} {
717 set float1 [::math::bignum::lshift $one $precision]
726 set d [::math::bignum::mul $x [::math::bignum::lshift $delta 1]]
727 set d [::math::bignum::add 1 [::math::bignum::rshift $d $precision]]
732 set t [opp [::math::bignum::rshift $x 1]]
735 while {![::math::bignum::iszero $t]} {
736 set s [::math::bignum::add $s $t]
737 set delta [::math::bignum::add $delta $dt]
738 set denom1 [::math::bignum::add $denom1 $two]
739 set denom2 [::math::bignum::add $denom2 $two]
740 set dt [::math::bignum::rshift [::math::bignum::add [::math::bignum::mul $x $dt]\
741 [::math::bignum::mul [::math::bignum::add $t $dt] $d]] $precision]
742 set dt [::math::bignum::add 1 $dt]
744 set t [opp [::math::bignum::div $t [::math::bignum::mul $denom1 $denom2]]]
752 proc ::math::bigfloat::cotan {x} {
753 return [::math::bigfloat::div [::math::bigfloat::cos $x] [::math::bigfloat::sin $x]]
760 proc ::math::bigfloat::deg2rad {x} {
767 return [div [mul $x $pi] [::math::bignum::fromstr 180]]
777 proc ::math::bigfloat::divPiQuarter {integer precision} {
779 set integer [::math::bignum::lshift $integer 1]
782 foreach {n integer} [::math::bignum::divqr $integer $dpi] {break}
784 set pi [::math::bignum::rshift $dpi 1]
785 foreach {n integer} [::math::bignum::divqr $integer $pi] {break}
788 set n [::math::bignum::lshift $n 1]
790 set pis2 [::math::bignum::rshift $pi 1]
791 foreach {m integer} [::math::bignum::divqr $integer $pis2] {break}
792 return [list [::math::bignum::add $n $m] [::math::bignum::rshift $integer 1]]
800 proc ::math::bigfloat::div {a b} {
806 return [::math::bignum::div $a $b]
814 set BMin [::math::bignum::sub $integerB $deltaB]
815 set BMax [::math::bignum::add $integerB $deltaB]
816 if {[::math::bignum::cmp $BMin $BMax]>0} {
823 if {[::math::bignum::iszero $integerA]} {
830 if {[::math::bignum::sign $BMin]+[::math::bignum::sign $BMax]==1 || \
831 [::math::bignum::iszero $BMin] || [::math::bignum::iszero $BMax]} {
835 set l [math::bignum::bits $integerB]
836 set integerA [::math::bignum::lshift $integerA $l]
837 set deltaA [::math::bignum::lshift $deltaA $l]
846 set delta [::math::bignum::div [::math::bignum::mul $deltaB \
848 set delta [::math::bignum::div [::math::bignum::add\
849 [::math::bignum::add 1 $delta]\
851 set quotient [::math::bignum::div $integerA $integerB]
852 if {[::math::bignum::sign $integerB]+[::math::bignum::sign $integerA]==1} {
853 set quotient [::math::bignum::sub $quotient 1]
855 return [normalize [list F $quotient $exp [::math::bignum::add $delta 1]]]
865 proc ::math::bigfloat::divFloatByInt {a b} {
874 if {[::math::bignum::iszero $b]} {
878 set l [::math::bignum::bits $b]
879 set integer [::math::bignum::lshift $integer $l]
880 set delta [::math::bignum::lshift $delta $l]
882 set integer [::math::bignum::div $integer $b]
885 set delta [::math::bignum::add 1 [::math::bignum::div $delta [abs $b]]]
897 proc ::math::bigfloat::equal {a b} {
899 return [expr {[::math::bignum::cmp $a $b]==0}]
910 set bint [::math::bignum::lshift $bint $diff]
911 set bdelta [::math::bignum::lshift $bdelta $diff]
913 set aint [::math::bignum::lshift $aint $diff]
914 set adelta [::math::bignum::lshift $adelta $diff]
917 set asupInt [::math::bignum::add $aint $adelta]
918 set ainfInt [::math::bignum::sub $aint $adelta]
919 set bsupInt [::math::bignum::add $bint $bdelta]
920 set binfInt [::math::bignum::sub $bint $bdelta]
923 if {[::math::bignum::cmp $bint $aint]==0} {
926 if {[::math::bignum::cmp $bint $aint]>0} {
927 set r [expr {[::math::bignum::cmp $asupInt $binfInt]>=0}]
929 set r [expr {[::math::bignum::cmp $bsupInt $ainfInt]>=0}]
937 proc ::math::bigfloat::exp {x} {
944 set integer [::math::bignum::lshift $integer $exp]
945 set delta [::math::bignum::lshift $delta $exp]
951 set integer [::math::bignum::lshift $integer 8]
952 set delta [::math::bignum::lshift $delta 8]
954 foreach {new_exp integer} [::math::bignum::divqr $integer $Log2] {break}
960 set delta [::math::bignum::add $delta $new_exp]
962 set delta [::math::bignum::rshift $delta 8]
967 if {![::math::bignum::iszero [::math::bignum::rshift [abs $new_exp] 30]]} {
972 set delta [::math::bignum::add 1 $delta]
973 return [normalize [list F [::math::bignum::rshift $integer 8] $exp $delta]]
987 proc ::math::bigfloat::_exp {integer precision delta} {
988 set oneShifted [::math::bignum::lshift 1 $precision]
989 if {[::math::bignum::iszero $integer]} {
993 set s [::math::bignum::add $oneShifted $integer]
995 set d [::math::bignum::add 1 [::math::bignum::div $delta $two]]
996 set delta [::math::bignum::add $delta $delta]
998 set dt [::math::bignum::add 1 [intMulShift $d $integer $precision]]
1001 set t [::math::bignum::div $t $two]
1003 while {![::math::bignum::iszero $t]} {
1005 set s [::math::bignum::add $s $t]
1006 set delta [::math::bignum::add $delta $dt]
1008 set denom [::math::bignum::add 1 $denom]
1010 set d [::math::bignum::add 1 [::math::bignum::div $d $denom]]
1011 set dt [::math::bignum::add $dt $d]
1015 set t [::math::bignum::div $t $denom]
1022 proc ::math::bigfloat::floatRShift {float {n 1}} {
1033 proc ::math::bigfloat::floor {number} {
1037 if {[::math::bignum::iszero $number]} {
1046 set sign [::math::bignum::sign $integer]
1049 set try [::math::bignum::rshift $integer [expr {-$exp}]]
1055 if {![equal [::math::bignum::lshift $try [expr {-$exp}]] $integer]} {
1056 set try [::math::bignum::add 1 $try]
1058 ::math::bignum::setsign try $sign
1075 proc ::math::bigfloat::fromstr {args} {
1081 return [::math::bignum::fromstr [lindex $args 2] [lindex $args 1]]
1108 # please note that most math::bigfloat procs accept BigInts as arguments
1109 return [::math::bignum::fromstr $string]
1149 set number [::math::bignum::mul [::math::bignum::fromstr $number]\
1151 ::math::bignum::setsign number $signe
1166 proc ::math::bigfloat::_fromstr {number exp} {
1174 set number [::math::bignum::lshift $number 4]
1176 set number [::math::bignum::mul $number $exponent]
1178 return [normalize [list F $number -4 [::math::bignum::lshift $exponent 4]]]
1190 set fivePow [::math::bignum::pow $five [::math::bignum::fromstr [expr {-$exp}]]]
1191 set number [::math::bignum::div [::math::bignum::lshift $number \
1193 set delta [::math::bignum::div [::math::bignum::lshift 1 \
1195 return [normalize [list F $number [expr {-$binaryExp}] [::math::bignum::add $delta 1]]]
1206 proc ::math::bigfloat::fromdouble {double {exp {}}} {
1223 proc ::math::bigfloat::int2float {int {decimals 1}} {
1235 set int [::math::bignum::mul $int [tenPow $decimals]]
1245 proc ::math::bigfloat::intMulShift {leftop rightop shift} {
1246 return [::math::bignum::rshift [::math::bignum::mul $leftop $rightop] $shift]
1252 proc ::math::bigfloat::isFloat {x} {
1265 # checks that n is a BigInt (a number create by math::bignum::fromstr)
1267 proc ::math::bigfloat::isInt {n} {
1282 proc ::math::bigfloat::iszero {x} {
1284 return [::math::bignum::iszero $x]
1290 set integer [::math::bignum::abs $integer]
1291 if {[::math::bignum::cmp $delta $integer]>=0} {return 1}
1299 proc ::math::bigfloat::log {x} {
1302 if {[::math::bignum::iszero $integer]||[::math::bignum::sign $integer]} {
1308 set precision [::math::bignum::bits $integer]
1310 set delta [::math::bignum::add 1 [_logOnePlusEpsilon $delta $integer $precision]]
1315 set delta [::math::bignum::add $delta $deltaIncr]
1320 set integer [::math::bignum::sub [::math::bignum::mul [_log2 $precision] \
1321 [set exp [::math::bignum::fromstr $exp]]] $integer]
1322 set delta [::math::bignum::add $delta [abs $exp]]
1340 proc ::math::bigfloat::_logOnePlusEpsilon {epsNum epsDenom precision} {
1341 if {[::math::bignum::cmp $epsNum $epsDenom]>=0} {
1344 set s [::math::bignum::lshift $epsNum $precision]
1345 set s [::math::bignum::div $s $epsDenom]
1348 set t [::math::bignum::div [::math::bignum::mul $s $epsNum] $epsDenom]
1349 set u [::math::bignum::div $t $divider]
1352 while {![::math::bignum::iszero $u]} {
1353 set s [::math::bignum::add $s $u]
1355 set divider [::math::bignum::add 1 $divider]
1357 set t [::math::bignum::div [::math::bignum::mul $t $epsNum] $epsDenom]
1359 set u [::math::bignum::div $t $divider]
1368 proc ::math::bigfloat::_log {integer} {
1371 set precision [::math::bignum::bits $integer]
1373 set integer [::math::bignum::lshift $integer $n]
1378 set integer [::math::bignum::sub [::math::bignum::lshift 1 $precision] $integer]
1385 set u [::math::bignum::div $t $denom]
1386 while {![::math::bignum::iszero $u]} {
1388 set s [::math::bignum::add $s $u]
1389 set delta [::math::bignum::add 1 $delta]
1393 set denom [::math::bignum::add 1 $denom]
1395 set u [::math::bignum::div $t $denom]
1398 set delta [::math::bignum::add 1 [::math::bignum::rshift $delta $n]]
1399 return [list [::math::bignum::rshift $s $n] $delta]
1408 proc ::math::bigfloat::__log {num denom precision} {
1440 set num [::math::bignum::fromstr [expr {$denom-$num}]]
1441 set denom [::math::bignum::fromstr $denom]
1443 set s [::math::bignum::div [::math::bignum::lshift $num $precision] $denom]
1445 set t [::math::bignum::div [::math::bignum::mul $s $num] $denom]
1449 set u [::math::bignum::div $t $d]
1450 while {![::math::bignum::iszero $u]} {
1451 set s [::math::bignum::add $s $u]
1453 set t [::math::bignum::div [::math::bignum::mul $t $num] $denom]
1455 set d [::math::bignum::add 1 $d]
1457 set u [::math::bignum::div $t $d]
1460 return [::math::bignum::rshift $s $n]
1466 proc ::math::bigfloat::__logbis {precision} {
1473 set r [::math::bignum::add [::math::bignum::mul $b $three] $a]
1474 set ::math::bigfloat::Log2 [::math::bignum::rshift $r $increment]
1483 proc ::math::bigfloat::_log2 {precision} {
1489 set l [::math::bignum::bits $Log2]
1500 # returns A modulo B (like with fmod() math function)
1502 proc ::math::bigfloat::mod {a b} {
1504 if {[isInt $a] && [isInt $b]} {return [::math::bignum::mod $a $b]}
1530 proc ::math::bigfloat::mul {a b} {
1535 return [::math::bignum::mul $a $b]
1546 set integer [::math::bignum::mul $integerA $integerB]
1548 set deltaAB [::math::bignum::mul $deltaA $deltaB]
1549 set deltaA [::math::bignum::mul [abs $integerB] $deltaA]
1550 set deltaB [::math::bignum::mul [abs $integerA] $deltaB]
1551 set delta [::math::bignum::add [::math::bignum::add $deltaA $deltaB] \
1552 [::math::bignum::add 1 $deltaAB]]
1560 proc ::math::bigfloat::mulFloatByInt {a b} {
1567 set integer [::math::bignum::mul $integer $b]
1568 set delta [::math::bignum::mul $delta $b]
1580 proc ::math::bigfloat::normalize {number} {
1583 set l [::math::bignum::bits $delta]
1589 set delta [::math::bignum::add 1 [::math::bignum::rshift $delta $l]]
1590 set integer [::math::bignum::rshift $integer $l]
1601 proc ::math::bigfloat::opp {a} {
1607 ::math::bignum::setsign a [expr {![::math::bignum::sign $a]}]
1619 proc ::math::bigfloat::pi {precision {binary 0}} {
1636 proc ::math::bigfloat::_pi {precision} {
1644 set lenPiGlobal [::math::bignum::bits $_pi0]
1648 return [::math::bignum::rshift $_pi0 [expr {[::math::bignum::bits $_pi0]-2-$precision}]]
1654 proc ::math::bigfloat::__pi {precision} {
1660 set a [::math::bignum::mul [_atanfract [::math::bignum::fromstr 18] $precision] \
1661 [::math::bignum::fromstr 48]]
1662 set a [::math::bignum::add $a [::math::bignum::mul \
1663 [_atanfract [::math::bignum::fromstr 57] $precision] [::math::bignum::fromstr 32]]]
1664 set a [::math::bignum::sub $a [::math::bignum::mul \
1665 [_atanfract [::math::bignum::fromstr 239] $precision] [::math::bignum::fromstr 20]]]
1666 return [::math::bignum::rshift $a $safetyLimit]
1673 proc ::math::bigfloat::_round {integer precision} {
1674 set shift [expr {[::math::bignum::bits $integer]-$precision}]
1676 set result [::math::bignum::rshift $integer $shift]
1680 if {[::math::bignum::testbit $integer [expr {$shift-1}]]} {
1682 return [::math::bignum::add 1 $result]
1690 proc ::math::bigfloat::pow {a b} {
1696 # from math::bignum (added 5th March 2005)
1698 return [::math::bignum::pow $a $b]
1707 if {[::math::bignum::iszero $b]} {return $one}
1713 set remainder [::math::bignum::testbit $b 0]
1716 set b [::math::bignum::rshift $b 1]
1724 if {[::math::bignum::iszero $b]} {
1739 proc ::math::bigfloat::rad2deg {x} {
1748 return [div [mul $x [::math::bignum::fromstr 180]] $pi]
1754 proc ::math::bigfloat::round {number} {
1759 if {[::math::bignum::iszero $integer]} {
1769 set sign [::math::bignum::sign $integer]
1772 set try [::math::bignum::rshift $integer $exp]
1774 set way [::math::bignum::testbit $integer [expr {$exp-1}]]
1776 set delta [::math::bignum::rshift $delta [expr {$exp-1}]]
1778 if {![::math::bignum::iszero $delta]} {
1782 set try [::math::bignum::add 1 $try]
1785 ::math::bignum::setsign try $sign
1792 proc ::math::bigfloat::roundshift {integer n} {
1795 foreach {result remainder} [::math::bignum::divqr $integer $exp] {}
1801 if {[::math::bignum::cmp $exp [::math::bignum::lshift $remainder 1]]<=0} {
1802 return [::math::bignum::add 1 $result]
1811 proc ::math::bigfloat::sign {n} {
1813 return [::math::bignum::sign $n]
1818 return [::math::bignum::sign [lindex $n 1]]
1825 proc ::math::bigfloat::sin {x} {
1836 set delta [::math::bignum::add $delta $n]
1838 set d [::math::bignum::mod $n $four]
1858 ::math::bignum::setsign integer $sign
1864 proc ::math::bigfloat::_sin2 {x precision delta} {
1868 set pis2 [::math::bignum::rshift $pi 1]
1869 set pis4 [::math::bignum::rshift $pi 2]
1870 if {[::math::bignum::cmp $x $pis4]>=0} {
1872 set delta [::math::bignum::add 1 $delta]
1873 set x [::math::bignum::sub $pis2 $x]
1884 proc ::math::bigfloat::_sin {x precision delta} {
1893 set double [::math::bignum::rshift [::math::bignum::mul $x $delta] [expr {$precision-1}]]
1894 set double [::math::bignum::add [::math::bignum::add 1 $double] [::math::bignum::rshift \
1895 [::math::bignum::mul $delta $delta] $precision]]
1898 set dt [::math::bignum::rshift [::math::bignum::add [::math::bignum::mul $x $delta] \
1899 [::math::bignum::mul [::math::bignum::add $s $delta] $double]] $precision]
1900 set dt [::math::bignum::add 1 $dt]
1909 set t [opp [::math::bignum::div $t [::math::bignum::mul $denom2 $denom3]]]
1910 while {![::math::bignum::iszero $t]} {
1911 set s [::math::bignum::add $s $t]
1912 set delta [::math::bignum::add $delta $dt]
1914 set denom2 [::math::bignum::add $denom2 $two]
1915 set denom3 [::math::bignum::add $denom3 $two]
1920 set dt [::math::bignum::rshift [::math::bignum::add [::math::bignum::mul $x $dt] \
1921 [::math::bignum::mul [::math::bignum::add $t $dt] $double]] $precision]
1924 #set dt [::math::bignum::add $dt $double]
1925 set denom [::math::bignum::mul $denom2 $denom3]
1927 set dt [::math::bignum::add 1 [::math::bignum::div $dt $denom]]
1928 set t [opp [::math::bignum::div $t $denom]]
1937 proc ::math::bigfloat::sqrt {x} {
1947 # we cannot get sqrt(x) if x<0
1949 error "negative sqrt input"
1953 # sqrt(1 + epsilon) = (1 + epsilon)^(1/2)
1956 # sqrt(1 - epsilon) = 1 + Sum(i=1..infinity) epsilon^i*(3*5*...*(2i-1))/(i!*2^i)
1957 # sqrt(n +/- delta)=sqrt(n) * sqrt(1 +/- delta/n)
1958 # so the uncertainty on sqrt(n +/- delta) equals sqrt(n) * (sqrt(1 - delta/n) - 1)
1959 # sqrt(1+eps) < sqrt(1-eps) because their logarithm compare as :
1962 # Delta = sqrt(n) * Sum(i=1..infinity) (delta/n)^i*(3*5*...*(2i-1))/(i!*2^i)
1965 set intLen [::math::bignum::bits $integer]
1971 set integer [::math::bignum::lshift $integer $intLen]
1974 # there is an exponent 2^$exp : when $exp is odd, we would need to compute sqrt(2)
1975 # so we decrement $exp, in order to get it even, and we do not need sqrt(2) anymore !
1978 set integer [::math::bignum::lshift $integer 1]
1982 # using a low-level (in math::bignum) root extraction procedure
1983 set integer [::math::bignum::sqrt $integer]
1985 set delta [::math::bignum::rshift [::math::bignum::mul $delta $integer] $precision]
1987 set delta [::math::bignum::add 1 $delta]
1995 # compute abs(sqrt(1-delta/integer)-1)
1998 proc ::math::bigfloat::_sqrtOnePlusEpsilon {delta integer} {
1999 # sqrt(1-x) - 1 = x/2 + x^2*3/(2^2*2!) + x^3*3*5/(2^3*3!) + ...
2003 set l [::math::bignum::bits $integer]
2007 set x [::math::bignum::div [::math::bignum::lshift $delta $l] $integer]
2013 set result [::math::bignum::div $x $two]
2018 set temp [::math::bignum::mul $result $delta]
2019 set temp [::math::bignum::div [::math::bignum::mul $temp $numerator] $integer]
2020 set temp [::math::bignum::add 1 [::math::bignum::div $temp $denom]]
2021 while {![::math::bignum::iszero $temp]} {
2022 set result [::math::bignum::add $result $temp]
2023 set numerator [::math::bignum::add $numerator $two]
2024 set denom [::math::bignum::add $two $denom]
2027 set temp [::math::bignum::mul [::math::bignum::mul $temp $delta] $numerator]
2028 set temp [::math::bignum::div [::math::bignum::div $temp $denom] $integer]
2036 proc ::math::bigfloat::sub {a b} {
2039 # the math::bignum::sub proc is designed to work with BigInts
2040 return [::math::bignum::sub $a $b]
2048 proc ::math::bigfloat::tan {x} {
2049 return [::math::bigfloat::div [::math::bigfloat::sin $x] [::math::bigfloat::cos $x]]
2055 proc ::math::bigfloat::tenPow {n} {
2057 return [::math::bignum::pow $ten [::math::bignum::fromstr $n]]
2065 proc ::math::bigfloat::todouble {x} {
2097 set integer [tostr [roundshift [::math::bignum::fromstr $integer] $lenDiff]]
2126 proc ::math::bigfloat::tostr {args} {
2138 return [::math::bignum::tostr $number]
2161 set fivePower [::math::bignum::pow $five [::math::bignum::fromstr $newExp]]
2164 set integer [::math::bignum::div [::math::bignum::lshift $integer $binExp] \
2167 set delta [::math::bignum::div [::math::bignum::lshift $delta $binExp] $fivePower]
2175 set fivePower [::math::bignum::pow $five \
2176 [::math::bignum::fromstr $newExp]]
2179 set integer [::math::bignum::rshift [::math::bignum::mul $integer $fivePower] \
2181 set delta [::math::bignum::rshift [::math::bignum::mul $delta $fivePower] \
2186 set sign [::math::bignum::sign $integer]
2187 set result [::math::bignum::abs $integer]
2189 set up [::math::bignum::add $result $delta]
2190 set down [::math::bignum::sub $result $delta]
2197 incr exp [expr {int(ceil([::math::bignum::bits $delta]*log(2)/log(10)))}]
2205 [::math::bignum::cmp [roundshift $up $shift] [roundshift $down $shift]]
2210 set result [::math::bignum::tostr [roundshift $up $shift]]
2270 proc ::math::bigfloat::cosh {x} {
2279 proc ::math::bigfloat::sinh {x} {
2288 proc ::math::bigfloat::tanh {x} {
2298 namespace eval ::math::bigfloat {
2304 exp log sqrt round ceil floor
2314 #namespace import ::math::bigfloat::*
2316 package provide math::bigfloat 1.2.2