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

schubmult/schubmult_py/_script.py

@@ -1,7 +1,5 @@
-from ._funcs import (
-    mult_poly,
-    schubmult,
-)
+from schubmult.schubmult_py._funcs import mult_poly, schubmult, schub_coprod
+import sys
 from symengine import sympify
 from schubmult._base_argparse import schub_argparse
 from schubmult.perm_lib import (
@@ -9,16 +7,18 @@ from schubmult.perm_lib import (
     theta,
     permtrim,
     inv,
-    mulperm,
-    code,
     uncode,
     trimcode,
 )
 
 
-def main():
+def main(argv=None):
+    if argv is None:
+        argv = sys.argv
     try:
-        args, formatter = schub_argparse("schubmult_py", "Compute products of ordinary Schubert polynomials")
+        args, formatter = schub_argparse(
+            "schubmult_py", "Compute products of ordinary Schubert polynomials", argv=argv[1:]
+        )
 
         mult = args.mult
         mulstring = args.mulstring
@@ -36,55 +36,30 @@ def main():
         ascode = args.ascode
         pr = args.pr
         coprod = args.coprod
-
+        raw_result_dict = {}
         if coprod:
             if ascode:
                 perms[0] = tuple(permtrim(uncode(perms[0])))
             pos = [*perms[1]]
             pos.sort()
-            mperm = perms[0]
+            mperm = tuple(permtrim(perms[0]))
 
-            cd = code(mperm)
-            perms[0] = mperm
+            coeff_dict = schub_coprod(mperm, pos)
 
-            while cd[-1] == 0:
-                cd.pop()
-            k = len(pos)
-            n = len(perms[0])
-            kcd = [pos[i] - i - 1 for i in range(len(pos))] + [n + 1 - k for i in range(k, n)]
-            N = len(kcd)
-            kperm = inverse(uncode(kcd))
-            coeff_dict = {tuple(permtrim(kperm)): 1}
-            coeff_dict = schubmult(coeff_dict, tuple(permtrim([*perms[0]])))
-
-            inv_kperm = inv(kperm)
-            inverse_kperm = inverse(kperm)
-            if pr:
-                for perm, val in coeff_dict.items():
-                    downperm = mulperm(list(perm), inverse_kperm)
-                    if inv(downperm) == inv(perm) - inv_kperm:
-                        flag = True
-                        for i in range(N):
-                            if downperm[i] > N:
-                                flag = False
-                                break
-                        if not flag:
-                            continue
-                        firstperm = downperm[0:N]
-                        secondperm = [downperm[i] - N for i in range(N, len(downperm))]
-                        if val != 0:
-                            # firstcode = code(firstperm)
-                            # while len(firstcode)>0 and firstcode[-1] == 0:
-                            # firstcode.pop()
-                            # secondcode = code(secondperm)
-                            # while len(secondcode)>0 and secondcode[-1] == 0:
-                            # secondcode.pop()
-                            if ascode:
+            if pr or formatter is None:
+                for firstperm, secondperm in coeff_dict:
+                    val = coeff_dict[(firstperm, secondperm)]
+                    if val != 0:
+                        if ascode:
+                            if formatter is None:
+                                raw_result_dict[(firstperm, secondperm)] = val
+                            else:
                                 print(f"{val} {trimcode(firstperm)} {trimcode(secondperm)}")
+                        else:
+                            if formatter is None:
+                                raw_result_dict[(firstperm, secondperm)] = val
                             else:
-                                print(
-                                    f"{val} {tuple(permtrim(firstperm))} {tuple(permtrim(secondperm))}"
-                                )
+                                print(f"{val} {firstperm} {secondperm}")
         else:
             if ascode:
                 for i in range(len(perms)):
@@ -100,16 +75,22 @@ def main():
                 mul_exp = sympify(mulstring)
                 coeff_dict = mult_poly(coeff_dict, mul_exp)
 
-            if pr:
+            if pr or formatter is None:
                 for perm, val in coeff_dict.items():
                     if val != 0:
                         if ascode:
-                            print(f"{val}  {trimcode(perm)}")
+                            raw_result_dict[tuple(trimcode(perm))] = val
+                            if formatter:
+                                print(f"{val}  {trimcode(perm)}")
                         else:
-                            print(f"{val}  {perm}")
+                            raw_result_dict[tuple(perm)] = val
+                            if formatter:
+                                print(f"{val}  {perm}")
+        if formatter is None:
+            return raw_result_dict
     except BrokenPipeError:
         pass
 
 
 if __name__ == "__main__":
-    main()
+    main(sys.argv)

schubmult/schubmult_q/__init__.py

@@ -10,3 +10,4 @@ __all__ = [
     "schubmult_db",
     "mult_poly"
 ]
+

schubmult/schubmult_q/__main__.py

@@ -2,4 +2,4 @@ import sys
 from ._script import main
 
 if __name__ == "__main__":
-    sys.exit(main())
+    sys.exit(main(sys.argv))

schubmult/schubmult_q/_funcs.py

@@ -1,7 +1,4 @@
-from ._vars import (
-    var_x,
-)
-from symengine import Add, Mul, Pow
+from symengine import Add, Mul, Pow, symarray
 from schubmult.perm_lib import (
     elem_sym_perms_q,
     add_perm_dict,
@@ -14,41 +11,28 @@ from schubmult.perm_lib import (
     mulperm,
     code,
     uncode,
-    double_elem_sym_q,
-    q_var,
+    double_elem_sym_q,    
 )
 
-# from symengine import sympify, Add, Mul, Pow, symarray, Symbol, expand
-# from schubmult._base_argparse import schub_argparse
-# from schubmult.perm_lib import (
-#     trimcode,
-#     elem_sym_perms_q,
-#     add_perm_dict,
-#     compute_vpathdicts,
-#     inverse,
-#     strict_theta,
-#     medium_theta,
-#     permtrim,
-#     inv,
-#     mulperm,
-#     code,
-#     uncode,
-#     double_elem_sym_q,
-#     longest_element,
-#     check_blocks,
-#     is_parabolic,
-#     q_vector,
-#     omega,
-#     count_less_than,
-#     q_var,
-#     sg,
-#     n,
-# )
-# import numpy as np
-# from schubmult.schubmult_q_double import factor_out_q_keep_factored
+from functools import cached_property
+
+
+class _gvars:
+    @cached_property
+    def n(self):
+        return 100
+    
+    @cached_property
+    def var_x(self):
+        return tuple(symarray("x", self.n).tolist())
+
+    @cached_property
+    def q_var(self):
+        return tuple(symarray("q", self.n).tolist())
 
+_vars = _gvars()
 
-def single_variable(coeff_dict, varnum, var_q=q_var):
+def single_variable(coeff_dict, varnum, var_q=_vars.q_var):
     ret = {}
     for u in coeff_dict:
         new_perms_k = elem_sym_perms_q(u, 1, varnum, var_q)
@@ -64,7 +48,7 @@ def single_variable(coeff_dict, varnum, var_q=q_var):
     return ret
 
 
-def mult_poly(coeff_dict, poly, var_x=var_x, var_q=q_var):
+def mult_poly(coeff_dict, poly, var_x=_vars.var_x, var_q=_vars.q_var):
     if poly in var_x:
         return single_variable(coeff_dict, var_x.index(poly), var_q=var_q)
     elif isinstance(poly, Mul):
@@ -90,7 +74,7 @@ def mult_poly(coeff_dict, poly, var_x=var_x, var_q=q_var):
             ret[perm] = poly * coeff_dict[perm]
         return ret
 
-def schubmult_db(perm_dict, v, q_var=q_var):
+def schubmult_db(perm_dict, v, q_var=_vars.q_var):
     if v == (1, 2):
         return perm_dict
     th = medium_theta(inverse(v))

schubmult/schubmult_q/_script.py

@@ -1,7 +1,6 @@
-from ._funcs import (
+from schubmult.schubmult_q._funcs import (
     schubmult,
     schubmult_db,
-    mult_poly,
 )
 from symengine import sympify
 from schubmult._base_argparse import schub_argparse
@@ -22,9 +21,10 @@ from schubmult.perm_lib import (
 )
 import numpy as np
 from schubmult.schubmult_q_double import factor_out_q_keep_factored
-
+import sys
 
 def _display_full(coeff_dict, args, formatter):
+    raw_result_dict = {}
     ascode = args.ascode
     parabolic_index = [int(s) for s in args.parabolic]
     parabolic = len(parabolic_index) != 0
@@ -81,25 +81,25 @@ def _display_full(coeff_dict, args, formatter):
         val = sympify(coeff_dict[perm]).expand()
         if val != 0:
             if ascode:
+
                 print(f"{str(trimcode(perm))}  {formatter(val)}")
             else:
                 print(f"{str(perm)}  {formatter(val)}")
+    return raw_result_dict
 
 
-def main():
+def main(argv=None):
+    if argv is None:
+        argv = sys.argv
     try:
         args, formatter = schub_argparse(
             "schubmult_q",
             "Compute products of quantum Schubert polynomials",
+            argv=argv[1:],
             quantum=True,
         )
 
-        mulstring = ""
-
-        mult = False
-        if args.mult is not None:
-            mult = True
-            mulstring = " ".join(args.mult)
+        
 
         perms = args.perms
 
@@ -143,15 +143,18 @@ def main():
             for perm in perms[1:]:
                 coeff_dict = schubmult(coeff_dict, tuple(permtrim([*perm])))
 
-        if mult:
-            mul_exp = sympify(mulstring)
-            coeff_dict = mult_poly(coeff_dict, mul_exp)
+        # if mult:
+        #     mul_exp = sympify(mulstring)
+        #     coeff_dict = mult_poly(coeff_dict, mul_exp)
 
-        if pr:
-            _display_full(coeff_dict, args, formatter)
+        if pr or formatter is None:
+            raw_result_dict = _display_full(coeff_dict, args, formatter)
+        if formatter is None:
+            return raw_result_dict
     except BrokenPipeError:
         pass
 
 
 if __name__ == "__main__":
-    main()
+    import sys
+    main(sys.argv)

schubmult/schubmult_q_double/__init__.py

@@ -2,7 +2,8 @@ from ._funcs import (
     schubmult,
     schubmult_db,
     mult_poly,
-    factor_out_q_keep_factored
+    factor_out_q_keep_factored,
+    schubpoly_quantum
 )
 
 
@@ -10,5 +11,7 @@ __all__ = [
     "schubmult",
     "schubmult_db",
     "mult_poly",
-    "factor_out_q_keep_factored"
+    "factor_out_q_keep_factored",
+    "schubpoly_quantum"
 ]
+

schubmult/schubmult_q_double/__main__.py

@@ -2,4 +2,4 @@ import sys
 from ._script import main
 
 if __name__ == "__main__":
-    sys.exit(main())
+    sys.exit(main(sys.argv))

schubmult/schubmult_q_double/_funcs.py

@@ -1,11 +1,13 @@
-from ._vars import (
-    var_y,
-    var_x,
-    var2,
-    var3,
-    q_var2,
-)
-from symengine import Add, Mul, Pow, expand
+# from ._vars import (
+#     var_y,
+#     var_x,
+#     var2,
+#     var3,
+#     q_var2,
+# )
+import schubmult.schubmult_double as norm_yz
+
+from symengine import Add, Mul, Pow, expand, symarray
 from schubmult.perm_lib import (
     elem_sym_perms_q,
     add_perm_dict,
@@ -22,16 +24,47 @@ from schubmult.perm_lib import (
     elem_sym_perms_q_op,
     elem_sym_func_q,
     call_zvars,
-    q_var,
 )
-import schubmult.schubmult_double as norm_yz
+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 q_var(self):
+        return tuple(symarray("q", self.n).tolist())
+
+    @cached_property
+    def var_r(self):
+        return symarray("r", 100)
+
+
+_vars = _gvars()
 
 
-def E(p, k, varl=var_y[1:]):
+def E(p, k, varl=_vars.var2[1:],var_x=_vars.var1):
     return elem_sym_poly_q(p, k, var_x[1:], varl)
 
 
-def single_variable(coeff_dict, varnum, var2=var2, q_var=q_var):
+def single_variable(coeff_dict, varnum, var2=_vars.var2, q_var=_vars.q_var):
     ret = {}
     for u in coeff_dict:
         if varnum - 1 < len(u):
@@ -51,7 +84,7 @@ def single_variable(coeff_dict, varnum, var2=var2, q_var=q_var):
     return ret
 
 
-def mult_poly(coeff_dict, poly, var_x=var_x, var_y=var_y, q_var=q_var):
+def mult_poly(coeff_dict, poly, var_x=_vars.var1, var_y=_vars.var2, q_var=_vars.q_var):
     if poly in var_x:
         return single_variable(coeff_dict, var_x.index(poly), var_y, q_var)
     elif isinstance(poly, Mul):
@@ -78,7 +111,7 @@ def mult_poly(coeff_dict, poly, var_x=var_x, var_y=var_y, q_var=q_var):
         return ret
 
 
-def nil_hecke(perm_dict, v, n, var2=var2, var3=var3):
+def nil_hecke(perm_dict, v, n, var2=_vars.var2, var3=_vars.var3):
     if v == (1, 2):
         return perm_dict
     th = strict_theta(inverse(v))
@@ -129,7 +162,7 @@ def nil_hecke(perm_dict, v, n, var2=var2, var3=var3):
     return ret_dict
 
 
-def elem_sym_func_q_q(k, i, u1, u2, v1, v2, udiff, vdiff, varl1, varl2, q_var=q_var):
+def elem_sym_func_q_q(k, i, u1, u2, v1, v2, udiff, vdiff, varl1, varl2, q_var=_vars.q_var):
     newk = k - udiff
     if newk < vdiff:
         return 0
@@ -151,7 +184,7 @@ def elem_sym_func_q_q(k, i, u1, u2, v1, v2, udiff, vdiff, varl1, varl2, q_var=q_
     return elem_sym_poly_q(newk - vdiff, newk, yvars, zvars, q_var)
 
 
-def schubpoly_quantum(v, var_x=var_x, var_y=var2, q_var=q_var, coeff=1):
+def schubpoly_quantum(v, var_x=_vars.var1, var_y=_vars.var2, q_var=_vars.q_var, coeff=1):
     th = strict_theta(inverse(v))
     mu = permtrim(uncode(th))
     vmu = permtrim(mulperm([*v], mu))
@@ -206,7 +239,7 @@ def schubpoly_quantum(v, var_x=var_x, var_y=var2, q_var=q_var, coeff=1):
     return ret_dict[(1, 2)]
 
 
-def schubmult(perm_dict, v, var2=var2, var3=var3, q_var=q_var):
+def schubmult(perm_dict, v, var2=_vars.var2, var3=_vars.var3, q_var=_vars.q_var):
     if v == (1, 2):
         return perm_dict
     th = strict_theta(inverse(v))
@@ -267,7 +300,7 @@ def schubmult(perm_dict, v, var2=var2, var3=var3, q_var=q_var):
     return ret_dict
 
 
-def schubmult_db(perm_dict, v, var2=var2, var3=var3, q_var=q_var):
+def schubmult_db(perm_dict, v, var2=_vars.var2, var3=_vars.var3, q_var=_vars.q_var):
     if v == (1, 2):
         return perm_dict
     th = medium_theta(inverse(v))
@@ -400,7 +433,7 @@ def schubmult_db(perm_dict, v, var2=var2, var3=var3, q_var=q_var):
     return ret_dict
 
 
-def div_diff(v, w, var2=var2, var3=var3):
+def div_diff(v, w, var2=_vars.var2, var3=_vars.var3):
     coeff_dict = {v: 1}
     coeff_dict = norm_yz.schubmult_down(coeff_dict, w, var2, var3)
     return coeff_dict.get((1, 2), 0)
@@ -427,7 +460,7 @@ def factor_out_q_keep_factored(poly):
     if str(poly).find("q") == -1:
         ret[1] = poly
         return ret
-    elif poly in q_var2:
+    elif poly in _vars.q_var:
         ret[poly] = 1
         return ret
     elif isinstance(poly, Add):
@@ -481,24 +514,24 @@ def factor_out_q(poly):
             for var_maybe_pow in key.args:
                 if isinstance(var_maybe_pow, Pow):
                     real_var = var_maybe_pow.args[0]
-                    if real_var in q_var2:
+                    if real_var in _vars.q_var:
                         q_part *= var_maybe_pow
                     else:
                         yz_part *= var_maybe_pow
                 else:
                     real_var = var_maybe_pow
-                    if real_var in q_var2:
+                    if real_var in _vars.q_var:
                         q_part *= var_maybe_pow
                     else:
                         yz_part *= var_maybe_pow
         elif isinstance(key, Pow):
             real_var = key.args[0]
-            if real_var in q_var2:
+            if real_var in _vars.q_var:
                 q_part *= key
             else:
                 yz_part *= key
         else:
-            if key in q_var2:
+            if key in _vars.q_var:
                 q_part *= key
             else:
                 yz_part *= key