| 1 | ;;; GNU Guix --- Functional package management for GNU |
| 2 | ;;; Copyright © 2012, 2013, 2014, 2015, 2016, 2017, 2018, 2019 Andreas Enge <andreas@enge.fr> |
| 3 | ;;; Copyright © 2013, 2015, 2017, 2018, 2021 Ludovic Courtès <ludo@gnu.org> |
| 4 | ;;; Copyright © 2016, 2017, 2018, 2019, 2020, 2021 Nicolas Goaziou <mail@nicolasgoaziou.fr> |
| 5 | ;;; Copyright © 2014, 2018 Mark H Weaver <mhw@netris.org> |
| 6 | ;;; Copyright © 2016, 2018, 2019 Ricardo Wurmus <rekado@elephly.net> |
| 7 | ;;; Copyright © 2017, 2020 Efraim Flashner <efraim@flashner.co.il> |
| 8 | ;;; Copyright © 2017–2021 Tobias Geerinckx-Rice <me@tobias.gr> |
| 9 | ;;; Copyright © 2017 Marius Bakke <mbakke@fastmail.com> |
| 10 | ;;; Copyright © 2017, 2019 Eric Bavier <bavier@member.fsf.org> |
| 11 | ;;; Copyright © 2019 Mathieu Othacehe <m.othacehe@gmail.com> |
| 12 | ;;; Copyright © 2020 Björn Höfling <bjoern.hoefling@bjoernhoefling.de> |
| 13 | ;;; Copyright © 2020 Jakub Kądziołka <kuba@kadziolka.net> |
| 14 | ;;; Copyright © 2020 Vincent Legoll <vincent.legoll@gmail.com> |
| 15 | ;;; Copyright © 2020 Vinicius Monego <monego@posteo.net> |
| 16 | ;;; Copyright © 2021 Lars-Dominik Braun <ldb@leibniz-psychology.org> |
| 17 | ;;; |
| 18 | ;;; This file is part of GNU Guix. |
| 19 | ;;; |
| 20 | ;;; GNU Guix is free software; you can redistribute it and/or modify it |
| 21 | ;;; under the terms of the GNU General Public License as published by |
| 22 | ;;; the Free Software Foundation; either version 3 of the License, or (at |
| 23 | ;;; your option) any later version. |
| 24 | ;;; |
| 25 | ;;; GNU Guix is distributed in the hope that it will be useful, but |
| 26 | ;;; WITHOUT ANY WARRANTY; without even the implied warranty of |
| 27 | ;;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
| 28 | ;;; GNU General Public License for more details. |
| 29 | ;;; |
| 30 | ;;; You should have received a copy of the GNU General Public License |
| 31 | ;;; along with GNU Guix. If not, see <http://www.gnu.org/licenses/>. |
| 32 | |
| 33 | (define-module (gnu packages algebra) |
| 34 | #:use-module (gnu packages) |
| 35 | #:use-module (gnu packages autotools) |
| 36 | #:use-module (gnu packages bison) |
| 37 | #:use-module (gnu packages check) |
| 38 | #:use-module (gnu packages compression) |
| 39 | #:use-module (gnu packages cpp) |
| 40 | #:use-module (gnu packages documentation) |
| 41 | #:use-module (gnu packages ed) |
| 42 | #:use-module (gnu packages flex) |
| 43 | #:use-module (gnu packages fltk) |
| 44 | #:use-module (gnu packages gl) |
| 45 | #:use-module (gnu packages graphviz) |
| 46 | #:use-module (gnu packages image) |
| 47 | #:use-module (gnu packages java) |
| 48 | #:use-module (gnu packages maths) |
| 49 | #:use-module (gnu packages mpi) |
| 50 | #:use-module (gnu packages multiprecision) |
| 51 | #:use-module (gnu packages ocaml) |
| 52 | #:use-module (gnu packages perl) |
| 53 | #:use-module (gnu packages pkg-config) |
| 54 | #:use-module (gnu packages pulseaudio) |
| 55 | #:use-module (gnu packages python) |
| 56 | #:use-module (gnu packages python-xyz) |
| 57 | #:use-module (gnu packages readline) |
| 58 | #:use-module (gnu packages shells) |
| 59 | #:use-module (gnu packages tex) |
| 60 | #:use-module (gnu packages texinfo) |
| 61 | #:use-module (gnu packages xiph) |
| 62 | #:use-module (gnu packages xorg) |
| 63 | #:use-module (guix build-system ant) |
| 64 | #:use-module (guix build-system gnu) |
| 65 | #:use-module (guix build-system cmake) |
| 66 | #:use-module (guix build-system python) |
| 67 | #:use-module (guix build-system r) |
| 68 | #:use-module (guix download) |
| 69 | #:use-module (guix git-download) |
| 70 | #:use-module (guix hg-download) |
| 71 | #:use-module ((guix licenses) #:prefix license:) |
| 72 | #:use-module (guix packages) |
| 73 | #:use-module (guix utils)) |
| 74 | |
| 75 | |
| 76 | (define-public mpfrcx |
| 77 | (package |
| 78 | (name "mpfrcx") |
| 79 | (version "0.6") |
| 80 | (source (origin |
| 81 | (method url-fetch) |
| 82 | (uri (string-append |
| 83 | "http://www.multiprecision.org/downloads/mpfrcx-" |
| 84 | version ".tar.gz")) |
| 85 | (sha256 |
| 86 | (base32 |
| 87 | "0gz5rma9al2jrifpknqkcnd9dkf8l05jcxy3s4ghwhd4y3h5dwia")))) |
| 88 | (build-system gnu-build-system) |
| 89 | (propagated-inputs |
| 90 | `(("gmp" ,gmp) |
| 91 | ("mpfr" ,mpfr) |
| 92 | ("mpc" ,mpc))) ; Header files are included by mpfrcx.h. |
| 93 | (synopsis "Arithmetic of polynomials over arbitrary precision numbers") |
| 94 | (description |
| 95 | "Mpfrcx is a library for the arithmetic of univariate polynomials over |
| 96 | arbitrary precision real (mpfr) or complex (mpc) numbers, without control |
| 97 | on the rounding. For the time being, only the few functions needed to |
| 98 | implement the floating point approach to complex multiplication are |
| 99 | implemented. On the other hand, these comprise asymptotically fast |
| 100 | multiplication routines such as Toom–Cook and the FFT.") |
| 101 | (license license:lgpl3+) |
| 102 | (home-page "http://www.multiprecision.org/mpfrcx/"))) |
| 103 | |
| 104 | (define-public gf2x |
| 105 | (package |
| 106 | (name "gf2x") |
| 107 | (version "1.2") |
| 108 | (source (origin |
| 109 | (method url-fetch) |
| 110 | (uri (string-append |
| 111 | "https://gforge.inria.fr/frs/download.php/file/36934/gf2x-" |
| 112 | version ".tar.gz")) |
| 113 | (sha256 |
| 114 | (base32 |
| 115 | "0d6vh1mxskvv3bxl6byp7gxxw3zzpkldrxnyajhnl05m0gx7yhk1")))) |
| 116 | (build-system gnu-build-system) |
| 117 | (synopsis "Arithmetic of polynomials over binary finite fields") |
| 118 | (description |
| 119 | "The gf2x library provides arithmetic of polynomials over finite fields |
| 120 | of characteristic 2. It implements the multiplication, squaring and |
| 121 | greatest common divisor operations.") |
| 122 | (license license:gpl3+) |
| 123 | (home-page "https://gforge.inria.fr/projects/gf2x/"))) |
| 124 | |
| 125 | (define-public cm |
| 126 | (package |
| 127 | (name "cm") |
| 128 | (version "0.3.1") |
| 129 | (source (origin |
| 130 | (method url-fetch) |
| 131 | (uri (string-append |
| 132 | "http://www.multiprecision.org/downloads/cm-" |
| 133 | version ".tar.gz")) |
| 134 | (sha256 |
| 135 | (base32 |
| 136 | "0qq6b1kwb1byj8ws33ya5awq0ilkpm32037pi1l4cf2737fg9m42")))) |
| 137 | (build-system gnu-build-system) |
| 138 | (propagated-inputs |
| 139 | `(("mpfrcx" ,mpfrcx) |
| 140 | ("zlib" ,zlib))) ; Header files included from cm_common.h. |
| 141 | (inputs |
| 142 | `(("pari-gp" ,pari-gp))) |
| 143 | (synopsis "CM constructions for elliptic curves") |
| 144 | (description |
| 145 | "The CM software implements the construction of ring class fields of |
| 146 | imaginary quadratic number fields and of elliptic curves with complex |
| 147 | multiplication via floating point approximations. It consists of libraries |
| 148 | that can be called from within a C program and of executable command |
| 149 | line applications.") |
| 150 | (license license:gpl3+) |
| 151 | (home-page "http://www.multiprecision.org/cm/"))) |
| 152 | |
| 153 | (define-public fplll |
| 154 | (package |
| 155 | (name "fplll") |
| 156 | (version "5.3.3") |
| 157 | (source (origin |
| 158 | (method git-fetch) |
| 159 | (uri (git-reference |
| 160 | (url "https://github.com/fplll/fplll") |
| 161 | (commit version))) |
| 162 | (file-name (git-file-name name version)) |
| 163 | (sha256 |
| 164 | (base32 |
| 165 | "06nyfidagp8pc2kfcw88ldgb2b1xm0a8z31n0sln7j72ihlmd8zj")) |
| 166 | (patches (search-patches "fplll-std-fenv.patch")))) |
| 167 | (build-system gnu-build-system) |
| 168 | (native-inputs |
| 169 | `(("autoconf" ,autoconf) |
| 170 | ("automake" ,automake) |
| 171 | ("libtool" ,libtool) |
| 172 | ("pkg-config" ,pkg-config))) |
| 173 | (propagated-inputs ; header files pulled in by fplll/defs.h |
| 174 | `(("gmp" ,gmp) |
| 175 | ("mpfr" ,mpfr))) |
| 176 | (home-page "https://github.com/fplll/fplll") |
| 177 | (synopsis "Library for LLL-reduction of euclidean lattices") |
| 178 | (description |
| 179 | "fplll contains implementations of several lattice algorithms. |
| 180 | The implementation relies on floating-point orthogonalization, and LLL |
| 181 | is central to the code, hence the name. |
| 182 | |
| 183 | It includes implementations of floating-point LLL reduction |
| 184 | algorithms, offering different speed/guarantees ratios. It contains |
| 185 | a @emph{wrapper} choosing the estimated best sequence of variants in |
| 186 | order to provide a guaranteed output as fast as possible. In the case |
| 187 | of the wrapper, the succession of variants is oblivious to the user. |
| 188 | |
| 189 | It includes an implementation of the BKZ reduction algorithm, |
| 190 | including the BKZ-2.0 improvements (extreme enumeration |
| 191 | pruning, pre-processing of blocks, early termination). Additionally, |
| 192 | Slide reduction and self dual BKZ are supported. |
| 193 | |
| 194 | It also includes a floating-point implementation of the |
| 195 | Kannan-Fincke-Pohst algorithm that finds a shortest non-zero lattice |
| 196 | vector. For the same task, the GaussSieve algorithm is also available |
| 197 | in fplll. Finally, it contains a variant of the enumeration algorithm |
| 198 | that computes a lattice vector closest to a given vector belonging to |
| 199 | the real span of the lattice.") |
| 200 | (license license:lgpl2.1+))) |
| 201 | |
| 202 | (define-public python-fpylll |
| 203 | (package |
| 204 | (name "python-fpylll") |
| 205 | (version "0.5.2") |
| 206 | (source |
| 207 | (origin |
| 208 | ;; Pypi contains and older release, so we use a tagged release from |
| 209 | ;; Github instead. |
| 210 | (method git-fetch) |
| 211 | (uri (git-reference |
| 212 | (url "https://github.com/fplll/fpylll") |
| 213 | (commit (string-append version "dev")))) |
| 214 | (file-name (git-file-name name version)) |
| 215 | (sha256 |
| 216 | (base32 |
| 217 | "1a25iibihph626jl4wbs4b77xc4a2c4nfc2ypscf9wpani3dnhjf")))) |
| 218 | (build-system python-build-system) |
| 219 | (inputs |
| 220 | `(("fplll" ,fplll) |
| 221 | ("gmp" ,gmp) |
| 222 | ("mpfr" ,mpfr) |
| 223 | ("pari-gp" ,pari-gp))) |
| 224 | (propagated-inputs |
| 225 | `(("cysignals" ,python-cysignals) |
| 226 | ("cython" ,python-cython) |
| 227 | ("flake8" ,python-flake8) |
| 228 | ("numpy" ,python-numpy) |
| 229 | ("pytest" ,python-pytest))) |
| 230 | (home-page "https://github.com/fplll/fpylll") |
| 231 | (synopsis "Python interface for fplll") |
| 232 | (description "fpylll is a Python wrapper for fplll.") |
| 233 | (license license:gpl2+))) |
| 234 | |
| 235 | (define-public pari-gp |
| 236 | (package |
| 237 | (name "pari-gp") |
| 238 | (version "2.13.1") |
| 239 | (source (origin |
| 240 | (method url-fetch) |
| 241 | (uri (string-append |
| 242 | "https://pari.math.u-bordeaux.fr/pub/pari/unix/pari-" |
| 243 | version ".tar.gz")) |
| 244 | (sha256 |
| 245 | (base32 |
| 246 | "1cgwdpw8b797883z9y92ixxjkv72kiy65zsw2qqf5and1kbzgv41")))) |
| 247 | (build-system gnu-build-system) |
| 248 | (native-inputs |
| 249 | `(("texlive" ,(texlive-union |
| 250 | (list texlive-amsfonts))))) |
| 251 | (inputs `(("gmp" ,gmp) |
| 252 | ("libx11" ,libx11) |
| 253 | ("perl" ,perl) |
| 254 | ("readline" ,readline))) |
| 255 | (arguments |
| 256 | '(#:make-flags '("all") |
| 257 | #:test-target "dobench" |
| 258 | #:phases |
| 259 | (modify-phases %standard-phases |
| 260 | (replace 'configure |
| 261 | (lambda* (#:key outputs #:allow-other-keys) |
| 262 | (invoke "./Configure" |
| 263 | (string-append "--prefix=" |
| 264 | (assoc-ref outputs "out")))))))) |
| 265 | (synopsis "PARI/GP, a computer algebra system for number theory") |
| 266 | (description |
| 267 | "PARI/GP is a widely used computer algebra system designed for fast |
| 268 | computations in number theory (factorisations, algebraic number theory, |
| 269 | elliptic curves...), but it also contains a large number of other useful |
| 270 | functions to compute with mathematical entities such as matrices, |
| 271 | polynomials, power series, algebraic numbers, etc., and a lot of |
| 272 | transcendental functions. |
| 273 | PARI is also available as a C library to allow for faster computations.") |
| 274 | (license license:gpl2+) |
| 275 | (home-page "https://pari.math.u-bordeaux.fr/"))) |
| 276 | |
| 277 | (define-public gp2c |
| 278 | (package |
| 279 | (name "gp2c") |
| 280 | (version "0.0.12") |
| 281 | (source (origin |
| 282 | (method url-fetch) |
| 283 | (uri (string-append |
| 284 | "https://pari.math.u-bordeaux.fr/pub/pari/GP2C/gp2c-" |
| 285 | version ".tar.gz")) |
| 286 | (sha256 |
| 287 | (base32 |
| 288 | "039ip7qkwwv46wrcdrz7y12m30kazzkjr44kqbc0h137g4wzd7zf")))) |
| 289 | (build-system gnu-build-system) |
| 290 | (native-inputs `(("perl" ,perl))) |
| 291 | (inputs `(("pari-gp" ,pari-gp))) |
| 292 | (arguments |
| 293 | '(#:configure-flags |
| 294 | (list (string-append "--with-paricfg=" |
| 295 | (assoc-ref %build-inputs "pari-gp") |
| 296 | "/lib/pari/pari.cfg")))) |
| 297 | (synopsis "PARI/GP, a computer algebra system for number theory") |
| 298 | (description |
| 299 | "PARI/GP is a widely used computer algebra system designed for fast |
| 300 | computations in number theory (factorisations, algebraic number theory, |
| 301 | elliptic curves...), but it also contains a large number of other useful |
| 302 | functions to compute with mathematical entities such as matrices, |
| 303 | polynomials, power series, algebraic numbers, etc., and a lot of |
| 304 | transcendental functions. |
| 305 | PARI is also available as a C library to allow for faster computations. |
| 306 | |
| 307 | GP2C, the GP to C compiler, translates GP scripts to PARI programs.") |
| 308 | (license license:gpl2) |
| 309 | (home-page "https://pari.math.u-bordeaux.fr/"))) |
| 310 | |
| 311 | (define-public cmh |
| 312 | (package |
| 313 | (name "cmh") |
| 314 | (version "1.1.0") |
| 315 | (source (origin |
| 316 | (method url-fetch) |
| 317 | ;; Git repo at <https://gitlab.inria.fr/cmh/cmh>. |
| 318 | (uri (string-append "http://www.multiprecision.org/downloads/cmh-" |
| 319 | version ".tar.gz")) |
| 320 | (sha256 |
| 321 | (base32 |
| 322 | "1ws2yhzxmm2l5xqqqcjcimmg40f9qq5l9i6d4i5434an9v9s8531")))) |
| 323 | (build-system gnu-build-system) |
| 324 | (inputs |
| 325 | `(("gmp" ,gmp) |
| 326 | ("mpfr" ,mpfr) |
| 327 | ("mpc" ,mpc) |
| 328 | ("mpfrcx" ,mpfrcx) |
| 329 | ("fplll" ,fplll) |
| 330 | ("pari-gp" ,pari-gp))) |
| 331 | (synopsis "Igusa class polynomial computations") |
| 332 | (description |
| 333 | "The CMH software computes Igusa (genus 2) class polynomials, which |
| 334 | parameterize the CM points in the moduli space of 2-dimensional abelian |
| 335 | varieties, i.e. Jacobians of hyperelliptic curves. |
| 336 | It can also be used to compute theta constants at arbitrary |
| 337 | precision.") |
| 338 | (license license:gpl3+) |
| 339 | (home-page "http://www.multiprecision.org/cmh/home.html"))) |
| 340 | |
| 341 | (define-public giac |
| 342 | (package |
| 343 | (name "giac") |
| 344 | (version "1.7.0-1") |
| 345 | (source |
| 346 | (origin |
| 347 | (method url-fetch) |
| 348 | ;; "~parisse/giac" is not used because the maintainer regularly |
| 349 | ;; overwrites the release tarball there, introducing a checksum |
| 350 | ;; mismatch every time. See |
| 351 | ;; <https://www-fourier.ujf-grenoble.fr/~parisse/debian/dists/stable/main/source/README> |
| 352 | (uri (string-append "https://www-fourier.ujf-grenoble.fr/" |
| 353 | "~parisse/debian/dists/stable/main/source/" |
| 354 | "giac_" version ".tar.gz")) |
| 355 | (sha256 |
| 356 | (base32 "0s926aza2larfz02hrhdlpxn77yjlrhjg844b3fhwz11yj942p9q")))) |
| 357 | (build-system gnu-build-system) |
| 358 | (arguments |
| 359 | `(#:modules ((ice-9 ftw) |
| 360 | (guix build utils) |
| 361 | (guix build gnu-build-system)) |
| 362 | #:phases |
| 363 | (modify-phases %standard-phases |
| 364 | (add-after 'unpack 'patch-bin-cp |
| 365 | ;; Some Makefiles contain hard-coded "/bin/cp". |
| 366 | (lambda _ |
| 367 | (substitute* (cons "micropython-1.12/xcas/Makefile" |
| 368 | (find-files "doc" "^Makefile")) |
| 369 | (("/bin/cp") (which "cp"))) |
| 370 | #t)) |
| 371 | (add-after 'unpack 'disable-failing-test |
| 372 | ;; FIXME: Test failing. Not sure why. |
| 373 | (lambda _ |
| 374 | (substitute* "check/Makefile.in" |
| 375 | (("chk_fhan11") "")) |
| 376 | #t)) |
| 377 | (add-after 'install 'fix-doc |
| 378 | (lambda* (#:key outputs #:allow-other-keys) |
| 379 | (let ((out (assoc-ref outputs "out"))) |
| 380 | ;; Most French documentation has a non-commercial |
| 381 | ;; license, so we need to remove it. |
| 382 | (with-directory-excursion (string-append out "/share/giac/doc/fr") |
| 383 | (for-each delete-file-recursively |
| 384 | '("cascas" "casexo" "casgeo" "casrouge" "cassim" |
| 385 | "castor"))) |
| 386 | ;; Remove duplicate documentation in |
| 387 | ;; "%out/share/doc/giac/", where Xcas does not expect |
| 388 | ;; to find it. |
| 389 | (delete-file-recursively (string-append out "/share/doc/giac")) |
| 390 | #t))) |
| 391 | (add-after 'install 'remove-unnecessary-executable |
| 392 | (lambda* (#:key outputs #:allow-other-keys) |
| 393 | (let ((out (assoc-ref outputs "out"))) |
| 394 | (delete-file (string-append out "/bin/xcasnew")) |
| 395 | #t)))))) |
| 396 | (inputs |
| 397 | ;; TODO: Add libnauty, unbundle "libmicropython.a". |
| 398 | `(("fltk" ,fltk) |
| 399 | ("glpk" ,glpk-4) |
| 400 | ("gmp" ,gmp) |
| 401 | ("gsl" ,gsl) |
| 402 | ("lapack" ,lapack) |
| 403 | ("libao" ,ao) |
| 404 | ("libjpeg" ,libjpeg-turbo) |
| 405 | ("libpng" ,libpng) |
| 406 | ("libsamplerate" ,libsamplerate) |
| 407 | ("libx11" ,libx11) |
| 408 | ("libxinerama" ,libxinerama) |
| 409 | ("libxft" ,libxft) |
| 410 | ("libxt" ,libxt) |
| 411 | ("mesa" ,mesa) |
| 412 | ("mpfi" ,mpfi) |
| 413 | ("mpfr" ,mpfr) |
| 414 | ("ntl" ,ntl) |
| 415 | ("perl" ,perl) |
| 416 | ("pari-gp" ,pari-gp) |
| 417 | ("tcsh" ,tcsh))) |
| 418 | (native-inputs |
| 419 | `(("bison" ,bison) |
| 420 | ("flex" ,flex) |
| 421 | ("hevea" ,hevea) |
| 422 | ("python" ,python-wrapper) |
| 423 | ("readline" ,readline) |
| 424 | ("texlive" ,texlive-tiny))) |
| 425 | (home-page "https://www-fourier.ujf-grenoble.fr/~parisse/giac.html") |
| 426 | (synopsis "Computer algebra system") |
| 427 | (description |
| 428 | "Giac/Xcas is a computer algebra system. It has a compatibility mode for |
| 429 | maple, mupad and the TI89. It is available as a standalone program (graphic |
| 430 | or text interfaces) or as a C++ library.") |
| 431 | (license license:gpl3+))) |
| 432 | |
| 433 | (define-public flint |
| 434 | (package |
| 435 | (name "flint") |
| 436 | (version "2.6.3") |
| 437 | (source |
| 438 | (origin |
| 439 | (method url-fetch) |
| 440 | (uri (string-append "http://flintlib.org/flint-" version ".tar.gz")) |
| 441 | (sha256 |
| 442 | (base32 "1qrf6hzbbmg7mhkhbb0bab8z2xpdnba5cj4kmmf72lzs0457a6nf")))) |
| 443 | (build-system gnu-build-system) |
| 444 | (inputs |
| 445 | `(("ntl" ,ntl))) |
| 446 | (propagated-inputs |
| 447 | `(("gmp" ,gmp) |
| 448 | ("mpfr" ,mpfr))) ; header files from both are included by flint/arith.h |
| 449 | (arguments |
| 450 | `(#:parallel-tests? #f ; seems to be necessary on arm |
| 451 | #:phases |
| 452 | (modify-phases %standard-phases |
| 453 | (add-before 'configure 'newer-c++ |
| 454 | (lambda _ |
| 455 | (substitute* "configure" |
| 456 | (("-ansi") "")) |
| 457 | #t)) |
| 458 | (replace 'configure |
| 459 | (lambda* (#:key inputs outputs #:allow-other-keys) |
| 460 | (let ((out (assoc-ref outputs "out")) |
| 461 | (gmp (assoc-ref inputs "gmp")) |
| 462 | (mpfr (assoc-ref inputs "mpfr")) |
| 463 | (ntl (assoc-ref inputs "ntl"))) |
| 464 | ;; Do not pass "--enable-fast-install", which makes the |
| 465 | ;; homebrew configure process fail. |
| 466 | (invoke "./configure" |
| 467 | (string-append "--prefix=" out) |
| 468 | (string-append "--with-gmp=" gmp) |
| 469 | (string-append "--with-mpfr=" mpfr) |
| 470 | (string-append "--with-ntl=" ntl)) |
| 471 | #t)))))) |
| 472 | (synopsis "Fast library for number theory") |
| 473 | (description |
| 474 | "FLINT is a C library for number theory. It supports arithmetic |
| 475 | with numbers, polynomials, power series and matrices over many base |
| 476 | rings, including multiprecision integers and rationals, integers |
| 477 | modulo n, p-adic numbers, finite fields (prime and non-prime order) |
| 478 | and real and complex numbers (via the Arb extension library). |
| 479 | |
| 480 | Operations that can be performed include conversions, arithmetic, |
| 481 | GCDs, factoring, solving linear systems, and evaluating special |
| 482 | functions. In addition, FLINT provides various low-level routines for |
| 483 | fast arithmetic.") |
| 484 | (license license:lgpl2.1+) |
| 485 | (home-page "http://flintlib.org/"))) |
| 486 | |
| 487 | (define-public arb |
| 488 | (package |
| 489 | (name "arb") |
| 490 | (version "2.18.1") |
| 491 | (source (origin |
| 492 | (method git-fetch) |
| 493 | (uri (git-reference |
| 494 | (url "https://github.com/fredrik-johansson/arb") |
| 495 | (commit version))) |
| 496 | (file-name (git-file-name name version)) |
| 497 | (sha256 |
| 498 | (base32 |
| 499 | "15fx3dcbzgwddw9p1nysmx0dbh058afv5m8cj5pdjkcmcl7kw7z9")))) |
| 500 | (build-system gnu-build-system) |
| 501 | (propagated-inputs |
| 502 | `(("flint" ,flint))) ; flint.h is included by arf.h |
| 503 | (inputs |
| 504 | `(("gmp" ,gmp) |
| 505 | ("mpfr" ,mpfr))) |
| 506 | (arguments |
| 507 | `(#:phases |
| 508 | (modify-phases %standard-phases |
| 509 | (replace 'configure |
| 510 | (lambda* (#:key inputs outputs #:allow-other-keys) |
| 511 | (let ((out (assoc-ref outputs "out")) |
| 512 | (flint (assoc-ref inputs "flint")) |
| 513 | (gmp (assoc-ref inputs "gmp")) |
| 514 | (mpfr (assoc-ref inputs "mpfr"))) |
| 515 | ;; Do not pass "--enable-fast-install", which makes the |
| 516 | ;; homebrew configure process fail. |
| 517 | (invoke "./configure" |
| 518 | (string-append "--prefix=" out) |
| 519 | (string-append "--with-flint=" flint) |
| 520 | (string-append "--with-gmp=" gmp) |
| 521 | (string-append "--with-mpfr=" mpfr)))))))) |
| 522 | (home-page "https://arblib.org") |
| 523 | (synopsis "Arbitrary precision floating-point ball arithmetic") |
| 524 | (description |
| 525 | "Arb is a C library for arbitrary-precision floating-point ball |
| 526 | arithmetic. It supports efficient high-precision computation with |
| 527 | polynomials, power series, matrices and special functions over the |
| 528 | real and complex numbers, with automatic, rigorous error control.") |
| 529 | (license license:lgpl2.1+))) |
| 530 | |
| 531 | (define-public python-flint |
| 532 | (package |
| 533 | (name "python-flint") |
| 534 | (version "0.3.0") |
| 535 | (source (origin |
| 536 | (method git-fetch) |
| 537 | (uri (git-reference |
| 538 | (url "https://github.com/fredrik-johansson/python-flint") |
| 539 | (commit version))) |
| 540 | (file-name (git-file-name name version)) |
| 541 | (sha256 |
| 542 | (base32 |
| 543 | "1v0anazbj1cfi68nl2j6dbd31kgkc1563xmr0zk5xk3xj78569pw")) |
| 544 | (patches (search-patches "python-flint-includes.patch")))) |
| 545 | (build-system python-build-system) |
| 546 | (native-inputs |
| 547 | `(("python-cython" ,python-cython))) |
| 548 | (propagated-inputs |
| 549 | `(("python-numpy" ,python-numpy))) |
| 550 | (inputs |
| 551 | `(("arb" ,arb) |
| 552 | ("flint" ,flint))) |
| 553 | (synopsis "Python module wrapping ARB and FLINT") |
| 554 | (description |
| 555 | "Python-flint is a Python extension module wrapping FLINT |
| 556 | (Fast Library for Number Theory) and Arb (arbitrary-precision ball |
| 557 | arithmetic). It supports integers, rationals, modular integers, |
| 558 | real and complex ball arithmetic, polynomials and matrices over all |
| 559 | these types and other mathematical functions.") |
| 560 | (license license:expat) |
| 561 | (home-page "https://fredrikj.net/python-flint/"))) |
| 562 | |
| 563 | (define-public ntl |
| 564 | (package |
| 565 | (name "ntl") |
| 566 | (version "11.4.4") |
| 567 | (source (origin |
| 568 | (method url-fetch) |
| 569 | (uri (string-append "https://shoup.net/ntl/ntl-" |
| 570 | version ".tar.gz")) |
| 571 | (sha256 |
| 572 | (base32 |
| 573 | "1nr1h27j2gdz6badzz9lk2pknxhdijqdxqhd3haryh0sw616wzwx")) |
| 574 | (modules '((guix build utils))) |
| 575 | (snippet |
| 576 | '(begin |
| 577 | (delete-file-recursively "src/libtool-origin") |
| 578 | #t)))) |
| 579 | (build-system gnu-build-system) |
| 580 | (native-inputs |
| 581 | `(("libtool" ,libtool) |
| 582 | ("perl" ,perl))) ; for configuration |
| 583 | (inputs |
| 584 | `(("gmp" ,gmp) |
| 585 | ("gf2x" ,gf2x))) |
| 586 | (arguments |
| 587 | `(#:phases |
| 588 | (modify-phases %standard-phases |
| 589 | (replace 'configure |
| 590 | (lambda* (#:key inputs outputs #:allow-other-keys) |
| 591 | (chdir "src") |
| 592 | (invoke "./configure" |
| 593 | (string-append "PREFIX=" (assoc-ref outputs "out")) |
| 594 | (string-append "LIBTOOL=" (assoc-ref inputs "libtool") "/bin/libtool") |
| 595 | ;; set the library prefixes explicitly so that they get |
| 596 | ;; embedded in the .la file |
| 597 | (string-append "GMP_PREFIX=" (assoc-ref inputs "gmp")) |
| 598 | (string-append "GF2X_PREFIX=" (assoc-ref inputs "gf2x")) |
| 599 | ;; Do not build especially for the build machine. |
| 600 | "NATIVE=off" |
| 601 | "NTL_GF2X_LIB=on" |
| 602 | "SHARED=on")))))) |
| 603 | (synopsis "C++ library for number theory") |
| 604 | (description |
| 605 | "NTL is a C++ library providing data structures and algorithms |
| 606 | for manipulating signed, arbitrary length integers, and for vectors, |
| 607 | matrices, and polynomials over the integers and over finite fields.") |
| 608 | (license license:gpl2+) |
| 609 | (home-page "https://shoup.net/ntl/"))) |
| 610 | |
| 611 | (define-public singular |
| 612 | (package |
| 613 | (name "singular") |
| 614 | (version "4.1.3p2") |
| 615 | (source |
| 616 | (origin |
| 617 | (method url-fetch) |
| 618 | (uri |
| 619 | (string-append "http://www.mathematik.uni-kl.de/ftp/pub/Math/" |
| 620 | "Singular/SOURCES/" |
| 621 | (string-join |
| 622 | (string-split |
| 623 | (string-trim-right version #\p |
| 624 | 0 (1- (string-length version))) |
| 625 | #\.) "-") |
| 626 | "/singular-" version ".tar.gz")) |
| 627 | (sha256 (base32 |
| 628 | "1524yrni7gh0hir5ckridq671q5s6avfjdsdyahj51kzdl3wcypf")))) |
| 629 | (build-system gnu-build-system) |
| 630 | (native-inputs |
| 631 | `(("doxygen" ,doxygen) |
| 632 | ("graphviz" ,graphviz) |
| 633 | ("perl" ,perl))) |
| 634 | (inputs |
| 635 | `(("cddlib" ,cddlib) |
| 636 | ("gmp" ,gmp) |
| 637 | ("flint" ,flint) |
| 638 | ("mpfr" ,mpfr) |
| 639 | ("ntl" ,ntl) |
| 640 | ("python" ,python-2) |
| 641 | ("readline" ,readline))) |
| 642 | (arguments |
| 643 | `(#:configure-flags |
| 644 | (list (string-append "--with-ntl=" |
| 645 | (assoc-ref %build-inputs "ntl"))))) |
| 646 | (synopsis "Computer algebra system for polynomial computations") |
| 647 | (description |
| 648 | "Singular is a computer algebra system for polynomial computations, |
| 649 | with special emphasis on commutative and non-commutative algebra, algebraic |
| 650 | geometry and singularity theory.") |
| 651 | ;; Singular itself is dual licensed gpl2 or gpl3, but some of the |
| 652 | ;; libraries with which it links are licensed under lgpl3+, so the |
| 653 | ;; combined work becomes gpl3. See COPYING in the source code. |
| 654 | (license license:gpl3) |
| 655 | (home-page "https://www.singular.uni-kl.de/index.php"))) |
| 656 | |
| 657 | (define-public gmp-ecm |
| 658 | (package |
| 659 | (name "gmp-ecm") |
| 660 | (version "7.0.4") |
| 661 | (source (origin |
| 662 | (method url-fetch) |
| 663 | (uri |
| 664 | (let ((hash "00c4c691a1ef8605b65bdf794a71539d")) |
| 665 | (string-append "https://gitlab.inria.fr/zimmerma/ecm/" |
| 666 | "uploads/" hash "/ecm-" version |
| 667 | ".tar.gz"))) |
| 668 | (sha256 (base32 |
| 669 | "0hxs24c2m3mh0nq1zz63z3sb7dhy1rilg2s1igwwcb26x3pb7xqc")))) |
| 670 | (build-system gnu-build-system) |
| 671 | (inputs |
| 672 | `(("gmp" ,gmp))) |
| 673 | (arguments |
| 674 | `(#:configure-flags '("--enable-shared" |
| 675 | ;; Disable specific assembly routines, which depend |
| 676 | ;; on the subarchitecture of the build machine, |
| 677 | ;; and use gmp instead. |
| 678 | "--disable-asm-redc"))) |
| 679 | (synopsis "Integer factorization library using the elliptic curve method") |
| 680 | (description |
| 681 | "GMP-ECM factors integers using the elliptic curve method (ECM) as well |
| 682 | as the P-1 and P+1 algorithms. It provides a library and a stand-alone |
| 683 | binary.") |
| 684 | ;; Most files are under lgpl3+, but some are under gpl3+ or gpl2+, |
| 685 | ;; so the combined work is under gpl3+. |
| 686 | (license license:gpl3+) |
| 687 | (home-page "http://ecm.gforge.inria.fr/"))) |
| 688 | |
| 689 | (define-public bc |
| 690 | (package |
| 691 | (name "bc") |
| 692 | (version "1.07.1") |
| 693 | (source (origin |
| 694 | (method url-fetch) |
| 695 | (uri (string-append "mirror://gnu/bc/bc-" version ".tar.gz")) |
| 696 | (sha256 |
| 697 | (base32 |
| 698 | "0amh9ik44jfg66csyvf4zz1l878c4755kjndq9j0270akflgrbb2")) |
| 699 | (patches (search-patches "bc-fix-cross-compilation.patch")))) |
| 700 | (build-system gnu-build-system) |
| 701 | (native-inputs |
| 702 | `(("automake" ,automake) |
| 703 | ("autoconf" ,autoconf) |
| 704 | ("ed" ,ed) |
| 705 | ("flex" ,flex) |
| 706 | ("texinfo" ,texinfo))) |
| 707 | (arguments |
| 708 | '(#:configure-flags |
| 709 | (list "--with-readline") |
| 710 | #:phases |
| 711 | (modify-phases %standard-phases |
| 712 | (add-after 'unpack 'autogen |
| 713 | (lambda _ |
| 714 | (invoke "autoreconf" "-vif")))))) |
| 715 | (home-page "https://www.gnu.org/software/bc/") |
| 716 | (synopsis "Arbitrary precision numeric processing language") |
| 717 | (description |
| 718 | "bc is an arbitrary precision numeric processing language. It includes |
| 719 | an interactive environment for evaluating mathematical statements. Its |
| 720 | syntax is similar to that of C, so basic usage is familiar. It also includes |
| 721 | \"dc\", a reverse-polish calculator.") |
| 722 | (license license:gpl2+))) |
| 723 | |
| 724 | ;; The original kiss-fft does not have a complete build system and does not |
| 725 | ;; build any shared libraries. This is a fork used by Extempore. |
| 726 | (define-public kiss-fft-for-extempore |
| 727 | (package |
| 728 | (name "kiss-fft-for-extempore") |
| 729 | (version "1.3.0") |
| 730 | (source (origin |
| 731 | (method git-fetch) |
| 732 | (uri (git-reference |
| 733 | (url "https://github.com/extemporelang/kiss_fft") |
| 734 | (commit version))) |
| 735 | (file-name (git-file-name name version)) |
| 736 | (sha256 |
| 737 | (base32 |
| 738 | "0jasbmqy4wkqrqx3w64s1dfmj34875xmsl72mb26aa4hpyn14bi2")))) |
| 739 | (build-system cmake-build-system) |
| 740 | (arguments `(#:tests? #f)) ; no tests included |
| 741 | ;; Extempore refuses to build on architectures other than x86_64 |
| 742 | (supported-systems '("x86_64-linux")) |
| 743 | (home-page "https://github.com/extemporelang/kiss_fft") |
| 744 | (synopsis "Mixed-radix Fast Fourier Transform") |
| 745 | (description |
| 746 | "Kiss FFT attempts to be a reasonably efficient, moderately useful FFT |
| 747 | that can use fixed or floating data types and can easily be incorporated into |
| 748 | a C program.") |
| 749 | (license license:bsd-3))) |
| 750 | |
| 751 | (define-public fftw |
| 752 | (package |
| 753 | (name "fftw") |
| 754 | (version "3.3.8") |
| 755 | (source (origin |
| 756 | (method url-fetch) |
| 757 | (uri (string-append "ftp://ftp.fftw.org/pub/fftw/fftw-" |
| 758 | version".tar.gz")) |
| 759 | (sha256 |
| 760 | (base32 |
| 761 | "00z3k8fq561wq2khssqg0kallk0504dzlx989x3vvicjdqpjc4v1")))) |
| 762 | (build-system gnu-build-system) |
| 763 | (arguments |
| 764 | `(#:configure-flags |
| 765 | '("--enable-shared" "--enable-openmp" "--enable-threads" |
| 766 | ,@(let ((system (or (%current-target-system) (%current-system)))) |
| 767 | ;; Enable SIMD extensions for codelets. See details at: |
| 768 | ;; <http://fftw.org/fftw3_doc/Installation-on-Unix.html>. |
| 769 | (cond |
| 770 | ((string-prefix? "x86_64" system) |
| 771 | '("--enable-sse2" "--enable-avx" "--enable-avx2" |
| 772 | "--enable-avx512" "--enable-avx-128-fma")) |
| 773 | ((string-prefix? "i686" system) |
| 774 | '("--enable-sse2")) |
| 775 | ((string-prefix? "aarch64" system) |
| 776 | ;; Note that fftw supports NEON on 32-bit ARM only when |
| 777 | ;; compiled for single-precision. |
| 778 | '("--enable-neon")) |
| 779 | (else |
| 780 | '()))) |
| 781 | ;; By default '-mtune=native' is used. However, that may cause the |
| 782 | ;; use of ISA extensions (e.g. AVX) that are not necessarily |
| 783 | ;; available on the user's machine when that package is built on a |
| 784 | ;; different machine. |
| 785 | "ax_cv_c_flags__mtune_native=no"))) |
| 786 | (native-inputs `(("perl" ,perl))) |
| 787 | (home-page "http://fftw.org") |
| 788 | (synopsis "Computing the discrete Fourier transform") |
| 789 | (description |
| 790 | "FFTW is a C subroutine library for computing the discrete Fourier |
| 791 | transform (DFT) in one or more dimensions, of arbitrary input size, and of |
| 792 | both real and complex data (as well as of even/odd data---i.e. the discrete |
| 793 | cosine/ sine transforms or DCT/DST).") |
| 794 | (license license:gpl2+))) |
| 795 | |
| 796 | (define-public fftwf |
| 797 | (package/inherit fftw |
| 798 | (name "fftwf") |
| 799 | (arguments |
| 800 | (substitute-keyword-arguments (package-arguments fftw) |
| 801 | ((#:configure-flags fftw-configure-flags) |
| 802 | `(cons* "--enable-single" |
| 803 | ,@(if (string-prefix? "arm" (or (%current-target-system) |
| 804 | (%current-system))) |
| 805 | ;; fftw supports NEON on 32-bit ARM only when compiled |
| 806 | ;; for single-precision, so add it here. |
| 807 | '("--enable-neon") |
| 808 | '()) |
| 809 | ,fftw-configure-flags)))) |
| 810 | (description |
| 811 | (string-append (package-description fftw) |
| 812 | " Single-precision version.")))) |
| 813 | |
| 814 | (define-public fftw-openmpi |
| 815 | (package/inherit fftw |
| 816 | (name "fftw-openmpi") |
| 817 | (inputs |
| 818 | `(("openmpi" ,openmpi) |
| 819 | ,@(package-inputs fftw))) |
| 820 | (arguments |
| 821 | (substitute-keyword-arguments (package-arguments fftw) |
| 822 | ((#:configure-flags cf) |
| 823 | `(cons "--enable-mpi" ,cf)) |
| 824 | ((#:phases phases '%standard-phases) |
| 825 | `(modify-phases ,phases |
| 826 | (add-before 'check 'mpi-setup |
| 827 | ,%openmpi-setup))))) |
| 828 | (description |
| 829 | (string-append (package-description fftw) |
| 830 | " With OpenMPI parallelism support.")))) |
| 831 | |
| 832 | (define-public java-la4j |
| 833 | (package |
| 834 | (name "java-la4j") |
| 835 | (version "0.6.0") |
| 836 | (source (origin |
| 837 | (method git-fetch) |
| 838 | (uri (git-reference |
| 839 | (url "https://github.com/vkostyukov/la4j") |
| 840 | (commit version))) |
| 841 | (file-name (string-append name "-" version "-checkout")) |
| 842 | (sha256 |
| 843 | (base32 |
| 844 | "1qir8dr978cfvz9k12m2kbdwpyf6cqdf1d0ilb7lnkhbgq5i53w3")))) |
| 845 | (build-system ant-build-system) |
| 846 | (arguments |
| 847 | `(#:jar-name "la4j.jar" |
| 848 | #:jdk ,icedtea-8 |
| 849 | #:test-exclude (list "**/Abstract*.java" |
| 850 | "**/MatrixTest.java" |
| 851 | "**/DenseMatrixTest.java" |
| 852 | "**/SparseMatrixTest.java" |
| 853 | "**/VectorTest.java" |
| 854 | "**/SparseVectorTest.java" |
| 855 | "**/DenseVectorTest.java"))) |
| 856 | (native-inputs |
| 857 | `(("java-junit" ,java-junit) |
| 858 | ("java-hamcrest-core" ,java-hamcrest-core))) |
| 859 | (home-page "http://la4j.org/") |
| 860 | (synopsis "Java library that provides Linear Algebra primitives and algorithms") |
| 861 | (description "The la4j library is a Java library that provides Linear |
| 862 | Algebra primitives (matrices and vectors) and algorithms. The key features of |
| 863 | the la4j library are: |
| 864 | |
| 865 | @itemize |
| 866 | @item No dependencies and tiny size |
| 867 | @item Fluent object-oriented/functional API |
| 868 | @item Sparse (CRS, CCS) and dense (1D/2D arrays) matrices |
| 869 | @item Linear systems solving (Gaussian, Jacobi, Zeidel, Square Root, Sweep and other) |
| 870 | @item Matrices decomposition (Eigenvalues/Eigenvectors, SVD, QR, LU, Cholesky and other) |
| 871 | @item MatrixMarket/CSV IO formats support for matrices and vectors |
| 872 | @end itemize\n") |
| 873 | (license license:asl2.0))) |
| 874 | |
| 875 | (define-public java-jlargearrays |
| 876 | (package |
| 877 | (name "java-jlargearrays") |
| 878 | (version "1.6") |
| 879 | (source (origin |
| 880 | (method url-fetch) |
| 881 | (uri (string-append "https://repo1.maven.org/maven2/" |
| 882 | "pl/edu/icm/JLargeArrays/" |
| 883 | version "/JLargeArrays-" version |
| 884 | "-sources.jar")) |
| 885 | (file-name (string-append name "-" version ".jar")) |
| 886 | (sha256 |
| 887 | (base32 |
| 888 | "0v05iphpxbjnd7f4jf1rlqq3m8hslhcm0imdbsgxr20pi3xkaf2a")))) |
| 889 | (build-system ant-build-system) |
| 890 | (arguments |
| 891 | `(#:jar-name "jlargearrays.jar" |
| 892 | #:tests? #f ; tests are not included in the release archive |
| 893 | #:jdk ,icedtea-8)) |
| 894 | (propagated-inputs |
| 895 | `(("java-commons-math3" ,java-commons-math3))) |
| 896 | (home-page "https://gitlab.com/ICM-VisLab/JLargeArrays") |
| 897 | (synopsis "Library of one-dimensional arrays that can store up to 263 elements") |
| 898 | (description "JLargeArrays is a Java library of one-dimensional arrays |
| 899 | that can store up to 263 elements.") |
| 900 | (license license:bsd-2))) |
| 901 | |
| 902 | (define-public java-jtransforms |
| 903 | (package |
| 904 | (name "java-jtransforms") |
| 905 | (version "3.1") |
| 906 | (source (origin |
| 907 | (method url-fetch) |
| 908 | (uri (string-append "https://repo1.maven.org/maven2/" |
| 909 | "com/github/wendykierp/JTransforms/" |
| 910 | version "/JTransforms-" version "-sources.jar")) |
| 911 | (sha256 |
| 912 | (base32 |
| 913 | "1haw5m8shv5srgcpwkl853dz8bv6h90bzlhcps6mdpb4cixjirsg")))) |
| 914 | (build-system ant-build-system) |
| 915 | (arguments |
| 916 | `(#:jar-name "jtransforms.jar" |
| 917 | #:tests? #f ; tests are not included in the release archive |
| 918 | #:jdk ,icedtea-8)) |
| 919 | (propagated-inputs |
| 920 | `(("java-commons-math3" ,java-commons-math3) |
| 921 | ("java-jlargearrays" ,java-jlargearrays))) |
| 922 | (home-page "https://github.com/wendykierp/JTransforms") |
| 923 | (synopsis "Multithreaded FFT library written in pure Java") |
| 924 | (description "JTransforms is a multithreaded FFT library written in pure |
| 925 | Java. Currently, four types of transforms are available: @dfn{Discrete |
| 926 | Fourier Transform} (DFT), @dfn{Discrete Cosine Transform} (DCT), @dfn{Discrete |
| 927 | Sine Transform} (DST) and @dfn{Discrete Hartley Transform} (DHT).") |
| 928 | (license license:bsd-2))) |
| 929 | |
| 930 | (define-public lmfit |
| 931 | (package |
| 932 | (name "lmfit") |
| 933 | (version "8.2.2") |
| 934 | (source (origin |
| 935 | (method git-fetch) |
| 936 | (uri (git-reference |
| 937 | (url "https://jugit.fz-juelich.de/mlz/lmfit.git") |
| 938 | (commit (string-append "v" version)))) |
| 939 | (file-name (git-file-name name version)) |
| 940 | (sha256 |
| 941 | (base32 |
| 942 | "00bch77a6qgnw6vzsjn2a42n8n683ih3xm0wpr454jxa15hw78vf")))) |
| 943 | (build-system cmake-build-system) |
| 944 | (native-inputs |
| 945 | `(("perl" ,perl))) ; for pod2man |
| 946 | (home-page "https://jugit.fz-juelich.de/mlz/lmfit") |
| 947 | (synopsis "Levenberg-Marquardt minimization and least-squares fitting") |
| 948 | (description "lmfit is a C library for Levenberg-Marquardt least-squares |
| 949 | minimization and curve fitting. It is mature code, based on decades-old |
| 950 | algorithms from the FORTRAN library MINPACK.") |
| 951 | (license license:bsd-2))) |
| 952 | |
| 953 | (define-public symengine |
| 954 | (package |
| 955 | (name "symengine") |
| 956 | (version "0.6.0") |
| 957 | (source |
| 958 | (origin |
| 959 | (method git-fetch) |
| 960 | (uri (git-reference |
| 961 | (url "https://github.com/symengine/symengine") |
| 962 | (commit (string-append "v" version)))) |
| 963 | (file-name (git-file-name name version)) |
| 964 | (sha256 |
| 965 | (base32 "129iv9maabmb42ylfdv0l0g94mcbf3y4q3np175008rcqdr8z6h1")))) |
| 966 | (build-system cmake-build-system) |
| 967 | (arguments |
| 968 | '(#:configure-flags |
| 969 | ;; These are the suggested build options in the README. |
| 970 | '("-DCMAKE_BUILD_TYPE=Release" |
| 971 | "-DWITH_GMP=on" |
| 972 | "-DWITH_MPFR=on" |
| 973 | "-DWITH_MPC=on" |
| 974 | "-DINTEGER_CLASS=flint" |
| 975 | "-DWITH_SYMENGINE_THREAD_SAFE=on" |
| 976 | "-DBUILD_SHARED_LIBS=on"))) ;also build libsymengine |
| 977 | (inputs |
| 978 | `(("flint" ,flint) |
| 979 | ("gmp" ,gmp) |
| 980 | ("mpc" ,mpc) |
| 981 | ("mpfr" ,mpfr))) |
| 982 | (home-page "https://github.com/symengine/symengine") |
| 983 | (synopsis "Fast symbolic manipulation library") |
| 984 | (description |
| 985 | "SymEngine is a standalone fast C++ symbolic manipulation library. |
| 986 | Optional thin wrappers allow usage of the library from other languages.") |
| 987 | (license (list license:expat ;SymEngine |
| 988 | license:bsd-3)))) ;3rd party code |
| 989 | |
| 990 | (define-public eigen |
| 991 | (package |
| 992 | (name "eigen") |
| 993 | (version "3.3.8") |
| 994 | (source (origin |
| 995 | (method url-fetch) |
| 996 | (uri (list |
| 997 | (string-append "https://bitbucket.org/eigen/eigen/get/" |
| 998 | version ".tar.bz2") |
| 999 | (string-append "mirror://debian/pool/main/e/eigen3/eigen3_" |
| 1000 | version ".orig.tar.bz2"))) |
| 1001 | (sha256 |
| 1002 | (base32 |
| 1003 | "1vxrsncfnkyq6gwxpsannpryp12mk7lc8f42ybvz3saf7icwc582")) |
| 1004 | (file-name (string-append name "-" version ".tar.bz2")) |
| 1005 | (patches (search-patches "eigen-remove-openmp-error-counting.patch" |
| 1006 | "eigen-stabilise-sparseqr-test.patch")) |
| 1007 | (modules '((guix build utils))) |
| 1008 | (snippet |
| 1009 | ;; There are 3 test failures in the "unsupported" directory, |
| 1010 | ;; but maintainers say it's a known issue and it's unsupported |
| 1011 | ;; anyway, so just skip them. |
| 1012 | '(begin |
| 1013 | (substitute* "unsupported/CMakeLists.txt" |
| 1014 | (("add_subdirectory\\(test.*") |
| 1015 | "# Do not build the tests for unsupported features.\n")) |
| 1016 | #t)))) |
| 1017 | (build-system cmake-build-system) |
| 1018 | (arguments |
| 1019 | '(;; Turn off debugging symbols to save space. |
| 1020 | #:build-type "Release" |
| 1021 | |
| 1022 | #:phases (modify-phases %standard-phases |
| 1023 | (replace 'check |
| 1024 | (lambda _ |
| 1025 | (let* ((cores (parallel-job-count)) |
| 1026 | (dash-j (format #f "-j~a" cores))) |
| 1027 | (setenv "EIGEN_SEED" "1") ;for reproducibility |
| 1028 | ;; First build the tests, in parallel. See |
| 1029 | ;; <http://eigen.tuxfamily.org/index.php?title=Tests>. |
| 1030 | (invoke "make" "buildtests" dash-j) |
| 1031 | |
| 1032 | ;; Then run 'CTest' with -V so we get more |
| 1033 | ;; details upon failure. |
| 1034 | (invoke "ctest" "-V" dash-j))))))) |
| 1035 | (home-page "https://eigen.tuxfamily.org") |
| 1036 | (synopsis "C++ template library for linear algebra") |
| 1037 | (description |
| 1038 | "Eigen is a C++ template library for linear algebra: matrices, vectors, |
| 1039 | numerical solvers, and related algorithms. It provides an elegant API based |
| 1040 | on \"expression templates\". It is versatile: it supports all matrix sizes, |
| 1041 | all standard numeric types, various matrix decompositions and geometry |
| 1042 | features, and more.") |
| 1043 | |
| 1044 | ;; Most of the code is MPLv2, with a few files under LGPLv2.1+ or BSD-3. |
| 1045 | ;; See 'COPYING.README' for details. |
| 1046 | (license license:mpl2.0))) |
| 1047 | |
| 1048 | (define-public eigen-for-tensorflow |
| 1049 | (let ((changeset "fd6845384b86") |
| 1050 | (revision "1")) |
| 1051 | (package (inherit eigen) |
| 1052 | (name "eigen-for-tensorflow") |
| 1053 | (version (string-append "3.3.5-" revision "." changeset)) |
| 1054 | (source (origin |
| 1055 | (method hg-fetch) |
| 1056 | (uri (hg-reference |
| 1057 | (url "https://bitbucket.org/eigen/eigen") |
| 1058 | (changeset changeset))) |
| 1059 | (sha256 |
| 1060 | (base32 |
| 1061 | "12cwgah63wqwb66xji048hcxc1z5zjg8a7701zlia5zbilnnk1n5")) |
| 1062 | (file-name (string-append name "-" version "-checkout")) |
| 1063 | (modules '((guix build utils))) |
| 1064 | (snippet |
| 1065 | ;; There are 3 test failures in the "unsupported" directory, |
| 1066 | ;; but maintainers say it's a known issue and it's unsupported |
| 1067 | ;; anyway, so just skip them. |
| 1068 | '(begin |
| 1069 | (substitute* "unsupported/CMakeLists.txt" |
| 1070 | (("add_subdirectory\\(test.*") |
| 1071 | "# Do not build the tests for unsupported features.\n")) |
| 1072 | #t))))))) |
| 1073 | |
| 1074 | (define-public xtensor |
| 1075 | (package |
| 1076 | (name "xtensor") |
| 1077 | (version "0.20.10") |
| 1078 | (source (origin |
| 1079 | (method git-fetch) |
| 1080 | (uri (git-reference |
| 1081 | (url "https://github.com/xtensor-stack/xtensor") |
| 1082 | (commit version))) |
| 1083 | (sha256 |
| 1084 | (base32 |
| 1085 | "1fmv2hpx610xwhxrndfsfvlbqfyk4l3gi5q5d7pa9m82kblxjj9l")) |
| 1086 | (file-name (git-file-name name version)))) |
| 1087 | (build-system cmake-build-system) |
| 1088 | (native-inputs |
| 1089 | `(("googletest" ,googletest) |
| 1090 | ("xtl" ,xtl))) |
| 1091 | (arguments |
| 1092 | `(#:configure-flags |
| 1093 | '("-DBUILD_TESTS=ON") |
| 1094 | #:test-target "xtest")) |
| 1095 | (home-page "https://xtensor.readthedocs.io/en/latest/") |
| 1096 | (synopsis "C++ tensors with broadcasting and lazy computing") |
| 1097 | (description "xtensor is a C++ library meant for numerical analysis with |
| 1098 | multi-dimensional array expressions. |
| 1099 | |
| 1100 | xtensor provides: |
| 1101 | @itemize |
| 1102 | @item an extensible expression system enabling lazy broadcasting. |
| 1103 | @item an API following the idioms of the C++ standard library. |
| 1104 | @item tools to manipulate array expressions and build upon xtensor. |
| 1105 | @end itemize") |
| 1106 | (license license:bsd-3))) |
| 1107 | |
| 1108 | (define-public gap |
| 1109 | (package |
| 1110 | (name "gap") |
| 1111 | (version "4.11.0") |
| 1112 | (source |
| 1113 | (origin |
| 1114 | (method url-fetch) |
| 1115 | (uri (string-append "https://files.gap-system.org/gap-" |
| 1116 | (version-major+minor version) |
| 1117 | "/tar.bz2/gap-" |
| 1118 | version |
| 1119 | ".tar.bz2")) |
| 1120 | (sha256 |
| 1121 | (base32 "00l6hvy4iggnlrib4vp805sxdm3j7n3hzpv5zs9hbiiavh80l1xz")) |
| 1122 | (modules '((guix build utils) (ice-9 ftw) (srfi srfi-1))) |
| 1123 | (snippet |
| 1124 | '(begin |
| 1125 | ;; Delete the external gmp and zlib libraries |
| 1126 | ;; and a subdirectory not needed for our build. |
| 1127 | (for-each delete-file-recursively |
| 1128 | '("extern" "hpcgap")) |
| 1129 | ;; Delete a failing test. |
| 1130 | ;; FIXME: This might be fixed in the next release, see |
| 1131 | ;; https://github.com/gap-system/gap/issues/3292 |
| 1132 | (delete-file "tst/testinstall/dir.tst") |
| 1133 | ;; Delete all packages except for a fixed list, |
| 1134 | ;; given by their names up to version numbers. |
| 1135 | (with-directory-excursion "pkg" |
| 1136 | (for-each delete-file-recursively |
| 1137 | (lset-difference |
| 1138 | (lambda (all keep) (string-prefix? keep all)) |
| 1139 | (scandir ".") |
| 1140 | '("." ".." |
| 1141 | ;; Necessary packages. |
| 1142 | "GAPDoc-" |
| 1143 | "primgrp-" |
| 1144 | "SmallGrp-" ; artistic2.0 |
| 1145 | "transgrp" ; artistic2.0 for data, |
| 1146 | ; gpl2 or gpl3 for code |
| 1147 | ;; Recommended package. |
| 1148 | "io-" ; gpl3+ |
| 1149 | ;; Optional packages, searched for at start, |
| 1150 | ;; and their depedencies. |
| 1151 | "alnuth-" |
| 1152 | "autpgrp-" |
| 1153 | "crisp-" ; bsd-2 |
| 1154 | "ctbllib" ; gpl3+, clarified in the next release; |
| 1155 | ; see |
| 1156 | ; http://www.math.rwth-aachen.de/~Thomas.Breuer/ctbllib/README.md |
| 1157 | "FactInt-" |
| 1158 | "fga" |
| 1159 | "irredsol-" ; bsd-2 |
| 1160 | "laguna-" |
| 1161 | "polenta-" |
| 1162 | "polycyclic-" |
| 1163 | "radiroot-" |
| 1164 | "resclasses-" |
| 1165 | "sophus-" |
| 1166 | "tomlib-" |
| 1167 | "utils-")))) |
| 1168 | #t)))) |
| 1169 | (build-system gnu-build-system) |
| 1170 | (inputs |
| 1171 | `(("gmp" ,gmp) |
| 1172 | ("readline" ,readline) |
| 1173 | ("zlib" ,zlib))) |
| 1174 | (arguments |
| 1175 | `(#:modules ((ice-9 ftw) |
| 1176 | (srfi srfi-26) |
| 1177 | (guix build gnu-build-system) |
| 1178 | (guix build utils)) |
| 1179 | #:phases |
| 1180 | (modify-phases %standard-phases |
| 1181 | (add-after 'build 'build-packages |
| 1182 | ;; Compile all packages that have not been deleted by the |
| 1183 | ;; code snippet above. |
| 1184 | (lambda _ |
| 1185 | (setenv "CONFIG_SHELL" (which "bash")) |
| 1186 | (with-directory-excursion "pkg" |
| 1187 | (invoke "../bin/BuildPackages.sh") |
| 1188 | #t))) |
| 1189 | (add-after 'build-packages 'build-doc |
| 1190 | ;; The documentation is bundled, but we create it from source. |
| 1191 | (lambda _ |
| 1192 | (with-directory-excursion "doc" |
| 1193 | (invoke "./make_doc")) |
| 1194 | #t)) |
| 1195 | (replace 'install |
| 1196 | (lambda* (#:key outputs #:allow-other-keys) |
| 1197 | (let* ((out (assoc-ref outputs "out")) |
| 1198 | (bin (string-append out "/bin")) |
| 1199 | (prog (string-append bin "/gap")) |
| 1200 | (prog-real (string-append bin "/.gap-real")) |
| 1201 | (share (string-append out "/share/gap"))) |
| 1202 | ;; Install only the gap binary; the gac compiler is left |
| 1203 | ;; for maybe later. "Wrap" it in a shell script that calls |
| 1204 | ;; the binary with the correct parameter. |
| 1205 | ;; The make target install-bin is supposed to do that, but |
| 1206 | ;; is not currently working. |
| 1207 | (mkdir-p bin) |
| 1208 | (copy-file "gap" prog-real) |
| 1209 | (call-with-output-file prog |
| 1210 | (lambda (port) |
| 1211 | (format port |
| 1212 | "#!~a~%exec ~a -l ~a \"$@\"~%" |
| 1213 | (which "bash") |
| 1214 | prog-real |
| 1215 | share))) |
| 1216 | (chmod prog #o755) |
| 1217 | ;; Install the headers and library, which are needed by Sage. |
| 1218 | (invoke "make" "install-headers") |
| 1219 | (invoke "make" "install-libgap") |
| 1220 | ;; Remove information on the build directory from sysinfo.gap. |
| 1221 | (substitute* "sysinfo.gap" |
| 1222 | (("GAP_BIN_DIR=\".*\"") "GAP_BIN_DIR=\"\"") |
| 1223 | (("GAP_LIB_DIR=\".*\"") "GAP_LIB_DIR=\"\"") |
| 1224 | (("GAP_CPPFLAGS=\".*\"") "GAP_CPPFLAGS=\"\"")) |
| 1225 | (invoke "make" "install-gaproot") |
| 1226 | ;; Copy the directory of compiled packages; the make target |
| 1227 | ;; install-pkg is currently empty. |
| 1228 | (copy-recursively "pkg" (string-append share "/pkg"))) |
| 1229 | #t))))) |
| 1230 | (home-page "https://www.gap-system.org/") |
| 1231 | (synopsis |
| 1232 | "System for computational group theory") |
| 1233 | (description |
| 1234 | "GAP is a system for computational discrete algebra, with particular |
| 1235 | emphasis on computational group theory. It provides a programming language, |
| 1236 | a library of thousands of functions implementing algebraic algorithms |
| 1237 | written in the GAP language as well as large data libraries of algebraic |
| 1238 | objects.") |
| 1239 | ;; Some packages have different licenses (effectively forcing the |
| 1240 | ;; combined work to be licensed as gpl3+); if this is the case, this |
| 1241 | ;; is mentioned above next to their name. |
| 1242 | ;; Some packages have no license mentioned explicitly; supposedly this |
| 1243 | ;; means that the gpl2+ licence of GAP itself applies, but to be on the |
| 1244 | ;; safe side, we drop them for now. |
| 1245 | (license license:gpl2+))) |
| 1246 | |
| 1247 | (define-public givaro |
| 1248 | (package |
| 1249 | (name "givaro") |
| 1250 | (version "4.1.1") |
| 1251 | (source (origin |
| 1252 | (method git-fetch) |
| 1253 | (uri (git-reference |
| 1254 | (url "https://github.com/linbox-team/givaro") |
| 1255 | (commit (string-append "v" version)))) |
| 1256 | (file-name (git-file-name name version)) |
| 1257 | (sha256 |
| 1258 | (base32 |
| 1259 | "11wz57q6ijsvfs5r82masxgr319as92syi78lnl9lgdblpc6xigk")))) |
| 1260 | (build-system gnu-build-system) |
| 1261 | (native-inputs |
| 1262 | `(("autoconf" ,autoconf) |
| 1263 | ("automake" ,automake) |
| 1264 | ("libtool" ,libtool))) |
| 1265 | (propagated-inputs |
| 1266 | `(("gmp" ,gmp))) ; gmp++.h includes gmpxx.h |
| 1267 | (synopsis "Algebraic computations with exact rings and fields") |
| 1268 | (description |
| 1269 | "Givaro is a C++ library implementing the basic arithmetic of various |
| 1270 | algebraic objects: prime fields, extension fields, finite fields, finite |
| 1271 | rings, polynomials, algebraic numbers, arbitrary precision integers and |
| 1272 | rationals (C++ wrappers over gmp), fixed precision integers. It also |
| 1273 | provides data-structures and templated classes for the manipulation of |
| 1274 | compound objects, such as vectors, matrices and univariate polynomials.") |
| 1275 | (license license:cecill-b) |
| 1276 | (home-page "https://github.com/linbox-team/givaro"))) |
| 1277 | |
| 1278 | (define-public fflas-ffpack |
| 1279 | (package |
| 1280 | (name "fflas-ffpack") |
| 1281 | (version "2.4.3") |
| 1282 | (source (origin |
| 1283 | (method git-fetch) |
| 1284 | (uri (git-reference |
| 1285 | (url "https://github.com/linbox-team/fflas-ffpack") |
| 1286 | (commit version))) |
| 1287 | (file-name (git-file-name name version)) |
| 1288 | (sha256 |
| 1289 | (base32 |
| 1290 | "1ynbjd72qrwp0b4kpn0p5d7gddpvj8dlb5fwdxajr5pvkvi3if74")))) |
| 1291 | (build-system gnu-build-system) |
| 1292 | (native-inputs |
| 1293 | `(("autoconf" ,autoconf) |
| 1294 | ("automake" ,automake) |
| 1295 | ("libtool" ,libtool) |
| 1296 | ("pkg-config" ,pkg-config))) |
| 1297 | (inputs |
| 1298 | `(("openblas" ,openblas))) |
| 1299 | (propagated-inputs |
| 1300 | `(("givaro" ,givaro))) ; required according to the .pc file |
| 1301 | (arguments |
| 1302 | `(#:configure-flags |
| 1303 | (list (string-append "--with-blas-libs=" |
| 1304 | (assoc-ref %build-inputs "openblas") |
| 1305 | "/lib/libopenblas.so")))) |
| 1306 | (synopsis "C++ library for linear algebra over finite fields") |
| 1307 | (description |
| 1308 | "FFLAS-FFPACK is a C++ template library for basic linear algebra |
| 1309 | operations over a finite field. |
| 1310 | FFLAS (Finite Field Linear Algebra Subprograms) provides the implementation |
| 1311 | of a subset of routines of the numerical BLAS; it also supports sparse |
| 1312 | matrix-vector products. |
| 1313 | FFPACK (Finite Field Linear Algebra Package) is inspired by the LAPACK |
| 1314 | library to provide functionalities of higher level, using the kernel |
| 1315 | of a BLAS. Additionally, it provides routines specific to exact linear |
| 1316 | algebra, such as the row echelon form.") |
| 1317 | (license license:lgpl2.1+) |
| 1318 | (home-page "https://linbox-team.github.io/fflas-ffpack/"))) |
| 1319 | |
| 1320 | (define-public linbox |
| 1321 | (package |
| 1322 | (name "linbox") |
| 1323 | (version "1.6.3") |
| 1324 | (source (origin |
| 1325 | (method git-fetch) |
| 1326 | (uri (git-reference |
| 1327 | (url "https://github.com/linbox-team/linbox") |
| 1328 | (commit (string-append "v" version)))) |
| 1329 | (file-name (git-file-name name version)) |
| 1330 | (sha256 |
| 1331 | (base32 |
| 1332 | "10j6dspbsq7d2l4q3y0c1l1xwmaqqba2fxg59q5bhgk9h5d7q571")) |
| 1333 | (patches (search-patches "linbox-fix-pkgconfig.patch")))) |
| 1334 | (build-system gnu-build-system) |
| 1335 | (native-inputs |
| 1336 | `(("autoconf" ,autoconf) |
| 1337 | ("automake" ,automake) |
| 1338 | ("libtool" ,libtool) |
| 1339 | ("pkg-config" ,pkg-config))) |
| 1340 | (propagated-inputs |
| 1341 | `(("fflas-ffpack" ,fflas-ffpack))) |
| 1342 | (synopsis "C++ library for linear algebra over exact rings") |
| 1343 | (description |
| 1344 | "LinBox is a C++ template library for exact linear algebra computation |
| 1345 | with dense, sparse, and structured matrices over the integers and over |
| 1346 | finite fields.") |
| 1347 | (license license:lgpl2.1+) |
| 1348 | (home-page "https://linbox-team.github.io/linbox/"))) |
| 1349 | |
| 1350 | (define-public m4ri |
| 1351 | (package |
| 1352 | (name "m4ri") |
| 1353 | (version "20140914") |
| 1354 | (source (origin |
| 1355 | (method git-fetch) |
| 1356 | (uri (git-reference |
| 1357 | (url "https://bitbucket.org/malb/m4ri") |
| 1358 | (commit (string-append "release-" version)))) |
| 1359 | (file-name (git-file-name name version)) |
| 1360 | (sha256 |
| 1361 | (base32 |
| 1362 | "0xfg6pffbn8r1s0y7bn9b8i55l00d41dkmhrpf7pwk53qa3achd3")))) |
| 1363 | (build-system gnu-build-system) |
| 1364 | (native-inputs |
| 1365 | `(("autoconf" ,autoconf) |
| 1366 | ("automake" ,automake) |
| 1367 | ("libtool" ,libtool) |
| 1368 | ("pkg-config" ,pkg-config))) |
| 1369 | (inputs |
| 1370 | `(("libpng" ,libpng))) |
| 1371 | (synopsis "Arithmetic of dense matrices over F_2") |
| 1372 | (description "M4RI is a library for fast arithmetic with dense matrices |
| 1373 | over F2. The name M4RI comes from the first implemented algorithm: The |
| 1374 | Method of the Four Russians inversion algorithm published by Gregory Bard. |
| 1375 | This algorithm in turn is named after the Method of the Four Russians |
| 1376 | multiplication algorithm.") |
| 1377 | (license license:gpl2+) |
| 1378 | (home-page "https://bitbucket.org/malb/m4ri/"))) |
| 1379 | |
| 1380 | (define-public symmetrica |
| 1381 | (package |
| 1382 | (name "symmetrica") |
| 1383 | (version "2.0") |
| 1384 | (source (origin |
| 1385 | (method url-fetch/tarbomb) |
| 1386 | (uri (let ((v (string-join (string-split version #\.) "_"))) |
| 1387 | (string-append "http://www.algorithm.uni-bayreuth.de/" |
| 1388 | "en/research/SYMMETRICA/" |
| 1389 | "SYM" v "_tar.gz"))) |
| 1390 | (sha256 |
| 1391 | (base32 |
| 1392 | "1qhfrbd5ybb0sinl9pad64rscr08qvlfzrzmi4p4hk61xn6phlmz")) |
| 1393 | ;; Taken from <https://git.sagemath.org/sage.git/plain/build/pkgs/symmetrica/patches/> |
| 1394 | (patches (search-patches "symmetrica-bruch.patch" |
| 1395 | "symmetrica-int32.patch" |
| 1396 | "symmetrica-return_values.patch" |
| 1397 | "symmetrica-sort_sum_rename.patch")))) |
| 1398 | (build-system gnu-build-system) |
| 1399 | (arguments |
| 1400 | `(#:tests? #f ;no test |
| 1401 | #:phases |
| 1402 | (modify-phases %standard-phases |
| 1403 | (add-after 'unpack 'fix-makefile |
| 1404 | (lambda _ |
| 1405 | (substitute* "makefile" |
| 1406 | (("cc -c") "gcc -c -fPIC")) |
| 1407 | #t)) |
| 1408 | (add-after 'fix-makefile 'turn-off-banner |
| 1409 | (lambda _ |
| 1410 | (substitute* "de.c" |
| 1411 | (("(INT no_banner = )FALSE" _ pre) (string-append pre "TRUE"))) |
| 1412 | #t)) |
| 1413 | (delete 'configure) ;no configure script |
| 1414 | (replace 'install ;no install target |
| 1415 | (lambda* (#:key outputs #:allow-other-keys) |
| 1416 | (let* ((out (assoc-ref outputs "out")) |
| 1417 | (lib (string-append out "/lib")) |
| 1418 | (inc (string-append out "/include/symmetrica")) |
| 1419 | (doc (string-append out "/share/doc/symmetrica-" ,version)) |
| 1420 | (static "libsymmetrica.a")) |
| 1421 | ;; Build static library. |
| 1422 | (apply invoke "ar" "crs" static (find-files "." "\\.o$")) |
| 1423 | (invoke "ranlib" static) |
| 1424 | ;; Install static library and headers. |
| 1425 | (for-each (lambda (f) (install-file f inc)) |
| 1426 | (find-files "." "\\.h$")) |
| 1427 | (install-file "libsymmetrica.a" lib) |
| 1428 | ;; Install documentation. |
| 1429 | (for-each (lambda (f) (install-file f doc)) |
| 1430 | (find-files "." "\\.doc$")) |
| 1431 | #t)))))) |
| 1432 | (home-page "http://www.algorithm.uni-bayreuth.de/en/research/SYMMETRICA/") |
| 1433 | (synopsis "Combinatoric C Library") |
| 1434 | (description "Symmetrica is a library for combinatorics. It has support |
| 1435 | for the representation theory of the symmetric group and related groups, |
| 1436 | combinatorics of tableaux, symmetric functions and polynomials, Schubert |
| 1437 | polynomials, and the representation theory of Hecke algebras of type A_n.") |
| 1438 | (license license:public-domain))) |
| 1439 | |
| 1440 | (define-public m4rie |
| 1441 | (package |
| 1442 | (name "m4rie") |
| 1443 | (version "20150908") |
| 1444 | (source (origin |
| 1445 | (method git-fetch) |
| 1446 | (uri (git-reference |
| 1447 | (url "https://bitbucket.org/malb/m4rie") |
| 1448 | (commit (string-append "release-" version)))) |
| 1449 | (file-name (git-file-name name version)) |
| 1450 | (sha256 |
| 1451 | (base32 |
| 1452 | "0r8lv46qx5mkz5kp3ay2jnsp0mbhlqr5z2z220wdk73wdshcznss")))) |
| 1453 | (build-system gnu-build-system) |
| 1454 | (native-inputs |
| 1455 | `(("autoconf" ,autoconf) |
| 1456 | ("automake" ,automake) |
| 1457 | ("libtool" ,libtool))) |
| 1458 | (inputs |
| 1459 | `(("m4ri" ,m4ri))) |
| 1460 | (synopsis "Arithmetic of dense matrices over F_{2^e}") |
| 1461 | (description "M4RI is a library for fast arithmetic with dense matrices |
| 1462 | over finite fields of characteristic 2. So it extends the functionality |
| 1463 | of M4RI from F_2 to F_{2^e}.") |
| 1464 | (license license:gpl2+) |
| 1465 | (home-page "https://bitbucket.org/malb/m4rie/"))) |
| 1466 | |
| 1467 | (define-public eclib |
| 1468 | (package |
| 1469 | (name "eclib") |
| 1470 | (version "20190909") |
| 1471 | (source (origin |
| 1472 | (method git-fetch) |
| 1473 | (uri (git-reference |
| 1474 | (url "https://github.com/JohnCremona/eclib/") |
| 1475 | (commit (string-append "v" version)))) |
| 1476 | (file-name (git-file-name name version)) |
| 1477 | (sha256 |
| 1478 | (base32 |
| 1479 | "1gw27lqc3f525n8qdcmr2nyn16y9g10z9f6dnmckyyxcdzvhq35n")))) |
| 1480 | (build-system gnu-build-system) |
| 1481 | (native-inputs |
| 1482 | `(("autoconf" ,autoconf) |
| 1483 | ("automake" ,automake) |
| 1484 | ("libtool" ,libtool))) |
| 1485 | (inputs |
| 1486 | `(("ntl" ,ntl) |
| 1487 | ("pari-gp" ,pari-gp))) |
| 1488 | (synopsis "Ranks of elliptic curves and modular symbols") |
| 1489 | (description "The eclib package includes mwrank (for 2-descent on |
| 1490 | elliptic curves over Q) and modular symbol code; it has been written by |
| 1491 | John Cremona to compute his elliptic curve database.") |
| 1492 | (license license:gpl2+) |
| 1493 | (home-page (string-append "http://homepages.warwick.ac.uk/staff/" |
| 1494 | "J.E.Cremona/mwrank/index.html")))) |
| 1495 | |
| 1496 | (define-public lrcalc |
| 1497 | (package |
| 1498 | (name "lrcalc") |
| 1499 | (version "1.2") |
| 1500 | (source (origin |
| 1501 | (method git-fetch) |
| 1502 | (uri (git-reference |
| 1503 | (url "https://bitbucket.org/asbuch/lrcalc") |
| 1504 | (commit (string-append "lrcalc-" version)))) |
| 1505 | (file-name (git-file-name name version)) |
| 1506 | (sha256 |
| 1507 | (base32 |
| 1508 | "1c12d04jdyxkkav4ak8d1aqrv594gzihwhpxvc6p9js0ry1fahss")) |
| 1509 | (patches (search-patches "lrcalc-includes.patch")))) |
| 1510 | (build-system gnu-build-system) |
| 1511 | (native-inputs |
| 1512 | `(("autoconf" ,autoconf) |
| 1513 | ("automake" ,automake) |
| 1514 | ("libtool" ,libtool))) |
| 1515 | (arguments |
| 1516 | `(#:phases |
| 1517 | (modify-phases %standard-phases |
| 1518 | (add-before 'build 'fix-permission |
| 1519 | (lambda _ |
| 1520 | (chmod "lrcalc.maple.src" #o644) |
| 1521 | #t))))) |
| 1522 | (synopsis "Littlewood-Richardson calculator in algebraic combinatorics") |
| 1523 | (description "The Littlewood-Richardson Calculator (lrcalc) is a |
| 1524 | program designed to compute Littlewood-Richardson coefficients. It computes |
| 1525 | single Littlewood-Richardson coefficients, products of Schur functions, or |
| 1526 | skew Schur functions. In addition it computes products in the small quantum |
| 1527 | cohomology ring of a Grassmann variety. The software package also includes |
| 1528 | a program that performs fast computation of the more general multiplicative |
| 1529 | structure constants of Schubert polynomials.") |
| 1530 | (license license:gpl2+) |
| 1531 | (home-page "https://sites.math.rutgers.edu/~asbuch/lrcalc/"))) |
| 1532 | |
| 1533 | (define-public iml |
| 1534 | (package |
| 1535 | (name "iml") |
| 1536 | (version "1.0.5") |
| 1537 | (source |
| 1538 | (origin |
| 1539 | (method url-fetch) |
| 1540 | (uri (string-append "http://www.cs.uwaterloo.ca/~astorjoh/iml-" |
| 1541 | version ".tar.bz2")) |
| 1542 | (sha256 |
| 1543 | (base32 |
| 1544 | "0akwhhz9b40bz6lrfxpamp7r7wkk48p455qbn04mfnl9a1l6db8x")))) |
| 1545 | (build-system gnu-build-system) |
| 1546 | (inputs |
| 1547 | `(("gmp" ,gmp) |
| 1548 | ("cblas" ,openblas))) ; or any other BLAS library; the documentation |
| 1549 | ; mentions ATLAS in particular |
| 1550 | (arguments |
| 1551 | `(#:configure-flags |
| 1552 | (list |
| 1553 | "--enable-shared" |
| 1554 | (string-append "--with-gmp-include=" |
| 1555 | (assoc-ref %build-inputs "gmp") "/include") |
| 1556 | (string-append "--with-gmp-lib=" |
| 1557 | (assoc-ref %build-inputs "gmp") "/lib") |
| 1558 | "--with-cblas=-lopenblas" |
| 1559 | (string-append "--with-cblas-include=" |
| 1560 | (assoc-ref %build-inputs "cblas") "/include") |
| 1561 | (string-append "--with-cblas-lib=" |
| 1562 | (assoc-ref %build-inputs "cblas") "/lib")))) |
| 1563 | (home-page "https://cs.uwaterloo.ca/~astorjoh/iml.html") |
| 1564 | (synopsis |
| 1565 | "Solver for systems of linear equations over the integers") |
| 1566 | (description |
| 1567 | "IML is a C library implementing algorithms for computing exact |
| 1568 | solutions to dense systems of linear equations over the integers. |
| 1569 | Currently, IML provides the following functionality: |
| 1570 | |
| 1571 | @itemize |
| 1572 | @item Nonsingular rational system solving: |
| 1573 | compute the unique rational solution X to the system AX=B, where A and B |
| 1574 | are integer matrices, A nonsingular. |
| 1575 | @item Compute the right nullspace or kernel of an integer matrix. |
| 1576 | @item Certified linear system solving: |
| 1577 | compute a minimal denominator solution x to a system Ax=b, where b is an |
| 1578 | integer vector and A is an integer matrix with arbitrary shape and |
| 1579 | rank profile. |
| 1580 | @end itemize |
| 1581 | |
| 1582 | In addition, IML provides some low level routines for a variety of mod p |
| 1583 | matrix operations: computing the row-echelon form, determinant, rank |
| 1584 | profile, and inverse of a mod p matrix. These mod p routines are not |
| 1585 | general purpose; they require that p satisfy some preconditions based on |
| 1586 | the dimension of the input matrix (usually p should be prime and should be |
| 1587 | no more than about 20 bits long).") |
| 1588 | (license license:bsd-3))) |
| 1589 | |
| 1590 | (define-public r-dtt |
| 1591 | (package |
| 1592 | (name "r-dtt") |
| 1593 | (version "0.1-2") |
| 1594 | (source |
| 1595 | (origin |
| 1596 | (method url-fetch) |
| 1597 | (uri (cran-uri "dtt" version)) |
| 1598 | (sha256 |
| 1599 | (base32 |
| 1600 | "0n8gj5iylfagdbaqirpykb01a9difsy4zl6qq55f0ghvazxqdvmn")))) |
| 1601 | (properties `((upstream-name . "dtt"))) |
| 1602 | (build-system r-build-system) |
| 1603 | (home-page "http://www.r-project.org") |
| 1604 | (synopsis "Discrete Trigonometric Transforms") |
| 1605 | (description |
| 1606 | "This package provides functions for 1D and 2D Discrete Cosine Transform |
| 1607 | (@dfn{DCT}), Discrete Sine Transform (@dfn{DST}) and Discrete Hartley Transform |
| 1608 | (@dfn{DHT}).") |
| 1609 | (license license:gpl2+))) |