def __init__(self, projection_point):
"""
Create a stereographic projection function.
INPUT:
- ``projection_point`` -- a list of coordinates in the
appropriate dimension, which is the point projected from.
EXAMPLES::
sage: from sage.geometry.polyhedron.plot import ProjectionFuncStereographic
sage: proj = ProjectionFuncStereographic([1.0,1.0])
sage: proj.__init__([1.0,1.0])
sage: proj.house
[-0.7071067811... 0.7071067811...]
[ 0.7071067811... 0.7071067811...]
sage: TestSuite(proj).run(skip='_test_pickling')
"""
self.projection_point = vector(projection_point)
self.dim = self.projection_point.degree()
pproj = vector(RDF,self.projection_point)
self.psize = norm(pproj)
if (self.psize).is_zero():
raise ValueError, "projection direction must be a non-zero vector."
v = vector(RDF, [0.0]*(self.dim-1) + [self.psize]) - pproj
polediff = matrix(RDF,v).transpose()
denom = RDF((polediff.transpose()*polediff)[0][0])
if denom.is_zero():
self.house = identity_matrix(RDF,self.dim)
else:
self.house = identity_matrix(RDF,self.dim) \
- 2*polediff*polediff.transpose()/denom # Householder reflector
def Polyhedra(base_ring, ambient_dim, backend=None):
r"""
Construct a suitable parent class for polyhedra
INPUT:
- ``base_ring`` -- A ring. Currently there are backends for `\ZZ`,
`\QQ`, and `\RDF`.
- ``ambient_dim`` -- integer. The ambient space dimension.
- ``backend`` -- string. The name of the backend for computations. There are
several backends implemented:
* ``backend="ppl"`` uses the Parma Polyhedra Library
* ``backend="cdd"`` uses CDD
* ``backend="normaliz"`` uses normaliz
* ``backend="polymake"`` uses polymake
* ``backend="field"`` a generic Sage implementation
OUTPUT:
A parent class for polyhedra over the given base ring if the
backend supports it. If not, the parent base ring can be larger
(for example, `\QQ` instead of `\ZZ`). If there is no
implementation at all, a ``ValueError`` is raised.
EXAMPLES::
sage: from sage.geometry.polyhedron.parent import Polyhedra
sage: Polyhedra(AA, 3)
Polyhedra in AA^3
sage: Polyhedra(ZZ, 3)
Polyhedra in ZZ^3
sage: type(_)
<class 'sage.geometry.polyhedron.parent.Polyhedra_ZZ_ppl_with_category'>
sage: Polyhedra(QQ, 3, backend='cdd')
Polyhedra in QQ^3
sage: type(_)
<class 'sage.geometry.polyhedron.parent.Polyhedra_QQ_cdd_with_category'>
CDD does not support integer polytopes directly::
sage: Polyhedra(ZZ, 3, backend='cdd')
Polyhedra in QQ^3
TESTS::
sage: Polyhedra(RR, 3, backend='field')
Traceback (most recent call last):
...
ValueError: the 'field' backend for polyhedron can not be used with non-exact fields
sage: Polyhedra(RR, 3)
Traceback (most recent call last):
...
ValueError: no appropriate backend for computations with Real Field with 53 bits of precision
"""
if backend is None:
if base_ring is ZZ or base_ring is QQ:
backend = 'ppl'
elif base_ring is RDF:
backend = 'cdd'
elif base_ring.is_exact():
# TODO: find a more robust way of checking that the coefficients are indeed
# real numbers
if not RDF.has_coerce_map_from(base_ring):
raise ValueError("invalid base ring")
backend = 'field'
else:
raise ValueError("no appropriate backend for computations with {}".format(base_ring))
if backend == 'ppl' and base_ring is QQ:
return Polyhedra_QQ_ppl(base_ring, ambient_dim, backend)
elif backend == 'ppl' and base_ring is ZZ:
return Polyhedra_ZZ_ppl(base_ring, ambient_dim, backend)
elif backend == 'normaliz' and base_ring is QQ:
return Polyhedra_QQ_normaliz(base_ring, ambient_dim, backend)
elif backend == 'normaliz' and base_ring is ZZ:
return Polyhedra_ZZ_normaliz(base_ring, ambient_dim, backend)
elif backend == 'cdd' and base_ring in (ZZ, QQ):
return Polyhedra_QQ_cdd(QQ, ambient_dim, backend)
elif backend == 'cdd' and base_ring is RDF:
return Polyhedra_RDF_cdd(RDF, ambient_dim, backend)
elif backend == 'polymake':
return Polyhedra_polymake(base_ring.fraction_field(), ambient_dim, backend)
elif backend == 'field':
if not base_ring.is_exact():
raise ValueError("the 'field' backend for polyhedron can not be used with non-exact fields")
return Polyhedra_field(base_ring.fraction_field(), ambient_dim, backend)
else:
raise ValueError('No such backend (=' + str(backend) +
') implemented for given basering (=' + str(base_ring)+').')
def Polyhedra(base_ring, ambient_dim, backend=None):
r"""
Construct a suitable parent class for polyhedra
INPUT:
- ``base_ring`` -- A ring. Currently there are backends for `\ZZ`,
`\QQ`, and `\RDF`.
- ``ambient_dim`` -- integer. The ambient space dimension.
- ``backend`` -- string. The name of the backend for computations. There are
several backends implemented:
* ``backend="ppl"`` uses the Parma Polyhedra Library
* ``backend="cdd"`` uses CDD
* ``backend="normaliz"`` uses normaliz
* ``backend="polymake"`` uses polymake
* ``backend="field"`` a generic Sage implementation
OUTPUT:
A parent class for polyhedra over the given base ring if the
backend supports it. If not, the parent base ring can be larger
(for example, `\QQ` instead of `\ZZ`). If there is no
implementation at all, a ``ValueError`` is raised.
EXAMPLES::
sage: from sage.geometry.polyhedron.parent import Polyhedra
sage: Polyhedra(AA, 3)
Polyhedra in AA^3
sage: Polyhedra(ZZ, 3)
Polyhedra in ZZ^3
sage: type(_)
<class 'sage.geometry.polyhedron.parent.Polyhedra_ZZ_ppl_with_category'>
sage: Polyhedra(QQ, 3, backend='cdd')
Polyhedra in QQ^3
sage: type(_)
<class 'sage.geometry.polyhedron.parent.Polyhedra_QQ_cdd_with_category'>
CDD does not support integer polytopes directly::
sage: Polyhedra(ZZ, 3, backend='cdd')
Polyhedra in QQ^3
TESTS::
sage: Polyhedra(RR, 3, backend='field')
Traceback (most recent call last):
...
ValueError: the 'field' backend for polyhedron can not be used with non-exact fields
sage: Polyhedra(RR, 3)
Traceback (most recent call last):
...
ValueError: no default backend for computations with Real Field with 53 bits of precision
sage: Polyhedra(QQ[I], 2)
Traceback (most recent call last):
...
ValueError: invalid base ring: Number Field in I with defining polynomial x^2 + 1 with I = 1*I cannot be coerced to a real field
"""
if backend is None:
if base_ring is ZZ or base_ring is QQ:
backend = 'ppl'
elif base_ring is RDF:
backend = 'cdd'
elif base_ring.is_exact():
# TODO: find a more robust way of checking that the coefficients are indeed
# real numbers
if not RDF.has_coerce_map_from(base_ring):
raise ValueError(
"invalid base ring: {} cannot be coerced to a real field".
format(base_ring))
backend = 'field'
else:
raise ValueError(
"no default backend for computations with {}".format(
base_ring))
from sage.symbolic.ring import SR
if backend == 'ppl' and base_ring is QQ:
return Polyhedra_QQ_ppl(base_ring, ambient_dim, backend)
elif backend == 'ppl' and base_ring is ZZ:
return Polyhedra_ZZ_ppl(base_ring, ambient_dim, backend)
elif backend == 'normaliz' and base_ring is QQ:
return Polyhedra_QQ_normaliz(base_ring, ambient_dim, backend)
elif backend == 'normaliz' and base_ring is ZZ:
return Polyhedra_ZZ_normaliz(base_ring, ambient_dim, backend)
elif backend == 'normaliz' and (base_ring is SR or base_ring.is_exact()):
return Polyhedra_normaliz(base_ring, ambient_dim, backend)
elif backend == 'cdd' and base_ring in (ZZ, QQ):
return Polyhedra_QQ_cdd(QQ, ambient_dim, backend)
elif backend == 'cdd' and base_ring is RDF:
return Polyhedra_RDF_cdd(RDF, ambient_dim, backend)
elif backend == 'polymake':
return Polyhedra_polymake(base_ring.fraction_field(), ambient_dim,
backend)
elif backend == 'field':
if not base_ring.is_exact():
raise ValueError(
"the 'field' backend for polyhedron can not be used with non-exact fields"
)
return Polyhedra_field(base_ring.fraction_field(), ambient_dim,
backend)
else:
raise ValueError('No such backend (=' + str(backend) +
') implemented for given basering (=' +
str(base_ring) + ').')
# Distributed under the terms of the GNU General Public License (GPL)
# http://www.gnu.org/licenses/
#**************************************************************************************
from sage.groups.perm_gps.permgroup import PermutationGroup, PermutationGroup_generic
import random
from sage.structure.sage_object import SageObject
from sage.rings.all import RationalField, Integer, RDF
#from sage.matrix.all import MatrixSpace
from sage.interfaces.all import gap
from sage.groups.perm_gps.permgroup_element import PermutationGroupElement
from sage.plot.polygon import polygon
from sage.plot.text import text
pi = RDF.pi()
from sage.plot.plot3d.shapes import Box
from sage.plot.plot3d.texture import Texture
####################### predefined colors ##################
named_colors = {
'red': (1,0,0), ## F face
'green': (0,1,0), ## R face
'blue': (0,0,1), ## D face
'yellow': (1,1,0), ## L face
'white': (1,1,1), ## none
'orange': (1,0.6,0.3), ## B face
'purple': (1,0,1), ## none
'lpurple': (1,0.63,1), ## U face
def _sage_(self):
"""
Convert self to a Sage object.
EXAMPLES::
sage: a = axiom(1/2); a #optional - axiom
1
-
2
sage: a.sage() #optional - axiom
1/2
sage: _.parent() #optional - axiom
Rational Field
sage: gp(axiom(1/2)) #optional - axiom
1/2
sage: fricas(1/2).sage() #optional - fricas
1/2
DoubleFloat's in Axiom are converted to be in RDF in Sage.
::
sage: axiom(2.0).as_type('DoubleFloat').sage() #optional - axiom
2.0
sage: _.parent() #optional - axiom
Real Double Field
sage: axiom(2.1234)._sage_() #optional - axiom
2.12340000000000
sage: _.parent() #optional - axiom
Real Field with 53 bits of precision
sage: a = RealField(100)(pi)
sage: axiom(a)._sage_() #optional - axiom
3.1415926535897932384626433833
sage: _.parent() #optional - axiom
Real Field with 100 bits of precision
sage: axiom(a)._sage_() == a #optional - axiom
True
sage: axiom(2.0)._sage_() #optional - axiom
2.00000000000000
sage: _.parent() #optional - axiom
Real Field with 53 bits of precision
We can also convert Axiom's polynomials to Sage polynomials.
sage: a = axiom(x^2 + 1) #optional - axiom
sage: a.type() #optional - axiom
Polynomial Integer
sage: a.sage() #optional - axiom
x^2 + 1
sage: _.parent() #optional - axiom
Univariate Polynomial Ring in x over Integer Ring
sage: axiom('x^2 + y^2 + 1/2').sage() #optional - axiom
y^2 + x^2 + 1/2
sage: _.parent() #optional - axiom
Multivariate Polynomial Ring in y, x over Rational Field
"""
P = self._check_valid()
type = str(self.type())
if type in ["Type", "Domain"]:
return self._sage_domain()
if type == "Float":
from sage.rings.all import RealField, ZZ
prec = max(self.mantissa().length()._sage_(), 53)
R = RealField(prec)
x, e, b = self.unparsed_input_form().lstrip('float(').rstrip(
')').split(',')
return R(ZZ(x) * ZZ(b)**ZZ(e))
elif type == "DoubleFloat":
from sage.rings.all import RDF
return RDF(repr(self))
elif type.startswith('Polynomial'):
from sage.rings.all import PolynomialRing
base_ring = P(type.lstrip('Polynomial '))._sage_domain()
vars = str(self.variables())[1:-1]
R = PolynomialRing(base_ring, vars)
return R(self.unparsed_input_form())
#If all else fails, try using the unparsed input form
try:
import sage.misc.sage_eval
return sage.misc.sage_eval.sage_eval(self.unparsed_input_form())
except Exception:
raise NotImplementedError
def Polyhedra(ambient_space_or_base_ring=None,
ambient_dim=None,
backend=None,
*,
ambient_space=None,
base_ring=None):
r"""
Construct a suitable parent class for polyhedra
INPUT:
- ``base_ring`` -- A ring. Currently there are backends for `\ZZ`,
`\QQ`, and `\RDF`.
- ``ambient_dim`` -- integer. The ambient space dimension.
- ``ambient_space`` -- A free module.
- ``backend`` -- string. The name of the backend for computations. There are
several backends implemented:
* ``backend="ppl"`` uses the Parma Polyhedra Library
* ``backend="cdd"`` uses CDD
* ``backend="normaliz"`` uses normaliz
* ``backend="polymake"`` uses polymake
* ``backend="field"`` a generic Sage implementation
OUTPUT:
A parent class for polyhedra over the given base ring if the
backend supports it. If not, the parent base ring can be larger
(for example, `\QQ` instead of `\ZZ`). If there is no
implementation at all, a ``ValueError`` is raised.
EXAMPLES::
sage: from sage.geometry.polyhedron.parent import Polyhedra
sage: Polyhedra(AA, 3)
Polyhedra in AA^3
sage: Polyhedra(ZZ, 3)
Polyhedra in ZZ^3
sage: type(_)
<class 'sage.geometry.polyhedron.parent.Polyhedra_ZZ_ppl_with_category'>
sage: Polyhedra(QQ, 3, backend='cdd')
Polyhedra in QQ^3
sage: type(_)
<class 'sage.geometry.polyhedron.parent.Polyhedra_QQ_cdd_with_category'>
CDD does not support integer polytopes directly::
sage: Polyhedra(ZZ, 3, backend='cdd')
Polyhedra in QQ^3
Using a more general form of the constructor::
sage: V = VectorSpace(QQ, 3)
sage: Polyhedra(V) is Polyhedra(QQ, 3)
True
sage: Polyhedra(V, backend='field') is Polyhedra(QQ, 3, 'field')
True
sage: Polyhedra(backend='field', ambient_space=V) is Polyhedra(QQ, 3, 'field')
True
sage: M = FreeModule(ZZ, 2)
sage: Polyhedra(M, backend='ppl') is Polyhedra(ZZ, 2, 'ppl')
True
TESTS::
sage: Polyhedra(RR, 3, backend='field')
Traceback (most recent call last):
...
ValueError: the 'field' backend for polyhedron can not be used with non-exact fields
sage: Polyhedra(RR, 3)
Traceback (most recent call last):
...
ValueError: no default backend for computations with Real Field with 53 bits of precision
sage: Polyhedra(QQ[I], 2)
Traceback (most recent call last):
...
ValueError: invalid base ring: Number Field in I with defining polynomial x^2 + 1 with I = 1*I cannot be coerced to a real field
"""
if ambient_space_or_base_ring is not None:
if ambient_space_or_base_ring in Rings():
base_ring = ambient_space_or_base_ring
else:
ambient_space = ambient_space_or_base_ring
if ambient_space is not None:
if ambient_space not in Modules:
# There is no category of free modules, unfortunately
# (see https://trac.sagemath.org/ticket/30164)...
raise ValueError('ambient_space must be a free module')
if base_ring is None:
base_ring = ambient_space.base_ring()
if ambient_dim is None:
try:
ambient_dim = ambient_space.rank()
except AttributeError:
# ... so we test whether it is free using the existence of
# a rank method
raise ValueError('ambient_space must be a free module')
if ambient_space is not FreeModule(base_ring, ambient_dim):
raise NotImplementedError(
'ambient_space must be a standard free module')
if backend is None:
if base_ring is ZZ or base_ring is QQ:
backend = 'ppl'
elif base_ring is RDF:
backend = 'cdd'
elif base_ring.is_exact():
# TODO: find a more robust way of checking that the coefficients are indeed
# real numbers
if not RDF.has_coerce_map_from(base_ring):
raise ValueError(
"invalid base ring: {} cannot be coerced to a real field".
format(base_ring))
backend = 'field'
else:
raise ValueError(
"no default backend for computations with {}".format(
base_ring))
from sage.symbolic.ring import SR
if backend == 'ppl' and base_ring is QQ:
return Polyhedra_QQ_ppl(base_ring, ambient_dim, backend)
elif backend == 'ppl' and base_ring is ZZ:
return Polyhedra_ZZ_ppl(base_ring, ambient_dim, backend)
elif backend == 'normaliz' and base_ring is QQ:
return Polyhedra_QQ_normaliz(base_ring, ambient_dim, backend)
elif backend == 'normaliz' and base_ring is ZZ:
return Polyhedra_ZZ_normaliz(base_ring, ambient_dim, backend)
elif backend == 'normaliz' and (base_ring is SR or base_ring.is_exact()):
return Polyhedra_normaliz(base_ring, ambient_dim, backend)
elif backend == 'cdd' and base_ring in (ZZ, QQ):
return Polyhedra_QQ_cdd(QQ, ambient_dim, backend)
elif backend == 'cdd' and base_ring is RDF:
return Polyhedra_RDF_cdd(RDF, ambient_dim, backend)
elif backend == 'polymake':
return Polyhedra_polymake(base_ring.fraction_field(), ambient_dim,
backend)
elif backend == 'field':
if not base_ring.is_exact():
raise ValueError(
"the 'field' backend for polyhedron can not be used with non-exact fields"
)
return Polyhedra_field(base_ring.fraction_field(), ambient_dim,
backend)
else:
raise ValueError('No such backend (=' + str(backend) +
') implemented for given basering (=' +
str(base_ring) + ').')
# Distributed under the terms of the GNU General Public License (GPL)
# http://www.gnu.org/licenses/
#**************************************************************************************
from sage.groups.perm_gps.permgroup import PermutationGroup, PermutationGroup_generic
import random
from sage.structure.sage_object import SageObject
from sage.rings.all import RationalField, Integer, RDF
#from sage.matrix.all import MatrixSpace
from sage.interfaces.all import gap
from sage.groups.perm_gps.permgroup_element import PermutationGroupElement
from sage.plot.polygon import polygon
from sage.plot.text import text
pi = RDF.pi()
from sage.plot.plot3d.shapes import Box
from sage.plot.plot3d.texture import Texture
####################### predefined colors ##################
named_colors = {
'red': (1, 0, 0), ## F face
'green': (0, 1, 0), ## R face
'blue': (0, 0, 1), ## D face
'yellow': (1, 1, 0), ## L face
'white': (1, 1, 1), ## none
'orange': (1, 0.6, 0.3), ## B face
'purple': (1, 0, 1), ## none
'lpurple': (1, 0.63, 1), ## U face