from dunshire.games import SymmetricLinearGame
from dunshire.matrices import (append_col, append_row, identity)
-MAX_COND = 100
+MAX_COND = 125
"""
-The maximum condition number of a randomly-generated game.
+The maximum condition number of a randomly-generated game. When the
+condition number of the games gets too high, we start to see
+:class:`PoorScalingException` being thrown. There's no science to
+choosing the upper bound -- it got lowered until those exceptions
+stopped popping up. It's at ``125`` because ``129`` doesn't work.
"""
RANDOM_MAX = 10
-------
float
- A random real number between ``-RANDOM_MAX`` and ``RANDOM_MAX``,
- inclusive.
+ A random real number between negative and positive
+ :const:`RANDOM_MAX`, inclusive.
Examples
--------
-------
float
- A random nonnegative real number between zero and ``RANDOM_MAX``,
- inclusive.
+ A random nonnegative real number between zero and
+ :const:`RANDOM_MAX`, inclusive.
Examples
--------
-------
int
- A random natural number between ``1`` and ``RANDOM_MAX`` inclusive.
+ A random natural number between ``1`` and :const:`RANDOM_MAX`,
+ inclusive.
Examples
--------
-------
matrix
- A new matrix whose entries are random floats chosen uniformly from
- the interval ``[-RANDOM_MAX, RANDOM_MAX]``.
+ A new matrix whose entries are random floats chosen uniformly
+ between negative and positive :const:`RANDOM_MAX`.
Examples
--------
matrix
A new matrix whose diagonal entries are random floats chosen
- using func:`random_scalar` and whose off-diagonal entries are
+ using :func:`random_scalar` and whose off-diagonal entries are
zero.
Examples
matrix
A new matrix, Lyapunov-like on the ice-cream cone in ``dims``
dimensions, whose free entries are random floats chosen uniformly
- from the interval ``[-RANDOM_MAX, RANDOM_MAX]``.
+ between negative and positive :const:`RANDOM_MAX`.
References
----------
We generate each of ``L``, ``K``, ``e1``, and ``e2`` randomly within
the constraints of the nonnegative orthant, and then construct a
game from them. The process is repeated until we generate a game with
- a condition number under ``MAX_COND``.
+ a condition number under :const:`MAX_COND`.
Returns
-------
We generate each of ``L``, ``K``, ``e1``, and ``e2`` randomly within
the constraints of the ice-cream cone, and then construct a game
from them. The process is repeated until we generate a game with a
- condition number under ``MAX_COND``.
+ condition number under :const:`MAX_COND`.
Returns
-------
return random_icecream_game()
+def random_game():
+ """
+ Return a random game.
+
+ One of the functions,
+
+ 1. :func:`random_orthant_game`
+ 2. :func:`random_icecream_game`
+
+ is chosen at random and used to generate a random game.
+
+ Returns
+ -------
+
+ SymmetricLinearGame
+ A random game.
+
+ Examples
+ --------
+
+ >>> random_game()
+ <dunshire.games.SymmetricLinearGame object at 0x...>
+
+ """
+ cone_type = randint(0,1)
+ if cone_type == 0:
+ return random_orthant_game()
+ elif cone_type == 1:
+ return random_icecream_game()
+
+
def random_ll_orthant_game():
"""
Return a random Lyapunov game over some nonnegative orthant.
to have a :func:`random_diagonal_matrix` as its operator. Such
things are Lyapunov-like on the nonnegative orthant. That process is
repeated until the condition number of the resulting game is within
- ``MAX_COND``.
+ :const:`MAX_COND`.
Returns
-------
SymmetricLinearGame
- A random game over some nonnegative orthant whose ``payoff`` method
- is based on a Lyapunov-like ``L`` operator.
+
+ A random game over some nonnegative orthant whose
+ :meth:`dunshire.games.SymmetricLinearGame.payoff` method is
+ based on a Lyapunov-like
+ :meth:`dunshire.games.SymmetricLinearGame.L` operator.
Examples
--------
We first construct a :func:`random_icecream_game` and then modify it
to have a :func:`random_lyapunov_like_icecream` operator. That
process is repeated until the condition number of the resulting game
- is within ``MAX_COND``.
+ is within :const:`MAX_COND`.
Returns
-------
SymmetricLinearGame
- A random game over some ice-cream cone whose ``payoff`` method
- is based on a Lyapunov-like ``L`` operator.
+ A random game over some ice-cream cone whose
+ :meth:`dunshire.games.SymmetricLinearGame.payoff` method
+ is based on a Lyapunov-like
+ :meth:`dunshire.games.SymmetricLinearGame.L` operator.
Examples
--------
return G
+def random_ll_game():
+ """
+ Return a random Lyapunov-like game.
+
+ One of the functions,
+
+ 1. :func:`random_ll_orthant_game`
+ 2. :func:`random_ll_icecream_game`
+
+ is chosen at random and used to generate a random game.
+
+ Returns
+ -------
+
+ SymmetricLinearGame
+ A random Lyapunov-like game.
+
+ Examples
+ --------
+
+ >>> random_ll_game()
+ <dunshire.games.SymmetricLinearGame object at 0x...>
+
+ """
+ cone_type = randint(0,1)
+ if cone_type == 0:
+ return random_ll_orthant_game()
+ elif cone_type == 1:
+ return random_ll_icecream_game()
+
+
def random_positive_orthant_game():
"""
Return a random game over the nonnegative orthant with a positive
We first construct a :func:`random_orthant_game` and then modify it
to have a :func:`random_nonnegative_matrix` as its operator. That
process is repeated until the condition number of the resulting game
- is within ``MAX_COND``.
+ is within :const:`MAX_COND`.
Returns
-------
SymmetricLinearGame
- A random game over some nonnegative orthant whose ``payoff`` method
- is based on a positive ``L`` operator.
+ A random game over some nonnegative orthant whose
+ :meth:`dunshire.games.SymmetricLinearGame.payoff` method
+ is based on a positive
+ :meth:`dunshire.games.SymmetricLinearGame.L` operator.
Examples
--------