Ports 搜索

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)

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.

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.

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.

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>

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.

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'.

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.

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.