## Example — A Polynomial Class

### Polynom Data Structure

This example implements a MATLAB data type for polynomials by defining a new class called polynom. The polynom class represents a polynomial with a row vector containing the coefficients of powers of the variable, in decreasing order. Therefore, a polynom object p is a structure with a single field, p.c, containing the coefficients. This field is accessible only within the methods in the @polynom directory.

### Polynom Methods

To create a class that is well behaved within the MATLAB environment and provides useful functionality for a polynomial data type, the polynom class implements the following methods:

• A constructor method polynom.m

• A polynom to double converter

• A polynom to char converter

• A display method

• A subsref method

• Overloaded +, -, and * operators

• Overloaded roots, polyval, plot, and diff functions

### The Polynom Constructor Method

Here is the polynom class constructor, @polynom/polynom.m.

```function p = polynom(a)
%POLYNOM Polynomial class constructor.
%   p = POLYNOM(v) creates a polynomial object from vector v,
%   containing the coefficients of descending powers of x.
if nargin == 0
p.c = [];
p = class(p,'polynom');
elseif isa(a,'polynom')
p = a;
else
p.c = a(:).';
p = class(p,'polynom');
end```

#### Constructor Calling Syntax

You can call the polynom constructor method with one of three different arguments:

• No input argument — If you call the constructor function with no arguments, it returns a polynom object with empty fields.

• Input argument is an object — If you call the constructor function with an input argument that is already a polynom object, MATLAB returns the input argument. The isa function (pronounced "is a") checks for this situation.

• Input argument is a coefficient vector — If the input argument is a variable that is not a polynom object, reshape it to be a row vector and assign it to the .c field of the object's structure. The class function creates the polynom object, which is then returned by the constructor.

An example use of the polynom constructor is the statement

`p = polynom([1 0 -2 -5])`

This creates a polynomial with the specified coefficients.

### Converter Methods for the Polynom Class

A converter method converts an object of one class to an object of another class. Two of the most important converter methods contained in MATLAB classes are double and char. Conversion to double produces the MATLAB traditional matrix, although this may not be appropriate for some classes. Conversion to char is useful for producing printed output.

#### The Polynom to Double Converter

The double converter method for the polynom class is a very simple M-file, @polynom/double.m, which merely retrieves the coefficient vector.

```function c = double(p)
% POLYNOM/DOUBLE  Convert polynom object to coefficient vector.
%   c = DOUBLE(p) converts a polynomial object to the vector c
%   containing the coefficients of descending powers of x.
c = p.c;```

On the object p,

`p = polynom([1 0 -2 -5])`

the statement

`double(p)`

returns

```	ans =
1	0	-2	-5```

Having implemented the double method, you can use it to call MATLAB functions on polynom objects that require double values as inputs. For example,

```size(double(p))
ans =
1		4
```

#### The Polynom to Char Converter

The converter to char is a key method because it produces a character string involving the powers of an independent variable, x. Therefore, once you have specified x, the string returned is a syntactically correct MATLAB expression, which you can then evaluate.

Here is @polynom/char.m.

```function s = char(p)
% POLYNOM/CHAR
% CHAR(p) is the string representation of p.c
if all(p.c == 0)
s = '0';
else
d = length(p.c) - 1;
s = [];
for a = p.c;
if a ~= 0;
if ~isempty(s)
if a > 0
s = [s ' + '];
else
s = [s ' - '];
a = -a;
end
end
if a ~= 1 | d == 0
s = [s num2str(a)];
if d > 0
s = [s '*'];
end
end
if d >= 2
s = [s 'x^' int2str(d)];
elseif d == 1
s = [s 'x'];
end
end
d = d - 1;
end
end```

#### Evaluating the Output

If you create the polynom object p

`p = polynom([1 0 -2 -5]);`

and then call the char method on p

`char(p)`

MATLAB produces the result

```ans =
x^3 - 2*x - 5```

The value returned by char is a string that you can pass to eval once you have defined a scalar value for x. For example,

```x = 3;

eval(char(p))
ans =
16```

See The Polynom subsref Method for a better method to evaluate the polynomial.

### The Polynom display Method

Here is @polynom/display.m. This method relies on the char method to produce a string representation of the polynomial, which is then displayed on the screen. This method produces output that is the same as standard MATLAB output. That is, the variable name is displayed followed by an equal sign, then a blank line, then a new line with the value.

```function display(p)
% POLYNOM/DISPLAY Command window display of a polynom
disp(' ');
disp([inputname(1),' = '])
disp(' ');
disp(['   ' char(p)])
disp(' ');```

The statement

`p = polynom([1 0 -2 -5])`

creates a polynom object. Since the statement is not terminated with a semicolon, the resulting output is

```p =
x^3 - 2*x - 5```

### The Polynom subsref Method

Suppose the design of the polynom class specifies that a subscripted reference to a polynom object causes the polynomial to be evaluated with the value of the independent variable equal to the subscript. That is, for a polynom object p,

`p = polynom([1 0 -2 -5]);`

the following subscripted expression returns the value of the polynomial at x = 3 and x = 4.

```p([3 4])
ans =
16   51```

#### subsref Implementation Details

This implementation takes advantage of the char method already defined in the polynom class to produce an expression that can then be evaluated.

