### 34.1 Creating a Class

We use in the following text a polynomial class to demonstrate the use of object oriented programming within Octave. This class was chosen as it is simple, and so doesn’t distract unnecessarily from the discussion of the programming features of Octave. However, even still a small understand of the polynomial class itself is necessary to fully grasp the techniques described.

The polynomial class is used to represent polynomials of the form

```a0 + a1 * x + a2 * x^2 + … + an * x^n
```

where a0, a1, etc. are real scalars. Thus the polynomial can be represented by a vector

```a = [a0, a1, a2, …, an];
```

We therefore now have sufficient information about the requirements of the class constructor for our polynomial class to write it. All object oriented classes in Octave, must be contained with a directory taking the name of the class, prepended with the @ symbol. For example, with our polynomial class, we would place the methods defining the class in the @polynomial directory.

The constructor of the class, must have the name of the class itself and so in our example the constructor with have the name @polynomial/polynomial.m. Also ideally when the constructor is called with no arguments to should return a value object. So for example our polynomial might look like

```## -*- texinfo -*-
## @deftypefn  {Function File} {} polynomial ()
## @deftypefnx {Function File} {} polynomial (@var{a})
## Create a polynomial object representing the polynomial
##
## @example
## a0 + a1 * x + a2 * x^2 + @dots{} + an * x^n
## @end example
##
## @noindent
## from a vector of coefficients [a0 a1 a2 @dots{} an].
## @end deftypefn

function p = polynomial (a)
if (nargin == 0)
p.poly = [0];
p = class (p, "polynomial");
elseif (nargin == 1)
if (strcmp (class (a), "polynomial"))
p = a;
elseif (isvector (a) && isreal (a))
p.poly = a(:).';
p = class (p, "polynomial");
else
error ("polynomial: expecting real vector");
endif
else
print_usage ();
endif
endfunction
```

Note that the return value of the constructor must be the output of the `class` function called with the first argument being a structure and the second argument being the class name. An example of the call to this constructor function is then

```p = polynomial ([1, 0, 1]);
```

Note that methods of a class can be documented. The help for the constructor itself can be obtained with the constructor name, that is for the polynomial constructor `help polynomial` will return the help string. Also the help can be obtained by restricting the search for the help to a particular class, for example ```help @polynomial/polynomial```. This second method is the only means of getting help for the overloaded methods and functions of the class.

The same is true for other Octave functions that take a function name as an argument. For example `type @polynomial/display` will print the code of the display method of the polynomial class to the screen, and `dbstop @polynomial/display` will set a breakpoint at the first executable line of the display method of the polynomial class.

To check where a variable is a user class, the `isobject` and `isa` functions can be used. For example:

```p = polynomial ([1, 0, 1]);
isobject (p)
⇒ 1
isa (p, "polynomial")
⇒ 1
```
Built-in Function: isobject (x)

Return true if x is a class object.

The available methods of a class can be displayed with the `methods` function.

Function File: methods (obj)
Function File: methods ("classname")
Function File: mtds = methods (…)

Return a cell array containing the names of the methods for the object obj or the named class classname.

obj may be an Octave class object or a Java object.

To inquire whether a particular method is available to a user class, the `ismethod` function can be used.

Built-in Function: ismethod (obj, method)

Return true if obj is a class object and the string method is a method of this class.

```p = polynomial ([1, 0, 1]);