Version 25 of tcl::mathfunc

Tcl 8.5 namespace that contains the definitions of all functions used in expr. Operators are in tcl::mathop. Note that changing or adding to these commands changes the set of functions available in expr. Also note that when your code is executing in a namespace other than the global one, you can define your own functions in the "yourNS::tcl::mathfunc" namespace.

[TODO: Combine text below with this page]

AMG: TIP 232 [L1 ] creates the ::tcl::mathfunc namespace which contains commands implementing the [expr] math functions. The functions are documented in the mathfunc(n) man page [L2 ]. (Previous to TIP 232, the math functions were documented in expr(n).)

List of built-in functions

Thanks to TIP 232 [L3 ], you can create new functions without having to resort to Tcl_CreateMathFunc(3) [L4 ]. This makes it possible for pure Tcl scripts to extend [expr]. Also this makes it possible to rewrite or delete math functions, two things that were previously impossible even for extensions written in C. (I have written code that needed this functionality; I guess it's time to update it!)

This makes math function arguments much more flexible, just as flexible as those of Tcl procs and commands. One possibility worth noting is variadic numbers of arguments, a feature used by the shiny, new min() and max() functions.

One more neat trick is calling math functions without using [expr]; they're regular Tcl commands now. Combine this with TIP 174 Math Operators as Commands, and you can avoid using [expr] altogether, bypassing the problems discussed at brace your expr-essions.

See the TIP for more creative usage ideas.

Neil Madden writes [L5 ]:

namespace eval tcl::mathfunc { namespace import ::otherns::* }

as a one liner to import a namespace worth of math functions into expr.

DKF: If you like doing your computations the Lisp way, add this to your scripts:

 namespace path {::tcl::mathop ::tcl::mathfunc}

Now you can use all the above functions (and the math operators) as commands without qualification.

AMG: Here's a math function I sometimes find useful. It accepts three arguments, and it returns whichever of the three is between the other two. It's mostly useful to clamp a number to a range.

 proc ::tcl::mathfunc::mid {a b c} {
     lindex [lsort -real [list $a $b $c]] 1
 }

It can also be implemented as a bunch of [if]s, which is how I do it in C.

Here is one incorrect implementation you should watch out for:

 proc ::tcl::mathfunc::mid {a b c} {
     expr {max($a, min($b, $c))}
 }

This is what Allegro (include/allegro/base.h) has used since the dawn of time. :^( I'm reporting it now; hopefully it'll be fixed. If you're curious, see [L6 ] for my writeup.

KPV The folk algorithm for finding the middle number (or second highest in a longer list) is to take the max of the pair-wise mins. To wit:

  max(min($a,$b), min($a,$c), min($b,$c))

LV So what is an example of a case in which the second, incorrect, version of the algorithm fails? Answer: "incorrect_mid 1 0 0" returns 1. The problem is it doesn't (always) handle the case where two of the inputs are the same. Doh.

AMG: I thought the problem was that it doesn't handle the case of the first input being greater than the other two. This wasn't a problem for Allegro because everyone used its MID macro thusly: MID(minimum_value, value_to_clamp, maximum_value).

RS 2008-01-02: Here's a little example for a user-defined recursive factorial function:

 % proc tcl::mathfunc::fac x {expr {$x<2? 1: $x*fac($x-1)}}
 % expr fac(5)
 120

DKF: A little helper for when writing custom functions:

 proc func {name arguments body} {
    proc tcl::mathfunc::$name $arguments [list expr $body]
 }

This lets us write factorials as just this:

 func fac x { $x<2 ? 1 : $x*fac($x-1) }

AMG: The man page for atan2 says that its arguments can't both be zero [L7 ]. On one system I checked, expr atan2(0,0) returns 0.0. On other systems, I suspect it may behave differently. Right? If so, shouldn't the implementation of atan2 check if both arguments are zero and throw an error?

bsg: Non-math mathfunc: who says all mathfunc's have to be about math. Turning common tcl commands into functions can clean up conditional statements making them easier to read.

Turn something like this:

    if {[lindex $data [expr {2*$i +1}]] eq [lindex $items [expr {2*$itemno +1}]]} {break}

into this:

    if {lindex($data, (2*$i+1)) eq lindex($items, (2*$itemno +1))} {break}

Another example:

    if { $priv(mBar) eq [string range $menu 0 [expr {[string length $priv(mBar)] - 1}]]} { ...

    if { $priv(mBar) eq substr($menu, 0, (strlen($priv(mBar)) - 1))} { ...

Notice how it also eliminates the recursive expr calls.

Here's what I've found useful so far:

  namespace eval tcl::mathfunc {
        proc strlen {str} {
                ::string length $str
        }
        proc stridx {str index} {
                ::string index $str $index
        }
        proc substr {str first last} {
                ::string range $str $first $last
        }
        proc llength {list} {
                ::llength $list
        }
        proc lindex {list index args} {
                ::lindex $list $index {*}$args
        }
        proc lrange {list first last} {
                ::lrange $list $first $last
        }
  }