From 16ce3b48b9ac2f8a47e2713edf6a0e35250d5873 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Gonzalo=20Tornar=C3=ADa?= Date: Mon, 28 Feb 2022 12:03:22 -0300 Subject: [PATCH 1/3] lrcalc: update to 2.1. --- common/shlibs | 2 +- srcpkgs/lrcalc/patches/includes.patch | 90 --------------------------- srcpkgs/lrcalc/template | 6 +- 3 files changed, 4 insertions(+), 94 deletions(-) delete mode 100644 srcpkgs/lrcalc/patches/includes.patch diff --git a/common/shlibs b/common/shlibs index 83b5783cb026..4a0a07d366cc 100644 --- a/common/shlibs +++ b/common/shlibs @@ -4038,7 +4038,7 @@ libarb.so.2 arb-2.20.0_1 libec.so.8 eclib-20210625_1 libsymmetrica.so.2 symmetrica-3.0.1_1 libLfunction.so.1 lcalc-2.0.4_1 -liblrcalc.so.1 lrcalc-1.2_1 +liblrcalc.so.2 lrcalc-2.1_1 libwayland-client++.so.0 libwaylandpp-0.2.8_1 libwayland-cursor++.so.0 libwaylandpp-0.2.8_1 libwayland-egl++.so.0 libwaylandpp-0.2.8_1 diff --git a/srcpkgs/lrcalc/patches/includes.patch b/srcpkgs/lrcalc/patches/includes.patch deleted file mode 100644 index 707da176a60f..000000000000 --- a/srcpkgs/lrcalc/patches/includes.patch +++ /dev/null @@ -1,90 +0,0 @@ -From 4a5e1c8c3c11efdb1cbb4239825a6bf4bf1c52f8 Mon Sep 17 00:00:00 2001 -From: Anders Skovsted Buch -Date: Sun, 29 Nov 2015 16:25:56 -0500 -Subject: [PATCH] Patch by Jeroen Demeyer to change include to - "vector.h", plus similar cases. - ---- - src/lrcalc.c | 2 +- - src/maple.c | 4 ++-- - src/schublib.h | 2 +- - src/symfcn.c | 6 +++--- - src/symfcn.h | 4 ++-- - 5 files changed, 9 insertions(+), 9 deletions(-) - -diff --git a/src/lrcalc.c b/src/lrcalc.c -index aff3f75..60df49e 100644 ---- a/src/lrcalc.c -+++ b/src/lrcalc.c -@@ -8,7 +8,7 @@ - #include - extern char *optarg; - --#include -+#include "vectarg.h" - - #include "symfcn.h" - #include "maple.h" -diff --git a/src/maple.c b/src/maple.c -index fdc0768..a5f4d14 100644 ---- a/src/maple.c -+++ b/src/maple.c -@@ -4,8 +4,8 @@ - */ - - #include --#include --#include -+#include "vector.h" -+#include "hashtab.h" - #include "maple.h" - - -diff --git a/src/schublib.h b/src/schublib.h -index a8e8511..864850c 100644 ---- a/src/schublib.h -+++ b/src/schublib.h -@@ -1,7 +1,7 @@ - #ifndef _SCHUBLIB_H - #define _SCHUBLIB_H - --#include -+#include "hashtab.h" - - hashtab *trans(vector *w, int vars, hashtab *res); - hashtab *monk(int i, hashtab *slc, int rank); -diff --git a/src/symfcn.c b/src/symfcn.c -index 4ffbe4b..fd5df5d 100644 ---- a/src/symfcn.c -+++ b/src/symfcn.c -@@ -5,9 +5,9 @@ - - #include - --#include --#include --#include -+#include "alloc.h" -+#include "vector.h" -+#include "hashtab.h" - - #include "symfcn.h" - -diff --git a/src/symfcn.h b/src/symfcn.h -index b8543b1..29bb00d 100644 ---- a/src/symfcn.h -+++ b/src/symfcn.h -@@ -1,8 +1,8 @@ - #ifndef _SYMFCN_H - #define _SYMFCN_H - --#include --#include -+#include "hashtab.h" -+#include "vector.h" - - int part_itr_sz(vector *part); - int part_itr_sub(vector *part, vector *outer); --- -2.1.1.1.g1fb337f - diff --git a/srcpkgs/lrcalc/template b/srcpkgs/lrcalc/template index 8b33c3cba6c8..afa889b6d6ad 100644 --- a/srcpkgs/lrcalc/template +++ b/srcpkgs/lrcalc/template @@ -1,14 +1,14 @@ # Template file for 'lrcalc' pkgname=lrcalc -version=1.2 -revision=2 +version=2.1 +revision=1 build_style=gnu-configure short_desc="Littlewood-Richardson Calculator" maintainer="Gonzalo Tornaría " license="GPL-3.0-or-later" homepage="https://sites.math.rutgers.edu/~asbuch/lrcalc/" distfiles="https://sites.math.rutgers.edu/~asbuch/lrcalc/lrcalc-$version.tar.gz" -checksum=792dd538a0d19698be2c5b8c138730bbb4820e8a44e03b001ae14bd5f1d7040b +checksum=996ac00e6ea8321ef09b34478f5379f613933c3254aeba624b6419b8afa5df57 lrcalc-devel_package() { depends="${sourcepkg}>=${version}_${revision} ${makedepends}" From 0bea3c29ecf5390a728f9c53fae3bc680819583f Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Gonzalo=20Tornar=C3=ADa?= Date: Mon, 28 Feb 2022 14:06:21 -0300 Subject: [PATCH 2/3] New package: python3-lrcalc-2.1 --- srcpkgs/python3-lrcalc/template | 14 ++++++++++++++ 1 file changed, 14 insertions(+) create mode 100644 srcpkgs/python3-lrcalc/template diff --git a/srcpkgs/python3-lrcalc/template b/srcpkgs/python3-lrcalc/template new file mode 100644 index 000000000000..9f335dac35dd --- /dev/null +++ b/srcpkgs/python3-lrcalc/template @@ -0,0 +1,14 @@ +# Template file for 'python3-lrcalc' +pkgname=python3-lrcalc +version=2.1 +revision=1 +wrksrc=lrcalc-${version} +build_style=python3-module +hostmakedepends="python3-setuptools python3-Cython" +makedepends="python3-devel lrcalc-devel" +short_desc="Python bindings for the Littlewood-Richardson Calculator library" +maintainer="Gonzalo Tornaría " +license="GPL-3.0-or-later" +homepage="https://math.rutgers.edu/~asbuch/lrcalc" +distfiles="${PYPI_SITE}/l/lrcalc/lrcalc-${version}.tar.gz" +checksum=e3a0509aeda487b412b391a52e817ca36b5c063a8305e09fd54d53259dd6aaa9 From 13ab5c4a1b3453fec6611dbf577816346ea6036c Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Gonzalo=20Tornar=C3=ADa?= Date: Mon, 28 Feb 2022 14:06:28 -0300 Subject: [PATCH 3/3] sagemath: rebuild for lrcalc 2.1 Also fix doctests for upgrade of ipython 8.0 and scipy 1.8 --- .../trac-31355-upgrade_lrcalc_to_2.1.patch | 670 ++++++++++++++++++ .../trac-33170-fix_doctest_ipython_8.patch | 40 ++ .../trac-33336-fix_doctest_scipy_1.8.patch | 19 + srcpkgs/sagemath/template | 6 +- 4 files changed, 732 insertions(+), 3 deletions(-) create mode 100644 srcpkgs/sagemath/patches/trac-31355-upgrade_lrcalc_to_2.1.patch create mode 100644 srcpkgs/sagemath/patches/trac-33170-fix_doctest_ipython_8.patch create mode 100644 srcpkgs/sagemath/patches/trac-33336-fix_doctest_scipy_1.8.patch diff --git a/srcpkgs/sagemath/patches/trac-31355-upgrade_lrcalc_to_2.1.patch b/srcpkgs/sagemath/patches/trac-31355-upgrade_lrcalc_to_2.1.patch new file mode 100644 index 000000000000..4bd6f4f4e2dc --- /dev/null +++ b/srcpkgs/sagemath/patches/trac-31355-upgrade_lrcalc_to_2.1.patch @@ -0,0 +1,670 @@ +As produced by `git diff 9.5 9.6.beta3 -- src/sage/libs/lrcalc` + +diff --git a/src/sage/libs/lrcalc/lrcalc.pxd b/src/sage/libs/lrcalc/lrcalc.pxd +deleted file mode 100644 +index 10b88db93f2..00000000000 +--- a/src/sage/libs/lrcalc/lrcalc.pxd ++++ /dev/null +@@ -1,77 +0,0 @@ +-# distutils: libraries = lrcalc +- +-cdef extern from "lrcalc/hashtab.h": +- ctypedef struct hashtab: +- pass +- +- ctypedef struct hash_itr: +- pass +- +- ctypedef unsigned long hashkey_t +- ctypedef int (*cmp_t) (void* a, void* b) +- ctypedef hashkey_t (*hash_t) (void* a) +- +- hashtab* hash_new(cmp_t cm, hash_t hsh) +- void hash_free(hashtab *ht) +- +- void* hash_lookup(hashtab *ht, void *key) +- void* hash_insert(hashtab *ht, void *key, void *value) +- +- bint hash_good(hash_itr) +- void hash_first(hashtab* s, hash_itr itr) +- void hash_next(hash_itr itr) +- void* hash_key(hash_itr itr) +- void* hash_value(hash_itr itr) +- int hash_intvalue(hash_itr itr) +- +-cdef extern from "lrcalc/vector.h": +- ctypedef struct vector: +- size_t length +- int* array +- +- vector* v_new(int length) +- void v_free(vector* v) +- void v_print(vector *v) +- int v_length(vector* v) +- int v_elem(vector* v, int i) +- +- ctypedef struct vecpair: +- vector *first +- vector *second +- +- vector* vp_first(vecpair* vp) +- vector* vp_second(vecpair* vp) +- +-cdef extern from "lrcalc/list.h": +- cdef struct _list: +- void **array +- size_t allocated +- size_t length +- void l_free(_list *lst) +- +-cdef extern from "lrcalc/symfcn.h": +- long long lrcoef_c "lrcoef"(vector* outer, vector* inner1, vector* inner2) +- hashtab* mult_c "mult"(vector *sh1, vector *sh2, int maxrows) +- hashtab* skew_c "skew"(vector *outer, vector *inner, int maxrows) +- hashtab* coprod_c "coprod"(vector *part, int all) +- void fusion_reduce_c "fusion_reduce"(hashtab* ht, int rows, int cols, int opt_zero) +- _list *quantum_reduce_c "quantum_reduce"(hashtab* ht, int rows, int col) +- +- ctypedef struct skewtab: +- vector *outer +- vector *inner +- vector *conts +- int maxrows +- vector *conjugate +- int rows +- int cols +- int matrix[1] +- +- skewtab *st_new(vector *outer, vector *inner, vector *conts, int maxrows) +- int st_next(skewtab *st) +- void st_print(skewtab *st) +- void st_free(skewtab *st) +- +- +-cdef extern from "lrcalc/schublib.h": +- hashtab* mult_schubert_c "mult_schubert"(vector *sh1, vector *sh2, int rank) +diff --git a/src/sage/libs/lrcalc/lrcalc.pyx b/src/sage/libs/lrcalc/lrcalc.py +similarity index 60% +rename from src/sage/libs/lrcalc/lrcalc.pyx +rename to src/sage/libs/lrcalc/lrcalc.py +index b591081ec4c..b541bfacd89 100644 +--- a/src/sage/libs/lrcalc/lrcalc.pyx ++++ b/src/sage/libs/lrcalc/lrcalc.py +@@ -10,7 +10,8 @@ fusion products. All of the above are achieved by counting LR + appropriate shape and content by iterating through them. + Additionally, ``lrcalc`` handles products of Schubert polynomials. + +-The web page of ``lrcalc`` is ``_. ++The web page of ``lrcalc`` is ++``_. + + The following describes the Sage interface to this library. + +@@ -36,12 +37,13 @@ Schur expansion:: + [4, 2]: 1} + + Same product, but include only partitions with at most 3 rows. This +-corresponds to computing in the representation ring of gl(3):: ++corresponds to computing in the representation ring of `\mathfrak{gl}(3)`:: + + sage: lrcalc.mult([2,1], [2,1], 3) + {[2, 2, 2]: 1, [3, 2, 1]: 2, [3, 3]: 1, [4, 1, 1]: 1, [4, 2]: 1} + +-We can also compute the fusion product, here for sl(3) and level 2:: ++We can also compute the fusion product, here for `\mathfrak{sl}(3)` ++and level 2:: + + sage: lrcalc.mult([3,2,1], [3,2,1], 3,2) + {[4, 4, 4]: 1, [5, 4, 3]: 1} +@@ -77,42 +79,38 @@ Multiply two Schubert polynomials:: + [6, 2, 1, 4, 3, 5]: 1} + + Same product, but include only permutations of 5 elements in the result. +-This corresponds to computing in the cohomology ring of Fl(5):: ++This corresponds to computing in the cohomology ring of `Fl(5)`:: + + sage: lrcalc.mult_schubert([4,2,1,3], [1,4,2,5,3], 5) + {[4, 5, 1, 3, 2]: 1, [5, 3, 1, 4, 2]: 1, [5, 4, 1, 2, 3]: 1} + + List all Littlewood-Richardson tableaux of skew shape `\mu/\nu`; in + this example `\mu=[3,2,1]` and `\nu=[2,1]`. Specifying a third entry +-`maxrows` restricts the alphabet to `\{1,2,\ldots,maxrows\}`:: ++`M' = ``maxrows`` restricts the alphabet to `\{1,2,\ldots,M\}`:: + + sage: list(lrcalc.lrskew([3,2,1],[2,1])) + [[[None, None, 1], [None, 1], [1]], [[None, None, 1], [None, 1], [2]], + [[None, None, 1], [None, 2], [1]], [[None, None, 1], [None, 2], [3]]] + + sage: list(lrcalc.lrskew([3,2,1],[2,1],maxrows=2)) +- [[[None, None, 1], [None, 1], [1]], [[None, None, 1], [None, 1], [2]], [[None, None, 1], [None, 2], [1]]] ++ [[[None, None, 1], [None, 1], [1]], [[None, None, 1], [None, 1], [2]], ++ [[None, None, 1], [None, 2], [1]]] + + .. TODO:: + +- use this library in the :class:`SymmetricFunctions` code, to ++ Use this library in the :class:`SymmetricFunctions` code, to + make it easy to apply it to linear combinations of Schur functions. + + .. SEEALSO:: + + - :func:`lrcoef` +- + - :func:`mult` +- + - :func:`coprod` +- + - :func:`skew` +- + - :func:`lrskew` +- + - :func:`mult_schubert` + +-.. rubric:: Underlying algorithmic in lrcalc ++.. RUBRIC:: Underlying algorithmic in lrcalc + + Here is some additional information regarding the main low-level + C-functions in `lrcalc`. Given two partitions ``outer`` and ``inner`` +@@ -187,180 +185,24 @@ AUTHORS: + # https://www.gnu.org/licenses/ + # **************************************************************************** + +-from sage.rings.integer cimport Integer +-from sage.structure.parent cimport Parent + from sage.combinat.partition import _Partitions + from sage.combinat.permutation import Permutation +-from sage.combinat.skew_tableau import SkewTableau +- +- +-cdef vector* iterable_to_vector(it): +- """ +- Return an lrcalc vector (which is a list of integers) from a Python iterable. +- +- TESTS:: +- +- sage: from sage.libs.lrcalc.lrcalc import test_iterable_to_vector +- sage: x = test_iterable_to_vector(Partition([3,2,1])); x #indirect doctest +- [3, 2, 1] +- """ +- cdef vector* v +- cdef list itr = list(it) +- cdef int n = len(itr) +- cdef int i +- v = v_new(n) +- for i in range(n): +- v.array[i] = int(itr[i]) +- return v +- +- +-cdef list vector_to_list(vector *v): +- """ +- Converts a lrcalc vector to Python list. +- +- TESTS:: +- +- sage: from sage.libs.lrcalc.lrcalc import test_iterable_to_vector +- sage: x = test_iterable_to_vector([]); x #indirect doctest +- [] +- """ +- cdef int i, n +- n = v_length(v) +- cdef list result = [None]*n +- for i in range(n): +- result[i] = Integer(v_elem(v, i)) +- return result +- +- +-def test_iterable_to_vector(it): +- """ +- A wrapper function for the cdef function ``iterable_to_vector`` +- and ``vector_to_list``, to test that they are working correctly. ++from sage.combinat.skew_tableau import SemistandardSkewTableaux ++from sage.combinat.skew_partition import SkewPartition ++from sage.rings.integer import Integer ++import lrcalc + +- EXAMPLES:: +- +- sage: from sage.libs.lrcalc.lrcalc import test_iterable_to_vector +- sage: x = test_iterable_to_vector([3,2,1]); x +- [3, 2, 1] +- """ +- cdef vector *v = iterable_to_vector(it) +- result = vector_to_list(v) +- v_free(v) +- return result +- +- +-cdef skewtab_to_SkewTableau(skewtab *st): +- """ +- A wrapper function which transforms the data set ``st`` used in +- ``lrcalc`` to a ``SkewTableau`` in Sage. ++def _lrcalc_dict_to_sage(result): ++ r""" ++ Translate from lrcalc output format to Sage expected format. + + TESTS:: + +- sage: from sage.libs.lrcalc.lrcalc import test_skewtab_to_SkewTableau +- sage: test_skewtab_to_SkewTableau([],[]) +- [] +- """ +- inner = vector_to_list(st.inner) +- outer = vector_to_list(st.outer) +- return SkewTableau(expr=[[inner[y] for y in range(len(outer))], +- [[st.matrix[x + y * st.cols] + 1 +- for x in range(inner[y], outer[y])] +- for y in range(len(outer) - 1, -1, -1)]]) +- +- +-def test_skewtab_to_SkewTableau(outer, inner): +- """ +- A wrapper function for the cdef function ``skewtab_to_SkewTableau`` +- for testing purposes. +- +- It constructs the first LR skew tableau of shape ``outer/inner`` +- as an ``lrcalc`` ``skewtab``, and converts it to a +- :class:`SkewTableau`. +- +- EXAMPLES:: +- +- sage: from sage.libs.lrcalc.lrcalc import test_skewtab_to_SkewTableau +- sage: test_skewtab_to_SkewTableau([3,2,1],[]) +- [[1, 1, 1], [2, 2], [3]] +- sage: test_skewtab_to_SkewTableau([4,3,2,1],[1,1]).pp() +- . 1 1 1 +- . 2 2 +- 1 3 +- 2 +- """ +- cdef vector* o = iterable_to_vector(outer) +- cdef vector* i = iterable_to_vector(inner+[0]*(len(outer)-len(inner))) +- cdef skewtab* st = st_new(o, i, NULL, 0) +- return skewtab_to_SkewTableau(st) +- +- +-cdef dict sf_hashtab_to_dict(hashtab *ht): +- """ +- Return a dictionary representing a Schur function. The keys are +- partitions and the values are integers . +- +- EXAMPLES:: +- + sage: from sage.libs.lrcalc.lrcalc import mult +- sage: sorted(mult([1],[1]).items()) #indirect doctest +- [([1, 1], 1), ([2], 1)] +- sage: assert isinstance(mult([1],[1]),dict)#indirect doctest +- """ +- cdef hash_itr itr +- cdef dict result = {} +- cdef list p +- hash_first(ht, itr) +- while hash_good(itr): +- p = vector_to_list( hash_key(itr)) +- result[_Partitions(p)] = Integer(hash_intvalue(itr)) +- hash_next(itr) +- return result +- +- +-cdef dict schubert_hashtab_to_dict(hashtab *ht): +- """ +- Return a dictionary corresponding to a Schubert polynomial whose keys +- are permutations and whose values are integers . +- +- EXAMPLES:: +- +- sage: from sage.libs.lrcalc.lrcalc import mult_schubert +- sage: mult_schubert([3,2,1], [1,2,3]) #indirect doctest +- {[3, 2, 1]: 1} +- """ +- cdef hash_itr itr +- cdef dict result = {} +- hash_first(ht, itr) +- while hash_good(itr): +- p = vector_to_list( hash_key(itr)) +- result[Permutation(p)] = Integer(hash_intvalue(itr)) +- hash_next(itr) +- return result +- +- +-cdef dict vp_hashtab_to_dict(hashtab *ht): +- """ +- Return a dictionary corresponding to the coproduct of a Schur function whose keys are +- pairs of partitions and whose values are integers . +- +- EXAMPLES:: +- +- sage: from sage.libs.lrcalc.lrcalc import coprod +- sage: coprod([1]) #indirect doctest +- {([1], []): 1} ++ sage: mult([2,1],[3,2,1],3) # indirect doctest ++ {[3, 3, 3]: 1, [4, 3, 2]: 2, [4, 4, 1]: 1, [5, 2, 2]: 1, [5, 3, 1]: 1} + """ +- cdef hash_itr itr +- cdef vecpair* vp +- cdef dict result = {} +- hash_first(ht, itr) +- while hash_good(itr): +- vp = hash_key(itr) +- p1 = _Partitions(vector_to_list(vp_first(vp))) +- p2 = _Partitions(vector_to_list(vp_second(vp))) +- result[(p1, p2)] = Integer(hash_intvalue(itr)) +- hash_next(itr) +- return result +- ++ return {_Partitions(la): Integer(k) for la, k in result.items()} + + def lrcoef_unsafe(outer, inner1, inner2): + r""" +@@ -371,13 +213,11 @@ def lrcoef_unsafe(outer, inner1, inner2): + + INPUT: + +- - ``outer`` -- a partition (weakly decreasing list of non-negative integers). +- +- - ``inner1`` -- a partition. ++ - ``outer`` -- a partition (weakly decreasing list of non-negative integers) ++ - ``inner1`` -- a partition ++ - ``inner2`` -- a partition + +- - ``inner2`` -- a partition. +- +- .. warning:: ++ .. WARNING:: + + This function does not do any check on its input. If you want + to use a safer version, use :func:`lrcoef`. +@@ -392,18 +232,7 @@ def lrcoef_unsafe(outer, inner1, inner2): + sage: lrcoef_unsafe([2,1,1,1,1], [2,1], [2,1]) + 0 + """ +- cdef long long result +- cdef vector *o +- cdef vector *i1 +- cdef vector *i2 +- o = iterable_to_vector(outer) +- i1 = iterable_to_vector(inner1) +- i2 = iterable_to_vector(inner2) +- result = lrcoef_c(o, i1, i2) +- v_free(o) +- v_free(i1) +- v_free(i2) +- return Integer(result) ++ return Integer(lrcalc.lrcoef(outer, inner1, inner2)) + + + def lrcoef(outer, inner1, inner2): +@@ -415,11 +244,9 @@ def lrcoef(outer, inner1, inner2): + + INPUT: + +- - ``outer`` -- a partition (weakly decreasing list of non-negative integers). +- +- - ``inner1`` -- a partition. +- +- - ``inner2`` -- a partition. ++ - ``outer`` -- a partition (weakly decreasing list of non-negative integers) ++ - ``inner1`` -- a partition ++ - ``inner2`` -- a partition + + .. NOTE:: + +@@ -436,7 +263,6 @@ def lrcoef(outer, inner1, inner2): + 1 + sage: lrcoef([2,1,1,1,1], [2,1], [2,1]) + 0 +- + """ + return lrcoef_unsafe(_Partitions(outer), _Partitions(inner1), _Partitions(inner2)) + +@@ -451,13 +277,9 @@ def mult(part1, part2, maxrows=None, level=None, quantum=None): + INPUT: + + - ``part1`` -- a partition +- + - ``part2`` -- a partition +- + - ``maxrows`` -- (optional) an integer +- + - ``level`` -- (optional) an integer +- + - ``quantum`` -- (optional) an element of a ring + + If ``maxrows`` is specified, then only partitions with at most +@@ -479,7 +301,8 @@ def mult(part1, part2, maxrows=None, level=None, quantum=None): + sage: sorted(mult([2],[2]).items()) + [([2, 2], 1), ([3, 1], 1), ([4], 1)] + sage: sorted(mult([2,1],[2,1]).items()) +- [([2, 2, 1, 1], 1), ([2, 2, 2], 1), ([3, 1, 1, 1], 1), ([3, 2, 1], 2), ([3, 3], 1), ([4, 1, 1], 1), ([4, 2], 1)] ++ [([2, 2, 1, 1], 1), ([2, 2, 2], 1), ([3, 1, 1, 1], 1), ++ ([3, 2, 1], 2), ([3, 3], 1), ([4, 1, 1], 1), ([4, 2], 1)] + sage: sorted(mult([2,1],[2,1],maxrows=2).items()) + [([3, 3], 1), ([4, 2], 1)] + sage: mult([2,1],[3,2,1],3) +@@ -510,44 +333,24 @@ def mult(part1, part2, maxrows=None, level=None, quantum=None): + if quantum is not None and (level is None or maxrows is None): + raise ValueError('missing parameters maxrows or level') + +- cdef vector* v1 = iterable_to_vector(part1) +- cdef vector* v2 = iterable_to_vector(part2) +- if maxrows is None: +- maxrows = 0 +- cdef hashtab* ht = mult_c(v1, v2, int(maxrows)) +- cdef hashtab* tab +- cdef dict result +- + if quantum is None: + if level is not None: +- fusion_reduce_c(ht, int(maxrows), int(level), int(0)) +- result = sf_hashtab_to_dict(ht) +- v_free(v1) +- v_free(v2) +- hash_free(ht) +- return result ++ return _lrcalc_dict_to_sage(lrcalc.mult_fusion(part1, part2, maxrows, level)) ++ if maxrows is None: ++ maxrows = -1 ++ return _lrcalc_dict_to_sage(lrcalc.mult(part1, part2, maxrows)) + + # Otherwise do quantum multiplication +- cdef _list *qlist +- cdef dict temp +- qlist = quantum_reduce_c(ht, int(maxrows), int(level)) +- # The above call frees the memory associated with ht +- v_free(v1) +- v_free(v2) +- +- cdef Parent P = quantum.parent() +- result = {} +- for i in range(qlist.length): +- tab = (qlist.array[i]) +- temp = sf_hashtab_to_dict(tab) +- for k in temp: +- result[k] = result.get(k, P.zero()) + quantum**i * temp[k] +- hash_free(tab) +- l_free(qlist) +- return result +- +- +-def skew(outer, inner, maxrows=0): ++ result = lrcalc.mult_quantum(part1, part2, maxrows, level, degrees=True) ++ P = quantum.parent() ++ output = {} ++ for i,k in result.items(): ++ la = _Partitions(i[0]) ++ output[la] = output.get(la, P.zero()) + k * quantum**(i[1]) ++ return output ++ ++ ++def skew(outer, inner, maxrows=-1): + """ + Compute the Schur expansion of a skew Schur function. + +@@ -557,11 +360,9 @@ def skew(outer, inner, maxrows=0): + + INPUT: + +- - ``outer`` -- a partition. +- +- - ``inner`` -- a partition. +- +- - ``maxrows`` -- an integer or ``None``. ++ - ``outer`` -- a partition ++ - ``inner`` -- a partition ++ - ``maxrows`` -- an integer or ``None`` + + If ``maxrows`` is specified, then only partitions with at most + this number of rows are included in the result. +@@ -572,14 +373,7 @@ def skew(outer, inner, maxrows=0): + sage: sorted(skew([2,1],[1]).items()) + [([1, 1], 1), ([2], 1)] + """ +- cdef vector* v1 = iterable_to_vector(outer) +- cdef vector* v2 = iterable_to_vector(inner) +- cdef hashtab* ht = skew_c(v1, v2, int(maxrows)) +- result = sf_hashtab_to_dict(ht) +- v_free(v1) +- v_free(v2) +- hash_free(ht) +- return result ++ return _lrcalc_dict_to_sage(lrcalc.skew(outer, inner, maxrows)) + + + def coprod(part, all=0): +@@ -592,9 +386,8 @@ def coprod(part, all=0): + + INPUT: + +- - ``part`` -- a partition. +- +- - ``all`` -- an integer. ++ - ``part`` -- a partition ++ - ``all`` -- an integer + + If ``all`` is non-zero then all terms are included in the result. + If ``all`` is zero, then only pairs of partitions ``(part1, +@@ -609,12 +402,9 @@ def coprod(part, all=0): + sage: sorted(coprod([2,1]).items()) + [(([1, 1], [1]), 1), (([2], [1]), 1), (([2, 1], []), 1)] + """ +- cdef vector* v1 = iterable_to_vector(part) +- cdef hashtab* ht = coprod_c(v1, int(all)) +- result = vp_hashtab_to_dict(ht) +- v_free(v1) +- hash_free(ht) +- return result ++ result = lrcalc.coprod(part, all) ++ return {tuple([_Partitions(mu) for mu in la]): Integer(k) ++ for la, k in result.items()} + + + def mult_schubert(w1, w2, rank=0): +@@ -627,11 +417,9 @@ def mult_schubert(w1, w2, rank=0): + + INPUT: + +- - ``w1`` -- a permutation. +- +- - ``w2`` -- a permutation. +- +- - ``rank`` -- an integer. ++ - ``w1`` -- a permutation ++ - ``w2`` -- a permutation ++ - ``rank`` -- an integer + + If ``rank`` is non-zero, then only permutations from the symmetric + group `S(\mathrm{rank})` are included in the result. +@@ -646,33 +434,24 @@ def mult_schubert(w1, w2, rank=0): + ([6, 4, 3, 1, 2, 5], 1), ([6, 5, 2, 1, 3, 4], 1), + ([7, 3, 4, 1, 2, 5, 6], 1), ([7, 4, 2, 1, 3, 5, 6], 1)] + """ +- cdef vector* v1 = iterable_to_vector(w1) +- cdef vector* v2 = iterable_to_vector(w2) +- cdef hashtab* ht = mult_schubert_c(v1, v2, int(rank)) +- result = schubert_hashtab_to_dict(ht) +- v_free(v1) +- v_free(v2) +- hash_free(ht) +- return result ++ result = lrcalc.schubmult(w1, w2, rank) ++ return {Permutation(list(la)):Integer(k) for la,k in result.items()} + + +-def lrskew(outer, inner, weight=None, maxrows=0): ++def lrskew(outer, inner, weight=None, maxrows=-1): + r""" + Iterate over the skew LR tableaux of shape ``outer / inner``. + + INPUT: + + - ``outer`` -- a partition +- + - ``inner`` -- a partition +- + - ``weight`` -- a partition (optional) +- +- - ``maxrows`` -- an integer (optional) ++ - ``maxrows`` -- a positive integer (optional) + + OUTPUT: an iterator of :class:`SkewTableau` + +- Specifying ``maxrows`` restricts the alphabet to `\{1,2,\ldots,maxrows\}`. ++ Specifying ``maxrows`` = `M` restricts the alphabet to `\{1,2,\ldots,M\}`. + + Specifying ``weight`` returns only those tableaux of given content/weight. + +@@ -702,22 +481,40 @@ def lrskew(outer, inner, weight=None, maxrows=0): + + sage: list(lrskew([3,2,1],[2], weight=[3,1])) + [[[None, None, 1], [1, 1], [2]]] ++ ++ TESTS:: ++ ++ sage: from sage.libs.lrcalc.lrcalc import lrskew ++ sage: list(lrskew([3,2,1],[2], weight=[])) ++ [] ++ sage: list(lrskew([3,2,1],[2], weight=[0])) ++ [] ++ sage: list(lrskew([3,2,1],[3,2,1], weight=[])) ++ [[[None, None, None], [None, None], [None]]] ++ sage: list(lrskew([3,2,1],[3,2,1], weight=[0])) ++ [[[None, None, None], [None, None], [None]]] ++ sage: list(lrskew([3,2,1],[3,2,1], weight=[1])) ++ [] + """ +- cdef vector* o = iterable_to_vector(outer) +- cdef vector* i = iterable_to_vector(inner + [0]*(len(outer) - len(inner))) +- cdef skewtab* st = st_new(o, i, NULL, int(maxrows)) ++ iterator = lrcalc.lr_iterator(outer, inner, maxrows) ++ shape = SkewPartition([outer, inner]) + + if weight is None: +- yield skewtab_to_SkewTableau(st) +- while st_next(st): +- yield skewtab_to_SkewTableau(st) ++ ST = SemistandardSkewTableaux(shape) ++ for data in iterator: ++ yield ST.from_shape_and_word(shape, [i+1 for i in data]) + else: + wt = _Partitions(weight) +- r = skewtab_to_SkewTableau(st) +- if r.weight() == wt: +- yield r +- while st_next(st): +- r = skewtab_to_SkewTableau(st) +- if r.weight() == wt: +- yield r +- st_free(st) ++ ST = SemistandardSkewTableaux(shape, wt) ++ m = len(wt) ++ for data in iterator: ++ w = [0] * m ++ for j in data: ++ if j >= m: ++ # We know they are not equal, so make the check below quick ++ w = None ++ break ++ w[j] += 1 ++ if w == wt: ++ yield ST.from_shape_and_word(shape, [i+1 for i in data]) ++ diff --git a/srcpkgs/sagemath/patches/trac-33170-fix_doctest_ipython_8.patch b/srcpkgs/sagemath/patches/trac-33170-fix_doctest_ipython_8.patch new file mode 100644 index 000000000000..1e2e0ba90742 --- /dev/null +++ b/srcpkgs/sagemath/patches/trac-33170-fix_doctest_ipython_8.patch @@ -0,0 +1,40 @@ +As produced by `git diff a90a3146{^^,}` + +diff --git a/src/sage/repl/interface_magic.py b/src/sage/repl/interface_magic.py +index 8a455b69b0e..a93e1c9e04c 100644 +--- a/src/sage/repl/interface_magic.py ++++ b/src/sage/repl/interface_magic.py +@@ -260,7 +260,7 @@ class InterfaceMagic(object): + 2 + 120 + sage: shell.run_cell('%%gap foo\n1+1;\n') +- ...File "", line unknown ++ ...File...... + SyntaxError: Interface magics have no options, got "foo" + + sage: shell.run_cell('%%gap?') +diff --git a/src/sage/repl/interpreter.py b/src/sage/repl/interpreter.py +index 7468afe52d7..06c47b7374a 100644 +--- a/src/sage/repl/interpreter.py ++++ b/src/sage/repl/interpreter.py +@@ -78,9 +78,9 @@ Check that Cython source code appears in tracebacks:: + dummy line + ... + ZeroDivisionError...Traceback (most recent call last) +- in ... ++ ...in ... + ----> 1 Integer(1)/Integer(0) +- .../sage/rings/integer.pyx in sage.rings.integer.Integer...div... ++ .../sage/rings/integer.pyx... in sage.rings.integer.Integer...div... + ... + -> ... raise ZeroDivisionError("rational division by zero") + ....: x = Rational.__new__(Rational) +@@ -423,7 +423,7 @@ def SagePreparseTransformer(lines): + sage: from sage.repl.interpreter import get_test_shell + sage: shell = get_test_shell() + sage: shell.run_cell(bad_syntax) +- File "", line unknown ++ File...... + SyntaxError: Mismatched ']' + + sage: shell.quit() diff --git a/srcpkgs/sagemath/patches/trac-33336-fix_doctest_scipy_1.8.patch b/srcpkgs/sagemath/patches/trac-33336-fix_doctest_scipy_1.8.patch new file mode 100644 index 000000000000..19b69700a4f6 --- /dev/null +++ b/srcpkgs/sagemath/patches/trac-33336-fix_doctest_scipy_1.8.patch @@ -0,0 +1,19 @@ +commit 9c8235e44ffb509efa8a3ca6cdb55154e2b5066d +Author: Antonio Rojas +Date: Sun Feb 13 19:53:14 2022 +0100 + + Fix deprecation warning with scipy 1.8 + +diff --git a/src/sage/tests/books/computational-mathematics-with-sagemath/linsolve_doctest.py b/src/sage/tests/books/computational-mathematics-with-sagemath/linsolve_doctest.py +index e9b60dae5ec..7932167b41d 100644 +--- a/src/sage/tests/books/computational-mathematics-with-sagemath/linsolve_doctest.py ++++ b/src/sage/tests/books/computational-mathematics-with-sagemath/linsolve_doctest.py +@@ -356,7 +356,7 @@ Sage example in ./linsolve.tex, line 2230:: + + Sage example in ./linsolve.tex, line 2609:: + +- sage: from scipy.sparse.linalg.dsolve import * ++ sage: from scipy.sparse.linalg import factorized + sage: from scipy.sparse import lil_matrix + sage: from numpy import array + sage: n = 200 diff --git a/srcpkgs/sagemath/template b/srcpkgs/sagemath/template index 710a9e80c052..02d4333fa545 100644 --- a/srcpkgs/sagemath/template +++ b/srcpkgs/sagemath/template @@ -1,7 +1,7 @@ # Template file for 'sagemath' pkgname=sagemath version=9.5 -revision=1 +revision=2 wrksrc=sage-$version build_wrksrc=pkgs/sagemath-standard build_style=python3-module @@ -12,7 +12,7 @@ hostmakedepends="m4 pkg-config python3-Cython python3-Jinja2 python3-pkgconfig makedepends="arb-devel boost-devel brial-devel cliquer-devel ecl eclib-devel ecm-devel fflas-ffpack flintlib-devel gap-devel gd-devel giac-devel glpk-devel gsl-devel iml-devel lcalc-devel libbraiding-devel libhomfly-devel libmpc-devel - libpng-devel linbox-devel lrcalc-devel m4ri-devel m4rie-devel mpfi-devel + libpng-devel linbox-devel m4ri-devel m4rie-devel mpfi-devel mpfr-devel ntl-devel openblas-devel pari-devel planarity-devel python3-cypari2 python3-cysignals python3-devel python3-gmpy2 python3-memory_allocator python3-numpy rankwidth-devel singular symmetrica-devel zn_poly" @@ -20,7 +20,7 @@ depends="FlintQS eclib-devel fflas-ffpack flintlib-devel gcc-fortran gd-devel gfan giac gsl-devel gzip libpng-devel linbox-devel m4ri-devel maxima-ecl mpfr-devel nauty ntl-devel palp pari-devel pari-elldata-small pari-galdata pari-galpol-small pari-seadata-small pkg-config python3-Cython python3-cypari2 - python3-cysignals python3-devel python3-fpylll python3-ipython + python3-cysignals python3-devel python3-fpylll python3-ipython python3-lrcalc python3-ipython_ipykernel python3-jupyter_ipywidgets python3-matplotlib python3-memory_allocator python3-networkx python3-pip python3-pkgconfig python3-pplpy python3-primecountpy python3-requests python3-scipy