Matlab – Object-Oriented Programming

Paul Schrimpf

January 14, 2009

Paul Schrimpf () Matlab – Object-Oriented Programming January 14, 2009 1 / 15

Programming Paradigms

Procedural
I Do this, then do that ...
I Most of what we have seen so far
Functional
I Operate on functions
I e.g. LISP, Scheme, Haskell
Object-oriented
I Focus on code reuse and reliability
I An object is data and methods to manipulate it
I Take components that are used repeatedly and share characteristics
and implement as a class
others ...

Paul Schrimpf () Matlab – Object-Oriented Programming January 14, 2009 2 / 15

Object-oriented Lingo

A class is a data structure and methods that act on it

An object is a specific instance of a class
I e.g. a double is a class with methods such as +,−,*,exp()
Encapsulation refers to the fact that a user of a class should only
need to know what a method does, not how it is implemented
I e.g. Do not need to worry about how doubles are stored or how + works
A subclass is a specialized version of a parent class. Subclasses
inherit data and methods from their parent.
I e.g. double and int might be subclasses of a generic numeric class

Paul Schrimpf () Matlab – Object-Oriented Programming January 14, 2009 3 / 15

More OO Lingo

Abstraction means writing code that operates at the highest level

class possible
I e.g. most arithmetic operations work with any numeric class
An abstraction barrier refers to the fact that as long as we do not
change a given class, changes above it should not require any changes
below it, and changes below it should not require any changes above
I e.g. doing a different sequence of arithmetic operations does not require
changing int or double, and changing the implementation of int or
double should not require changing a sequence of arithmetic operations

Paul Schrimpf () Matlab – Object-Oriented Programming January 14, 2009 4 / 15

Example: function series class

Often, we want to approximate an unknown function by a series of

functions (as in the dynamic programming example covered earlier)
Many types of series: orthogonal polynomials, Fourier series, splines,
etc
For any series, we should be able to evaluate at a point, add,
subtract, multiply, differentiate, integrate, and construct to give a
best approximation to a function
This suggests writing a generic function series parent class with these
methods, and then writing specific types of series as subclasses

Paul Schrimpf () Matlab – Object-Oriented Programming January 14, 2009 5 / 15

Example: function series class
This code should be in a file named seriesFn.m in a directory named
@seriesFn (In older versions of matlab (before 7.5?) the way of
organizing classes and methods was different.)

1 classdef seriesFn
2 properties % the data
3 order % order of series
4 coeff % coefficients
5 dim % dimension
6 powers % powers that go with coefficients
7 end
8 methods (Abstract=true) % these are methods that are only
9 % implemented in child classes
10 y = sval(f,x) % evaluate series
11 d = derivative(f) % create derivative
12 F = integral(f,lo,hi) % evaluate integral
13 c = mtimes(a,b) % multiplication
14 s = approxFn(s,fn,tol) % make s approximate fn
15 end
Paul Schrimpf () Matlab – Object-Oriented Programming January 14, 2009 6 / 15
Example: function series class – constructor
Constructors create a new object
Child classes can redefine their constructors (or any other method) if
they do not, they inherit their parent’s constructor
The following code would go inside a methods block inside classdef
seriesFn

1 function f = seriesFn(order,coeff,tol,dim)
2 f.order = order;
3 f.dim = dim;
4 f.powers = intVecsLessThan(f.order,f.dim)';
5 if (length(coeff)<size(f.powers,1))
6 warning('order=%d, but only %d coeff\n',order, ...
7 length(coeff));
8 end
9 f.coeff = coeff;
10 f.coeff(end+1:size(f.powers,2)) = 0;
11 f.coeff = reshape(f.coeff,1,numel(f.coeff));
12 end

Paul Schrimpf () Matlab – Object-Oriented Programming January 14, 2009 7 / 15

Example: function series class – operator overloading

Classes can redefine their own versions of operators (+,−,*,(),:, etc)

The following code would go inside a methods block inside classdef
seriesFn
This version of plus will be called whenever someone writes a + b and
either a or b is a seriesFn

Paul Schrimpf () Matlab – Object-Oriented Programming January 14, 2009 8 / 15

 1 function c=plus(a,b)
2 if ¬isa(a,'seriesFn') | | ¬isa(b,'seriesFn')
3 error('Both arguments must be seriesFn objects');
4 end
5 order = max(a.order,b.order);
6 c = seriesFn(order,zeros(1,order+1));
7 if (a.order>b.order)
8 c.coeff = a.coeff;
9 c.coeff(1:length(b.coeff)) = c.coeff(1:length(b.coeff)) + b
10 elseif (b.order>a.order)
11 c.coeff = b.coeff;
12 c.coeff(1:length(a.coeff)) = c.coeff(1:length(a.coeff)) + a
13 else
14 c.coeff = a.coeff+b.coeff;
15 end
16 end % function plus

