Remove a stray include

I thought of moving SplineKnot to a separate header but decided against
it (for now) and this got left behind.

Add a simple linearly interpolated "spline"

Fix a missing return in assignment operator

Move a #include to where it's actually used

Move the Knot struct out of Spline

It doesn't depend on the degree of the spline, so this will generate less
different types and make it easier to create splines of different degrees
from the same knots.

Add an interpolation sub-library

Initially including polynomials and splines, with cubic Hermite splines
being the only implemented spline type.

Fix a memory access error in DynamicMatrix::invert

Gauss_jordan returns a reference to the result, which is a local
variable.  It needs to be assigned to *this to retain it.

Copy Matrix test cases for DynamicMatrix

Improve readability of Matrix test cases with typedefs

Improve Vector constructor for C++11

The new overload allows vectors of any size to be constructed by passing
the component values as constructor arguments.

Fix a bug in the prefix version of vector compose function

Add test cases for Vector

Use numeric_limits in Matrix test cases

Add formatted output operators for vector and matrix classes

Fix a function name

The definition was changed in fb1e198 but since everything is templates,
I didn't notice the incorrect name here.

Use correct type for constant

Add row and column accessors to Matrix

Rename the low-level matrix inversion function to gauss_jordan

Since that's the name of the algorithm being used.  Also remove an
unnecessary assignment from the non-mutating case.

Optimize bounding box bisection with more early culling

Add some comments to shape.h

Use the coverage function to calculate tighter bounding boxes

Add a function to test whether a shapes covers a bounding box

Fix composite shape ray intersection logic

The test for start_nesting coalescence was written the wrong way, causing
intersection shapes to return spurious hits when the ray started inside
some part of the shape.  Presumably union shapes did not return hits in
some cases when they should.

Use correct class to refer to member function

Add a missing include

Use numeric literals in place of M_PI

Recent Windows headers require _USE_MATH_DEFINES to be #defined in order
to #define M_PI, but we can't guarantee that someone else won't #include
<cmath> before us.

Avoid a warning about shadowing a member

Add dynamically allocated versions of matrix and vector

Sometimes it's not possible to know the dimensions at compile time, for
example when calculating regressions from user-inputted data.

Adjust start_nesting in CompositeShape::get_intersections

The intersection points are coalesced to incrementally form a single
composite shape so start_nesting must follow suit.

Ensure that HyperBox does not produce duplicate intersections

In certain corner cases (literally) two coincident intersections could be
produced when the ray passed through the edge of the box, preventing
intersctions on the opposite side from being produced.

Use the proper array size in the raytrace example

Minor fixes

Rework CompositeShape algorithms

The old version had problems with coplanar surfaces and sometimes failed
to produce intersections when it should have.

Add an entry flag to SharedPoint

Remove a debug print

Fix the name of the properties panel

Add a Blender operator to export shapes

Correct a spelling mistake

Add a forgotten & to a getter

Fix the bounding sphere algorithm

Add missing #includes to dummy.cpp

Comment tweaks

Avoid division by zero in HalfSpace::get_intersections

Always explicitly construct values of type T

Add a raytracer example program

Add a loading system for shapes

Convert the geometry part to use the new vector slicing API

Everything being templates makes catching subtle compilation errors a bit
hard.

Clearer API for slicing and dicing vectors, and also matrices

Always pivot rows when inverting for better numerical stability

Add an empty flag to BoundingSphere

Useful for distinguishing a bounding sphere that has nothing in it from
one that contains a single point.

Add a bounding sphere class

Shapes don't produce bounding spheres yet, but it can be used for other
purposes.

Add missing return statements

Negation contains a pointer and needs copy c'tor and operator=

Put ray and bounding box transformations in AffineTransformation

This makes them easier to use elsewhere, in cases where creating a
TransformedShape would be overkill.

Take care not to count initialization values when finding min/max

Add testcases for BoundingBox

Some bounding box logic fixes

Make CompositeShape::get_intersections work with null points

This was a bit tricky, since it's necessary to inspect the points returned
by component shapes to see if they're actually on the composite surface.
To that end, a temporary buffer is allocated.  This is most likely used in
interactive point-and-pick situations, so the performance loss should not
be significant.

Implement the missing assignment operator in CompositeShape

Also rewrite the copy constructor in a slightly different way.

Put the common #includes in shape.h

Almost every shape needs these, so it's not worth it to try and avoid
unnecessary headers in the base class.

Fix a case in ExtrudedShape with certain ray parameters

A ray starting outside of the length of the shape and pointing away from
it caused a local ray with a negative limit to be constructed.

Implement bounding boxes with a separate class

This solves several problems with them, including positioning off the
origin and bounding boxes of negated shapes.

Rewrite composite shape vector constructors with iterator ranges

Besides the issue of favoring one container type over others, constness
of the contents causes it to be a different, incompatible type.  Iterators
solve this in an elegant way.

Add a HalfSpace shape

Make the check_intersection function non-virtual

Almost all shapes were implementing it with a call to get_intersections,
so might as well make the base class do that.  Performance loss is likely
negligible.

Properly sort intersection points for complex shapes

Code structure in simpler shapes have been adjusted to keep it similar.

Add shapes representing set operations

Miscellaneous fixes, mostly stylistic

Verify that parameters make sense

Math function usage fixes

Add using declarations and #includes where needed, and clean up some
unnecessary ones.  abs() is particularly annoying, as the int version
easily gets into the global namespace and doesn't give a warning if
used with floats or doubles.

Transform normals correctly

Add a class for extruded shapes

Add a distance limit to Ray

Record distance in SurfacePoint

Give Vector constructors from one higher/lower dimension

These replace the augment/reduce_vector functions, which were in a rather
odd place.

Add basic description for all classes

Add more collision check functions for shapes

Use a cached inverse transformation in TransformedShape

Add multiplication and inversion operations to AffineTransformation

Some more member mis-use fixes

Don't qualify potentially overloaded functions with the std namespace

Instead put a using std::func before the call.  This makes things work if
the template argument is a user-defined type with these functions defined
in another namespace.

TransformedShape should derive from Shape

Add four-component members and constructor to Vector

Fix AffineTransformation::translate

Translation coordinates go in the last column, not in the last row.

Fix Matrix template copy constructor

A different version of the template is a different class, so the data
member can't be accessed directly.

Improvements to the Angle class

Add comparison operators and wrapping functions.

Use turn instead of circle in the factory functions and provide an
interface to and from turns.

Redesign the Vector interface

The constructors from two and three components are now provided directly
by the Vector template, so Vector2 and Vector3 are no longer needed.  In
addition, two- and three-component vectors now have named members.

Some basic test cases

Beginnings of a geometry library

Add a Vector2 class

Use the correct multiplication operator

Move some simple function definitions inside the class declarations

Another big batch of stuff

This includes most of the missing things.

Minor fixes

Rename the library to mspmath and make linal a sublibrary

Basic vector and matrix classes

Some classes are still incomplete