Class for Polynomials

Designing a Polynomial Object

This example implements a class to represent polynomials in the MATLAB® language. The design requirements are:

  • Value class behavior—a polynomial object should behave like MATLAB numeric variables when copied and passed to functions.

  • Specialized display and indexing

  • Arithmetic operations

  • Double converter simplifying the use of polynomial object with existing MATLAB functions that accept numeric inputs.

Displaying the Class Files

Open the DocPolynom class definition file in the MATLAB editor.Open the DocPolynom class definition file in the MATLAB editor.

To use the class, create a folder named @DocPolynom and save DocPolynom.m to this folder. The parent folder of @DocPolynom must be on the MATLAB path.

Summary of the DocPolynom Class

The class definition specifies a property for data storage and defines a folder (@DocPolynom) that contains the class definition.

The following table summarizes the properties defined for the DocPolynom class.

DocPolynom Class Properties

Name

Class

Default

Description

coef

double

[]

Vector of polynomial coefficients [highest order ... lowest order]

The following table summarizes the methods for the DocPolynom class.

DocPolynom Class Methods

Name

Description

DocPolynom

Class constructor

double

Converts a DocPolynom object to a double (i.e., returns its coefficients in a vector)

char

Creates a formatted display of the DocPolynom object as powers of x and is used by the disp method

disp

Determines how MATLAB displays a DocPolynom objects on the command line

subsref

Enables you to specify a value for the independent variable as a subscript, access the coef property with dot notation, and call methods with dot notation.

plus

Implements addition of DocPolynom objects

minus

Implements subtraction of DocPolynom objects

mtimes

Implements multiplication of DocPolynom objects

Using the DocPolynom Class

The following examples illustrate basic use of the DocPolynom class.

Create DocPolynom objects to represent the following polynomials. Note that the argument to the constructor function contains the polynomial coefficients and .

p1 = DocPolynom([1 0 -2 -5])
p1 =
   x^3 - 2*x - 5
p2 = DocPolynom([2 0 3 2 -7])
p2 =
   2*x^4 + 3*x^2 + 2*x - 7

Find the roots of the polynomial by passing the coefficients to the roots function.

roots(p1.coef)

ans =

   2.0946          
  -1.0473 + 1.1359i
  -1.0473 - 1.1359i

Add the two polynomials p1 and p2.

MATLAB calls the plus method defined for the DocPolynom class when you add two DocPolynom objects.

p1 + p2
ans =
   2*x^4 + x^3 + 3*x^2 - 12

The DocPolynom Constructor Method

The following function is the DocPolynom class constructor, which is in the file @DocPolynom/DocPolynom.m:

function obj = DocPolynom(c)
   % Construct a DocPolynom object using the coefficients supplied
   if isa(c,'DocPolynom')
      obj.coef = c.coef;
   else
      obj.coef = c(:).';
   end
end 

Constructor Calling Syntax

It is possible to all the DocPolynom constructor with two different arguments:

  • Input argument is a DocPolynom object — If you call the constructor function with an input argument that is already a DocPolynom object, the constructor returns a new DocPolynom object with the same coefficients as the input argument. The isa function checks for this input.

  • Input argument is a coefficient vector — If the input argument is not a DocPolynom object, the constructor attempts to reshape the values into a vector and assign them to the coef property.

    The coef property set method restricts property values to doubles. See Removing Irrelevant Coefficients for a description of the property set method.

An example use of the DocPolynom constructor is the statement:

p = DocPolynom([1 0 -2 -5])
p = 
   x^3 - 2*x -5

This statement creates an instance of the DocPolynom class with the specified coefficients. Note the display of the object shows the equivalent polynomial using MATLAB language syntax. The DocPolynom class implements this display using the disp and char class methods.

Removing Irrelevant Coefficients

MATLAB software represents polynomials as row vectors containing coefficients ordered by descending powers. Zeros in the coefficient vector represent terms that drop out of the polynomial. Leading zeros, therefore, can be ignored when forming the polynomial.

Some DocPolynom class methods use the length of the coefficient vector to determine the degree of the polynomial. It is useful, therefore, to remove leading zeros from the coefficient vector so that its length represents the true value.

The DocPolynom class stores the coefficient vector in a property that uses a set method to remove leading zeros from the specified coefficients before setting the property value.

