Add a bunch more natural numbers in the Naturals module.

Add the (in progress) FEM.R1 module.

Fix some docs in Roots.Simple.

Implement Gaussian quadrature and test it.

Rename zipcol to colzip.
Add a new function, colzipwith.

Add the Integration.Gaussian.nodes_and_weights function.

Add zipcol and matmap functions in Linear.Matrix.

Add the Integration.Gaussian module where we begin to implement Gaussian quadrature.

Add comments to Linear.QR about non-convergence.

Finish the eigenvectors_symmetric tests.

Add the eigenvectors_symmetric function and begin writing tests for it.

Implement the QR algorithm for computing eigenvalues.

Add type synonyms for column/row matrices.
Add row' and column' functions that do what you'd expect only they return Mats instead of Vecs like their un-prime counterparts.

Small cleanups in Linear.Vector.
Add 'diagonal' and 'trace' functions to Linear.Matrix.

Clean up imports everywhere.

Add tolerant versions of is_{upper,lower}_triangular.
Fix the QR factorization code.
Add tests for the QR behavior.

Add a Normed instance for (Vec n a).

Switch Linear.Vector to the numeric prelude and add the element_sum function to it.
Use Linear.Vector.element_sum in Linear.Matrix.

Remove old comment from Normed.

Add the Frobenius norm to Linear.Matrix.

Add the Linear.QR module and update the ghci/cabal files.

New function: Linear.Matrix.identity_matrix.

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.