```function b = subsref(a,s)
% SUBSREF
switch s.type
case '()'
ind = s.subs{:};
for k = 1:length(ind)
b(k) = eval(strrep(char(a), 'x', ...
['(' num2str(ind(k)) ')']));
end
otherwise
error('Specify value for x as p(x)')
end```

Once the polynomial expression has been generated by the char method, the strrep function is used to swap the passed in value for the character x. The eval function then evaluates the expression and returns the value in the output argument.

Note that if you perform an indexed reference from within other class methods, MATLAB calls the built-in subsref or subsassign. See Behavior Within Class Methods for more information.

Several arithmetic operations are meaningful on polynomials and should be implemented for the polynom class. When overloading arithmetic operators, keep in mind what data types you want to operate on. In this section, the plus, minus, and mtimes methods are defined for the polynom class to handle addition, subtraction, and multiplication on polynom/polynom and polynom/double combinations of operands.

If either p or q is a polynom, the expression

`p + q`

generates a call to a function @polynom/plus.m, if it exists (unless p or q is an object of a higher precedence, as described in Object Precedence).

The following M-file redefines the + operator for the polynom class.

```function r = plus(p,q)
% POLYNOM/PLUS  Implement p + q for polynoms.
p = polynom(p);
q = polynom(q);
k = length(q.c) - length(p.c);
r = polynom([zeros(1,k) p.c] + [zeros(1,-k) q.c]);```

The function first makes sure that both input arguments are polynomials. This ensures that expressions such as

`p + 1`

that involve both a polynom and a double, work correctly. The function then accesses the two coefficient vectors and, if necessary, pads one of them with zeros to make them the same length. The actual addition is simply the vector sum of the two coefficient vectors. Finally, the function calls the polynom constructor a third time to create the properly typed result.

You can implement the overloaded minus operator (-) using the same approach as the plus (+) operator. MATLAB calls @polynom/minus.m to compute p-q.

```function r = minus(p,q)
% POLYNOM/MINUS Implement p - q for polynoms.
p = polynom(p);
q = polynom(q);
k = length(q.c) - length(p.c);
r = polynom([zeros(1,k) p.c] - [zeros(1,-k) q.c]);```

MATLAB calls the method @polynom/mtimes.m to compute the product p*q. The letter m at the beginning of the function name comes from the fact that it is overloading the MATLAB matrix multiplication. Multiplication of two polynomials is simply the convolution of their coefficient vectors.

```function r = mtimes(p,q)
% POLYNOM/MTIMES   Implement p * q for polynoms.
p = polynom(p);
q = polynom(q);
r = polynom(conv(p.c,q.c));```

#### Using the Overloaded Operators

Given the polynom object

`p = polynom([1 0 -2 -5])`

MATLAB calls these two functions @polynom/plus.m and @polynom/mtimes.m when you issue the statements

```q = p+1
r = p*q```

to produce

```q =
x^3 - 2*x - 4

r =
x^6 - 4*x^4 - 9*x^3 + 4*x^2 + 18*x + 20```

### Overloading Functions for the Polynom Class

MATLAB already has several functions for working with polynomials represented by coefficient vectors. They should be overloaded to also work with the new polynom object. In many cases, the overloading methods can simply apply the original function to the coefficient field.

#### Overloading roots for the Polynom Class

The method @polynom/roots.m finds the roots of polynom objects.

```function r = roots(p)
% POLYNOM/ROOTS.  ROOTS(p) is a vector containing the roots of p.
r = roots(p.c);```

The statement

`roots(p)`

results in

```ans =
2.0946
-1.0473 + 1.1359i
-1.0473 - 1.1359i```

#### Overloading polyval for the Polynom Class

The function polyval evaluates a polynomial at a given set of points. @polynom/polyval.m uses nested multiplication, or Horner's method to reduce the number of multiplication operations used to compute the various powers of x.

```function y = polyval(p,x)
% POLYNOM/POLYVAL  POLYVAL(p,x) evaluates p at the points x.
y = 0;
for a = p.c
y = y.*x + a;
end```

#### Overloading plot for the Polynom Class

The overloaded plot function uses both root and polyval. The function selects the domain of the independent variable to be slightly larger than an interval containing the roots of the polynomial. Then polyval is used to evaluate the polynomial at a few hundred points in the domain.

```function plot(p)
% POLYNOM/PLOT  PLOT(p) plots the polynom p.
r = max(abs(roots(p)));
x = (-1.1:0.01:1.1)*r;
y = polyval(p,x);
plot(x,y);
title(char(p))
grid on```

#### Overloading diff for the Polynom Class

The method @polynom/diff.m differentiates a polynomial by reducing the degree by 1 and multiplying each coefficient by its original degree.

```function q = diff(p)
% POLYNOM/DIFF  DIFF(p) is the derivative of the polynom p.
c = p.c;
d = length(c) - 1;  % degree
q = polynom(p.c(1:d).*(d:-1:1));```

### Listing Class Methods

The function call

`methods('classname')`

or its command form

`methods classname`

shows all the methods available for a particular class. For the polynom example, the output is

```methods polynom
Methods for class polynom:```
 char display minus plot polynom roots diff double mtimes plus polyval subsref

Plotting the two polynom objects x and p calls most of these methods.

```x = polynom([1 0]);
p = polynom([1 0 -2 -5]);
plot(diff(p*p + 10*p + 20*x) - 20)```