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

schubmult/schubmult_double/_script.py

@@ -1,34 +1,35 @@
+import sys
+from functools import cached_property
+
 import numpy as np
 import sympy
-import sys
+from symengine import expand, symarray, sympify
 
-# from schubmult.schubmult_double._vars import var_x, var, var_r
-from schubmult.schubmult_double._funcs import (
-    mult_poly,
-    mult_poly_down,
-    schubmult,
-    schubmult_down,
-    compute_positive_rep,
-    posify,
-    split_perms,
-)
-from symengine import expand, sympify, symarray
 from schubmult._base_argparse import schub_argparse
 from schubmult.perm_lib import (
     add_perm_dict,
-    inverse,
-    theta,
-    permtrim,
+    code,
     inv,
+    inverse,
+    mu_A,
     mulperm,
-    code,
+    permtrim,
+    theta,
+    trimcode,
     uncode,
     will_formula_work,
-    mu_A,
-    trimcode,
 )
 
-from functools import cached_property
+# from schubmult.schubmult_double._vars import var_x, var, var_r
+from schubmult.schubmult_double._funcs import (
+    compute_positive_rep,
+    mult_poly,
+    mult_poly_down,
+    posify,
+    schubmult,
+    schubmult_down,
+    split_perms,
+)
 
 
 class _gvars:
