Code Index:

package Math::Polynom
- _debug
- _add_monom
- _clean
- _is_root
- _error
- _exception
- new
- clone
- stringify
- derivate
- eval
- add
- minus
- negate
- multiply
- divide
- newton_raphson
- secant
- brent
__END__
EOF

NAME

Math::Polynom - Operations on polynomials

SYNOPSIS

    use Math::Polynom;

To create the polynomial 'x^3 + 4*x^2 + 1', write:

    my $p1 = Math::Polynom->new(3 => 1, 2 => 4, 0 => 1);

To create '3.5*x^4.2 + 1.78*x^0.9':

    my $p2 = Math::Polynom->new(4.2 => 3.5, 0.9 => 1.78);

Common operations:

    my $p3 = $p1->multiply($p2); # multiply 2 polynomials
    my $p3 = $p1->multiply(4.5); # multiply a polynomial with a constant

    my $p3 = $p1->add($p2);      # add 2 polynomials
    my $p3 = $p1->add(3.6);      # add a constant to a polynomial

    my $p3 = $p1->minus($p2);    # substract 2 polynomials
    my $p3 = $p1->minus(1.5);    # substract a constant to a polynomial

    my $p3 = $p1->negate();      # negate a polynomial

    my $p3 = $p1->divide(3.2);   # divide a polynomial by a constant

    my $v = $p1->eval(1.35);     # evaluate the polynomial on a given value

    my $p3 = $p1->derivate();    # return the derivate of a polynomial

    print $p1->stringify."\n";   # stringify polynomial

To try to find a root to a polynomial using the Newton Raphson method:

    my $r;
    eval { $r = $p1->newton_raphson(guess => 2, precision => 0.001); };
    if ($@) {
	if ($p1->error) {
	    # that's an internal error
	    if ($p1->error == Math::Polynom::ERROR_NAN) {
		# bumped on a complex number
	    }
	} else {
	    # either invalid arguments (or a bug in solve())
	}
    }

Same with the secant method:

    eval { $r = $p1->secant(p0 => 0, p2 => 2, precision => 0.001); };

DESCRIPTION

What! Yet another module to manipulate polynomials!! No, don't worry, there is a good reason for this one ;)

I needed (for my work at a large financial institution) a robust way to compute the internal rate of return (IRR) of various cashflows. An IRR is typically obtained by solving a usually ugly looking polynomial of one variable with up to hundreds of coefficients and non integer powers (ex: powers with decimals). I also needed thorough exception handling. Other CPAN modules providing operations on polynomials did not fill those requirements.

If what you need is to manipulate simple polynomials with integer powers, without concern for failures, check out Math::Polynomial since it provides a more complete api than Math::Polynom.

An instance of Math::Polynom is a representation of a 1-variable polynomial. It supports a few basic operations specific to polynomials such as addition, substraction and multiplication.

Math::Polynom also implements various root finding algorithms (which is kind of the main purpose of this module) such as the Newton Raphson, Secant and Brent methods.

API

$p1 = new(%power_coef)

Create a new Math::Polynom. Each key in the hash %power_coef is a power and each value the corresponding coefficient.

$p3 = $p1->clone()

Return a clone of the current polynomial.

$p3 = $p1->add($p2)

Return a new polynomial that is the sum of the current polynomial with the polynomial $p2. If $p2 is a scalar, we add it to the current polynomial as a numeric constant.