## Mathematical workbench

Arjen Markus At the Third European Tcl/Tk Users Meeting I presented a "mathematical workbench". This page shows a small example of this work. The idea is described in the abstract:

A handheld calculator is a great way to do all kinds of ad hoc calculations. You do not write a C or Fortran program with hard-coded numbers to add them for balancing your books. In a similar way doing mathematics - for instance solve some geometrical problem - requires a handheld calculator suitable for that type of calculations.

The essential ingredients are an interactive program that interprets dedicated commands, and a few conventions to make its use more or less uniform.

This paper describes the application of Tkcon and such a set of conventions to provide the interface. It illustrates the concepts with three different mathematical tools: complex numbers, ordinary differential equations and (statistical) optimisation.

The script below contains a few commands that illustrate the idea compactly:

• You can define a function of x via [func \$expression]
• You can define the derivative of that function via [deriv funcname]
• You can get the value of a function for a specific value

If you run the script from within Tkcon or a similar shell, you can experiment with it.

(Note: the full workbench contains much more convenient commands)

The workbench is available at the Starkit Distribution Archive [1 ].

AM A small but significant improvement: xderiv_impl now uses the original function, so that you can use it to calculate the second-order derivative and so on! [Did this improvement make it into the latest starkit?]

5Jan2011 JM Is there any demo on the starkit? if so, how is it named?

AM (7 january 2011) I will have to brush off the code - if you are interested, I can do so, but I have not really expanded it of late. The idea still interests me, but with Tcllib and Tklib there is a whole bunch of quite useable modules available.

JM (7 january 2011) Thanks, for now I will look through your other posts, which are very interesting.

``` # functions.tcl --
#
#    Package for analysing real functions
#    (sample Workbench module)
#
# Notes:
#    This package provides basic analysis functionality for real
#    functions of one variable.
#
# Version information:
#    version 0.1: initial implementation, july 2002

package provide Functions 0.1

namespace eval ::Workbench {

variable nextID 0

# uniqueID --
#    Create a unique ID (private)
#
# Arguments:
#    expression   Expression using "x" as independent variable
#                 evaluating to the function value
#
# Result:
#    Name of a new command implementing the function
#
# Side effect:
#    Create a new command that takes one argument, x, and
#    returns the function value
#
proc uniqueID {typename} {
variable nextID

incr nextID

return "\${typename}##\$nextID"
}
} ;# End of namespace

namespace eval ::Functions {

namespace export func deriv

# func --
#    Create a new function
#
# Arguments:
#    expression   Expression using "x" as independent variable
#                 evaluating to the function value
#
# Result:
#    Name of a new command implementing the function
#
# Side effect:
#    Create a new command that takes one argument, x, and
#    returns the function value
#
proc func {expression} {
set name [::Workbench::uniqueID "X-FUNCTION"]
interp alias {} \$name {} [namespace current]::xfunc_impl \$expression
return \$name
}

# xfunc_impl --
#    Implementation of an "x function"
#
# Arguments:
#    expression   Expression using "x" (hidden via [interp alias])
#    x            Independent variable
#
# Result:
#    Function value
#
proc xfunc_impl {expression x} {
expr \$expression
}

# deriv --
#    Create a new function that evaluates to the derivative of the given
#    function
#
# Arguments:
#    funcname     Name (!) of the function
#    step         Step for the numerical derivation
#
# Result:
#    Name of a new command implementing the function's derivative
#
# Side effect:
#    Create a new command that takes one argument, x, and
#    returns the original function's derivative
#
proc deriv {funcname {step 0.01} } {
upvar \$funcname fname
set name [::Workbench::uniqueID "X-DERIVATIVE"]
set expression [lindex [interp alias {} \$fname] 1]
interp alias {} \$name {} [namespace current]::xderiv_impl  \$fname [expr {\$step*0.5}]
return \$name
}

# xderiv_impl --
#    Implementation of the derivative of an "x function"
#
# Arguments:
#    fname     Name (!) of the function
#    step         Step size for numerical derivation
#    xv           Independent variable
# Result:
#    Value of derivative
#
# Note:
#    By using the
#
proc xderiv_impl {fname step xv} {
set x   [expr {\$xv-\$step}]
set fx1 [\$fname \$x]
set x   [expr {\$xv+\$step}]
set fx2 [\$fname \$x]
expr {(\$fx2-\$fx1)/(2.0*\$step)}
}

} ;# End of namespace

#
# Import the functions procedures
#
namespace import ::Functions::*

#
# Simple demo
#
if { [file tail [info script]] == [file tail \$::argv0] } {
puts "Simply a parabola: y = x^2"
set f [func {\$x*\$x}]
set df [deriv f]
set x 0.0
while { \$x < 10.1 } {
puts "[\$f \$x] [\$df \$x]"
set x [expr {\$x+1.0}]
}

puts "A more complex function"
set f [func {sin(\$x)*\$x}]
set df [deriv f]
set x 0.0
while { \$x < 10.1 } {
puts "[\$f \$x] [\$df \$x]"
set x [expr {\$x+0.1}]
}
}```

 Category Mathematics Category Application