schubmult 2.0.2__py3-none-any.whl → 2.0.3__py3-none-any.whl

schubmult/schubmult_q_double/_script.py

@@ -1,7 +1,12 @@
 import sys
 import numpy as np
-from ._vars import var_x, var2, var3, var2_t, var3_t
-from ._funcs import schubmult, schubmult_db, mult_poly, nil_hecke, factor_out_q_keep_factored
+from schubmult.schubmult_q_double._funcs import (
+    schubmult,
+    schubmult_db,
+    # mult_poly,
+    nil_hecke,
+    factor_out_q_keep_factored,
+)
 from schubmult.schubmult_double import compute_positive_rep, posify, div_diff
 from symengine import expand, sympify, symarray
 from schubmult.perm_lib import (
@@ -23,9 +28,40 @@ from schubmult.perm_lib import (
     omega,
 )
 from schubmult._base_argparse import schub_argparse
+from functools import cached_property
+
+
+class _gvars:
+    @cached_property
+    def n(self):
+        return 100
+
+    # @cached_property
+    # def fvar(self):
+    #     return 100
+
+    @cached_property
+    def var1(self):
+        return tuple(symarray("x", self.n).tolist())
+
+    @cached_property
+    def var2(self):
+        return tuple(symarray("y", self.n).tolist())
+
+    @cached_property
+    def var3(self):
+        return tuple(symarray("z", self.n).tolist())
+
+    @cached_property
+    def var_r(self):
+        return symarray("r", 100)
+
 
+_vars = _gvars()
 
-def _display_full(coeff_dict, args, formatter, posified=None, var2=var2, var3=var3):
+
+def _display_full(coeff_dict, args, formatter, posified=None, var2=_vars.var2, var3=_vars.var3):
+    raw_result_dict = {}
     mult = args.mult
 
     perms = args.perms
@@ -37,12 +73,17 @@ def _display_full(coeff_dict, args, formatter, posified=None, var2=var2, var3=va
     display_positive = args.display_positive
     expa = args.expa
     slow = args.slow
-    nilhecke_apply = False    
+    nilhecke_apply = False
+    subs_dict2 = {}
+    for i in range(1, 100):
+        sm = var2[1]
+        for j in range(1, i):
+            sm += _vars.var_r[j]
+        subs_dict2[var2[i]] = sm
 
     coeff_perms = list(coeff_dict.keys())
     coeff_perms.sort(key=lambda x: (inv(x), *x))
 
-    var_r = symarray("r", 100)
     for perm in coeff_perms:
         val = coeff_dict[perm]
         if expand(val) != 0:
@@ -50,81 +91,85 @@ def _display_full(coeff_dict, args, formatter, posified=None, var2=var2, var3=va
                 int(val)
             except Exception:
                 val2 = 0
-                if display_positive and not posified and not same:
+                if display_positive and not posified:
                     q_dict = factor_out_q_keep_factored(val)
                     for q_part in q_dict:
                         try:
                             val2 += q_part * int(q_dict[q_part])
                         except Exception:
-                            try:
-                                if len(perms) == 2:
-                                    u = tuple(permtrim([*perms[0]]))
-                                    v = tuple(permtrim([*perms[1]]))
-                                if (
-                                    len(perms) == 2
-                                    and code(inverse(perms[1])) == medium_theta(inverse(perms[1]))
-                                    and not mult
-                                    and not slow
-                                    and not nilhecke_apply
-                                ):
-                                    val2 += q_part * q_dict[q_part]
-                                else:
-                                    q_part2 = q_part
-                                    if not mult and not nilhecke_apply and len(perms) == 2:
-                                        qv = q_vector(q_part)
-                                        u2, v2, w2 = u, v, perm
-                                        u2, v2, w2, qv, did_one = reduce_q_coeff(u2, v2, w2, qv)
-                                        while did_one:
+                            if same:
+                                to_add = q_part * expand(sympify(q_dict[q_part]).xreplace(subs_dict2))
+                                val2 += to_add
+                            else:
+                                try:
+                                    if len(perms) == 2:
+                                        u = tuple(permtrim([*perms[0]]))
+                                        v = tuple(permtrim([*perms[1]]))
+                                    if (
+                                        len(perms) == 2
+                                        and code(inverse(perms[1])) == medium_theta(inverse(perms[1]))
+                                        and not mult
+                                        and not slow
+                                        and not nilhecke_apply
+                                    ):
+                                        val2 += q_part * q_dict[q_part]
+                                    else:
+                                        q_part2 = q_part
+                                        if not mult and not nilhecke_apply and len(perms) == 2:
+                                            qv = q_vector(q_part)
+                                            u2, v2, w2 = u, v, perm
                                             u2, v2, w2, qv, did_one = reduce_q_coeff(u2, v2, w2, qv)
-                                        q_part2 = np.prod(
-                                            [q_var[i + 1] ** qv[i] for i in range(len(qv))]
-                                        )
-                                        if q_part2 == 1:
-                                            # reduced to classical coefficient
-                                            val2 += q_part * posify(
-                                                q_dict[q_part],
-                                                u2,
-                                                v2,
-                                                w2,
-                                                var2_t,
-                                                var3_t,
-                                                msg,
-                                                False,
+                                            while did_one:
+                                                u2, v2, w2, qv, did_one = reduce_q_coeff(u2, v2, w2, qv)
+                                            q_part2 = np.prod(
+                                                [q_var[i + 1] ** qv[i] for i in range(len(qv))]
                                             )
+                                            if q_part2 == 1:
+                                                # reduced to classical coefficient
+                                                val2 += q_part * posify(
+                                                    q_dict[q_part],
+                                                    u2,
+                                                    v2,
+                                                    w2,
+                                                    var2,
+                                                    var3,
+                                                    msg,
+                                                    False,
+                                                )
+                                            else:
+                                                val2 += q_part * compute_positive_rep(
+                                                    q_dict[q_part],
+                                                    var2,
+                                                    var3,
+                                                    msg,
+                                                    False,
+                                                )
                                         else:
                                             val2 += q_part * compute_positive_rep(
                                                 q_dict[q_part],
-                                                var2_t,
-                                                var3_t,
+                                                var2,
+                                                var3,
                                                 msg,
                                                 False,
                                             )
+                                except Exception as e:
+                                    if mult:
+                                        print(
+                                            "warning; --display-positive is on but result is not positive",
+                                            file=sys.stderr,
+                                        )
+                                        val2 = val
+                                        break
                                     else:
-                                        val2 += q_part * compute_positive_rep(
-                                            q_dict[q_part],
-                                            var2_t,
-                                            var3_t,
-                                            msg,
-                                            False,
+                                        print(
+                                            f"error; write to schubmult@gmail.com with the case {perms=} {perm=} {val=} {coeff_dict.get(perm,0)=}"
                                         )
-                            except Exception as e:
-                                if mult:
-                                    print(
-                                        "warning; --display-positive is on but result is not positive",
-                                        file=sys.stderr,
-                                    )
-                                    val2 = val
-                                    break
-                                else:
-                                    print(
-                                        f"error; write to schubmult@gmail.com with the case {perms=} {perm=} {val=} {coeff_dict.get(perm,0)=}"
-                                    )
-                                    print(f"Exception: {e}")
-                                    import traceback
+                                        print(f"Exception: {e}")
+                                        import traceback
 
-                                    traceback.print_exc()
-                                    exit(1)
-                    if check and expand(val - val2) != 0:
+                                        traceback.print_exc()
+                                        exit(1)
+                    if not same and check and expand(val - val2) != 0:
                         if mult:
                             val2 = val
                         else:
@@ -133,26 +178,25 @@ def _display_full(coeff_dict, args, formatter, posified=None, var2=var2, var3=va
                             )
                             exit(1)
                     val = val2
-            if same and display_positive:
-                if same:
-                    subs_dict = {}
-                    for i in range(1, 100):
-                        sm = var2[1]
-                        for j in range(1, i):
-                            sm += var_r[j]
-                        subs_dict[var2[i]] = sm
-                    val = sympify(coeff_dict[perm]).subs(subs_dict)
-            elif expa:
+            if expa:
                 val = expand(val)
             if val != 0:
                 if ascode:
-                    print(f"{str(trimcode(perm))}  {formatter(val)}")
+                    raw_result_dict[tuple(trimcode(perm))] = val
+                    if formatter:
+                        print(f"{str(trimcode(perm))}  {formatter(val)}")
                 else:
-                    print(f"{str(perm)}  {formatter(val)}")
+                    raw_result_dict[tuple(perm)] = val
+                    if formatter:
+                        print(f"{str(perm)}  {formatter(val)}")
+    return raw_result_dict
 
 
-def main():
-    global var2, var3
+def main(argv=None):
+    if argv is None:
+        argv = sys.argv
+    var2 = tuple(symarray("y", 100))
+    var3 = tuple(symarray("z", 100))
     try:
         sys.setrecursionlimit(1000000)
 
@@ -161,17 +205,24 @@ def main():
             "Compute coefficients of products of quantum double Schubert polynomials in the same or different sets of coefficient variables",
             yz=True,
             quantum=True,
+            argv=argv[1:],
         )
+        subs_dict2 = {}
+        for i in range(1, 100):
+            sm = var2[1]
+            for j in range(1, i):
+                sm += _vars.var_r[j]
+            subs_dict2[var2[i]] = sm
 
-        mult = args.mult
-        mulstring = args.mulstring
+        mult = args.mult  # noqa: F841
+        mulstring = args.mulstring  # noqa: F841
 
         perms = args.perms
 
         ascode = args.ascode
         msg = args.msg
         display_positive = args.display_positive
-        pr = args.pr        
+        pr = args.pr
         parabolic_index = [int(s) for s in args.parabolic]
         parabolic = len(parabolic_index) != 0
         slow = args.slow
@@ -212,18 +263,18 @@ def main():
                     coeff_dict = schubmult_db(coeff_dict, perm, var2, var3)
                 else:
                     coeff_dict = schubmult(coeff_dict, perm, var2, var3)
-            if mult:
-                for v in var2:
-                    globals()[str(v)] = v
-                for v in var3:
-                    globals()[str(v)] = v
-                for v in var_x:
-                    globals()[str(v)] = v
-                for v in q_var:
-                    globals()[str(v)] = v
-
-                mul_exp = eval(mulstring)
-                coeff_dict = mult_poly(coeff_dict, mul_exp)
+                # if mult:
+                #     for v in var2:
+                #         globals()[str(v)] = v
+                #     for v in var3:
+                #         globals()[str(v)] = v
+                #     for v in var_x:
+                #         globals()[str(v)] = v
+                #     for v in q_var:
+                #         globals()[str(v)] = v
+
+                # mul_exp = eval(mulstring)
+                # coeff_dict = mult_poly(coeff_dict, mul_exp)
 
         posified = False
         if parabolic:
@@ -271,67 +322,77 @@ def main():
                     except Exception:
                         pass
                     q_val_part = q_dict[q_part]
-                    if display_positive and not same:
+                    if display_positive:
                         try:
                             q_val_part = int(q_val_part)
                         except Exception:
-                            try:
-                                if len(perms) == 2 and q_part == 1:
-                                    u = permtrim([*perms[0]])
-                                    v = permtrim([*perms[1]])
-                                    q_val_part = posify(
-                                        q_dict[q_part],
-                                        tuple(u),
-                                        tuple(v),
-                                        w_1,
-                                        var2_t,
-                                        var3_t,
-                                        msg,
-                                        False,
-                                    )
-                                else:
-                                    qv = q_vector(q_part)
-                                    u2, v2, w2 = perms[0], perms[1], w_1
-                                    u2, v2, w2, qv, did_one = reduce_q_coeff(u2, v2, w2, qv)
-                                    while did_one:
-                                        u2, v2, w2, qv, did_one = reduce_q_coeff(u2, v2, w2, qv)
-                                    q_part2 = np.prod(
-                                        [q_var[i + 1] ** qv[i] for i in range(len(qv))]
-                                    )
-                                    if q_part2 == 1:
+                            if same:
+                                q_val_part = expand(sympify(q_val_part).xreplace(subs_dict2))
+                            else:
+                                try:
+                                    if len(perms) == 2 and q_part == 1:
+                                        u = permtrim([*perms[0]])
+                                        v = permtrim([*perms[1]])
                                         q_val_part = posify(
                                             q_dict[q_part],
-                                            u2,
-                                            v2,
-                                            w2,
-                                            var2_t,
-                                            var3_t,
+                                            tuple(u),
+                                            tuple(v),
+                                            w_1,
+                                            var2,
+                                            var3,
                                             msg,
                                             False,
                                         )
                                     else:
-                                        q_val_part = compute_positive_rep(
-                                            q_dict[q_part],
-                                            var2_t,
-                                            var3_t,
-                                            msg,
-                                            False,
+                                        qv = q_vector(q_part)
+                                        u2, v2, w2 = perms[0], perms[1], w_1
+                                        u2, v2, w2, qv, did_one = reduce_q_coeff(u2, v2, w2, qv)
+                                        while did_one:
+                                            u2, v2, w2, qv, did_one = reduce_q_coeff(u2, v2, w2, qv)
+                                        q_part2 = np.prod(
+                                            [q_var[i + 1] ** qv[i] for i in range(len(qv))]
                                         )
-                            except Exception as e:
-                                print(
-                                    f"error; write to schubmult@gmail.com with the case {perms=} {perm=} {q_part*q_val_part=} {coeff_dict.get(w_1,0)=}"
-                                )
-                                print(f"Exception: {e}")
-                                exit(1)
-                    coeff_dict_update[w] = coeff_dict_update.get(w, 0) + new_q_part * q_val_part
+                                        if q_part2 == 1:
+                                            q_val_part = posify(
+                                                q_dict[q_part],
+                                                u2,
+                                                v2,
+                                                w2,
+                                                var2,
+                                                var3,
+                                                msg,
+                                                False,
+                                            )
+                                        else:
+                                            q_val_part = compute_positive_rep(
+                                                q_dict[q_part],
+                                                var2,
+                                                var3,
+                                                msg,
+                                                False,
+                                            )
+                                except Exception as e:
+                                    print(
+                                        f"error; write to schubmult@gmail.com with the case {perms=} {perm=} {q_part*q_val_part=} {coeff_dict.get(w_1,0)=}"
+                                    )
+                                    print(f"Exception: {e}")
+                                    exit(1)
+                            coeff_dict_update[w] = (
+                                coeff_dict_update.get(w, 0) + new_q_part * q_val_part
+                            )
 
             coeff_dict = coeff_dict_update
 
-        if pr:
-            _display_full(coeff_dict, args, formatter, posified)
+        raw_result_dict = {}
+        if pr or formatter is None:
+            raw_result_dict = _display_full(coeff_dict, args, formatter, posified)
+        if formatter is None:
+            return raw_result_dict
     except BrokenPipeError:
         pass
 
 
 if __name__ == "__main__":
-    main()
+    import sys
+
+    main(sys.argv)

{schubmult-2.0.2.dist-info → schubmult-2.0.3.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: schubmult
-Version: 2.0.2
+Version: 2.0.3
 Summary: Package for algebraic computation with single, double, and quantum Schubert polynomials
 Author-email: Matt Samuel <schubmult@gmail.com>
 Maintainer-email: Matt Samuel <schubmult@gmail.com>
@@ -18,7 +18,7 @@ Requires-Dist: sympy>=1.12
 Requires-Dist: psutil
 Requires-Dist: cachetools
 Requires-Dist: sortedcontainers
-Requires-Dist: setuptools>=71.0.0
+Requires-Dist: setuptools
 Provides-Extra: sage
 Requires-Dist: sagemath-standard; extra == "sage"
 Dynamic: license-file
@@ -207,8 +207,8 @@ This will install the [sagemath-standard](https://pypi.org/project/sagemath-stan
 ## Basic sage example
 
 ```python
-sage: from schubmult.sage_integration import FastSchubertPolynomial, FastDoubleSchubertPolynomialRing,
-FastQuantumSchubertPolynomial, FastQuantumDoubleSchubertPolynomialRing
+sage: from schubmult.sage_integration import FastSchubertPolynomialRing, FastDoubleSchubertPolynomialRing,
+FastQuantumSchubertPolynomialRing, FastQuantumDoubleSchubertPolynomialRing
 sage: SingleRing = FastSchubertPolynomialRing(ZZ, 100, "x")
 sage: SingleRing([3,4,1,2])
 Sx[3, 4, 1, 2]

schubmult-2.0.3.dist-info/RECORD

@@ -0,0 +1,30 @@
+schubmult/__init__.py,sha256=HFL2NgNf74s56viRPRlgp_rAmKP1MzrtnJeQ8LxF_8M,21
+schubmult/_base_argparse.py,sha256=m6Ffzb2Ec7kxdH_bH9iFtIOTjKR6bpyFXccPnviFlq4,6213
+schubmult/_tests.py,sha256=SmN_w9FsUDXZKttuzrfAeiP2zLUtF5M5pIH3DLoKOa8,260
+schubmult/perm_lib.py,sha256=Q2Z_8fIDzBE2Y-f9BMEqmxyxRWw-Auu2vuyjO02v5-k,31815
+schubmult/sage_integration/__init__.py,sha256=YMco9u--i3SYl4KXeO_EqS4zKIIqZo0mCVccm3KsbNk,799
+schubmult/sage_integration/_fast_double_schubert_polynomial_ring.py,sha256=RxzBGprT1fOeail4e6V90hMDrbM2RSJc4p5LvA8qDds,22068
+schubmult/sage_integration/_fast_schubert_polynomial_ring.py,sha256=Nv9lWTuUfPRTOAu_Ge-lTBa_2vzCoOZXpVIb-Txw6WE,14156
+schubmult/sage_integration/_indexing.py,sha256=EYRkGaOIwftC3huvto8toqdVrnjezdzmVhego6RDmQ4,2007
+schubmult/schubmult_double/__init__.py,sha256=Cc-yVBj53VXxe20KdyVdF-W1LsPU_mRutXUy6yN-xh4,307
+schubmult/schubmult_double/__main__.py,sha256=xi7dE5cpRZzkK-LVOGAGyaNDBdC-YGzUJJPcuB6T2rQ,99
+schubmult/schubmult_double/_funcs.py,sha256=znzIKO4yGw7LOTWc_yaiFGCoQQ8tGQScgeYeSrmtzQw,53819
+schubmult/schubmult_double/_script.py,sha256=i8HCnub_VGgCuolZiPNxFaNtYF2auUwyqVpew59eNtg,17360
+schubmult/schubmult_py/__init__.py,sha256=wdzFhh9fdNl_uSaPtyfXf1D6EfjJE7ycOoEkKi-8j8Y,142
+schubmult/schubmult_py/__main__.py,sha256=xi7dE5cpRZzkK-LVOGAGyaNDBdC-YGzUJJPcuB6T2rQ,99
+schubmult/schubmult_py/_funcs.py,sha256=tGmJTz3FT7AAL4iwnpBEXJhdTVbwlr3dY1ddJkWrnvo,4803
+schubmult/schubmult_py/_script.py,sha256=oiKOKLe8EicpesZTeFucJSuKoG-u7oceexCY6Fn0f9Q,3270
+schubmult/schubmult_q/__init__.py,sha256=OIDt8M_rWHZdKMl38NKyxCXJrBZhNiD0WpqxDjZU1Eg,141
+schubmult/schubmult_q/__main__.py,sha256=xi7dE5cpRZzkK-LVOGAGyaNDBdC-YGzUJJPcuB6T2rQ,99
+schubmult/schubmult_q/_funcs.py,sha256=tf1eNFs1gdrrmzut0CHMO675j518cGRjHiQYzkkRmbA,10131
+schubmult/schubmult_q/_script.py,sha256=ZznlsTfih_4MgFnTnpkLkaIm00lQwK2fvBjZr4hS-to,5018
+schubmult/schubmult_q_double/__init__.py,sha256=IGDsxBS5mHTbPXXJ6Pra9LUmIm2HfhnAAU0EJKxMOOc,255
+schubmult/schubmult_q_double/__main__.py,sha256=xi7dE5cpRZzkK-LVOGAGyaNDBdC-YGzUJJPcuB6T2rQ,99
+schubmult/schubmult_q_double/_funcs.py,sha256=HAD4DajZbGvmrAS66C9haUHA0B7Bdb4SN652GAeQgzY,19218
+schubmult/schubmult_q_double/_script.py,sha256=6bSkcpMoYjCktJzXz3N80as01teBtw4ZuAvJ5m6Vusw,16478
+schubmult-2.0.3.dist-info/licenses/LICENSE,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
+schubmult-2.0.3.dist-info/METADATA,sha256=MrrmzKDk_lc_WypnLh8HM-oR0v4LeROQ-JXGCKSyJSM,32373
+schubmult-2.0.3.dist-info/WHEEL,sha256=L0N565qmK-3nM2eBoMNFszYJ_MTx03_tQ0CQu1bHLYo,91
+schubmult-2.0.3.dist-info/entry_points.txt,sha256=_W_Xff08pmbrTZGBhRrU4n9jOIMaco9S_cqE17Tb4r4,240
+schubmult-2.0.3.dist-info/top_level.txt,sha256=IkujyjRu8lbpoSTdPE8DmMJ9sbyXHpo9L0RHL7nOzM0,10
+schubmult-2.0.3.dist-info/RECORD,,

{schubmult-2.0.2.dist-info → schubmult-2.0.3.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (77.0.3)
+Generator: setuptools (78.0.1)
 Root-Is-Purelib: true
 Tag: py3-none-any
 

schubmult-2.0.3.dist-info/entry_points.txt

@@ -0,0 +1,5 @@
+[console_scripts]
+schubmult_double = schubmult.schubmult_double._script:main
+schubmult_py = schubmult.schubmult_py._script:main
+schubmult_q = schubmult.schubmult_q._script:main
+schubmult_q_double = schubmult.schubmult_q_double._script:main

{schubmult-2.0.2.dist-info → schubmult-2.0.3.dist-info}/top_level.txt

@@ -1,2 +1 @@
 schubmult
-tests

schubmult/schubmult_double/_vars.py

@@ -1,18 +0,0 @@
-from symengine import symarray
-
-n = 100
-fvar = 0
-
-var = tuple(symarray("x", n).tolist())
-var2 = tuple(symarray("y", n).tolist())
-var3 = tuple(symarray("z", n).tolist())
-
-var_x = symarray("x", 100).tolist()
-var_y = var2
-var_z = var3
-
-x = var_x
-y = var_y
-z = var_z
-
-var_r = symarray("r", 100)

schubmult/schubmult_py/_vars.py

@@ -1,3 +0,0 @@
-from symengine import symarray
-
-var_x = symarray("x", 100).tolist()

schubmult/schubmult_q/_vars.py

@@ -1,18 +0,0 @@
-from symengine import symarray
-
-n = 100
-
-var = symarray("x", n)
-var2 = symarray("y", n)
-var3 = var2
-var_r = symarray("r", n)
-
-subs_dict = {}
-
-var_x = symarray("x", 100).tolist()
-
-for i in range(1, n):
-    sm = var_r[0]
-    for j in range(1, i):
-        sm += var_r[j]
-    subs_dict[var2[i]] = sm

schubmult/schubmult_q_double/_vars.py

@@ -1,21 +0,0 @@
-from symengine import symarray
-from schubmult.perm_lib import q_var
-
-var2 = symarray("y", 100)
-var3 = symarray("z", 100)
-
-var_y = var2.tolist()
-var_z = var3.tolist()
-var_x = symarray("x", 100).tolist()
-
-x = var_x
-y = var_y
-z = var_z
-
-q_var2 = q_var.tolist()
-
-var2_t = tuple(var2.tolist())
-var3_t = tuple(var3.tolist())
-
-n = 100
-

schubmult-2.0.2.dist-info/RECORD

@@ -1,36 +0,0 @@
-schubmult/__init__.py,sha256=xARS6PXiulA1Bog5UZUM6hqQfydeRzKLyWtOyUBL-Ss,21
-schubmult/_base_argparse.py,sha256=Gpr2rKcjmXH4Ufl84e0s7mX-ezDrMUZSUiZ5PPg2ndY,5523
-schubmult/perm_lib.py,sha256=Q2Z_8fIDzBE2Y-f9BMEqmxyxRWw-Auu2vuyjO02v5-k,31815
-schubmult/sage_integration/__init__.py,sha256=_EeNYfhM92qVbabAPJ9jdwedhD750D--EpIhWzkAP1o,797
-schubmult/sage_integration/_fast_double_schubert_polynomial_ring.py,sha256=mtlcjrqrOuJm0jXPlkDL49Kt3y4zalBZ7YcSgWBtsUw,20067
-schubmult/sage_integration/_fast_schubert_polynomial_ring.py,sha256=V2x2IEezPtNyn1Xh9KPW2Ajm1slRK_6i_CrGT9dDBK4,12957
-schubmult/sage_integration/_indexing.py,sha256=29zYqbylKJZz9XqYGfJXFfeaYa3ifXtxpEQIvAQEfI4,1576
-schubmult/schubmult_double/__init__.py,sha256=2-mZz_moyqcq1ncx7_YB6FNtztNycHZvGiJjtRlLPiE,256
-schubmult/schubmult_double/__main__.py,sha256=qhN6z5Evi4PakpzTM4wXHsYCSwfA0T-M2RYDzVcmNdE,91
-schubmult/schubmult_double/_funcs.py,sha256=XMf3b1RZEus10zM0zE1gQU8iHJIreYeAhEmNCVTVtds,51551
-schubmult/schubmult_double/_script.py,sha256=I_IAvlpVeleYJj3uaWe8-vZWLTfAvLRJ2WrU9vRnMgI,15180
-schubmult/schubmult_double/_vars.py,sha256=YjtEmP7TEx64WFq8PIE2Zfx62fOALGwynunnOapSKPI,290
-schubmult/schubmult_py/__init__.py,sha256=WCH_afeTqjjozAFkqJDyO1t62U0PRXsZF8r8JKNjs7s,102
-schubmult/schubmult_py/__main__.py,sha256=qhN6z5Evi4PakpzTM4wXHsYCSwfA0T-M2RYDzVcmNdE,91
-schubmult/schubmult_py/_funcs.py,sha256=G9nw3GNLIiY09Xq6L0nZVOwWx9C8q1FN2-7jhn-3_0M,3440
-schubmult/schubmult_py/_script.py,sha256=Y4qkqTaq1v0YZV3cUURUS9YIvRrwpeJWN3f59HrM3-g,3930
-schubmult/schubmult_py/_vars.py,sha256=10b7uZhrKg65eMdInI_74CMnhGOXMxInxhMqKbp_hco,68
-schubmult/schubmult_q/__init__.py,sha256=9RA1-qRIe1A5EumnXTygFrasdeJZHh9o-WESZJ9X3tw,140
-schubmult/schubmult_q/__main__.py,sha256=qhN6z5Evi4PakpzTM4wXHsYCSwfA0T-M2RYDzVcmNdE,91
-schubmult/schubmult_q/_funcs.py,sha256=RQZG-zKQtpjWmlxcSmvUzOBA6Vh0zWPq4muDqc2uTQE,10453
-schubmult/schubmult_q/_script.py,sha256=lRdScEcdSFPa8oJvxJkkfpnXPLTL3X6acbuGaRhvEEg,4870
-schubmult/schubmult_q/_vars.py,sha256=dU1f9CgMersgRpP9dld7ViRkyLA76sqx7ejq0JM1ECs,295
-schubmult/schubmult_q_double/__init__.py,sha256=WuCChjSQM5f7bzaHbyKOyCtdl8mBLav1T-ycGpY87Uc,254
-schubmult/schubmult_q_double/__main__.py,sha256=qhN6z5Evi4PakpzTM4wXHsYCSwfA0T-M2RYDzVcmNdE,91
-schubmult/schubmult_q_double/_funcs.py,sha256=cmxKSCkmBAan0W9FNXJA1NIZiK4iC7mrQJjDMXv8gbM,18388
-schubmult/schubmult_q_double/_script.py,sha256=dzTIljHMv7B-YUk6l99SxuUWRxpWW69k12xVZ17Q5QQ,14418
-schubmult/schubmult_q_double/_vars.py,sha256=JPL4kUPRtxkBJU9FkjA4mThNMbNVev5w_SmTcEsGvoM,329
-schubmult-2.0.2.dist-info/licenses/LICENSE,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
-tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-tests/test_fast_double_schubert.py,sha256=TGzjZ4kbsGpRncwHI-KNQlwOVo76ESQdCWuQxM3z0v4,4980
-tests/test_fast_schubert.py,sha256=cF1Wckg-FBycCxv0KYASIpAPQ7AOYqmtGJl9Q_puKXA,1315
-schubmult-2.0.2.dist-info/METADATA,sha256=Su5rRAogn-dOzhLLACjSm7Jd1ngrsbE3O_VbVjnlhu4,32373
-schubmult-2.0.2.dist-info/WHEEL,sha256=1tXe9gY0PYatrMPMDd6jXqjfpz_B-Wqm32CPfRC58XU,91
-schubmult-2.0.2.dist-info/entry_points.txt,sha256=FN_a2Ct5ZWBWWjST2GKx1h-VjU_c0UIkpnNeyevHPuo,244
-schubmult-2.0.2.dist-info/top_level.txt,sha256=zYdC9Gl5JX_FHOKDElw9g21WKiJTL2-cGBAXbC92Lo8,16
-schubmult-2.0.2.dist-info/RECORD,,

schubmult-2.0.2.dist-info/entry_points.txt

@@ -1,5 +0,0 @@
-[console_scripts]
-schubmult_double = schubmult.schubmult_double.__main__:main
-schubmult_py = schubmult.schubmult_py.__main__:main
-schubmult_q = schubmult.schubmult_q.__main__:main
-schubmult_q_double = schubmult.schubmult_q_double.__main__:main