# exact.test --
#
# Test cases for the math::exact package
#
# Copyright (c) 2015 by Kevin B. Kenny
#
# See the file "license.terms" for information on usage and redistribution of
# this file, and for a DISCLAIMER OF ALL WARRANTIES.
#
#-----------------------------------------------------------------------------
source [file join \
[file dirname [file dirname [file join [pwd] [info script]]]] \
devtools testutilities.tcl]
testsNeedTcl 8.6
testsNeedTcltest 2.3
support {
use grammar_aycock/aycock-runtime.tcl grammar::aycock::runtime grammar::aycock
useKeep grammar_aycock/aycock-debug.tcl grammar::aycock::debug grammar::aycock
useKeep grammar_aycock/aycock-build.tcl grammar::aycock grammar::aycock
}
testing {
useLocal exact.tcl math::exact
}
package require Tcl 8.6
package require grammar::aycock 1.0
package require math::exact 1.0.1
#-----------------------------------------------------------------------------
namespace eval math::exact::test {
namespace import ::math::exact::exactexpr
proc signum {x} {expr {($x > 0) - ($x < 0)}}
proc leakBaseline {} {
variable leakBaseline
foreach o [info commands ::oo::Obj*] {
dict set leakBaseline $o {}
}
return
}
proc leakCheck {} {
variable leakBaseline
set trouble {}
set sep {}
foreach o [lsort -dictionary [info commands ::oo::Obj*]] {
if {![dict exists $leakBaseline $o]} {
if {[info object isa typeof $o math::exact::counted]} {
append trouble $sep "Leaked counted object " \
$o ": " [$o dump] \n
} else {
append trouble $sep "Leaked object " $o \n
}
}
}
if {$trouble ne {}} {
return -code error -errorcode {LEAKCHECK} $trouble
}
return
}
namespace import ::tcltest::test
test math::exact-1.0 {unit test gcd} {
math::exact::gcd 2
} 2
test math::exact-1.1 {unit test gcd} {
math::exact::gcd 2 0
} 2
test math::exact-1.2 {unit test gcd} {
math::exact::gcd 0 2
} 2
test math::exact-1.3 {unit test gcd} {
math::exact::gcd 2 3
} 1
test math::exact-1.4 {unit test gcd} {
math::exact::gcd 3 2
} 1
test math::exact-1.5 {unit test gcd} {
math::exact::gcd 21 12
} 3
test math::exact-1.6 {unit test gcd} {
math::exact::gcd 12 21
} 3
test math::exact-1.5 {unit test gcd} {
math::exact::gcd 21 12
} 3
test math::exact-1.6 {unit test gcd} {
math::exact::gcd 12 21
} 3
test math::exact-1.7 {unit test gcd} {
math::exact::gcd 108 66
} 6
test math::exact-1.8 {unit test gcd} {
math::exact::gcd 66 108
} 6
test math::exact-1.9 {unit test gcd} {
math::exact::gcd 66 108 88
} 2
test math::exact-2.0 {unit test transpose matrix} {
math::exact::trans {{0 1} {2 3}}
} {{0 2} {1 3}}
test math::exact-2.1 {unit test transpose 2x2x2} {
math::exact::trans {{{0 1} {2 3}} {{4 5} {6 7}}}
} {{{0 1} {4 5}} {{2 3} {6 7}}}
test math::exact-3.1 {unit test determinant} {
math::exact::determinant {{2 3} {5 7}}
} -1
test math::exact-4.1 {unit test reverse} {
math::exact::reverse {{2 3} {5 7}}
} {{7 -3} {-5 2}}
test math::exact-5.1 {unit test veven} {
math::exact::veven {2 4}
} 1
test math::exact-5.2 {unit test veven} {
math::exact::veven {2 3}
} 0
test math::exact-6.1 {unit test meven} {
math::exact::meven {{2 4} {6 8}}
} 1
test math::exact-6.2 {unit test meven} {
math::exact::meven {{2 3} {6 8}}
} 0
test math::exact-7.1 {unit test teven} {
math::exact::teven {{{2 4} {6 8}} {{10 12} {14 16}}}
} 1
test math::exact-7.2 {unit test teven} {
math::exact::teven {{{2 4} {6 8}} {{10 13} {14 16}}}
} 0
test math::exact-8.1 {unit test vhalf} {
math::exact::vhalf {6 8}
} {3 4}
test math::exact-9.1 {unit test mhalf} {
math::exact::mhalf {{6 8} {10 12}}
} {{3 4} {5 6}}
test math::exact-10.1 {unit test thalf} {
math::exact::thalf {{{6 8} {10 12}} {{14 16} {18 20}}}
} {{{3 4} {5 6}} {{7 8} {9 10}}}
test math::exact-11.1 {unit test sign} {
set trouble {}
set sep \n
for {set a -1} {$a <= 1} {incr a} {
for {set b -1} {$b <= 1} {incr b} {
if {$a ==0 && $b == 0} {
set sb 0
} elseif {$a == 0} {
set sb [signum $b]
} elseif {$b == 0} {
set sb [signum $a]
} elseif {$a/$b < 0} {
set sb 0
} else {
set sb [signum $a]
}
set is [math::exact::sign [list $a $b]]
if {$is != $sb} {
append trouble "sign(" $a "," $b ") is " $is \
", should be " $sb "\n"
}
}
}
set trouble
} {}
test math::exact-12.1 {unit test vrefines} {
set trouble {}
set sep {}
for {set a -1} {$a <= 1} {incr a} {
for {set b -1} {$b <= 1} {incr b} {
if {$a ==0 && $b == 0} {
set sb 0
} elseif {$a == 0} {
set sb 1
} elseif {$b == 0} {
set sb 1
} elseif {$a/$b < 0} {
set sb 0
} else {
set sb 1
}
set is [math::exact::vrefines [list $a $b]]
if {$is != $sb} {
append trouble $sep "vrefines(" $a "," $b ") is " $is \
", should be " $sb
set sep \n
}
}
}
set trouble
} {}
test math::exact-13.1 {unit test mrefines} {
math::exact::mrefines {{1 2} {3 4}}
} 1
test math::exact-13.2 {unit test mrefines} {
math::exact::mrefines {{1 2} {-3 -4}}
} 0
test math::exact-13.3 {unit test mrefines} {
math::exact::mrefines {{-1 -2} {-3 -4}}
} 1
test math::exact-13.4 {unit test mrefines} {
math::exact::mrefines {{-1 2} {-3 4}}
} 0
test math::exact-14.1 {unit test trefines} {
math::exact::trefines {{{1 2} {3 4}} {{5 6} {7 8}}}
} 1
test math::exact-14.2 {unit test trefines} {
math::exact::trefines {{{-1 -2} {-3 -4}} {{-5 -6} {-7 -8}}}
} 1
test math::exact-14.3 {unit test trefines} {
math::exact::trefines {{{-1 2} {-3 4}} {{-5 6} {-7 8}}}
} 0
test math::exact-14.4 {unit test trefines} {
math::exact::trefines {{{1 2} {3 4}} {{5 6}} {{-7 -8}}}
} 0
test math::exact-14.5 {unit test trefines} {
math::exact::trefines {{{1 2} {3 4}} {{-5 -6}} {{-7 -8}}}
} 0
test math::exact-14.6 {unit test trefines} {
math::exact::trefines {{{1 2} {-3 -4}} {{-5 -6}} {{-7 -8}}}
} 0
test math::exact-15.1 {unit test vlessv} {
set intervals {
{-1 0} {-2 1} {-1 1} {-1 2} {0 1} {2 4} {3 3} {14 7} {1 0}
}
set trouble {}
set sep {}
set i 0
foreach a $intervals {
set j 0
foreach b $intervals {
set is [math::exact::vlessv $a $b]
if {[lindex $a 1] == 0 && [lindex $b 1] == 0} {
set sb 0
} else {
set sb [expr {$i < $j}]
}
if {$is != $sb} {
append trouble $sep "vlessv(" $a ";" $b ") is " $is \
" should be " $sb
set sep \n
}
incr j
}
incr i
}
set trouble
} {}
test math::exact-16.1 {unit test mlessm - also tests mlessv} {
set intervals {
{-2 1} {-1 1} {-1 2} {0 1} {2 4} {3 3} {14 7} {1 0}
}
set trouble {}
set sep {}
set i 0
foreach a $intervals {
set j $i
foreach b [lrange $intervals $i end] {
set k 0
foreach c $intervals {
set l $k
foreach d [lrange $intervals $k end] {
if {[lindex $b 1] == 0 && [lindex $c 1] == 0} {
set sb 0
} else {
set sb [expr {$j < $k}]
}
set is [math::exact::mlessm [list $b $a] [list $d $c]]
if {$is != $sb} {
append trouble $sep "mlessm(" $a "," $b ";" \
$c "," $d ") is " $is \
" should be " $sb " -- " \
[list i $i j $j k $k l $k]
set sep \n
}
incr l
}
incr k
}
incr j
}
incr i
}
set trouble
} {}
test math::exact-17.1 {unit test vscale} {
math::exact::vscale {2 3}
} {2 3}
test math::exact-17.2 {unit test vscale} {
math::exact::vscale {4 6}
} {2 3}
test math::exact-17.1 {unit test vscale} {
math::exact::vscale {8 12}
} {2 3}
test math::exact-18.1 {unit test mscale} {
math::exact::mscale {{2 3} {4 5}}
} {{2 3} {4 5}}
test math::exact-18.2 {unit test mscale} {
math::exact::mscale {{4 6} {8 10}}
} {{2 3} {4 5}}
test math::exact-18.3 {unit test mscale} {
math::exact::mscale {{8 12} {16 20}}
} {{2 3} {4 5}}
test math::exact-19.1 {unit test tscale} {
math::exact::tscale {{{2 3} {4 5}} {{6 7} {8 9}}}
} {{{2 3} {4 5}} {{6 7} {8 9}}}
test math::exact-19.2 {unit test tscale} {
math::exact::tscale {{{4 6} {8 10}} {{12 14} {16 18}}}
} {{{2 3} {4 5}} {{6 7} {8 9}}}
test math::exact-10.3 {unit test tscale} {
math::exact::tscale {{{8 12} {16 20}} {{24 28} {32 36}}}
} {{{2 3} {4 5}} {{6 7} {8 9}}}
test math::exact-20.1 {unit test vreduce} {
math::exact::vreduce {2 3}
} {2 3}
test math::exact-20.2 {unit test vreduce} {
math::exact::vreduce {4 6}
} {2 3}
test math::exact-20.1 {unit test vreduce} {
math::exact::vreduce {8 12}
} {2 3}
test math::exact-21.1 {unit test mreduce} {
math::exact::mreduce {{2 3} {4 5}}
} {{2 3} {4 5}}
test math::exact-21.2 {unit test mreduce} {
math::exact::mreduce {{4 6} {8 10}}
} {{2 3} {4 5}}
test math::exact-21.3 {unit test mreduce} {
math::exact::mreduce {{8 12} {16 20}}
} {{2 3} {4 5}}
test math::exact-22.1 {unit test treduce} {
math::exact::treduce {{{2 3} {4 5}} {{6 7} {8 9}}}
} {{{2 3} {4 5}} {{6 7} {8 9}}}
test math::exact-22.2 {unit test treduce} {
math::exact::treduce {{{4 6} {8 10}} {{12 14} {16 18}}}
} {{{2 3} {4 5}} {{6 7} {8 9}}}
test math::exact-22.3 {unit test treduce} {
math::exact::treduce {{{8 12} {16 20}} {{24 28} {32 36}}}
} {{{2 3} {4 5}} {{6 7} {8 9}}}
test math::exact-23.1 {unit test mdotv} {
math::exact::mdotv {{2 3} {4 5}} {10 1}
} {24 35}
test math::exact-24.1 {unit test mdotm} {
math::exact::mdotm {{2 3} {4 5}} {{1000 10} {100 1}}
} {{2040 3050} {204 305}}
test math::exact-25.1 {unit test mdott} {
math::exact::mdott {{1000 10} {100 1}} {{{2 3} {4 5}} {{6 7} {8 9}}}
} {{{2300 23} {4500 45}} {{6700 67} {8900 89}}}
test math::exact-26.1 {unit test tleftv} {
math::exact::tleftv {{{2 3} {4 5}} {{6 7} {8 9}}} {10 1}
} {{26 37} {48 59}}
test math::exact-27.1 {unit test trightv} {
math::exact::trightv {{{2 3} {4 5}} {{6 7} {8 9}}} {10 1}
} {{24 35} {68 79}}
test math::exact-28.1 {unit test tleftm} {
math::exact::tleftm {{{2 3} {4 5}} {{6 7} {8 9}}} {{1000 10} {100 1}}
} {{{2060 3070} {4080 5090}} {{206 307} {408 509}}}
test math::exact-29.1 {unit test trightm} {
math::exact::trightm {{{2 3} {4 5}} {{6 7} {8 9}}} {{1000 10} {100 1}}
} {{{2040 3050} {204 305}} {{6080 7090} {608 709}}}
test math::exact-30.1 {unit test mdisjointm} {
set intervals {
{-2 1} {-1 1} {-1 2} {0 1} {2 4} {3 3} {14 7} {1 0}
}
set trouble {}
set sep {}
set i 0
foreach a $intervals {
set j $i
foreach b [lrange $intervals $i end] {
set k 0
foreach c $intervals {
set l $k
foreach d [lrange $intervals $k end] {
set sb [expr {$j < $k || $l < $i}]
set is [math::exact::mdisjointm \
[list $b $a] [list $d $c]]
if {$is != $sb} {
append trouble $sep "mdisjointm(" $a "," $b ";" \
$c "," $d ") is " $is \
" should be " $sb " -- " \
[list i $i j $j k $k l $k]
set sep \n
}
incr l
}
incr k
}
incr j
}
incr i
}
set trouble
} {}
test math::exact-31.0 {mAsFloat, rational} {
math::exact::mAsFloat {{1 3} {1 3}}
} 1/3
test math::exact-31.1 {mAsFloat, scientificNotation, mantissa, eFormat} {
set p 0
set q 1
set res {}
for {set i 0} {$i < 16} {incr i} {
set r [expr {$p + $q}]
if {$q * $q > $p * $r} {
set m [list [list $q $p] \
[list $r $q]]
} else {
set m [list [list $r $q] \
[list $q $p]]
}
lappend res [math::exact::mAsFloat $m]
set p $q
set q $r
}
set res
} [list \
Undetermined 1.e0 1.e0 1.6e0 1.6e0 1.6e0 1.62e0 1.61e0 1.61e0 \
1.618e0 1.618e0 1.6180e0 1.6180e0 1.61803e0 1.61803e0 1.61803e0]
test math::exact-31.2 {mAsFloat, scientificNotation, mantissa, eFormat} {
set p 0
set q 1
set res {}
for {set i 0} {$i < 16} {incr i} {
set r [expr {$p + $q}]
if {$q * $q > $p * $r} {
set m [list [list [expr {1000*$q}] $p] \
[list [expr {1000*$r}] $q]]
} else {
set m [list [list [expr {1000*$r}] $q] \
[list [expr {1000*$q}] $p]]
}
lappend res [math::exact::mAsFloat $m]
set p $q
set q $r
}
set res
} [list \
Undetermined 1.e3 1.e3 1.6e3 1.6e3 1.6e3 1.62e3 1.61e3 1.61e3 \
1.618e3 1.618e3 1.6180e3 1.6180e3 1.61803e3 1.61803e3 1.61803e3]
test math::exact-31.3 {mAsFloat, scientificNotation, mantissa, eFormat} {
set p 0
set q 1
set res {}
for {set i 0} {$i < 16} {incr i} {
set r [expr {$p + $q}]
if {$q * $q > $p * $r} {
set m [list [list $q [expr {1000*$p}]] \
[list $r [expr {1000*$q}]]]
} else {
set m [list [list $r [expr {1000*$q}]] \
[list $q [expr {1000*$p}]]]
}
lappend res [math::exact::mAsFloat $m]
set p $q
set q $r
}
set res
} [list \
Undetermined 1.e-3 1.e-3 1.6e-3 1.6e-3 \
1.6e-3 1.62e-3 1.61e-3 1.61e-3 \
1.618e-3 1.618e-3 1.6180e-3 1.6180e-3 \
1.61803e-3 1.61803e-3 1.61803e-3]
test math::exact-31.4 {mAsFloat, scientificNotation, mantissa, eFormat} {
set p 0
set q 1
set res {}
for {set i 0} {$i < 16} {incr i} {
set r [expr {$p + $q}]
set mq [expr {-$q}]
set mr [expr {-$r}]
if {$q * $q > $p * $r} {
set m [list [list $mq $p] \
[list $mr $q]]
} else {
set m [list [list $mr $q] \
[list $mq $p]]
}
lappend res [math::exact::mAsFloat $m]
set p $q
set q $r
}
set res
} [list \
Undetermined -2.e0 -2.e0 -1.6e0 \
-1.7e0 -1.7e0 -1.62e0 -1.62e0 \
-1.62e0 -1.618e0 -1.618e0 -1.6180e0 \
-1.6181e0 -1.61803e0 -1.61804e0 -1.61804e0]
test math::exact-31.5 {mAsFloat, 0/0} {
math::exact::mAsFloat {{0 0} {0 0}}
} NaN
test math::exact-31.6 {mAsFloat, infinity} {
math::exact::mAsFloat {{1 0} {1 0}}
} Inf
test math::exact-31.7 {mAsFloat, zero} {
math::exact::mAsFloat {{0 1} {0 1}}
} 0
test math::exact-31.8 {mAsFloat, integer} {
math::exact::mAsFloat {{2 1} {2 1}}
} 2
test math::exact-31.9 {mAsFloat, reverse signs} {
list [math::exact::mAsFloat {{2 -1} {2 -1}}] \
[math::exact::mAsFloat {{-2 -1} {-2 -1}}]
} {-2 2}
test math::exact-40.1 {simple expr} {
-setup leakBaseline
-body {
set v [[exactexpr {1}] ref]
set result [list [$v asPrint 57] [$v asFloat 57]]
$v unref
leakCheck
set result
}
-result {1 1.0000000000000000e0}
}
test math::exact-40.2 {unary plus} {
-setup leakBaseline
-body {
set v [[exactexpr {+ 1}] ref]
set result [list [$v asPrint 57] [$v asFloat 57]]
$v unref
leakCheck
set result
}
-result {1 1.0000000000000000e0}
}
test math::exact-40.3 {unary minus} {
-setup leakBaseline
-body {
set v [[exactexpr {- 1}] ref]
set result [list [$v asPrint 57] [$v asFloat 57]]
$v unref
leakCheck
set result
}
-result {-1 -9.999999999999999e-1}
}
test math::exact-40.4 {product} {
-setup leakBaseline
-body {
set v [[exactexpr {2 * 3}] ref]
set result [list [$v asPrint 57] [$v asFloat 57]]
$v unref
leakCheck
set result
}
-result {6 6.000000000000000e0}
}
test math::exact-40.5 {quotient} {
-setup leakBaseline
-body {
set v [[exactexpr {2 / 3}] ref]
set result [list [$v asPrint 57] [$v asFloat 57]]
$v unref
leakCheck
set result
}
-result {2/3 6.666666666666666e-1}
}
test math::exact-40.6 {associativity of /} {
-setup leakBaseline
-body {
set v [[exactexpr {2 / 3 / 4}] ref]
set result [list [$v asPrint 57] [$v asFloat 57]]
$v unref
leakCheck
set result
}
-result {1/6 1.6666666666666667e-1}
}
test math::exact-40.7 {associativity of */} {
-setup leakBaseline
-body {
set v [[exactexpr {2 / 3 * 4}] ref]
set result [list [$v asPrint 57] [$v asFloat 57]]
$v unref
leakCheck
set result
}
-result {8/3 2.6666666666666667e0}
}
test math::exact-40.8 {associativity of */} {
-setup leakBaseline
-body {
set v [[exactexpr {2 * 3 / 4}] ref]
set result [list [$v asPrint 57] [$v asFloat 57]]
$v unref
leakCheck
set result
}
-result {3/2 1.5000000000000000e0}
}
test math::exact-40.9 {sum} {
-setup leakBaseline
-body {
set v [[exactexpr {2 + 3}] ref]
set result [list [$v asPrint 57] [$v asFloat 57]]
$v unref
leakCheck
set result
}
-result {5 5.000000000000000e0}
}
test math::exact-40.10 {difference} {
-setup leakBaseline
-body {
set v [[exactexpr {2 - 3}] ref]
set result [list [$v asPrint 57] [$v asFloat 57]]
$v unref
leakCheck
set result
}
-result {-1 -9.999999999999999e-1}
}
test math::exact-40.11 {associativity of -} {
-setup leakBaseline
-body {
set v [[exactexpr {2 - 3 - 4}] ref]
set result [list [$v asPrint 57] [$v asFloat 57]]
$v unref
leakCheck
set result
}
-result {-5 -5.000000000000000e0}
}
test math::exact-40.12 {associativity of +-} {
-setup leakBaseline
-body {
set v [[exactexpr {2 - 3 + 4}] ref]
set result [list [$v asPrint 57] [$v asFloat 57]]
$v unref
leakCheck
set result
}
-result {3 3.0000000000000001e0}
}
test math::exact-40.13 {associativity of +-} {
-setup leakBaseline
-body {
set v [[exactexpr {2 + 3 - 4}] ref]
set result [list [$v asPrint 57] [$v asFloat 57]]
$v unref
leakCheck
set result
}
-result {1 1.0000000000000000e0}
}
test math::exact-40.14 {precedence of +*} {
-setup leakBaseline
-body {
set v [[exactexpr {3 + 5 * 7}] ref]
set result [list [$v asPrint 57] [$v asFloat 57]]
$v unref
leakCheck
set result
}
-result {38 3.800000000000000e1}
}
test math::exact-40.15 {precedence of +*} {
-setup leakBaseline
-body {
set v [[exactexpr {3 * 5 + 7}] ref]
set result [list [$v asPrint 57] [$v asFloat 57]]
$v unref
leakCheck
set result
}
-result {22 2.200000000000000e1}
}
test math::exact-40.16 {parentheses} {
-setup leakBaseline
-body {
set v [[exactexpr {(2 + 3) * 5}] ref]
set result [list [$v asPrint 57] [$v asFloat 57]]
$v unref
leakCheck
set result
}
-result {25 2.500000000000000e1}
}
test math::exact-40.17 {V + E} {
-setup leakBaseline
-body {
set v [[exactexpr {2 + real(-3/5)}] ref]
set result [list [$v asPrint 57] [$v asFloat 57]]
$v unref
leakCheck
set result
}
-result {1.4000000000000000e0 1.4000000000000000e0}
}
test math::exact-40.18 {V - E} {
-setup leakBaseline
-body {
set v [[exactexpr {2 - real(3/5)}] ref]
set result [list [$v asPrint 57] [$v asFloat 57]]
$v unref
leakCheck
set result
}
-result {1.4000000000000000e0 1.4000000000000000e0}
}
test math::exact-40.19 {E / E} {
-setup leakBaseline
-body {
set v [[exactexpr {real(3/5)/real(2/5)}] ref]
set result [list [$v asPrint 57] [$v asFloat 57]]
$v unref
leakCheck
set result
}
-result {1.5000000000000000e0 1.5000000000000000e0}
}
test math::exact-40.20 {E + V} {
-setup leakBaseline
-body {
set v [[exactexpr {real(3/2) + (2/5)}] ref]
set result [list [$v asPrint 57] [$v asFloat 57]]
$v unref
leakCheck
set result
}
-result {1.9000000000000000e0 1.9000000000000000e0}
}
test math::exact-40.21 {E - V} {
-setup leakBaseline
-body {
set v [[exactexpr {real(3/2) - (2/5)}] ref]
set result [list [$v asPrint 57] [$v asFloat 57]]
$v unref
leakCheck
set result
}
-result {1.1000000000000000e0 1.1000000000000000e0}
}
test math::exact-40.22 {E * V} {
-setup leakBaseline
-body {
set v [[exactexpr {real(3/2) * (2/5)}] ref]
set result [list [$v asPrint 57] [$v asFloat 57]]
$v unref
leakCheck
set result
}
-result {6.0000000000000001e-1 6.0000000000000001e-1}
}
test math::exact-40.23 {E / V} {
-setup leakBaseline
-body {
set v [[exactexpr {real(3/2) / (5/2)}] ref]
set result [list [$v asPrint 57] [$v asFloat 57]]
$v unref
leakCheck
set result
}
-result {6.0000000000000001e-1 6.0000000000000001e-1}
}
test math::exact-40.24 {lexical error} {
-setup leakBaseline
-body {
set result [list [catch {exactexpr {2 ! 1}} m] $m]
leakCheck
set result
}
-match glob
-result {1 {invalid character*}}
}
test math::exact-40.25 {syntax error} {
-setup leakBaseline
-body {
set result [list [catch {exactexpr {2 $ 1}} m] $m]
leakCheck
set result
}
-match glob
-result {1 {syntax error*}}
}
test math::exact-41.1 {square root} {
-setup leakBaseline
-body {
set v [[exactexpr {sqrt(25/16)}] ref]
set result [list [$v refcount] [$v asFloat 57]]
$v unref
#leakCheck
set result
}
-result {1 1.2500000000000000e0}
}
test math::exact-41.2 {square root} {
-setup leakBaseline
-body {
set v [[exactexpr {sqrt(2)}] ref]
set result [list [$v refcount] [$v asFloat 57]]
$v unref
leakCheck
set result
}
-result {1 1.4142135623730950e0}
}
test math::exact-41.3 {square root} {
-setup leakBaseline
-body {
set v [[exactexpr {sqrt(2000000)}] ref]
set result [list [$v refcount] [$v asFloat 57]]
$v unref
leakCheck
set result
}
-result {1 1.4142135623731e3}
}
test math::exact-41.4 {square root} {
-setup leakBaseline
-body {
set v [[exactexpr {sqrt(2 / 1000000)}] ref]
set result [list [$v refcount] [$v asFloat 57]]
$v unref
leakCheck
set result
}
-result {1 1.41421356237309e-3}
}
test math::exact-41.5 {square root} {
-setup leakBaseline
-body {
set v [[exactexpr {sqrt(sqrt(1/81))}] ref]
set result [list [$v refcount] [$v asFloat 57]]
$v unref
leakCheck
set result
}
-result {1 3.3333333333333333e-1}
}
test math::exact-41.6 {square root of negative rational} {
-setup {
leakBaseline
catch {unset v}
}
-body {
set v [[exactexpr {sqrt(-1)}] ref]
set result [$v asPrint 57]
$v unref
unset v
set result
}
-cleanup {
if {[info exists v]} {$v unref}
}
-match glob
-returnCodes error
-result {*negative argument*}
}
test math::exact-41.7 {square root of negative real} {
-setup {
leakBaseline
catch {unset v}
}
-body {
set v [[exactexpr {sqrt(-sqrt(81))}] ref]
set result [$v asPrint 57]
$v unref
unset v
set result
}
-cleanup {
if {[info exists v]} {$v unref}
}
-match glob
-returnCodes error
-result {*negative argument*}
}
test math::exact-41.8 {square root, cached result} {
-setup leakBaseline
-body {
set x [[exactexpr {sqrt(2)}] ref]
set y [[exactexpr {$x * $x}] ref]
$x unref
set result [list [$y asFloat 57] [$y asFloat 57]]
$y unref
leakCheck
set result
}
-result {2.0000000000000000e0 2.0000000000000000e0}
}
test math::exact-42.1 {exponential} {
-setup leakBaseline
-body {
set v [[exactexpr {exp(1)}] ref]
set result [list [$v refcount] [$v asFloat 57]]
$v unref
leakCheck
set result
}
-result {1 2.7182818284590452e0}
}
test math::exact-42.2 {exponential} {
-setup leakBaseline
-body {
set v [[exactexpr {exp(4)}] ref]
set result [list [$v refcount] [$v asFloat 57]]
$v unref
leakCheck
set result
}
-result {1 5.45981500331442e1}
}
test math::exact-42.3 {exponential} {
-setup leakBaseline
-body {
set v [[exactexpr {exp(0)}] ref]
set result [list [$v refcount] [$v asFloat 57]]
$v unref
leakCheck
set result
}
-result {1 1.0000000000000000e0}
}
test math::exact-43.1 {logarithm} {
-setup leakBaseline
-body {
set v [[exactexpr {log(1)}] ref]
set result [list [$v refcount] [$v asFloat 57]]
$v unref
leakCheck
set result
}
-result {1 0e-18}
}
test math::exact-43.2 {logarithm} {
-setup leakBaseline
-body {
set v [[exactexpr {log(2)}] ref]
set result [list [$v refcount] [$v asFloat 57]]
$v unref
leakCheck
set result
}
-result {1 6.931471805599453e-1}
}
test math::exact-43.3 {logarithm} {
-setup leakBaseline
-body {
set v [[exactexpr {log(1/2)}] ref]
set result [list [$v refcount] [$v asFloat 57]]
$v unref
leakCheck
set result
}
-result {1 -6.931471805599454e-1}
}
test math::exact-43.4 {logarithm} {
-setup {
# Consume digits from math::exact::log2 to avoid appearance of
# a leak in its cache
$math::exact::log2 asFloat 100
leakBaseline
}
-body {
set v [[exactexpr {log(4)}] ref]
set result [list [$v refcount] [$v asFloat 57]]
$v unref
leakCheck
set result
}
-result {1 1.3862943611198906e0}
}
test math::exact-43.5 {logarithm} {
-setup {
# Consume digits from math::exact::log2 to avoid appearance of
# a leak in its cache
$math::exact::log2 asFloat 100
leakBaseline
}
-body {
set v [[exactexpr {log(1/4)}] ref]
set result [list [$v refcount] [$v asFloat 57]]
$v unref
leakCheck
set result
}
-result {1 -1.3862943611198907e0}
}
test math::exact-43.6 {logarithm} {
-setup {
# Consume digits from math::exact::log2 to avoid appearance of
# a leak in its cache
$math::exact::log2 asFloat 100
leakBaseline
}
-body {
set v [[exactexpr {log(exp(10))}] ref]
set result [list [$v refcount] [$v asFloat 57]]
$v unref
leakCheck
set result
}
-result {1 1.0000000000000000e1}
}
test math::exact-43.7 {logarithm} {
-setup {
# Consume digits from math::exact::log2 to avoid appearance of
# a leak in its cache
$math::exact::log2 asFloat 100
leakBaseline
}
-body {
set v [[exactexpr {log(exp(1/10))}] ref]
set result [list [$v refcount] [$v asFloat 57]]
$v unref
leakCheck
set result
}
-result {1 1.0000000000000000e-1}
}
test math::exact-43.8 {logarithm of negative argument} {
-setup {
leakBaseline
catch {unset v}
}
-body {
set v [[exactexpr {log(-sqrt(81))}] ref]
set result [$v asPrint 57]
$v unref
unset v
set result
}
-cleanup {
if {[info exists v]} {$v unref}
}
-match glob
-returnCodes error
-result {*negative argument*}
}
test math::exact-44.1 {pi} {
-setup {
# Consume digits from math::exact::pi to avoid appearance of
# a leak in its cache
$math::exact::pi asFloat 3000
leakBaseline
}
-body {
set v [[exactexpr {pi()}] ref]
set result [$v asFloat 3000]
$v unref
leakCheck
list [string range $result 0 4] \
[string first 999999 $result] \
[string range $result end-1 end]
}
-result {3.141 763 e0}
}
test math::exact-44.2 {Ramanujan constant} {
-setup {
# Consume digits from math::exact::pi to avoid appearance of
# a leak in its cache
$math::exact::pi asFloat 100
leakBaseline
}
-body {
set v [[exactexpr {exp(pi()*sqrt(163))}] ref]
set result [$v asFloat 160]
$v unref
leakCheck
set result
}
-result 2.625374126407687439999999999992e17
}
test math::exact-45.1 {tangent} {
-setup leakBaseline
-body {
set v [[exactexpr {tan(0)}] ref]
set result [list [$v refcount] [$v asFloat 57]]
$v unref
leakCheck
set result
}
-result {1 0e-18}
}
test math::exact-45.2 {tangent} {
-setup leakBaseline
-body {
set v [[exactexpr {tan(pi()/4)}] ref]
set result [list [$v refcount] [$v asFloat 57]]
$v unref
leakCheck
set result
}
-result {1 1.0000000000000000e0}
}
test math::exact-45.3 {tangent} {
-setup leakBaseline
-body {
set v [[exactexpr {tan(pi()/-4)}] ref]
set result [list [$v refcount] [$v asFloat 57]]
$v unref
leakCheck
set result
}
-result {1 -1.0000000000000000e0}
}
test math::exact-45.4 {tangent} {
-setup leakBaseline
-body {
set v [[exactexpr {tan(pi()/3)-sqrt(3)}] ref]
set result [list [$v refcount] [$v asFloat 57]]
$v unref
leakCheck
set result
}
-result {1 0e-18}
}
test math::exact-45.5 {tangent} {
-setup leakBaseline
-body {
set v [[exactexpr {tan(-pi()/3)+sqrt(3)}] ref]
set result [list [$v refcount] [$v asFloat 57]]
$v unref
leakCheck
set result
}
-result {1 0e-18}
}
test math::exact-45.6 {tangent} {
-setup leakBaseline
-body {
set v [[exactexpr {1/tan(pi()/2)}] ref]
set result [list [$v refcount] [$v asFloat 57]]
$v unref
leakCheck
set result
}
-result {1 0e-18}
}
test math::exact-45.7 {tangent} {
-setup leakBaseline
-body {
set v [[exactexpr {tan(pi()/2)}] ref]
set result [list [$v refcount] [$v asFloat 57]]
$v unref
leakCheck
set result
}
-result {1 Undetermined}
}
test math::exact-46.1 {sine} {
-setup leakBaseline
-body {
set v [[exactexpr {sin(0)}] ref]
set result [list [$v refcount] [$v asFloat 57]]
$v unref
leakCheck
set result
}
-result {1 0e-18}
}
test math::exact-46.2 {sine} {
-setup leakBaseline
-body {
set v [[exactexpr {sin(pi()/6)}] ref]
set result [list [$v refcount] [$v asFloat 57]]
$v unref
leakCheck
set result
}
-result {1 5.000000000000000e-1}
}
test math::exact-46.3 {sine} {
-setup leakBaseline
-body {
set v [[exactexpr {sin(-pi()/6)}] ref]
set result [list [$v refcount] [$v asFloat 57]]
$v unref
leakCheck
set result
}
-result {1 -5.000000000000000e-1}
}
test math::exact-46.4 {sine} {
-setup leakBaseline
-body {
set v [[exactexpr {sin(pi()/2)}] ref]
set result [list [$v refcount] [$v asFloat 57]]
$v unref
leakCheck
set result
}
-result {1 1.0000000000000000e0}
}
test math::exact-46.5 {sine} {
-setup leakBaseline
-body {
set v [[exactexpr {sin(-pi()/2)}] ref]
set result [list [$v refcount] [$v asFloat 57]]
$v unref
leakCheck
set result
}
-result {1 -1.0000000000000000e0}
}
test math::exact-46.6 {sine} {
-setup leakBaseline
-body {
set v [[exactexpr {sin(pi())}] ref]
set result [list [$v refcount] [$v asFloat 57]]
$v unref
leakCheck
set result
}
-result {1 0e-18}
}
test math::exact-46.7 {sine} {
-setup leakBaseline
-body {
set v [[exactexpr {sin(-pi())}] ref]
set result [list [$v refcount] [$v asFloat 57]]
$v unref
leakCheck
set result
}
-result {1 0e-18}
}
test math::exact-46.8 {sine} {
-setup leakBaseline
-body {
set v [[exactexpr {sin(13*pi()/6)}] ref]
set result [list [$v refcount] [$v asFloat 57]]
$v unref
leakCheck
set result
}
-result {1 5.000000000000000e-1}
}
test math::exact-46.9 {sine} {
-setup leakBaseline
-body {
set v [[exactexpr {sin(-13*pi()/6)}] ref]
set result [list [$v refcount] [$v asFloat 57]]
$v unref
leakCheck
set result
}
-result {1 -5.000000000000000e-1}
}
test math::exact-47.1 {cosine} {
-setup leakBaseline
-body {
set v [[exactexpr {cos(0)}] ref]
set result [list [$v refcount] [$v asFloat 57]]
$v unref
leakCheck
set result
}
-result {1 9.999999999999999e-1}
}
test math::exact-47.2 {cosine} {
-setup leakBaseline
-body {
set v [[exactexpr {cos(pi()/3)}] ref]
set result [list [$v refcount] [$v asFloat 57]]
$v unref
leakCheck
set result
}
-result {1 5.000000000000000e-1}
}
test math::exact-47.3 {cosine} {
-setup leakBaseline
-body {
set v [[exactexpr {cos(-pi()/3)}] ref]
set result [list [$v refcount] [$v asFloat 57]]
$v unref
leakCheck
set result
}
-result {1 5.000000000000000e-1}
}
test math::exact-47.4 {cosine} {
-setup leakBaseline
-body {
set v [[exactexpr {cos(pi()/2)}] ref]
set result [list [$v refcount] [$v asFloat 57]]
$v unref
leakCheck
set result
}
-result {1 0e-18}
}
test math::exact-47.5 {cosine} {
-setup leakBaseline
-body {
set v [[exactexpr {cos(-pi()/2)}] ref]
set result [list [$v refcount] [$v asFloat 57]]
$v unref
leakCheck
set result
}
-result {1 0e-18}
}
test math::exact-47.6 {cosine} {
-setup leakBaseline
-body {
set v [[exactexpr {cos(pi())}] ref]
set result [list [$v refcount] [$v asFloat 57]]
$v unref
leakCheck
set result
}
-result {1 -1.0000000000000000e0}
}
test math::exact-47.7 {cosine} {
-setup leakBaseline
-body {
set v [[exactexpr {cos(-pi())}] ref]
set result [list [$v refcount] [$v asFloat 57]]
$v unref
leakCheck
set result
}
-result {1 -1.0000000000000000e0}
}
test math::exact-47.8 {cosine} {
-setup leakBaseline
-body {
set v [[exactexpr {cos(7*pi()/3)}] ref]
set result [list [$v refcount] [$v asFloat 57]]
$v unref
leakCheck
set result
}
-result {1 5.000000000000000e-1}
}
test math::exact-47.9 {cosine} {
-setup leakBaseline
-body {
set v [[exactexpr {cos(-7*pi()/3)}] ref]
set result [list [$v refcount] [$v asFloat 57]]
$v unref
leakCheck
set result
}
-result {1 5.000000000000000e-1}
}
test math::exact-45.1 {arctangent} {
-setup leakBaseline
-body {
set v [[exactexpr {atan(0)}] ref]
set result [list [$v refcount] [$v asFloat 57]]
$v unref
leakCheck
set result
}
-result {1 0e-18}
}
test math::exact-45.2 {arctangent} {
-setup leakBaseline
-body {
# Hack to get $szer as a sign matrix
set v [[exactexpr {atan(pi()-pi())}] ref]
set result [list [$v refcount] [$v asFloat 57]]
$v unref
leakCheck
set result
}
-result {1 0e-18}
}
test math::exact-45.3 {arctangent} {
-setup leakBaseline
-body {
set v [[exactexpr {4*atan(1)-pi()}] ref]
set result [list [$v refcount] [$v asFloat 57]]
$v unref
leakCheck
set result
}
-result {1 0e-18}
}
test math::exact-45.4 {arctangent} {
-setup leakBaseline
-body {
set v [[exactexpr {4*atan(-1)+pi()}] ref]
set result [list [$v refcount] [$v asFloat 57]]
$v unref
leakCheck
set result
}
-result {1 0e-18}
}
test math::exact-45.5 {arctangent} {
-setup leakBaseline
-body {
set v [[exactexpr {atan(tan(157/100))}] ref]
set result [list [$v refcount] [$v asFloat 57]]
$v unref
leakCheck
set result
}
-result {1 1.5700000000000000e0}
}
test math::exact-45.6 {arctangent, cached} {
-setup leakBaseline
-body {
set u [[exactexpr {atan(1)}] ref]
set v [[exactexpr {$u + $u + $u + $u}] ref]
$u unref
set result [$v asFloat 57]
$v unref
leakCheck
set result
}
-result 3.1415926535897933e0
}
test math::exact-46.1 {arcsine} {
-setup leakBaseline
-body {
set v [[exactexpr {asin(0)}] ref]
set result [list [$v refcount] [$v asFloat 57]]
$v unref
leakCheck
set result
}
-result {1 0e-18}
}
test math::exact-46.2 {arcsine} {
-setup leakBaseline
-body {
set v [[exactexpr {asin(1/2)-pi()/6}] ref]
set result [list [$v refcount] [$v asFloat 57]]
$v unref
leakCheck
set result
}
-result {1 0e-18}
}
test math::exact-46.3 {arcsine} {
-setup leakBaseline
-body {
set v [[exactexpr {asin(-1/2)+pi()/6}] ref]
set result [list [$v refcount] [$v asFloat 57]]
$v unref
leakCheck
set result
}
-result {1 0e-18}
}
test math::exact-47.1 {arccosine} {
-setup leakBaseline
-body {
set v [[exactexpr {acos(0)-pi()/2}] ref]
set result [list [$v refcount] [$v asFloat 57]]
$v unref
leakCheck
set result
}
-result {1 0e-18}
}
test math::exact-47.2 {arccosine} {
-setup leakBaseline
-body {
set v [[exactexpr {acos(1/2)-pi()/3}] ref]
set result [list [$v refcount] [$v asFloat 57]]
$v unref
leakCheck
set result
}
-result {1 0e-18}
}
test math::exact-47.3 {arccosine} {
-setup leakBaseline
-body {
set v [[exactexpr {acos(-1/2)-2*pi()/3}] ref]
set result [list [$v refcount] [$v asFloat 57]]
$v unref
leakCheck
set result
}
-result {1 0e-18}
}
test math::exact-48.1 {hyperbolic functions} {
-setup leakBaseline
-body {
set result {}
set v [[exactexpr {sinh(0)}] ref]
lappend result [$v asFloat 57]
$v unref
set v [[exactexpr {cosh(0)}] ref]
lappend result [$v asFloat 57]
$v unref
set v [[exactexpr {tanh(0)}] ref]
lappend result [$v asFloat 57]
$v unref
leakCheck
set result
}
-result {0e-18 1.0000000000000000e0 0e-18}
}
test math::exact-48.2 {hyperbolic functions} {
-setup leakBaseline
-body {
set result {}
set v [[exactexpr {sinh(1)}] ref]
lappend result [$v asFloat 57]
$v unref
set v [[exactexpr {cosh(1)}] ref]
lappend result [$v asFloat 57]
$v unref
set v [[exactexpr {tanh(1)}] ref]
lappend result [$v asFloat 57]
$v unref
leakCheck
set result
}
-result {1.1752011936438014e0 1.5430806348152437e0 7.615941559557649e-1}
}
test math::exact-48.3 {hyperbolic functions} {
-setup leakBaseline
-body {
set result {}
set v [[exactexpr {sinh(-1)}] ref]
lappend result [$v asFloat 57]
$v unref
set v [[exactexpr {cosh(-1)}] ref]
lappend result [$v asFloat 57]
$v unref
set v [[exactexpr {tanh(-1)}] ref]
lappend result [$v asFloat 57]
$v unref
leakCheck
set result
}
-result {-1.1752011936438015e0 1.5430806348152437e0 -7.615941559557649e-1}
}
test math::exact-49.1 {asinh} {
-setup leakBaseline
-body {
set result {}
set v [[exactexpr {asinh(-1)}] ref]
lappend result [$v asFloat 57]
$v unref
set v [[exactexpr {asinh(0)}] ref]
lappend result [$v asFloat 57]
$v unref
set v [[exactexpr {asinh(1)}] ref]
lappend result [$v asFloat 57]
$v unref
leakCheck
set result
}
-result {-8.813735870195431e-1 0e-18 8.813735870195430e-1}
}
test math::exact-50.1 {acosh} {
-setup leakBaseline
-body {
set result {}
set v [[exactexpr {acosh(3/2)}] ref]
lappend result [$v asFloat 57]
$v unref
set v [[exactexpr {acosh(2)}] ref]
lappend result [$v asFloat 57]
$v unref
set v [[exactexpr {acosh(3)}] ref]
lappend result [$v asFloat 57]
$v unref
leakCheck
set result
}
-result {9.624236501192069e-1 1.3169578969248167e0 1.7627471740390860e0}
}
test math::exact-51.1 {atanh} {
-setup leakBaseline
-body {
set result {}
set v [[exactexpr {atanh(-1/2)}] ref]
lappend result [$v asFloat 57]
$v unref
set v [[exactexpr {atanh(0)}] ref]
lappend result [$v asFloat 57]
$v unref
set v [[exactexpr {atanh(1/2)}] ref]
lappend result [$v asFloat 57]
$v unref
leakCheck
set result
}
-result {-5.4930614433405485e-1 0e-18 5.4930614433405485e-1}
}
test math::exact-52.1 {e} {
-setup {
# don't report cached digits of e as a leak
$math::exact::e asPrint 100;
leakBaseline
}
-body {
set v [[exactexpr {e()}] ref]
set result [$v asPrint 57]
$v unref
leakCheck
set result
}
-result 2.7182818284590452e0
}
test math::exact-52.2 {e} {
-setup {
# don't report cached digits of e as a leak
$math::exact::e asPrint 100;
leakBaseline
}
-body {
set v [[exactexpr {log(e())}] ref]
set result [$v asPrint 57]
$v unref
leakCheck
set result
}
-result 1.0000000000000000e0
}
test math::exact-52.2 {e} {
-setup {
# don't report cached digits of e as a leak
$math::exact::e asPrint 100;
leakBaseline
}
-body {
set v [[exactexpr {asinh((e() - 1/e()) / 2)}] ref]
set result [$v asPrint 57]
$v unref
leakCheck
set result
}
-result 1.0000000000000000e0
}
test math::exact-53.1 {real**real} {
-setup {
# Consume digits from math::exact::e and math::exact::log2
# to avoid appearance of a leak in the cache
$math::exact::e asFloat 100
$math::exact::log2 asFloat 100
leakBaseline
}
-body {
set v [[exactexpr {e() ** log(2)}] ref]
set result [$v asPrint 57]
$v unref
leakCheck
set result
}
-result 2.0000000000000000e0
}
test math::exact-53.2 {rational**real} {
-setup {
# Consume digits from math::exact::e
# to avoid appearance of a leak in the cache
$math::exact::e asFloat 100
leakBaseline
}
-body {
set v [[exactexpr {2 ** e()}] ref]
set result [$v asPrint 57]
$v unref
leakCheck
set result
}
-result 6.580885991017921e0
}
test math::exact-53.3 {real**1} {
-setup leakBaseline
-body {
set v [[exactexpr {sqrt(4) ** 1}] ref]
set result [$v asPrint 57]
$v unref
leakCheck
set result
}
-result 2.0000000000000000e0
}
test math::exact-53.4 {real**-1} {
-setup leakBaseline
-body {
set v [[exactexpr {sqrt(4) ** (-1)}] ref]
set result [$v asPrint 57]
$v unref
leakCheck
set result
}
-result 5.000000000000000e-1
}
test math::exact-53.5 {real**0} {
-setup leakBaseline
-body {
set v [[exactexpr {sqrt(4) ** 0}] ref]
set result [$v asPrint 57]
$v unref
leakCheck
set result
}
-result 1
}
test math::exact-53.6 {real**+int} {
-setup leakBaseline
-body {
set v [[exactexpr {sqrt(4)**2}] ref]
set result [$v asPrint 57]
$v unref
leakCheck
set result
}
-result 4.000000000000000e0
}
test math::exact-53.7 {real**+int} {
-setup leakBaseline
-body {
set v [[exactexpr {sqrt(4)**5}] ref]
set result [$v asPrint 57]
$v unref
leakCheck
set result
}
-result 3.200000000000000e1
}
test math::exact-53.6 {real**-int} {
-setup leakBaseline
-body {
set v [[exactexpr {sqrt(4)**-2}] ref]
set result [$v asPrint 57]
$v unref
leakCheck
set result
}
-result 2.5000000000000000e-1
}
test math::exact-53.7 {real**+int} {
-setup leakBaseline
-body {
set v [[exactexpr {sqrt(4)**-5}] ref]
set result [$v asPrint 57]
$v unref
leakCheck
set result
}
-result 3.125000000000000e-2
}
test math::exact-53.8 {real**rational} {
-setup leakBaseline
-body {
set v [[exactexpr {sqrt(64)**(10/3)}] ref]
set result [$v asPrint 57]
$v unref
leakCheck
set result
}
-result 1.02400000000000e3
}
test math::exact-53.9 {real**rational} {
-setup leakBaseline
-body {
set v [[exactexpr {sqrt(64)**(1/-3)}] ref]
set result [$v asPrint 57]
$v unref
leakCheck
set result
}
-result 5.000000000000000e-1
}
test math::exact-53.10 {real**integer, accidental} {
-setup leakBaseline
-body {
set v [[math::exact::real**rat [exactexpr {3}] 2 1] ref]
set result [$v asPrint 57]
$v unref
leakCheck
set result
}
-result 9
}
test math::exact-53.11 {zero to zero power} {
-setup leakBaseline
-body {
set v [[exactexpr {0**0}] ref]
set result [$v asPrint 57]
$v unref
leakCheck
set result
}
-returnCodes error
-result "zero to zero power"
}
test math::exact-53.12 {zero to infinite power} {
-setup leakBaseline
-body {
set v [[exactexpr {0**(1/0)}] ref]
set result [$v asPrint 57]
$v unref
leakCheck
set result
}
-returnCodes error
-result "zero to infinite power"
}
test math::exact-53.13 {zero to rational power} {
-setup leakBaseline
-body {
set v [[exactexpr {0**(1/2)}] ref]
set result [$v asPrint 57]
$v unref
leakCheck
set result
}
-result 0
}
test math::exact-53.14 {infinity to zero power} {
-setup leakBaseline
-body {
set v [[exactexpr {(1/0)**0}] ref]
set result [$v asPrint 57]
$v unref
leakCheck
set result
}
-returnCodes error
-result "infinity to zero power"
}
test math::exact-53.15 {infinity to negative power} {
-setup leakBaseline
-body {
set v [[exactexpr {(1/0)**-1}] ref]
set result [$v asPrint 57]
$v unref
leakCheck
set result
}
-result 0
}
test math::exact-53.15 {infinity to positive power} {
-setup leakBaseline
-body {
set v [[exactexpr {(1/0)**1}] ref]
set result [$v asPrint 57]
$v unref
leakCheck
set result
}
-result Inf
}
test math::exact-53.16 {rational to zero power} {
-setup leakBaseline
-body {
set v [[exactexpr {(2/3)**0}] ref]
set result [$v asPrint 57]
$v unref
leakCheck
set result
}
-result 1
}
test math::exact-53.17 {rational power of negative real argument} {
-setup leakBaseline
-body {
set v [[exactexpr {(-sqrt(64))**(1/3)}] ref]
set result [$v asPrint 57]
$v unref
leakCheck
set result
}
-result -2.0000000000000000e0
}
test math::exact-53.18 {rational power of argument near zero} {
-setup leakBaseline
-body {
set v [[exactexpr {log(exp(1/8))**(1/3)}] ref]
set result [$v asPrint 57]
$v unref
leakCheck
set result
}
-result 5.000000000000000e-1
}
test math::exact-53.19 {negative real to real power} {
-setup leakBaseline
-body {
set v [[exactexpr {(-sqrt(4))**(1/2)}] ref]
set result [$v asPrint 57]
$v unref
leakCheck
set result
}
-returnCodes error
-result "negative number to real power"
}
test math::exact-53.20 {rational to zero power} {
-setup leakBaseline
-body {
set v [[exactexpr {(2/3)**0}] ref]
set result [$v asPrint 57]
$v unref
leakCheck
set result
}
-result 1
}
test math::exact-53.21 {rational to positive integer power} {
-setup leakBaseline
-body {
set v [[exactexpr {(2/3)**2}] ref]
set result [$v asPrint 57]
$v unref
leakCheck
set result
}
-result 4/9
}
test math::exact-53.22 {rational to negative integer power} {
-setup leakBaseline
-body {
set v [[exactexpr {(2/3)**-2}] ref]
set result [$v asPrint 57]
$v unref
leakCheck
set result
}
-result 9/4
}
test math::exact-53.23 {rational to rational} {
-setup leakBaseline
-body {
set v [[exactexpr {(-8)**(1/3)}] ref]
set result [$v asPrint 57]
$v unref
leakCheck
set result
}
-result -2.0000000000000000e0
}
test math::exact-53.24 {real to 0/0} {
-setup leakBaseline
-body {
set bad [[math::exact::V new {0 0}] ref]
set v [[exactexpr {sqrt(2)**$bad}] ref]
$bad unref
set result [$v asPrint 57]
$v unref
leakCheck
set result
}
-returnCodes error
-result {zero divided by zero}
}
test math::exact-53.24 {rational to 0/0} {
-setup leakBaseline
-body {
set bad [[math::exact::V new {0 0}] ref]
set v [[exactexpr {(1/2)**$bad}] ref]
$bad unref
set result [$v asPrint 57]
$v unref
leakCheck
set result
}
-returnCodes error
-result {zero divided by zero}
}
test math::exact-53.26 {unit test - rat**int (2/3)**0} {
-setup leakBaseline
-body {
set v [[math::exact::rat**int 2 3 0] ref]
set result [$v asPrint 57]
$v unref
leakCheck
set result
}
-result {1}
}
test math::exact-53.27 {rational powers - normalize base and exponent} {
-setup leakBaseline
-body {
set p [[math::exact::V new {-2 -1}] ref]
set q [[math::exact::V new {-3 -1}] ref]
set r [[exactexpr {$p ** $q}] ref]
$p unref
$q unref
set result [$r asPrint 57]
$r unref
leakCheck
set result
}
-result 8
}
test math::exact-54.1 {abs1, signum1} {
-setup leakBaseline
-body {
set p [[exactexpr {0}] ref]
set q [[exactexpr {2}] ref]
while 1 {
set t [[exactexpr {($q-$p) * 10**36}] ref]
set f [math::exact::abs1 $t]; $t unref
if {!$f} break
set x [[exactexpr {($p+$q)/2}] ref]
set resid [[exactexpr {$x*$x-2}] ref]
set t [[exactexpr {$resid * 10**36}] ref]
if {[math::exact::signum1 $t] > 0} {
$q unref; set q $x
} else {
$p unref; set p $x
}
$t unref; $resid unref
}
set result [$p asFloat 100]
$p unref
$q unref
leakCheck
set result
}
-result 1.41421356237309504880168872421e0
}
# following are demos that I don't know where to put, yet
if 0 {
set p 1
for {set i 0} {$i < 20} {incr i} {
set f [expr {sin(0.01 * $p* acos(-1))}]
set v [[exactexpr "sin($p * pi() / 100)"] ref]
set a [$v asPrint 57]
set r [expr {$f - $a}]
puts "i: $i p: $p float: $f exact: $a difference: $r"
$v unref
set p [expr {11 * $p}]
}
}
if 0 {
for {set x 100} {$x <= 12200} {incr x 100} {
set ex [[exactexpr $x] ref]
puts "x $x ex [$ex asPrint 57]"
set fa [expr {-(double($x)**-4)}]
set ea [[exactexpr {-($ex**-4)}] ref]
puts "fa $fa ea [$ea asPrint 57]"
set fb [expr {exp($fa)}]
set eb [[exactexpr {exp($ea)}] ref]
puts "fb $fb eb [$eb asPrint 120]"
set fc [expr {log($fb)}]
set ec [[exactexpr {log($eb)}] ref]
puts "fc $fc ec [$ec asPrint 120]"
catch {expr {(-$fc) ** -0.25}} ff
set ef [[exactexpr {(-$ec)**(-1/4)}] ref]
puts [format "kahan's function: %s %g" $ff [$ef asFloat 28]]
$ef unref
$ec unref
$eb unref
$ea unref
$ex unref
}
}
if 0 {
set x0 4.0
set x1 4.25
set ex0 [[exactexpr 4] ref]
set ex1 [[exactexpr 4+25/100] ref]
for {set i 1} {$i < 100} {incr i} {
set x2 [expr {108. - (815. - 1500. / $x0) / $x1}]
set x0 $x1
set x1 $x2
set ex2 [[exactexpr {108 - (815 - 1500 / $ex0) / $ex1}] ref]
$ex0 unref
set ex0 $ex1
set ex1 $ex2
puts "$i $x2 [$ex2 asFloat 57]"
}
$ex0 unref
$ex1 unref
}
testsuiteCleanup
}
#-----------------------------------------------------------------------------
# End of test cases
testsuiteCleanup
# Exit if running this test standalone, to allow for Nagelfar coverage
if {$::argv0 eq [info script]} {
exit
}
# Local Variables:
# mode: tcl
# End:
