Ports Search

This module defines an abstract interface for random number generation. Subclasses of this model will implement specific types of random number generators or will wrap existing random number generators.

Cryptographically-secure, cross-platform replacement for rand()

This module gives you the ability to round numbers to either decimal or fractional precision while encapsulating the rounding precision in an object. This allows scripts and modules to maintain multiple precision values as objects. It also implements flexible scheme parsing, so that your programs and modules can offload the how-to-round decisions to this module.

This module extends the functionality of Math::Symbolic by offering facilities to compile symbolic math trees (formulas) to C code. It also uses Inline::C to compile and link the generated C code at run-time, thus allowing the user to do symbolic calculations in Perl with Math::Symbolic and then use the results in a fast numeric environment. This software generates code. Code generators are difficult to test, but the first release of the module is now 1.5 years old and I haven't received any bug reports, so I consider it somewhat stable now. Please read the manpage of Math::Symbolic::Compiler which comes with the Math::Symbolic distribution. Most of the gotchas involved with compiling the functions to Perl subroutines also apply to this module which compiles to C instead. Alternatively, you can use the module not for faster calculations from your Perl program, but to generate C code for you. I have used it to generate an implementation for (many!) Zernike Polynomials for work in C.

This module extends the functionality of Math::Symbolic by offering facilities to test a Math::Symbolic tree for existance of a specific subtree in the Math::Symbolic tree.

This module extends the functionality of Math::Symbolic by offering facilities to calculate the propagated variance of a function of variables with variances themselves.

This class provides the to_latex() method for all Math::Symbolic trees. It is a rewrite of the to_latex() method that was supplied by Math::Symbolic prior to version 0.201. For details on how the custom method delegation model works, please have a look at the Math::Symbolic::Custom and Math::Symbolic::Custom::Base classes.

This module is an extension to the Math::Symbolic module. A basic familiarity with that module is required. The Math::Symbolic::Custom::Pattern module implements pattern matching routines on Math::Symbolic trees. The patterns itself are constructed from Math::Symbolic trees with just a few variables which have a special meaning. The module provides two interfaces. You can use the new() and match() methods this class provides, or you can use the to_pattern() and is_of_form() methods on any Math::Symbolic tree. (Exported by the Math::Symbolic::Custom::Pattern::Export module. Refer to that module for details on is_of_form().)

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.

Math::Symbolic::Custom::Transformation is an extension to the Math::Symbolic module. You're assumed to be remotely familiar with that module throughout the documentation. This package implements transformations of Math::Symbolic trees using Math::Symbolic trees. I'll try to explain what this means in the following paragraphs. Until now, in order to be able to inspect a Math::Symbolic tree, one had to use the low-level Math::Symbolic interface like comparing the top node's term type with a constant (such as T_OPERATOR) and then its operator type with more constants. This has changed with the release of Math::Symbolic::Custom::Pattern. To modify the tree, you had to use equally low-level or even encapsulation-breaking methods. This is meant to be changed by this distribution.