def load_wrap(filename, attach=False):
"""
Encode a load or attach command as valid Python code.
INPUT:
- ``filename`` - a string; the argument to the load or attach
command
- ``attach`` - a boolean (default: False); whether to attach
``filename``, instead of loading it
OUTPUT:
- a string
EXAMPLES::
sage: sage.repl.load.load_wrap('foo.py', True)
'sage.repl.load.load(sage.repl.load.base64.b64decode("Zm9vLnB5"),globals(),True)'
sage: sage.repl.load.load_wrap('foo.sage')
'sage.repl.load.load(sage.repl.load.base64.b64decode("Zm9vLnNhZ2U="),globals(),False)'
sage: m = sage.repl.load.base64.b64decode("Zm9vLnNhZ2U=")
sage: m == b'foo.sage'
True
"""
# Note: In Python 3, b64encode only accepts bytes, and returns bytes.
b64 = base64.b64encode(str_to_bytes(filename, FS_ENCODING,
"surrogateescape"))
txt = 'sage.repl.load.load(sage.repl.load.base64.b64decode("{}"),globals(),{})'
return txt.format(bytes_to_str(b64, 'ascii'), attach)
def __call__(self, *args, **kwds):
"""
TESTS::
sage: from pGroupCohomology import CohomologyRing
sage: print(CohomologyRing(64,12)) # indirect doctest
Cohomology ring of Small Group number 12 of order 64 with coefficients in GF(2)
<BLANKLINE>
Computation complete
Minimal list of generators:
[b_2_1: 2-Cocycle in H^*(SmallGroup(64,12); GF(2)),
c_2_2: 2-Cocycle in H^*(SmallGroup(64,12); GF(2)),
c_2_3: 2-Cocycle in H^*(SmallGroup(64,12); GF(2)),
a_1_0: 1-Cocycle in H^*(SmallGroup(64,12); GF(2)),
b_1_1: 1-Cocycle in H^*(SmallGroup(64,12); GF(2))]
Minimal list of algebraic relations:
[a_1_0^2,
a_1_0*b_1_1,
b_2_1*a_1_0,
b_2_1*b_1_1^2+b_2_1^2]
"""
from sage.matrix.matrix_gfpn_dense import mtx_unpickle
# Input for mtx_unpickle is this:
# f, int nr, int nc, bytes Data, bint m
# Hence, we ignore kwds and deal with py2->py3 incompatibility.
f, nr, nc, Data, m = args
return mtx_unpickle(f, nr, nc, str_to_bytes(Data, encoding='latin1'),
m)
def _strhash(s):
"""
Implementation of the strhash function from binutils
See
https://sourceware.org/git/gitweb.cgi?p=binutils-gdb.git;a=blob;f=binutils/dllwrap.c;hb=d0e6d77b3fb64561ca66535f8ed6ca523eac923e#l449
This is used to re-implement support for --enable-auto-image-base with a
custom base address, which is currently broken in ld/binutils for PE32+
binaries.
TESTS::
sage: from sage.misc.cython import _strhash
sage: hex(_strhash('test.pyx'))
'0x3d99a20'
"""
s = str_to_bytes(s)
h = 0
l = len(s)
for c in s:
h += c + (c << 17)
h ^= h >> 2
h += l + (l << 17)
h ^= h >> 2
return h
def load_wrap(filename, attach=False):
"""
Encodes a load or attach command as valid Python code.
INPUT:
- ``filename`` - a string; the argument to the load or attach
command
- ``attach`` - a boolean (default: False); whether to attach
``filename``, instead of loading it
OUTPUT:
- a string
EXAMPLES::
sage: sage.repl.load.load_wrap('foo.py', True)
'sage.repl.load.load(sage.repl.load.base64.b64decode("Zm9vLnB5"),globals(),True)'
sage: sage.repl.load.load_wrap('foo.sage')
'sage.repl.load.load(sage.repl.load.base64.b64decode("Zm9vLnNhZ2U="),globals(),False)'
sage: m = sage.repl.load.base64.b64decode("Zm9vLnNhZ2U=")
sage: m == b'foo.sage'
True
"""
# Note: On Python 3 b64encode only accepts bytes, and returns bytes (yet
# b64decode does accept str, but always returns bytes)
b64 = base64.b64encode(str_to_bytes(filename, FS_ENCODING,
"surrogateescape"))
return 'sage.repl.load.load(sage.repl.load.base64.b64decode("{}"),globals(),{})'.format(
bytes_to_str(b64, 'ascii'), attach)
def iscc_card(arg):
r"""
EXAMPLES::
sage: from surface_dynamics import *
sage: from surface_dynamics.misc.iscc import iscc_card
sage: cd = CylinderDiagram('(0,1)-(0,2) (2)-(1)')
sage: iscc_card(cd) # optional - barvinok
'[w0, w1] -> { 1 : 0 <= w1 <= w0 }'
sage: r = RibbonGraph(faces='(0,2,4,6,7)(8,9,5,3,1)', edges='(0,1)(2,3)(4,5)(6,7)(8,9)')
sage: iscc_card(r) # optional - barvinok
'[b0, b1] -> { (((1 - 1/8 * b0) + 17/12 * b1 + 5/8 * b1^2 + 1/12 * b1^3) + 1/4 * floor((2b0)/4)) : (b0 + b1) mod 2 = 0 and 0 <= b1 <= -2 + b0; ((1 + 31/24 * b0 + 5/8 * b0^2 + 1/12 * b0^3) + 1/4 * floor((2b0)/4)) : (b0 + b1) mod 2 = 0 and b0 >= 0 and b1 >= b0 }'
"""
from surface_dynamics.flat_surfaces.separatrix_diagram import CylinderDiagram
from surface_dynamics.flat_surfaces.homology import RibbonGraph
if isinstance(arg, CylinderDiagram):
poly = iscc_cd_string(arg)
elif isinstance(arg, RibbonGraph):
poly = iscc_rg_string(arg)
from subprocess import Popen, PIPE
cmd = 'P := {};\n'.format(poly)
cmd += 'q := card P;\n'
cmd += 'q;'
proc = Popen(['iscc'], stdin=PIPE, stdout=PIPE, stderr=PIPE)
ans, err = proc.communicate(str_to_bytes(cmd))
return bytes_to_str(ans).strip()
def is_functional(self):
r"""
Test whether ``lrs`` works on a trivial input.
EXAMPLES::
sage: from sage.features.lrs import Lrs
sage: Lrs().is_functional() # optional: lrslib
FeatureTestResult('lrslib', True)
"""
from sage.misc.temporary_file import tmp_filename
tf_name = tmp_filename()
with open(tf_name, 'wb') as tf:
tf.write(str_to_bytes("V-representation\nbegin\n 1 1 rational\n 1 \nend\nvolume"))
devnull = open(os.devnull, 'wb')
command = ['lrs', tf_name]
try:
lines = bytes_to_str(subprocess.check_output(command, stderr=devnull))
except subprocess.CalledProcessError as e:
return FeatureTestResult(self, False,
reason="Call to `{command}` failed with exit code {e.returncode}.".format(command=" ".join(command), e=e))
expected_list = ["Volume= 1", "Volume=1"]
if all(lines.find(expected) == -1 for expected in expected_list):
print(lines)
return FeatureTestResult(self, False,
reason="Output of `{command}` did not contain the expected result {expected}.".format(
command=" ".join(command),
expected=" or ".join(expected_list)))
return FeatureTestResult(self, True)
def integrate(arg,
polynomial=None,
algorithm='triangulate',
raw_output=False,
verbose=False,
**kwds):
r"""
Call to the function integrate from LattE integrale.
INPUT:
- ``arg`` -- a cdd or LattE description string.
- ``polynomial`` -- multivariate polynomial or valid LattE polynomial description string.
If given, the valuation parameter of LattE is set to integrate, and is set to volume otherwise.
- ``algorithm`` -- (default: 'triangulate') the integration method. Use 'triangulate' for
polytope triangulation or 'cone-decompose' for tangent cone decomposition method.
- ``raw_output`` -- if ``True`` then return directly the output string from LattE.
- ``verbose`` -- if ``True`` then return directly verbose output from LattE.
- For all other options of the integrate program, consult the LattE manual.
OUTPUT:
Either a string (if ``raw_output`` if set to ``True``) or a rational.
EXAMPLES::
sage: from sage.interfaces.latte import integrate # optional - latte_int
sage: P = 2 * polytopes.cube()
sage: x, y, z = polygen(QQ, 'x, y, z')
Integrating over a polynomial over a polytope in either the H or V representation::
sage: integrate(P.cdd_Hrepresentation(), x^2*y^2*z^2, cdd=True) # optional - latte_int
4096/27
sage: integrate(P.cdd_Vrepresentation(), x^2*y^2*z^2, cdd=True) # optional - latte_int
4096/27
Computing the volume of a polytope in either the H or V representation::
sage: integrate(P.cdd_Hrepresentation(), cdd=True) # optional - latte_int
64
sage: integrate(P.cdd_Vrepresentation(), cdd=True) # optional - latte_int
64
Polynomials given as a string in LattE description are also accepted::
sage: integrate(P.cdd_Hrepresentation(), '[[1,[2,2,2]]]', cdd=True) # optional - latte_int
4096/27
TESTS:
Testing raw output::
sage: from sage.interfaces.latte import integrate # optional - latte_int
sage: P = polytopes.cuboctahedron()
sage: cddin = P.cdd_Vrepresentation()
sage: x, y, z = polygen(QQ, 'x, y, z')
sage: f = 3*x^2*y^4*z^6 + 7*y^3*z^5
sage: integrate(cddin, f, cdd=True, raw_output=True) # optional - latte_int
'629/47775'
Testing the ``verbose`` option to integrate over a polytope::
sage: ans = integrate(cddin, f, cdd=True, verbose=True, raw_output=True) # optional - latte_int
This is LattE integrale ...
...
Invocation: integrate --valuation=integrate --triangulate --redundancy-check=none --cdd --monomials=... /dev/stdin
...
Testing triangulate algorithm::
sage: from sage.interfaces.latte import integrate # optional - latte_int
sage: P = polytopes.cuboctahedron()
sage: cddin = P.cdd_Vrepresentation()
sage: integrate(cddin, algorithm='triangulate', cdd=True) # optional - latte_int
20/3
Testing convex decomposition algorithm::
sage: from sage.interfaces.latte import integrate # optional - latte_int
sage: P = polytopes.cuboctahedron()
sage: cddin = P.cdd_Vrepresentation()
sage: integrate(cddin, algorithm='cone-decompose', cdd=True) # optional - latte_int
20/3
Testing raw output::
sage: from sage.interfaces.latte import integrate # optional - latte_int
sage: P = polytopes.cuboctahedron()
sage: cddin = P.cdd_Vrepresentation()
sage: integrate(cddin, cdd=True, raw_output=True) # optional - latte_int
'20/3'
Testing polynomial given as a string in LattE description::
sage: from sage.interfaces.latte import integrate # optional - latte_int
sage: P = polytopes.cuboctahedron()
sage: integrate(P.cdd_Hrepresentation(), '[[3,[2,4,6]],[7,[0, 3, 5]]]', cdd=True) # optional - latte_int
629/47775
Testing the ``verbose`` option to compute the volume of a polytope::
sage: from sage.interfaces.latte import integrate # optional - latte_int
sage: P = polytopes.cuboctahedron()
sage: cddin = P.cdd_Vrepresentation()
sage: ans = integrate(cddin, cdd=True, raw_output=True, verbose=True) # optional - latte_int
This is LattE integrale ...
...
Invocation: integrate --valuation=volume --triangulate --redundancy-check=none --cdd /dev/stdin
...
Testing the runtime error::
sage: P = Polyhedron(rays=[[1,0],[0,1]])
sage: P._volume_latte() # optional - latte_int
Traceback (most recent call last):
...
RuntimeError: LattE integrale program failed (exit code -6):
This is LattE integrale ...
...
determinant: nonsquare matrix
"""
# Check that LattE is present
Latte().require()
arg = str_to_bytes(arg)
from sage.rings.rational import Rational
args = ['integrate']
got_polynomial = True if polynomial is not None else False
if got_polynomial:
args.append('--valuation=integrate')
else:
args.append('--valuation=volume')
if algorithm == 'triangulate':
args.append('--triangulate')
elif algorithm == 'cone-decompose':
args.append('--cone-decompose')
if 'redundancy_check' not in kwds:
args.append('--redundancy-check=none')
for key, value in kwds.items():
if value is None or value is False:
continue
key = key.replace('_', '-')
if value is True:
args.append('--{}'.format(key))
else:
args.append('--{}={}'.format(key, value))
if got_polynomial:
if not isinstance(polynomial, str):
# transform polynomial to LattE description
monomials_list = to_latte_polynomial(polynomial)
else:
monomials_list = str(polynomial)
from sage.misc.temporary_file import tmp_filename
filename_polynomial = tmp_filename()
with open(filename_polynomial, 'w') as f:
f.write(monomials_list)
args += ['--monomials=' + filename_polynomial]
args += ['/dev/stdin']
# The cwd argument is needed because latte
# always produces diagnostic output files.
latte_proc = Popen(args,
stdin=PIPE,
stdout=PIPE,
stderr=(None if verbose else PIPE),
cwd=str(SAGE_TMP))
ans, err = latte_proc.communicate(arg)
if err:
err = bytes_to_str(err)
ret_code = latte_proc.poll()
if ret_code:
if err is None:
err = ", see error message above"
else:
err = ":\n" + err
raise RuntimeError(
"LattE integrale program failed (exit code {})".format(ret_code) +
err.strip())
ans = bytes_to_str(ans)
ans = ans.splitlines()
ans = ans[-5].split()
assert (ans[0] == 'Answer:')
ans = ans[1]
if raw_output:
return ans
else:
return Rational(ans)
def count(arg,
ehrhart_polynomial=False,
multivariate_generating_function=False,
raw_output=False,
verbose=False,
**kwds):
r"""
Call to the program count from LattE integrale
INPUT:
- ``arg`` -- a cdd or LattE description string
- ``ehrhart_polynomial``, ``multivariate_generating_function`` -- to
compute Ehrhart polynomial or multivariate generating function instead of
just counting points
- ``raw_output`` -- if ``True`` then return directly the output string from LattE
- For all other options of the count program, consult the LattE manual
OUTPUT:
Either a string (if ``raw_output`` if set to ``True``) or an integer (when
counting points), or a polynomial (if ``ehrhart_polynomial`` is set to
``True``) or a multivariate THING (if ``multivariate_generating_function``
is set to ``True``)
EXAMPLES::
sage: from sage.interfaces.latte import count # optional - latte_int
sage: P = 2 * polytopes.cube()
Counting integer points from either the H or V representation::
sage: count(P.cdd_Hrepresentation(), cdd=True) # optional - latte_int
125
sage: count(P.cdd_Vrepresentation(), cdd=True) # optional - latte_int
125
Ehrhart polynomial::
sage: count(P.cdd_Hrepresentation(), cdd=True, ehrhart_polynomial=True) # optional - latte_int
64*t^3 + 48*t^2 + 12*t + 1
Multivariate generating function currently only work with ``raw_output=True``::
sage: opts = {'cdd': True,
....: 'multivariate_generating_function': True,
....: 'raw_output': True}
sage: cddin = P.cdd_Hrepresentation()
sage: print(count(cddin, **opts)) # optional - latte_int
x[0]^2*x[1]^(-2)*x[2]^(-2)/((1-x[1])*(1-x[2])*(1-x[0]^(-1)))
+ x[0]^(-2)*x[1]^(-2)*x[2]^(-2)/((1-x[1])*(1-x[2])*(1-x[0]))
+ x[0]^2*x[1]^(-2)*x[2]^2/((1-x[1])*(1-x[2]^(-1))*(1-x[0]^(-1)))
+ x[0]^(-2)*x[1]^(-2)*x[2]^2/((1-x[1])*(1-x[0])*(1-x[2]^(-1)))
+ x[0]^2*x[1]^2*x[2]^(-2)/((1-x[2])*(1-x[1]^(-1))*(1-x[0]^(-1)))
+ x[0]^(-2)*x[1]^2*x[2]^(-2)/((1-x[2])*(1-x[0])*(1-x[1]^(-1)))
+ x[0]^2*x[1]^2*x[2]^2/((1-x[2]^(-1))*(1-x[1]^(-1))*(1-x[0]^(-1)))
+ x[0]^(-2)*x[1]^2*x[2]^2/((1-x[0])*(1-x[2]^(-1))*(1-x[1]^(-1)))
TESTS:
Testing raw output::
sage: from sage.interfaces.latte import count # optional - latte_int
sage: P = polytopes.cuboctahedron()
sage: cddin = P.cdd_Vrepresentation()
sage: count(cddin, cdd=True, raw_output=True) # optional - latte_int
'19'
sage: count(cddin, cdd=True, raw_output=True, ehrhart_polynomial=True) # optional - latte_int
' + 1 * t^0 + 10/3 * t^1 + 8 * t^2 + 20/3 * t^3'
sage: count(cddin, cdd=True, raw_output=True, multivariate_generating_function=True) # optional - latte_int
'x[0]^(-1)*x[1]^(-1)/((1-x[0]*x[2])*(1-x[0]^(-1)*x[1])*...x[0]^(-1)*x[2]^(-1)))\n'
Testing the ``verbose`` option::
sage: n = count(cddin, cdd=True, verbose=True, raw_output=True) # optional - latte_int
This is LattE integrale ...
...
Invocation: count '--redundancy-check=none' --cdd /dev/stdin
...
Total Unimodular Cones: ...
Maximum number of simplicial cones in memory at once: ...
<BLANKLINE>
**** The number of lattice points is: ****
Total time: ... sec
Trivial input for which LattE's preprocessor does all the work::
sage: P = Polyhedron(vertices=[[0,0,0]])
sage: cddin = P.cdd_Hrepresentation()
sage: count(cddin, cdd=True, raw_output=False) # optional - latte_int
1
Testing the runtime error::
sage: P = Polyhedron(rays=[[0,1], [1,0]])
sage: cddin = P.cdd_Hrepresentation()
sage: count(cddin, cdd=True, raw_output=False) # optional - latte_int
Traceback (most recent call last):
...
RuntimeError: LattE integrale program failed (exit code 1):
This is LattE integrale ...
...
The polyhedron is unbounded.
"""
# Check that LattE is present
Latte().require()
arg = str_to_bytes(arg)
args = ['count']
if ehrhart_polynomial and multivariate_generating_function:
raise ValueError
if ehrhart_polynomial:
args.append('--ehrhart-polynomial')
elif multivariate_generating_function:
args.append('--multivariate-generating-function')
if 'redundancy_check' not in kwds:
args.append('--redundancy-check=none')
for key, value in kwds.items():
if value is None or value is False:
continue
key = key.replace('_', '-')
if value is True:
args.append('--{}'.format(key))
else:
args.append('--{}={}'.format(key, value))
if multivariate_generating_function:
from sage.misc.temporary_file import tmp_filename
filename = tmp_filename()
with open(filename, 'w') as f:
f.write(bytes_to_str(arg))
args += [filename]
else:
args += ['/dev/stdin']
# The cwd argument is needed because latte
# always produces diagnostic output files.
latte_proc = Popen(args,
stdin=PIPE,
stdout=PIPE,
stderr=(None if verbose else PIPE),
cwd=str(SAGE_TMP))
ans, err = latte_proc.communicate(arg)
if err:
err = bytes_to_str(err)
ret_code = latte_proc.poll()
if ret_code:
if err is None:
err = ", see error message above"
else:
err = ":\n" + err
raise RuntimeError(
"LattE integrale program failed (exit code {})".format(ret_code) +
err.strip())
ans = bytes_to_str(ans)
if ehrhart_polynomial:
ans = ans.splitlines()[-2]
if raw_output:
return ans
else:
from sage.rings.polynomial.polynomial_ring_constructor import PolynomialRing
from sage.rings.rational_field import QQ
R = PolynomialRing(QQ, 't')
return R(ans)
elif multivariate_generating_function:
with open(filename + '.rat') as f:
ans = f.read()
if raw_output:
return ans
else:
raise NotImplementedError(
"there is no Sage object to handle multivariate series from LattE, use raw_output=True"
)
else:
if ans: # Sometimes (when LattE's preproc does the work), no output appears on stdout.
ans = ans.splitlines()[-1]
if not ans:
# opening a file is slow (30e-6s), so we read the file
# numOfLatticePoints only in case of a IndexError above
with open(SAGE_TMP + '/numOfLatticePoints', 'r') as f:
ans = f.read()
if raw_output:
return ans
else:
return Integer(ans)
def __call__(self, action, input=None, options=[], verbose=False):
r"""
This function calls Frobby as a command line program using streams
for input and output. Strings passed as part of the command get
broken up at whitespace. This is not done to the data passed
via the streams.
INPUT:
- action -- A string telling Frobby what to do.
- input -- None or a string that is passed to Frobby as standard in.
- options -- A list of options without the dash in front.
- verbose -- bool (default: false) Print detailed information.
OUTPUT:
- string -- What Frobby wrote to the standard output stream.
EXAMPLES:
We compute the lcm of an ideal provided in Monos format. ::
sage: frobby("analyze", input="vars x,y,z;[x^2,x*y];", # optional - frobby
....: options=["lcm", "iformat monos", "oformat 4ti2"]) # optional - frobby
' 2 1 0\n\n2 generators\n3 variables\n'
We get an exception if frobby reports an error. ::
sage: frobby("do_dishes") # optional - frobby
Traceback (most recent call last):
...
RuntimeError: Frobby reported an error:
ERROR: No action has the prefix "do_dishes".
AUTHOR:
- Bjarke Hammersholt Roune (2008-04-27)
"""
command = ['frobby'] + action.split()
for option in options:
command += ('-' + option.strip()).split()
if verbose:
print("Frobby action: ", action)
print("Frobby options: ", repr(options))
print("Frobby command: ", repr(command))
print("Frobby input:\n", input)
process = Popen(command, stdin=PIPE, stdout=PIPE, stderr=PIPE)
if input:
frinput = str_to_bytes(input)
else:
frinput = None
output, err = process.communicate(input=frinput)
output = bytes_to_str(output)
err = bytes_to_str(err)
if verbose:
print("Frobby output:\n", output)
print("Frobby error:\n", err)
if process.poll() != 0:
raise RuntimeError("Frobby reported an error:\n" + err)
return output
def _crunch_c(args):
argc = int(len(args))
argv = (ctypes.c_char_p * int(argc))()
for i in range(argc):
argv[i] = str_to_bytes(args[i])
return common.libcrunch.crunch(argc, argv)
