eja: factor out mat2vec() and vec2mat() helper functions.

eja: add matrix inner products, and factor out the two used in R^n.

eja: replace nonexistent ArgumentError class.

eja: finally give Euclidean Jordan algebras an inner product.

eja: fix alphabetical ordering of element methods.

eja: add natural_representation() for elements.

eja: maintain a "natural basis" for EJAs.

This will eventually let us see the "usual" representation of an EJA
element. In other words, we don't want to see (1,0,1) to indicate the
identity element of the 2-by-2 symmetric matrices.

eja: rename matrix() to operator_matrix().

This leaves the dangerous parent class matrix() method there, but
whatever. The tests pass.

eja: define operator_matrix() to eventually replace matrix().

eja: add operator_commutes_with() for elements.

eja: add a test for power-operator-commutativity.

eja: remove pointless abs() calls.

eja: add polarization-identity and power-associativity tests.

eja: add an inverse() example.

eja: add element inverse() and is_invertible().

eja: add more quadratic representation tests.

eja: fix the dimension of the complex Hermitian simple EJA.

eja: add a test for the degree of Sn.

eja: replace eja_ln() and eja_sn() with their new names.

eja: add ComplexHermitianSimpleEJA to random_eja().

eja: begin implementing the complex hermitian simple EJA.

eja: pass a dimension to a matrix() constructor for an extra sanity check.

eja: fix screwup introduced in 5d147bd962.

eja: add a function to embed complex matrices in (bigger) real ones.

eja: add placeholder constructors for all simple EJAs.

eja: factor out the ugly bits of constructing simple matrix EJAs.

eja: add a TODO with some tests that fail for now.

eja: add non-working trace_inner_product() for EJA elements.

eja: add quadratic_representation() for elements.

eja: use random_eja() where applicable in tests.

eja: don't test for element matrix() symmetry (I don't think it holds).

eja: fix the basis order for Sn.

eja: add missing set_random_seed() call.

eja: add the random_eja() function.

eja: add a comment about row/column vectors to eja_sn().

eja: add the simple algebra S^n.

eja: add det() and trace() for regular elements.

eja: de-implement characteristic_polynomial for irregular elements.

eja: put element methods in alphabetical order.

eja: add is_regular() method on elements.

eja: fix element matrices.

The superclass matrix() method of elements sometimes computes the
right-matrix acting on row vectors. Nobody wants that shit. This
commit overrides it (to simply return the transpose of the superclass
matrix), and thus fixes the subalgebra_idempotent() method. Some tests
were added for the latter method, too.

eja: fix element powers.

We were using row-vector multiplication for powers (taken from the
superclass), but our vectors are column vectors. Oops. This broke
things when we assumed column vectors were being used, like when
we constructed a multiplication table. This commit fixes the powers
and adds/updates some tests.

eja: add doctest for a bug in subalgebra_generated_by().

eja: add currently-busted subalgebra_idempotent() method.

eja: use different generator names in subalgebras.

eja: add is_nilpotent() for elements.

eja: recurse more directly in minimal_polynomial().

eja: use the associativity of one-generator subalgebras.

eja: fix the rank of the spin factor algebra.

eja: remove symmetry test that don't work.

I don't know why, but the multiplication table of a commutative
algebra doesn't have to be symmetric. I'll think about this later.
In the meantime, don't crash about it.

Postscript (a month later): left-multiplication and right-multiplication
are the same in the EJA, but not necessarily for the matrices that represent
them. It was wrong to conflate the two concepts in the first place.

eja: rewrite the classcall/init process.

I'm not sure what I just did, but by copying the __classcall_private__
method from FiniteDimensionalAlgebra, I was able to make it take an
extra (optional) "rank" parameter while creating EJAs. This lets us
hard-code the rank for known EJAs, and put off figuring how we might
compute it otherwise.

eja: implement a working minimal_polynomial().

eja: add subalgebra_generated_by() method.

