from dunshire.games import SymmetricLinearGame
from dunshire.matrices import (append_col, append_row, identity)
-MAX_COND = 250
+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
def random_scalar():
"""
- Generate a random scalar in ``[-RANDOM_MAX, RANDOM_MAX]``.
+ Generate a random scalar.
Returns
-------
float
+ A random real number between negative and positive
+ :const:`RANDOM_MAX`, inclusive.
Examples
--------
def random_nn_scalar():
"""
- Generate a random nonnegative scalar in ``[0, RANDOM_MAX]``.
+ Generate a random nonnegative scalar.
Returns
-------
float
+ A random nonnegative real number between zero and
+ :const:`RANDOM_MAX`, inclusive.
Examples
--------
def random_natural():
"""
- Generate a random natural number between ``1 and RANDOM_MAX``
- inclusive.
+ Generate a random natural number.
Returns
-------
int
+ 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
----------
def random_orthant_game():
"""
- Generate the ``L``, ``K``, ``e1``, and ``e2`` parameters for a
- random game over the nonnegative orthant, and return the
- corresponding :class:`SymmetricLinearGame`.
+ Generate a random game over the nonnegative orthant.
+
+ 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 :const:`MAX_COND`.
+
+ Returns
+ -------
+
+ SymmetricLinearGame
+ A random game over some nonnegative orthant.
+
+ Examples
+ --------
+
+ >>> random_orthant_game()
+ <dunshire.games.SymmetricLinearGame object at 0x...>
- We keep going until we generate a game with a condition number under
- MAX_COND.
"""
ambient_dim = random_natural() + 1
K = NonnegativeOrthant(ambient_dim)
- e1 = [random_nn_scalar() for _ in range(K.dimension())]
- e2 = [random_nn_scalar() for _ in range(K.dimension())]
+ e1 = [0.1 + random_nn_scalar() for _ in range(K.dimension())]
+ e2 = [0.1 + random_nn_scalar() for _ in range(K.dimension())]
L = random_matrix(K.dimension())
G = SymmetricLinearGame(L, K, e1, e2)
def random_icecream_game():
"""
- Generate the ``L``, ``K``, ``e1``, and ``e2`` parameters for a
- random game over the ice-cream cone, and return the corresponding
- :class:`SymmetricLinearGame`.
+ Generate a random game over the ice-cream cone.
+
+ 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 :const:`MAX_COND`.
+
+ Returns
+ -------
+
+ SymmetricLinearGame
+ A random game over some ice-cream cone.
+
+ Examples
+ --------
+
+ >>> random_icecream_game()
+ <dunshire.games.SymmetricLinearGame object at 0x...>
- We keep going until we generate a game with a condition number under
- MAX_COND.
"""
# Use a minimum dimension of two to avoid divide-by-zero in
# the fudge factor we make up later.
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
+ :meth:`dunshire.games.SymmetricLinearGame.payoff` method is
+ based on a Lyapunov-like
+ :meth:`dunshire.games.SymmetricLinearGame.L` operator.
+
+ Examples
+ --------
+
+ >>> random_ll_orthant_game()
+ <dunshire.games.SymmetricLinearGame object at 0x...>
+
"""
G = random_orthant_game()
- L = random_diagonal_matrix(G._K.dimension())
+ L = random_diagonal_matrix(G.dimension())
# Replace the totally-random ``L`` with random Lyapunov-like one.
- G = SymmetricLinearGame(L, G._K, G._e1, G._e2)
+ G = SymmetricLinearGame(L, G.K(), G.e1(), G.e2())
while G.condition() > MAX_COND:
# Try again until the condition number is satisfactory.
G = random_orthant_game()
- L = random_diagonal_matrix(G._K.dimension())
- G = SymmetricLinearGame(L, G._K, G._e1, G._e2)
+ L = random_diagonal_matrix(G.dimension())
+ G = SymmetricLinearGame(L, G.K(), G.e1(), G.e2())
return G
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
+ :meth:`dunshire.games.SymmetricLinearGame.payoff` method
+ is based on a Lyapunov-like
+ :meth:`dunshire.games.SymmetricLinearGame.L` operator.
+
+ Examples
+ --------
+
+ >>> random_ll_icecream_game()
+ <dunshire.games.SymmetricLinearGame object at 0x...>
+
"""
G = random_icecream_game()
- L = random_lyapunov_like_icecream(G._K.dimension())
+ L = random_lyapunov_like_icecream(G.dimension())
# Replace the totally-random ``L`` with random Lyapunov-like one.
- G = SymmetricLinearGame(L, G._K, G._e1, G._e2)
+ G = SymmetricLinearGame(L, G.K(), G.e1(), G.e2())
while G.condition() > MAX_COND:
# Try again until the condition number is satisfactory.
G = random_icecream_game()
- L = random_lyapunov_like_icecream(G._K.dimension())
- G = SymmetricLinearGame(L, G._K, G._e1, G._e2)
+ L = random_lyapunov_like_icecream(G.dimension())
+ G = SymmetricLinearGame(L, G.K(), G.e1(), G.e2())
return G
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
+ :meth:`dunshire.games.SymmetricLinearGame.payoff` method
+ is based on a positive
+ :meth:`dunshire.games.SymmetricLinearGame.L` operator.
+
+ Examples
+ --------
+
+ >>> random_positive_orthant_game()
+ <dunshire.games.SymmetricLinearGame object at 0x...>
+
"""
G = random_orthant_game()
- L = random_nonnegative_matrix(G._K.dimension())
+ L = random_nonnegative_matrix(G.dimension())
# Replace the totally-random ``L`` with the random nonnegative one.
- G = SymmetricLinearGame(L, G._K, G._e1, G._e2)
+ G = SymmetricLinearGame(L, G.K(), G.e1(), G.e2())
while G.condition() > MAX_COND:
# Try again until the condition number is satisfactory.
G = random_orthant_game()
- L = random_nonnegative_matrix(G._K.dimension())
- G = SymmetricLinearGame(L, G._K, G._e1, G._e2)
+ L = random_nonnegative_matrix(G.dimension())
+ G = SymmetricLinearGame(L, G.K(), G.e1(), G.e2())
return G
"""
Scale the given game by a random nonnegative amount.
+ We re-attempt the scaling with a new random number until the
+ resulting scaled game has an acceptable condition number.
+
Parameters
----------
- G : :class:`SymmetricLinearGame`
+ G : SymmetricLinearGame
The game that you would like to scale.
Returns
-------
- (float, :class:`SymmetricLinearGame`)
+ (float, SymmetricLinearGame)
A pair containing the both the scaling factor and the new scaled game.
+ Examples
+ --------
+
+ >>> from dunshire.matrices import norm
+ >>> from dunshire.options import ABS_TOL
+ >>> G = random_orthant_game()
+ >>> (alpha, H) = random_nn_scaling(G)
+ >>> alpha >= 0
+ True
+ >>> G.K() == H.K()
+ True
+ >>> norm(G.e1() - H.e1()) < ABS_TOL
+ True
+ >>> norm(G.e2() - H.e2()) < ABS_TOL
+ True
+
"""
alpha = random_nn_scalar()
- H = SymmetricLinearGame(alpha*G._L.trans(), G._K, G._e1, G._e2)
+ H = SymmetricLinearGame(alpha*G.L().trans(), G.K(), G.e1(), G.e2())
while H.condition() > MAX_COND:
# Loop until the condition number of H doesn't suck.
alpha = random_nn_scalar()
- H = SymmetricLinearGame(alpha*G._L.trans(), G._K, G._e1, G._e2)
+ H = SymmetricLinearGame(alpha*G.L().trans(), G.K(), G.e1(), G.e2())
return (alpha, H)
"""
Translate the given game by a random amount.
+ We re-attempt the translation with new random scalars until the
+ resulting translated game has an acceptable condition number.
+
Parameters
----------
- G : :class:`SymmetricLinearGame`
+ G : SymmetricLinearGame
The game that you would like to translate.
Returns
-------
- (float, :class:`SymmetricLinearGame`)
+ (float, SymmetricLinearGame)
A pair containing the both the translation distance and the new
scaled game.
+ Examples
+ --------
+
+ >>> from dunshire.matrices import norm
+ >>> from dunshire.options import ABS_TOL
+ >>> G = random_orthant_game()
+ >>> (alpha, H) = random_translation(G)
+ >>> G.K() == H.K()
+ True
+ >>> norm(G.e1() - H.e1()) < ABS_TOL
+ True
+ >>> norm(G.e2() - H.e2()) < ABS_TOL
+ True
+
"""
alpha = random_scalar()
- tensor_prod = G._e1 * G._e2.trans()
- M = G._L + alpha*tensor_prod
+ tensor_prod = G.e1() * G.e2().trans()
+ M = G.L() + alpha*tensor_prod
- H = SymmetricLinearGame(M.trans(), G._K, G._e1, G._e2)
+ H = SymmetricLinearGame(M.trans(), G.K(), G.e1(), G.e2())
while H.condition() > MAX_COND:
# Loop until the condition number of H doesn't suck.
alpha = random_scalar()
- M = G._L + alpha*tensor_prod
- H = SymmetricLinearGame(M.trans(), G._K, G._e1, G._e2)
+ M = G.L() + alpha*tensor_prod
+ H = SymmetricLinearGame(M.trans(), G.K(), G.e1(), G.e2())
return (alpha, H)
projects / dunshire.git / blobdiff