''[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 in 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 serious real-time games and simulation programs, thus broadening the appeal of Tcl.

----
''[Lars H]: Please elaborate. I don't see how the five operations you suggest would be of much help for any of those (with the possible exception of databases, but for that there already are such things as [mk4tcl] to compete with).''

[alove] Let me put it this way: struct::matrix is ALREADY included in the ActiveTCL batteries-included install package, so there's obviously a real demand for it.  And these five procs are THOUSANDS of times faster than struct::matrix, in terms of performance.  So that says something.  ^_^

[Lars H]: Have you considered a [Critcl]-powered package as an alternative 
to a core modification? It's probably very nearly as fast, and much easier 
to get accepted.

[alove] 17 Oct - Alright, I'm reading the documentation for [Critcl].  I'll give it a shot...

[RS] Matrix access (for lists-of-lists, with [lindex] and [lset]) and from 8.5 initialization (with [lrepeat]) are part of the C-coded Tcl core, and as shown they are pretty fast. So where's the problem? 

[alove] The problem is, it's not obvious to newer programmers that they can create matrices.  When they look at the documentation, all they see are list commands.  I program with Tcl on Windows and a lot more people would too, very much like BASIC was used in the 80's, if it was more user-friendly.  I had no idea that lset and lindex could be used to make matrices, and why would anyone think that?  Nowhere in the documentation does it say, "to make a matrix, use these list commands".  And you shouldn't have to use list commands to create a matrix, in the same way that you don't have to create a list by saying "set [list a b c]" - we have a special ''lset'' command for that.

Besides, there are other features of a matrix that aren't duplicated without code, like adding and deleting specific rows.  
----

 # 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:

 # struct::matrix - test program

 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 def matrix = $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] 
----
[[
[Category Graphics]
|
[Category Animation]
]]