Date: Sunday, December 26, 2021 @ 13:45:28 Author: arojas Revision: 1083849
archrelease: copy trunk to community-staging-x86_64 Added: sagemath/repos/community-staging-x86_64/ sagemath/repos/community-staging-x86_64/PKGBUILD (from rev 1083848, sagemath/trunk/PKGBUILD) sagemath/repos/community-staging-x86_64/latte-count.patch (from rev 1083848, sagemath/trunk/latte-count.patch) sagemath/repos/community-staging-x86_64/sagemath-bliss-0.77.patch (from rev 1083848, sagemath/trunk/sagemath-bliss-0.77.patch) sagemath/repos/community-staging-x86_64/sagemath-lcalc2.patch (from rev 1083848, sagemath/trunk/sagemath-lcalc2.patch) sagemath/repos/community-staging-x86_64/sagemath-linbox-1.7.patch (from rev 1083848, sagemath/trunk/sagemath-linbox-1.7.patch) sagemath/repos/community-staging-x86_64/sagemath-lrcalc2.patch (from rev 1083848, sagemath/trunk/sagemath-lrcalc2.patch) sagemath/repos/community-staging-x86_64/sagemath-mpmath.patch (from rev 1083848, sagemath/trunk/sagemath-mpmath.patch) sagemath/repos/community-staging-x86_64/sagemath-optional-packages.patch (from rev 1083848, sagemath/trunk/sagemath-optional-packages.patch) sagemath/repos/community-staging-x86_64/sagemath-singular-4.2.1.p1.patch (from rev 1083848, sagemath/trunk/sagemath-singular-4.2.1.p1.patch) sagemath/repos/community-staging-x86_64/test-optional.patch (from rev 1083848, sagemath/trunk/test-optional.patch) ----------------------------------+ PKGBUILD | 116 +++++++ latte-count.patch | 89 +++++ sagemath-bliss-0.77.patch | 183 +++++++++++ sagemath-lcalc2.patch | 507 ++++++++++++++++++++++++++++++++ sagemath-linbox-1.7.patch | 58 +++ sagemath-lrcalc2.patch | 573 +++++++++++++++++++++++++++++++++++++ sagemath-mpmath.patch | 14 sagemath-optional-packages.patch | 17 + sagemath-singular-4.2.1.p1.patch | 266 +++++++++++++++++ test-optional.patch | 25 + 10 files changed, 1848 insertions(+) Copied: sagemath/repos/community-staging-x86_64/PKGBUILD (from rev 1083848, sagemath/trunk/PKGBUILD) =================================================================== --- community-staging-x86_64/PKGBUILD (rev 0) +++ community-staging-x86_64/PKGBUILD 2021-12-26 13:45:28 UTC (rev 1083849) @@ -0,0 +1,116 @@ +# Maintainer: Antonio Rojas <aro...@archlinux.org> +# Contributor: Evgeniy Alekseev <arcanis.arch at gmail dot com> +# Contributor: Daniel Wallace <danielwallace at gtmanfred dot com> +# Contributor: Thomas Dziedzic <gostrc at gmail dot com> +# Contributor: Osman Ugus <ugus11 at yahoo dot com> +# Contributor: Stefan Husmann <stefan-husmann at t-online dot de> + +pkgname=sagemath +pkgver=9.4 +pkgrel=8 +pkgdesc='Open Source Mathematics Software, free alternative to Magma, Maple, Mathematica, and Matlab' +arch=(x86_64) +url='http://www.sagemath.org' +license=(GPL) +depends=(palp brial cliquer maxima-ecl gfan sympow nauty python-rpy2 python-fpylll python-psutil python-cypari2 + python-matplotlib python-scipy python-sympy python-networkx python-pplpy python-sphinx python-ipywidgets python-memory-allocator + gap flintqs lcalc lrcalc arb eclib zn_poly gd python-cvxopt pynac linbox m4rie pari-galdata pari-seadata-small planarity rankwidth tachyon + sage-data-combinatorial_designs sage-data-elliptic_curves sage-data-graphs sage-data-polytopes_db sage-data-conway_polynomials + iml giac libhomfly libbraiding symmetrica threejs-sage) +optdepends=('cython: to compile cython code' 'python-pkgconfig: to compile cython code' + 'jmol: alternative 3D plot engine' 'jupyter-jsmol: alternative 3D plot engine in the Jupyter notebook' + 'sagemath-doc: HTML documentation' 'python-igraph: igraph backend for graph theory' + 'sage-numerical-backends-coin: COIN mixed integer linear programming backend' + 'coin-or-csdp: for computing Lovász theta-function of graphs' + 'buckygen: for generating fullerene graphs' 'plantri: for generating some classes of graphs' 'benzene: for generating fusenes and benzenoids' + 'bliss: bliss backend for graph theory' + 'ffmpeg: to export animations to video' 'imagemagick: to show animations' + 'coxeter: Coxeter groups implementation' + 'rubiks: Rubiks cube algorithms' + 'lrs: Algorithms for linear reverse search used in game theory and for computing volume of polytopes' + 'python-pynormaliz: Normaliz backend for polyhedral computations' + 'latte-integrale: integral point count in polyhedra' 'python-jupymake: polymake backend for polyhedral computations' + 'shared_meataxe: faster matrix arithmetic over finite fields' 'openblas: faster linear algebra' + 'sirocco: for computing the fundamental group of the complement of a plane curve' 'primecount: faster prime_pi implementation' + 'dot2tex: for displaying some diagrams' 'cryptominisat5: SAT solver' 'python-pycosat: picosat SAT solver' + 'python-pip: to install optional packages with sage -pip' 'sage-notebook-exporter: convert flask notebooks to Jupyter' + 'python-database-knotinfo: interface to the KnotInfo and LinkInfo databases') +makedepends=(cython boost ratpoints python-jinja sirocco mcqd coxeter bliss tdlib python-pkgconfig shared_meataxe primecount) +conflicts=(sagemath-jupyter) +replaces=(sagemath-jupyter) +source=(https://github.com/sagemath/sage/archive/$pkgver/$pkgname-$pkgver.tar.gz + sagemath-optional-packages.patch + latte-count.patch + test-optional.patch + sagemath-lrcalc2.patch + sagemath-lcalc2.patch + sagemath-mpmath.patch + sagemath-singular-4.2.1.p1.patch + sagemath-linbox-1.7.patch + sagemath-bliss-0.77.patch) +sha256sums=('47190f37e679c2483dadc13112595bacb399dfe4c4a0cde18d3627f5b2db0ea5' + '665fc76fa57b1c50f122a8d1874e187afc97a9120921706176b63da3d9d30651' + '88e944f23c3b2391dc2e9f9be8e1131152d837dc8c829dfc714663869a272e81' + 'af984186f852d2847d770a18fb6822296c50a652dbf55a1ed59d27517c3d3ee4' + '240ac4c29d96d56407a20e1b7f9846e342a7eb2bb4edd6e5c86b3b5a8ff462f9' + '791b3f2c6e5529b09c3abf2f9703b6cf754d633a7a4177645b70b72ea014135a' + 'be1c871fe6306a053169dce3edbb8bc78a96254ae7c83b2b741257ef3445b6eb' + 'e3cdfe730d0b0f422fe837e465ecde3419b16de50bef3dd2b674f275f528ed97' + 'eacea27b214d32cb886a75695153dfc36b5bad2fd2517e8e4eee18e74220e9e3' + '49ede468b8e1e7b8d7a390aab9ff1a6e899a0c5e487632cbf76902d80c637505') + +prepare(){ + cd sage-$pkgver + +# Upstream patches +# Replace lrcalc.pyx with a wrapper over lrcalc's python bindings https://trac.sagemath.org/ticket/31355 + patch -p1 -i ../sagemath-lrcalc2.patch +# Port to lcalc 2 https://trac.sagemath.org/ticket/32037 + patch -p1 -i ../sagemath-lcalc2.patch +# Make it work with vanilla mpmath https://trac.sagemath.org/ticket/32799 + patch -p1 -i ../sagemath-mpmath.patch +# Fix build with singular 4.2.1.p1 https://trac.sagemath.org/ticket/32907 + patch -p1 -i ../sagemath-singular-4.2.1.p1.patch +# Fix build with linbox 1.7 https://trac.sagemath.org/ticket/32959 + patch -p1 -i ../sagemath-linbox-1.7.patch +# Fix build with bliss 0.77 https://trac.sagemath.org/ticket/33010 + patch -p1 -i ../sagemath-bliss-0.77.patch + +# Arch-specific patches +# assume all optional packages are installed + patch -p1 -i ../sagemath-optional-packages.patch +# don't list optional packages when running tests + patch -p1 -i ../test-optional.patch +# use correct latte-count binary name + patch -p1 -i ../latte-count.patch + + cd build/pkgs/sagelib + ./bootstrap +} + +build() { + cd sage-$pkgver/pkgs/sagemath-standard + + export SAGE_NUM_THREADS=10 + python setup.py build +} + +package() { + cd sage-$pkgver/pkgs/sagemath-standard + + python setup.py install --root="$pkgdir" --optimize=1 + +# Remove sage_setup + rm -r "$pkgdir"/usr/lib/python*/site-packages/sage_setup + +# fix symlinks to assets + _pythonpath=`python -c "from sysconfig import get_path; print(get_path('platlib'))"` + for _i in $(ls "$srcdir"/sage-$pkgver/src/sage/ext_data/notebook-ipython); do + rm "$pkgdir"/usr/share/jupyter/kernels/sagemath/$_i + ln -s $_pythonpath/sage/ext_data/notebook-ipython/$_i "$pkgdir"/usr/share/jupyter/kernels/sagemath/ + done + +# adjust threejs version + rm "$pkgdir"$_pythonpath/sage/ext_data/threejs/threejs-version.txt + ln -s /usr/share/threejs-sage/version "$pkgdir"$_pythonpath/sage/ext_data/threejs/threejs-version.txt +} Copied: sagemath/repos/community-staging-x86_64/latte-count.patch (from rev 1083848, sagemath/trunk/latte-count.patch) =================================================================== --- community-staging-x86_64/latte-count.patch (rev 0) +++ community-staging-x86_64/latte-count.patch 2021-12-26 13:45:28 UTC (rev 1083849) @@ -0,0 +1,89 @@ +diff --git a/src/sage/geometry/polyhedron/base_ZZ.py b/src/sage/geometry/polyhedron/base_ZZ.py +index 268af9db0d..70d41dfa30 100644 +--- a/src/sage/geometry/polyhedron/base_ZZ.py ++++ b/src/sage/geometry/polyhedron/base_ZZ.py +@@ -193,7 +193,7 @@ class Polyhedron_ZZ(Polyhedron_base): + sage: p = P._ehrhart_polynomial_latte(maxdet=5, verbose=True) # optional - latte_int + This is LattE integrale ... + ... +- Invocation: count --ehrhart-polynomial '--redundancy-check=none' --cdd '--maxdet=5' /dev/stdin ++ Invocation: latte-count --ehrhart-polynomial '--redundancy-check=none' --cdd '--maxdet=5' /dev/stdin + ... + sage: p # optional - latte_int + 1/2*t^2 + 3/2*t + 1 +@@ -201,7 +201,7 @@ class Polyhedron_ZZ(Polyhedron_base): + sage: p = P._ehrhart_polynomial_latte(dual=True, verbose=True) # optional - latte_int + This is LattE integrale ... + ... +- Invocation: count --ehrhart-polynomial '--redundancy-check=none' --cdd --dual /dev/stdin ++ Invocation: latte-count --ehrhart-polynomial '--redundancy-check=none' --cdd --dual /dev/stdin + ... + sage: p # optional - latte_int + 1/2*t^2 + 3/2*t + 1 +@@ -209,7 +209,7 @@ class Polyhedron_ZZ(Polyhedron_base): + sage: p = P._ehrhart_polynomial_latte(irrational_primal=True, verbose=True) # optional - latte_int + This is LattE integrale ... + ... +- Invocation: count --ehrhart-polynomial '--redundancy-check=none' --cdd --irrational-primal /dev/stdin ++ Invocation: latte-count --ehrhart-polynomial '--redundancy-check=none' --cdd --irrational-primal /dev/stdin + ... + sage: p # optional - latte_int + 1/2*t^2 + 3/2*t + 1 +@@ -217,7 +217,7 @@ class Polyhedron_ZZ(Polyhedron_base): + sage: p = P._ehrhart_polynomial_latte(irrational_all_primal=True, verbose=True) # optional - latte_int + This is LattE integrale ... + ... +- Invocation: count --ehrhart-polynomial '--redundancy-check=none' --cdd --irrational-all-primal /dev/stdin ++ Invocation: latte-count --ehrhart-polynomial '--redundancy-check=none' --cdd --irrational-all-primal /dev/stdin + ... + sage: p # optional - latte_int + 1/2*t^2 + 3/2*t + 1 +@@ -229,7 +229,7 @@ class Polyhedron_ZZ(Polyhedron_base): + ... + RuntimeError: LattE integrale program failed (exit code 1): + ... +- Invocation: count --ehrhart-polynomial '--redundancy-check=none' --cdd '--bim-bam-boum=19' /dev/stdin ++ Invocation: latte-count --ehrhart-polynomial '--redundancy-check=none' --cdd '--bim-bam-boum=19' /dev/stdin + Unknown command/option --bim-bam-boum=19 + """ + # note: the options below are explicitly written in the function +diff --git a/src/sage/interfaces/latte.py b/src/sage/interfaces/latte.py +index 066cedd401..302b39910d 100644 +--- a/src/sage/interfaces/latte.py ++++ b/src/sage/interfaces/latte.py +@@ -95,7 +95,7 @@ def count(arg, ehrhart_polynomial=False, multivariate_generating_function=False, + sage: n = count(cddin, cdd=True, verbose=True, raw_output=True) # optional - latte_int + This is LattE integrale ... + ... +- Invocation: count '--redundancy-check=none' --cdd /dev/stdin ++ Invocation: latte-count '--redundancy-check=none' --cdd /dev/stdin + ... + Total Unimodular Cones: ... + Maximum number of simplicial cones in memory at once: ... +@@ -127,7 +127,7 @@ def count(arg, ehrhart_polynomial=False, multivariate_generating_function=False, + + arg = str_to_bytes(arg) + +- args = ['count'] ++ args = ['latte-count'] + if ehrhart_polynomial and multivariate_generating_function: + raise ValueError + if ehrhart_polynomial: +diff --git a/src/sage/features/latte.py b/src/sage/features/latte.py +index 63d227fd35..040a5cf1f9 100644 +--- a/src/sage/features/latte.py ++++ b/src/sage/features/latte.py +@@ -9,10 +9,10 @@ from . import Executable, Feature, FeatureTestResult + + class Latte_count(Executable): + r""" +- Feature for the executable ``count`` from the LattE suite. ++ Feature for the executable ``latte-count`` from the LattE suite. + """ + def __init__(self): +- Executable.__init__(self, "count", executable="count", ++ Executable.__init__(self, "latte-count", executable="latte-count", + spkg="latte_int", + url=LATTE_URL) + + Copied: sagemath/repos/community-staging-x86_64/sagemath-bliss-0.77.patch (from rev 1083848, sagemath/trunk/sagemath-bliss-0.77.patch) =================================================================== --- community-staging-x86_64/sagemath-bliss-0.77.patch (rev 0) +++ community-staging-x86_64/sagemath-bliss-0.77.patch 2021-12-26 13:45:28 UTC (rev 1083849) @@ -0,0 +1,183 @@ +diff --git a/build/pkgs/bliss/checksums.ini b/build/pkgs/bliss/checksums.ini +index e97d89587b..0c1ebf647b 100644 +--- a/build/pkgs/bliss/checksums.ini ++++ b/build/pkgs/bliss/checksums.ini +@@ -1,4 +1,5 @@ +-tarball=bliss-VERSION.tar.gz +-sha1=1da8f098046824fbfff4c64c337e28b2a082f74f +-md5=452aea8737d3c4ad0d8ff39180be8004 +-cksum=2193930007 ++tarball=bliss-VERSION.zip ++sha1=c91c9dcbc11d66ffbcf6415e09ebe793df37be2a ++md5=5707cbfd9fd00980571c64ab3584c505 ++cksum=1626493724 ++upstream_url=https://users.aalto.fi/~tjunttil/bliss/downloads/bliss-VERSION.zip +diff --git a/build/pkgs/bliss/dependencies b/build/pkgs/bliss/dependencies +index 3546cda461..66d6773d90 100644 +--- a/build/pkgs/bliss/dependencies ++++ b/build/pkgs/bliss/dependencies +@@ -1,4 +1,4 @@ +-# no dependencies ++| cmake + + ---------- + All lines of this file are ignored except the first. +diff --git a/build/pkgs/bliss/package-version.txt b/build/pkgs/bliss/package-version.txt +index e93ee1376f..9e1e206c41 100644 +--- a/build/pkgs/bliss/package-version.txt ++++ b/build/pkgs/bliss/package-version.txt +@@ -1 +1 @@ +-0.73+debian-1+sage-2016-08-02.p0 ++0.77 +diff --git a/build/pkgs/bliss/spkg-install.in b/build/pkgs/bliss/spkg-install.in +index aaf4c3037b..ad1fe8176c 100644 +--- a/build/pkgs/bliss/spkg-install.in ++++ b/build/pkgs/bliss/spkg-install.in +@@ -1,4 +1,6 @@ + cd src +-sdh_configure --disable-gmp ++sdh_cmake -DUSE_GMP=OFF -DCMAKE_VERBOSE_MAKEFILE=ON + sdh_make +-sdh_make_install ++sdh_install src/*.hh $SAGE_LOCAL/include/bliss/ ++sdh_install libbliss.so $SAGE_LOCAL/lib/ ++sdh_install bliss $SAGE_LOCAL/bin/ +diff --git a/build/pkgs/bliss/spkg-src b/build/pkgs/bliss/spkg-src +deleted file mode 100755 +index 90073233b7..0000000000 +--- a/build/pkgs/bliss/spkg-src ++++ /dev/null +@@ -1,28 +0,0 @@ +-#!/bin/sh +-# +-# creates the tarball in the current dir, to be moved to ../../../upstream +-# +-# adapted from cliquer/spkg-src +- +-die () { +- echo >&2 "$@" +- exit 1 +-} +- +-rm -rf bliss/ +-git clone -b sage_package https://github.com/mkoeppe/bliss.git || die "Failed to git clone" +-cd bliss/ +- +-VERSION=`autoconf --trace='AC_INIT:$2'` +-libtoolize || die "Failed to autoreconf" +-autoreconf -fi || die "Failed to autoreconf" +-automake --add-missing --copy || die "automake failed" +-./configure || die "configure failed" +- +-rm -f bliss-$VERSION.tar.gz +-make dist || die "make dist failed" +-mv bliss-$VERSION.tar.gz ../ +-cd .. +-rm -rf bliss/ +- +- +diff --git a/src/sage/graphs/bliss.pyx b/src/sage/graphs/bliss.pyx +index 22e861a587..fa426e3d11 100644 +--- a/src/sage/graphs/bliss.pyx ++++ b/src/sage/graphs/bliss.pyx +@@ -47,22 +47,27 @@ cdef extern from "bliss/graph.hh" namespace "bliss": + cdef cppclass Graph(AbstractGraph): + Graph(const unsigned int) + void add_edge(const unsigned int, const unsigned int) +- void find_automorphisms(Stats&, void (*)(void* , unsigned int, +- const unsigned int*), void*) ++ #void find_automorphisms(Stats&, void (*)(void* , unsigned int, ++ #const unsigned int*), void*) + void change_color(const unsigned int, const unsigned int); +- const unsigned int* canonical_form(Stats&, void (*)(void*,unsigned int, +- const unsigned int*), void*) ++ const unsigned int* canonical_form(Stats&) ++ ++cdef extern from "bliss/digraph.hh" namespace "bliss": + + cdef cppclass Digraph(AbstractGraph): + Digraph(const unsigned int) + void add_edge(const unsigned int, const unsigned int) +- void find_automorphisms(Stats&, void (*)(void* , unsigned int, +- const unsigned int*), void*) ++ #void find_automorphisms(Stats&, void (*)(void* , unsigned int, ++ #const unsigned int*), void*) + void change_color(const unsigned int, const unsigned int); +- const unsigned int* canonical_form(Stats&, void (*)(void*,unsigned int, +- const unsigned int*), void*) ++ const unsigned int* canonical_form(Stats&) + unsigned int get_hash() + ++cdef extern from "bliss_find_automorphisms.h": ++ ++ void bliss_find_automorphisms(Graph*, void (*)(void*, unsigned int, const unsigned int*), void*, Stats&) ++ void bliss_find_automorphisms(Digraph*, void (*)(void*, unsigned int, const unsigned int*), void*, Stats&) ++ + + cdef int encoding_numbits(int n): + r""" +@@ -124,9 +129,6 @@ cdef void add_gen(void *user_param, unsigned int n, const unsigned int *aut): + + sig_free(done) + +-cdef void empty_hook(void *user_param , unsigned int n, const unsigned int *aut): +- return +- + ##################################################### + # constructing bliss graphs from edge lists + ##################################################### +@@ -345,10 +347,10 @@ cdef canonical_form_from_edge_list(int Vnr, list Vout, list Vin, int Lnr=1, list + + if directed: + d = bliss_digraph_from_labelled_edges(Vnr, Lnr, Vout, Vin, labels, partition) +- aut = d.canonical_form(s, empty_hook, NULL) ++ aut = d.canonical_form(s) + else: + g = bliss_graph_from_labelled_edges(Vnr, Lnr, Vout, Vin, labels, partition) +- aut = g.canonical_form(s, empty_hook, NULL) ++ aut = g.canonical_form(s) + + for i in range(len(Vout)): + x = Vout[i] +@@ -640,11 +642,11 @@ cdef automorphism_group_gens_from_edge_list(int Vnr, Vout, Vin, int Lnr=1, label + + if directed: + d = bliss_digraph_from_labelled_edges(Vnr, Lnr, Vout, Vin, labels, partition) +- d.find_automorphisms(s, add_gen, <void*>data) ++ bliss_find_automorphisms(d, add_gen, <void*>data, s) + del d + else: + g = bliss_graph_from_labelled_edges(Vnr, Lnr, Vout, Vin, labels, partition) +- g.find_automorphisms(s, add_gen, <void*>data) ++ bliss_find_automorphisms(g, add_gen, <void*>data, s) + del g + + return [[cyc for cyc in gen if cyc[0] is not None] for gen in gens] +diff --git a/src/sage/graphs/bliss_find_automorphisms.h b/src/sage/graphs/bliss_find_automorphisms.h +new file mode 100644 +index 0000000000..a2c084a163 +--- /dev/null ++++ b/src/sage/graphs/bliss_find_automorphisms.h +@@ -0,0 +1,22 @@ ++#include <bliss/graph.hh> ++#include <bliss/digraph.hh> ++ ++inline void bliss_find_automorphisms(bliss::Graph *graph, void (*hook)(void *user_param, unsigned int n, const unsigned int *aut), void *hook_user_param, bliss::Stats s) ++{ ++ auto report_aut = [&](unsigned int n, const unsigned int *aut) -> void { ++ if(hook) ++ (*hook)(hook_user_param, n, aut); ++ }; ++ ++ graph->find_automorphisms(s, report_aut); ++} ++ ++inline void bliss_find_automorphisms(bliss::Digraph *graph, void (*hook)(void *user_param, unsigned int n, const unsigned int *aut), void *hook_user_param, bliss::Stats s) ++{ ++ auto report_aut = [&](unsigned int n, const unsigned int *aut) -> void { ++ if(hook) ++ (*hook)(hook_user_param, n, aut); ++ }; ++ ++ graph->find_automorphisms(s, report_aut); ++} Copied: sagemath/repos/community-staging-x86_64/sagemath-lcalc2.patch (from rev 1083848, sagemath/trunk/sagemath-lcalc2.patch) =================================================================== --- community-staging-x86_64/sagemath-lcalc2.patch (rev 0) +++ community-staging-x86_64/sagemath-lcalc2.patch 2021-12-26 13:45:28 UTC (rev 1083849) @@ -0,0 +1,507 @@ +diff --git a/src/sage/lfunctions/lcalc.py b/src/sage/lfunctions/lcalc.py +index aabbd47..6efa5fe 100644 +--- a/src/sage/lfunctions/lcalc.py ++++ b/src/sage/lfunctions/lcalc.py +@@ -225,19 +225,54 @@ class LCalc(SageObject): + EXAMPLES:: + + sage: I = CC.0 +- sage: lcalc.values_along_line(0.5, 0.5+20*I, 5) +- [(0.500000000, -1.46035451), (0.500000000 + 4.00000000*I, 0.606783764 + 0.0911121400*I), (0.500000000 + 8.00000000*I, 1.24161511 + 0.360047588*I), (0.500000000 + 12.0000000*I, 1.01593665 - 0.745112472*I), (0.500000000 + 16.0000000*I, 0.938545408 + 1.21658782*I)] ++ sage: values = lcalc.values_along_line(0.5, 0.5+20*I, 5) ++ sage: values[0][0] # abs tol 1e-8 ++ 0.5 ++ sage: values[0][1] # abs tol 1e-8 ++ -1.46035451 + 0.0*I ++ sage: values[1][0] # abs tol 1e-8 ++ 0.5 + 4.0*I ++ sage: values[1][1] # abs tol 1e-8 ++ 0.606783764 + 0.0911121400*I ++ sage: values[2][0] # abs tol 1e-8 ++ 0.5 + 8.0*I ++ sage: values[2][1] # abs tol 1e-8 ++ 1.24161511 + 0.360047588*I ++ sage: values[3][0] # abs tol 1e-8 ++ 0.5 + 12.0*I ++ sage: values[3][1] # abs tol 1e-8 ++ 1.01593665 - 0.745112472*I ++ sage: values[4][0] # abs tol 1e-8 ++ 0.5 + 16.0*I ++ sage: values[4][1] # abs tol 1e-8 ++ 0.938545408 + 1.21658782*I + + Sometimes warnings are printed (by lcalc) when this command is + run:: + + sage: E = EllipticCurve('389a') +- sage: E.lseries().values_along_line(0.5, 3, 5) +- [(0.000000000, 0.209951303), +- (0.500000000, -...e-16), +- (1.00000000, 0.133768433), +- (1.50000000, 0.360092864), +- (2.00000000, 0.552975867)] ++ sage: values = E.lseries().values_along_line(0.5, 3, 5) ++ sage: values[0][0] # abs tol 1e-8 ++ 0.0 ++ sage: values[0][1] # abs tol 1e-8 ++ 0.209951303 + 0.0*I ++ sage: values[1][0] # abs tol 1e-8 ++ 0.5 ++ sage: values[1][1] # abs tol 1e-8 ++ 0.0 + 0.0*I ++ sage: values[2][0] # abs tol 1e-8 ++ 1.0 ++ sage: values[2][1] # abs tol 1e-8 ++ 0.133768433 - 0.0*I ++ sage: values[3][0] # abs tol 1e-8 ++ 1.5 ++ sage: values[3][1] # abs tol 1e-8 ++ 0.360092864 - 0.0*I ++ sage: values[4][0] # abs tol 1e-8 ++ 2.0 ++ sage: values[4][1] # abs tol 1e-8 ++ 0.552975867 + 0.0*I ++ + """ + L = self._compute_L(L) + CC = sage.rings.all.ComplexField(prec) +@@ -281,8 +316,31 @@ class LCalc(SageObject): + + EXAMPLES:: + +- sage: lcalc.twist_values(0.5, -10, 10) +- [(-8, 1.10042141), (-7, 1.14658567), (-4, 0.667691457), (-3, 0.480867558), (5, 0.231750947), (8, 0.373691713)] ++ sage: values = lcalc.twist_values(0.5, -10, 10) ++ sage: values[0][0] ++ -8 ++ sage: values[0][1] # abs tol 1e-8 ++ 1.10042141 + 0.0*I ++ sage: values[1][0] ++ -7 ++ sage: values[1][1] # abs tol 1e-8 ++ 1.14658567 + 0.0*I ++ sage: values[2][0] ++ -4 ++ sage: values[2][1] # abs tol 1e-8 ++ 0.667691457 + 0.0*I ++ sage: values[3][0] ++ -3 ++ sage: values[3][1] # abs tol 1e-8 ++ 0.480867558 + 0.0*I ++ sage: values[4][0] ++ 5 ++ sage: values[4][1] # abs tol 1e-8 ++ 0.231750947 + 0.0*I ++ sage: values[5][0] ++ 8 ++ sage: values[5][1] # abs tol 1e-8 ++ 0.373691713 + 0.0*I + """ + L = self._compute_L(L) + CC = sage.rings.all.ComplexField(prec) +diff --git a/src/sage/lfunctions/zero_sums.pyx b/src/sage/lfunctions/zero_sums.pyx +index 225fe7d..8b0e566 100644 +--- a/src/sage/lfunctions/zero_sums.pyx ++++ b/src/sage/lfunctions/zero_sums.pyx +@@ -829,8 +829,11 @@ cdef class LFunctionZeroSum_abstract(SageObject): + EXAMPLES:: + + sage: E = EllipticCurve("11a") +- sage: E.lseries().zeros(2) +- [6.36261389, 8.60353962] ++ sage: zeros = E.lseries().zeros(2) ++ sage: zeros[0] # abs tol 1e-8 ++ 6.36261389 ++ sage: zeros[1] # abs tol 1e-8 ++ 8.60353962 + + E is a rank zero curve; the lowest zero has imaginary part ~6.36. The + zero sum with tau=0 indicates that there are no zeros at the central +diff --git a/src/sage/libs/lcalc/lcalc_Lfunction.pxd b/src/sage/libs/lcalc/lcalc_Lfunction.pxd +index d1dbb5d..5edf084 100644 +--- a/src/sage/libs/lcalc/lcalc_Lfunction.pxd ++++ b/src/sage/libs/lcalc/lcalc_Lfunction.pxd +@@ -21,7 +21,7 @@ cdef extern from "lcalc_sage.h": + int (* compute_rank) () + double (* N) (double T) + void (* find_zeros_v)(double T1, double T2, double stepsize, doublevec result ) +- void (*find_zeros_via_N_v)(long count,int do_negative,double max_refine, int rank, int test_explicit_formula, doublevec result) ++ int (*find_zeros)(long count, long start, double max_refine, int rank, const char* message_stamp, doublevec* result) + void (*print_data_L)() + + #Constructor and destructor +@@ -38,7 +38,7 @@ cdef extern from "lcalc_sage.h": + double (* N) (double T) + double *dirichlet_coefficient + void (* find_zeros_v)(double T1, double T2, double stepsize, doublevec result ) +- void (*find_zeros_via_N_v)(long count,int do_negative,double max_refine, int rank, int test_explicit_formula, doublevec result) ++ int (*find_zeros)(long count, long start, double max_refine, int rank, const char* message_stamp, doublevec* result) + void (*print_data_L)() + + #Constructor and destructor +@@ -54,7 +54,7 @@ cdef extern from "lcalc_sage.h": + int (* compute_rank) () + double (* N) (double T) + void (* find_zeros_v)(double T1, double T2, double stepsize, doublevec result ) +- void (*find_zeros_via_N_v)(long count,int do_negative,double max_refine, int rank, int test_explicit_formula, doublevec result) ++ int (*find_zeros)(long count, long start, double max_refine, int rank, const char* message_stamp, doublevec* result) + void (*print_data_L)() + + #Constructor and destructor +@@ -70,7 +70,7 @@ cdef extern from "lcalc_sage.h": + int (* compute_rank) () + double (* N) (double T) + void (* find_zeros_v)(double T1, double T2, double stepsize, doublevec result ) +- void (*find_zeros_via_N_v)(long count,int do_negative,double max_refine, int rank, int test_explicit_formula, doublevec result)#puts result in vector<double> result ++ int (*find_zeros)(long count, long start, double max_refine, int rank, const char* message_stamp, doublevec* result) + void (*find_zeros_via_N)(long count,int do_negative,double max_refine, int rank, int test_explicit_formula, char *filename) #puts result in filename + + #Constructor and destructor +@@ -111,7 +111,7 @@ cdef class Lfunction: + #strange bug, replacing Double with double gives me a compile error + cdef Double __typedN(self, double T) + cdef void __find_zeros_v(self, double T1, double T2, double stepsize,doublevec *result) +- cdef void __find_zeros_via_N_v(self, long count,int do_negative,double max_refine, int rank, int test_explicit_formula,doublevec *result) ++ cdef int __find_zeros(self, long count, long start, double max_refine, int rank, const char* message_stamp, doublevec* result) + + cdef str _repr + +diff --git a/src/sage/libs/lcalc/lcalc_Lfunction.pyx b/src/sage/libs/lcalc/lcalc_Lfunction.pyx +index 7e54d7e..88a6e13 100644 +--- a/src/sage/libs/lcalc/lcalc_Lfunction.pyx ++++ b/src/sage/libs/lcalc/lcalc_Lfunction.pyx +@@ -143,29 +143,29 @@ cdef class Lfunction: + sage: chi = DirichletGroup(5)[2] #This is a quadratic character + sage: from sage.libs.lcalc.lcalc_Lfunction import * + sage: L=Lfunction_from_character(chi, type="int") +- sage: L.value(.5) # abs tol 3e-15 ++ sage: L.value(.5) # abs tol 1e-8 + 0.231750947504016 + 5.75329642226136e-18*I +- sage: L.value(.2+.4*I) +- 0.102558603193... + 0.190840777924...*I ++ sage: L.value(.2+.4*I) # abs tol 1e-8 ++ 0.102558603193 + 0.190840777924*I + + sage: L=Lfunction_from_character(chi, type="double") +- sage: L.value(.6) # abs tol 3e-15 ++ sage: L.value(.6) # abs tol 1e-8 + 0.274633355856345 + 6.59869267328199e-18*I +- sage: L.value(.6+I) +- 0.362258705721... + 0.433888250620...*I ++ sage: L.value(.6+I) # abs tol 1e-8 ++ 0.362258705721 + 0.433888250620*I + + sage: chi = DirichletGroup(5)[1] + sage: L=Lfunction_from_character(chi, type="complex") +- sage: L.value(.5) +- 0.763747880117... + 0.216964767518...*I +- sage: L.value(.6+5*I) +- 0.702723260619... - 1.10178575243...*I ++ sage: L.value(.5) # abs tol 1e-8 ++ 0.763747880117 + 0.216964767518*I ++ sage: L.value(.6+5*I) # abs tol 1e-8 ++ 0.702723260619 - 1.10178575243*I + + sage: L=Lfunction_Zeta() +- sage: L.value(.5) +- -1.46035450880... +- sage: L.value(.4+.5*I) +- -0.450728958517... - 0.780511403019...*I ++ sage: L.value(.5) # abs tol 1e-8 ++ -1.46035450880 + 0.0*I ++ sage: L.value(.4+.5*I) # abs tol 1e-8 ++ -0.450728958517 - 0.780511403019*I + """ + cdef ComplexNumber complexified_s = CCC(s) + cdef c_Complex z = new_Complex(mpfr_get_d(complexified_s.__re, MPFR_RNDN), mpfr_get_d(complexified_s.__im, MPFR_RNDN)) +@@ -185,23 +185,21 @@ cdef class Lfunction: + sage: chi = DirichletGroup(5)[2] # Quadratic character + sage: from sage.libs.lcalc.lcalc_Lfunction import * + sage: L = Lfunction_from_character(chi, type="int") +- sage: L.hardy_z_function(0) +- 0.231750947504... +- sage: L.hardy_z_function(.5).imag() # abs tol 1e-15 ++ sage: L.hardy_z_function(0) # abs tol 1e-8 ++ 0.231750947504 + 0.0*I ++ sage: L.hardy_z_function(.5).imag() # abs tol 1e-8 + 1.17253174178320e-17 +- sage: L.hardy_z_function(.4+.3*I) +- 0.2166144222685... - 0.00408187127850...*I + sage: chi = DirichletGroup(5)[1] + sage: L = Lfunction_from_character(chi, type="complex") +- sage: L.hardy_z_function(0) +- 0.793967590477... +- sage: L.hardy_z_function(.5).imag() # abs tol 1e-15 ++ sage: L.hardy_z_function(0) # abs tol 1e-8 ++ 0.793967590477 + 0.0*I ++ sage: L.hardy_z_function(.5).imag() # abs tol 1e-8 + 0.000000000000000 + sage: E = EllipticCurve([-82,0]) + sage: L = Lfunction_from_elliptic_curve(E, number_of_coeffs=40000) +- sage: L.hardy_z_function(2.1) +- -0.00643179176869... +- sage: L.hardy_z_function(2.1).imag() # abs tol 1e-15 ++ sage: L.hardy_z_function(2.1) # abs tol 1e-8 ++ -0.00643179176863296 - 1.47189978221606e-19*I ++ sage: L.hardy_z_function(2.1).imag() # abs tol 1e-8 + -3.93833660115668e-19 + """ + #This takes s -> .5 + I*s +@@ -241,8 +239,8 @@ cdef class Lfunction: + sage: from sage.libs.lcalc.lcalc_Lfunction import * + sage: chi = DirichletGroup(5)[2] #This is a quadratic character + sage: L=Lfunction_from_character(chi, type="complex") +- sage: L.__N(10) +- 3.17043978326... ++ sage: L.__N(10) # abs tol 1e-8 ++ 4.0 + """ + cdef RealNumber real_T=RRR(T) + cdef double double_T = mpfr_get_d(real_T.value, MPFR_RNDN) +@@ -307,18 +305,21 @@ cdef class Lfunction: + return returnvalue + + #The default values are from L.h. See L.h +- def find_zeros_via_N(self, count=0, do_negative=False, max_refine=1025, +- rank=-1, test_explicit_formula=0): ++ def find_zeros_via_N(self, count=0, start=0, max_refine=1025, rank=-1): + """ +- Finds ``count`` number of zeros with positive imaginary part +- starting at real axis. This function also verifies that all +- the zeros have been found. ++ Find ``count`` zeros (in order of increasing magnitude) and output ++ their imaginary parts. This function verifies that no zeros ++ are missed, and that all values output are indeed zeros. ++ ++ If this L-function is self-dual (if its Dirichlet coefficients ++ are real, up to a tolerance of 1e-6), then only the zeros with ++ positive imaginary parts are output. Their conjugates, which ++ are also zeros, are not output. + + INPUT: + + - ``count`` - number of zeros to be found +- - ``do_negative`` - (default: False) False to ignore zeros below the +- real axis. ++ - ``start`` - (default: 0) how many initial zeros to skip + - ``max_refine`` - when some zeros are found to be missing, the step + size used to find zeros is refined. max_refine gives an upper limit + on when lcalc should give up. Use default value unless you know +@@ -326,13 +327,9 @@ cdef class Lfunction: + - ``rank`` - integer (default: -1) analytic rank of the L-function. + If -1 is passed, then we attempt to compute it. (Use default if in + doubt) +- - ``test_explicit_formula`` - integer (default: 0) If nonzero, test +- the explicit formula for additional confidence that all the zeros +- have been found and are accurate. This is still being tested, so +- using the default is recommended. + + OUTPUT: +- ++ + list -- A list of the imaginary parts of the zeros that have been found + + EXAMPLES:: +@@ -349,21 +346,26 @@ cdef class Lfunction: + + sage: chi = DirichletGroup(5)[1] + sage: L=Lfunction_from_character(chi, type="complex") +- sage: L.find_zeros_via_N(3) +- [6.18357819545..., 8.45722917442..., 12.6749464170...] ++ sage: zeros = L.find_zeros_via_N(3) ++ sage: zeros[0] # abs tol 1e-8 ++ -4.13290370521286 ++ sage: zeros[1] # abs tol 1e-8 ++ 6.18357819545086 ++ sage: zeros[2] # abs tol 1e-8 ++ 8.45722917442320 + + sage: L=Lfunction_Zeta() + sage: L.find_zeros_via_N(3) + [14.1347251417..., 21.0220396387..., 25.0108575801...] + """ +- cdef Integer count_I = Integer(count) +- cdef Integer do_negative_I = Integer(do_negative) +- cdef RealNumber max_refine_R = RRR(max_refine) +- cdef Integer rank_I = Integer(rank) +- cdef Integer test_explicit_I = Integer(test_explicit_formula) ++ ++ # This is the default value for message_stamp, but we have to ++ # pass it explicitly since we're passing in the next argument, ++ # our &result pointer. ++ cdef const char* message_stamp = "" + cdef doublevec result + sig_on() +- self.__find_zeros_via_N_v(mpz_get_si(count_I.value), mpz_get_si(do_negative_I.value), mpfr_get_d(max_refine_R.value, MPFR_RNDN), mpz_get_si(rank_I.value), mpz_get_si(test_explicit_I.value), &result) ++ self.__find_zeros(count, start, max_refine, rank, message_stamp, &result) + sig_off() + returnvalue = [] + for i in range(result.size()): +@@ -390,7 +392,7 @@ cdef class Lfunction: + cdef void __find_zeros_v(self,double T1, double T2, double stepsize, doublevec *result): + raise NotImplementedError + +- cdef void __find_zeros_via_N_v(self, long count,int do_negative,double max_refine, int rank, int test_explicit_formula, doublevec *result): ++ cdef int __find_zeros(self, long count, long start, double max_refine, int rank, const char* message_stamp, doublevec *result): + raise NotImplementedError + + ############################################################################## +@@ -486,8 +488,8 @@ cdef class Lfunction_I(Lfunction): + cdef double __typedN(self, double T): + return (<c_Lfunction_I *>self.thisptr).N(T) + +- cdef void __find_zeros_via_N_v(self, long count,int do_negative,double max_refine, int rank, int test_explicit_formula, doublevec *result): +- (<c_Lfunction_I *>self.thisptr).find_zeros_via_N_v(count, do_negative, max_refine, rank, test_explicit_formula, result[0]) ++ cdef int __find_zeros(self, long count, long start, double max_refine, int rank, const char* message_stamp, doublevec *result): ++ (<c_Lfunction_I *>self.thisptr).find_zeros(count, start, max_refine, rank, message_stamp, result) + + # debug tools + def _print_data_to_standard_output(self): +@@ -500,7 +502,7 @@ cdef class Lfunction_I(Lfunction): + sage: from sage.libs.lcalc.lcalc_Lfunction import * + sage: chi = DirichletGroup(5)[2] #This is a quadratic character + sage: L=Lfunction_from_character(chi, type="int") +- sage: L._print_data_to_standard_output() # tol 1e-15 ++ sage: L._print_data_to_standard_output() # tol 1e-8 + ----------------------------------------------- + <BLANKLINE> + Name of L_function: +@@ -624,8 +626,8 @@ cdef class Lfunction_D(Lfunction): + cdef double __typedN(self, double T): + return (<c_Lfunction_D *>self.thisptr).N(T) + +- cdef void __find_zeros_via_N_v(self, long count,int do_negative,double max_refine, int rank, int test_explicit_formula, doublevec *result): +- (<c_Lfunction_D *>self.thisptr).find_zeros_via_N_v(count, do_negative, max_refine, rank, test_explicit_formula, result[0]) ++ cdef int __find_zeros(self, long count, long start,double max_refine, int rank, const char* message_stamp, doublevec *result): ++ (<c_Lfunction_D *>self.thisptr).find_zeros(count, start, max_refine, rank, message_stamp, result) + + # debug tools + def _print_data_to_standard_output(self): +@@ -638,7 +640,7 @@ cdef class Lfunction_D(Lfunction): + sage: from sage.libs.lcalc.lcalc_Lfunction import * + sage: chi = DirichletGroup(5)[2] #This is a quadratic character + sage: L=Lfunction_from_character(chi, type="double") +- sage: L._print_data_to_standard_output() # tol 1e-15 ++ sage: L._print_data_to_standard_output() # tol 1e-8 + ----------------------------------------------- + <BLANKLINE> + Name of L_function: +@@ -769,8 +771,8 @@ cdef class Lfunction_C: + cdef double __typedN(self, double T): + return (<c_Lfunction_C *>self.thisptr).N(T) + +- cdef void __find_zeros_via_N_v(self, long count,int do_negative,double max_refine, int rank, int test_explicit_formula, doublevec *result): +- (<c_Lfunction_C *>self.thisptr).find_zeros_via_N_v(count, do_negative, max_refine, rank, test_explicit_formula, result[0]) ++ cdef int __find_zeros(self, long count, long start, double max_refine, int rank, const char* message_stamp, doublevec *result): ++ (<c_Lfunction_C *>self.thisptr).find_zeros(count, start, max_refine, rank, message_stamp, result) + + # debug tools + def _print_data_to_standard_output(self): +@@ -783,7 +785,7 @@ cdef class Lfunction_C: + sage: from sage.libs.lcalc.lcalc_Lfunction import * + sage: chi = DirichletGroup(5)[1] + sage: L=Lfunction_from_character(chi, type="complex") +- sage: L._print_data_to_standard_output() # tol 1e-15 ++ sage: L._print_data_to_standard_output() # tol 1e-8 + ----------------------------------------------- + <BLANKLINE> + Name of L_function: +@@ -854,8 +856,8 @@ cdef class Lfunction_Zeta(Lfunction): + cdef double __typedN(self, double T): + return (<c_Lfunction_Zeta *>self.thisptr).N(T) + +- cdef void __find_zeros_via_N_v(self, long count,int do_negative,double max_refine, int rank, int test_explicit_formula, doublevec *result): +- (<c_Lfunction_Zeta *>self.thisptr).find_zeros_via_N_v(count, do_negative, max_refine, rank, test_explicit_formula, result[0]) ++ cdef int __find_zeros(self, long count, long start, double max_refine, int rank, const char* message_stamp, doublevec *result): ++ (<c_Lfunction_Zeta *>self.thisptr).find_zeros(count, start, max_refine, rank, message_stamp, result) + + def __dealloc__(self): + """ +@@ -950,10 +952,11 @@ def Lfunction_from_elliptic_curve(E, number_of_coeffs=10000): + sage: L = Lfunction_from_elliptic_curve(EllipticCurve('37')) + sage: L + L-function with real Dirichlet coefficients +- sage: L.value(0.5).abs() < 1e-15 # "noisy" zero on some platforms (see #9615) ++ sage: L.value(0.5).abs() < 1e-8 # "noisy" zero on some platforms (see #9615) + True +- sage: L.value(0.5, derivative=1) +- 0.305999... ++ sage: L.value(0.5, derivative=1) # abs tol 1e-6 ++ 0.305999773835200 + 0.0*I ++ + """ + import sage.libs.lcalc.lcalc_Lfunction + Q = RRR(E.conductor()).sqrt() / RRR(2 * pi) +diff --git a/src/sage/libs/lcalc/lcalc_sage.h b/src/sage/libs/lcalc/lcalc_sage.h +index 4985289..891a40c 100644 +--- a/src/sage/libs/lcalc/lcalc_sage.h ++++ b/src/sage/libs/lcalc/lcalc_sage.h +@@ -1,4 +1,4 @@ +-#include "Lfunction/L.h" ++#include "lcalc/L.h" + int *new_ints(int l) + { + return new int[l]; +@@ -62,4 +62,3 @@ void testL(L_function<Complex> *L) + cout << "Value at 1" << L->value(1.0) <<endl; + cout << "Value at .5+I" << L->value(.5+I) <<endl; + } +- +diff --git a/src/sage/modular/dirichlet.py b/src/sage/modular/dirichlet.py +index d101f6a..23a9b1b 100644 +--- a/src/sage/modular/dirichlet.py ++++ b/src/sage/modular/dirichlet.py +@@ -751,8 +751,8 @@ class DirichletCharacter(MultiplicativeGroupElement): + sage: a = a.primitive_character() + sage: L = a.lfunction(algorithm='lcalc'); L + L-function with complex Dirichlet coefficients +- sage: L.value(4) # abs tol 1e-14 +- 0.988944551741105 - 5.16608739123418e-18*I ++ sage: L.value(4) # abs tol 1e-8 ++ 0.988944551741105 + 0.0*I + """ + if algorithm is None: + algorithm = 'pari' +diff --git a/src/sage/schemes/elliptic_curves/ell_rational_field.py b/src/sage/schemes/elliptic_curves/ell_rational_field.py +index bda999e..1736ce4 100644 +--- a/src/sage/schemes/elliptic_curves/ell_rational_field.py ++++ b/src/sage/schemes/elliptic_curves/ell_rational_field.py +@@ -1516,7 +1516,7 @@ class EllipticCurve_rational_field(EllipticCurve_number_field): + sage: EllipticCurve([1234567,89101112]).analytic_rank(algorithm='rubinstein') + Traceback (most recent call last): + ... +- RuntimeError: unable to compute analytic rank using rubinstein algorithm (unable to convert ' 6.19283e+19 and is too large' to an integer) ++ RuntimeError: unable to compute analytic rank using rubinstein algorithm (unable to convert ' 6.19283... and is too large' to an integer) + sage: EllipticCurve([1234567,89101112]).analytic_rank(algorithm='sympow') + Traceback (most recent call last): + ... +diff --git a/src/sage/schemes/elliptic_curves/lseries_ell.py b/src/sage/schemes/elliptic_curves/lseries_ell.py +index 1fcd02f..8536db5 100644 +--- a/src/sage/schemes/elliptic_curves/lseries_ell.py ++++ b/src/sage/schemes/elliptic_curves/lseries_ell.py +@@ -400,8 +400,22 @@ class Lseries_ell(SageObject): + + sage: E = EllipticCurve('37a') + sage: vals = E.lseries().twist_values(1, -12, -4) +- sage: vals # abs tol 1e-15 +- [(-11, 1.47824342), (-8, 8.9590946e-18), (-7, 1.85307619), (-4, 2.45138938)] ++ sage: vals[0][0] ++ -11 ++ sage: vals[0][1] # abs tol 1e-8 ++ 1.47824342 + 0.0*I ++ sage: vals[1][0] ++ -8 ++ sage: vals[1][1] # abs tol 1e-8 ++ 0.0 + 0.0*I ++ sage: vals[2][0] ++ -7 ++ sage: vals[2][1] # abs tol 1e-8 ++ 1.85307619 + 0.0*I ++ sage: vals[3][0] ++ -4 ++ sage: vals[3][1] # abs tol 1e-8 ++ 2.45138938 + 0.0*I + sage: F = E.quadratic_twist(-8) + sage: F.rank() + 1 + Copied: sagemath/repos/community-staging-x86_64/sagemath-linbox-1.7.patch (from rev 1083848, sagemath/trunk/sagemath-linbox-1.7.patch) =================================================================== --- community-staging-x86_64/sagemath-linbox-1.7.patch (rev 0) +++ community-staging-x86_64/sagemath-linbox-1.7.patch 2021-12-26 13:45:28 UTC (rev 1083849) @@ -0,0 +1,58 @@ +diff --git a/src/sage/libs/linbox/conversion.pxd b/src/sage/libs/linbox/conversion.pxd +index 7794c9e..1753277 100644 +--- a/src/sage/libs/linbox/conversion.pxd ++++ b/src/sage/libs/linbox/conversion.pxd +@@ -177,9 +177,8 @@ cdef inline Vector_integer_dense new_sage_vector_integer_dense(P, DenseVector_in + - v -- linbox vector + """ + cdef Vector_integer_dense res = P() +- cdef cppvector[Integer] * vec = &v.refRep() + cdef size_t i + for i in range(<size_t> res._degree): +- mpz_set(res._entries[i], vec[0][i].get_mpz_const()) ++ mpz_set(res._entries[i], v.getEntry(i).get_mpz_const()) + + return res +diff --git a/src/sage/libs/linbox/linbox.pxd b/src/sage/libs/linbox/linbox.pxd +index 9112d15..dcc4829 100644 +--- a/src/sage/libs/linbox/linbox.pxd ++++ b/src/sage/libs/linbox/linbox.pxd +@@ -32,7 +32,7 @@ cdef extern from "linbox/matrix/dense-matrix.h": + ctypedef Modular_double Field + ctypedef double Element + DenseMatrix_Modular_double(Field F, size_t m, size_t n) +- DenseMatrix_Modular_double(Field F, Element*, size_t m, size_t n) ++ DenseMatrix_Modular_double(Field F, size_t m, size_t n, Element*) + void setEntry(size_t i, size_t j, Element& a) + Element &getEntry(size_t i, size_t j) + +@@ -42,7 +42,7 @@ cdef extern from "linbox/matrix/dense-matrix.h": + ctypedef Modular_float Field + ctypedef float Element + DenseMatrix_Modular_float(Field F, size_t m, size_t n) +- DenseMatrix_Modular_float(Field F, Element*, size_t m, size_t n) ++ DenseMatrix_Modular_float(Field F, size_t m, size_t n, Element*) + void setEntry(size_t i, size_t j, Element& a) + Element &getEntry(size_t i, size_t j) + +@@ -101,7 +101,6 @@ cdef extern from "linbox/vector/vector.h": + DenseVector_integer (Field &F) + DenseVector_integer (Field &F, long& m) + DenseVector_integer (Field &F, cppvector[Integer]&) +- cppvector[Element]& refRep() + size_t size() + void resize(size_t) + void resize(size_t n, const Element&) +diff --git a/src/sage/matrix/matrix_modn_dense_template.pxi b/src/sage/matrix/matrix_modn_dense_template.pxi +index 010365d..3d60726 100644 +--- a/src/sage/matrix/matrix_modn_dense_template.pxi ++++ b/src/sage/matrix/matrix_modn_dense_template.pxi +@@ -219,7 +219,7 @@ cdef inline linbox_echelonize_efd(celement modulus, celement* entries, Py_ssize_ + return 0,[] + + cdef ModField *F = new ModField(<long>modulus) +- cdef DenseMatrix *A = new DenseMatrix(F[0], <ModField.Element*>entries,<Py_ssize_t>nrows, <Py_ssize_t>ncols) ++ cdef DenseMatrix *A = new DenseMatrix(F[0], <Py_ssize_t>nrows, <Py_ssize_t>ncols, <ModField.Element*>entries) + cdef Py_ssize_t r = reducedRowEchelonize(A[0]) + cdef Py_ssize_t i,j + for i in range(nrows): Copied: sagemath/repos/community-staging-x86_64/sagemath-lrcalc2.patch (from rev 1083848, sagemath/trunk/sagemath-lrcalc2.patch) =================================================================== --- community-staging-x86_64/sagemath-lrcalc2.patch (rev 0) +++ community-staging-x86_64/sagemath-lrcalc2.patch 2021-12-26 13:45:28 UTC (rev 1083849) @@ -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 <asb...@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 Copied: sagemath/repos/community-staging-x86_64/sagemath-mpmath.patch (from rev 1083848, sagemath/trunk/sagemath-mpmath.patch) =================================================================== --- community-staging-x86_64/sagemath-mpmath.patch (rev 0) +++ community-staging-x86_64/sagemath-mpmath.patch 2021-12-26 13:45:28 UTC (rev 1083849) @@ -0,0 +1,14 @@ +diff --git a/src/sage/env.py b/src/sage/env.py +index e5af037..40ace13 100644 +--- a/src/sage/env.py ++++ b/src/sage/env.py +@@ -237,6 +237,9 @@ LIBSINGULAR_PATH = var("LIBSINGULAR_PATH", "libSingular.so") + OPENMP_CFLAGS = var("OPENMP_CFLAGS", "") + OPENMP_CXXFLAGS = var("OPENMP_CXXFLAGS", "") + ++# Make sure mpmath uses Sage types ++os.environ['MPMATH_SAGE'] = '1' ++ + # misc + SAGE_BANNER = var("SAGE_BANNER", "") + SAGE_IMPORTALL = var("SAGE_IMPORTALL", "yes") Copied: sagemath/repos/community-staging-x86_64/sagemath-optional-packages.patch (from rev 1083848, sagemath/trunk/sagemath-optional-packages.patch) =================================================================== --- community-staging-x86_64/sagemath-optional-packages.patch (rev 0) +++ community-staging-x86_64/sagemath-optional-packages.patch 2021-12-26 13:45:28 UTC (rev 1083849) @@ -0,0 +1,17 @@ +diff --git a/build/pkgs/sagelib/src/setup.py b/build/pkgs/sagelib/src/setup.py +index 0d7c29d746..fb34cbfd5e 100755 +--- a/build/pkgs/sagelib/src/setup.py ++++ b/build/pkgs/sagelib/src/setup.py +@@ -75,10 +75,9 @@ if sdist: + else: + distributions = [''] + optional_packages_with_extensions = ['mcqd', 'bliss', 'tdlib', 'primecount', +- 'coxeter3', 'fes', 'sirocco', 'meataxe'] ++ 'coxeter3', 'sirocco', 'meataxe'] + distributions += ['sage-{}'.format(pkg) +- for pkg in optional_packages_with_extensions +- if is_package_installed_and_updated(pkg)] ++ for pkg in optional_packages_with_extensions] + log.warn('distributions = {0}'.format(distributions)) + + from sage_setup.find import find_python_sources Copied: sagemath/repos/community-staging-x86_64/sagemath-singular-4.2.1.p1.patch (from rev 1083848, sagemath/trunk/sagemath-singular-4.2.1.p1.patch) =================================================================== --- community-staging-x86_64/sagemath-singular-4.2.1.p1.patch (rev 0) +++ community-staging-x86_64/sagemath-singular-4.2.1.p1.patch 2021-12-26 13:45:28 UTC (rev 1083849) @@ -0,0 +1,266 @@ +diff --git a/src/sage/libs/singular/decl.pxd b/src/sage/libs/singular/decl.pxd +index 806937ff6e..68741d7588 100644 +--- a/src/sage/libs/singular/decl.pxd ++++ b/src/sage/libs/singular/decl.pxd +@@ -747,21 +747,21 @@ cdef extern from "singular/Singular/libsingular.h": + + # general number constructor + +- number *n_Init(int n, ring *r) ++ number *n_Init(int n, n_Procs_s *cf) + + # general number destructor + +- void n_Delete(number **n, ring *r) ++ void n_Delete(number **n, n_Procs_s *cf) + + # Copy this number +- number *n_Copy(number *n, ring* r) ++ number *n_Copy(number *n, n_Procs_s *cf) + + # Invert this number + int n_IsUnit(number *n, const n_Procs_s *cf) + number *n_Invers(number *n, const n_Procs_s *cf) + + # Characteristic of coefficient domain +- int n_GetChar(const ring* r) ++ int n_GetChar(const n_Procs_s *cf) + + # rational number from int + +diff --git a/src/sage/libs/singular/polynomial.pyx b/src/sage/libs/singular/polynomial.pyx +index 7687de8f2d..027e0b574a 100644 +--- a/src/sage/libs/singular/polynomial.pyx ++++ b/src/sage/libs/singular/polynomial.pyx +@@ -130,7 +130,7 @@ cdef int singular_polynomial_rmul(poly **ret, poly *p, RingElement n, ring *r): + rChangeCurrRing(r) + cdef number *_n = sa2si(n, r) + ret[0] = pp_Mult_nn(p, _n, r) +- n_Delete(&_n, r) ++ n_Delete(&_n, r.cf) + return 0 + + cdef int singular_polynomial_call(poly **ret, poly *p, ring *r, list args, poly *(*get_element)(object)): +@@ -275,7 +275,7 @@ cdef int singular_polynomial_cmp(poly *p, poly *q, ring *r): + h = r.cf.cfSub(p_GetCoeff(p, r),p_GetCoeff(q, r),r.cf) + # compare coeffs + ret = -1+r.cf.cfIsZero(h,r.cf)+2*r.cf.cfGreaterZero(h, r.cf) # -1: <, 0:==, 1: > +- n_Delete(&h, r) ++ n_Delete(&h, r.cf) + p = pNext(p) + q = pNext(q) + +@@ -346,7 +346,7 @@ cdef int singular_polynomial_div_coeff(poly** ret, poly *p, poly *q, ring *r) ex + cdef number *n = p_GetCoeff(q, r) + n = r.cf.cfInvers(n,r.cf) + ret[0] = pp_Mult_nn(p, n, r) +- n_Delete(&n, r) ++ n_Delete(&n, r.cf) + sig_off() + return 0 + +diff --git a/src/sage/libs/singular/singular.pyx b/src/sage/libs/singular/singular.pyx +index ce93c3b8cb..c4eba5fe59 100644 +--- a/src/sage/libs/singular/singular.pyx ++++ b/src/sage/libs/singular/singular.pyx +@@ -669,7 +669,7 @@ cdef object si2sa(number *n, ring *_ring, object base): + cdef number *sa2si(Element elem, ring * _ring): + cdef int i = 0 + if isinstance(elem._parent, FiniteField_prime_modn): +- return n_Init(int(elem),_ring) ++ return n_Init(int(elem),_ring.cf) + + elif isinstance(elem._parent, RationalField): + return sa2si_QQ(elem, _ring) +@@ -690,7 +690,7 @@ cdef number *sa2si(Element elem, ring * _ring): + return sa2si_NF(elem, _ring) + elif isinstance(elem._parent, IntegerModRing_generic): + if _ring.cf.type == n_unknown: +- return n_Init(int(elem),_ring) ++ return n_Init(int(elem),_ring.cf) + return sa2si_ZZmod(elem, _ring) + else: + raise ValueError("cannot convert to SINGULAR number") +diff --git a/src/sage/rings/polynomial/multi_polynomial_ideal_libsingular.pyx b/src/sage/rings/polynomial/multi_polynomial_ideal_libsingular.pyx +index 6f884ea2c1..dcbc2a52a8 100644 +--- a/src/sage/rings/polynomial/multi_polynomial_ideal_libsingular.pyx ++++ b/src/sage/rings/polynomial/multi_polynomial_ideal_libsingular.pyx +@@ -329,7 +329,7 @@ def interred_libsingular(I): + n = r.cf.cfInvers(n,r.cf) + result.m[j] = pp_Mult_nn(p, n, r) + p_Delete(&p,r) +- n_Delete(&n,r) ++ n_Delete(&n,r.cf) + + id_Delete(&i,r) + +diff --git a/src/sage/rings/polynomial/multi_polynomial_libsingular.pyx b/src/sage/rings/polynomial/multi_polynomial_libsingular.pyx +index 2c69227760..4ab9a36f78 100644 +--- a/src/sage/rings/polynomial/multi_polynomial_libsingular.pyx ++++ b/src/sage/rings/polynomial/multi_polynomial_libsingular.pyx +@@ -1652,7 +1652,7 @@ cdef class MPolynomialRing_libsingular(MPolynomialRing_base): + else: + raise ArithmeticError("Cannot divide these coefficients.") + else: +- p_SetCoeff0(res, n_Init(1, r), r) ++ p_SetCoeff0(res, n_Init(1, r.cf), r) + return new_MP(self, res) + + def monomial_divides(self, MPolynomial_libsingular a, MPolynomial_libsingular b): +@@ -1805,7 +1805,7 @@ cdef class MPolynomialRing_libsingular(MPolynomialRing_base): + if r is not currRing: + rChangeCurrRing(r) + flt = pMDivide(f._poly, h._poly) +- p_SetCoeff(flt, n_Init(1, r), r) ++ p_SetCoeff(flt, n_Init(1, r.cf), r) + return (new_MP(self, flt), h) + return (self._zero_element, self._zero_element) + +@@ -2885,7 +2885,7 @@ cdef class MPolynomial_libsingular(MPolynomial): + flag = 1 + if flag == 0: + newptemp = p_LmInit(p,r) +- p_SetCoeff(newptemp,n_Copy(p_GetCoeff(p,r),r),r) ++ p_SetCoeff(newptemp,n_Copy(p_GetCoeff(p,r),r.cf),r) + for i from 0<=i<gens: + if exps[i] != -1: + p_SetExp(newptemp,i+1,0,r) +@@ -3187,7 +3187,7 @@ cdef class MPolynomial_libsingular(MPolynomial): + t = pNext(p) + p.next = NULL + coeff = si2sa(p_GetCoeff(p, _ring), _ring, base) +- p_SetCoeff(p, n_Init(1,_ring), _ring) ++ p_SetCoeff(p, n_Init(1,_ring.cf), _ring) + p_Setm(p, _ring) + yield (coeff, new_MP(parent, p)) + p = t +@@ -3716,7 +3716,7 @@ cdef class MPolynomial_libsingular(MPolynomial): + while p: + t = pNext(p) + p.next = NULL +- p_SetCoeff(p, n_Init(1,_ring), _ring) ++ p_SetCoeff(p, n_Init(1,_ring.cf), _ring) + p_Setm(p, _ring) + l.append( new_MP(parent,p) ) + p = t +@@ -3993,7 +3993,7 @@ cdef class MPolynomial_libsingular(MPolynomial): + if self._poly == NULL: + return self._parent._zero_element + _p = p_Head(self._poly, _ring) +- p_SetCoeff(_p, n_Init(1,_ring), _ring) ++ p_SetCoeff(_p, n_Init(1,_ring.cf), _ring) + p_Setm(_p,_ring) + return new_MP(self._parent, _p) + +@@ -4142,7 +4142,7 @@ cdef class MPolynomial_libsingular(MPolynomial): + elif p_IsOne(_right._poly, r): + return self + +- if n_GetChar(r) > 1<<29: ++ if n_GetChar(r.cf) > 1<<29: + raise NotImplementedError("Division of multivariate polynomials over prime fields with characteristic > 2^29 is not implemented.") + + if r.cf.type != n_unknown: +@@ -4153,7 +4153,7 @@ cdef class MPolynomial_libsingular(MPolynomial): + while p: + if p_DivisibleBy(_right._poly, p, r): + temp = p_MDivide(p, _right._poly, r) +- p_SetCoeff0(temp, n_Copy(p_GetCoeff(p, r), r), r) ++ p_SetCoeff0(temp, n_Copy(p_GetCoeff(p, r), r.cf), r) + quo = p_Add_q(quo, temp, r) + p = pNext(p) + return new_MP(parent, quo) +@@ -4458,7 +4458,7 @@ cdef class MPolynomial_libsingular(MPolynomial): + except Exception: + raise NotImplementedError("Factorization of multivariate polynomials over %s is not implemented."%self._parent._base) + +- if n_GetChar(_ring) > 1<<29: ++ if n_GetChar(_ring.cf) > 1<<29: + raise NotImplementedError("Factorization of multivariate polynomials over prime fields with characteristic > 2^29 is not implemented.") + + # I make a temporary copy of the poly in self because singclap_factorize appears to modify it's parameter +@@ -4842,7 +4842,7 @@ cdef class MPolynomial_libsingular(MPolynomial): + if _ring.cf.type == n_Znm or _ring.cf.type == n_Zn or _ring.cf.type == n_Z2m : + raise NotImplementedError("GCD over rings not implemented.") + +- if n_GetChar(_ring) > 1<<29: ++ if n_GetChar(_ring.cf) > 1<<29: + raise NotImplementedError("GCD of multivariate polynomials over prime fields with characteristic > 2^29 is not implemented.") + + cdef int count = singular_polynomial_length_bounded(self._poly,20) \ +@@ -4915,7 +4915,7 @@ cdef class MPolynomial_libsingular(MPolynomial): + else: + _g = <MPolynomial_libsingular>g + +- if n_GetChar(_ring) > 1<<29: ++ if n_GetChar(_ring.cf) > 1<<29: + raise NotImplementedError("LCM of multivariate polynomials over prime fields with characteristic > 2^29 is not implemented.") + + cdef int count = singular_polynomial_length_bounded(self._poly,20) \ +@@ -4995,7 +4995,7 @@ cdef class MPolynomial_libsingular(MPolynomial): + py_rem = self - right*py_quo + return py_quo, py_rem + +- if n_GetChar(r) > 1<<29: ++ if n_GetChar(r.cf) > 1<<29: + raise NotImplementedError("Division of multivariate polynomials over prime fields with characteristic > 2^29 is not implemented.") + + cdef int count = singular_polynomial_length_bounded(self._poly,15) +@@ -5450,7 +5450,7 @@ cdef class MPolynomial_libsingular(MPolynomial): + raise TypeError("second parameter needs to be an element of self.parent() or None") + + +- if n_GetChar(_ring) > 1<<29: ++ if n_GetChar(_ring.cf) > 1<<29: + raise NotImplementedError("Resultants of multivariate polynomials over prime fields with characteristic > 2^29 is not implemented.") + + if is_IntegerRing(self._parent._base): +diff --git a/src/sage/rings/polynomial/plural.pyx b/src/sage/rings/polynomial/plural.pyx +index 349871f508..540bc5cd29 100644 +--- a/src/sage/rings/polynomial/plural.pyx ++++ b/src/sage/rings/polynomial/plural.pyx +@@ -1063,7 +1063,7 @@ cdef class NCPolynomialRing_plural(Ring): + else: + raise ArithmeticError("Cannot divide these coefficients.") + else: +- p_SetCoeff0(res, n_Init(1, r), r) ++ p_SetCoeff0(res, n_Init(1, r.cf), r) + return new_NCP(self, res) + + def monomial_divides(self, NCPolynomial_plural a, NCPolynomial_plural b): +@@ -1251,7 +1251,7 @@ cdef class NCPolynomialRing_plural(Ring): + h = <NCPolynomial_plural>g + if p_LmDivisibleBy(h._poly, m, r): + flt = pMDivide(f._poly, h._poly) +- p_SetCoeff(flt, n_Init(1, r), r) ++ p_SetCoeff(flt, n_Init(1, r.cf), r) + return (new_NCP(self,flt), h) + return (self._zero_element, self._zero_element) + +@@ -2112,7 +2112,7 @@ cdef class NCPolynomial_plural(RingElement): + flag = 1 + if flag == 0: + newptemp = p_LmInit(p,r) +- p_SetCoeff(newptemp,n_Copy(p_GetCoeff(p,r),r),r) ++ p_SetCoeff(newptemp,n_Copy(p_GetCoeff(p,r),r.cf),r) + for i from 0<=i<gens: + if exps[i] != -1: + p_SetExp(newptemp,i+1,0,r) +@@ -2545,7 +2545,7 @@ cdef class NCPolynomial_plural(RingElement): + while p: + t = pNext(p) + p.next = NULL +- p_SetCoeff(p, n_Init(1,_ring), _ring) ++ p_SetCoeff(p, n_Init(1,_ring.cf), _ring) + p_Setm(p, _ring) + l.append( new_NCP(parent,p) ) + p = t +@@ -2650,7 +2650,7 @@ cdef class NCPolynomial_plural(RingElement): + if self._poly == NULL: + return (<NCPolynomialRing_plural>self._parent)._zero_element + _p = p_Head(self._poly, _ring) +- p_SetCoeff(_p, n_Init(1,_ring), _ring) ++ p_SetCoeff(_p, n_Init(1,_ring.cf), _ring) + p_Setm(_p,_ring) + return new_NCP((<NCPolynomialRing_plural>self._parent), _p) + Copied: sagemath/repos/community-staging-x86_64/test-optional.patch (from rev 1083848, sagemath/trunk/test-optional.patch) =================================================================== --- community-staging-x86_64/test-optional.patch (rev 0) +++ community-staging-x86_64/test-optional.patch 2021-12-26 13:45:28 UTC (rev 1083849) @@ -0,0 +1,25 @@ +diff --git a/src/sage/doctest/control.py b/src/sage/doctest/control.py +index 2d93841e50..937e20cd2e 100644 +--- a/src/sage/doctest/control.py ++++ b/src/sage/doctest/control.py +@@ -357,20 +357,6 @@ class DocTestController(SageObject): + # Special case to run all optional tests + options.optional = True + else: +- # We replace the 'optional' tag by all optional +- # packages for which the installed version matches the +- # latest available version (this implies in particular +- # that the package is actually installed). +- if 'optional' in options.optional: +- options.optional.discard('optional') +- from sage.misc.package import list_packages +- for pkg in list_packages('optional', local=True).values(): +- if pkg['installed'] and pkg['installed_version'] == pkg['remote_version']: +- options.optional.add(pkg['name']) +- +- from sage.features import package_systems +- options.optional.update(system.name for system in package_systems()) +- + # Check that all tags are valid + for o in options.optional: + if not optionaltag_regex.search(o):