Tcl Library Source Code

2014-09-21  Arjen Markus <[email protected]>
	* bigfloat2.tcl: Solve ticket UUID 3309165, different implementation of isInt than suggested
	* bigfloat2.test: Added several tests for the new implementation of isInt
	* optimize.tcl: Solve ticket UUID 3193459, as suggested.
	* optimize.tcl: Solve a problem with the detection of the exceptions in solving linear programs. Version 1.0.1
	* optimize.test: Added tests to distinguish infeasible and unbounded linear programs
	* optimize.test: Added test for ticket UUID 3193459
	* pkgIndex.tcl: Bumping version of math::optimize package to 1.0.1, bigfloat2 to 2.0.2

2014-08-21  Arjen Markus <[email protected]>
	* calculus.tcl: Bumping version to 0.8
	* pkgIndex.tcl: Bumping version of math::calculus package to 0.8

2014-08-21  Arjen Markus <[email protected]>
	* calculus.man: Describe the qk15 procedure implementing Gauss-Kronrod 15 points quadrature rule

################################################################################
# procedures that handle floating-point numbers
# these procedures are sorted by name (after eventually removing the underscores)
#
# BigFloats are internally represented as a list :
# {"F" Mantissa Exponent Delta} where "F" is a character which determins
# the datatype, Mantissa and Delta are two big integers and Exponent another integer.
#
# The BigFloat value equals to (Mantissa +/- Delta)*2^Exponent
# So the internal representation is binary, but trying to get as close as possible to
# the decimal one when converted to a string.
# When calling [fromstr], the Delta parameter is set to the value of 1 at the position
# of the last decimal digit.
# Example : 1.50 belongs to [1.49,1.51], but internally Delta may not equal to 1.
# Because of the binary representation, it is between 1 and 1+(2^-15).
#
# So Mantissa and Delta are not limited in size, but in practice Delta is kept under
# 2^32 by the 'normalize' procedure, to avoid a never-ended growth of memory used.
# Indeed, when you perform some computations, the Delta parameter (which represent
# the uncertainty on the value of the Mantissa) may increase.
# Exponent, as an integer, is limited to 32 bits, and this limit seems fair.
# The exponent is indeed involved in logarithmic computations, so it may be
# a mistake to give it a too large value.

        return [add $piOverTwo [asin [abs $x]]]
    }
    # we always use _asin to compute the result
    # but as it is a Taylor development, the value given to [_asin]
    # has to be a bit smaller than 1 ; by using that trick : acos(x)=asin(sqrt(1-x^2))
    # we can limit the entry of the Taylor development below 1/sqrt(2)
    if {[compare $x [fromstr 0.7071]]>0} {
        # x > sqrt(2)/2 : trying to make _asin converge quickly
        # creating 0 and 1 with the same precision as the entry
        set fzero [list F 0 -$precision 1]
        # 1.000 with $precision zeros
        set fone [list F [expr {1<<$precision}] -$precision 1]
        # when $x is close to 1 (acos(1.0)=0.0)
        if {[equal $fone $x]} {
            return $fzero

    if {$expA<$expB} {
        foreach {dummy integerA expA deltaA} $b {break}
        foreach {dummy integerB expB deltaB} $a {break}
    }
    # when we add two numbers which have different digit numbers (after the dot)
    # for example : 1.0 and 0.00001
    # We promote the one with the less number of digits (1.0) to the same level as
    # the other : so 1.00000.
    # that is why we shift left the number which has the greater exponent
    # But we do not forget the Delta parameter, which is lshift'ed too.
    if {$expA>$expB} {
        set diff [expr {$expA-$expB}]
        set integerA [expr {$integerA<<$diff}]
        set deltaA [expr {$deltaA<<$diff}]
        incr integerA $integerB

################################################################################
proc ::math::bigfloat::_asin {x} {
    # Taylor development
    # asin(x)=x + 1/2 x^3/3 + 3/2.4 x^5/5 + 3.5/2.4.6 x^7/7 + ...
    # into this iterative form :
    # asin(x)=x * (1 + 1/2 * x^2 * (1/3 + 3/4 *x^2 * (...
    # ...* (1/(2n-1) + (2n-1)/2n * x^2 / (2n+1))...)))
    # we show how is really computed the development :
    # we don't need to set a var with x^n or a product of integers
    # all we need is : x^2, 2n-1, 2n, 2n+1 and a few variables
    foreach {dummy mantissa exp delta} $x {break}
    set precision [expr {-$exp}]
    if {$precision+1<[bits $mantissa]} {
        error "sinus greater than 1"
    }

        error "bad result: $l bits"
    }
    while {($int>>($l-1))==0} {
        incr l -1
    }
    return $l
}

################################################################################
# returns the integer part of a BigFloat, as a BigInt
# the result is the same one you would have
# if you had called [expr {ceil($x)}]
################################################################################
proc ::math::bigfloat::ceil {number} {
    checkFloat $number

################################################################################
# divide A by B and returns the result
# throw error : divide by zero
################################################################################
proc ::math::bigfloat::div {a b} {
    checkNumber $a
    checkNumber $b
    # dispatch to an appropriate procedure
    if {[isInt $a]} {
        if {[isInt $b]} {
            return [expr {$a/$b}]
        }
        error "trying to divide an integer by a BigFloat"
    }
    if {[isInt $b]} {return [divFloatByInt $a $b]}

        set BMax $temp
    }
    # multiply by zero gives zero
    if {$integerA==0} {
        # why not return any number or the integer 0 ?
        # because there is an exponent that might be different between two BigFloats
        # 0.00 --> exp = -2, 0.000000 -> exp = -6
        return $a
    }
    # test of the division by zero
    if {$BMin*$BMax<0 || $BMin==0 || $BMax==0} {
        error "divide by zero"
    }
    # shift A because we need accuracy
    set l [bits $integerB]

        incr exp -[string length [lindex $tab 1]]
    }
    # this is necessary to ensure we can call fromstr (recursively) with
    # the mantissa ($number)
    if {![string is digit $mantissa]} {
        error "$number is not a number"
    }
    # take account of trailing zeros
    incr exp -$addzeros
    # multiply $number by 10^$trailingZeros
    append mantissa [string repeat 0 $addzeros]
    # add the sign
    # here we avoid octal numbers by trimming the leading zeros!
    # 2005-10-28 S.ARNOLD
    if {$signe} {set mantissa [expr {-[string trimleft $mantissa 0]}]}

    return 0
}

################################################################################
# checks that n is a BigInt (a number create by math::bignum::fromstr)
################################################################################
proc ::math::bigfloat::isInt {n} {
    set rc [catch {
        expr {$n%2}
    }]



    return [expr {$rc == 0}]
}



################################################################################
# returns 1 if x is null, 0 otherwise
################################################################################

    # we would lose accuracy because small uncertainties add to themselves.
    # Example : 0.0001 + 0.0010 = 0.0011 +/- 0.0002
    # This is quite the same reason that made tcl_precision defaults to 12 :
    # internally, doubles are computed with 17 digits, but to keep precision
    # we need to limit our results to 12.
    # The solution : given a precision target, increment precision with a
    # computed value so that all digits of he result are exacts.
    #
    # p is the precision
    # pk is the precision increment
    # 2 power pk is also the maximum number of iterations
    # for a number close to 1 but lower than 1,
    # (denom-num)/denum is (in our case) lower than 1/5
    # so the maximum nb of iterations is for:
    # 1/5*(1+1/5*(1/2+1/5*(1/3+1/5*(...))))

################################################################################
proc ::math::bigfloat::_sin {x precision delta} {
    # $s holds the result
    set s $x
    # sin(x) = x - x^3/3! + x^5/5! - ... + (-1)^n*x^(2n+1)/(2n+1)!
    #        = x * (1 - x^2/(2*3) * (1 - x^2/(4*5) * (...* (1 - x^2/(2n*(2n+1)) )...)))
    # The second expression allows us to compute the less we can

    # $double holds the uncertainty (Delta) of x^2 : 2*(Mantissa*Delta) + Delta^2
    # (Mantissa+Delta)^2=Mantissa^2 + 2*Mantissa*Delta + Delta^2
    set double [expr {$x*$delta>>$precision-1}]
    incr double [expr {1+$delta*$delta>>$precision}]
    # $x holds the Mantissa of x^2
    set x [expr {$x*$x>>$precision}]
    set dt [expr {$x*$delta+$double*($s+$delta)>>$precision}]

#
# Computes the square root of an integer
# Returns an integer
#
proc ::math::bigfloat::_sqrt {n} {
    set i [expr {(([bits $n]-1)/2)+1}]
    set b [expr {$i*2}] ; # Bit to set to get 2^i*2^i

    set r 0 ; # guess
    set x 0 ; # guess^2
    set s 0 ; # guess^2 backup
    set t 0 ; # intermediate result
    for {} {$i >= 0} {incr i -1; incr b -2} {
        set x [expr {$s+($t|(1<<$b))}]
        if {abs($x)<= abs($n)} {

    # please note: here we call math::bigfloat::tostr
    set result [string trimleft [tostr $x] +]
    set minus ""
    if {[string index $result 0]=="-"} {
        set minus -
        set result [string range $result 1 end]
    }

    set l [split $result e]
    set exp 0
    if {[llength $l]==2} {
        # exp : x=Mantissa*2^Exp
        set exp [lindex $l 1]
    }
    # caution with octal numbers : we have to remove heading zeros

    # rounded 'integer' +/- 'delta'
    set up [expr {$result+$delta}]
    set down [expr {$result-$delta}]
    if {($up<0 && $down>0)||($up>0 && $down<0)} {
        # $up>0 and $down<0 or vice-versa : then the number is considered equal to zero
        set isZero yes
	# delta <= 2**n (n = bits(delta))
	# 2**n  <= 10**exp , then
	# exp >= n.log(2)/log(10)
	# delta <= 10**(n.log(2)/log(10))
        incr exp [expr {int(ceil([bits $delta]*log(2)/log(10)))}]
        set result 0
    } else {
	# iterate until the convergence of the rounding
	# we incr $shift until $up and $down are rounded to the same number

        namespace export $function
    }
}

# (AM) No "namespace import" - this should be left to the user!
#namespace import ::math::bigfloat::*

package provide math::bigfloat 2.0.2

######################################################
# Begin testsuite
######################################################

proc testSuite {} {


    # adds 999..9 and 1 -> 1000..0
    for {set i 1} {$i<15} {incr i} {
        assert add 1.0 {tostr [add \
                    [fromstr [string repeat 999 $i]] [fromstr 1]]
        } 1[string repeat 000 $i]
    }
    # sub 1000..0 1 -> 999..9

                    [string repeat ${j}000 $i]
        }
    }
    # div 10^8 by 1 .. 9
    for {set i 1} {$i<=9} {incr i} {
        assert div 1.3 {tostr [div [fromstr 100000000] [fromstr $i]]} [expr {wide(100000000)/$i}]
    }


    # 10^8 modulo 1 .. 9
    for {set i 1} {$i<=9} {incr i} {
        assert mod 1.4 {tostr [mod [fromstr 100000000] [fromstr $i]]} [expr {wide(100000000)%$i}]
    }

    ################################################################################
    # fromstr problem with octal exponents
    ################################################################################
    fassert fromstr 2.0 {todouble [fromstr 1.0e+099]} 1.0e+099
    fassert fromstr 2.0a {todouble [fromstr 1.0e99]} 1.0e99
    fassert fromstr 2.0b {todouble [fromstr 1.0e-99]} 1.0e-99
    fassert fromstr 2.0c {todouble [fromstr 1.0e-099]} 1.0e-99


    ################################################################################
    # fromdouble with precision
    ################################################################################
    assert fromdouble 2.1 {tostr [ceil [fromdouble 1.0e99 100]]} 1[zero 99]
    assert fromdouble 2.1a {tostr [fromdouble 1.11 3]} 1.11
    assert fromdouble 2.1b {tostr [fromdouble +1.11 3]} 1.11
    assert fromdouble 2.1c {tostr [fromdouble -1.11 3]} -1.11
    assert fromdouble 2.1d {tostr [fromdouble +01.11 3]} 1.11
    assert fromdouble 2.1e {tostr [fromdouble -01.11 3]} -1.11
    # more to come...
    fassert fromdouble 2.1f {compare [fromdouble [expr {atan(1.0)*4}]] [pi $::tcl_precision]} 0

    ################################################################################
    # abs()
    ################################################################################
    proc absTest {version x {int 0}} {
        if {!$int} {
            fassert abs $version {
                tostr [abs [fromstr $x]]
            } [expr {abs($x)}]
        } else {
            assert abs $version {
                tostr [abs [fromstr $x]]
            } [expr {($x<0)?(-$x):$x}]
        }

    }
    absTest 2.2a 1.000
    absTest 2.2b -1.000
    absTest 2.2c -0.10
    absTest 2.2d 0 1
    absTest 2.2e 1 1
    absTest 2.2f 10000 1
    absTest 2.2g -1 1
    absTest 2.2h -10000 1
    rename absTest ""

    ################################################################################
    # opposite
    ################################################################################
    proc oppTest {version x {int 0}} {
        if {$int} {
            assert opp $version {tostr [opp [fromstr $x]]} [expr {-$x}]
        } else {
            fassert opp $version {tostr [opp [fromstr $x]]} [expr {-$x}]
        }

    }
    oppTest 2.3a 1.00
    oppTest 2.3b -1.00
    oppTest 2.3c 0.10
    oppTest 2.3d -0.10
    oppTest 2.3e 0.00
    oppTest 2.3f 1 1
    oppTest 2.3g -1 1
    oppTest 2.3h 0 1
    oppTest 2.3i 100000000 1
    oppTest 2.3j -100000000 1
    rename oppTest ""

    ################################################################################
    # equal
    ################################################################################
    proc equalTest {x y} {
        equal [fromstr $x] [fromstr $y]
    }
    assert equal 2.4a {equalTest 0.0 0.1} 1
    assert equal 2.4b {equalTest 0.00 0.10} 0
    assert equal 2.4c {equalTest 0.0 -0.1} 1
    assert equal 2.4d {equalTest 0.00 -0.10} 0

    rename equalTest ""
    ################################################################################
    # compare
    ################################################################################
    proc compareTest {x y} {
        compare [fromstr $x] [fromstr $y]
    }
    assert cmp 2.5a {compareTest 0.00 0.10} -1
    assert cmp 2.5b {compareTest 0.1 0.4} -1
    assert cmp 2.5c {compareTest 0.0 -1.0} 1
    assert cmp 2.5d {compareTest -1.0 0.0} -1
    assert cmp 2.5e {compareTest 0.00 0.10} -1

    # cleanup
    rename compareTest ""

    ################################################################################
    # round
    ################################################################################
    proc roundTest {version x rounded} {
        assert round $version {tostr [round [fromstr $x]]} $rounded
    }
    roundTest 2.6a 0.10 0
    roundTest 2.6b 0.0 0
    roundTest 2.6c 0.50 1
    roundTest 2.6d 0.40 0
    roundTest 2.6e 1.0 1
    roundTest 2.6d -0.40 0
    roundTest 2.6e -0.50 -1
    roundTest 2.6f -1.0 -1
    roundTest 2.6g -1.50 -2
    roundTest 2.6h 1.50 2
    roundTest 2.6i 0.49 0
    roundTest 2.6j -0.49 0
    roundTest 2.6k 1.49 1
    roundTest 2.6l -1.49 -1


    # cleanup
    rename roundTest ""

    ################################################################################
    # floor
    ################################################################################
    proc floorTest {version x} {
        assert floor $version {tostr [floor [fromstr $x]]} [expr {int(floor($x))}]
    }
    floorTest 2.7a 0.10
    floorTest 2.7b 0.90
    floorTest 2.7c 1.0
    floorTest 2.7d -0.10
    floorTest 2.7e -1.0

    # cleanup
    rename floorTest ""

    ################################################################################
    # ceil
    ################################################################################
    proc ceilTest {version x} {
        assert ceil $version {tostr [ceil [fromstr $x]]} [expr {int(ceil($x))}]
    }
    ceilTest 2.8a 0.10
    ceilTest 2.8b 0.90
    ceilTest 2.8c 1.0
    ceilTest 2.8d -0.10
    ceilTest 2.8e -1.0
    ceilTest 2.8f 0.0

    # cleanup
    rename ceilTest ""

    ################################################################################
    # BigInt to BigFloat conversion
    ################################################################################
    proc convTest {version x {decimals 1}} {
        assert int2float $version {tostr [int2float [fromstr $x] $decimals]} \
                $x.[string repeat 0 [expr {$decimals-1}]]
    }
    set subversion 0
    foreach decimals {1 2 5 10 100} {
        set version 2.9.$subversion
        fassert int2float $version.0 {tostr [int2float [fromstr 0] $decimals]} 0.0
        convTest $version.1 1 $decimals
        convTest $version.2 5 $decimals
        convTest $version.3 5000000000 $decimals
        incr subversion
    }
    #cleanup
    rename convTest ""

    ################################################################################
    # addition
    ################################################################################
    proc addTest {version x y} {
        fassert add $version {todouble [add [fromstr $x] [fromstr $y]]} [expr {$x+$y}]
    }
    addTest 3.0a 1.00 2.00

    addTest 3.0j 0 -1.00
    addTest 3.0k 2.00 1
    addTest 3.0l -2.00 1
    addTest 3.0m 1.00 0
    addTest 3.0n -1.00 0
    #cleanup
    rename addTest ""

    ################################################################################
    # substraction
    ################################################################################
    proc subTest {version x y} {
        fassert sub $version {todouble [sub [fromstr $x] [fromstr $y]]} [expr {$x-$y}]
    }
    subTest 3.1a 1.00 2.00

    subTest 3.1l 2.00 1
    subTest 3.1m 1.00 2
    subTest 3.1n -1.00 1
    subTest 3.1o 0.00 2
    subTest 3.1p 2.00 0
    # cleanup
    rename subTest ""

    ################################################################################
    # multiplication
    ################################################################################
    proc mulTest {version x y} {
        fassert mul $version {todouble [mul [fromstr $x] [fromstr $y]]} [expr {$x*$y}]
    }
    proc mulInt {version x y} {

    mulInt 3.2h 1 2.00
    mulInt 3.2i 1 -2.00
    mulInt 3.2j 0 2.00
    mulInt 3.2k 0 -2.00
    mulInt 3.2l 10 2.00
    mulInt 3.2m 10 -2.00
    mulInt 3.2n 1 0.00


    # cleanup
    rename mulTest ""
    rename mulInt ""

    ################################################################################
    # division
    ################################################################################
    proc divTest {version x y} {
        fassert div $version {
            string trimright [todouble [div [fromstr $x] [fromstr $y]]] 0
        } [string trimright [expr {$x/$y}] 0]
    }


    divTest 3.3a 1.00 2.00
    divTest 3.3b 2.00 1.00
    divTest 3.3c -1.00 2.00
    divTest 3.3d 1.00 -2.00
    divTest 3.3e 2.00 -1.00
    divTest 3.3f -2.00 1.00
    divTest 3.3g -1.00 -2.00
    divTest 3.3h -2.00 -1.00
    divTest 3.3i 0.0 1.0
    divTest 3.3j 0.0 -1.0

    # cleanup
    rename divTest ""

    ################################################################################
    # rest of the division
    ################################################################################
    proc modTest {version x y} {
        fassert mod $version {
            todouble [mod [fromstr $x] [fromstr $y]]
        } [expr {fmod($x,$y)}]
    }

    modTest 3.4a 1.00 2.00
    modTest 3.4b 2.00 1.00
    modTest 3.4c -1.00 2.00
    modTest 3.4d 1.00 -2.00
    modTest 3.4e 2.00 -1.00
    modTest 3.4f -2.00 1.00
    modTest 3.4g -1.00 -2.00
    modTest 3.4h -2.00 -1.00
    modTest 3.4i 0.0 1.0
    modTest 3.4j 0.0 -1.0

    modTest 3.4k 1.00 2
    modTest 3.4l 2.00 1
    modTest 3.4m -1.00 2
    modTest 3.4n -2.00 1
    modTest 3.4o 0.0 1
    modTest 3.4p 1.50 1

    # cleanup
    rename modTest ""

    ################################################################################
    # divide a BigFloat by an integer
    ################################################################################
    proc divTest {version x y} {
        fassert div $version {todouble [div [fromstr $x] [fromstr $y]]} \
            [expr {double(round(1000*$x/$y))/1000.0}]
    }
    set subversion 0
    foreach a {1.0000 -1.0000} {
        foreach b {2 3} {
            divTest 3.5.$subversion $a $b
            incr subversion
        }
    }

    # cleanup
    rename divTest ""

    ################################################################################
    # pow : takes a float to an integer power (>0)
    ################################################################################
    proc powTest {version x y {int 0}} {
        if {!$int} {
            fassert pow $version {todouble [pow [fromstr $x 14] [fromstr $y]]}\
                    [expr [join [string repeat "[string trimright $x 0] " $y] *]]

    set subversion 0
    foreach a {1 2 3} {
        foreach b {2 3 5 8} {
            powTest 3.7.$subversion $a $b 1
            incr subversion
        }
    }

    # cleanup
    rename powTest ""


    ################################################################################
    # pi constant and angles conversion
    ################################################################################
    fassert pi 3.8.0 {todouble [pi 16]} [expr {atan(1)*4}]
    # converts Pi -> 180�
    fassert rad2deg 3.8.1 {todouble [rad2deg [pi 20]]} 180.0
    # converts 180� -> Pi
    fassert deg2rad 3.8.2 {todouble [deg2rad [fromstr 180.0 20]]} [expr {atan(1.0)*4}]


    ################################################################################
    # iszero : the precision is too small to determinate the number
    ################################################################################

    assert iszero 4.0a {iszero [fromstr 0]} 1
    assert iszero 4.0b {iszero [fromstr 0.0]} 1
    assert iszero 4.0c {iszero [fromstr 1]} 0
    assert iszero 4.0d {iszero [fromstr 1.0]} 0
    assert iszero 4.0e {iszero [fromstr -1]} 0
    assert iszero 4.0f {iszero [fromstr -1.0]} 0

    ################################################################################
    # sqrt : square root
    ################################################################################
    proc sqrtTest {version x} {
        fassert sqrt $version {todouble [sqrt [fromstr $x 18]]} [expr {sqrt($x)}]
    }
    sqrtTest 4.1a 1.
    sqrtTest 4.1b 0.001
    sqrtTest 4.1c 0.004
    sqrtTest 4.1d 4.

    # cleanup
    rename sqrtTest ""


    ################################################################################
    # expTest : exponential function
    ################################################################################
    proc expTest {version x} {
        fassert exp $version {todouble [exp [fromstr $x 17]]} [expr {exp($x)}]
    }

    expTest 4.2a 1.
    expTest 4.2b 0.001
    expTest 4.2c 0.004
    expTest 4.2d 40.
    expTest 4.2e -0.001

    # cleanup
    rename expTest ""

    ################################################################################
    # logTest : logarithm
    ################################################################################
    proc logTest {version x} {
        fassert log $version {todouble [log [fromstr $x 17]]} [expr {log($x)}]
    }

    logTest 4.3a 1.0
    logTest 4.3b 0.001
    logTest 4.3c 0.004
    logTest 4.3d 40.
    logTest 4.3e 1[zero 10].0

    # cleanup
    rename logTest ""

    ################################################################################
    # cos & sin : trigonometry
    ################################################################################
    proc cosEtSin {version quartersOfPi} {
        set x [div [mul [pi 18] [fromstr $quartersOfPi]] [fromstr 4]]
        #fassert cos {todouble [cos $x]} [expr {cos(atan(1)*$quartersOfPi)}]
        #fassert sin {todouble [sin $x]} [expr {sin(atan(1)*$quartersOfPi)}]
        fassert cos $version.0 {todouble [cos $x]} [expr {cos([todouble $x])}]
        fassert sin $version.1 {todouble [sin $x]} [expr {sin([todouble $x])}]
    }

    fassert cos 4.4.0.0 {todouble [cos [fromstr 0. 17]]} [expr {cos(0)}]
    fassert sin 4.4.0.1 {todouble [sin [fromstr 0. 17]]} [expr {sin(0)}]
    foreach i {1 2 3 4 5 6 7 8} {
        cosEtSin 4.4.$i $i
    }


    # cleanup
    rename cosEtSin ""

    ################################################################################
    # tan & cotan : trigonometry
    ################################################################################
    proc tanCotan {version i} {
        upvar pi pi
        set x [div [mul $pi [fromstr $i]] [fromstr 10]]
        set double [expr {atan(1)*(double($i)*0.4)}]
        fassert cos $version.0 {todouble [cos $x]} [expr {cos($double)}]
        fassert sin $version.1 {todouble [sin $x]} [expr {sin($double)}]
        fassert tan $version.2 {todouble [tan $x]} [expr {tan($double)}]
        fassert cotan $version.3 {todouble [cotan $x]} [expr {double(1.0)/tan($double)}]
    }

    set pi [pi 20]
    set subversion 0
    foreach i {1 2 3 6 7 8 9} {
        tanCotan 4.5.$subversion $i
        incr subversion
    }


    # cleanup
    rename tanCotan ""


    ################################################################################
    # atan , asin & acos : trigonometry (inverse functions)
    ################################################################################
    proc atanTest {version x} {
        set f [fromstr $x 20]
        fassert atan $version.0 {todouble [atan $f]} [expr {atan($x)}]
        if {abs($x)<=1.0} {
            fassert acos $version.1 {todouble [acos $f]} [expr {acos($x)}]
            fassert asin $version.2 {todouble [asin $f]} [expr {asin($x)}]
        }
    }
    set subversion 0
    atanTest 4.6.0.0 0.0
    foreach i {1 2 3 4 5 6 7 8 9} {
        atanTest 4.6.1.$subversion 0.$i
        atanTest 4.6.2.$subversion $i.0
        atanTest 4.6.3.$subversion -0.$i
        atanTest 4.6.4.$subversion -$i.0
        incr subversion
    }

    # cleanup
    rename atanTest ""

    ################################################################################
    # cosh , sinh & tanh : hyperbolic functions
    ################################################################################
    proc hyper {version x} {
        set f [fromstr $x 18]
        fassert cosh $version.0 {todouble [cosh $f]} [expr {cosh($x)}]
        fassert sinh $version.1 {todouble [sinh $f]} [expr {sinh($x)}]
        fassert tanh $version.2 {todouble [tanh $f]} [expr {tanh($x)}]
    }

    hyper 4.7.0 0.0
    set subversion 0
    foreach i {1 2 3 4 5 6 7 8 9} {
        hyper 4.7.1.$subversion 0.$i
        hyper 4.7.2.$subversion $i.0
        hyper 4.7.3.$subversion -0.$i
        hyper 4.7.4.$subversion -$i.0
    }

    # cleanup
    rename hyper ""

	################################################################################
	# tostr with -nosci option
	################################################################################
	set version 5.0
	fassert tostr-nosci $version.0 {tostr -nosci [fromstr 23450.e+7]} 234500000000.
	fassert tostr-nosci $version.1 {tostr -nosci [fromstr 23450.e-7]} 0.002345
	fassert tostr-nosci $version.2 {tostr -nosci [fromstr 23450000]} 23450000.
	fassert tostr-nosci $version.3 {tostr -nosci [fromstr 2345.0]} 2345.

	################################################################################
	# tests for isInt - ticket 3309165
	################################################################################
	assert isInt $version.0 {isInt 12345678901234} 1
	assert isInt $version.1 {isInt 12345678901234.0} 0
	assert isInt $version.1 {isInt not-a-number} 0
}

testSuite
################################################################################
# end of testsuite for bigfloat 1.0
################################################################################
# cleanup global procs

	    }
	    incr i
	}

	# Return if the relative error is within an acceptable range

	set rerror [expr { 2. * abs( $yTop - $yBot )
			   / ( abs( $yTop ) + abs( $yBot ) + $params(-ftol) ) }]
	if { $rerror < $params(-ftol) } {
	    set status ok
	    break
	}

	# Count iterations

	foreach {x y} $dd(x) break
	expr { abs($x-0.774561) < 0.00005 && abs($y-0.755644) < 0.00005 }
    } \
    -cleanup {
	rename g {}; unset dd
    } \
    -result 1

# Make sure the method deals gracefully with a "valley"
# (Ticket UUID: 3193459)

test nelderMead-2.5 "Nelder-Mead - indeterminate minimum (valley)" \
    -setup {
	proc h {a b} {
	    return [expr {abs($a-$b)}]
	}
    } \
    -body {
	array set dd [::math::optimize::nelderMead h {1. 1.}]
	foreach {x y} $dd(x) break
	expr { abs($x-1.) < 0.00005 && abs($y-1.) < 0.00005 }
    } \
    -cleanup {
	rename h {}; unset dd
    } \
    -result 1

testsuiteCleanup

#  Restore precision
set ::tcl_precision $old_precision

# Local Variables:

package ifneeded math::linearalgebra     1.1.4 [list source [file join $dir linalg.tcl]]
package ifneeded math::bignum            3.1.1 [list source [file join $dir bignum.tcl]]
package ifneeded math::bigfloat          1.2.2 [list source [file join $dir bigfloat.tcl]]
package ifneeded math::machineparameters 0.1   [list source [file join $dir machineparameters.tcl]]

if {![package vsatisfies [package provide Tcl] 8.5]} {return}
package ifneeded math::calculus::symdiff 1.0   [list source [file join $dir symdiff.tcl]]
package ifneeded math::bigfloat          2.0.2 [list source [file join $dir bigfloat2.tcl]]
package ifneeded math::numtheory         1.0   [list source [file join $dir numtheory.tcl]]
package ifneeded math::decimal           1.0.3 [list source [file join $dir decimal.tcl]]