Thie document points out a few details to those who may be interested
in more details than what is provided in

	http://www.fulcrum.org/msouth/perl_summary.txt

Probably The most interesting project I have worked on is an online
test-creation and test-taking system.  (The project's funding future came
into question in mid stream and so it was never completed, but there is
a lot of good work in it.)  The full source code can be found here:

	http://www.fulcrum.org/msouth/code/scape.tgz

(That file contains a subdirectory called "module" which contains
the perl code I am referring to.  Nearly everything else there is hacked
together for a demo, although the stuff that creates the database and
tables is pretty much ok, and the templates work, although they are 
ugly.)

There is a summary of the structure of the Perl modules in the
project at

	http://www.fulcrum.org/msouth/code/scape_structure.txt

There are something like 38 class files if I recall correctly.  One 
place of interest in the code might be the AUTOLOAD method in 

	http://www.fulcrum.org/msouth/code/scape/module/Course/Generic/Generic.pm.txt

which checks the object's "_autoguys" member to see if the method is
authorized for autoloading (in which case it provides a simple get/set
functionality).  Failing that, it checks the "_from_parent" member to
see if it is to pass that message on to whatever object is defined in
"_parent".  An extra level of flexibility is added, however, by allowing
the "_from_parent" entry to specify which method of the "_parent" is to be
called in proxy.

For example, you have a Question object that has several Text segments.
In the definition of Text, one could define

	$self->{_from_parent} = {number=>undef, question_id=>'id'};

meaning, "for this object, if someone asks for the number() method,
give them my _parent's number() method.  If they ask for the question_id()
method, call my _parent's id() method".

Math::MatrixReal methods

The problem:

Math::MatrixReal is a CPAN module that implements a wide range of matrix
operations for matrices of real numbers.  However, the native constructors
would only create empty matrices or read in matrices formatted as strings
(!), making it decidedly inconvenient to create one from, for example,
an array or an array of arrays, or even an array of column vectors of
type Math::MatrixReal.

Solution:

I created two methods, one for creating a matrix from rows and one from
columns, called new_from_rows() and new_from_cols().  For input, one can
pass in any combination of 

	* array references,

	* column or row vectors created by Math::MatrixReal (or any object
	which implements correspondingly named accessors)

	* strings properly formatted for Math::MatrixReal's new() method.

Sample Result:

Code that once read like this:

$mat = Math::MatrixReal->new_from_string( <<'END') ;
[ 1 2 3 ]
[ 4 5 6 ]
[ 7 8 9 ]
END

can now be done like this:

$mat = Math::MatrixReal->new_from_rows( [ [1,2,3], [4,5,6], [7,8,9] ] );

The code:

You can get Math::MatrixReal from CPAN.  I have cut out just my subroutines
and put them here:

http://fulcrum.org/msouth/code/mmr.txt

Extra-Curricular Activities:

Polyplus.pm is an extension of Lincoln Stein's GD::Polygon class.  I had
several things that I wanted to be able to do with polygons in my own
work, such as spin them about their point centroid or expand them 
in place with the center of the expansion being at the center of the
bounding box of the polygon.

Here is the pod2html output:

http://www.fulcrum.org/projects/polyplus/Polyplus.html

And the source is at:

http://fulcrum.org/msouth/code/pp.txt


(Note that the unusual syntax in that file is a "when in Rome" thing that
was consistent with Lincoln's implementation of GD::Polygon.  I don't
know why it was coded that way, but I was being consistent to make it
easy for him to integrate if he so chose.)

Vector and Vector::Group

My main use for Polyplus.pm these days is to give me a simple way to
display the output of stuff that uses a more general vector graphics
module.  Vector.pm defines an interesting array of methods which are very
useful for mucking around with three-dimensional wireframes.  There are
several convenience methods that turn out to be big time savers, such
as tilt() which can be used to grab a 3-d world by one vector and rotate
that vector to a new location, dragging the 3-d world with it.

This allows you to, for example, pass in the x,y,z location of a 
"camera" (or "viewpoint") and the z axis (0,0,1), tilt the rest of
the vectors in such a way that the viewpoint gets rotated onto
(0,0,1), and then simply pass the x and y coordinates of the vectors
to a renderer.

Here is the pod2html output:

http://fulcrum.org/msouth/code/vector.html

The source for Vector.pm is here:

http://fulcrum.org/msouth/code/vector.txt

Another interesting function is in Vector::Group, which mostly just
implements grouping of vectors so that it is easy to (for example)
tilt() them all at once.  However, for one project I needed to take
a two-dimensional polygon and extrude it into the third dimension
(i.e. turn a square into a square box, an octagon into an octagonal
box, etc).  You can see how that was done with the smear() method 
in Vector::Group.

Here is the source for Group.pm:

http://fulcrum.org/msouth/code/group.txt

-- 
Michael South

101 Canyon Run
Cary NC  27513 USA
(919) 465-9074

msouth@fulcrum.org