Results 81–90 of 792 for /math/.(0.002 seconds)
OO wrapper to gpc library (translated to XS)
OO wrapper to gpc library (translated from Inline-based
Math::Geometry::Planar::GPC::Polygon to XS)
Scaling math used in image size constraining (such as thumbnails)
Scaling math used in image size constraining (such as thumbnails)
Class for fast check if point is inside polygon
Math::Polygon::Tree creates a B-tree of polygon parts for fast check
if object is inside this polygon. This method is effective if polygon
has hundreds or more segments.
User defined simplification routines
This module is an extension to the Math::Symbolic module. A basic
familiarity with that module is required.
Math::Symbolic offers some builtin simplification routines. These,
however, are not capable of complex simplifications. This extension offers
facilities to override the default simplification routines through means
of subclassing this module. A subclass of this module is required to
define a simplify object method that implements a simplification of
Math::Symbolic trees.
There are two class methods to inherit: register and unregister. Calling
the register method on your subclass registers your class as providing the
simplify method that is invoked whenever simplify() is called on a
Math::Symbolic::Operator object.
Calling unregister on your subclass restores whichever simplification
routines where in place before.
Statistical distributions
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.
Human-readable unit-aware calculator
Math::Calc::Units is a simple calculator that keeps track
of units. It currently handles combinations of byte sizes
and duration only, although adding any other
multiplicative types is easy. Any unknown type is treated
as a unique user type (with some effort to map English
plurals to their singular forms).
Seamus Venasse <svenasse@polaris.ca>
Script to turn intuitively written math into latex
This program is an easy way to typeset mathematics. You can try it
out at
http://cauchy.math.missouri.edu/~stephen/cgi-bin/naturalmath.cgi
Actually what it does is to convert text written in the Natural Math
language into latex.
Implements an algorithm to find good values for chart axis
Chart::Math::Axis implements in a generic way an algorithm for finding a
set of ideal values for an axis. That is, for any given set of data,
what should the top and bottom of the axis scale be, and what should the
interval between the ticks be.
The terms top and bottom are used throughout this module, as it's
primary use is for determining the Y axis. For calculating the X axis,
you should think of 'top' as 'right', and 'bottom' as 'left'.
C implementation of the ISAAC PRNG Algorithm
As with other Pseudo-Random Number Generator (PRNG) algorithms like the
Mersenne Twister (see Math::Random::MT), this algorithm is designed to
take some seed information and produce seemingly random results as output.
However, ISAAC (Indirection, Shift, Accumulate, Add, and Count) has
different goals than these commonly used algorithms. In particular, it's
really fast - on average, it requires only 18.75 machine cycles to generate
a 32-bit value. This makes it suitable for applications where a significant
amount of random data needs to be produced quickly, such solving using the
Monte Carlo method or for games.
Perl interface to the ISAAC PRNG Algorithm
As with other Pseudo-Random Number Generator (PRNG) algorithms like the
Mersenne Twister (see Math::Random::MT), this algorithm is designed to
take some seed information and produce seemingly random results as output.
However, ISAAC (Indirection, Shift, Accumulate, Add, and Count) has
different goals than these commonly used algorithms. In particular, it's
really fast - on average, it requires only 18.75 machine cycles to generate
a 32-bit value. This makes it suitable for applications where a significant
amount of random data needs to be produced quickly, such solving using the
Monte Carlo method or for games.