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)