Add missing examples for two methods and use math for equations.

Reword two paragraphs in the overview.

Mention additional build and development requirements.

Output xhtml files instead of html ones (requires new alabaster theme).

Fiddle with some documentation settings and fix the LaTeX build.

Add a MANIFEST.in file, and a new "make dist" target.

Add the "test" package to setup.py for distribution.

Fix a typo.

Add some pointless fluff to my setup.py, and start at v0.1.0.

Add a very basic README.rst to be used as my package description on pypi.

Add some comments to the makefile.

Don't call my game a bastard.

Add some more docs for the player[12]_start() methods.

Disable all variable/method name warnings from pylint.

Ain't nobody got time for this.

Add and update a few test case docstrings.

Make the c(), G(), and h() methods of games public.

These don't really *need* to be public, but having them available and
documented should be helpful to anyone who wants to understand how we
transform our game into a cone program.

Remove the condition number from the game string representation.

Fix the test script to appease pylint.

Add missing docs for two SymmetricLinearGame methods.

Rename epsilon_scale() to tolerance_scale().

Remove a completed TODO.

Add two previously-failing examples as doctests for solution().

Enable the dual starting point and fix the test tolerance.

We set dualstart=player2_start(), but that caused some tests to fail
as unknown or optimal but not valid. So the new epsilon_scale() method
is used to verify the primal/dual optimal in solution(). After that,
the tests of course fail, because we're accepting much more-wrong
solutions. Incorporating epsilon_scale() into the test suite fixes
that.

Add an epsilon_scale() method for games.

When testing, we often need to know how lenient to be when making
comparisons. Trying to figure out just how lenient has been a huge
source of problems, and ultimately, the scaling factor (applied to
ABS_TOL) probably depends on properties of the solution.

This commit adds a new method, epsilon_scale(), that returns a safe
(very lenient) scaling factor. If things are within epsilon_scale()
times ABS_TOL, we consider then equal, or optimal, or whatever.

Add a cached method for games that returns the spectral norm of L.

Print a "pass" count during testing loops.

Build looping into the test suite and make doctests optional.

Add two spaces to the tests to make pylint happy.

Add a ball_radius() method for cones and use it to compute starting points.

Fix an example in the overview docs, and use ellipses in doctests.

Use "2" as a numerically-better factor in player[12]_start().

Add the player2_start() method and some tests for it.

Use player1_start() as the primal starting point and fix some tests.

Add the player1_start() method and two tests for it.

Make the _C(), _A(), and _b() methods for games public.

Replace a few member variable references with method calls.

Add the specnorm() function to the matrices module.

Figure out the base field automatically in condition_number().

Fix a mixup between e1 and e2 in the background documentation.

Add a "solutions don't change" test for the ice-cream cone too.

Test that we get the same solution if we solve the same game twice.

Remove the "VERBOSE" option, since you never want to change it.

Add a new failing test case.

Use the DEBUG_FLOAT_FORMAT when printing exception details.

Use modifier=4 in the orthogonality tests.

Remove another "unknown" TODO, since those don't seem to happen any more.

Remove two TODOs that were addressed with larger fudge factors in tests.

Remove the "unknown" solution TODO, our new heuristic seems to always work.

Remove the "math domain error" TODO, addressed by twiddling MAX_COND.

Add another TODO.

Remove a fixed TODO.

Fix docstring formatting of the solution() method.

Fix some pylint warnings.

Replace _try_solution() with something more reliable and update tests.

This huge change eliminates _try_solution() entirely. It turns out
that if we just solve with the default tolerance and then *test* what
we get back (regardless of the "status" field), we do better than the
two-phase _try_solution() approach. Well, we fail less, anyway.

The code for solution is now fairly simple. It solves the problem, and
if it isn't infeasible, checks the solution for sanity: the
primal/dual values are close (within 2*ABS_TOL) and the optimal points
are in the cone. If those two things are true, we return the solution
even if CVXOPT said "unknown". This fixes two test failures, which are
now included as doctests to ensure that they can be solved.

Moreover, the value of a game is now set to be the payoff at the
optimal points. Before, we simply took the primal optimal value from
CVXOPT. That was causing some test failures though, and either one is
just as good as the other and mathematically unjustified as yet. There
were existing tests to check the payoff at the optimal points, but they
became redundant and were removed.

Finally, all of the tests have been updated to use more conservative
modifiers, not based on the condition number of the game. Some failures
are still being ironed out, but they are rare.

Note: the _c(), _h(), etc. methods on the game are now overkill since
they are only used once, but they don't hurt I guess.

Lower MAX_COND down to 125 after witnessing a failure.

Put the MAX_COND at 150 for now... until it causes problems.

Update the project URL.

Add two small, well-conditioned games that fail solution as test cases.

Add a new DEBUG_FLOAT_FORMAT and use it when raising game exceptions.

Add game accessor methods for its L, K, e1, e2, and dimension.

Add a "checkloop" makefile target to run tests forever.

Fix a bug in my two-tolerance strategy and add a test case for it.

Allow longer modules in .pylintrc and ignore some new names.

Don't pass a sole argument as a keyword.

Use private methods for the rest of the CVXOPT vectors/matrices.

We already had private methods for _zero(), _A(), and _G(). Now we
have them for the rest of the matrices and vectors as well. This
improves consistency, and maybe more importantly prevents people from
ever thinking it's safe to pass the same matrix to CVXOPT twice.

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.