Add more docs for a few private methods and implement the do-over.

Some examples and return type documentation were added for the
_zero(), _A(), and _G() methods of SymmetricLinearGame. The _zero()
method was also uncached, since attempting to cache _A() and _G()
revealed that CVXOPT clobbers them. The zero vector appears safe, but
let's play it safe.

This also implements a two-stage retry for the solution of a game. Our
default tolerance is now 1e-6, but when we're trying to solve a game,
we try it with 1e7 first. If we can solve it with the stricter
tolerance, then great. If not, we use the default.

Take the condition number into account when evaluating test results.

This adds a ``modifier`` parameter to the assert_within_tol() method
used in the SymmetricLinearGame unit tests. The condition number of
the game is always passed in as the modifier, and that lets us allow a
larger tolerance for nasty matrices.

Pass ABS_TOL to CVXOPT when solving games.

Our ABS_TOL is less than the CVXOPT default, and it looks like using
ours reduces the number of "unknown" results that we get. So let's try
that for now.

Change EPSILON to something more conservative in the test suite.

The old value of EPSILON was more lenient, but the new one can
actually be justified. The tests are currently pretty reliable, but
some tolerance > EPSILON failures are still occurring so this will
probably need to be massaged some more.

Set MAX_COND to 100 in the randomgen module to facilitate random testing.

Change the default tolerance to 1e-6 to reduce unknown solutions.

Ensure that e1,e2 are far enough inside K in random_orthant_game().

Add more doctest examples to the randomgen module.

Use "..." for floating point output in doctests.

Fix typo in last commit.

Enable doctest ELLIPSIS in a few modules.

Enable docs for the new test modules and clean them up.

Remove one TODO for a failing test that was caused by a typo (fixed earlier).

Remove the TODO for the dunshire.matrices tests.

Rename a test that I mistakenly renamed earlier.

Improve the two no-clobber tests with deepcopy().

Comment my new method-rgx in .pylintrc.

Clean up and document some of the new test code.

Add a new unit test suite for the dunshire.matrices module.

Enable and fix doctests for the new randomgen module.

Factor out the random test generation code into a new module.

Make the SymmetricLinearGame.condition() method public.

Fix a pylint warning in the matrices module.

Fix a pylint warning for a top-level variable name in test/__main__.py.

Use a shebang for the main test executable.

This replaces the "python test/" call with "./test/__main__py". It
may seem like a pointless change, but the former will always use
whatever "python" points to, and the latter will use the contents of
the shebang in "__main__.py". Distributions can fix the shebang on
that one file to ensure that the test suite is run with the proper
version of python.

Remove some debug print() statements and fix a copy-paste-o in the tests.

Add another failing test TODO, and one about a payoff() method.

Add another testing TODO.

Overhaul the tests to get more predictable behavior.

The most important change to the SymmetricLinearGame tests is that we
now check the condition numbers of the generated games. That prevents
most of the numerical trouble experienced before, and solves a few
open TODO items.

A RANDOM_MAX constant was introduced, and incorporated into the fudge
factor for the absolute tolerance used in tests. That contributes to
fixing the open TODO items as well.

The test code itself is pretty ugly now, but it can be fixed once they
all pass reliably (there's still a Lyapunov-like test failing).

Set options.ABS_TOL to 1e-7; we should adjust it elsewhere if needed.

Add a fudge factor of two when checking "unknown" conelp results.

Add two more TODOs, one minor, and one bad test failure.

Halve the definition of the condition number of a game.

Add a TODO to avoid comparing floats in doctests.

Add the condition number of the game to its string representation.

Add a PoorScalingException for the "math domain errors" that haunt me.

Document a missing parameter for GameUnsolvableExceptions.

Add the condition_number() function to the matrices module.

Add a "typecode" parameter to the identity() matrix function.

Add yet another TODO for failing tests.

Exit with a non-zero code when the test suite fails.

Add two more TODOs concerning failing tests.

Clean up a few pylint warnings and make "doc" a phony target.

Update Sphinx with the new directory structure.

Add setup.py and reorganize everything to make its "test" command happy.

Remove a unicode hyphen from a reference.

Add the AGPL3 license.

Pylint cleanup for tests.

Remove two more defunct TODO items.

Print the game data along with every GameUnsolvableException.

Rename "xi" and "gamma" to "p" and "q" to avoid name clashes with CVXOPT.

Remove a few completed TODO items.

Separate and organize the various documentation sections.

Reorganize the test source code and doc building.

Move unit test code into its own file (unders test/ instead of src/).

Add another TODO.

Switch to Mathjax for the docs and finish the "Background" section.

Remove a completed TODO.

Enable doctesting of ReST docs with `make doctest`.

Do a bunch more README work.

Add one more TODO.

Tweak the makefile now that the imports work better.

Clean up a bit of the import mess.

Remove docs with `make clean`.

Do a bunch more work on the intro/background.

Begin writing the background/introduction material.

Locally disable another pylint warning to get clean again.

Fiddle with the pylint settings.

Make sure SymmetricPSD doesn't contain asymmetric matrices.

Eliminate some unused variables by slicing a tuple before assignment.

Fix two more pylint bad-variable-name warnings.

Add a .pylintrc file and fix a few warnings.

Add tests for Lyapunov games over the ice-cream cone.

Return CVXOPT matrices from the random matrix functions.

Test the dual game value of a Lyapunov game over the orthant.

Remove unused import.

Add another TODO for Lyapunov game tests.

Add a test for Lyapunov games over the orthant.

Add eigenvalues_re() to compute real parts of eigenvalues of any matrix.

Refactor the random matrix functions a bit.

Use syevr instead of syev for eigenvalues.

Add a test for the value of a positive operator on the nonnegative orthant.

Add tests for the orthogonality relationships of a game solution.

Fix (or cover up) a bunch of pylint warnings.

Add tests for the "translated" and "negated" games (from a few corollaries).

Remove a completed TODO.

Attempt to recover from "unknown" solutions.

Sometimes CVXOPT was coming back with "unknown" solutions that looked
pretty close to real solutions. Now, instead of failing immediately,
we check to see if the primal/dual objectives are within ABS_TOL of
each other, and whether or not the optimal solutions lie in the
cone. If they all do, we take that as our solution and succeed rather
than raising an exception.

This required the loosening of what it means to be in the cone. Before
this commit, a point needed to be "far" inside the cone (past the
tolerance). Now it can lie outside of the cone (but still within the
tolerance). This weakens the checks that we perform on e1 and e2, but
gives us an easy way to check the optimal strategies.

Set ABS_TOL to 1e-6 to fix solution comparisons in the test suite.

Remove a completed TODO.

Get rid of the contains_strict() methods and compare against ABS_TOL.

Since we're comparing floating point numbers in the containment tests,
we should be doing it against a tolerance. But then, it becomes
pointless to distinguish between strict and non-strict containment.
So, this commit leaves only the __contains__() methods and checks
against options.ABS_TOL.

Add two more tests for nonnegative scaling factors.

Add another TODO about failing tests.

Add a test for an example in the Gowda/Ravindran paper.

Replace one TODO with something else, and add a new one.

Remove a completed TODO.

Finish overhauling the docstrings to numpy format.

Switch the docs style of cones.py and update cartesian product containment.

The docs for cones.py have all been switched (roughly) to use the
numpy style. In the process, I noticed that cartesian product
containment was a lot weirder than it needs to be. The "point" that
the __contains__() and contains_strict() methods take is now a tuple
corresponding to the factors of the cartesian product.

Another shot at documenting the options module.

More "easy" docs work in matrices.py/options.py.

Rename the "symmetric_linear_game" module to "games".