Fix implementation of Linear.Matrix.construct.

Add the Polynomials.Orthogonal module.

Bump dependencies.

Add the rayleigh_quotient function.

Add Gauss-Seidel and SOR iterative methods.

Rename 'diagonal' to 'diagonal_part'.
Add functions to pull out the (strict) lower/upper triangular parts of a matrix.

Fix a bunch of hlint warnings.

Update ghci/cabal files to load the new module.

Add the Linear.Iteration module.

Add another example for forward_substitute.

Add 'diagonal' function.

Constrain Normed instance to column vectors (m-by-1 matrices).

Add the unit_roundoff function.

Update numeric-prelude and fixed-vector.
Use the (!) function from the new fixed-vector.
Add the Fast/Simple trisection method and a test.

Get determinants working.

Replace the whole Matrix implementation with something a little better.
Add the Linear.System module.
Get all doctests working again.
Update .ghci/cabal files.

Add Vec1, Vec4, Vec5 aliases.

Add triangular functions, determinant, minor (all half-baked) to Linear.Matrix.

Add the Linear.System module.

Add the delete function to Vector.hs.

Fix compiler warnings and doctests.

Convert scalars to 1x1 vectors.

A huge pile of crap upon Matrix/Vector.

Update .ghci.

Remove assumptions on the Normed class.

Convert Integration/Simpson.hs and Integration/Trapezoid.hs to numeric-prelude.

Use RealField/RealRing where possible instead of their constituents.
Convert src/ODE/IVP.hs to numeric-prelude.
Add RealRing/RealField instanced to BigFloat.

Rename Aliases.hs to BigFloat.hs, now containing numeric-prelude instances for BigFloats.
Rewrite Normed.hs, Roots/Fast.hs, and Roots/Simple.hs for numeric-prelude.

Make the partition function work with numeric-prelude.

Add numeric-prelude to the deps.

Move the Vector and Matrix modules under Linear.

Bump to fixed-vector-0.2.*.

Replace (fromRational . toRational) with realToFrac everywhere.

Update cabal file for the separate project/repo.

Fix import and module list names.

Add a 2D fixed-point doctest (example) to Vector.hs.
Remove unused imports.

Add a Normed instance for Float.

Remove non-fixed Matrix module.
Drop the "Fixed" prefix for Vector/Matrix modules.
Update ghci includes.

Clean up imports in FixedMatrix.hs.
Add matrix multiplication and Cholesky factorization to FixedMatrix.hs.
Add some doctests to FixedMatrix.hs.

Clean up imports in FixedVector.hs.

Remove reimplemented vector functions from FixedVector.hs.
Replace custom Vn functions with vector equivalents.

Add a Vector instance for Vn.

Begin the fixed-size matrix implementation.

Encode the vector type in Vn.
Add FixedVector.length.
Add FixedVector.map.
Include a special 4D type.

Add toList and fromList functions in FixedVector.hs.

Remove TwoTuple.hs.

Add 2d/3d wrapper types for easy pattern matching.
Implement both safe and unsafe indexing.

Replace the custom 'Vector' typeclass with 'Normed' everywhere.

Add cleaner Show instance for Vn.
Fix compiler warnings in FixedVector.hs.
Add more doctests to FixedVector.hs.

Add FixedVector and Matrix to the compiled modules.
Update deps for the new modules.

Fix compiler warnings in Matrix.hs.

Begin implementation of normed, fixed-length vectors.

Fix two compiler warnings.

Remove unused dependencies.
Set looser base version bounds.
Expose (and thus compile) more modules.

Add a simple unsafe matrix class to test the Cholesky algorithm.

Add an alternate book, and a gitignore for the numerical-analysis/dist directory.

Fix an off-by-one error in Euler's method.

Add an implementation of Euler's method that takes the step size 'h' as an argument instead of the number of subintervals 'n'.

Add the ODE.IVP module with Euler's method.
Clean up .ghci a little bit and add the new module.

Bump test deps for ghc-7.6.

Bump deps for ghc-7.6.

Add Integration.Simpson implementing Simpson's rule for numerical integration.

Move the partition function out of Integration.Trapezoid and into Misc.
Fix some trapezoid doctests.

Use filemanip to automatically doctest all source files.

Add the Integration.Trapezoid module; import it in the .ghci file.

Use the 2-norm instead of the infty-norm for the fixed point error ratios.

Fix a "norm" in Roots.Fast.

Rename "norm" to "norm_2" in the Vector class.
Add "norm_infty" to the Vector class.

Add an iteration count to the fixed_point function, rename it, and move it to the Roots.Fast module.
Implement fixed_point and fixed_point_iteration_count in Roots.Simple in terms of the general function.
Add a fixed_point_error_ratios function.

Require Vector instances to be instances of Num as well.

Import Aliases and TwoTuple in the .ghci file.

Add the Aliases module.

Add a custom Show instance for TwoTuple.

Change the type signature of fixed_point to work on Vectors.

Bump the doctest dependency.

Add a Vector class and make TwoTuple (and several base types) instances of it.

Begin work on a simple 2-tuple type.

Make numbers == 3000.1.* required.
Import Data.Number.BigFloat in the .ghci file.
Add a doctest for newtons_method using BigFloat.

Move the .ghci file to the top-level directory.
Use a simpler ghci prompt.

Remove an unused variable.

Add the fixed point method to Roots.Simple.

Add Newton's method tests.

Add a .ghci file.

Add the secant method to Roots.Simple.

Add Newton's method.

Split Roots into Roots.Simple and Roots.Fast.
Allow the makefile to find sources in subdirectories.
Update module exports in the cabal file.

Add the numerical-analysis Haskell library.