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
-------
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
--------
"""
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 ``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
--------
"""
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 ``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
--------
"""
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
>>> (alpha, H) = random_nn_scaling(G)
>>> alpha >= 0
True
- >>> G._K == H._K
+ >>> G.K() == H.K()
True
- >>> norm(G._e1 - H._e1) < ABS_TOL
+ >>> norm(G.e1() - H.e1()) < ABS_TOL
True
- >>> norm(G._e2 - H._e2) < ABS_TOL
+ >>> 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)
>>> from dunshire.options import ABS_TOL
>>> G = random_orthant_game()
>>> (alpha, H) = random_translation(G)
- >>> G._K == H._K
+ >>> G.K() == H.K()
True
- >>> norm(G._e1 - H._e1) < ABS_TOL
+ >>> norm(G.e1() - H.e1()) < ABS_TOL
True
- >>> norm(G._e2 - H._e2) < ABS_TOL
+ >>> 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