Date::Handler is a container for dates that holds all the methods
to transform itself from Timezone to Timezone and format itself.
It uses operator overloading and Delta date objects to calculates
time differences.
This package supplies a set of functions and operators to manipulate
operator expressions algebraically using the familiar Perl syntax.
These expressions are constructed from "Symbols", "Operators", and
"Functions", and processed via "Methods". For examples, see: "Examples".
Math::BigInt - Arbitrary size integer math package for perl.
This is a complete rewrite of Math::BigInt, Math::BigFloat and friends,
which are included with the standard system perl.
Math::GMPf is a bigfloat module utilising the GNU MP (GMP) library. Basically
this module simply wraps all of the mpf floating point functions provided by
that library. See the Math::GMPf test suite for some examples of usage.
Math::GMPz is a bignum module utilising the GNU MP (GMP) library. Basically this
module simply wraps all of the mpz integer functions provided by that library.
See the Math::GMPz test suite for some examples of usage.
This module is just a wrapper around the gpc C library written by Alan
Murta
gpc: General Polygon Clipping library (C) 1997-1999, Advanced Interfaces
Group, University of Manchester.
Please refer to the gpc manual for more details on gpc.
This package is a Perl interface to famous library PARI for
numerical/scientific/number-theoretic calculations. It allows use of most
PARI functions as Perl functions, and (almost) seamless merging of PARI
and Perl data.
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 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.
This class is a container class for numbers with a number of associated
symmetric and asymmetric errors. It overloads practically all common
arithmetic operations and trigonometric functions to propagate the errors.
It can do proper scientific rounding (as explained in more detail below in
the documentation of the significant_digit() method).
You can use Math::BigFloat objects as the internal representation of
numbers in order to support arbitrary precision calculations.
Errors are propagated using Gaussian error propagation.
With a notable exception, the test suite covers way over ninety percent of
the code. The remaining holes are mostly difficult-to-test corner cases
and sanity tests. The comparison routines are the exception for which
there will be more extensive tests in a future release.