This module adds big number support to Math::Symbolic. It does so by
extending the parser of the Math::Symbolic module (that is, the one stored
in $Math::Symbolic::Parser) with certain special functions that create
arbitrary precision constants. (Math::Symbolic::Variable objects have been
able to contain arbitrary precision objects since the very beginning.)
This module adds complex number support to Math::Symbolic. It does so by
extending the parser of the Math::Symbolic module (that is, the one stored
in $Math::Symbolic::Parser) with certain special functions that create
complex constants. (Math::Symbolic::Variable objects have been able to
contain complex number objects since the very beginning.)
This module adds numeric error (or uncertainty) support to the
Math::Symbolic parser. It does so by extending the parser grammar of the
Math::Symbolic module (that is, the one stored in $Math::Symbolic::Parser)
with certain special functions that create constants as Number::WithError
objects. (Math::Symbolic::Variable objects have been able to contain
objects since the very beginning.)
This module is an extension to the Math::Symbolic module. A basic
familiarity with that module is required.
Math::SymbolicX::Inline allows easy creation of Perl functions from
symbolic expressions in the context of Math::Symbolic. That means you can
define arbitrary Math::Symbolic trees (including derivatives) and let this
module compile them to package subroutines.
This module offers facilities to turn off the builtin Math::Symbolic
simplification routines and replace them with routines that just clone the
objects. You may want to do this in cases where the simplification
routines fail to simplify the Math::Symbolic trees and waste a lot of CPU
time. (For example, calculating the first order Taylor polynomial of a
moderately complex test function was sped up by 100% on my machine.)
A word of caution, however: If you turn off the simplification routines,
some procedures may produce very, very large trees. One such procedure
would be the consecutive application of many derivatives to a product
without intermediate simplification. This would yield exponential growth
of nodes. (And may, in fact, still do if you keep the simplification
heuristics turned on because most expressions cannot be simplified
significantly.)
This module provides a simple way to extend the Math::Symbolic parser with
arbitrary functions that return any valid Math::Symbolic tree. The return
value of the function call is inserted into the complete parse tree at the
point at which the function call is parsed. Familiarity with the
Math::Symbolic module will be assumed throughout the documentation.
This module is not object oriented. It does not export anything. You
should not call any subroutines directly nor should you modify any class
data directly. The complete interface is the call to use
Math::SymbolicX::ParserExtensionFactory and its arguments. The reason for
the long module name is that you should not have to call it multiple times
in your code because it modifies the parser for good. It is intended to be
a pain to type. :-)
The aim of the module is to allow for hooks into the parser without
modifying the parser yourself because that requires rather in-depth
knowledge of the module code. By specifying key => value pairs of function
names and function implementations (code references) as arguments to the
use() call of the module, this module extends the parser that is stored in
the $Math::Symbolic::Parser variable with the specified functions and
whenever "yourfunction(any argument string not containing an unescaped \)
)" occurs in the code, the subroutine reference is called with the
argument string as argument.
The subroutine is expected to return any Math::Symbolic tree. That means,
as of version 0.133, a Math::Symbolic::Operator, a
Math::Symbolic::Variable, or a Math::Symbolic::Constant object. The
returned object will be incorporated into the Math::Symbolic tree that
results from the parse at the exact position at which the custom function
call was parsed.
Please note that the usage of this module will be quite slow at compile
time because it has to regenerate the complete Math::Symbolic parser the
first time you use this module in your code. The run time performance
penalty should be low, however.
This module offers easy access to formulas for a few often-used
distributions. For that, it uses the Math::Symbolic module which gives the
user an opportunity to manufacture distributions to his liking.
The module can be used in two styles: It has a procedural interface which
is demonstrated in the first half of the synopsis. But it also features a
wholly different interface: It can modify the Math::Symbolic parser so
that you can use the distributions right inside strings that will be
parsed as Math::Symbolic trees. This is demonstrated for very simple cases
in the second half of the synopsis.
All arguments in both interface styles are optional. Whichever expression
is used instead of, for examle 'mean', is plugged into the formula for the
distribution as a Math::Symbolic tree. Details on argument handling are
explained below.
Please see the section on Export for details on how to choose the
interface style you want to use.
A perl extension module for scientific data access via the netCDF API
This class is a subclass of Number::WithError. It provides the same
interface and the same exports.
It adds several methods to every object. The main functionality is
provided by latex(), which dumps the object as valid LaTeX code. Also,
encode() is a convenient way to encode any UTF-8 string into TeX. It is
just a convenience thing since it is delegated to TeX::Encode.
Unlike Number::WithError, this module requires perl version 5.8 or later.
(That is the rationale for creating a separate distribution, too.)
`Oleo' has more than one user interface. The traditional `oleo'
environment shows a curses based (character mode) user interface.
A bare bones user interface based on the X Window System exists as of
version 1.6 which dates back to 1994. In 1998, development started for
a `motif' based user interface. It should be more user friendly than
the character based UI.