eja: add another test for degree().

eja: test that left-mult matrices are symmetric.

eja: add span_of_powers() method.

eja: remove an erroneous comment.

eja: begin implementing an element class.

eja: implement my own algebra subclass.

eja: fix field arguments, add comment.

eja: add eja_minimal_polynomial() function.

eja: add eja_ln() for the rank-two algebra.

eja: add examples for eja_rn.

eja: begin draft implementation of euclidean jordan algebras.

mjo/polynomial.py: remove a redundant line from a test.

mjo/polynomial.py: add another multidiv test based on an exercise.

Revert "mjo/polynomial.py: improve multidiv performance a bit."

This reverts commit 4e4efc9eff5c77a2ca19002b1dfa45598e974c54. Example
4 in the text doesn't work with this implementation, but it does with
my original one. Let's stick with slow and correct, for now.

mjo/polynomial.py: add a (failing!) test for Example 4 in the text.

mjo/polynomial.py: add two more examples from exercises in the text.

mjo/polynomial.py: improve multidiv performance a bit.

We don't need to re-check earlier "denominators" after division has
occurred, even though we *do* need to re-check the current one. This
makes the algorithm closer in practice to the one given in the text.

mjo/polynomial.py: improve tests for new multidiv function.

mjo/orthogonal_polynomials.py: fix doctests.

Add new mjo.polynomial module with the "multidiv" function.

This new module implements the generalized polynomial division
algorithm in Section 2.3 of Cox, Little, and O'Shea.

Revert "... add completely_positive_operators_gens()."

This reverts commit 3d6ec3f4f138a6278be4f393b491aa1ac2bbffa8. The new
function was mathematically wrong, and can't be fixed. Oops.

mjo/cone/completely_positive.py: add completely_positive_operators_gens().

Add a new function to return (as matrices) the generators of the
completely-positive cone of K, where K is some other given cone.

mjo/cone/symmetric_pd: add inverse_symmetric_pd() function.

mjo/cone/symmetric_pd: new module for symmetric positive-definite matrices.

mjo/cone/symmetric_psd: add missing set_random_seed() calls.

mjo/cone/symmetric_psd: don't use recusion; work on trivial matrices.

mjo/cone: improve docstrings the the rearrangement and schur cones.

mjo/cone: rename random_psd() to random_symmetric_psd().

cone/trivial_cone.py: add the trivial_cone() function.

cone/rearrangement.py: simplify the implementation.

Use matrix tricks instead of a local function to construct the
generators.

cone/rearrangement.py: add a "lattice" argument.

cone/rearrangement.py: fix the test for propriety.

We had a test for the rearrangement cone being proper, but it
incorrectly tested the p=0 case. Now that we're sanity-checking p,
that test was throwing a ValueError. Fix it to use p >= 1.

cone/rearrangement.py: add a few more tests.

Add a few more tests to the rearrangement_cone() function. In
particular, delete the has_rearrangement_property() function since it
only served to test the rearrangement cone. The property tests were
moved into the cone doctests.

The cone constructor now also checks that "p" is within bounds, and
throws a ValueError if not. There are tests for this too.

cone/rearrangement.py: add some preliminary references.

cone/schur.py: add "lattice" argument.

cone/nonnegative_orthant.py: add a word to the docs.

cone/nonnegative_orthant.py: add "lattice" argument.

cone/schur.py: add a test for the dual of the Schur cone.

cone/symmetric_psd.py: use two more generator expressions.

cone/symmetric_psd.py: use a generator expression in unit_eigenvectors().

cone/cone.py: use generator expressions instead of lists.

orthogonal_polynomials.py: use generator expressions where applicable.

orthogonal_polynomials.py: use xrange everywhere.

matrix_vector.py: use xrange everywhere.

mjo/interpolation.py: partial conversion to generator expressions.

mjo/interpolation.py: use xrange everywhere.

cone/schur.py: use xrange in one place.