alove 13 Oct 2004 - What I'm presenting here is essentially a new TCL command that allows you to very easily create a two dimensional matrix and then add or delete data from it.
Currently there is no elegant way to do this is TCL. You either have to create a list-within-a-list using lindex and lreplace/lrange, or else use a combination of arrays and lists, which is equally awkward. Just figuring out how to create a two dimensional matrix is quite a task!
It would be so much nicer if you could just define a matrix and then set or get variables, like so:
defx mymatrix 50 50 setx mymatrix 3 4 'hello world" set a [getx mymatrix 3 4]
So I created a set of five commands that would do that, as seen below. RS gave me some very helpful hints for using upvar, string repeat and other coding tips. Then ak pointed out that the tcllib package struct::matrix is designed to create a 2d matrix just like my commands. So I compared the two approaches using time to see which was fastest. the results are summarized below:
defx struct::matrix -------------------------------------------------------------------------------------- Test setx = 4424 ms Test set cell = 321170 ms defx 7260% faster Test addx = 7041 ms Test add rows = 182172 ms addx 2587% faster Test defx = 11358 ms Test def matrix = 11003083 ms defx 96875% faster
These results are pretty dramatic. Please see the source programs below to verify the results.
I've always felt that Tcl desperately needs 2D matrix commands as part of its core. They have so many uses: for 2D graphics in games, for databases, for plotting points in graphs, basically anything that requires two dimensions.
I am proposing that we include only five new commands - defx, setx and getx are general purpose; addx and delx can be used to add and delete rows, and all the rows below are adjusted, as if you had a list stack in a database.
The advantage of these commands is that they create a standard Tcl list variable that you can manipulate, unlike the struct::matrix package. And they are much faster. If compiled into the Tcl core, they would be fast enoughto use in seriuos real-time games and simulation programs, thus broadening the appeal of Tcl.
# defx - test program
package require Tcl 8.4
wm title . "Matrix"
text .text -height 20 -width 50 -font arial -padx 10 -pady 10
pack .text -expand yes -fill both
proc K {a b} {set a}
proc defx {v a b} {
upvar $v var; set var [string repeat "{[string repeat {{} } $b]} " $a]
}
proc setx {v a b value} {upvar $v var; lset var $a $b $value}
proc getx {v a b} {upvar $v var; lindex $var $x $y}
proc delx {v a} {upvar $v var; set var [lreplace [K $var [set list {}]] $a $a]}
proc addx {v a} {
upvar $v var; set new [string repeat {{} } [llength [lindex $var 0]]]
lappend var $new
if {$a ne "end"} then {
set a1 [expr {[llength $var] - 1}]
for {set x $a1} {$x > $a} {incr x -1} {lset var $x [lindex $var [expr {$x - 1}]]}
lset var $a $new
}
}
# test the matrix. Ranges must be positive integers.
set a 10; set b 5
defx wow $a $b ;# define a matrix: rows/columns
setx wow 4 1 hello ;# set row 4, col 1 = "hello"
setx wow 5 2 big ;# this row is deleted using 'delx' below
setx wow 6 3 world
setx wow 9 4 end
delx wow 5 ;# delete row 5; now there are only nine rows
addx wow 5 ;# add row 5 back again (empty); now there are 10 rows
.text insert end "defx Matrix wow ($a rows, $b cols) \n\n"
.text insert end "Total rows = [llength $wow] \n\n"
foreach x $wow {
foreach y $x {
.text insert end "#$y \t"
}
.text insert end "\n"
}
proc set_command {} {
global wow
for {set x 0} {$x < 1000} {incr x} {setx wow 4 1 hello}
}
set t [time {set_command} 1]
.text insert end "\nTest setx = $t\n"
proc add_command {} {
global wow
for {set x 0} {$x < 1000} {incr x} {addx wow end}
}
set t [time {add_command} 1]
.text insert end "Test addx = $t\n"
proc def_command {} {
defx neo 1000 1000
}
set t [time {def_command} 1]
.text insert end "Test defx = $t\n"And here is the struct::matrix program that I used for the time trial:
package require Tcl 8.4
package require struct::matrix 1.2.1
wm title . "Matrix"
text .text -height 20 -width 50 -font arial -padx 10 -pady 10
pack .text -expand yes -fill both
# test the matrix. Ranges must be positive integers.
set a 10; set b 5
::struct::matrix wow
wow add rows $a
wow add columns $b
wow set cell 1 4 hello
wow set cell 2 5 big
wow set cell 3 6 world
wow set cell 4 9 end
wow delete row 5
wow add rows 1
.text insert end "::struct::matrix wow ($a rows, $b cols) \n\n"
.text insert end "Total rows = [wow rows] \n\n"
for {set x 0} {$x < [wow rows]} {incr x} {
for {set y 0} {$y < [wow columns]} {incr y} {
.text insert end "#[wow get cell $y $x] \t"
}
.text insert end "\n"
}
proc x_settimer {} {
for {set x 0} {$x < 1000} {incr x} {wow set cell 1 4 hello}
}
set t [time {x_settimer} 1]
.text insert end "\nTest set cell = $t\n"
proc add_command {} {
for {set x 0} {$x < 1000} {incr x} {wow add rows 1}
}
set t [time {add_command} 1]
.text insert end "Test add rows = $t\n"
proc def_command {} {
::struct::matrix neo
wow add rows 1000
wow add columns 1000
}
set t [time {def_command} 1]
.text insert end "Test defx = $t\n"AM Interesting - I have been contemplating an investigation into the performance of various ways to create and update a matrix with numbers - this in response to Partial Differential Equations