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.
p5-Math-Polygon is a perl class provides an OO interface around
Math::Polygon::Calc and Math::Polygon::Clip.
The rpn function will take a scalar or list of sclars which
contain an RPN expression as a set of comma delimited values and
operators, and return the result or stack, depending on context.
Math::Random is a Perl port of the C version of randlib, which is a
suite of routines for generating random deviates.
Math::Round supplies functions that will round numbers in different ways. The
functions round and nearest are exported by default; others are available as
described below. "use ... qw(:all)" exports all functions.
Math::Sequence defines a class for simple mathematic sequences with a
recursive definition such as x_(n+1) = 1 / (x_n + 1). Creation of a
Math::Sequence object is described below in the paragraph about the
constructor.
Math::Sequence uses Math::Symbolic to parse and modify the recursive
sequence definitions. That means you specify the sequence as a string
which is parsed by Math::Symbolic. Alternatively, you can pass the
constructor a Math::Symbolic tree directly.
Because Math::Sequence uses Math::Symbolic for its implementation, all
results will be Math::Symbolic objects which may contain other variables
than the sequence variable itself.
Each Math::Sequence object is an iterator to iterate over the elements of
the sequence starting at the first element (which was specified by the
starting element, the second argument to the new() constructor). It offers
facilities to cache all calculated elements and access any element
directly, though unless the element has been cached in a previous
calculation, this is just a shortcut for repeated use of the iterator.
Math::Series defines a class for simple mathematic series with a recursive
definition such as x_(n+1) = 1 / (x_n + 1). Such a recursive definition is
treated as a sequence whose elements will be added to form a series. You
can refer to the previous sequence element as well as to the current index
in the series. Creation of a Math::Series object is described below in the
paragraph about the constructor.
Math::Series uses Math::Symbolic to parse and modify the recursive
sequence definitions. That means you specify the sequence as a string
which is parsed by Math::Symbolic. Alternatively, you can pass the
constructor a Math::Symbolic tree directly.
Because Math::Series uses Math::Symbolic for its implementation, all
results will be Math::Symbolic objects which may contain other variables
than the sequence variable and the iterator variable.
Each Math::Series object is an iterator to iterate over the elements of
the series starting at the first element (which was specified by the
starting element, the second argument to the new() constructor). It offers
facilities to cache all calculated elements and access any element
directly, though unless the element has been cached in a previous
calculation, this is just a shortcut for repeated use of the iterator.
This package provides cubic spline interpolation of numeric data. The
data is passed as references to two arrays containing the x and y
ordinates. It may be used as an exporter of the numerical functions or,
more easily as a class module.
The Math::TrulyRandom module provides an ability to generate truly random
numbers from within Perl programs. The source of the randomness is from
interrupt timing discrepancies.
This module was adapted from Math::Vector.
It uses most of the same algorithms, and currently preserves the same
names as the original functions, though some aliases have been added
to make the interface more natural.
The "object" for the object oriented calling style is a blessed array
reference which contains a vector of the form [x,y,z]. Methods will
typically return a list.