function obj = set.coef(obj,val)
   % coef set method
   if ~isa(val,'double')
      error('Coefficients must be of class double')
   end 
   ind = find(val(:).'~=0);
   if ~isempty(ind);
      obj.coef = val(ind(1):end);
   else
      obj.coef = val;
   end
end

Converting DocPolynom Objects to Other Types

The DocPolynom class defines two methods to convert DocPolynom objects to other classes:

  • double — Converts to the double numeric type so functions can perform mathematical operations on the coefficients.

  • char — Converts to string used to format output for display in the command window

The DocPolynom to Double Converter

The double converter method for the DocPolynom class simply returns the coefficient vector:

function c = double(obj)
   % DocPolynom/Double Converter
   c = obj.coef;
end 

For the DocPolynom object p:

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

the statement:

c = double(p)

returns:

c=
    1     0    -2    -5

which is of class double:

class(c)
ans = 
   double

The DocPolynom to Character Converter

The char method produces a character string that represents the polynomial displayed as powers of an independent variable, x. Therefore, after you have specified a value for x, the string returned is a syntactically correct MATLAB expression, which you can evaluate.

The char method uses a cell array to collect the string components that make up the displayed polynomial.

The disp method uses char to format the DocPolynom object for display. Class users are not likely to call the char or disp methods directly, but these methods enable the DocPolynom class to behave like other data classes in MATLAB.

Here is the char method.

function str = char(obj)
   % Created a formated display of the polynom
   % as powers of x
   if all(obj.coef == 0)
      s = '0';
      str = s;
      return
   else
      d = length(obj.coef)-1;
      s = cell(1,d);
      ind = 1;
      for a = obj.coef;
         if a ~= 0;
            if ind ~= 1
               if a > 0
                  s(ind) = {' + '};
                  ind = ind + 1;
               else
                  s(ind) = {' - '};
                  a = -a;
                 ind = ind + 1;
               end
            end
            if a ~= 1 || d == 0
               if a == -1
                  s(ind) = {'-'};
                  ind = ind + 1;
               else
                  s(ind) = {num2str(a)};
                  ind = ind + 1;
                  if d > 0
                    s(ind) = {'*'};
                    ind = ind + 1;
                  end
               end
            end
            if d >= 2
               s(ind) = {['x^' int2str(d)]};
               ind = ind + 1;
            elseif d == 1
               s(ind) = {'x'};
               ind = ind + 1;
            end
         end
         d = d - 1;
      end
   end
   str = [s{:}];
end

Evaluating the Output

If you create the DocPolynom object p:

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

and then call the char method on p:

char(p)

the result is:

ans =
    x^3 - 2*x - 5

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

x = 3;

eval(char(p))
ans = 
    16

The DocPolynom disp Method

To provide a more useful display of DocPolynom objects, this class overloads disp in the class definition.

This disp method relies on the char method to produce a string representation of the polynomial, which it then displays on the screen.

function disp(obj)
   % DISP Display object in MATLAB syntax
   c = char(obj); % char returns a cell array
   if iscell(c)
      disp(['     ' c{:}])
   else
      disp(c) % all coefficients are zero
   end
end 

When MATLAB Calls the disp Method

The statement:

p = DocPolynom([1 0 -2 -5])

creates a DocPolynom object. Because the statement is not terminated with a semicolon, the resulting output is displayed on the command line:

p =
    x^3 - 2*x - 5

The DocPolynom subsref Method

Normally, subscripted assignment is defined automatically by MATLAB. However, in this particular case, the design of the DocPolynom class specifies that a subscripted reference to a DocPolynom object causes an evaluation of the polynomial with the value of the independent variable equal to the subscript.

For example, given the following polynomial:

Create a DocPolynom object p:

p = DocPolynom([1 0 -2 -5])
p =
    x^3 - 2*x - 5

The following subscripted expression evaluates the value of the polynomial at x = 3 and x = 4 and returns the resulting values:

p([3 4])
ans =
    16   51

Defining the subsref Method

The DocPolynom class redefines the default subscripted reference behavior by implementing a subsref method.

If a class defines a subsref method, MATLAB software calls this method for objects of this class whenever a subscripted reference occurs. You must, therefore, define all the behaviors you want your class to exhibit in the local method.

The DocPolynom subsref method implements the following behaviors:

  • The ability to pass a value for the independent variable as a subscripted reference (i.e., p(3) evaluates the polynomial at x = 3)

  • Dot notation for accessing the coef property

  • Dot notation for access to class methods, which accept and return differing numbers of input and output arguments

subsref Implementation Details

See the subsref function for general information on implementing this method.

When you implement a subsref method to support calling methods with arguments using dot notation, both the type and subs structure fields contain multiple elements.

For example, consider a call to the polyval function:

p = DocPolynom([1 0 -2 -5])
p = 
     x^3 - 2*x - 5
polyval(p.coef,[3 5 7])
ans =
    16   110   324

The polyval function requires an input argument of values at which to evaluate the polynomial and returns the value of f(x) at these values. subsref performs the method call through the statements:

case '()'
   ind = s.subs{:};
   b = polyval(a.coef,ind);

The subsref method implements all subscripted reference explicitly, as show in the following code listing.

function b = subsref(a,s)
   switch s(1).type
      case '()'
         ind = s.subs{:};
         b = polyval(a.coef,ind);
      case '.'
         switch s(1).subs
            case 'coef'
               b = a.coef;
            case 'disp'
               disp(a)
            otherwise
               if length(s)>1
                  b = a.(s(1).subs)(s(2).subs{:});
               else
                  b = a.(s.subs);
               end
         end
      otherwise
         error('Specify value for x as obj(x)')
   end
end % subsref

Defining Arithmetic Operators for DocPolynom

Several arithmetic operations are meaningful on polynomials and are implemented for the DocPolynom class.

This section shows how to implement the following methods:

Method and Syntax

Operator Implemented

plus(a,b)

Addition

minus(a,b)

Subtraction

mtimes(a,b)

Matrix multiplication

When overloading arithmetic operators, keep in mind what data types you want to operate on. The plus, minus, and mtimes methods are defined for the DocPolynom class to handle addition, subtraction, and multiplication on DocPolynomDocPolynom and DocPolynomdouble combinations of operands.

Defining the + Operator

If either p or q is a DocPolynom object, the expression

p + q

generates a call to a function @DocPolynom/plus, unless the other object is of a class of higher precedence.

The following function redefines the plus (+) operator for the DocPolynom class:

function r = plus(obj1,obj2)
   % Plus Implement obj1 + obj2 for DocPolynom 
   obj1 = DocPolynom(obj1);
   obj2 = DocPolynom(obj2);
   k = length(obj2.coef) - length(obj1.coef);
   r = DocPolynom([zeros(1,k) obj1.coef]+[zeros(1,-k) obj2.coef]);
end 

Here is how the function works:

  • Ensure that both input arguments are DocPolynom objects so that expressions such as

    p + 1
    

    that involve both a DocPolynom and a double, work correctly.

  • Access the two coefficient vectors and, if necessary, pad one of them with zeros to make both the same length. The actual addition is simply the vector sum of the two coefficient vectors.

  • Call the DocPolynom constructor to create a properly typed result.

Defining the - Operator

You can implement the minus operator (-) using the same approach as the plus (+) operator.

The MATLAB runtime calls the DocPolynom minus method to compute p - q, where p, q, or both are DocPolynom objects:

function r = minus(obj1,obj2)
   % MINUS Implement obj1 - obj2 for DocPolynom
   obj1 = DocPolynom(obj1);
   obj2 = DocPolynom(obj2);
   k = length(obj2.coef) - length(obj1.coef);
   r = DocPolynom([zeros(1,k) obj1.coef]-[zeros(1,-k) obj2.coef]);
end 

Defining the * Operator

MATLAB calls the DocPolynom mtimes method to compute the product p*q. The mtimes method implements matrix multiplication since the multiplication of two polynomials is simply the convolution (conv) of their coefficient vectors:

function r = mtimes(obj1,obj2)
   % MTIMES Implement obj1 * obj2 for DocPolynoms
   obj1 = DocPolynom(obj1);
   obj2 = DocPolynom(obj2);
   r = DocPolynom(conv(obj1.coef,obj2.coef));
end 

Using the Arithmetic Operators

Given the DocPolynom object:

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

The following two arithmetic operations call the DocPolynom plus and mtimes methods:

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
Was this topic helpful?