@@ -145,12 +146,12 @@ def _display_full(
 
         if ascode:
             width = max(
-                [len(str(trimcode(perm[0])) + " " + str(trimcode(perm[1]))) for perm in perm_pairs]
+                [len(str(trimcode(perm[0])) + " " + str(trimcode(perm[1]))) for perm in perm_pairs],
             )
         else:
             width = max([len(str(perm[0]) + " " + str(perm[1])) for perm in perm_pairs])
 
-        subs_dict2 = {}        
+
         for perm in coeff_perms:
             val = coeff_dict[perm]
             downperm = mulperm(list(perm), inverse_kperm)
@@ -166,8 +167,8 @@ def _display_full(
                 secondperm = [downperm[i] - N for i in range(N, len(downperm))]
                 val = sympify(val).subs(subs_dict)
 
-                if same and display_positive:                    
-                    val = expand(sympify(val).xreplace(subs_dict2))
+                if same and display_positive:
+                    val = expand(sympify(val).subs(subs_dict2))
 
                 if val != 0:
                     if display_positive and not same:
@@ -184,10 +185,10 @@ def _display_full(
                             )
                             if expand(val - val2) != 0:
                                 _display(
-                                    f"error; write to schubmult@gmail.com with the case {perms=}\n{code(firstperm)=} {code(secondperm)=}\n{val2=}\n{val=}"
+                                    f"error; write to schubmult@gmail.com with the case {perms=}\n{code(firstperm)=} {code(secondperm)=}\n{val2=}\n{val=}",
                                 )
                                 _display(
-                                    f"{code(tuple(permtrim(mulperm(firstperm,muA))))=},{code(tuple(permtrim(mulperm(secondperm,muB))))=},{code(the_top_perm)=}\n{expand(val-val2)=}"
+                                    f"{code(tuple(permtrim(mulperm(firstperm,muA))))=},{code(tuple(permtrim(mulperm(secondperm,muB))))=},{code(the_top_perm)=}\n{expand(val-val2)=}",
                                 )
                                 exit(1)
                             val = val2
@@ -205,7 +206,7 @@ def _display_full(
                             ] = val
                             if formatter:
                                 _display(
-                                    f"{tuple(permtrim(firstperm))}{' ':>{width2}}{tuple(permtrim(secondperm))}  {formatter(val)}"
+                                    f"{tuple(permtrim(firstperm))}{' ':>{width2}}{tuple(permtrim(secondperm))}  {formatter(val)}",
                                 )
                         else:
                             width2 = (
@@ -218,7 +219,7 @@ def _display_full(
                             ] = val
                             if formatter:
                                 _display(
-                                    f"{trimcode(firstperm)}{' ':>{width2}}{trimcode(secondperm)}  {formatter(val)}"
+                                    f"{trimcode(firstperm)}{' ':>{width2}}{trimcode(secondperm)}  {formatter(val)}",
                                 )
     else:
         if ascode:
@@ -281,36 +282,30 @@ def _display_full(
                                 )
                             else:
                                 _display(
-                                    f"error; write to schubmult@gmail.com with the case {perms=} {perm=} {val=} {check_coeff_dict.get(perm,0)=}"
+                                    f"error; write to schubmult@gmail.com with the case {perms=} {perm=} {val=} {check_coeff_dict.get(perm,0)=}",
                                 )
                                 exit(1)
                         if check and expand(val - check_coeff_dict.get(perm, 0)) != 0:
                             _display(
-                                f"error; write to schubmult@gmail.com with the case {perms=} {perm=} {val=} {check_coeff_dict.get(perm,0)=}"
+                                f"error; write to schubmult@gmail.com with the case {perms=} {perm=} {val=} {check_coeff_dict.get(perm,0)=}",
                             )
                             exit(1)
                 if val != 0:
                     if ascode:
                         raw_result_dict[tuple(trimcode(perm))] = val
                         if formatter:
-                            _display(f"{str(trimcode(perm)):>{width}}  {formatter(val)}")
+                            _display(f"{trimcode(perm)!s:>{width}}  {formatter(val)}")
                     else:
                         raw_result_dict[tuple(perm)] = val
                         if formatter:
-                            _display(f"{str(perm):>{width}}  {formatter(val)}")
+                            _display(f"{perm!s:>{width}}  {formatter(val)}")
     return raw_result_dict
 
 
 def main(argv=None):
-    import logging
-
-    logging.basicConfig(
-        level=logging.ERROR, format="%(asctime)s %(levelname)s %(message) %(module) s"
-    )
-    logger = logging.getLogger(__name__)
-    logger.log(logging.DEBUG, f"main {argv=}")
     if argv is None:
         argv = sys.argv
+
     try:
         var2 = tuple(symarray("y", 100).tolist())
         var3 = tuple(symarray("z", 100).tolist())
@@ -365,7 +360,7 @@ def main(argv=None):
 
             if pr or formatter is None:
                 # logger.log(logging.DEBUG, f"main {var2=}{var3=}{same=}")
-                return _display_full(
+                raw_result_dict = _display_full(
                     coeff_dict,
                     args,
                     formatter,
@@ -375,6 +370,8 @@ def main(argv=None):
                     var3=var3,
                     N=N,
                 )
+            if formatter is None:
+                return raw_result_dict
         else:
             if ascode:
                 for i in range(len(perms)):
@@ -445,7 +442,7 @@ def main(argv=None):
                         coeff_dict4 = schubmult(coeff_dict4, perm, var2, var3)
                         for w in coeff_dict4:
                             coeff_dict4[w] = coeff_dict2[u] * posify(
-                                coeff_dict4[w], u, perm, w, var2, var3, msg
+                                coeff_dict4[w], u, perm, w, var2, var3, msg,
                             )
                         coeff_dict3 = add_perm_dict(coeff_dict4, coeff_dict3)
                     coeff_dict2 = coeff_dict3
@@ -454,6 +451,7 @@ def main(argv=None):
             elif not posified:
                 coeff_dict = check_coeff_dict
 
+
             if pr or formatter is None:
                 raw_result_dict = _display_full(
                     coeff_dict,
@@ -464,11 +462,13 @@ def main(argv=None):
                     posified=posified,
                     check_coeff_dict=check_coeff_dict,
                 )
+
             if formatter is None:
                 return raw_result_dict
     except BrokenPipeError:
         pass
+    return 0
 
 
 if __name__ == "__main__":
-    main(sys.argv)
+    sys.exit(main(sys.argv))

schubmult/schubmult_py/__init__.py

@@ -1,13 +1,12 @@
 from ._funcs import (
-    schubmult,
     mult_poly,
     schub_coprod,
+    schubmult,
 )
 
-
 __all__ = [
-    "schubmult",
     "mult_poly",
-    "schub_coprod"
+    "schub_coprod",
+    "schubmult",
 ]
 

schubmult/schubmult_py/__main__.py

@@ -1,4 +1,5 @@
 import sys
+
 from ._script import main
 
 if __name__ == "__main__":

schubmult/schubmult_py/_funcs.py

@@ -1,16 +1,18 @@
+from functools import cached_property
+
+from symengine import Add, Mul, Pow, symarray
+
 from schubmult.perm_lib import (
-    elem_sym_perms,
     add_perm_dict,
     compute_vpathdicts,
-    inverse,
-    theta,
-    permtrim,
+    elem_sym_perms,
     inv,
+    inverse,
     mulperm,
+    permtrim,
+    theta,
     uncode,
 )
-from symengine import Add, Mul, Pow, symarray
-from functools import cached_property
 
 
 class _gvars:
@@ -45,28 +47,27 @@ def single_variable(coeff_dict, varnum):
 def mult_poly(coeff_dict, poly, var_x=_vars.var_x):
     if poly in var_x:
         return single_variable(coeff_dict, var_x.index(poly))
-    elif isinstance(poly, Mul):
+    if isinstance(poly, Mul):
         ret = coeff_dict
         for a in poly.args:
             ret = mult_poly(ret, a, var_x)
         return ret
-    elif isinstance(poly, Pow):
+    if isinstance(poly, Pow):
         base = poly.args[0]
         exponent = int(poly.args[1])
         ret = coeff_dict
         for i in range(int(exponent)):
             ret = mult_poly(ret, base, var_x)
         return ret
-    elif isinstance(poly, Add):
+    if isinstance(poly, Add):
         ret = {}
         for a in poly.args:
             ret = add_perm_dict(ret, mult_poly(coeff_dict, a, var_x))
         return ret
-    else:
-        ret = {}
-        for perm in coeff_dict:
-            ret[perm] = poly * coeff_dict[perm]
-        return ret
+    ret = {}
+    for perm in coeff_dict:
+        ret[perm] = poly * coeff_dict[perm]
+    return ret
 
 
 def schubmult(perm_dict, v):
@@ -87,8 +88,7 @@ def schubmult(perm_dict, v):
     for index in range(len(th)):
         for vp in vpathdicts[index]:
             for v2, vdiff, s in vpathdicts[index][vp]:
-                if th[index] - vdiff > mx_th[index]:
-                    mx_th[index] = th[index] - vdiff
+                mx_th[index] = max(mx_th[index], th[index] - vdiff)
 
     for u, val in perm_dict.items():
         inv_u = inv(u)
@@ -150,7 +150,7 @@ def schub_coprod(perm, indices):
                     break
             if not flag:
                 continue
-            firstperm = tuple(permtrim((list(downperm[0:N]))))
-            secondperm = tuple(permtrim(([downperm[i] - N for i in range(N, len(downperm))])))
+            firstperm = tuple(permtrim(list(downperm[0:N])))
+            secondperm = tuple(permtrim([downperm[i] - N for i in range(N, len(downperm))]))
             ret_dict[(firstperm, secondperm)] = val
     return ret_dict

schubmult/schubmult_py/_script.py

@@ -1,15 +1,17 @@
-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 (
+    inv,
     inverse,
-    theta,
     permtrim,
-    inv,
-    uncode,
+    theta,
     trimcode,
+    uncode,
 )
+from schubmult.schubmult_py._funcs import mult_poly, schub_coprod, schubmult
 
 
 def main(argv=None):
@@ -17,7 +19,7 @@ def main(argv=None):
         argv = sys.argv
     try:
         args, formatter = schub_argparse(
-            "schubmult_py", "Compute products of ordinary Schubert polynomials", argv=argv[1:]
+            "schubmult_py", "Compute products of ordinary Schubert polynomials", argv=argv[1:],
         )
 
         mult = args.mult
@@ -52,14 +54,13 @@ def main(argv=None):
                     if val != 0:
                         if ascode:
                             if formatter is None:
-                                raw_result_dict[(firstperm, secondperm)] = val
+                                raw_result_dict[(tuple(trimcode(firstperm)), tuple(trimcode(secondperm)))] = val
                             else:
                                 print(f"{val} {trimcode(firstperm)} {trimcode(secondperm)}")
+                        elif formatter is None:
+                            raw_result_dict[(firstperm, secondperm)] = val
                         else:
-                            if formatter is None:
-                                raw_result_dict[(firstperm, secondperm)] = val
-                            else:
-                                print(f"{val} {firstperm} {secondperm}")
+                            print(f"{val} {firstperm} {secondperm}")
         else:
             if ascode:
                 for i in range(len(perms)):
@@ -93,4 +94,4 @@ def main(argv=None):
 
 
 if __name__ == "__main__":
-    main(sys.argv)
+    sys.exit(main(sys.argv))

schubmult/schubmult_q/__init__.py

@@ -1,13 +1,8 @@
-from ._funcs import (
-    schubmult,
-    schubmult_db,
-    mult_poly
-)
-
+from ._funcs import mult_poly, schubmult, schubmult_db
 
 __all__ = [
+    "mult_poly",
     "schubmult",
     "schubmult_db",
-    "mult_poly"
 ]
 

schubmult/schubmult_q/__main__.py

@@ -1,4 +1,5 @@
 import sys
+
 from ._script import main
 
 if __name__ == "__main__":

schubmult/schubmult_q/_funcs.py

@@ -1,27 +1,28 @@
+from functools import cached_property
+
 from symengine import Add, Mul, Pow, symarray
+
 from schubmult.perm_lib import (
-    elem_sym_perms_q,
     add_perm_dict,
+    code,
     compute_vpathdicts,
+    double_elem_sym_q,
+    elem_sym_perms_q,
+    inv,
     inverse,
-    strict_theta,
     medium_theta,
-    permtrim,
-    inv,
     mulperm,
-    code,
+    permtrim,
+    strict_theta,
     uncode,
-    double_elem_sym_q,    
 )
 
-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())
@@ -51,28 +52,27 @@ def single_variable(coeff_dict, varnum, var_q=_vars.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):
+    if isinstance(poly, Mul):
         ret = coeff_dict
         for a in poly.args:
             ret = mult_poly(ret, a, var_x, var_q=var_q)
         return ret
-    elif isinstance(poly, Pow):
+    if isinstance(poly, Pow):
         base = poly.args[0]
         exponent = int(poly.args[1])
         ret = coeff_dict
         for i in range(int(exponent)):
             ret = mult_poly(ret, base, var_x, var_q=var_q)
         return ret
-    elif isinstance(poly, Add):
+    if isinstance(poly, Add):
         ret = {}
         for a in poly.args:
             ret = add_perm_dict(ret, mult_poly(coeff_dict, a, var_x, var_q=var_q))
         return ret
-    else:
-        ret = {}
-        for perm in coeff_dict:
-            ret[perm] = poly * coeff_dict[perm]
-        return ret
+    ret = {}
+    for perm in coeff_dict:
+        ret[perm] = poly * coeff_dict[perm]
+    return ret
 
 def schubmult_db(perm_dict, v, q_var=_vars.q_var):
     if v == (1, 2):
@@ -102,14 +102,12 @@ def schubmult_db(perm_dict, v, q_var=_vars.q_var):
             mx_th = 0
             for vp in vpathdicts[index]:
                 for v2, vdiff, s in vpathdicts[index][vp]:
-                    if th[index] - vdiff > mx_th:
-                        mx_th = th[index] - vdiff
+                    mx_th = max(mx_th, th[index] - vdiff)
             if index < len(th) - 1 and th[index] == th[index + 1]:
                 mx_th1 = 0
                 for vp in vpathdicts[index + 1]:
                     for v2, vdiff, s in vpathdicts[index + 1][vp]:
-                        if th[index + 1] - vdiff > mx_th1:
-                            mx_th1 = th[index + 1] - vdiff
+                        mx_th1 = max(mx_th1, th[index + 1] - vdiff)
                 newpathsums = {}
                 for up in vpathsums:
                     newpathsums0 = {}
@@ -126,7 +124,7 @@ def schubmult_db(perm_dict, v, q_var=_vars.q_var):
                                 if udiff1 + vdiff2 == th[index]:
                                     newpathsums0[(up1, udiff1, mul_val1)][v2] = (
                                         newpathsums0[(up1, udiff1, mul_val1)].get(
-                                            v2, 0
+                                            v2, 0,
                                         )
                                         + s2 * sumval * mul_val1
                                     )
@@ -173,7 +171,7 @@ def schubmult_db(perm_dict, v, q_var=_vars.q_var):
             vpathsums = newpathsums
         toget = tuple(vmu)
         ret_dict = add_perm_dict(
-            {ep: vpathsums[ep].get(toget, 0) for ep in vpathsums}, ret_dict
+            {ep: vpathsums[ep].get(toget, 0) for ep in vpathsums}, ret_dict,
         )
     return ret_dict
 
@@ -198,13 +196,12 @@ def schubmult(perm_dict, v):
             mx_th = 0
             for vp in vpathdicts[index]:
                 for v2, vdiff, s in vpathdicts[index][vp]:
-                    if th[index] - vdiff > mx_th:
-                        mx_th = th[index] - vdiff
+                    mx_th = max(mx_th, th[index] - vdiff)
             newpathsums = {}
             for up in vpathsums:
                 inv_up = inv(up)
                 newperms = elem_sym_perms_q(
-                    up, min(mx_th, (inv_mu - (inv_up - inv_u)) - inv_vmu), th[index]
+                    up, min(mx_th, (inv_mu - (inv_up - inv_u)) - inv_vmu), th[index],
                 )
                 for up2, udiff, mul_val in newperms:
                     if up2 not in newpathsums:
@@ -222,7 +219,7 @@ def schubmult(perm_dict, v):
             vpathsums = newpathsums
         toget = tuple(vmu)
         ret_dict = add_perm_dict(
-            {ep: vpathsums[ep].get(toget, 0) for ep in vpathsums}, ret_dict
+            {ep: vpathsums[ep].get(toget, 0) for ep in vpathsums}, ret_dict,
         )
     return ret_dict
 

schubmult/schubmult_q/_script.py

@@ -1,27 +1,30 @@
-from schubmult.schubmult_q._funcs import (
-    schubmult,
-    schubmult_db,
-)
+import sys
+
+import numpy as np
 from symengine import sympify
+
 from schubmult._base_argparse import schub_argparse
 from schubmult.perm_lib import (
-    trimcode,
-    permtrim,
-    inv,
-    mulperm,
-    uncode,
-    longest_element,
     check_blocks,
+    count_less_than,
+    inv,
     is_parabolic,
-    q_vector,
+    longest_element,
+    mulperm,
     omega,
-    count_less_than,
+    permtrim,
     q_var,
+    q_vector,
     sg,
+    trimcode,
+    uncode,
+)
+from schubmult.schubmult_q._funcs import (
+    schubmult,
+    schubmult_db,
 )
-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 = {}
@@ -63,7 +66,7 @@ def _display_full(coeff_dict, args, formatter):
                         q_var[index + 1 - count_less_than(parabolic_index, index + 1)] ** qv[index]
                         for index in range(len(qv))
                         if index + 1 not in parabolic_index
-                    ]
+                    ],
                 )
 
                 try:
