tcl::mathfunc

The ::tcl::mathfunc namespace provides commands for all the functions available in [expr]

• See Also
• Documentation
• Description
• List of built-in functions
• User-Defined Functions
• Defining New Functions at the C Level
• Namespace-local tcllib::mathfun
• func: a Convenient Procedure
• Using Math Functions in a Namespace
• atan2
• Non-Math mathfunc
• Not only scalars

See Also

• Additional math functions

Documentation

official reference

TIP 232

for the creation of the ::tcl::mathfunc namespace

TIP 174

Math Operators as Commands. Presents various usage ideas.

Description

::tcl::mathfunc was made available in Tcl 8.5. 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.

List of built-in functions

User-Defined Functions

TIP 232 provides for script-level creation of new functions, analagous to the C level Tcl_CreateMathFunc(3) .

[expr] can be extended with new functions by adding commands to ::tcl::mathfunc, or to a tcl::matchfunc child namespace of any other namespace. In the latter case, the additional [expr] functions are only available to commands in the parent namespace.

Functions can also be overriden or deleted from [expr] by overriding or modifying the corresponding procedure in an appropriate tcl::mathfunc namespace. This functionality was previously not available, even at the C level.

[expr] function arguments are now just as flexible as those of Tcl procs and commands. Variadic numbers of arguments are also possible, and illustrated by by the min() and max() functions.

[expr] functions can now also be called as procedures without using [expr] at all. This is one way to to bypassing the problems discussed at brace your expr-essions.

Defining New Functions at the C Level

AM: On the c.l.t the other day [is this as of May 2003?], Martin Russell asked about how to define new math functions. If you want to do it without the help of DKF's extension [??] and CrtLib [ critcl's critlib?], then here is a recipe provided by Pat Thoyts:

Something along these lines.

static Tcl_MathProc ArbLogProc;

static int
ArbLogProc(clientData, interp, args, resultPtr)
  ClientData clientData;
  Tcl_Interp *interp;     /* current interpreter */
  Tcl_Value  *args;       /* input arguments */
  Tcl_Value  *resultPtr;  /* where to store the result */
{
   double b, n, d;
   b = args[0].doubleValue;
   n = args[1].doubleValue;

   /* do your maths and assign d to the result */
   d = 1.0;

   resultPtr->type = TCL_DOUBLE;
   resultPtr->doubleValue = d;
   return TCL_OK;
}

in your package initialisation...

Tcl_ValueType arblogArgs[2] = { TCL_DOUBLE, TCL_DOUBLE };
Tcl_CreateMathFunc(interp, "arblog", 2, arblogArgs, ArbLogProc,
                   (ClientData)NULL);

Namespace-local tcllib::mathfun

As of Tcl 8.5, if any namespace has a child namespace called tcl::mathfunc (notice that it's a relative name), [expr] will look first in that namespace for available functions. I.e., either ::tcl::matfunc::f or [namespace current]::tcl::mathfunc::f can resolve f($x).

In the following example, any proc in mynamespace can use logbase():

namespace eval mynamespace {
    proc tcl::mathfunc::logbase {x b} {
        expr {log($x) / log($b)}
    }
    
    proc dostuff {} {
        ...
        expr {logbase($some_var,$some_other_var)}
    }
}

func: a Convenient Procedure

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) }

It can be useful to import functions from elsewhere into the local tcl::mathfunc namespace:

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

References:

tcl talked badly (and high on reddit) ,comp.lang.tcl ,2008-02-15

Using Math Functions in a Namespace

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.

atan2

AMG: The man page for atan2 says that its arguments can't both be zero [L1 ]. 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?

Non-Math mathfunc

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
    }
}

Not only scalars

arjen: Mathematical functions defined this way can take lists as arguments and produce lists as results, as illustrated by these rather trivial examples:

proc tcl::mathfunc::maxlist {values} {
    set maxvalue [lindex $values 0]

    foreach value $values {
        set maxvalue [expr {$value > $maxvalue? $value : $maxvalue}]
    }

    return $maxvalue
}

proc tcl::mathfunc::multiply {factor values} {
    set result {}

    foreach value $values {
        lappend result [expr {$factor * $value}]
    }

    return $result
}

puts [expr {maxlist({4 1 2 3})}]
puts [expr {multiply(2,{4 1 2 3})}]