Support lrcalc 2.x

1 files changed, 573 insertions, 0 deletions

diff --git a/sagemath-lrcalc2.patch b/sagemath-lrcalc2.patch
new file mode 100644
index 000000000000..a970430661ac
--- /dev/null
+++ b/sagemath-lrcalc2.patch
@@ -0,0 +1,573 @@
+diff --git a/build/pkgs/lrcalc/checksums.ini b/build/pkgs/lrcalc/checksums.ini
+index 7a0e6a1b96..70de56c40d 100644
+--- a/build/pkgs/lrcalc/checksums.ini
++++ b/build/pkgs/lrcalc/checksums.ini
+@@ -1,4 +1,5 @@
+ tarball=lrcalc-VERSION.tar.gz
+-sha1=89c288875bc3e3e2919876cb645bdfd7316b5965
+-md5=6bba16c0cca9debccd0af847bd3d4a23
+-cksum=3738483656
++sha1=2a98661eb39c7ef526c932f7886fc3142fd639ab
++md5=7cfa8f67287f2b70a15a833b94bc24b6
++cksum=2250996027
++upstream_url=https://sites.math.rutgers.edu/~asbuch/lrcalc/lrcalc-VERSION.tar.gz
+diff --git a/build/pkgs/lrcalc/package-version.txt b/build/pkgs/lrcalc/package-version.txt
+index 92ab3427e8..879b416e60 100644
+--- a/build/pkgs/lrcalc/package-version.txt
++++ b/build/pkgs/lrcalc/package-version.txt
+@@ -1 +1 @@
+-1.2.p1
++2.1
+diff --git a/build/pkgs/lrcalc/patches/includes.patch b/build/pkgs/lrcalc/patches/includes.patch
+deleted file mode 100644
+index 707da176a6..0000000000
+--- a/build/pkgs/lrcalc/patches/includes.patch
++++ /dev/null
+@@ -1,90 +0,0 @@
+-From 4a5e1c8c3c11efdb1cbb4239825a6bf4bf1c52f8 Mon Sep 17 00:00:00 2001
+-From: Anders Skovsted Buch <asbuch@math.rutgers.edu>
+-Date: Sun, 29 Nov 2015 16:25:56 -0500
+-Subject: [PATCH] Patch by Jeroen Demeyer to change include <vector.h> 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 <stdlib.h>
+- extern char *optarg;
+- 
+--#include <vectarg.h>
+-+#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 <stdio.h>
+--#include <vector.h>
+--#include <hashtab.h>
+-+#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 <hashtab.h>
+-+#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 <stdio.h>
+- 
+--#include <alloc.h>
+--#include <vector.h>
+--#include <hashtab.h>
+-+#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 <hashtab.h>
+--#include <vector.h>
+-+#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/build/pkgs/lrcalc/spkg-install.in b/build/pkgs/lrcalc/spkg-install.in
+index d6665bfb42..a34493b776 100644
+--- a/build/pkgs/lrcalc/spkg-install.in
++++ b/build/pkgs/lrcalc/spkg-install.in
+@@ -7,3 +7,6 @@ cp "$SAGE_ROOT"/config/config.sub .
+ sdh_configure
+ sdh_make
+ sdh_make_install
++
++cd python
++sdh_pip_install .
+diff --git a/src/sage/libs/lrcalc/lrcalc.pxd b/src/sage/libs/lrcalc/lrcalc.pxd
+deleted file mode 100644
+index 10b88db93f..0000000000
+--- 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 65%
+rename from src/sage/libs/lrcalc/lrcalc.pyx
+rename to src/sage/libs/lrcalc/lrcalc.py
+index 1cf67dc15a..d4e2f5d538 100644
+--- a/src/sage/libs/lrcalc/lrcalc.pyx
++++ b/src/sage/libs/lrcalc/lrcalc.py
+@@ -187,180 +187,16 @@ 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.
+-
+-    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.
+-
+-    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 <type 'sage.rings.integer.Integer'>.
+-
+-    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(<vector*> 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 <type 'sage.rings.integer.Integer'>.
+-
+-    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(<vector*> 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 <type 'sage.rings.integer.Integer'>.
+-
+-    EXAMPLES::
+-
+-        sage: from sage.libs.lrcalc.lrcalc import coprod
+-        sage: coprod([1])      #indirect doctest
+-        {([1], []): 1}
+-    """
+-    cdef hash_itr itr
+-    cdef vecpair* vp
+-    cdef dict result = {}
+-    hash_first(ht, itr)
+-    while hash_good(itr):
+-        vp = <vecpair*> 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
++from sage.combinat.skew_tableau import SkewTableaux
++from sage.combinat.skew_partition import SkewPartition
++from sage.combinat.words.word import Word
++from sage.rings.integer import Integer
++import lrcalc
+ 
++def _lrcalc_dict_to_sage(result):
++    return dict({_Partitions(i):Integer(k) for i,k in result.items()})
+ 
+ def lrcoef_unsafe(outer, inner1, inner2):
+     r"""
+@@ -392,18 +228,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):
+@@ -510,44 +335,23 @@ 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 = <hashtab*>(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():
++        output[_Partitions(i[0])] = output.get(_Partitions(i[0]), P.zero()) + k*quantum**(i[1])
++    return output
++
++
++def skew(outer, inner, maxrows=-1):
+     """
+     Compute the Schur expansion of a skew Schur function.
+ 
+@@ -572,14 +376,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):
+@@ -609,12 +406,8 @@ 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 dict({tuple(_Partitions(j) for j in i):Integer(k) for i,k in result.items()})
+ 
+ 
+ def mult_schubert(w1, w2, rank=0):
+@@ -646,17 +439,11 @@ 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 dict({Permutation(list(i)):Integer(k) for i,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``.
+ 
+@@ -703,21 +490,23 @@ def lrskew(outer, inner, weight=None, maxrows=0):
+         sage: list(lrskew([3,2,1],[2], weight=[3,1]))
+         [[[None, None, 1], [1, 1], [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, 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)
++        while True:
++            try:
++                word = Word([i+1 for i in next(iterator)])
++                yield SkewTableaux().from_shape_and_word(shape, word)
++            except StopIteration:
++                break
+     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)
++        while True:
++            try:
++                word = Word([i+1 for i in next(iterator)])
++                r = SkewTableaux().from_shape_and_word(shape, word)
++                if r.weight() == wt:
++                    yield r
++            except StopIteration:
++                break