@@ -81,10 +84,13 @@ 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)}")
+                raw_result_dict[tuple(trimcode(perm))] = val
+                if formatter:
+                    print(f"{trimcode(perm)!s}  {formatter(val)}")
             else:
-                print(f"{str(perm)}  {formatter(val)}")
+                raw_result_dict[perm] = val
+                if formatter:
+                    print(f"{perm!s}  {formatter(val)}")
     return raw_result_dict
 
 
@@ -99,7 +105,7 @@ def main(argv=None):
             quantum=True,
         )
 
-        
+
 
         perms = args.perms
 
@@ -130,7 +136,7 @@ def main(argv=None):
                 index = parabolic_index[i] - 1
                 if sg(index, perms[0]) == 1 or sg(index, perms[1]) == 1:
                     print(
-                        "Parabolic given but elements are not minimal length coset representatives."
+                        "Parabolic given but elements are not minimal length coset representatives.",
                     )
                     exit(1)
 
@@ -157,4 +163,4 @@ def main(argv=None):
 
 if __name__ == "__main__":
     import sys
-    main(sys.argv)
+    sys.exit(main(sys.argv))

schubmult/schubmult_q_double/__init__.py

@@ -1,17 +1,10 @@
-from ._funcs import (
-    schubmult,
-    schubmult_db,
-    mult_poly,
-    factor_out_q_keep_factored,
-    schubpoly_quantum
-)
-
+from ._funcs import factor_out_q_keep_factored, mult_poly, schubmult, schubmult_db, schubpoly_quantum
 
 __all__ = [
+    "factor_out_q_keep_factored",
+    "mult_poly",
     "schubmult",
     "schubmult_db",
-    "mult_poly",
-    "factor_out_q_keep_factored",
-    "schubpoly_quantum"
+    "schubpoly_quantum",
 ]
 

schubmult/schubmult_q_double/__main__.py

@@ -1,4 +1,5 @@
 import sys
+
 from ._script import main
 
 if __name__ == "__main__":