Paul Schrimpf () Matlab – Object-Oriented Programming January 14, 2009 9 / 15

Example: function series class – subclass

1 classdef polynomial < seriesFn

2 methods
3 function c=mtimes(a,b)
4 c = polynomial(a.order+b.order, ...
5 conv(a.coeff(end:−1:1),b.coeff(end:−1:1)))
6 c.coeff = c.coeff(end:−1:1);
7 end
8 function y = sval(f,x)
9 y = polyval(f.coeff(end:−1:1),x);
10 end
11 function df = derivative(f)
12 df=polynomial(f.order − 1,f.coeff(2:end).*(1:f.order));
13 end
14 % ... more methods omitted ...
15 end
16 end

Paul Schrimpf () Matlab – Object-Oriented Programming January 14, 2009 10 / 15

Forward Automatic Differentiation

Forward automatic differentiation computes derivatives by applying

the chain rule to each operation in a computation
I e.g. for x = 2; y = x 2 ; z = log(y ); forward AD would
1 x = 2, ∂x = 1
2 y = x 2 = 4, ∂y = 2x∂x = 4
3 z = log(y ), ∂z = y1 ∂y = 2
We can write a class that stores the value of a number and its
derivative, overload every arithmetic operator to work with that class,
and then by using this class in place of doubles, we will be able to
compute the derivative of any function without changing our code

Paul Schrimpf () Matlab – Object-Oriented Programming January 14, 2009 11 / 15

Example: Forward AD

1 classdef autodiff
2 properties
3 val % value
4 deriv % derivative, deriv(:,:,i) is dval / dx i
5 end % properties
6 methods
7 function dx = autodiff(x) % Constructor
8 % ... body omitted ...
9 end % function autodiff
10 % Accessors
11 function v = value(x)
12 v = x.val;
13 end
14 function d = diff(x)
15 d = x.deriv;
16 end

Paul Schrimpf () Matlab – Object-Oriented Programming January 14, 2009 12 / 15

Example: Forward AD

1 function c=mtimes(a,b)
2 c = autodiff([]);
3 if (isa(a,'autodiff'))
4 if (isa(b,'autodiff'))
5 c.val = a.val*b.val;
6 c.deriv = zeros([size(c.val) size(a.deriv,3)]);
7 for i=1:size(a.deriv,3)
8 c.deriv(:,:,i) = a.deriv(:,:,i) *b.val + ...
9 a.val*b.deriv(:,:,i);
10 end
11 else
12 c.val = a.val * b;
13 c.deriv = zeros([size(c.val) size(a.deriv,3)]);
14 for i=1:size(a.deriv,3)
15 c.deriv(:,:,i) = a.deriv(:,:,i)*b;
16 end
17 end
18 else
19 % ... other cases omitted ...
20 end % mtimes()
Paul Schrimpf () Matlab – Object-Oriented Programming January 14, 2009 13 / 15
Example: Forward AD – usage

Want to differentiate fn(x) with respect to x

1 % x is a double vector or matrix

2 x = autodiff(x); % make an autodiff object from x
3 fAD = fn(x); % compute fn and its derivative
4 fval = value(fAD); % extract the function value
5 df = diff(fAD); % extract the derivative

For a more complete example, see binChoiceLikeAD.m, which uses

autodiff on the probit likelihood

Paul Schrimpf () Matlab – Object-Oriented Programming January 14, 2009 14 / 15

Exercises

1 Incorporate objects into the dynamic programming example from earlier. You might begin by making it use the
serisFn class described above.
2 Add to the autodiff class. It is incomplete. Many methods that work for double matrices have not been implemented.
Particularly important and easy methods that need to be implemented include size, ndims, length, and numel. For
motivation, you could try making the autodiff class work with some other code that you have written.
3 If the autodiff class was well designed, it would allow doing something like
x = autodiff(autodiff(x)) to compute 2nd and higher order derivatives. Does this work? If not,
try to make it work.
4 Design a class hierarchy for datasets. Every econometric program needs to deal with data. A well designed class should
make dealing with data easier.
5 Think about the patterns in the type of programs that you most often write, or expect to write. Design classes that will
help organize your programs.

Paul Schrimpf () Matlab – Object-Oriented Programming January 14, 2009 15 / 15