from sage.all import *
-def random_cone(min_dim=None, max_dim=None, min_rays=None, max_rays=None):
+def random_cone(min_dim=0, max_dim=None, min_rays=0, max_rays=None):
r"""
Generate a random rational convex polyhedral cone.
Lower and upper bounds may be provided for both the dimension of the
- ambient space and the number of generating rays of the cone. Any
- parameters left unspecified will be chosen randomly.
+ ambient space and the number of generating rays of the cone. If a
+ lower bound is left unspecified, it defaults to zero. Unspecified
+ upper bounds will be chosen randomly.
INPUT:
- - ``min_dim`` (default: random) -- The minimum dimension of the ambient
- lattice.
+ - ``min_dim`` (default: zero) -- A nonnegative integer representing the
+ minimum dimension of the ambient lattice.
- - ``max_dim`` (default: random) -- The maximum dimension of the ambient
+ - ``max_dim`` (default: random) -- A nonnegative integer representing
+ the maximum dimension of the ambient
lattice.
- - ``min_rays`` (default: random) -- The minimum number of generating rays
- of the cone.
+ - ``min_rays`` (default: zero) -- A nonnegative integer representing the
+ minimum number of generating rays of the
+ cone.
- - ``max_rays`` (default: random) -- The maximum number of generating rays
- of the cone.
+ - ``max_rays`` (default: random) -- A nonnegative integer representing the
+ maximum number of generating rays of the
+ cone.
OUTPUT:
A new, randomly generated cone.
+ EXAMPLES:
+
+ If we set the lower/upper bounds to zero, then our result is
+ predictable::
+
+ sage: random_cone(0,0,0,0)
+ 0-d cone in 0-d lattice N
+
+ In fact, as long as we ask for zero rays, we should be able to predict
+ the output when ``min_dim == max_dim``::
+
+ sage: random_cone(min_dim=4, max_dim=4, min_rays=0, max_rays=0)
+ 0-d cone in 4-d lattice N
+
TESTS:
It's hard to test the output of a random process, but we can at
least make sure that we get a cone back::
- sage: from sage.geometry.cone import is_Cone
- sage: K = random_cone()
- sage: is_Cone(K) # long time
+ sage: from sage.geometry.cone import is_Cone # long time
+ sage: K = random_cone() # long time
+ sage: is_Cone(K) # long time
True
+ Ensure that an exception is raised when either lower bound is greater
+ than its respective upper bound::
+
+ sage: random_cone(min_dim=5, max_dim=2)
+ Traceback (most recent call last):
+ ...
+ ValueError: max_dim must be greater than or equal to min_dim.
+
+ sage: random_cone(min_rays=5, max_rays=2)
+ Traceback (most recent call last):
+ ...
+ ValueError: max_rays must be greater than or equal to min_rays.
+
"""
+ # Catch obvious mistakes so that we can generate clear error
+ # messages.
+
+ if min_dim < 0:
+ raise ValueError('min_dim must be nonnegative.')
+
+ if min_rays < 0:
+ raise ValueError('min_rays must be nonnegative.')
+
+ if max_dim is not None:
+ if max_dim < 0:
+ raise ValueError('max_dim must be nonnegative.')
+ if (min_dim > max_dim):
+ raise ValueError('max_dim must be greater than or equal to min_dim.')
+
+ if max_rays is not None:
+ if max_rays < 0:
+ raise ValueError('max_rays must be nonnegative.')
+ if (min_rays > max_rays):
+ raise ValueError('max_rays must be greater than or equal to min_rays.')
+
+
def random_min_max(l,u):
r"""
- We need to handle four cases to prevent us from doing
- something stupid like having an upper bound that's lower than
- our lower bound. And we would need to repeat all of that logic
- for the dimension/rays, so we consolidate it here.
+ We need to handle two cases for the upper bounds, and we need to do
+ the same thing for max_dim/max_rays. So we consolidate the logic here.
"""
- if l is None and u is None:
- # They're both random, just return a random nonnegative
- # integer.
- return ZZ.random_element().abs()
-
- if l is not None and u is not None:
- # Both were specified. Again, just make up a number and
- # return it. If the user wants to give us u < l then he
- # can have an exception.
- return ZZ.random_element(l,u)
-
- if l is not None and u is None:
- # In this case, we're generating the upper bound randomly
- # GIVEN A LOWER BOUND. So we add a random nonnegative
- # integer to the given lower bound.
- u = l + ZZ.random_element().abs()
- return ZZ.random_element(l,u)
-
- # Here we must be in the only remaining case, where we are
- # given an upper bound but no lower bound. We might as well
- # use zero.
- return ZZ.random_element(0,u)
+ if u is None:
+ # The upper bound is unspecified; return a random integer
+ # in [l,infinity).
+ return l + ZZ.random_element().abs()
+ else:
+ # We have an upper bound, and it's greater than or equal
+ # to our lower bound. So we generate a random integer in
+ # [0,u-l], and then add it to l to get something in
+ # [l,u]. To understand the "+1", check the
+ # ZZ.random_element() docs.
+ return l + ZZ.random_element(u - l + 1)
+
d = random_min_max(min_dim, max_dim)
r = random_min_max(min_rays, max_rays)
L = ToricLattice(d)
rays = [L.random_element() for i in range(0,r)]
- # We pass the lattice in case there are no rays.
+ # The lattice parameter is required when no rays are given, so we
+ # pass it just in case.
return Cone(rays, lattice=L)
The complementarity set of the dual can be obtained by switching the
components of the complementarity set of the original cone::
- sage: K1 = random_cone(0,10,0,10)
+ sage: K1 = random_cone(max_dim=10, max_rays=10)
sage: K2 = K1.dual()
sage: expected = [(x,s) for (s,x) in discrete_complementarity_set(K2)]
sage: actual = discrete_complementarity_set(K1)
The Lyapunov rank should be additive on a product of cones::
- sage: K1 = random_cone(0,10,0,10)
- sage: K2 = random_cone(0,10,0,10)
+ sage: K1 = random_cone(max_dim=10, max_rays=10)
+ sage: K2 = random_cone(max_dim=10, max_rays=10)
sage: K = K1.cartesian_product(K2)
sage: lyapunov_rank(K) == lyapunov_rank(K1) + lyapunov_rank(K2)
True
The dual cone `K^{*}` of ``K`` should have the same Lyapunov rank as ``K``
itself::
- sage: K = random_cone(0,10,0,10)
+ sage: K = random_cone(max_dim=10, max_rays=10)
sage: lyapunov_rank(K) == lyapunov_rank(K.dual())
True
projects / sage.d.git / commitdiff