Richard Suchenwirth 2005-03-25 -
TOOT is "transparent
OO for
Tcl" - a "pure-value" approach, where a value (a
listable string) like
{Foo | bar grill}is interpreted to be of class
Foo (so
Foo's methods can be applied to it), with the "instance variable" values
bar and ''grill'. (In fact, they aren't "variable" - values are immutable).
The "|" as second element just identifies this as a TOOT value. "Transparent" means that a TOOT has nothing to hide - its state is fully visible in the string representation. For a "constructor",
list is sufficient:
set c [list Complex | $real $imag]
but a few keystrokes add "constructor sugar", so you might as well call
set c [Complex | $real $imag]
No
garbage collection is necessary: like all Tcl values, TOOT values just go away when nobody wants them any more (e.g. on
return when associated with a local variable).
Methods are called as usual, with the method name (which can also look like "+") after the object, and then possibly more arguments. The example with the multiplication method named, evidently, "*" shows that the appearance of infix arithmetics comes as a by-product:
set i {Complex | 0 1} ;#-- imaginary unit i
$i * $i ==> {Complex | -1 0} ;#-- such that i*i == -1Reinventing
Complex math made simple, here's my experiments. Binary operators take one argument, which can be another Complex, or a real number x, which then gets "upgraded" to [Complex | $x 0]. A single
proc contains all methods for the Complex "class":
proc Complex {| r i {method ""} args} {
if {[llength $args]==1} {
set operand [lindex $args 0]
if [string is double -strict $operand] {
set r2 $operand; set i2 0
} else {foreach {Complex | r2 i2} $operand break}
}
switch -- $method {
"" {list Complex | $r $i ;#--constructor sugar}
real {set r}
imag {set i}
abs {expr {hypot($i,$r)}}
arg {expr {atan2($i,$r)}}
format {expr {$i ? "$r+i*$i" : $r}}
== {expr {$r==$r2 && $i==$i2}}
!= {expr {!($r==$r2 && $i==$i2)}}
+ {Complex | [+ $r $r2] [+ $i $i2]}
- {Complex | [- $r $r2] [- $i $i2]}
* {Complex | [expr {$r*$r2 - $i*$i2}] \
[expr {$r*$i2 + $r2*$i}]
}
/ {set div [expr {$r2*$r2 + $i2*$i2}]
Complex | [expr {($r*$r2 + $i*$i2) / $div}] \
[expr {($r2*$i - $r*$i2) / $div}]
}
default {error "unknown method $method"}
}
}
#-- For convenience, [expr] operators are exported as commands:
foreach op {+ - * /} {proc $op {a b} "expr {\$a $op \$b}"}To make this flavor of TOOT work, we
let unknown know it shall auto-expand the first word if its second element is "|" :
proc know what {proc unknown args $what\n[info body unknown]}
know {
if {[lindex $args 0 1] eq "|"} {
return [uplevel 1 [lindex $args 0] [lrange $args 1 end]]
}
}
#-- This little tester reports the unexpected
proc ? {cmd expected} {
catch {uplevel 1 $cmd} res
if {$res ne $expected} {puts "$cmd -> $res, expected $expected"}
}
#-- The test suite passes silently when all goes well:
set i {Complex | 0 1} ;# flat value
set b [Complex | 3 4] ;# constructor sugar
? {$b format} {3+i*4}
? {$b abs} 5.0
? {$b real} 3
? {$b imag} 4
? {$i == $i} 1
? {$i == $b} 0
? {$i != $b} 1
? {$i + $b} {Complex | 3 5}
? {$b - $i} {Complex | 3 3}
? {$b + 1} {Complex | 4 4}
? {$i * $i} {Complex | -1 0} ;# i**2 == -1?
? {[$i * $i] format} -1
set r [$b abs]
set phi [$b arg]
? {[[Complex | [expr cos($phi)] [expr sin($phi)]] * $r] == $b} 1
? {$b / 0} "divide by zero"
? {$b / {Complex | 0 0}} "divide by zero"
? {$a foo} "unknown method foo"See also
Straightforward implementation of complex numbers which is included in recent
Tcllib
