**13.4****
****Polynomials** (.NET, C#, CSharp, VB, Visual Basic, F#)

Class **Polynomial** extends **OneVariableFunction** (Section 13.1).
Rather than encapsulating an arbitrary function delegate, **Polynomial** represents a polynomial by
its coefficients, arranged in ascending order—that is, a vector
such that:

Thus, the polynomial is represented as a **DoubleVector**
of length 5 with elements "3
1 -2 0 5".

A **Polynomial**
instance can be constructed in two ways. If you know the exact form of
the polynomial, simply pass in the vector of coefficients:

Code Example – C# polynomials

var coef = new DoubleVector( "1 0 2"); // 2x^2 + 1

var p = new Polynomial( coef );

Code Example – VB polynomials

Dim Coef As New DoubleVector("1 0 2") ' 2x^2 + 1

Dim P As New Polynomial(Coef)

Alternatively, you can interpolate a polynomial through
a set of points. If the number of points is *n*,
then the constructed polynomial will have degree *n*
- 1 and pass through the interpolation points. For example, this code
interpolates the polynomial
through the points (1,6), (2,11),
and (3,20):

Code Example – C# polynomials

var x = new DoubleVector( "1 2 3");

var y = new DoubleVector( "6 11 20" );

var p = new Polynomial( x, y );

Code Example – VB polynomials

Dim X As New DoubleVector("1 2 3")

Dim Y As New DoubleVector("6 11 20")

Dim P As New Polynomial(X, Y)

You can also construct a **Polynomial**
instance from a vector of *x*-values
and a **OneVariableFunction** evaluated
at each *x*:

Code Example – C# polynomials

var f = new Func<double, double>( myFunction );

var x = new DoubleVector( 10, 1, 1 );

var p = new Polynomial( x, f );

Code Example – VB polynomials

Dim F As New Func(Of Double, Double)(AddressOf myFunction)

Dim X As New DoubleVector(10, 1, 1)

Dim P As New Polynomial(X, F)

Class **Polynomial**
inherits Function, Integrator,
and Differentiator properties from **OneVariableFunction** (Section 13.1).
Additionally, **Polynomial** provides
these properties:

● Coeff gets and sets the vector of coefficients.

● Degree gets the degree of the polynomial.

The degree is the order of the highest non-zero coefficient. Therefore, the degree may be less than the length of the underlying coefficient vector, as returned for example by Coeff.Length. The Reduce() method is provided for removing trailing zeros from the coefficient vector.

Class **Polynomial**
inherits the Evaluate() method from **OneVariableFunction**. This method evaluates
a polynomial at a given *x*-value, or
vector of *x*

Code Example – C# polynomials

var coeff = new DoubleVector( "6 -1 5 0 3 -2" );

var p = new Polynomial( coeff );

double y = p.Evaluate( 1.25 );

Code Example – VB polynomials

Dim Coeff As New DoubleVector("6 -1 5 0 3 -2")

Dim P As New Polynomial(Coeff)

Dim Y As Double = P.Evaluate(1.25)

**Algebraic Manipulation of Polynomials**

Because a **Polynomial**
*is-a* **OneVariableFunction**,
all of the overloaded arithmetic operators and equivalent named methods
described in Section 13.1
accept polynomials. For example, this code adds a **Polymomial**
to a **OneVariableFunction** to create
a new **OneVariableFunction**:

Code Example – C# polynomials

var coeff = new DoubleVector( "1 4 -1 1 2 -3" );

var p = new Polynomial( coeff );

var d = new Func<double, double>( MyFunction );

var f = new OneVariableFunction( d );

OneVariableFunction g = p + f;

Code Example – VB polynomials

Dim Coeff As New DoubleVector("1 4 -1 1 2 -3")

Dim P As New Polynomial(Coeff)

Dim D As New Func(Of Double, Double)(AddressOf MyFunction)

Dim F As New OneVariableFunction(D)

Dim G As Func(Of Double, Double) = P + F

Additionally, class **Polynomial**
provides overloads of the arithmetic operators and named methods. These
operators and methods work either with two polynomials, or with a polynomial
and a scalar. They operate directly on the underlying vector(s) of coefficients,
and therefore return instances of **Polynomial**.
For example:

Code Example – C# polynomials

var coeff = new DoubleVector( "-11 3 1 1 0 -1 2" );

var p = new Polynomial( coeff );

Polynomial p2 = p/2;

Polynomial p3 = p + p2;

Code Example – VB polynomials

Dim Coeff As New DoubleVector("-11 3 1 1 0 -1 2")

Dim P As New Polynomial(Coeff)

Dim P2 As Polynomial = P / 2.0

Dim P3 As Polynomial = P + P2

**NOTE—****You
can divide one Polynomial by another, but the result is a OneVariableFunction
rather than a Polynomial, since the quotient is a rational function,
and not necessarily a polynomial.**

Class **Polynomial**
inherits the Integrate() method from **OneVariableFunction** (Section 13.2),
which computes the integral of the current function over a given interval.
**Polynomial** also extends the interface
to include an AntiDerivative() method that
returns a new polynomial encapsulating the antiderivative (indefinite
integral) of the current polynomial. For example:

Code Example – C# polynomials

var p = new Polynomial( new DoubleVector( "5 3 0 2" ) );

double integral = p.Integrate( -1, 1 );

Polynomial i = p.AntiDerivative();

Code Example – VB polynomials

Dim P As New Polynomial(New DoubleVector("5 3 0 2"))

Dim Integral As Double = P.Integrate(-1, 1)

Dim I As Polynomial = P.AntiDerivative()

In constructing the antiderivative, the constant of integration is assumed to be zero.

Each **Polynomial**
object has a **PolynomialIntegrator**
associated with it, which implements the **IIntegrator**
interface. Because the antiderivative of a polynomial can be easily constructed,
**PolynomialIntegrator** simply constructs
the antiderivative and evaluates it at the lower and upper bounds. This
gives the exact integral.

**NOTE—****You
can, of course, set the IIntegrator associated with a Polynomial to a
non-default value, such as a Romberg numerical integrator. But since
this would only compute an approximation of the integral, there
would be little point.**

Class **Polynomial**
inherits both Differentiate() and Derivative() methods from **OneVariableFunction**
(Section 13.3).
Differentiate() returns the derivative of
the current function at a given *x*-value.
Derivative() is overridden to return a new
polynomial that is the first derivative of the current polynomial. Thus:

Code Example – C# polynomials

var coeff = new DoubleVector( "1 -2 3" );

var p = new Polynomial( coeff );

Polynomial der = p.Derivative(); // der.Coeff = "-2 6"

Code Example – VB polynomials

Dim Coeff As New DoubleVector("1 -2 3")

Dim P As New Polynomial(Doeff)

Dim Der As Polynomial = P.Derivative() ' Der.Coeff = "-2 6"

Each **Polynomial**
object has a **PolynomialDifferentiator**
associated with it, which implements the **IDifferentiator**
interface. Because the derivative of a polynomial can be easily constructed,
**PolynomialDifferentiator** simply
constructs the first derivative and evaluates it at the given *x*-value. This gives the exact derivative.

**NOTE—****You
can, of course, set the Differentiator associated with a polynomial to
a non-default value, such as a Ridders numerical differentiator. But
again, as this would only compute an approximation of the derivative,
there would be little point.**