Version 30 of tcl::mathfunc

• Intro
• See Also
• List of build-in functions
• User-Defined Functions
• Namespace-local tcllib::mathfun
• Using Math Functions in a Namespace
• atan2
• Non-Math mathfunc

Intro

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.

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

See Also

• Additional math functions

List of build-in functions

User-Defined 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.

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), the [expr] command 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 mynamesapce can uset the lobgase() function.

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

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 [L5 ]. 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
    }
}