aland/nixpkgs-odroid-hc4
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions 2

uboot: (firmwareOdroidC2/C4) don't invoke patch tool, use patches = [] instead

Browse source 
https://github.com/NixOS/nixpkgs/blob/master/pkgs/stdenv/generic/setup.sh#L948
this can do it nicely.

Signed-off-by: Anton Arapov <anton@deadbeef.mx>
This commit is contained in:
Anton Arapov 2021-04-03 12:58:10 +02:00 • committed by Alan Daniels
commit 56de2bcd43
30691 changed files with 3076956 additions and 0 deletions
Download patch file Download diff file Expand all files Collapse all files

21
pkgs/development/libraries/science/astronomy/cfitsio/darwin-rpath-universal.patch Normal file
View file

@ -0,0 +1,21 @@
diff -ruN cfitsio/configure cfitsio-rpath-universal/configure
--- cfitsio/configure 2018-05-09 21:16:00.000000000 +0200
+++ cfitsio-rpath-universal/configure 2021-10-27 12:02:25.000000000 +0200
@@ -4829,16 +4829,7 @@
SHLIB_SUFFIX=".dylib"
CFITSIO_SHLIB="lib\${PACKAGE}.\${CFITSIO_SONAME}.\${CFITSIO_MAJOR}.\${CFITSIO_MINOR}\${SHLIB_SUFFIX}"
CFITSIO_SHLIB_SONAME="lib\${PACKAGE}.\${CFITSIO_SONAME}\${SHLIB_SUFFIX}"
- case $host in
- *darwin[56789]*)
- SHLIB_LD="$CC -dynamiclib -install_name lib\${PACKAGE}.\${CFITSIO_SONAME}\${SHLIB_SUFFIX} -compatibility_version \${CFITSIO_SONAME} -current_version \${CFITSIO_SONAME}.\${CFITSIO_MAJOR}.\${CFITSIO_MINOR}.\${CFITSIO_MICRO}"
- ;;
- *)
- # Build 'Universal' binaries (i386 & x86_64 architectures) and
- # use rpath token on Darwin 10.x or newer:
- SHLIB_LD="$CC -dynamiclib $C_UNIV_SWITCH -headerpad_max_install_names -install_name @rpath/lib\${PACKAGE}.\${CFITSIO_SONAME}\${SHLIB_SUFFIX} -compatibility_version \${CFITSIO_SONAME} -current_version \${CFITSIO_SONAME}.\${CFITSIO_MAJOR}.\${CFITSIO_MINOR}.\${CFITSIO_MICRO}"
- ;;
- esac
+ SHLIB_LD="$CC -dynamiclib -install_name ${out}/lib/lib\${PACKAGE}.\${CFITSIO_SONAME}\${SHLIB_SUFFIX} -compatibility_version \${CFITSIO_SONAME} -current_version \${CFITSIO_SONAME}.\${CFITSIO_MAJOR}.\${CFITSIO_MINOR}"
lhea_shlib_cflags="-fPIC -fno-common"
;;

42
pkgs/development/libraries/science/astronomy/cfitsio/default.nix Normal file
View file

@ -0,0 +1,42 @@
{ stdenv, lib, fetchurl, bzip2, zlib }:
stdenv.mkDerivation rec {
pname = "cfitsio";
version = "4.1.0";
src = fetchurl {
url = "https://heasarc.gsfc.nasa.gov/FTP/software/fitsio/c/cfitsio-${version}.tar.gz";
sha256 = "sha256-s2fGldKDGVjnFmkhw7NW1d+lGx7O5QW5dBa6OdG2wXo=";
};
buildInputs = [ bzip2 zlib ];
patches = [ ./darwin-rpath-universal.patch ];
configureFlags = [ "--with-bzip2=${bzip2.out}" "--enable-reentrant" ];
hardeningDisable = [ "format" ];
# Shared-only build
buildFlags = [ "shared" ];
postPatch = '' sed -e '/^install:/s/libcfitsio.a //' -e 's@/bin/@@g' -i Makefile.in
'';
meta = with lib; {
homepage = "https://heasarc.gsfc.nasa.gov/fitsio/";
description = "Library for reading and writing FITS data files";
longDescription =
'' CFITSIO is a library of C and Fortran subroutines for reading and
writing data files in FITS (Flexible Image Transport System) data
format. CFITSIO provides simple high-level routines for reading and
writing FITS files that insulate the programmer from the internal
complexities of the FITS format. CFITSIO also provides many
advanced features for manipulating and filtering the information in
FITS files.
'';
changelog = "https://heasarc.gsfc.nasa.gov/FTP/software/fitsio/c/docs/changes.txt";
license = licenses.mit;
maintainers = with maintainers; [ xbreak hjones2199 ];
platforms = with platforms; linux ++ darwin;
};
}

56
pkgs/development/libraries/science/astronomy/indilib/default.nix Normal file
View file

@ -0,0 +1,56 @@
{ stdenv
, lib
, fetchFromGitHub
, cmake
, cfitsio
, libusb1
, zlib
, boost
, libnova
, curl
, libjpeg
, gsl
, fftw
}:
stdenv.mkDerivation rec {
pname = "indilib";
version = "1.9.5";
src = fetchFromGitHub {
owner = "indilib";
repo = "indi";
rev = "v${version}";
sha256 = "sha256-mj9rnPn85Fbc7Y8qRndqPVANzBrk3al+vDJagLTDJ04=";
};
nativeBuildInputs = [
cmake
];
buildInputs = [
curl
cfitsio
libusb1
zlib
boost
libnova
libjpeg
gsl
fftw
];
cmakeFlags = [
"-DCMAKE_INSTALL_LIBDIR=lib"
"-DUDEVRULES_INSTALL_DIR=lib/udev/rules.d"
];
meta = with lib; {
homepage = "https://www.indilib.org/";
description = "Implementation of the INDI protocol for POSIX operating systems";
changelog = "https://github.com/indilib/indi/releases/tag/v${version}";
license = licenses.lgpl2Plus;
maintainers = with maintainers; [ hjones2199 ];
platforms = platforms.linux;
};
}

79
pkgs/development/libraries/science/astronomy/indilib/indi-3rdparty.nix Normal file
View file

@ -0,0 +1,79 @@
{ stdenv
, lib
, cmake
, cfitsio
, libusb1
, zlib
, boost
, libnova
, curl
, libjpeg
, gsl
, fftw
, indilib
, libgphoto2
, libraw
, libftdi1
, libdc1394
, gpsd
, ffmpeg
, version
, src
, withFirmware ? false
, firmware ? null
}:
stdenv.mkDerivation rec {
pname = "indi-3rdparty";
inherit version src;
nativeBuildInputs = [ cmake ];
buildInputs = [
indilib libnova curl cfitsio libusb1 zlib boost gsl gpsd
libjpeg libgphoto2 libraw libftdi1 libdc1394 ffmpeg fftw
] ++ lib.optionals withFirmware [
firmware
];
postPatch = ''
for f in indi-qsi/CMakeLists.txt \
indi-dsi/CMakeLists.txt \
indi-armadillo-platypus/CMakeLists.txt \
indi-orion-ssg3/CMakeLists.txt
do
substituteInPlace $f \
--replace "/lib/udev/rules.d" "lib/udev/rules.d" \
--replace "/etc/udev/rules.d" "lib/udev/rules.d" \
--replace "/lib/firmware" "lib/firmware"
done
'';
cmakeFlags = [
"-DINDI_DATA_DIR=share/indi"
"-DCMAKE_INSTALL_LIBDIR=lib"
"-DUDEVRULES_INSTALL_DIR=lib/udev/rules.d"
"-DRULES_INSTALL_DIR=lib/udev/rules.d"
# Pentax, Atik, and SX cmakelists are currently broken
"-DWITH_PENTAX=off"
"-DWITH_ATIK=off"
"-DWITH_SX=off"
] ++ lib.optionals (!withFirmware) [
"-DWITH_APOGEE=off"
"-DWITH_DSI=off"
"-DWITH_QHY=off"
"-DWITH_ARMADILLO=off"
"-DWITH_FISHCAMP=off"
"-DWITH_SBIG=off"
];
meta = with lib; {
homepage = "https://www.indilib.org/";
description = "Third party drivers for the INDI astronomical software suite";
changelog = "https://github.com/indilib/indi-3rdparty/releases/tag/v${version}";
license = licenses.lgpl2Plus;
maintainers = with maintainers; [ hjones2199 ];
platforms = platforms.linux;
};
}

66
pkgs/development/libraries/science/astronomy/indilib/indi-firmware.nix Normal file
View file

@ -0,0 +1,66 @@
{ stdenv
, lib
, cmake
, cfitsio
, libusb1
, zlib
, boost
, libnova
, curl
, libjpeg
, gsl
, fftw
, indilib
, libgphoto2
, libraw
, libftdi1
, libdc1394
, gpsd
, ffmpeg
, version
, src
}:
stdenv.mkDerivation rec {
pname = "indi-firmware";
inherit version src;
nativeBuildInputs = [ cmake ];
buildInputs = [
indilib libnova curl cfitsio libusb1 zlib boost gsl gpsd
libjpeg libgphoto2 libraw libftdi1 libdc1394 ffmpeg fftw
];
cmakeFlags = [
"-DINDI_DATA_DIR=\${CMAKE_INSTALL_PREFIX}/share/indi"
"-DCMAKE_INSTALL_LIBDIR=lib"
"-DUDEVRULES_INSTALL_DIR=lib/udev/rules.d"
"-DRULES_INSTALL_DIR=lib/udev/rules.d"
"-DFIRMWARE_INSTALL_DIR=\${CMAKE_INSTALL_PREFIX}/lib/firmware"
"-DCONF_DIR=etc"
"-DBUILD_LIBS=1"
"-DWITH_PENTAX=off"
];
postPatch = ''
for f in libfishcamp/CMakeLists.txt libsbig/CMakeLists.txt
do
substituteInPlace $f --replace "/lib/firmware" "lib/firmware"
done
'';
postFixup = ''
rm $out/lib/udev/rules.d/99-fli.rules
'';
meta = with lib; {
homepage = "https://www.indilib.org/";
description = "Third party firmware for the INDI astronomical software suite";
changelog = "https://github.com/indilib/indi-3rdparty/releases/tag/v${version}";
license = licenses.lgpl2Plus;
maintainers = with maintainers; [ hjones2199 ];
platforms = platforms.linux;
};
}

30
pkgs/development/libraries/science/astronomy/indilib/indi-full.nix Normal file
View file

@ -0,0 +1,30 @@
{ stdenv, lib, callPackage, fetchFromGitHub, indilib }:
let
indi-version = "1.9.3";
indi-3rdparty-src = fetchFromGitHub {
owner = "indilib";
repo = "indi-3rdparty";
rev = "v${indi-version}";
sha256 = "sha256-TBccdheBEO48uIXd6tya6dytkzxaHg2+YancBkcL3bw=";
};
indi-firmware = callPackage ./indi-firmware.nix {
version = indi-version;
src = indi-3rdparty-src;
};
indi-3rdparty = callPackage ./indi-3rdparty.nix {
version = indi-version;
src = indi-3rdparty-src;
withFirmware = stdenv.isx86_64;
firmware = indi-firmware;
};
in
callPackage ./indi-with-drivers.nix {
pname = "indi-full";
version = indi-version;
extraDrivers = [
indi-3rdparty
] ++ lib.optionals stdenv.isx86_64 [
indi-firmware
];
}

10
pkgs/development/libraries/science/astronomy/indilib/indi-with-drivers.nix Normal file
View file

@ -0,0 +1,10 @@
{ buildEnv, indilib ? indilib, pname ? "indi-with-drivers", version ? null, extraDrivers ? null }:
buildEnv {
name = "${pname}-${version}";
paths = [
indilib
]
++ extraDrivers;
inherit (indilib) meta;
}

25
pkgs/development/libraries/science/astronomy/libnova/default.nix Normal file
View file

@ -0,0 +1,25 @@
{ lib, stdenv, fetchgit, autoreconfHook }:
stdenv.mkDerivation rec {
pname = "libnova";
version = "0.16";
# pull from git repo because upstream stopped tarball releases after v0.15
src = fetchgit {
url = "https://git.code.sf.net/p/libnova/${pname}";
rev = "v${version}";
sha256 = "0icwylwkixihzni0kgl0j8dx3qhqvym6zv2hkw2dy6v9zvysrb1b";
};
nativeBuildInputs = [
autoreconfHook
];
meta = with lib; {
description = "Celestial Mechanics, Astrometry and Astrodynamics Library";
homepage = "http://libnova.sf.net";
license = licenses.gpl2;
maintainers = with maintainers; [ hjones2199 ];
platforms = platforms.unix;
};
}

30
pkgs/development/libraries/science/astronomy/stellarsolver/default.nix Normal file
View file

@ -0,0 +1,30 @@
{ lib, mkDerivation, fetchFromGitHub, cmake,
qtbase, cfitsio, gsl, wcslib, withTester ? false }:
mkDerivation rec {
pname = "stellarsolver";
version = "2.2";
src = fetchFromGitHub {
owner = "rlancaste";
repo = pname;
rev = version;
sha256 = "sha256-Ay7bszR4D5KKFiVLXfweJcc8jgUSZljnZVblEx7xh8o=";
};
nativeBuildInputs = [ cmake ];
buildInputs = [ qtbase cfitsio gsl wcslib ];
cmakeFlags = [
"-DBUILD_TESTER=${if withTester then "on" else "off"}"
];
meta = with lib; {
homepage = "https://github.com/rlancaste/stellarsolver";
description = "Astrometric plate solving library";
license = licenses.gpl3Plus;
maintainers = with maintainers; [ hjones2199 ];
platforms = platforms.unix;
};
}

30
pkgs/development/libraries/science/astronomy/wcslib/default.nix Normal file
View file

@ -0,0 +1,30 @@
{ lib, stdenv, fetchurl, flex }:
stdenv.mkDerivation rec {
pname = "wcslib";
version = "7.9";
src = fetchurl {
url = "ftp://ftp.atnf.csiro.au/pub/software/wcslib/${pname}-${version}.tar.bz2";
sha256 = "sha256-vv+MHw6GAAeIE8Ay0a/NnLMFwx9WdWdDSCQjPVgqulg=";
};
nativeBuildInputs = [ flex ];
enableParallelBuilding = true;
outputs = [ "out" "man" ];
meta = with lib; {
homepage = "https://www.atnf.csiro.au/people/mcalabre/WCS/";
description = "World Coordinate System library for astronomy";
longDescription = ''
Library for world coordinate systems for spherical geometries
and their conversion to image coordinate systems. This is the
standard library for this purpose in astronomy.
'';
maintainers = with maintainers; [ hjones2199 ];
license = licenses.lgpl3Plus;
platforms = platforms.unix;
};
}

28
pkgs/development/libraries/science/benchmark/papi/default.nix Normal file
View file

@ -0,0 +1,28 @@
{ lib, stdenv
, fetchurl
}:
stdenv.mkDerivation rec {
version = "6.0.0.1";
pname = "papi";
src = fetchurl {
url = "https://bitbucket.org/icl/papi/get/papi-${lib.replaceStrings ["."] ["-"] version}-t.tar.gz";
sha256 = "1jd67yadyffzxwsqlylsi0bx8ishb0cgj2ziz1wdslaz6ylvyf9j";
};
setSourceRoot = ''
sourceRoot=$(echo */src)
'';
doCheck = true;
checkTarget = "test";
meta = with lib; {
homepage = "https://icl.utk.edu/papi/";
description = "Library providing access to various hardware performance counters";
license = licenses.bsdOriginal;
platforms = platforms.linux;
maintainers = with maintainers; [ costrouc zhaofengli ];
};
}

26
pkgs/development/libraries/science/biology/EBTKS/default.nix Normal file
View file

@ -0,0 +1,26 @@
{ lib, stdenv, fetchFromGitHub, cmake, libminc }:
stdenv.mkDerivation rec {
pname = "EBTKS";
version = "unstable-2017-09-23";
src = fetchFromGitHub {
owner = "BIC-MNI";
repo = pname;
rev = "67e4e197d8a32d6462c9bdc7af44d64ebde4fb5c";
sha256 = "1a1qw6i47fs1izx60l1ysabpmyx9j5sjnbdv8b47wi2xcc9i3hpq";
};
nativeBuildInputs = [ cmake ];
buildInputs = [ libminc ];
cmakeFlags = [ "-DLIBMINC_DIR=${libminc}/lib/cmake" ];
meta = with lib; {
homepage = "https://github.com/BIC-MNI/${pname}";
description = "Library for working with MINC files";
maintainers = with maintainers; [ bcdarwin ];
platforms = platforms.unix;
license = licenses.free;
};
}

33
pkgs/development/libraries/science/biology/bicgl/default.nix Normal file
View file

@ -0,0 +1,33 @@
{ lib, stdenv, fetchFromGitHub, cmake, libminc, bicpl, freeglut, mesa_glu, GLUT }:
stdenv.mkDerivation rec {
pname = "bicgl";
version = "unstable-2018-04-06";
owner = "BIC-MNI";
src = fetchFromGitHub {
inherit owner;
repo = pname;
rev = "61a035751c9244fcca1edf94d6566fa2a709ce90";
sha256 = "0lzirdi1mf4yl8srq7vjn746sbydz7h0wjh7wy8gycy6hq04qrg4";
};
nativeBuildInputs = [ cmake ];
buildInputs = [ libminc bicpl mesa_glu ]
++ lib.optionals stdenv.isDarwin [ GLUT ]
++ lib.optionals stdenv.isLinux [ freeglut ];
cmakeFlags = [
"-DLIBMINC_DIR=${libminc}/lib/cmake"
"-DBICPL_DIR=${bicpl}/lib"
];
meta = with lib; {
homepage = "https://github.com/${owner}/${pname}";
description = "Brain Imaging Centre graphics library";
maintainers = with maintainers; [ bcdarwin ];
platforms = platforms.unix;
license = licenses.free;
};
}

30
pkgs/development/libraries/science/biology/bicpl/default.nix Normal file
View file

@ -0,0 +1,30 @@
{ lib, stdenv, fetchFromGitHub, cmake, libminc, netpbm }:
stdenv.mkDerivation rec {
pname = "bicpl";
version = "unstable-2020-10-15";
# current master is significantly ahead of most recent release, so use Git version:
src = fetchFromGitHub {
owner = "BIC-MNI";
repo = pname;
rev = "a58af912a71a4c62014975b89ef37a8e72de3c9d";
sha256 = "0iw0pmr8xrifbx5l8a0xidfqbm1v8hwzqrw0lcmimxlzdihyri0g";
};
nativeBuildInputs = [ cmake ];
buildInputs = [ libminc netpbm ];
cmakeFlags = [ "-DLIBMINC_DIR=${libminc}/lib/cmake" ];
doCheck = false;
# internal_volume_io.h: No such file or directory
meta = with lib; {
homepage = "https://github.com/BIC-MNI/bicpl";
description = "Brain Imaging Centre programming library";
maintainers = with maintainers; [ bcdarwin ];
platforms = platforms.unix;
license = licenses.free;
};
}

36
pkgs/development/libraries/science/biology/bpp-core/default.nix Normal file
View file

@ -0,0 +1,36 @@
{ lib, stdenv, fetchFromGitHub, cmake }:
stdenv.mkDerivation rec {
pname = "bpp-core";
version = "2.4.1";
src = fetchFromGitHub { owner = "BioPP";
repo = pname;
rev = "v${version}";
sha256 = "0ma2cl677l7s0n5sffh66cy9lxp5wycm50f121g8rx85p95vkgwv";
};
nativeBuildInputs = [ cmake ];
preCheck = ''
export LD_LIBRARY_PATH=$(pwd)/src
'';
postFixup = ''
substituteInPlace $out/lib/cmake/bpp-core/bpp-core-targets.cmake \
--replace 'set(_IMPORT_PREFIX' '#set(_IMPORT_PREFIX'
'';
# prevents cmake from exporting incorrect INTERFACE_INCLUDE_DIRECTORIES
# of form /nix/store/.../nix/store/.../include,
# probably due to relative vs absolute path issue
doCheck = !stdenv.isDarwin;
meta = with lib; {
homepage = "http://biopp.univ-montp2.fr/wiki/index.php/Main_Page";
changelog = "https://github.com/BioPP/bpp-core/blob/master/ChangeLog";
description = "C++ bioinformatics libraries and tools";
maintainers = with maintainers; [ bcdarwin ];
license = licenses.cecill20;
};
}

32
pkgs/development/libraries/science/biology/bpp-phyl/default.nix Normal file
View file

@ -0,0 +1,32 @@
{ stdenv, fetchFromGitHub, cmake, bpp-core, bpp-seq }:
stdenv.mkDerivation rec {
pname = "bpp-phyl";
inherit (bpp-core) version;
src = fetchFromGitHub {
owner = "BioPP";
repo = pname;
rev = "v${version}";
sha256 = "192zks6wyk903n06c2lbsscdhkjnfwms8p7jblsmk3lvjhdipb20";
};
nativeBuildInputs = [ cmake ];
buildInputs = [ bpp-core bpp-seq ];
preCheck = ''
export LD_LIBRARY_PATH=$(pwd)/src
'';
postFixup = ''
substituteInPlace $out/lib/cmake/${pname}/${pname}-targets.cmake \
--replace 'set(_IMPORT_PREFIX' '#set(_IMPORT_PREFIX'
'';
doCheck = !stdenv.isDarwin;
meta = bpp-core.meta // {
changelog = "https://github.com/BioPP/bpp-phyl/blob/master/ChangeLog";
};
}

35
pkgs/development/libraries/science/biology/bpp-popgen/default.nix Normal file
View file

@ -0,0 +1,35 @@
{ stdenv, fetchFromGitHub, cmake, bpp-core, bpp-seq }:
stdenv.mkDerivation rec {
pname = "bpp-popgen";
inherit (bpp-core) version;
src = fetchFromGitHub {
owner = "BioPP";
repo = pname;
rev = "v${version}";
sha256 = "0bz0fhrq3dri6a0hvfc3zlvrns8mrzzlnicw5pyfa812gc1qwfvh";
};
nativeBuildInputs = [ cmake ];
buildInputs = [ bpp-core bpp-seq ];
preCheck = ''
export LD_LIBRARY_PATH=$(pwd)/src
'';
postFixup = ''
substituteInPlace $out/lib/cmake/${pname}/${pname}-targets.cmake \
--replace 'set(_IMPORT_PREFIX' '#set(_IMPORT_PREFIX'
'';
# prevents cmake from exporting incorrect INTERFACE_INCLUDE_DIRECTORIES
# of form /nix/store/.../nix/store/.../include,
# probably due to relative vs absolute path issue
doCheck = !stdenv.isDarwin;
meta = bpp-core.meta // {
changelog = "https://github.com/BioPP/bpp-popgen/blob/master/ChangeLog";
};
}

35
pkgs/development/libraries/science/biology/bpp-seq/default.nix Normal file
View file

@ -0,0 +1,35 @@
{ stdenv, fetchFromGitHub, cmake, bpp-core }:
stdenv.mkDerivation rec {
pname = "bpp-seq";
inherit (bpp-core) version;
src = fetchFromGitHub {
owner = "BioPP";
repo = pname;
rev = "v${version}";
sha256 = "1mc09g8jswzsa4wgrfv59jxn15ys3q8s0227p1j838wkphlwn2qk";
};
nativeBuildInputs = [ cmake ];
buildInputs = [ bpp-core ];
preCheck = ''
export LD_LIBRARY_PATH=$(pwd)/src
'';
postFixup = ''
substituteInPlace $out/lib/cmake/${pname}/${pname}-targets.cmake \
--replace 'set(_IMPORT_PREFIX' '#set(_IMPORT_PREFIX'
'';
# prevents cmake from exporting incorrect INTERFACE_INCLUDE_DIRECTORIES
# of form /nix/store/.../nix/store/.../include,
# probably due to relative vs absolute path issue
doCheck = !stdenv.isDarwin;
meta = bpp-core.meta // {
changelog = "https://github.com/BioPP/bpp-seq/blob/master/ChangeLog";
};
}

38
pkgs/development/libraries/science/biology/elastix/default.nix Normal file
View file

@ -0,0 +1,38 @@
{ lib, stdenv, fetchFromGitHub, fetchpatch, cmake, itk, python3, Cocoa }:
stdenv.mkDerivation rec {
pname = "elastix";
version = "5.0.1";
src = fetchFromGitHub {
owner = "SuperElastix";
repo = pname;
rev = version;
sha256 = "1mx8kkak2d3ibfrxrh8jkmh2zkdlgl9h578wiw3617zcwaa97bxw";
};
patches = [
(fetchpatch {
name = "install-executables.patch"; # https://github.com/SuperElastix/elastix/issues/305
url = "https://github.com/SuperElastix/elastix/commit/8e26cdc0d66f6030c7be085fdc424d84d4fc7546.patch";
sha256 = "12y9wbpi9jlarnw6fk4iby97jxvx5g4daq9zqblbcmn51r134bj5";
})
];
nativeBuildInputs = [ cmake python3 ];
buildInputs = [ itk ] ++ lib.optionals stdenv.isDarwin [ Cocoa ];
doCheck = !stdenv.isDarwin; # usual dynamic linker issues
preCheck = "
export LD_LIBRARY_PATH=$(pwd)/bin
";
meta = with lib; {
homepage = "https://elastix.lumc.nl";
description = "Image registration toolkit based on ITK";
maintainers = with maintainers; [ bcdarwin ];
platforms = platforms.x86_64; # libitkpng linker issues with ITK 5.1
license = licenses.asl20;
};
}

34
pkgs/development/libraries/science/biology/gifticlib/default.nix Normal file
View file

@ -0,0 +1,34 @@
{ lib, stdenv, fetchFromGitHub, cmake, expat, nifticlib, zlib }:
stdenv.mkDerivation rec {
pname = "gifticlib";
version = "unstable-2020-07-07";
src = fetchFromGitHub {
owner = "NIFTI-Imaging";
repo = "gifti_clib";
rev = "5eae81ba1e87ef3553df3b6ba585f12dc81a0030";
sha256 = "0gcab06gm0irjnlrkpszzd4wr8z0fi7gx8f7966gywdp2jlxzw19";
};
cmakeFlags = [ "-DUSE_SYSTEM_NIFTI=ON" "-DDOWNLOAD_TEST_DATA=OFF" ];
nativeBuildInputs = [ cmake ];
buildInputs = [ expat nifticlib zlib ];
# without the test data, this is only a few basic tests
doCheck = !stdenv.isDarwin;
checkPhase = ''
runHook preCheck
ctest -LE 'NEEDS_DATA'
runHook postCheck
'';
meta = with lib; {
homepage = "https://www.nitrc.org/projects/gifti";
description = "Medical imaging geometry format C API";
maintainers = with maintainers; [ bcdarwin ];
platforms = platforms.unix;
license = licenses.publicDomain;
};
}

52
pkgs/development/libraries/science/biology/htslib/default.nix Normal file
View file

@ -0,0 +1,52 @@
{ lib, stdenv, fetchurl, zlib, bzip2, xz, curl, perl }:
stdenv.mkDerivation rec {
pname = "htslib";
version = "1.15";
src = fetchurl {
url = "https://github.com/samtools/htslib/releases/download/${version}/${pname}-${version}.tar.bz2";
sha256 = "sha256-Gp9JkRUDoi9WgXzILqm4f7fnRntf+YnKWqYcEufVMtk=";
};
# perl is only used during the check phase.
nativeBuildInputs = [ perl ];
buildInputs = [ zlib bzip2 xz curl ];
configureFlags = if ! stdenv.hostPlatform.isStatic
then [ "--enable-libcurl" ] # optional but strongly recommended
else [ "--disable-libcurl" "--disable-plugins" ];
# In the case of static builds, we need to replace the build and install phases
buildPhase = lib.optional stdenv.hostPlatform.isStatic ''
make AR=$AR lib-static
make LDFLAGS=-static bgzip htsfile tabix
'';
installPhase = lib.optional stdenv.hostPlatform.isStatic ''
install -d $out/bin
install -d $out/lib
install -d $out/include/htslib
install -D libhts.a $out/lib
install -m644 htslib/*h $out/include/htslib
install -D bgzip htsfile tabix $out/bin
'';
preCheck = ''
patchShebangs test/
'';
enableParallelBuilding = true;
doCheck = true;
meta = with lib; {
description = "A C library for reading/writing high-throughput sequencing data";
license = licenses.mit;
homepage = "http://www.htslib.org/";
platforms = platforms.unix;
maintainers = [ maintainers.mimame ];
};
}

44
pkgs/development/libraries/science/biology/mirtk/default.nix Normal file
View file

@ -0,0 +1,44 @@
{ lib, stdenv, gtest, fetchFromGitHub, cmake, boost, eigen, python3, vtk, zlib, tbb }:
stdenv.mkDerivation rec {
version = "2.0.0";
pname = "mirtk";
src = fetchFromGitHub {
owner = "BioMedIA";
repo = "MIRTK";
rev = "v${version}";
sha256 = "0i2v97m66ir5myvi5b123r7zcagwy551b73s984gk7lksl5yiqxk";
fetchSubmodules = true;
};
cmakeFlags = [
"-DWITH_VTK=ON"
"-DBUILD_ALL_MODULES=ON"
"-DWITH_TBB=ON"
];
doCheck = true;
checkPhase = ''
ctest -E '(Polynomial|ConvolutionFunction|Downsampling|EdgeTable|InterpolateExtrapolateImage)'
'';
# testPolynomial - segfaults for some reason
# testConvolutionFunction, testDownsampling - main not called correctly
# testEdgeTable, testInterpolateExtrapolateImageFunction - setup fails
postInstall = ''
install -Dm644 -t "$out/share/bash-completion/completions/mirtk" share/completion/bash/mirtk
'';
nativeBuildInputs = [ cmake gtest ];
buildInputs = [ boost eigen python3 vtk zlib tbb ];
meta = with lib; {
homepage = "https://github.com/BioMedIA/MIRTK";
description = "Medical image registration library and tools";
maintainers = with maintainers; [ bcdarwin ];
platforms = platforms.linux;
license = licenses.asl20;
};
}

33
pkgs/development/libraries/science/biology/nifticlib/default.nix Normal file
View file

@ -0,0 +1,33 @@
{ lib, stdenv, fetchFromGitHub, cmake, zlib }:
stdenv.mkDerivation rec {
pname = "nifticlib";
version = "3.0.1";
src = fetchFromGitHub {
owner = "NIFTI-Imaging";
repo = "nifti_clib";
rev = "v${version}";
sha256 = "0hamm6nvbjdjjd5md4jahzvn5559frigxaiybnjkh59ckxwb1hy4";
};
cmakeFlags = [ "-DDOWNLOAD_TEST_DATA=OFF" ];
nativeBuildInputs = [ cmake ];
buildInputs = [ zlib ];
checkPhase = ''
runHook preCheck
ctest -LE 'NEEDS_DATA'
runHook postCheck
'';
doCheck = true;
meta = with lib; {
homepage = "https://nifti-imaging.github.io";
description = "Medical imaging format C API";
maintainers = with maintainers; [ bcdarwin ];
platforms = platforms.unix;
license = licenses.publicDomain;
};
}

39
pkgs/development/libraries/science/biology/oobicpl/default.nix Normal file
View file

@ -0,0 +1,39 @@
{ lib
, stdenv
, fetchFromGitHub
, cmake
, libminc
, bicpl
, arguments
, pcre-cpp }:
stdenv.mkDerivation rec {
pname = "oobicpl";
version = "unstable-2020-08-12";
src = fetchFromGitHub {
owner = "BIC-MNI";
repo = pname;
rev = "a9409da8a5bb4925438f32aff577b6333faec28b";
sha256 = "0b4chjhr32wbb1sash8cq1jfnr7rzdq84hif8anlrjqd3l0gw357";
};
nativeBuildInputs = [ cmake ];
buildInputs = [ libminc bicpl arguments pcre-cpp ];
cmakeFlags = [
"-DLIBMINC_DIR=${libminc}/lib/cmake"
"-DBICPL_DIR=${bicpl}/lib"
"-DARGUMENTS_DIR=${arguments}/lib"
"-DOOBICPL_BUILD_SHARED_LIBS=TRUE"
];
meta = with lib; {
homepage = "https://github.com/BIC-MNI/oobicpl";
description = "Brain Imaging Centre object-oriented programming library (and tools)";
maintainers = with maintainers; [ bcdarwin ];
platforms = platforms.unix;
license = licenses.free;
};
}

68
pkgs/development/libraries/science/chemistry/avogadrolibs/default.nix Normal file
View file

@ -0,0 +1,68 @@
{ lib, stdenv, fetchFromGitHub, cmake, zlib, eigen, libGL, doxygen, spglib
, mmtf-cpp, glew, python3, libarchive, libmsym, msgpack, qttools, wrapQtAppsHook
}:
let
pythonWP = python3.withPackages (p: with p; [ openbabel-bindings numpy ]);
# Pure data repositories
moleculesRepo = fetchFromGitHub {
owner = "OpenChemistry";
repo = "molecules";
rev = "1.0.0";
sha256 = "guY6osnpv7Oqt+HE1BpIqL10POp+x8GAci2kY0bLmqg=";
};
crystalsRepo = fetchFromGitHub {
owner = "OpenChemistry";
repo = "crystals";
rev = "1.0.1";
sha256 = "sH/WuvLaYu6akOc3ssAKhnxD8KNoDxuafDSozHqJZC4=";
};
in stdenv.mkDerivation rec {
pname = "avogadrolibs";
version = "1.95.1";
src = fetchFromGitHub {
owner = "OpenChemistry";
repo = pname;
rev = version;
sha256 = "0zzVg8xNqFwDrK8gRkDm3tRgBt7fD4K3Uy/ajUBc+eQ=";
};
postUnpack = ''
cp -r ${moleculesRepo} molecules
cp -r ${crystalsRepo} crystals
'';
nativeBuildInputs = [
cmake
wrapQtAppsHook
];
buildInputs = [
eigen
zlib
libGL
spglib
mmtf-cpp
glew
libarchive
libmsym
msgpack
qttools
];
postFixup = ''
substituteInPlace $out/lib/cmake/${pname}/AvogadroLibsConfig.cmake \
--replace "''${AvogadroLibs_INSTALL_PREFIX}/$out" "''${AvogadroLibs_INSTALL_PREFIX}"
'';
meta = with lib; {
description = "Molecule editor and visualizer";
maintainers = with maintainers; [ sheepforce ];
homepage = "https://github.com/OpenChemistry/avogadrolibs";
platforms = platforms.linux;
license = licenses.gpl2Only;
};
}

26
pkgs/development/libraries/science/chemistry/cppe/default.nix Normal file
View file

@ -0,0 +1,26 @@
{ stdenv, lib, fetchFromGitHub, cmake, llvmPackages }:
stdenv.mkDerivation rec {
pname = "cppe";
version = "0.3.1";
src = fetchFromGitHub {
owner = "maxscheurer";
repo = pname;
rev = "v${version}";
sha256 = "sha256-guM7+ZWDJLcAUJtPkKLvC4LYSA2eBvER7cgwPZ7FxHw=";
};
nativeBuildInputs = [ cmake ]
++ lib.optionals stdenv.cc.isClang [ llvmPackages.openmp ];
cmakeFlags = [ "-DCMAKE_INSTALL_LIBDIR=lib" ];
meta = with lib; {
description = "C++ and Python library for Polarizable Embedding";
homepage = "https://github.com/maxscheurer/cppe";
license = licenses.lgpl3Only;
platforms = platforms.unix;
maintainers = [ maintainers.sheepforce ];
};
}

23
pkgs/development/libraries/science/chemistry/libmsym/default.nix Normal file
View file

@ -0,0 +1,23 @@
{ stdenv, lib, fetchFromGitHub, cmake } :
stdenv.mkDerivation rec {
pname = "libmsym";
version = "0.2.3";
src = fetchFromGitHub {
owner = "mcodev31";
repo = pname;
rev = "v${version}";
sha256= "k+OEwrA/saupP/wX6Ii5My0vffiJ0X9xMCTrliMSMik=";
};
nativeBuildInputs = [ cmake ];
meta = with lib; {
description = " molecular point group symmetry lib";
homepage = "https://github.com/mcodev31/libmsym";
license = licenses.mit;
platforms = platforms.linux;
maintainers = [ maintainers.sheepforce ];
};
}

25
pkgs/development/libraries/science/chemistry/mmtf-cpp/default.nix Normal file
View file

@ -0,0 +1,25 @@
{ stdenv, lib, fetchFromGitHub, cmake, msgpack } :
stdenv.mkDerivation rec {
pname = "mmtf-cpp";
version = "1.0.0";
src = fetchFromGitHub {
owner = "rcsb";
repo = pname;
rev = "v${version}";
sha256= "17ylramda69plf5w0v5hxbl4ggkdi5s15z55cv0pljl12yvyva8l";
};
nativeBuildInputs = [ cmake ];
buildInputs = [ msgpack ];
meta = with lib; {
description = "A library of exchange-correlation functionals with arbitrary-order derivatives";
homepage = "https://github.com/rcsb/mmtf-cpp";
license = licenses.mit;
platforms = platforms.linux;
maintainers = [ maintainers.sheepforce ];
};
}

33
pkgs/development/libraries/science/chemistry/molequeue/default.nix Normal file
View file

@ -0,0 +1,33 @@
{ lib, stdenv, fetchFromGitHub, cmake, qttools, wrapQtAppsHook }:
stdenv.mkDerivation rec {
pname = "molequeue";
version = "0.9.0";
src = fetchFromGitHub {
owner = "OpenChemistry";
repo = pname;
rev = version;
sha256 = "+NoY8YVseFyBbxc3ttFWiQuHQyy1GN8zvV1jGFjmvLg=";
};
nativeBuildInputs = [
cmake
wrapQtAppsHook
];
buildInputs = [ qttools ];
postFixup = ''
substituteInPlace $out/lib/cmake/molequeue/MoleQueueConfig.cmake \
--replace "''${MoleQueue_INSTALL_PREFIX}/$out" "''${MoleQueue_INSTALL_PREFIX}"
'';
meta = with lib; {
description = "Desktop integration of high performance computing resources";
maintainers = with maintainers; [ sheepforce ];
homepage = "https://github.com/OpenChemistry/molequeue";
platforms = platforms.linux;
license = licenses.bsd3;
};
}

30
pkgs/development/libraries/science/chemistry/xcfun/default.nix Normal file
View file

@ -0,0 +1,30 @@
{ stdenv, lib, fetchFromGitHub, cmake, gfortran, python3 } :
stdenv.mkDerivation rec {
pname = "xcfun";
version = "2.1.1";
src = fetchFromGitHub {
owner = "dftlibs";
repo = pname;
rev = "v${version}";
sha256 = "1bj70cnhbh6ziy02x988wwl7cbwaq17ld7qwhswqkgnnx8rpgxid";
};
nativeBuildInputs = [
cmake
gfortran
];
propagatedBuildInputs = [ (python3.withPackages (p: with p; [ pybind11 ])) ];
cmakeFlags = [ "-DXCFUN_MAX_ORDER=3" ];
meta = with lib; {
description = "A library of exchange-correlation functionals with arbitrary-order derivatives";
homepage = "https://github.com/dftlibs/xcfun";
license = licenses.mpl20;
platforms = platforms.linux;
maintainers = [ maintainers.sheepforce ];
};
}

47
pkgs/development/libraries/science/electronics/qcsxcad/default.nix Normal file
View file

@ -0,0 +1,47 @@
{ lib
, mkDerivation
, fetchFromGitHub
, cmake
, csxcad
, tinyxml
, vtkWithQt5
, qtbase
}:
mkDerivation {
pname = "qcsxcad";
version = "unstable-2020-01-04";
src = fetchFromGitHub {
owner = "thliebig";
repo = "QCSXCAD";
rev = "0dabbaf2bc1190adec300871cf309791af842c8e";
sha256 = "11kbh0mxbdfh7s5azqin3i2alic5ihmdfj0jwgnrhlpjk4cbf9rn";
};
outputs = [ "out" "dev" ];
nativeBuildInputs = [
cmake
];
cmakeFlags = [
"-DCSXCAD_ROOT_DIR=${csxcad}"
"-DENABLE_RPATH=OFF"
];
buildInputs = [
csxcad
tinyxml
vtkWithQt5
qtbase
];
meta = with lib; {
description = "Qt library for CSXCAD";
homepage = "https://github.com/thliebig/QCSXCAD";
license = licenses.gpl3;
maintainers = with maintainers; [ matthuszagh ];
platforms = platforms.linux;
};
}

26
pkgs/development/libraries/science/math/QuadProgpp/default.nix Normal file
View file

@ -0,0 +1,26 @@
{ lib, stdenv, fetchFromGitHub, cmake }:
stdenv.mkDerivation rec {
pname = "QuadProgpp";
version = "4b6bd65f09fbff99c172a86d6e96ca74449b323f";
src = fetchFromGitHub {
owner = "liuq";
repo = "QuadProgpp";
rev = version;
sha256 = "02r0dlk2yjpafknvm945vbgs4sl26w2i1gw3pllar9hi364y8hnx";
};
nativeBuildInputs = [ cmake ];
meta = with lib; {
homepage = "https://github.com/liuq/QuadProgpp";
license = licenses.mit;
description = ''
A C++ library for Quadratic Programming which implements the
Goldfarb-Idnani active-set dual method.
'';
maintainers = with maintainers; [ ];
platforms = platforms.all;
};
}

70
pkgs/development/libraries/science/math/amd-blis/default.nix Normal file
View file

@ -0,0 +1,70 @@
{ lib, stdenv
, fetchFromGitHub
, perl
, python3
# Enable BLAS interface with 64-bit integer width.
, blas64 ? false
# Target architecture. "amd64" compiles kernels for all Zen
# generations. To build kernels for specific Zen generations,
# use "zen", "zen2", or "zen3".
, withArchitecture ? "amd64"
# Enable OpenMP-based threading.
, withOpenMP ? true
}:
let
threadingSuffix = if withOpenMP then "-mt" else "";
blasIntSize = if blas64 then "64" else "32";
in stdenv.mkDerivation rec {
pname = "amd-blis";
version = "3.0";
src = fetchFromGitHub {
owner = "amd";
repo = "blis";
rev = version;
hash = "sha256-bbbeo1yOKse9pzbsB6lQ7pULKdzu3G7zJzTUgPXiMZY=";
};
inherit blas64;
nativeBuildInputs = [
perl
python3
];
# Tests currently fail with non-Zen CPUs due to a floating point
# exception in one of the generic kernels. Try to re-enable the
# next release.
doCheck = false;
enableParallelBuilding = true;
configureFlags = [
"--enable-cblas"
"--blas-int-size=${blasIntSize}"
] ++ lib.optionals withOpenMP [ "--enable-threading=openmp" ]
++ [ withArchitecture ];
postPatch = ''
patchShebangs configure build/flatten-headers.py
'';
postInstall = ''
ln -s $out/lib/libblis${threadingSuffix}.so.3 $out/lib/libblas.so.3
ln -s $out/lib/libblis${threadingSuffix}.so.3 $out/lib/libcblas.so.3
ln -s $out/lib/libblas.so.3 $out/lib/libblas.so
ln -s $out/lib/libcblas.so.3 $out/lib/libcblas.so
'';
meta = with lib; {
description = "BLAS-compatible library optimized for AMD CPUs";
homepage = "https://developer.amd.com/amd-aocl/blas-library/";
license = licenses.bsd3;
maintainers = [ maintainers.markuskowa ];
platforms = [ "x86_64-linux" ];
};
}

34
pkgs/development/libraries/science/math/amd-libflame/add-lapacke.diff Normal file
View file

@ -0,0 +1,34 @@
diff --git a/Makefile b/Makefile
index 5549ce30..ac2ee51e 100644
--- a/Makefile
+++ b/Makefile
@@ -583,14 +583,14 @@ endif
# --- Shared library linker rules ---
-$(LIBFLAME_SO_PATH): $(MK_ALL_FLAMEC_OBJS)
+$(LIBFLAME_SO_PATH): $(MK_ALL_FLAMEC_OBJS) $(LAPACKE_A_PATH)
ifeq ($(ENABLE_VERBOSE),yes)
ifeq ($(FLA_ENABLE_MAX_ARG_LIST_HACK),yes)
$(CAT) $(AR_OBJ_LIST_FILE) | xargs -n$(AR_CHUNK_SIZE) $(AR) $(ARFLAGS) $(LIBFLAME_A)
ifeq ($(OS_NAME),Darwin)
- $(LINKER) $(SOFLAGS) -o $@ -Wl,-force_load,$(LIBFLAME_A) $(LDFLAGS)
+ $(LINKER) $(SOFLAGS) -o $@ -Wl,-force_load,$(LIBFLAME_A),$(LAPACKE_A_PATH) $(LDFLAGS)
else
- $(LINKER) $(SOFLAGS) -o $@ -Wl,--whole-archive,$(LIBFLAME_A),--no-whole-archive $(LDFLAGS)
+ $(LINKER) $(SOFLAGS) -o $@ -Wl,--whole-archive,$(LIBFLAME_A),$(LAPACKE_A_PATH)--no-whole-archive $(LDFLAGS)
endif
else
# NOTE: Can't use $^ automatic variable as long as $(AR_OBJ_LIST_FILE) is in
@@ -602,9 +602,9 @@ else
ifeq ($(FLA_ENABLE_MAX_ARG_LIST_HACK),yes)
@$(CAT) $(AR_OBJ_LIST_FILE) | xargs -n$(AR_CHUNK_SIZE) $(AR) $(ARFLAGS) $(LIBFLAME_A)
ifeq ($(OS_NAME),Darwin)
- @$(LINKER) $(SOFLAGS) -o $@ -Wl,-force_load,$(LIBFLAME_A) $(LDFLAGS)
+ @$(LINKER) $(SOFLAGS) -o $@ -Wl,-force_load,$(LIBFLAME_A),$(LAPACKE_A_PATH) $(LDFLAGS)
else
- @$(LINKER) $(SOFLAGS) -o $@ -Wl,--whole-archive,$(LIBFLAME_A),--no-whole-archive $(LDFLAGS)
+ @$(LINKER) $(SOFLAGS) -o $@ -Wl,--whole-archive,$(LIBFLAME_A),$(LAPACKE_A_PATH),--no-whole-archive $(LDFLAGS)
endif
else
# NOTE: Can't use $^ automatic variable as long as $(AR_OBJ_LIST_FILE) is in

78
pkgs/development/libraries/science/math/amd-libflame/default.nix Normal file
View file

@ -0,0 +1,78 @@
{ lib
, stdenv
, fetchFromGitHub
, gfortran
, python3
, amd-blis
, withOpenMP ? true
, blas64 ? false
}:
# right now only LP64 is supported
assert !blas64;
stdenv.mkDerivation rec {
pname = "amd-libflame";
version = "3.0";
src = fetchFromGitHub {
owner = "amd";
repo = "libflame";
rev = version;
hash = "sha256-jESae5NqANw90RBbIHH2oGEq5/mudc4IONv50P/AeQ0=";
};
patches = [
# The LAPACKE interface is compiled as a separate static library,
# we want the main dynamic library to provide LAPACKE symbols.
# This patch adds lapacke.a to the shared library as well.
./add-lapacke.diff
];
passthru = { inherit blas64; };
nativeBuildInputs = [ gfortran python3 ];
buildInputs = [ amd-blis ];
configureFlags = [
# Build a dynamic library with a LAPACK interface.
"--disable-static-build"
"--enable-dynamic-build"
"--enable-lapack2flame"
# Use C BLAS interface.
"--enable-cblas-interfaces"
# Avoid overloading maximum number of arguments.
"--enable-max-arg-list-hack"
# libflame by default leaves BLAS symbols unresolved and leaves it
# up to the application to explicitly link to a BLAS. This is
# problematic for us, since then the BLAS library becomes an
# implicit dependency. Moreover, since the point of the AMD forks
# is to optimized for recent AMD CPUs, link against AMD BLIS.
"LDFLAGS=-lcblas"
]
++ lib.optionals withOpenMP [ "--enable-multithreading=openmp" ];
enableParallelBuilding = true;
postPatch = ''
patchShebangs build
'';
postInstall = ''
ln -s $out/lib/libflame.so.${version} $out/lib/liblapack.so.3
ln -s $out/lib/libflame.so.${version} $out/lib/liblapacke.so.3
'';
meta = with lib; {
description = "LAPACK-compatible linear algebra library optimized for AMD CPUs";
homepage = "https://developer.amd.com/amd-aocl/blas-library/";
license = licenses.bsd3;
maintainers = with maintainers; [ ];
platforms = [ "x86_64-linux" ];
};
}

62
pkgs/development/libraries/science/math/arpack/default.nix Normal file
View file

@ -0,0 +1,62 @@
{ lib, stdenv, fetchFromGitHub, fetchpatch, cmake
, gfortran, blas, lapack, eigen }:
stdenv.mkDerivation rec {
pname = "arpack";
version = "3.8.0";
src = fetchFromGitHub {
owner = "opencollab";
repo = "arpack-ng";
rev = version;
sha256 = "sha256-nc710iLRqy/p3EaVgbEoCRzNJ9GpKqqQp33tbn7R6lA=";
};
patches = [
# https://github.com/opencollab/arpack-ng/pull/301
(fetchpatch {
name = "pkg-config-paths.patch";
url = "https://github.com/opencollab/arpack-ng/commit/47fc83cb371a9cc8a8c058097de5e0298cd548f5.patch";
excludes = [ "CHANGES" ];
sha256 = "1aijvrfsxkgzqmkzq2dmaj8q3jdpg2hwlqpfl8ddk9scv17gh9m8";
})
];
nativeBuildInputs = [ cmake gfortran ];
buildInputs = assert (blas.isILP64 == lapack.isILP64); [
blas
lapack
eigen
];
doCheck = true;
cmakeFlags = [
"-DBUILD_SHARED_LIBS=ON"
"-DINTERFACE64=${if blas.isILP64 then "1" else "0"}"
];
preCheck = if stdenv.isDarwin then ''
export DYLD_LIBRARY_PATH=$DYLD_LIBRARY_PATH''${DYLD_LIBRARY_PATH:+:}`pwd`/lib:${blas}/lib:${lapack}/lib
'' else ''
export LD_LIBRARY_PATH=$LD_LIBRARY_PATH''${LD_LIBRARY_PATH:+:}`pwd`/lib
'' + ''
# Prevent tests from using all cores
export OMP_NUM_THREADS=2
'';
postFixup = lib.optionalString stdenv.isDarwin ''
install_name_tool -change libblas.dylib ${blas}/lib/libblas.dylib $out/lib/libarpack.dylib
'';
meta = {
homepage = "https://github.com/opencollab/arpack-ng";
description = ''
A collection of Fortran77 subroutines to solve large scale eigenvalue
problems.
'';
license = lib.licenses.bsd3;
maintainers = with lib.maintainers; [ ttuegel dotlambda ];
platforms = lib.platforms.unix;
};
}

44
pkgs/development/libraries/science/math/blas/default.nix Normal file
View file

@ -0,0 +1,44 @@
{ lib, stdenv, fetchurl, cmake, gfortran
# Wether to build with ILP64 interface
, blas64 ? false
}:
stdenv.mkDerivation rec {
pname = "blas";
version = "3.10.0";
src = fetchurl {
url = "http://www.netlib.org/blas/${pname}-${version}.tgz";
sha256 = "sha256-LjYNmcm9yEB6YYiMQKqFP7QhlCDruCZNtIbLiGBGirM=";
};
passthru = { inherit blas64; };
nativeBuildInputs = [ cmake gfortran ];
cmakeFlags = [ "-DBUILD_SHARED_LIBS=ON" ]
++ lib.optional blas64 "-DBUILD_INDEX64=ON";
postInstall = let
canonicalExtension = if stdenv.hostPlatform.isLinux
then "${stdenv.hostPlatform.extensions.sharedLibrary}.${lib.versions.major version}"
else stdenv.hostPlatform.extensions.sharedLibrary;
in lib.optionalString blas64 ''
ln -s $out/lib/libblas64${canonicalExtension} $out/lib/libblas${canonicalExtension}
'';
preFixup = lib.optionalString stdenv.isDarwin ''
for fn in $(find $out/lib -name "*.so*"); do
if [ -L "$fn" ]; then continue; fi
install_name_tool -id "$fn" "$fn"
done
'';
meta = with lib; {
description = "Basic Linear Algebra Subprograms";
license = licenses.publicDomain;
maintainers = [ maintainers.markuskowa ];
homepage = "http://www.netlib.org/blas/";
platforms = platforms.unix;
};
}

64
pkgs/development/libraries/science/math/blis/default.nix Normal file
View file

@ -0,0 +1,64 @@
{ lib, stdenv
, fetchFromGitHub
, perl
, python3
# Enable BLAS interface with 64-bit integer width.
, blas64 ? false
# Target architecture. x86_64 builds Intel and AMD kernels.
, withArchitecture ? "x86_64"
# Enable OpenMP-based threading.
, withOpenMP ? true
}:
let
blasIntSize = if blas64 then "64" else "32";
in stdenv.mkDerivation rec {
pname = "blis";
version = "0.9.0";
src = fetchFromGitHub {
owner = "flame";
repo = "blis";
rev = version;
sha256 = "sha256-1aHIdt5wCDrT1hBPnaUVThwjwDkJQ0G0+tao2iFXYpM=";
};
inherit blas64;
nativeBuildInputs = [
perl
python3
];
doCheck = true;
enableParallelBuilding = true;
configureFlags = [
"--enable-cblas"
"--blas-int-size=${blasIntSize}"
] ++ lib.optionals withOpenMP [ "--enable-threading=openmp" ]
++ [ withArchitecture ];
postPatch = ''
patchShebangs configure build/flatten-headers.py
'';
postInstall = ''
ln -s $out/lib/libblis.so.3 $out/lib/libblas.so.3
ln -s $out/lib/libblis.so.3 $out/lib/libcblas.so.3
ln -s $out/lib/libblas.so.3 $out/lib/libblas.so
ln -s $out/lib/libcblas.so.3 $out/lib/libcblas.so
'';
meta = with lib; {
description = "BLAS-compatible linear algebra library";
homepage = "https://github.com/flame/blis";
license = licenses.bsd3;
maintainers = [ ];
platforms = [ "x86_64-linux" ];
};
}

51
pkgs/development/libraries/science/math/bonmin/default.nix Normal file
View file

@ -0,0 +1,51 @@
{ lib
, stdenv
, fetchFromGitHub
, gfortran
, pkg-config
, blas
, bzip2
, cbc
, clp
, ipopt
, lapack
, libamplsolver
, zlib
}:
assert (!blas.isILP64) && (!lapack.isILP64);
stdenv.mkDerivation rec {
pname = "bonmin";
version = "1.8.8";
src = fetchFromGitHub {
owner = "coin-or";
repo = "Bonmin";
rev = "releases/${version}";
sha256 = "sha256-HU25WjvG01oL3U1wG6ivTcYaN51MMxgLdKZ3AkDNe2Y=";
};
nativeBuildInputs = [
gfortran
pkg-config
];
buildInputs = [
blas
bzip2
cbc
clp
ipopt
lapack
libamplsolver
zlib
];
meta = with lib; {
description = "An open-source code for solving general MINLP (Mixed Integer NonLinear Programming) problems";
homepage = "https://github.com/coin-or/Bonmin";
license = licenses.epl10;
platforms = platforms.unix;
maintainers = with maintainers; [ aanderse ];
};
}

46
pkgs/development/libraries/science/math/brial/default.nix Normal file
View file

@ -0,0 +1,46 @@
{ lib, stdenv
, fetchFromGitHub
, autoreconfHook
, pkg-config
, boost
, m4ri
, gd
}:
stdenv.mkDerivation rec {
version = "1.2.10";
pname = "brial";
src = fetchFromGitHub {
owner = "BRiAl";
repo = "BRiAl";
rev = version;
sha256 = "1qg6ssp87rb8p37kahxmm88fbxqg6r540cky5v7wq7l19n2b1bss";
};
# FIXME package boost-test and enable checks
doCheck = false;
configureFlags = [
"--with-boost-unit-test-framework=no"
];
buildInputs = [
boost
m4ri
gd
];
nativeBuildInputs = [
autoreconfHook
pkg-config
];
meta = with lib; {
homepage = "https://github.com/BRiAl/BRiAl";
description = "Legacy version of PolyBoRi maintained by sagemath developers";
license = licenses.gpl2Plus;
maintainers = teams.sage.members;
platforms = platforms.unix;
};
}

35
pkgs/development/libraries/science/math/cholmod-extra/default.nix Normal file
View file

@ -0,0 +1,35 @@
{ lib, stdenv, fetchFromGitHub, gfortran, suitesparse, blas, lapack }:
stdenv.mkDerivation rec {
pname = "cholmod-extra";
version = "1.2.0";
src = fetchFromGitHub {
repo = pname;
owner = "jluttine";
rev = version;
sha256 = "0hz1lfp0zaarvl0dv0zgp337hyd8np41kmdpz5rr3fc6yzw7vmkg";
};
nativeBuildInputs = [ gfortran ];
buildInputs = [ suitesparse blas lapack ];
makeFlags = [
"BLAS=-lcblas"
];
installFlags = [
"INSTALL_LIB=$(out)/lib"
"INSTALL_INCLUDE=$(out)/include"
];
doCheck = true;
meta = with lib; {
homepage = "https://github.com/jluttine/cholmod-extra";
description = "A set of additional routines for SuiteSparse CHOLMOD Module";
license = with licenses; [ gpl2Plus ];
maintainers = with maintainers; [ jluttine ];
platforms = with platforms; unix;
};
}

68
pkgs/development/libraries/science/math/clblas/default.nix Normal file
View file

@ -0,0 +1,68 @@
{ lib, stdenv
, fetchFromGitHub
, cmake
, gfortran
, blas
, boost
, python3
, ocl-icd
, opencl-headers
, Accelerate, CoreGraphics, CoreVideo, OpenCL
}:
stdenv.mkDerivation rec {
pname = "clblas";
version = "2.12";
src = fetchFromGitHub {
owner = "clMathLibraries";
repo = "clBLAS";
rev = "v${version}";
sha256 = "154mz52r5hm0jrp5fqrirzzbki14c1jkacj75flplnykbl36ibjs";
};
patches = [ ./platform.patch ];
postPatch = ''
sed -i -re 's/(set\(\s*Boost_USE_STATIC_LIBS\s+).*/\1OFF\ \)/g' src/CMakeLists.txt
'';
preConfigure = ''
cd src
'';
cmakeFlags = [
"-DBUILD_TEST=OFF"
];
nativeBuildInputs = [ cmake gfortran ];
buildInputs = [
blas
python3
boost
] ++ lib.optionals (!stdenv.isDarwin) [
ocl-icd
opencl-headers
] ++ lib.optionals stdenv.isDarwin [
Accelerate
CoreGraphics
CoreVideo
];
propagatedBuildInputs = lib.optionals stdenv.isDarwin [
OpenCL
];
strictDeps = true;
meta = with lib; {
homepage = "https://github.com/clMathLibraries/clBLAS";
description = "A software library containing BLAS functions written in OpenCL";
longDescription = ''
This package contains a library of BLAS functions on top of OpenCL.
'';
license = licenses.asl20;
maintainers = with maintainers; [ artuuge ];
platforms = platforms.unix;
};
}

34
pkgs/development/libraries/science/math/clblas/platform.patch Normal file
View file

@ -0,0 +1,34 @@
diff --git a/src/library/tools/ktest/config.cpp b/src/library/tools/ktest/config.cpp
index 8b20128..faf9bde 100644
--- a/src/library/tools/ktest/config.cpp
+++ b/src/library/tools/ktest/config.cpp
@@ -24,8 +24,6 @@
using namespace clMath;
-static const char DEFAULT_PLATFORM_NAME[] = "AMD Accelerated Parallel Processing";
-
Config::Config() :
defaultConfig_(""),
cpp_("ktest.cpp"),
@@ -35,7 +33,10 @@ Config::Config() :
hasFuncID_(false), hasSubdims_(false),
skipAccuracy_(false)
{
- setPlatform(DEFAULT_PLATFORM_NAME);
+ platform_ = NULL;
+ setPlatform("");
+
+ device_ = NULL;
setDevice("");
memset(&kargs_, 0, sizeof(kargs_));
@@ -262,7 +263,7 @@ Config::setPlatform(const std::string& name)
continue;
}
if (name.empty()) {
- found = (strcmp(pname, DEFAULT_PLATFORM_NAME) == 0);
+ found = true;
}
else {
found = (strcmp(pname, name.c_str()) == 0);

39
pkgs/development/libraries/science/math/cliquer/default.nix Normal file
View file

@ -0,0 +1,39 @@
{ lib, stdenv
, fetchFromGitHub
, autoreconfHook
}:
stdenv.mkDerivation rec {
version = "1.22";
pname = "cliquer";
# autotoolized version of the original cliquer
src = fetchFromGitHub {
owner = "dimpase";
repo = "autocliquer";
rev = "v${version}";
sha256 = "00gcmrhi2fjn8b246w5a3b0pl7p6haxy5wjvd9kcqib1xanz59z4";
};
doCheck = true;
buildInputs = [
autoreconfHook
];
meta = with lib; {
description = "Routines for clique searching";
longDescription = ''
Cliquer is a set of C routines for finding cliques in an arbitrary weighted graph.
It uses an exact branch-and-bound algorithm developed by Patric Östergård.
It is designed with the aim of being efficient while still being flexible and
easy to use.
'';
homepage = "https://users.aalto.fi/~pat/cliquer.html";
downloadPage = src.meta.homepage; # autocliquer
license = licenses.gpl2Plus;
maintainers = teams.sage.members;
mainProgram = "cl";
platforms = platforms.unix;
};
}

75
pkgs/development/libraries/science/math/clmagma/default.nix Normal file
View file

@ -0,0 +1,75 @@
{ lib, stdenv, fetchurl, gfortran, opencl-headers, clblas, ocl-icd, mkl, intel-ocl }:
with lib;
let
incfile = builtins.toFile "make.inc.custom" ''
CC = g++
FORT = gfortran
ARCH = ar
ARCHFLAGS = cr
RANLIB = ranlib
OPTS = -fPIC -O3 -DADD_ -Wall
FOPTS = -fPIC -O3 -DADD_ -Wall -x f95-cpp-input
F77OPTS = -fPIC -O3 -DADD_ -Wall
LDOPTS = -fPIC
-include make.check-mkl
-include make.check-clblas
# Gnu mkl is not available I guess?
#LIB = -lmkl_gf_lp64 -lmkl_gnu_thread -lmkl_core -lpthread -lm -fopenmp
LIB = -lmkl_intel_lp64 -lmkl_intel_thread -lmkl_core -liomp5 -lm -fopenmp
LIB += -lclBLAS -lOpenCL
LIBDIR = -L$(MKLROOT)/lib/intel64 \
-L$(MKLROOT)/../compiler/lib/intel64 \
-L$(clBLAS)/lib64
INC = -I$(clBLAS)/include
#-I$(AMDAPP)/include
'';
in stdenv.mkDerivation rec {
pname = "clmagma";
version = "1.3.0";
src = fetchurl {
url = "https://icl.cs.utk.edu/projectsfiles/magma/cl/clmagma-${version}.tar.gz";
sha256 = "1n27ny0xhwirw2ydn46pfcwy53gzia9zbam4irx44fd4d7f9ydv7";
name = "clmagma-${version}.tar.gz";
};
buildInputs = [
gfortran
clblas
opencl-headers
ocl-icd
mkl
intel-ocl
];
enableParallelBuilding=true;
MKLROOT = "${mkl}";
clBLAS = "${clblas}";
# Otherwise build looks for it in /run/opengl-driver/etc/OpenCL/vendors,
# which is not available.
OPENCL_VENDOR_PATH="${intel-ocl}/etc/OpenCL/vendors";
preBuild = ''
# By default it tries to use GPU, and thus fails for CPUs
sed -i "s/CL_DEVICE_TYPE_GPU/CL_DEVICE_TYPE_DEFAULT/" interface_opencl/clmagma_runtime.cpp
sed -i "s%/usr/local/clmagma%/$out%" Makefile.internal
cp ${incfile} make.inc
'';
meta = with lib; {
description = "Matrix Algebra on GPU and Multicore Architectures, OpenCL port";
license = licenses.bsd3;
homepage = "https://icl.cs.utk.edu/magma/index.html";
platforms = platforms.linux;
maintainers = with maintainers; [ volhovm ];
};
}

116
pkgs/development/libraries/science/math/cudnn/extension.nix Normal file
View file

@ -0,0 +1,116 @@
final: prev: let
inherit (final) callPackage;
inherit (prev) cudatoolkit cudaVersion lib pkgs;
### CuDNN
buildCuDnnPackage = args:
let
useCudatoolkitRunfile = lib.versionOlder cudaVersion "11.3.999";
in
callPackage ./generic.nix { inherit useCudatoolkitRunfile; } args;
toUnderscore = str: lib.replaceStrings ["."] ["_"] str;
majorMinorPatch = str: lib.concatStringsSep "." (lib.take 3 (lib.splitVersion str));
cuDnnPackages = with lib; let
# Check whether a file is supported for our cuda version
isSupported = fileData: elem cudaVersion fileData.supportedCudaVersions;
# Return the first file that is supported. In practice there should only ever be one anyway.
supportedFile = files: findFirst isSupported null files;
# Supported versions with versions as keys and file as value
supportedVersions = filterAttrs (version: file: file !=null ) (mapAttrs (version: files: supportedFile files) cuDnnVersions);
# Compute versioned attribute name to be used in this package set
computeName = version: "cudnn_${toUnderscore version}";
# Add all supported builds as attributes
allBuilds = mapAttrs' (version: file: nameValuePair (computeName version) (buildCuDnnPackage (removeAttrs file ["fileVersion"]))) supportedVersions;
# Set the default attributes, e.g. cudnn = cudnn_8_3_1;
defaultBuild = { "cudnn" = allBuilds.${computeName cuDnnDefaultVersion}; };
in allBuilds // defaultBuild;
cuDnnVersions = let
urlPrefix = "https://developer.download.nvidia.com/compute/redist/cudnn";
in {
"7.4.2" = [
rec {
fileVersion = "10.0";
fullVersion = "7.4.2.24";
sha256 = "18ys0apiz9afid2s6lvy9qbyi8g66aimb2a7ikl1f3dm09mciprf";
url = "${urlPrefix}/v${majorMinorPatch fullVersion}/cudnn-10.0-linux-x64-v${fullVersion}.tgz";
supportedCudaVersions = [ "10.0" ];
}
];
"7.6.5" = [
rec {
fileVersion = "10.0";
fullVersion = "7.6.5.32";
hash = "sha256-KDVeOV8LK5OsLIO2E2CzW6bNA3fkTni+GXtrYbS0kro=";
url = "${urlPrefix}/v${majorMinorPatch fullVersion}/cudnn-${cudatoolkit.majorVersion}-linux-x64-v${fullVersion}.tgz";
supportedCudaVersions = [ "10.0" ];
}
rec {
fileVersion = "10.1";
fullVersion = "7.6.5.32";
hash = "sha256-fq7IA5osMKsLx1jTA1iHZ2k972v0myJIWiwAvy4TbLM=";
url = "${urlPrefix}/v${majorMinorPatch fullVersion}/cudnn-${cudatoolkit.majorVersion}-linux-x64-v${fullVersion}.tgz";
supportedCudaVersions = [ "10.1" ];
}
rec {
fileVersion = "10.2";
fullVersion = "7.6.5.32";
hash = "sha256-fq7IA5osMKsLx1jTA1iHZ2k972v0myJIWiwAvy4TbLN=";
url = "${urlPrefix}/v${majorMinorPatch fullVersion}/cudnn-${cudatoolkit.majorVersion}-linux-x64-v${fullVersion}.tgz";
supportedCudaVersions = [ "10.2" ];
}
];
"8.1.1" = [
rec {
fileVersion = "10.2";
fullVersion = "8.1.1.33";
hash = "sha256-Kkp7mabpv6aQ6xm7QeSVU/KnpJGls6v8rpAOFmxbbr0=";
url = "${urlPrefix}/v${majorMinorPatch fullVersion}/cudnn-${fileVersion}-linux-x64-v${fullVersion}.tgz";
supportedCudaVersions = [ "10.2" ];
}
rec {
fileVersion = "11.2";
fullVersion = "8.1.1.33";
hash = "sha256-mKh4TpKGLyABjSDCgbMNSgzZUfk2lPZDPM9K6cUCumo=";
url = "${urlPrefix}/v${majorMinorPatch fullVersion}/cudnn-${fileVersion}-linux-x64-v${fullVersion}.tgz";
supportedCudaVersions = [ "11.2" ];
}
];
"8.3.2" = [
rec {
fileVersion = "10.2";
fullVersion = "8.3.2.44";
hash = "sha256-mKh4TpKGLyABjSDCgbMNSgzZUfk2lPZDPM9K6cUCumo=";
url = "${urlPrefix}/v${majorMinorPatch fullVersion}/local_installers/${fileVersion}/cudnn-linux-x86_64-${fullVersion}_cuda${fileVersion}-archive.tar.xz";
supportedCudaVersions = [ "10.2" ];
}
rec {
fileVersion = "11.5";
fullVersion = "8.3.2.44";
hash = "sha256-VQCVPAjF5dHd3P2iNPnvvdzb5DpTsm3AqCxyP6FwxFc=";
url = "${urlPrefix}/v${majorMinorPatch fullVersion}/local_installers/${fileVersion}/cudnn-linux-x86_64-${fullVersion}_cuda${fileVersion}-archive.tar.xz";
supportedCudaVersions = [ "11.0" "11.1" "11.2" "11.3" "11.4" "11.4" "11.5" "11.6" ];
}
];
};
# Default attributes
cuDnnDefaultVersion = {
"10.0" = "7.4.2";
"10.1" = "7.6.5";
"10.2" = "8.3.2";
"11.0" = "8.3.2";
"11.1" = "8.3.2";
"11.2" = "8.3.2";
"11.3" = "8.3.2";
"11.4" = "8.3.2";
"11.5" = "8.3.2";
"11.6" = "8.3.2";
}.${cudaVersion};
in cuDnnPackages

115
pkgs/development/libraries/science/math/cudnn/generic.nix Normal file
View file

@ -0,0 +1,115 @@
{ stdenv
, lib
, zlib
, useCudatoolkitRunfile ? false
, cudaVersion
, cudaMajorVersion
, cudatoolkit # if cuda>=11: only used for .cc
, libcublas ? null # cuda <11 doesn't ship redist packages
, autoPatchelfHook
, autoAddOpenGLRunpathHook
, fetchurl
, # The distributed version of CUDNN includes both dynamically liked .so files,
# as well as statically linked .a files. However, CUDNN is quite large
# (multiple gigabytes), so you can save some space in your nix store by
# removing the statically linked libraries if you are not using them.
#
# Setting this to true removes the statically linked .a files.
# Setting this to false keeps these statically linked .a files.
removeStatic ? false
}:
{ fullVersion
, url
, hash ? null
, sha256 ? null
, supportedCudaVersions ? [ ]
}:
assert (hash != null) || (sha256 != null);
assert useCudatoolkitRunfile || (libcublas != null);
let
inherit (cudatoolkit) cc;
majorMinorPatch = version: lib.concatStringsSep "." (lib.take 3 (lib.splitVersion version));
version = majorMinorPatch fullVersion;
cudatoolkit_root =
if useCudatoolkitRunfile
then cudatoolkit
else libcublas;
in
stdenv.mkDerivation {
pname = "cudatoolkit-${cudaMajorVersion}-cudnn";
inherit version;
src = fetchurl {
inherit url hash sha256;
};
# Check and normalize Runpath against DT_NEEDED using autoPatchelf.
# Prepend /run/opengl-driver/lib using addOpenGLRunpath for dlopen("libcudacuda.so")
nativeBuildInputs = [
autoPatchelfHook
autoAddOpenGLRunpathHook
];
# Used by autoPatchelfHook
buildInputs = [
cc.cc.lib # libstdc++
zlib
cudatoolkit_root
];
# We used to patch Runpath here, but now we use autoPatchelfHook
#
# Note also that version <=8.3.0 contained a subdirectory "lib64/" but in
# version 8.3.2 it seems to have been renamed to simply "lib/".
installPhase = ''
runHook preInstall
mkdir -p $out
cp -a include $out/include
[ -d "lib/" ] && cp -a lib $out/lib
[ -d "lib64/" ] && cp -a lib64 $out/lib64
'' + lib.optionalString removeStatic ''
rm -f $out/lib/*.a
rm -f $out/lib64/*.a
'' + ''
runHook postInstall
'';
# Without --add-needed autoPatchelf forgets $ORIGIN on cuda>=8.0.5.
postFixup = lib.optionalString (lib.versionAtLeast fullVersion "8.0.5") ''
patchelf $out/lib/libcudnn.so --add-needed libcudnn_cnn_infer.so
'';
passthru = {
inherit useCudatoolkitRunfile;
cudatoolkit = lib.warn ''
cudnn.cudatoolkit passthru attribute is deprecated;
if your derivation uses cudnn directly, it should probably consume cudaPackages instead
''
cudatoolkit;
majorVersion = lib.versions.major version;
};
meta = with lib; {
# Check that the cudatoolkit version satisfies our min/max constraints (both
# inclusive). We mark the package as broken if it fails to satisfies the
# official version constraints (as recorded in default.nix). In some cases
# you _may_ be able to smudge version constraints, just know that you're
# embarking into unknown and unsupported territory when doing so.
broken = !(elem cudaVersion supportedCudaVersions);
description = "NVIDIA CUDA Deep Neural Network library (cuDNN)";
homepage = "https://developer.nvidia.com/cudnn";
# TODO: consider marking unfreRedistributable when not using runfile
license = licenses.unfree;
platforms = [ "x86_64-linux" ];
maintainers = with maintainers; [ mdaiter samuela ];
};
}

69
pkgs/development/libraries/science/math/cutensor/generic.nix Normal file
View file

@ -0,0 +1,69 @@
{ stdenv
, lib
, libPath
, cudatoolkit
, fetchurl
, autoPatchelfHook
, addOpenGLRunpath
, version
, hash
}:
let
mostOfVersion = builtins.concatStringsSep "."
(lib.take 3 (lib.versions.splitVersion version));
in
stdenv.mkDerivation {
pname = "cudatoolkit-${cudatoolkit.majorVersion}-cutensor";
inherit version;
src = fetchurl {
url = "https://developer.download.nvidia.com/compute/cutensor/${mostOfVersion}/local_installers/libcutensor-${stdenv.hostPlatform.parsed.kernel.name}-${stdenv.hostPlatform.parsed.cpu.name}-${version}.tar.gz";
inherit hash;
};
outputs = [ "out" "dev" ];
nativeBuildInputs = [
autoPatchelfHook
addOpenGLRunpath
];
buildInputs = [
stdenv.cc.cc.lib
];
propagatedBuildInputs = [
cudatoolkit
];
# Set RUNPATH so that libcuda in /run/opengl-driver(-32)/lib can be found.
# See the explanation in addOpenGLRunpath.
installPhase = ''
mkdir -p "$out" "$dev"
mv include "$dev"
mv ${libPath} "$out/lib"
function finalRPathFixups {
for lib in $out/lib/lib*.so; do
addOpenGLRunpath $lib
done
}
postFixupHooks+=(finalRPathFixups)
'';
passthru = {
inherit cudatoolkit;
majorVersion = lib.versions.major version;
};
meta = with lib; {
description = "cuTENSOR: A High-Performance CUDA Library For Tensor Primitives";
homepage = "https://developer.nvidia.com/cutensor";
license = licenses.unfree;
platforms = [ "x86_64-linux" ];
maintainers = with maintainers; [ obsidian-systems-maintenance ];
};
}

38
pkgs/development/libraries/science/math/ecos/default.nix Normal file
View file

@ -0,0 +1,38 @@
{ lib, stdenv, fetchFromGitHub }:
stdenv.mkDerivation rec {
pname = "ecos";
version = "2.0.7";
src = fetchFromGitHub {
owner = "embotech";
repo = "ecos";
rev = version;
sha256 = "1hsndim5kjvcwk5svqa4igawzahj982180xj1d7yd0dbjlgxc7w7";
};
buildPhase = ''
make all shared
'';
doCheck = true;
checkPhase = ''
make test
./runecos
'';
installPhase = ''
mkdir -p $out/lib
cp lib*.a lib*.so $out/lib
cp -r include $out/
'';
meta = with lib; {
description = "A lightweight conic solver for second-order cone programming";
homepage = "https://www.embotech.com/ECOS";
downloadPage = "https://github.com/embotech/ecos/releases";
license = licenses.gpl3;
platforms = platforms.all;
maintainers = with maintainers; [ bhipple ];
};
}

40
pkgs/development/libraries/science/math/flintqs/default.nix Normal file
View file

@ -0,0 +1,40 @@
{ lib, stdenv
, fetchFromGitHub
, autoreconfHook
, gmp
}:
stdenv.mkDerivation rec {
version = "1.0";
pname = "flintqs";
src = fetchFromGitHub {
owner = "sagemath";
repo = "FlintQS";
rev = "v${version}";
sha256 = "1f0lnayz6j6qgasx8pbq61d2fqam0wwhsmh6h15l4vq58l1vvbwj";
};
preAutoreconf = ''
touch ChangeLog
'';
buildInputs = [
gmp
];
nativeBuildInputs = [
autoreconfHook
];
doCheck = true;
meta = with lib; {
description = "Highly optimized multi-polynomial quadratic sieve for integer factorization";
homepage = "https://github.com/sagemath/FlintQS";
license = with licenses; [ gpl2 ];
maintainers = teams.sage.members;
mainProgram = "QuadraticSieve";
platforms = platforms.all;
};
}

43
pkgs/development/libraries/science/math/ipopt/default.nix Normal file
View file

@ -0,0 +1,43 @@
{ lib
, stdenv
, fetchFromGitHub
, pkg-config
, blas
, lapack
, gfortran
, enableAMPL ? stdenv.isLinux, libamplsolver
}:
assert (!blas.isILP64) && (!lapack.isILP64);
stdenv.mkDerivation rec {
pname = "ipopt";
version = "3.14.5";
src = fetchFromGitHub {
owner = "coin-or";
repo = "Ipopt";
rev = "releases/${version}";
sha256 = "sha256-eqOacZGuuGAjWMs2H6RntQ+WJmGTi+EqydHUQXEpY54=";
};
CXXDEFS = [ "-DHAVE_RAND" "-DHAVE_CSTRING" "-DHAVE_CSTDIO" ];
configureFlags = [
"--with-asl-cflags=-I${libamplsolver}/include"
"--with-asl-lflags=-lamplsolver"
];
nativeBuildInputs = [ pkg-config gfortran ];
buildInputs = [ blas lapack ] ++ lib.optionals enableAMPL [ libamplsolver ];
enableParallelBuilding = true;
meta = with lib; {
description = "A software package for large-scale nonlinear optimization";
homepage = "https://projects.coin-or.org/Ipopt";
license = licenses.epl10;
platforms = platforms.unix;
maintainers = with maintainers; [ abbradar ];
};
}

55
pkgs/development/libraries/science/math/itpp/default.nix Normal file
View file

@ -0,0 +1,55 @@
{ lib, stdenv
, fetchurl
, cmake
, gtest
, blas
, fftw
, liblapack
, gfortran
}:
stdenv.mkDerivation rec {
pname = "it++";
version = "4.3.1";
src = fetchurl {
url = "mirror://sourceforge/itpp/itpp-${version}.tar.bz2";
sha256 = "0xxqag9wi0lg78xgw7b40rp6wxqp5grqlbs9z0ifvdfzqlhpcwah";
};
nativeBuildInputs = [ cmake gfortran ];
buildInputs = [
fftw
liblapack
# NOTE: OpenBLAS doesn't work here because IT++ doesn't pass aligned
# buffers, which causes segfaults in the optimized kernels :-(
blas
];
cmakeFlags = [
"-DCMAKE_CXX_FLAGS=-std=c++11"
"-DBLAS_FOUND:BOOL=TRUE"
"-DBLAS_LIBRARIES:STRING=${blas}/lib/libblas.so"
"-DLAPACK_FOUND:BOOL=TRUE"
"-DLAPACK_LIBRARIES:STRING=${liblapack}/lib/liblapack.so"
"-DGTEST_DIR:PATH=${gtest.src}/googletest"
];
doCheck = true;
checkPhase = ''
export LD_LIBRARY_PATH=$LD_LIBRARY_PATH''${LD_LIBRARY_PATH:+:}$PWD/itpp
export DYLD_LIBRARY_PATH=$DYLD_LIBRARY_PATH''${DYLD_LIBRARY_PATH:+:}$PWD/itpp
./gtests/itpp_gtests
'';
meta = with lib; {
description = "IT++ is a C++ library of mathematical, signal processing and communication classes and functions";
homepage = "http://itpp.sourceforge.net/";
license = licenses.gpl3;
platforms = platforms.unix;
maintainers = with maintainers; [ andrew-d ];
broken = stdenv.isDarwin; # never built on Hydra https://hydra.nixos.org/job/nixpkgs/trunk/itpp.x86_64-darwin
};
}

41
pkgs/development/libraries/science/math/lcalc/default.nix Normal file
View file

@ -0,0 +1,41 @@
{ lib, stdenv
, autoreconfHook
, gengetopt
, pkg-config
, fetchFromGitLab
, pari
}:
stdenv.mkDerivation rec {
version = "2.0.5";
pname = "lcalc";
src = fetchFromGitLab {
owner = "sagemath";
repo = pname;
rev = version;
sha256 = "sha256-RxWZ7T0I9zV7jUVnL6jV/PxEoU32KY7Q1UsOL5Lonuc=";
};
nativeBuildInputs = [
autoreconfHook
gengetopt
pkg-config
];
buildInputs = [
pari
];
configureFlags = [
"--with-pari"
];
meta = with lib; {
homepage = "https://gitlab.com/sagemath/lcalc";
description = "A program for calculating with L-functions";
license = with licenses; [ gpl2 ];
maintainers = teams.sage.members;
platforms = platforms.all;
};
}

37
pkgs/development/libraries/science/math/libamplsolver/default.nix Normal file
View file

@ -0,0 +1,37 @@
{ lib, stdenv, fetchurl, fetchpatch }:
stdenv.mkDerivation rec {
pname = "libamplsolver";
version = "20211109";
src = fetchurl {
url = "https://ampl.com/netlib/ampl/solvers.tgz";
sha256 = "sha256-LVmScuIvxmZzywPSBl9T9YcUBJP7UFAa3eWs9r4q3JM=";
};
patches = [
# Debian provides a patch to build a shared library
(fetchpatch {
url = "https://sources.debian.org/data/main/liba/libamplsolver/0~20190702-2/debian/patches/fix-makefile-shared-lib.patch";
sha256 = "sha256-96qwj3fLugzbsfxguKMce13cUo7XGC4VUE7xKcJs42Y=";
})
];
installPhase = ''
runHook preInstall
pushd sys.`uname -m`.`uname -s`
install -D -m 0644 *.h -t $out/include
install -D -m 0644 *.so* -t $out/lib
install -D -m 0644 *.a -t $out/lib
popd
runHook postInstall
'';
meta = with lib; {
description = "A library of routines that help solvers work with AMPL";
homepage = "https://ampl.com/netlib/ampl/";
license = [ licenses.mit ];
platforms = platforms.linux;
maintainers = with maintainers; [ aanderse ];
};
}

34
pkgs/development/libraries/science/math/libbraiding/default.nix Normal file
View file

@ -0,0 +1,34 @@
{ lib, stdenv
, fetchFromGitHub
, autoreconfHook
}:
stdenv.mkDerivation rec {
version = "1.1";
pname = "libbraiding";
src = fetchFromGitHub {
owner = "miguelmarco";
repo = "libbraiding";
rev = version;
sha256 = "1n1j58y9jaiv0ya0y4fpfb3b05wv0h6k2babpnk2zifjw26xr366";
};
nativeBuildInputs = [
autoreconfHook
];
# no tests included for now (2018-08-05), but can't hurt to activate
doCheck = true;
meta = with lib; {
homepage = "https://github.com/miguelmarco/libbraiding/";
description = "C++ library for computations on braid groups";
longDescription = ''
A library to compute several properties of braids, including centralizer and conjugacy check.
'';
license = licenses.gpl3;
maintainers = teams.sage.members;
platforms = platforms.all;
};
}

35
pkgs/development/libraries/science/math/libhomfly/default.nix Normal file
View file

@ -0,0 +1,35 @@
{ lib, stdenv
, fetchFromGitHub
, autoreconfHook
, boehmgc
}:
stdenv.mkDerivation rec {
version = "1.02r6";
pname = "libhomfly";
src = fetchFromGitHub {
owner = "miguelmarco";
repo = "libhomfly";
rev = version;
sha256 = "sha256-s1Hgy6S9+uREKsgjOVQdQfnds6oSLo5UWTrt5DJnY2s=";
};
buildInputs = [
boehmgc
];
nativeBuildInputs = [
autoreconfHook
];
doCheck = true;
meta = with lib; {
homepage = "https://github.com/miguelmarco/libhomfly/";
description = "Library to compute the homfly polynomial of knots and links";
license = licenses.unlicense;
maintainers = teams.sage.members;
platforms = platforms.all;
};
}

75
pkgs/development/libraries/science/math/liblapack/default.nix Normal file
View file

@ -0,0 +1,75 @@
{ lib
, stdenv
, fetchFromGitHub
, gfortran
, cmake
, shared ? true
# Compile with ILP64 interface
, blas64 ? false
}:
stdenv.mkDerivation rec {
pname = "liblapack";
version = "3.10.1";
src = fetchFromGitHub {
owner = "Reference-LAPACK";
repo = "lapack";
rev = "v${version}";
sha256 = "07wwydw72gl4fhfqcyc8sbz7ynm0i23pggyfqn0r9a29g7qh8bqs";
};
nativeBuildInputs = [ gfortran cmake ];
# Configure stage fails on aarch64-darwin otherwise, due to either clang 11 or gfortran 10.
hardeningDisable = lib.optionals (stdenv.isDarwin && stdenv.isAarch64) [ "stackprotector" ];
cmakeFlags = [
"-DCMAKE_Fortran_FLAGS=-fPIC"
"-DLAPACKE=ON"
"-DCBLAS=ON"
"-DBUILD_TESTING=ON"
] ++ lib.optional shared "-DBUILD_SHARED_LIBS=ON"
++ lib.optional blas64 "-DBUILD_INDEX64=ON";
passthru = { inherit blas64; };
postInstall = let
canonicalExtension = if stdenv.hostPlatform.isLinux
then "${stdenv.hostPlatform.extensions.sharedLibrary}.${lib.versions.major version}"
else stdenv.hostPlatform.extensions.sharedLibrary;
in lib.optionalString blas64 ''
ln -s $out/lib/liblapack64${canonicalExtension} $out/lib/liblapack${canonicalExtension}
ln -s $out/lib/liblapacke64${canonicalExtension} $out/lib/liblapacke${canonicalExtension}
'';
doCheck = true;
# Some CBLAS related tests fail on Darwin:
# 14 - CBLAS-xscblat2 (Failed)
# 15 - CBLAS-xscblat3 (Failed)
# 17 - CBLAS-xdcblat2 (Failed)
# 18 - CBLAS-xdcblat3 (Failed)
# 20 - CBLAS-xccblat2 (Failed)
# 21 - CBLAS-xccblat3 (Failed)
# 23 - CBLAS-xzcblat2 (Failed)
# 24 - CBLAS-xzcblat3 (Failed)
#
# Upstream issue to track:
# * https://github.com/Reference-LAPACK/lapack/issues/440
ctestArgs = lib.optionalString stdenv.isDarwin "-E '^(CBLAS-(x[sdcz]cblat[23]))$'";
checkPhase = ''
runHook preCheck
ctest ${ctestArgs}
runHook postCheck
'';
meta = with lib; {
description = "Linear Algebra PACKage";
homepage = "http://www.netlib.org/lapack/";
maintainers = with maintainers; [ markuskowa ];
license = licenses.bsd3;
platforms = platforms.all;
};
}

19
pkgs/development/libraries/science/math/liblbfgs/default.nix Normal file
View file

@ -0,0 +1,19 @@
{ lib, stdenv, fetchurl }:
stdenv.mkDerivation rec {
pname = "liblbfgs";
version = "1.10";
configureFlags = [ "--enable-sse2" ];
src = fetchurl {
url = "https://github.com/downloads/chokkan/liblbfgs/liblbfgs-${version}.tar.gz";
sha256 = "1kv8d289rbz38wrpswx5dkhr2yh4fg4h6sszkp3fawxm09sann21";
};
meta = {
broken = (stdenv.isLinux && stdenv.isAarch64);
description = "Library of Limited-memory Broyden-Fletcher-Goldfarb-Shanno (L-BFGS)";
homepage = "http://www.chokkan.org/software/liblbfgs/";
license = lib.licenses.mit;
platforms = lib.platforms.unix;
};
}

103
pkgs/development/libraries/science/math/libtorch/bin.nix Normal file
View file

@ -0,0 +1,103 @@
{ callPackage
, stdenv
, fetchzip
, lib
, libcxx
, addOpenGLRunpath
, patchelf
, fixDarwinDylibNames
, cudaSupport
}:
let
# The binary libtorch distribution statically links the CUDA
# toolkit. This means that we do not need to provide CUDA to
# this derivation. However, we should ensure on version bumps
# that the CUDA toolkit for `passthru.tests` is still
# up-to-date.
version = "1.10.0";
device = if cudaSupport then "cuda" else "cpu";
srcs = import ./binary-hashes.nix version;
unavailable = throw "libtorch is not available for this platform";
libcxx-for-libtorch = if stdenv.hostPlatform.system == "x86_64-darwin" then libcxx else stdenv.cc.cc.lib;
in stdenv.mkDerivation {
inherit version;
pname = "libtorch";
src = fetchzip srcs."${stdenv.targetPlatform.system}-${device}" or unavailable;
nativeBuildInputs =
if stdenv.isDarwin then [ fixDarwinDylibNames ]
else [ patchelf ] ++ lib.optionals cudaSupport [ addOpenGLRunpath ];
dontBuild = true;
dontConfigure = true;
dontStrip = true;
installPhase = ''
# Copy headers and CMake files.
mkdir -p $dev
cp -r include $dev
cp -r share $dev
install -Dm755 -t $out/lib lib/*${stdenv.hostPlatform.extensions.sharedLibrary}*
# We do not care about Java support...
rm -f $out/lib/lib*jni* 2> /dev/null || true
# Fix up library paths for split outputs
substituteInPlace $dev/share/cmake/Torch/TorchConfig.cmake \
--replace \''${TORCH_INSTALL_PREFIX}/lib "$out/lib" \
substituteInPlace \
$dev/share/cmake/Caffe2/Caffe2Targets-release.cmake \
--replace \''${_IMPORT_PREFIX}/lib "$out/lib" \
'';
postFixup = let
rpath = lib.makeLibraryPath [ stdenv.cc.cc.lib ];
in lib.optionalString stdenv.isLinux ''
find $out/lib -type f \( -name '*.so' -or -name '*.so.*' \) | while read lib; do
echo "setting rpath for $lib..."
patchelf --set-rpath "${rpath}:$out/lib" "$lib"
${lib.optionalString cudaSupport ''
addOpenGLRunpath "$lib"
''}
done
'' + lib.optionalString stdenv.isDarwin ''
for f in $out/lib/*.dylib; do
otool -L $f
done
for f in $out/lib/*.dylib; do
install_name_tool -id $out/lib/$(basename $f) $f || true
for rpath in $(otool -L $f | grep rpath | awk '{print $1}');do
install_name_tool -change $rpath $out/lib/$(basename $rpath) $f
done
if otool -L $f | grep /usr/lib/libc++ >& /dev/null; then
install_name_tool -change /usr/lib/libc++.1.dylib ${libcxx-for-libtorch.outPath}/lib/libc++.1.0.dylib $f
fi
done
for f in $out/lib/*.dylib; do
otool -L $f
done
'';
outputs = [ "out" "dev" ];
passthru.tests.cmake = callPackage ./test {
inherit cudaSupport;
};
meta = with lib; {
description = "C++ API of the PyTorch machine learning framework";
homepage = "https://pytorch.org/";
# Includes CUDA and Intel MKL, but redistributions of the binary are not limited.
# https://docs.nvidia.com/cuda/eula/index.html
# https://www.intel.com/content/www/us/en/developer/articles/license/onemkl-license-faq.html
license = licenses.bsd3;
maintainers = with maintainers; [ junjihashimoto ];
platforms = platforms.unix;
};
}

19
pkgs/development/libraries/science/math/libtorch/binary-hashes.nix Normal file
View file

@ -0,0 +1,19 @@
version : builtins.getAttr version {
"1.10.0" = {
x86_64-darwin-cpu = {
name = "libtorch-macos-1.10.0.zip";
url = "https://download.pytorch.org/libtorch/cpu/libtorch-macos-1.10.0.zip";
hash = "sha256-HSisxHs466c6XwvZEbkV/1kVNBzJOy3uVw9Bh497Vk8=";
};
x86_64-linux-cpu = {
name = "libtorch-cxx11-abi-shared-with-deps-1.10.0-cpu.zip";
url = "https://download.pytorch.org/libtorch/cpu/libtorch-cxx11-abi-shared-with-deps-1.10.0%2Bcpu.zip";
hash = "sha256-wAtA+AZx3HjaFbsrbyfkSXjYM0BP8H5HwCgyHbgJXJ0=";
};
x86_64-linux-cuda = {
name = "libtorch-cxx11-abi-shared-with-deps-1.10.0-cu113.zip";
url = "https://download.pytorch.org/libtorch/cu113/libtorch-cxx11-abi-shared-with-deps-1.10.0%2Bcu113.zip";
hash = "sha256-jPylK4j0V8SEQ8cZU+O22P7kQ28wanIB0GkBzRGyTj8=";
};
};
}

38
pkgs/development/libraries/science/math/libtorch/prefetch.sh Executable file
View file

@ -0,0 +1,38 @@
#!/usr/bin/env nix-shell
#!nix-shell -i bash -p nix-prefetch-scripts
set -eou pipefail
version=$1
bucket="https://download.pytorch.org/libtorch"
CUDA_VERSION=cu113
url_and_key_list=(
"x86_64-darwin-cpu $bucket/cpu/libtorch-macos-${version}.zip libtorch-macos-${version}.zip"
"x86_64-linux-cpu $bucket/cpu/libtorch-cxx11-abi-shared-with-deps-${version}%2Bcpu.zip libtorch-cxx11-abi-shared-with-deps-${version}-cpu.zip"
"x86_64-linux-cuda $bucket/${CUDA_VERSION}/libtorch-cxx11-abi-shared-with-deps-${version}%2B${CUDA_VERSION}.zip libtorch-cxx11-abi-shared-with-deps-${version}-${CUDA_VERSION}.zip"
)
hashfile="binary-hashes-$version.nix"
echo " \"$version\" = {" >> $hashfile
for url_and_key in "${url_and_key_list[@]}"; do
key=$(echo "$url_and_key" | cut -d' ' -f1)
url=$(echo "$url_and_key" | cut -d' ' -f2)
name=$(echo "$url_and_key" | cut -d' ' -f3)
echo "prefetching ${url}..."
hash=$(nix hash to-sri --type sha256 $(nix-prefetch-url --unpack "$url" --name "$name"))
echo " $key = {" >> $hashfile
echo " name = \"$name\";" >> $hashfile
echo " url = \"$url\";" >> $hashfile
echo " hash = \"$hash\";" >> $hashfile
echo " };" >> $hashfile
echo
done
echo " };" >> $hashfile
echo "done."

5
pkgs/development/libraries/science/math/libtorch/test/CMakeLists.txt Normal file
View file

@ -0,0 +1,5 @@
cmake_minimum_required(VERSION 3.0)
find_package(Torch REQUIRED)
set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${TORCH_CXX_FLAGS}")
add_executable(test test.cpp)
target_link_libraries(test "${TORCH_LIBRARIES}")

51
pkgs/development/libraries/science/math/libtorch/test/default.nix Normal file
View file

@ -0,0 +1,51 @@
{ lib
, stdenv
, cmake
, libtorch-bin
, linkFarm
, symlinkJoin
, cudaSupport
, cudaPackages ? {}
}:
let
inherit (cudaPackages) cudatoolkit cudnn;
cudatoolkit_joined = symlinkJoin {
name = "${cudatoolkit.name}-unsplit";
paths = [ cudatoolkit.out cudatoolkit.lib ];
};
# We do not have access to /run/opengl-driver/lib in the sandbox,
# so use a stub instead.
cudaStub = linkFarm "cuda-stub" [{
name = "libcuda.so.1";
path = "${cudatoolkit}/lib/stubs/libcuda.so";
}];
in stdenv.mkDerivation {
pname = "libtorch-test";
version = libtorch-bin.version;
src = ./.;
nativeBuildInputs = [ cmake ];
buildInputs = [ libtorch-bin ] ++
lib.optionals cudaSupport [ cudnn ];
cmakeFlags = lib.optionals cudaSupport
[ "-DCUDA_TOOLKIT_ROOT_DIR=${cudatoolkit_joined}" ];
doCheck = true;
installPhase = ''
touch $out
'';
checkPhase = lib.optionalString cudaSupport ''
LD_LIBRARY_PATH=${cudaStub}''${LD_LIBRARY_PATH:+:}$LD_LIBRARY_PATH \
'' + ''
./test
'';
}

20
pkgs/development/libraries/science/math/libtorch/test/test.cpp Normal file
View file

@ -0,0 +1,20 @@
#undef NDEBUG
#include <cassert>
#include <iostream>
#include <torch/torch.h>
int main() {
torch::Tensor tensor = torch::eye(3);
float checkData[] = {
1, 0, 0,
0, 1, 0,
0, 0, 1
};
torch::Tensor check = torch::from_blob(checkData, {3, 3});
assert(tensor.allclose(check));
}

25
pkgs/development/libraries/science/math/lrs/default.nix Normal file
View file

@ -0,0 +1,25 @@
{lib, stdenv, fetchurl, gmp}:
stdenv.mkDerivation rec {
pname = "lrs";
version = "7.2";
src = fetchurl {
url = "http://cgm.cs.mcgill.ca/~avis/C/lrslib/archive/lrslib-072.tar.gz";
sha256 = "1w1jsnfgny8cihndr5gfm99pvwp48qsvxkqfsi2q87gd3m57aj7w";
};
buildInputs = [ gmp ];
preBuild = ''
export makeFlags="$makeFlags prefix=$out";
'';
meta = {
description = "Implementation of the reverse search algorithm for vertex enumeration/convex hull problems";
license = lib.licenses.gpl2 ;
maintainers = [lib.maintainers.raskin];
platforms = lib.platforms.linux;
homepage = "http://cgm.cs.mcgill.ca/~avis/C/lrs.html";
};
}

30
pkgs/development/libraries/science/math/m4ri/default.nix Normal file
View file

@ -0,0 +1,30 @@
{ lib, stdenv
, fetchFromBitbucket
, autoreconfHook
}:
stdenv.mkDerivation rec {
version = "20200125";
pname = "m4ri";
src = fetchFromBitbucket {
owner = "malb";
repo = "m4ri";
rev = "release-${version}";
sha256 = "1dxgbv6zdyki3h61qlv7003wzhy6x14zmcaz9x19md1i7ng07w1k";
};
doCheck = true;
nativeBuildInputs = [
autoreconfHook
];
meta = with lib; {
homepage = "https://malb.bitbucket.io/m4ri/";
description = "Library to do fast arithmetic with dense matrices over F_2";
license = licenses.gpl2Plus;
maintainers = teams.sage.members;
platforms = platforms.unix;
};
}

39
pkgs/development/libraries/science/math/m4rie/default.nix Normal file
View file

@ -0,0 +1,39 @@
{ lib, stdenv
, fetchFromBitbucket
, autoreconfHook
, m4ri
}:
stdenv.mkDerivation rec {
version = "20200115";
pname = "m4rie";
src = fetchFromBitbucket {
owner = "malb";
repo = "m4rie";
rev = "release-${version}";
sha256 = "0s8if80x5d6mikbcfsbbxg347136spahp9f3x8i1hflbwl8xj9k8";
};
doCheck = true;
buildInputs = [
m4ri
];
nativeBuildInputs = [
autoreconfHook
];
meta = with lib; {
homepage = "https://malb.bitbucket.io/m4rie/";
description = "Library for matrix multiplication, reduction and inversion over GF(2^k) for 2 <= k <= 10";
longDescription = ''
M4RIE is a library for fast arithmetic with dense matrices over small finite fields of even characteristic.
It uses the M4RI library, implementing the same operations over the finite field F2.
'';
license = licenses.gpl2Plus;
maintainers = teams.sage.members;
platforms = platforms.unix;
};
}

76
pkgs/development/libraries/science/math/magma/default.nix Normal file
View file

@ -0,0 +1,76 @@
{ lib, stdenv, fetchurl, cmake, gfortran, ninja, cudaPackages, libpthreadstubs, lapack, blas }:
let
inherit (cudaPackages) cudatoolkit;
in
assert let majorIs = lib.versions.major cudatoolkit.version;
in majorIs == "9" || majorIs == "10" || majorIs == "11";
let
version = "2.6.2";
# We define a specific set of CUDA compute capabilities here,
# because CUDA 11 does not support compute capability 3.0. Also,
# we use it to enable newer capabilities that are not enabled
# by magma by default. The list of supported architectures
# can be found in magma's top-level CMakeLists.txt.
cudaCapabilities = rec {
cuda9 = [
"Kepler" # 3.0, 3.5
"Maxwell" # 5.0
"Pascal" # 6.0
"Volta" # 7.0
];
cuda10 = [
"Turing" # 7.5
] ++ cuda9;
cuda11 = [
"sm_35" # sm_30 is not supported by CUDA 11
"Maxwell" # 5.0
"Pascal" # 6.0
"Volta" # 7.0
"Turing" # 7.5
"Ampere" # 8.0
];
};
capabilityString = lib.strings.concatStringsSep ","
cudaCapabilities."cuda${lib.versions.major cudatoolkit.version}";
in stdenv.mkDerivation {
pname = "magma";
inherit version;
src = fetchurl {
url = "https://icl.cs.utk.edu/projectsfiles/magma/downloads/magma-${version}.tar.gz";
hash = "sha256-dbVU2rAJA+LRC5cskT5Q5/iMvGLzrkMrWghsfk7aCnE=";
name = "magma-${version}.tar.gz";
};
nativeBuildInputs = [ gfortran cmake ninja ];
buildInputs = [ cudatoolkit libpthreadstubs lapack blas ];
cmakeFlags = [ "-DGPU_TARGET=${capabilityString}" ];
doCheck = false;
preConfigure = ''
export CC=${cudatoolkit.cc}/bin/gcc CXX=${cudatoolkit.cc}/bin/g++
'';
enableParallelBuilding=true;
buildFlags = [ "magma" "magma_sparse" ];
meta = with lib; {
description = "Matrix Algebra on GPU and Multicore Architectures";
license = licenses.bsd3;
homepage = "http://icl.cs.utk.edu/magma/index.html";
platforms = platforms.unix;
maintainers = with maintainers; [ tbenst ];
};
passthru.cudatoolkit = cudatoolkit;
}

21
pkgs/development/libraries/science/math/metis/default.nix Normal file
View file

@ -0,0 +1,21 @@
{ lib, stdenv, fetchurl, unzip, cmake }:
stdenv.mkDerivation rec {
pname = "metis";
version = "5.1.0";
src = fetchurl {
url = "http://glaros.dtc.umn.edu/gkhome/fetch/sw/metis/metis-${version}.tar.gz";
sha256 = "1cjxgh41r8k6j029yxs8msp3z6lcnpm16g5pvckk35kc7zhfpykn";
};
cmakeFlags = [ "-DGKLIB_PATH=../GKlib" ];
nativeBuildInputs = [ unzip cmake ];
meta = {
description = "Serial graph partitioning and fill-reducing matrix ordering";
homepage = "http://glaros.dtc.umn.edu/gkhome/metis/metis/overview";
license = lib.licenses.asl20;
platforms = lib.platforms.all;
};
}

201
pkgs/development/libraries/science/math/mkl/default.nix Normal file
View file

@ -0,0 +1,201 @@
{ lib
, stdenv
, callPackage
, stdenvNoCC
, fetchurl
, rpmextract
, undmg
, darwin
, validatePkgConfig
, enableStatic ? stdenv.hostPlatform.isStatic
}:
/*
For details on using mkl as a blas provider for python packages such as numpy,
numexpr, scipy, etc., see the Python section of the NixPkgs manual.
*/
let
# Release notes and download URLs are here:
# https://registrationcenter.intel.com/en/products/
version = "${mklVersion}.${rel}";
# Darwin is pinned to 2019.3 because the DMG does not unpack; see here for details:
# https://github.com/matthewbauer/undmg/issues/4
mklVersion = if stdenvNoCC.isDarwin then "2019.3" else "2021.1.1";
rel = if stdenvNoCC.isDarwin then "199" else "52";
# Intel openmp uses its own versioning.
openmpVersion = if stdenvNoCC.isDarwin then "19.0.3" else "19.1.3";
openmpRel = "189";
# Thread Building Blocks release.
tbbRel = "119";
shlibExt = stdenvNoCC.hostPlatform.extensions.sharedLibrary;
oneapi-mkl = fetchurl {
url = "https://yum.repos.intel.com/oneapi/intel-oneapi-mkl-${mklVersion}-${mklVersion}-${rel}.x86_64.rpm";
hash = "sha256-G2Y7iX3UN2YUJhxcMM2KmhONf0ls9owpGlOo8hHOfqA=";
};
oneapi-mkl-common = fetchurl {
url = "https://yum.repos.intel.com/oneapi/intel-oneapi-mkl-common-${mklVersion}-${mklVersion}-${rel}.noarch.rpm";
hash = "sha256-HrMt2OcPIRxM8EL8SPjYTyuHJnC7RhPFUrvLhRH+7vc=";
};
oneapi-mkl-common-devel = fetchurl {
url = "https://yum.repos.intel.com/oneapi/intel-oneapi-mkl-common-devel-${mklVersion}-${mklVersion}-${rel}.noarch.rpm";
hash = "sha256-XDE2WFJzEcpujFmO2AvqQdipZMvKB6/G+ksBe2sE438=";
};
oneapi-mkl-devel = fetchurl {
url = "https://yum.repos.intel.com/oneapi/intel-oneapi-mkl-devel-${mklVersion}-${mklVersion}-${rel}.x86_64.rpm";
hash = "sha256-GhUJZ0Vr/ZXp10maie29/5ryU7zzX3F++wRCuuFcE0s=";
};
oneapi-openmp = fetchurl {
url = "https://yum.repos.intel.com/oneapi/intel-oneapi-openmp-${mklVersion}-${mklVersion}-${openmpRel}.x86_64.rpm";
hash = "sha256-yP2c4aQAFNRffjLoIZgWXLcNXbiez8smsgu2wXitefU=";
};
oneapi-tbb = fetchurl {
url = "https://yum.repos.intel.com/oneapi/intel-oneapi-tbb-${mklVersion}-${mklVersion}-${tbbRel}.x86_64.rpm";
hash = "sha256-K1BvhGoGVU2Zwy5vg2ZvJWBrSdh5uQwo0znt5039X0A=";
};
in stdenvNoCC.mkDerivation ({
pname = "mkl";
inherit version;
dontUnpack = stdenvNoCC.isLinux;
nativeBuildInputs = [ validatePkgConfig ] ++ (if stdenvNoCC.isDarwin
then
[ undmg darwin.cctools ]
else
[ rpmextract ]);
buildPhase = if stdenvNoCC.isDarwin then ''
for f in Contents/Resources/pkg/*.tgz; do
tar xzvf $f
done
'' else ''
rpmextract ${oneapi-mkl}
rpmextract ${oneapi-mkl-common}
rpmextract ${oneapi-mkl-common-devel}
rpmextract ${oneapi-mkl-devel}
rpmextract ${oneapi-openmp}
rpmextract ${oneapi-tbb}
'';
installPhase = if stdenvNoCC.isDarwin then ''
for f in $(find . -name 'mkl*.pc') ; do
bn=$(basename $f)
substituteInPlace $f \
--replace "prefix=<INSTALLDIR>/mkl" "prefix=$out" \
--replace $\{MKLROOT} "$out" \
--replace "lib/intel64_lin" "lib" \
--replace "lib/intel64" "lib"
done
for f in $(find opt/intel -name 'mkl*iomp.pc') ; do
substituteInPlace $f \
--replace "../compiler/lib" "lib"
done
mkdir -p $out/lib
cp -r compilers_and_libraries_${version}/mac/mkl/include $out/
cp -r compilers_and_libraries_${version}/licensing/mkl/en/license.txt $out/lib/
cp -r compilers_and_libraries_${version}/mac/compiler/lib/* $out/lib/
cp -r compilers_and_libraries_${version}/mac/mkl/lib/* $out/lib/
cp -r compilers_and_libraries_${version}/mac/tbb/lib/* $out/lib/
mkdir -p $out/lib/pkgconfig
cp -r compilers_and_libraries_${version}/mac/mkl/bin/pkgconfig/* $out/lib/pkgconfig
'' else ''
for f in $(find . -name 'mkl*.pc') ; do
bn=$(basename $f)
substituteInPlace $f \
--replace $\{MKLROOT} "$out" \
--replace "lib/intel64" "lib"
sed -r -i "s|^prefix=.*|prefix=$out|g" $f
done
for f in $(find opt/intel -name 'mkl*iomp.pc') ; do
substituteInPlace $f --replace "../compiler/lib" "lib"
done
# License
install -Dm0655 -t $out/share/doc/mkl opt/intel/oneapi/mkl/2021.1.1/licensing/en/license.txt
# Dynamic libraries
install -Dm0755 -t $out/lib opt/intel/oneapi/mkl/${mklVersion}/lib/intel64/*.so*
install -Dm0755 -t $out/lib opt/intel/oneapi/compiler/2021.1.1/linux/compiler/lib/intel64_lin/*.so*
install -Dm0755 -t $out/lib opt/intel/oneapi/tbb/2021.1.1/lib/intel64/gcc4.8/*.so*
# Headers
cp -r opt/intel/oneapi/mkl/${mklVersion}/include $out/
'' +
(if enableStatic then ''
install -Dm0644 -t $out/lib opt/intel/oneapi/mkl/${mklVersion}/lib/intel64/*.a
install -Dm0644 -t $out/lib/pkgconfig opt/intel/oneapi/mkl/2021.1.1/tools/pkgconfig/*.pc
'' else ''
cp opt/intel/oneapi/mkl/${mklVersion}/lib/intel64/*.so* $out/lib
install -Dm0644 -t $out/lib/pkgconfig opt/intel/oneapi/mkl/2021.1.1/tools/pkgconfig/*dynamic*.pc
'') + ''
# Setup symlinks for blas / lapack
ln -s $out/lib/libmkl_rt${shlibExt} $out/lib/libblas${shlibExt}
ln -s $out/lib/libmkl_rt${shlibExt} $out/lib/libcblas${shlibExt}
ln -s $out/lib/libmkl_rt${shlibExt} $out/lib/liblapack${shlibExt}
ln -s $out/lib/libmkl_rt${shlibExt} $out/lib/liblapacke${shlibExt}
'' + lib.optionalString stdenvNoCC.hostPlatform.isLinux ''
ln -s $out/lib/libmkl_rt${shlibExt} $out/lib/libblas${shlibExt}".3"
ln -s $out/lib/libmkl_rt${shlibExt} $out/lib/libcblas${shlibExt}".3"
ln -s $out/lib/libmkl_rt${shlibExt} $out/lib/liblapack${shlibExt}".3"
ln -s $out/lib/libmkl_rt${shlibExt} $out/lib/liblapacke${shlibExt}".3"
'';
# fixDarwinDylibName fails for libmkl_cdft_core.dylib because the
# larger updated load commands do not fit. Use install_name_tool
# explicitly and ignore the error.
postFixup = lib.optionalString stdenvNoCC.isDarwin ''
for f in $out/lib/*.dylib; do
install_name_tool -id $out/lib/$(basename $f) $f || true
done
install_name_tool -change @rpath/libiomp5.dylib $out/lib/libiomp5.dylib $out/lib/libmkl_intel_thread.dylib
install_name_tool -change @rpath/libtbb.dylib $out/lib/libtbb.dylib $out/lib/libmkl_tbb_thread.dylib
install_name_tool -change @rpath/libtbbmalloc.dylib $out/lib/libtbbmalloc.dylib $out/lib/libtbbmalloc_proxy.dylib
'';
# Per license agreement, do not modify the binary
dontStrip = true;
dontPatchELF = true;
passthru.tests = {
pkg-config-dynamic-iomp = callPackage ./test { enableStatic = false; execution = "iomp"; };
pkg-config-static-iomp = callPackage ./test { enableStatic = true; execution = "iomp"; };
pkg-config-dynamic-seq = callPackage ./test { enableStatic = false; execution = "seq"; };
pkg-config-static-seq = callPackage ./test { enableStatic = true; execution = "seq"; };
};
meta = with lib; {
description = "Intel OneAPI Math Kernel Library";
longDescription = ''
Intel OneAPI Math Kernel Library (Intel oneMKL) optimizes code with minimal
effort for future generations of Intel processors. It is compatible with your
choice of compilers, languages, operating systems, and linking and
threading models.
'';
homepage = "https://software.intel.com/en-us/mkl";
license = licenses.issl;
platforms = [ "x86_64-linux" "x86_64-darwin" ];
maintainers = with maintainers; [ bhipple ];
};
} // lib.optionalAttrs stdenvNoCC.isDarwin {
src = fetchurl {
url = "http://registrationcenter-download.intel.com/akdlm/irc_nas/tec/15235/m_mkl_${version}.dmg";
sha256 = "14b3ciz7995sqcd6jz7hc8g2x4zwvqxmgxgni46vrlb7n523l62f";
};
})

41
pkgs/development/libraries/science/math/mkl/test/default.nix Normal file
View file

@ -0,0 +1,41 @@
{ stdenv
, pkg-config
, mkl
, enableStatic ? false
, execution ? "seq"
}:
let
linkType = if enableStatic then "static" else "dynamic";
in stdenv.mkDerivation {
pname = "mkl-test";
version = mkl.version;
src = ./.;
nativeBuildInputs = [ pkg-config ];
buildInputs = [ (mkl.override { inherit enableStatic; }) ];
doCheck = true;
buildPhase = ''
# Check regular Nix build.
gcc test.c -o test $(pkg-config --cflags --libs mkl-${linkType}-ilp64-${execution})
# Clear flags to ensure that we are purely relying on options
# provided by pkg-config.
NIX_CFLAGS_COMPILE="" \
NIX_LDFLAGS="" \
gcc test.c -o test $(pkg-config --cflags --libs mkl-${linkType}-ilp64-${execution})
'';
installPhase = ''
touch $out
'';
checkPhase = ''
./test
'';
}

12
pkgs/development/libraries/science/math/mkl/test/test.c Normal file
View file

@ -0,0 +1,12 @@
#include <assert.h>
#include <mkl_cblas.h>
int main() {
float u[] = {1., 2., 3.};
float v[] = {4., 5., 6.};
float dp = cblas_sdot(3, u, 1, v, 1);
assert(dp == 32.);
}

30
pkgs/development/libraries/science/math/mongoose/default.nix Normal file
View file

@ -0,0 +1,30 @@
{ lib, stdenv
, fetchFromGitHub
, cmake
}:
stdenv.mkDerivation rec {
pname = "mongoose";
version = "2.0.4";
outputs = [ "bin" "out" "dev" ];
src = fetchFromGitHub {
owner = "ScottKolo";
repo = "Mongoose";
rev = "v${version}";
sha256 = "0ymwd4n8p8s0ndh1vcbmjcsm0x2cc2b7v3baww5y6as12873bcrh";
};
nativeBuildInputs = [
cmake
];
meta = with lib; {
description = "Graph Coarsening and Partitioning Library";
homepage = "https://github.com/ScottKolo/Mongoose";
license = licenses.gpl3;
maintainers = with maintainers; [];
platforms = with platforms; unix;
};
}

52
pkgs/development/libraries/science/math/nccl/default.nix Normal file
View file

@ -0,0 +1,52 @@
{ lib, stdenv, fetchFromGitHub, which, cudatoolkit, addOpenGLRunpath }:
stdenv.mkDerivation rec {
name = "nccl-${version}-cuda-${cudatoolkit.majorVersion}";
version = "2.12.10-1";
src = fetchFromGitHub {
owner = "NVIDIA";
repo = "nccl";
rev = "v${version}";
sha256 = "sha256-QqORzm0gD+QG+P8rId8bQn2oZsxL5YyxCIobUVs85wE=";
};
outputs = [ "out" "dev" ];
nativeBuildInputs = [ which addOpenGLRunpath ];
buildInputs = [ cudatoolkit ];
preConfigure = ''
patchShebangs src/collectives/device/gen_rules.sh
'';
makeFlags = [
"CUDA_HOME=${cudatoolkit}"
"PREFIX=$(out)"
];
postFixup = ''
moveToOutput lib/libnccl_static.a $dev
# Set RUNPATH so that libnvidia-ml in /run/opengl-driver(-32)/lib can be found.
# See the explanation in addOpenGLRunpath.
addOpenGLRunpath $out/lib/lib*.so
'';
NIX_CFLAGS_COMPILE = [ "-Wno-unused-function" ];
enableParallelBuilding = true;
passthru = {
inherit cudatoolkit;
};
meta = with lib; {
description = "Multi-GPU and multi-node collective communication primitives for NVIDIA GPUs";
homepage = "https://developer.nvidia.com/nccl";
license = licenses.bsd3;
platforms = [ "x86_64-linux" ];
maintainers = with maintainers; [ mdaiter orivej ];
};
}

235
pkgs/development/libraries/science/math/openblas/default.nix Normal file
View file

@ -0,0 +1,235 @@
{ lib, stdenv, fetchFromGitHub, perl, which
# Most packages depending on openblas expect integer width to match
# pointer width, but some expect to use 32-bit integers always
# (for compatibility with reference BLAS).
, blas64 ? null
# Multi-threaded applications must not call a threaded OpenBLAS
# (the only exception is when an application uses OpenMP as its
# *only* form of multi-threading). See
# https://github.com/xianyi/OpenBLAS/wiki/Faq/4bded95e8dc8aadc70ce65267d1093ca7bdefc4c#multi-threaded
# https://github.com/xianyi/OpenBLAS/issues/2543
# This flag builds a single-threaded OpenBLAS using the flags
# stated in thre.
, singleThreaded ? false
, buildPackages
# Select a specific optimization target (other than the default)
# See https://github.com/xianyi/OpenBLAS/blob/develop/TargetList.txt
, target ? null
# Select whether DYNAMIC_ARCH is enabled or not.
, dynamicArch ? null
# enable AVX512 optimized kernels.
# These kernels have been a source of trouble in the past.
# Use with caution.
, enableAVX512 ? false
, enableStatic ? stdenv.hostPlatform.isStatic
, enableShared ? !stdenv.hostPlatform.isStatic
}:
with lib;
let blas64_ = blas64; in
let
setTarget = x: if target == null then x else target;
setDynamicArch = x: if dynamicArch == null then x else dynamicArch;
# To add support for a new platform, add an element to this set.
configs = {
armv6l-linux = {
BINARY = 32;
TARGET = setTarget "ARMV6";
DYNAMIC_ARCH = setDynamicArch false;
USE_OPENMP = true;
};
armv7l-linux = {
BINARY = 32;
TARGET = setTarget "ARMV7";
DYNAMIC_ARCH = setDynamicArch false;
USE_OPENMP = true;
};
aarch64-darwin = {
BINARY = 64;
TARGET = setTarget "VORTEX";
DYNAMIC_ARCH = setDynamicArch true;
USE_OPENMP = false;
MACOSX_DEPLOYMENT_TARGET = "11.0";
};
aarch64-linux = {
BINARY = 64;
TARGET = setTarget "ARMV8";
DYNAMIC_ARCH = setDynamicArch true;
USE_OPENMP = true;
};
i686-linux = {
BINARY = 32;
TARGET = setTarget "P2";
DYNAMIC_ARCH = setDynamicArch true;
USE_OPENMP = true;
};
x86_64-darwin = {
BINARY = 64;
TARGET = setTarget "ATHLON";
DYNAMIC_ARCH = setDynamicArch true;
NO_AVX512 = !enableAVX512;
USE_OPENMP = false;
MACOSX_DEPLOYMENT_TARGET = "10.7";
};
x86_64-linux = {
BINARY = 64;
TARGET = setTarget "ATHLON";
DYNAMIC_ARCH = setDynamicArch true;
NO_AVX512 = !enableAVX512;
USE_OPENMP = !stdenv.hostPlatform.isMusl;
};
powerpc64le-linux = {
BINARY = 64;
TARGET = setTarget "POWER5";
DYNAMIC_ARCH = setDynamicArch true;
USE_OPENMP = !stdenv.hostPlatform.isMusl;
};
riscv64-linux = {
BINARY = 64;
TARGET = setTarget "RISCV64_GENERIC";
DYNAMIC_ARCH = setDynamicArch false;
USE_OPENMP = true;
};
};
in
let
config =
configs.${stdenv.hostPlatform.system}
or (throw "unsupported system: ${stdenv.hostPlatform.system}");
in
let
blas64 =
if blas64_ != null
then blas64_
else hasPrefix "x86_64" stdenv.hostPlatform.system;
# Convert flag values to format OpenBLAS's build expects.
# `toString` is almost what we need other than bools,
# which we need to map {true -> 1, false -> 0}
# (`toString` produces empty string `""` for false instead of `0`)
mkMakeFlagValue = val:
if !builtins.isBool val then toString val
else if val then "1" else "0";
mkMakeFlagsFromConfig = mapAttrsToList (var: val: "${var}=${mkMakeFlagValue val}");
shlibExt = stdenv.hostPlatform.extensions.sharedLibrary;
in
stdenv.mkDerivation rec {
pname = "openblas";
version = "0.3.20";
outputs = [ "out" "dev" ];
src = fetchFromGitHub {
owner = "xianyi";
repo = "OpenBLAS";
rev = "v${version}";
sha256 = "sha256-FLPVcepf7tv/es+4kur9Op7o3iVAAayuYN4hY/P4mmQ=";
};
inherit blas64;
# Some hardening features are disabled due to sporadic failures in
# OpenBLAS-based programs. The problem may not be with OpenBLAS itself, but
# with how these flags interact with hardening measures used downstream.
# In either case, OpenBLAS must only be used by trusted code--it is
# inherently unsuitable for security-conscious applications--so there should
# be no objection to disabling these hardening measures.
hardeningDisable = [
# don't modify or move the stack
"stackprotector" "pic"
# don't alter index arithmetic
"strictoverflow"
# don't interfere with dynamic target detection
"relro" "bindnow"
];
nativeBuildInputs = [
perl
which
];
depsBuildBuild = [
buildPackages.gfortran
buildPackages.stdenv.cc
];
makeFlags = mkMakeFlagsFromConfig (config // {
FC = "${stdenv.cc.targetPrefix}gfortran";
CC = "${stdenv.cc.targetPrefix}${if stdenv.cc.isClang then "clang" else "cc"}";
PREFIX = placeholder "out";
NUM_THREADS = 64;
INTERFACE64 = blas64;
NO_STATIC = !enableStatic;
NO_SHARED = !enableShared;
CROSS = stdenv.hostPlatform != stdenv.buildPlatform;
HOSTCC = "cc";
# Makefile.system only checks defined status
# This seems to be a bug in the openblas Makefile:
# on x86_64 it expects NO_BINARY_MODE=
# but on aarch64 it expects NO_BINARY_MODE=0
NO_BINARY_MODE = if stdenv.isx86_64
then toString (stdenv.hostPlatform != stdenv.buildPlatform)
else stdenv.hostPlatform != stdenv.buildPlatform;
} // (lib.optionalAttrs singleThreaded {
# As described on https://github.com/xianyi/OpenBLAS/wiki/Faq/4bded95e8dc8aadc70ce65267d1093ca7bdefc4c#multi-threaded
USE_THREAD = false;
USE_LOCKING = true; # available with openblas >= 0.3.7
USE_OPENMP = false; # openblas will refuse building with both USE_OPENMP=1 and USE_THREAD=0
}));
doCheck = true;
checkTarget = "tests";
postInstall = ''
# Write pkgconfig aliases. Upstream report:
# https://github.com/xianyi/OpenBLAS/issues/1740
for alias in blas cblas lapack; do
cat <<EOF > $out/lib/pkgconfig/$alias.pc
Name: $alias
Version: ${version}
Description: $alias provided by the OpenBLAS package.
Cflags: -I$out/include
Libs: -L$out/lib -lopenblas
EOF
done
# Setup symlinks for blas / lapack
'' + lib.optionalString enableShared ''
ln -s $out/lib/libopenblas${shlibExt} $out/lib/libblas${shlibExt}
ln -s $out/lib/libopenblas${shlibExt} $out/lib/libcblas${shlibExt}
ln -s $out/lib/libopenblas${shlibExt} $out/lib/liblapack${shlibExt}
ln -s $out/lib/libopenblas${shlibExt} $out/lib/liblapacke${shlibExt}
'' + lib.optionalString (stdenv.hostPlatform.isLinux && enableShared) ''
ln -s $out/lib/libopenblas${shlibExt} $out/lib/libblas${shlibExt}.3
ln -s $out/lib/libopenblas${shlibExt} $out/lib/libcblas${shlibExt}.3
ln -s $out/lib/libopenblas${shlibExt} $out/lib/liblapack${shlibExt}.3
ln -s $out/lib/libopenblas${shlibExt} $out/lib/liblapacke${shlibExt}.3
'' + lib.optionalString enableStatic ''
ln -s $out/lib/libopenblas.a $out/lib/libblas.a
ln -s $out/lib/libopenblas.a $out/lib/libcblas.a
ln -s $out/lib/libopenblas.a $out/lib/liblapack.a
ln -s $out/lib/libopenblas.a $out/lib/liblapacke.a
'';
meta = with lib; {
description = "Basic Linear Algebra Subprograms";
license = licenses.bsd3;
homepage = "https://github.com/xianyi/OpenBLAS";
platforms = platforms.unix;
maintainers = with maintainers; [ ttuegel ];
};
}

23
pkgs/development/libraries/science/math/openlibm/default.nix Normal file
View file

@ -0,0 +1,23 @@
{ lib, stdenv, fetchFromGitHub }:
stdenv.mkDerivation rec {
pname = "openlibm";
version = "0.8.1";
src = fetchFromGitHub {
owner = "JuliaLang";
repo = "openlibm";
rev = "v${version}";
sha256 = "sha256-q7BYUU8oChjuBFbVnpT+vqIAu+BVotT4xY2Dn0hmWfc=";
};
makeFlags = [ "prefix=$(out)" ];
meta = {
description = "High quality system independent, portable, open source libm implementation";
homepage = "https://openlibm.org/";
license = lib.licenses.mit;
maintainers = [ lib.maintainers.ttuegel ];
platforms = lib.platforms.all;
};
}

24
pkgs/development/libraries/science/math/openspecfun/default.nix Normal file
View file

@ -0,0 +1,24 @@
{ lib, stdenv, fetchFromGitHub, gfortran }:
stdenv.mkDerivation rec {
pname = "openspecfun";
version = "0.5.5";
src = fetchFromGitHub {
owner = "JuliaLang";
repo = "openspecfun";
rev = "v${version}";
sha256 = "sha256-fX2wc8LHUcF5nN/hiA60ZZ7emRTs0SznOm/0q6lD+Ko=";
};
makeFlags = [ "prefix=$(out)" ];
nativeBuildInputs = [ gfortran ];
meta = {
description = "A collection of special mathematical functions";
homepage = "https://github.com/JuliaLang/openspecfun";
license = lib.licenses.mit;
maintainers = [ lib.maintainers.ttuegel ];
platforms = lib.platforms.all;
};
}

118
pkgs/development/libraries/science/math/or-tools/default.nix Normal file
View file

@ -0,0 +1,118 @@
{ lib
, stdenv
, fetchFromGitHub
, cmake
, abseil-cpp
, bzip2
, zlib
, lsb-release
, which
, protobuf
, cbc
, ensureNewerSourcesForZipFilesHook
, python
, swig4
}:
stdenv.mkDerivation rec {
pname = "or-tools";
version = "9.1";
disabled = python.pythonOlder "3.6"; # not supported upstream
src = fetchFromGitHub {
owner = "google";
repo = "or-tools";
rev = "v${version}";
sha256 = "sha256-dEYMPWpa3J9EqtCq3kubdUYJivNRTOKUpNDx3UC1IcQ=";
};
# The original build system uses cmake which does things like pull
# in dependencies through git and Makefile creation time. We
# obviously don't want to do this so instead we provide the
# dependencies straight from nixpkgs and use the make build method.
# Cbc is linked against bzip2 and declares this in its pkgs-config file,
# but this makefile doesn't use pkgs-config, so we also have to add lbz2
configurePhase = ''
substituteInPlace makefiles/Makefile.third_party.unix.mk \
--replace 'COINUTILS_LNK = $(STATIC_COINUTILS_LNK)' \
'COINUTILS_LNK = $(STATIC_COINUTILS_LNK) -lbz2'
cat <<EOF > Makefile.local
UNIX_ABSL_DIR=${abseil-cpp}
UNIX_PROTOBUF_DIR=${protobuf}
UNIX_CBC_DIR=${cbc}
USE_SCIP=OFF
EOF
'';
# Many of these 'samples' (which are really the tests) require using SCIP, and or-tools 8.1
# will just crash if SCIP is not found because it doesn't fall back to using one of
# the available solvers: https://github.com/google/or-tools/blob/b77bd3ac69b7f3bb02f55b7bab6cbb4bab3917f2/ortools/linear_solver/linear_solver.cc#L427
# We don't compile with SCIP because it does not have an open source license.
# See https://github.com/google/or-tools/issues/2395
preBuild = ''
for file in ortools/linear_solver/samples/*.cc; do
if grep -q SCIP_MIXED_INTEGER_PROGRAMMING $file; then
substituteInPlace $file --replace SCIP_MIXED_INTEGER_PROGRAMMING CBC_MIXED_INTEGER_PROGRAMMING
fi;
done
substituteInPlace ortools/linear_solver/samples/simple_mip_program.cc \
--replace 'SCIP' 'CBC'
'';
makeFlags = [
"prefix=${placeholder "out"}"
"PROTOBUF_PYTHON_DESC=${python.pkgs.protobuf}/${python.sitePackages}/google/protobuf/descriptor_pb2.py"
];
buildFlags = [ "cc" "pypi_archive" ];
doCheck = true;
checkTarget = "test_cc";
installTargets = [ "install_cc" ];
# The upstream install_python target installs to $HOME.
postInstall = ''
mkdir -p "$python/${python.sitePackages}"
(cd temp_python/ortools; PYTHONPATH="$python/${python.sitePackages}:$PYTHONPATH" python setup.py install '--prefix=$python')
'';
# protobuf generation is not thread safe
enableParallelBuilding = false;
nativeBuildInputs = [
cmake
lsb-release
swig4
which
ensureNewerSourcesForZipFilesHook
python.pkgs.setuptools
python.pkgs.wheel
];
buildInputs = [
zlib
bzip2
python
];
propagatedBuildInputs = [
abseil-cpp
protobuf
python.pkgs.protobuf
python.pkgs.six
python.pkgs.absl-py
python.pkgs.mypy-protobuf
];
outputs = [ "out" "python" ];
meta = with lib; {
homepage = "https://github.com/google/or-tools";
license = licenses.asl20;
description = ''
Google's software suite for combinatorial optimization.
'';
maintainers = with maintainers; [ andersk ];
platforms = with platforms; linux;
};
}

42
pkgs/development/libraries/science/math/osi/default.nix Normal file
View file

@ -0,0 +1,42 @@
{ stdenv, lib, fetchurl, gfortran, pkg-config
, blas, zlib, bzip2
, withGurobi ? false, gurobi
, withCplex ? false, cplex }:
stdenv.mkDerivation rec {
pname = "osi";
version = "0.108.6";
src = fetchurl {
url = "https://www.coin-or.org/download/source/Osi/Osi-${version}.tgz";
sha256 = "1n2jlpq4aikbp0ncs16f7q1pj7yk6kny1bh4fmjaqnwrjw63zvsp";
};
buildInputs =
[ blas zlib bzip2 ]
++ lib.optional withGurobi gurobi
++ lib.optional withCplex cplex;
nativeBuildInputs = [ gfortran pkg-config ];
configureFlags =
lib.optionals withGurobi [ "--with-gurobi-incdir=${gurobi}/include" "--with-gurobi-lib=-lgurobi${gurobi.libSuffix}" ]
++ lib.optionals withCplex [ "--with-cplex-incdir=${cplex}/cplex/include/ilcplex" "--with-cplex-lib=-lcplex${cplex.libSuffix}" ];
NIX_LDFLAGS =
lib.optionalString withCplex "-L${cplex}/cplex/bin/${cplex.libArch}";
# Compile errors
NIX_CFLAGS_COMPILE = "-Wno-cast-qual";
hardeningDisable = [ "format" ];
enableParallelBuilding = true;
passthru = { inherit withGurobi withCplex; };
meta = with lib; {
description = "An abstract base class to a generic linear programming (LP) solver";
homepage = "https://github.com/coin-or/Osi";
license = licenses.epl10;
platforms = platforms.unix;
maintainers = with maintainers; [ abbradar ];
};
}

27
pkgs/development/libraries/science/math/osqp/default.nix Normal file
View file

@ -0,0 +1,27 @@
{ lib, stdenv
, fetchFromGitHub
, cmake
}:
stdenv.mkDerivation rec {
pname = "osqp";
version = "0.6.2";
src = fetchFromGitHub {
owner = "oxfordcontrol";
repo = "osqp";
rev = "v${version}";
sha256 = "sha256-RYk3zuZrJXPcF27eMhdoZAio4DZ+I+nFaUEg1g/aLNk=";
fetchSubmodules = true;
};
nativeBuildInputs = [ cmake ];
meta = with lib; {
description = "A quadratic programming solver using operator splitting";
homepage = "https://osqp.org";
license = licenses.asl20;
maintainers = with maintainers; [ taktoa ];
platforms = platforms.all;
};
}

72
pkgs/development/libraries/science/math/p4est-sc/default.nix Normal file
View file

@ -0,0 +1,72 @@
{ lib, stdenv, fetchFromGitHub
, autoreconfHook, pkg-config
, p4est-sc-debugEnable ? true, p4est-sc-mpiSupport ? true
, mpi, openssh, zlib
}:
let
dbg = if debugEnable then "-dbg" else "";
debugEnable = p4est-sc-debugEnable;
mpiSupport = p4est-sc-mpiSupport;
isOpenmpi = mpiSupport && mpi.pname == "openmpi";
in
stdenv.mkDerivation {
pname = "p4est-sc${dbg}";
version = "unstable-2021-06-14";
# fetch an untagged snapshot of the prev3-develop branch
src = fetchFromGitHub {
owner = "cburstedde";
repo = "libsc";
rev = "1ae814e3fb1cc5456652e0d77550386842cb9bfb";
sha256 = "14vm0b162jh8399pgpsikbwq4z5lkrw9vfzy3drqykw09n6nc53z";
};
strictDeps = true;
nativeBuildInputs = [ autoreconfHook pkg-config ];
propagatedNativeBuildInputs = lib.optional mpiSupport mpi
++ lib.optional isOpenmpi openssh
;
propagatedBuildInputs = [ zlib ];
inherit debugEnable mpiSupport;
postPatch = ''
echo "dist_scaclocal_DATA += config/sc_v4l2.m4" >> Makefile.am
'';
preConfigure = ''
echo "2.8.0" > .tarball-version
${if mpiSupport then "unset CC" else ""}
'';
configureFlags = [ "--enable-pthread=-pthread" ]
++ lib.optional debugEnable "--enable-debug"
++ lib.optional mpiSupport "--enable-mpi"
;
dontDisableStatic = true;
enableParallelBuilding = true;
makeFlags = [ "V=0" ];
preCheck = ''
export OMPI_MCA_rmaps_base_oversubscribe=1
export HYDRA_IFACE=lo
'';
# disallow Darwin checks due to prototype incompatibility of qsort_r
# to be fixed in a future version of the source code
doCheck = !stdenv.isDarwin && stdenv.hostPlatform == stdenv.buildPlatform;
meta = {
branch = "prev3-develop";
description = "Support for parallel scientific applications";
longDescription = ''
The SC library provides support for parallel scientific applications.
Its main purpose is to support the p4est software library, hence
this package is called p4est-sc, but it works standalone, too.
'';
homepage = "https://www.p4est.org/";
downloadPage = "https://github.com/cburstedde/libsc.git";
license = lib.licenses.lgpl21Plus;
maintainers = [ lib.maintainers.cburstedde ];
};
}

59
pkgs/development/libraries/science/math/p4est/default.nix Normal file
View file

@ -0,0 +1,59 @@
{ lib, stdenv, fetchFromGitHub
, autoreconfHook, pkg-config
, p4est-withMetis ? true, metis
, p4est-sc
}:
let
inherit (p4est-sc) debugEnable mpiSupport;
dbg = if debugEnable then "-dbg" else "";
withMetis = p4est-withMetis;
in
stdenv.mkDerivation {
pname = "p4est${dbg}";
version = "unstable-2021-06-22";
# fetch an untagged snapshot of the prev3-develop branch
src = fetchFromGitHub {
owner = "cburstedde";
repo = "p4est";
rev = "7423ac5f2b2b64490a7a92e5ddcbd251053c4dee";
sha256 = "0vffnf48rzw6d0as4c3x1f31b4kapmdzr1hfj5rz5ngah72gqrph";
};
strictDeps = true;
nativeBuildInputs = [ autoreconfHook pkg-config ];
propagatedBuildInputs = [ p4est-sc ];
buildInputs = lib.optional withMetis metis;
inherit debugEnable mpiSupport withMetis;
patches = [ ./p4est-metis.patch ];
postPatch = ''
sed -i -e "s:\(^\s*ACLOCAL_AMFLAGS.*\)\s@P4EST_SC_AMFLAGS@\s*$:\1 -I ${p4est-sc}/share/aclocal:" Makefile.am
'';
preConfigure = ''
echo "2.8.0" > .tarball-version
${if mpiSupport then "unset CC" else ""}
'';
configureFlags = p4est-sc.configureFlags
++ [ "--with-sc=${p4est-sc}" ]
++ lib.optional withMetis "--with-metis"
;
inherit (p4est-sc) makeFlags dontDisableStatic enableParallelBuilding preCheck doCheck;
meta = {
branch = "prev3-develop";
description = "Parallel AMR on Forests of Octrees";
longDescription = ''
The p4est software library provides algorithms for parallel AMR.
AMR refers to Adaptive Mesh Refinement, a technique in scientific
computing to cover the domain of a simulation with an adaptive mesh.
'';
homepage = "https://www.p4est.org/";
downloadPage = "https://github.com/cburstedde/p4est.git";
license = lib.licenses.gpl2Plus;
maintainers = [ lib.maintainers.cburstedde ];
};
}

26
pkgs/development/libraries/science/math/p4est/p4est-metis.patch Normal file
View file

@ -0,0 +1,26 @@
diff --git a/src/p4est_connectivity.c b/src/p4est_connectivity.c
index 95339136..c93528f2 100644
--- a/src/p4est_connectivity.c
+++ b/src/p4est_connectivity.c
@@ -3715,6 +3715,7 @@ p4est_connectivity_reorder_newid (sc_MPI_Comm comm, int k,
sc_array_t * newid)
{
const int n = (int) conn->num_trees;
+ int metis_n;
int *xadj;
int *adjncy;
int *part;
@@ -3862,10 +3863,12 @@ p4est_connectivity_reorder_newid (sc_MPI_Comm comm, int k,
P4EST_GLOBAL_INFO ("Entering metis\n");
/* now call metis */
+ metis_n = n;
P4EST_EXECUTE_ASSERT_INT
- (METIS_PartGraphRecursive (&n, &ncon, xadj, adjncy, NULL, NULL,
+ (METIS_PartGraphRecursive (&metis_n, &ncon, xadj, adjncy, NULL, NULL,
NULL, &k, NULL, NULL, NULL, &volume, part),
METIS_OK);
+ P4EST_ASSERT (metis_n == n);
P4EST_GLOBAL_INFO ("Done metis\n");
P4EST_GLOBAL_STATISTICSF ("metis volume %d\n", volume);

34
pkgs/development/libraries/science/math/parmetis/default.nix Normal file
View file

@ -0,0 +1,34 @@
{ lib, stdenv
, fetchurl
, cmake
, mpi
}:
stdenv.mkDerivation rec {
pname = "parmetis";
version = "4.0.3";
src = fetchurl {
url = "http://glaros.dtc.umn.edu/gkhome/fetch/sw/parmetis/parmetis-${version}.tar.gz";
sha256 = "0pvfpvb36djvqlcc3lq7si0c5xpb2cqndjg8wvzg35ygnwqs5ngj";
};
nativeBuildInputs = [ cmake ];
buildInputs = [ mpi ];
# metis and GKlib are packaged with distribution
# AUR https://aur.archlinux.org/packages/parmetis/ has reported that
# it easier to build with the included packages as opposed to using the metis
# package. Compilation time is short.
configurePhase = ''
make config metis_path=$PWD/metis gklib_path=$PWD/metis/GKlib prefix=$out
'';
meta = with lib; {
description = "An MPI-based parallel library that implements a variety of algorithms for partitioning unstructured graphs, meshes, and for computing fill-reducing orderings of sparse matrices";
homepage = "http://glaros.dtc.umn.edu/gkhome/metis/parmetis/overview";
platforms = platforms.all;
license = licenses.unfree;
maintainers = [ maintainers.costrouc ];
};
}

84
pkgs/development/libraries/science/math/petsc/default.nix Normal file
View file

@ -0,0 +1,84 @@
{ lib
, stdenv
, fetchurl
, darwin
, gfortran
, python3
, blas
, lapack
, mpi # generic mpi dependency
, openssh # required for openmpi tests
, petsc-withp4est ? true
, p4est
, zlib # propagated by p4est but required by petsc
}:
# This version of PETSc does not support a non-MPI p4est build
assert petsc-withp4est -> p4est.mpiSupport;
stdenv.mkDerivation rec {
pname = "petsc";
version = "3.17.0";
src = fetchurl {
url = "http://ftp.mcs.anl.gov/pub/petsc/release-snapshots/petsc-${version}.tar.gz";
sha256 = "sha256-ltWspoThzhQliRpiDSeHc8JWEcsUQWWpOxdTEjjqr4o=";
};
mpiSupport = !withp4est || p4est.mpiSupport;
withp4est = petsc-withp4est;
strictDeps = true;
nativeBuildInputs = [ python3 gfortran ]
++ lib.optional mpiSupport mpi
++ lib.optional (mpiSupport && mpi.pname == "openmpi") openssh
;
buildInputs = [ blas lapack ]
++ lib.optional withp4est p4est
;
prePatch = lib.optionalString stdenv.isDarwin ''
substituteInPlace config/install.py \
--replace /usr/bin/install_name_tool ${darwin.cctools}/bin/install_name_tool
'';
preConfigure = ''
export FC="${gfortran}/bin/gfortran" F77="${gfortran}/bin/gfortran"
patchShebangs ./lib/petsc/bin
configureFlagsArray=(
$configureFlagsArray
${if !mpiSupport then ''
"--with-mpi=0"
'' else ''
"--CC=mpicc"
"--with-cxx=mpicxx"
"--with-fc=mpif90"
"--with-mpi=1"
''}
${if withp4est then ''
"--with-p4est=1"
"--with-zlib-include=${zlib.dev}/include"
"--with-zlib-lib=-L${zlib}/lib -lz"
'' else ""}
"--with-blas=1"
"--with-lapack=1"
)
'';
configureScript = "python ./configure";
# disable stackprotector on aarch64-darwin for now
# https://github.com/NixOS/nixpkgs/issues/158730
# see https://github.com/NixOS/nixpkgs/issues/127608 for a similar issue
hardeningDisable = lib.optionals (stdenv.isAarch64 && stdenv.isDarwin) [ "stackprotector" ];
enableParallelBuilding = true;
doCheck = stdenv.hostPlatform == stdenv.buildPlatform;
meta = with lib; {
description = "Portable Extensible Toolkit for Scientific computation";
homepage = "https://www.mcs.anl.gov/petsc/index.html";
license = licenses.bsd2;
maintainers = with maintainers; [ cburstedde ];
};
}

30
pkgs/development/libraries/science/math/planarity/default.nix Normal file
View file

@ -0,0 +1,30 @@
{ lib, stdenv
, fetchFromGitHub
, autoreconfHook
}:
stdenv.mkDerivation rec {
pname = "planarity";
version = "3.0.2.0";
src = fetchFromGitHub {
owner = "graph-algorithms";
repo = "edge-addition-planarity-suite";
rev = "Version_${version}";
sha256 = "sha256-cUAh2MXCSmtxFtV6iTHgSRgsq/26DjWwxhWJH1+367A=";
};
nativeBuildInputs = [
autoreconfHook
];
doCheck = true;
meta = with lib; {
homepage = "https://github.com/graph-algorithms/edge-addition-planarity-suite";
description = "A library for implementing graph algorithms";
license = licenses.bsd3;
maintainers = teams.sage.members;
platforms = platforms.unix;
};
}

27
pkgs/development/libraries/science/math/rankwidth/default.nix Normal file
View file

@ -0,0 +1,27 @@
{ lib, stdenv
, fetchurl
}:
stdenv.mkDerivation rec {
pname = "rankwidth";
version = "0.9";
src = fetchurl {
url = "mirror://sageupstream/rw/rw-${version}.tar.gz";
sha256 = "sha256-weA1Bv4lzfy0KMBR/Fay0q/7Wwb7o/LOdWYxRmvvtEE=";
};
configureFlags = [
"--enable-executable=no" # no igraph dependency
];
# check phase is empty for now (as of version 0.9)
doCheck = true;
meta = with lib; {
description = "Calculates rank-width and rank-decompositions";
license = with licenses; [ gpl2Plus ];
maintainers = teams.sage.members;
platforms = platforms.unix;
};
}

81
pkgs/development/libraries/science/math/rubiks/default.nix Normal file
View file

@ -0,0 +1,81 @@
{ lib, stdenv
, fetchurl
, fetchpatch
, coreutils
}:
stdenv.mkDerivation rec {
pname = "rubiks";
version = "20070912";
src = fetchurl {
url = "mirror://sageupstream/rubiks/rubiks-${version}.tar.bz2";
sha256 = "0zdmkb0j1kyspdpsszzb2k3279xij79jkx0dxd9f3ix1yyyg3yfq";
};
preConfigure = ''
export INSTALL="${coreutils}/bin/install"
'';
# everything is done in `make install`
buildPhase = "true";
installFlags = [
"PREFIX=$(out)"
];
patches = [
# Fix makefiles which use all the variables in all the wrong ways and
# hardcode values for some variables.
(fetchpatch {
url = "https://git.sagemath.org/sage.git/plain/build/pkgs/rubiks/patches/dietz-cu2-Makefile.patch?id=07d6c37d18811e2b377a9689790a7c5e24da16ba";
sha256 = "1ry3w1mk9q4jqd91zlaa1bdiiplld4hpfjaldbhlmzlgrrc99qmq";
})
(fetchpatch {
url = "https://git.sagemath.org/sage.git/plain/build/pkgs/rubiks/patches/dietz-mcube-Makefile.patch?id=07d6c37d18811e2b377a9689790a7c5e24da16ba";
sha256 = "0zsbh6k3kqdg82fv0kzghr1x7pafisv943gmssqscp107bhg77bz";
})
(fetchpatch {
url = "https://git.sagemath.org/sage.git/plain/build/pkgs/rubiks/patches/dietz-solver-Makefile.patch?id=07d6c37d18811e2b377a9689790a7c5e24da16ba";
sha256 = "0vhw70ylnmydgjhwx8jjlb2slccj4pfqn6vzirkyz1wp8apsmfhp";
})
(fetchpatch {
url = "https://git.sagemath.org/sage.git/plain/build/pkgs/rubiks/patches/reid-Makefile.patch?id=07d6c37d18811e2b377a9689790a7c5e24da16ba";
sha256 = "1r311sn012xs135s0d21qwsig2kld7rdcq19nm0zbnklviid57df";
})
];
meta = with lib; {
homepage = "https://wiki.sagemath.org/spkg/rubiks";
description = "Several programs for working with Rubik's cubes";
# The individual websites are no longer available
longDescription = ''
There are several programs for working with Rubik's cubes, by three
different people. Look inside the directories under /src to see
specific info and licensing. In summary the three contributers are:
Michael Reid (GPL) http://www.math.ucf.edu/~reid/Rubik/optimal_solver.html
optimal - uses many pre-computed tables to find an optimal
solution to the 3x3x3 Rubik's cube
Dik T. Winter (MIT License)
cube - uses Kociemba's algorithm to iteratively find a short
solution to the 3x3x3 Rubik's cube
size222 - solves a 2x2x2 Rubik's cube
Eric Dietz (GPL) http://www.wrongway.org/?rubiksource
cu2 - A fast, non-optimal 2x2x2 solver
cubex - A fast, non-optimal 3x3x3 solver
mcube - A fast, non-optimal 4x4x4 solver
'';
license = with licenses; [
gpl2 # Michael Reid's and Eric Dietz software
mit # Dik T. Winter's software
];
maintainers = teams.sage.members;
platforms = platforms.unix;
};
}

81
pkgs/development/libraries/science/math/scalapack/default.nix Normal file
View file

@ -0,0 +1,81 @@
{ lib, stdenv, fetchFromGitHub, fetchpatch, cmake, openssh
, mpi, blas, lapack
} :
assert blas.isILP64 == lapack.isILP64;
stdenv.mkDerivation rec {
pname = "scalapack";
version = "2.2.1";
src = fetchFromGitHub {
owner = "Reference-ScaLAPACK";
repo = pname;
rev = "v${version}";
sha256 = "sha256-GNVGWrIWdfyTfbz7c31Vjt9eDlVzCd/aLHoWq2DMyX4=";
};
passthru = { inherit (blas) isILP64; };
# upstream patch, remove with next release
patches = [ (fetchpatch {
name = "gcc-10";
url = "https://github.com/Reference-ScaLAPACK/scalapack/commit/a0f76fc0c1c16646875b454b7d6f8d9d17726b5a.patch";
sha256 = "0civn149ikghakic30bynqg1bal097hr7i12cm4kq3ssrhq073bp";
})];
# Required to activate ILP64.
# See https://github.com/Reference-ScaLAPACK/scalapack/pull/19
postPatch = lib.optionalString passthru.isILP64 ''
sed -i 's/INTSZ = 4/INTSZ = 8/g' TESTING/EIG/* TESTING/LIN/*
sed -i 's/INTGSZ = 4/INTGSZ = 8/g' TESTING/EIG/* TESTING/LIN/*
# These tests are not adapted to ILP64
sed -i '/xssep/d;/xsgsep/d;/xssyevr/d' TESTING/CMakeLists.txt
'';
nativeBuildInputs = [ cmake ];
checkInputs = [ openssh ];
buildInputs = [ blas lapack ];
propagatedBuildInputs = [ mpi ];
doCheck = true;
preConfigure = ''
cmakeFlagsArray+=(
-DBUILD_SHARED_LIBS=ON -DBUILD_STATIC_LIBS=OFF
-DLAPACK_LIBRARIES="-llapack"
-DBLAS_LIBRARIES="-lblas"
-DCMAKE_Fortran_COMPILER=${mpi}/bin/mpif90
${lib.optionalString passthru.isILP64 ''
-DCMAKE_Fortran_FLAGS="-fdefault-integer-8"
-DCMAKE_C_FLAGS="-DInt=long"
''}
)
'';
# Increase individual test timeout from 1500s to 10000s because hydra's builds
# sometimes fail due to this
checkFlagsArray = [ "ARGS=--timeout 10000" ];
preCheck = ''
# make sure the test starts even if we have less than 4 cores
export OMPI_MCA_rmaps_base_oversubscribe=1
# Fix to make mpich run in a sandbox
export HYDRA_IFACE=lo
# Run single threaded
export OMP_NUM_THREADS=1
export LD_LIBRARY_PATH=$LD_LIBRARY_PATH''${LD_LIBRARY_PATH:+:}`pwd`/lib
'';
meta = with lib; {
homepage = "http://www.netlib.org/scalapack/";
description = "Library of high-performance linear algebra routines for parallel distributed memory machines";
license = licenses.bsd3;
platforms = [ "x86_64-linux" ];
maintainers = with maintainers; [ costrouc markuskowa ];
};
}

52
pkgs/development/libraries/science/math/scs/default.nix Normal file
View file

@ -0,0 +1,52 @@
{ lib, stdenv, fetchFromGitHub, blas, lapack, gfortran, fixDarwinDylibNames }:
assert (!blas.isILP64) && (!lapack.isILP64);
stdenv.mkDerivation rec {
pname = "scs";
version = "3.2.0";
src = fetchFromGitHub {
owner = "cvxgrp";
repo = "scs";
rev = version;
sha256 = "sha256-ewn7AGNqTXY3bp5itHTfAQ2Es2ZAIbuRFM5U600Px50=";
};
# Actually link and add libgfortran to the rpath
postPatch = ''
substituteInPlace scs.mk \
--replace "#-lgfortran" "-lgfortran" \
--replace "gcc" "cc"
'';
nativeBuildInputs = lib.optional stdenv.isDarwin fixDarwinDylibNames;
buildInputs = [ blas lapack gfortran.cc.lib ];
doCheck = true;
# Test demo requires passing data and seed; numbers chosen arbitrarily.
postCheck = ''
./out/demo_socp_indirect 42 0.42 0.42 42
'';
installPhase = ''
runHook preInstall
mkdir -p $out/lib
cp -r include $out/
cp out/*.a out/*.so out/*.dylib $out/lib/
runHook postInstall
'';
meta = with lib; {
description = "Splitting Conic Solver";
longDescription = ''
Numerical optimization package for solving large-scale convex cone problems
'';
homepage = "https://github.com/cvxgrp/scs";
license = licenses.mit;
platforms = platforms.all;
maintainers = [ maintainers.bhipple ];
};
}

52
pkgs/development/libraries/science/math/spooles/default.nix Normal file
View file

@ -0,0 +1,52 @@
{ lib, stdenv, fetchurl, perl }:
stdenv.mkDerivation rec {
pname = "spooles";
version = "2.2";
src = fetchurl {
url = "http://www.netlib.org/linalg/spooles/spooles.${version}.tgz";
sha256 = "1pf5z3vvwd8smbpibyabprdvcmax0grzvx2y0liy98c7x6h5jid8";
};
sourceRoot = ".";
patches = [
./spooles.patch
];
postPatch = lib.optionalString stdenv.hostPlatform.isDarwin ''
substituteInPlace makefile --replace '-Wl,-soname' '-Wl,-install_name'
'';
buildPhase = ''
make lib
'';
installPhase = ''
mkdir -p $out/lib $out/include/spooles
cp libspooles.a libspooles.so.2.2 $out/lib/
ln -s libspooles.so.2.2 $out/lib/libspooles.so.2
ln -s libspooles.so.2 $out/lib/libspooles.so
for h in *.h; do
if [ $h != 'MPI.h' ]; then
cp $h $out/include/spooles
d=`basename $h .h`
if [ -d $d ]; then
mkdir $out/include/spooles/$d
cp $d/*.h $out/include/spooles/$d
fi
fi
done
'';
nativeBuildInputs = [ perl ];
meta = with lib; {
homepage = "http://www.netlib.org/linalg/spooles/";
description = "Library for solving sparse real and complex linear systems of equations";
license = licenses.publicDomain;
maintainers = with maintainers; [ gebner ];
platforms = platforms.unix;
};
}

188
pkgs/development/libraries/science/math/spooles/spooles.patch Normal file
View file

@ -0,0 +1,188 @@
diff --git a/I2Ohash/src/util.c b/I2Ohash/src/util.c
index 72d082e..f32f667 100644
--- a/I2Ohash/src/util.c
+++ b/I2Ohash/src/util.c
@@ -39,9 +39,10 @@ fflush(stdout) ;
*/
loc1 = (key1 + 1) % hashtable->nlist ;
loc2 = (key2 + 1) % hashtable->nlist ;
-loc = (loc1*loc2) % hashtable->nlist ;
+long int loc3 = (long int)loc1*(long int)loc2 % hashtable->nlist ;
+loc =(int) loc3;
#if MYDEBUG > 0
-fprintf(stdout, "\n loc1 = %d, loc2 = %d, loc3 = %d", loc1, loc2, loc) ;
+fprintf(stdout, "\n loc1 = %d, loc2 = %d, loc3 = %ld, loc = %d", loc1, loc2, loc3, loc) ;
fflush(stdout) ;
#endif
/*
@@ -158,9 +159,10 @@ fflush(stdout) ;
#endif
loc1 = (key1 + 1) % hashtable->nlist ;
loc2 = (key2 + 1) % hashtable->nlist ;
-loc = (loc1*loc2) % hashtable->nlist ;
+long int loc3 = (long int)loc1*(long int)loc2 % hashtable->nlist ;
+loc =(int) loc3;
#if MYDEBUG > 0
-fprintf(stdout, "\n loc1 = %d, loc2 = %d, loc3 = %d", loc1, loc2, loc) ;
+fprintf(stdout, "\n loc1 = %d, loc2 = %d, loc3 = %ld, loc = %d", loc1, loc2, loc3, loc) ;
fflush(stdout) ;
#endif
/*
diff --git a/MPI/makefile b/MPI/makefile
index 0c09f86..d25e70a 100644
--- a/MPI/makefile
+++ b/MPI/makefile
@@ -2,7 +2,7 @@ all_drivers :
cd drivers ; make drivers
lib :
- cd src ; make spoolesMPI.a
+ cd src ; make makeLib
clean :
cd src ; make clean
diff --git a/MPI/src/makefile b/MPI/src/makefile
index f7650b7..71e4c49 100644
--- a/MPI/src/makefile
+++ b/MPI/src/makefile
@@ -42,3 +42,8 @@ $(OBJ).a : \
clean :
- rm -f *.a *.o
+
+makeLib :
+ perl ../../makeLib > makeG
+ make -f makeG
+ rm -f makeG
diff --git a/MT/makefile b/MT/makefile
index 9b86a32..d25e70a 100644
--- a/MT/makefile
+++ b/MT/makefile
@@ -2,7 +2,7 @@ all_drivers :
cd drivers ; make drivers
lib :
- cd src ; make spoolesMT.a
+ cd src ; make makeLib
clean :
cd src ; make clean
diff --git a/Make.inc b/Make.inc
index f99eb8f..2de8a25 100644
--- a/Make.inc
+++ b/Make.inc
@@ -12,7 +12,7 @@
# for solaris
#
# CC = gcc
- CC = /usr/lang-4.0/bin/cc
+# CC = /usr/lang-4.0/bin/cc
#
# for sgi
#
@@ -28,7 +28,7 @@
#
# OPTLEVEL =
# OPTLEVEL = -g -v
- OPTLEVEL = -O
+ OPTLEVEL = -O3
# OPTLEVEL = -xO5 -v
# OPTLEVEL = -O3
# OPTLEVEL = -O4
@@ -43,7 +43,7 @@
# set any load flags
#
# LDFLAGS = -Wl,+parallel -Wl,+tm,spp2000 # for hp exemplar
- LDFLAGS =
+# LDFLAGS =
#
#---------------------------------------------------------------------
#
@@ -103,7 +103,7 @@
# MPI install library
#
# MPI_INSTALL_DIR =
- MPI_INSTALL_DIR = /usr/local/mpich-1.0.13
+# MPI_INSTALL_DIR = /usr/lib/openmpi
#
#---------------------------------------------------------------------
#
@@ -142,6 +142,6 @@
# MPI include path
#
# MPI_INCLUDE_DIR =
- MPI_INCLUDE_DIR = -I$(MPI_INSTALL_DIR)/include
+# MPI_INCLUDE_DIR = -I/usr/include/mpi
#
#---------------------------------------------------------------------
diff --git a/Utilities/src/iohb.c b/Utilities/src/iohb.c
index ac38f7b..ac34034 100644
--- a/Utilities/src/iohb.c
+++ b/Utilities/src/iohb.c
@@ -1725,7 +1725,7 @@ static void upcase(char* S)
static void IOHBTerminate(char* message)
{
- fprintf(stderr,message);
+ fputs(message, stderr);
exit(1);
}
diff --git a/makeLib b/makeLib
index 1780f39..7697b06 100755
--- a/makeLib
+++ b/makeLib
@@ -64,14 +64,19 @@ foreach $src ( @srcnames ) {
$srcname = " \\\n " . $src ;
print $srcname ;
}
+print "\n\n.SUFFIXES: .c .o .lo .a .so" ;
print "\n\nOBJ_FILES = \$\{SRC:.c=.o\}" ;
+print "\n\nLOBJ_FILES = \$\{SRC:.c=.lo\}" ;
print "\n\n" ;
print <<'EOF' ;
.c.o :
- $(PURIFY) $(CC) -c $(CFLAGS) $*.c -o $(OBJ)_$*.o
+ $(PURIFY) $(CC) -c $(CFLAGS) $*.c -o $(OBJ)_$*.o $(MPI_INCLUDE_DIR)
-../../spooles.a : ${OBJ_FILES}
- $(AR) $(ARFLAGS) ../../spooles.a $(OBJ)_*.o
+.c.lo :
+ $(PURIFY) $(CC) -c $(CFLAGS) $*.c -fPIC -DPIC -o $(OBJ)_$*.lo $(MPI_INCLUDE_DIR)
+
+../../libspooles.a : ${OBJ_FILES} ${LOBJ_FILES}
+ $(AR) $(ARFLAGS) ../../libspooles.a $(OBJ)_*.o
rm -f $(OBJ)_*.o
- $(RANLIB) ../../spooles.a
+ $(RANLIB) ../../libspooles.a
EOF
diff --git a/makefile b/makefile
index f014c7d..7c8042a 100755
--- a/makefile
+++ b/makefile
@@ -124,7 +124,9 @@ lib :
cd ZV ; make lib
cd misc ; make lib
#cd MPI ; make lib
-#cd MT ; make lib
+ cd MT ; make lib
+ $(CC) -shared */*/*.lo -Wl,-soname,libspooles.so.2.2 -o libspooles.so.2.2 -lpthread -lm
+ ln -s libspooles.so.2.2 libspooles.so
global :
cd A2/src ; make -f makeGlobalLib
diff --git a/timings.h b/timings.h
index 23df189..685800b 100644
--- a/timings.h
+++ b/timings.h
@@ -2,9 +2,8 @@
#define _TIMINGS_
#include <sys/time.h>
static struct timeval TV ;
-static struct timezone TZ ;
#define MARKTIME(t) \
- gettimeofday(&TV, &TZ) ; \
+ gettimeofday(&TV, NULL) ; \
t = (TV.tv_sec + 0.000001*TV.tv_usec)
#endif

32
pkgs/development/libraries/science/math/suitesparse-graphblas/default.nix Normal file
View file

@ -0,0 +1,32 @@
{ lib, stdenv
, fetchFromGitHub
, cmake
, gnum4
}:
stdenv.mkDerivation rec {
pname = "suitesparse-graphblas";
version = "6.2.5";
outputs = [ "out" "dev" ];
src = fetchFromGitHub {
owner = "DrTimothyAldenDavis";
repo = "GraphBLAS";
rev = "v${version}";
sha256 = "sha256-N4yFlTxV+lVz70PSHPuWEEFLp0dpsImXYDLUYEo2JQI=";
};
nativeBuildInputs = [
cmake
gnum4
];
meta = with lib; {
description = "Graph algorithms in the language of linear algebra";
homepage = "http://faculty.cse.tamu.edu/davis/GraphBLAS.html";
license = licenses.asl20;
maintainers = with maintainers; [];
platforms = with platforms; unix;
};
}

43
pkgs/development/libraries/science/math/suitesparse/4.2.nix Normal file
View file

@ -0,0 +1,43 @@
{ lib, stdenv, fetchurl, gfortran, blas, lapack }:
let
int_t = if blas.isILP64 then "int64_t" else "int32_t";
in
stdenv.mkDerivation rec {
version = "4.2.1";
pname = "suitesparse";
src = fetchurl {
url = "http://www.cise.ufl.edu/research/sparse/SuiteSparse/SuiteSparse-${version}.tar.gz" ;
sha256 = "1ga69637x7kdkiy3w3lq9dvva7220bdangv2lch2wx1hpi83h0p8";
};
nativeBuildInputs = [ gfortran ];
buildInputs = [ blas lapack ];
preConfigure = ''
mkdir -p $out/lib
mkdir -p $out/include
sed -i "SuiteSparse_config/SuiteSparse_config.mk" \
-e 's/METIS .*$/METIS =/' \
-e 's/METIS_PATH .*$/METIS_PATH =/' \
-e '/CHOLMOD_CONFIG/ s/$/-DNPARTITION -DLONGBLAS=${int_t}/' \
-e '/UMFPACK_CONFIG/ s/$/-DLONGBLAS=${int_t}/'
'';
makeFlags = [
"PREFIX=\"$(out)\""
"INSTALL_LIB=$(out)/lib"
"INSTALL_INCLUDE=$(out)/include"
"BLAS=-lblas"
"LAPACK=-llapack"
];
meta = with lib; {
homepage = "http://faculty.cse.tamu.edu/davis/suitesparse.html";
description = "A suite of sparse matrix algorithms";
license = with licenses; [ bsd2 gpl2Plus lgpl21Plus ];
maintainers = with maintainers; [ ttuegel ];
platforms = with platforms; unix;
};
}

98
pkgs/development/libraries/science/math/suitesparse/4.4.nix Normal file
View file

@ -0,0 +1,98 @@
{ lib, stdenv, fetchurl, gfortran, blas, lapack
, enableCuda ? false, cudatoolkit
}:
let
int_t = if blas.isILP64 then "int64_t" else "int32_t";
SHLIB_EXT = stdenv.hostPlatform.extensions.sharedLibrary;
in
stdenv.mkDerivation rec {
version = "4.4.4";
pname = "suitesparse";
src = fetchurl {
url = "http://faculty.cse.tamu.edu/davis/SuiteSparse/SuiteSparse-${version}.tar.gz";
sha256 = "1zdn1y0ij6amj7smmcslkqgbqv9yy5cwmbyzqc9v6drzdzllgbpj";
};
preConfigure = ''
mkdir -p $out/lib
mkdir -p $out/include
sed -i "SuiteSparse_config/SuiteSparse_config.mk" \
-e 's/METIS .*$/METIS =/' \
-e 's/METIS_PATH .*$/METIS_PATH =/' \
-e '/CHOLMOD_CONFIG/ s/$/-DNPARTITION -DLONGBLAS=${int_t}/' \
-e '/UMFPACK_CONFIG/ s/$/-DLONGBLAS=${int_t}/'
''
+ lib.optionalString stdenv.isDarwin ''
sed -i "SuiteSparse_config/SuiteSparse_config.mk" \
-e 's/^[[:space:]]*\(LIB = -lm\) -lrt/\1/'
''
+ lib.optionalString enableCuda ''
sed -i "SuiteSparse_config/SuiteSparse_config.mk" \
-e 's|^[[:space:]]*\(CUDA_ROOT =\)|CUDA_ROOT = ${cudatoolkit}|' \
-e 's|^[[:space:]]*\(GPU_BLAS_PATH =\)|GPU_BLAS_PATH = $(CUDA_ROOT)|' \
-e 's|^[[:space:]]*\(GPU_CONFIG =\)|GPU_CONFIG = -I$(CUDA_ROOT)/include -DGPU_BLAS -DCHOLMOD_OMP_NUM_THREADS=$(NIX_BUILD_CORES) |' \
-e 's|^[[:space:]]*\(CUDA_PATH =\)|CUDA_PATH = $(CUDA_ROOT)|' \
-e 's|^[[:space:]]*\(CUDART_LIB =\)|CUDART_LIB = $(CUDA_ROOT)/lib64/libcudart.so|' \
-e 's|^[[:space:]]*\(CUBLAS_LIB =\)|CUBLAS_LIB = $(CUDA_ROOT)/lib64/libcublas.so|' \
-e 's|^[[:space:]]*\(CUDA_INC_PATH =\)|CUDA_INC_PATH = $(CUDA_ROOT)/include/|' \
-e 's|^[[:space:]]*\(NV20 =\)|NV20 = -arch=sm_20 -Xcompiler -fPIC|' \
-e 's|^[[:space:]]*\(NV30 =\)|NV30 = -arch=sm_30 -Xcompiler -fPIC|' \
-e 's|^[[:space:]]*\(NV35 =\)|NV35 = -arch=sm_35 -Xcompiler -fPIC|' \
-e 's|^[[:space:]]*\(NVCC =\) echo|NVCC = $(CUDA_ROOT)/bin/nvcc|' \
-e 's|^[[:space:]]*\(NVCCFLAGS =\)|NVCCFLAGS = $(NV20) -O3 -gencode=arch=compute_20,code=sm_20 -gencode=arch=compute_30,code=sm_30 -gencode=arch=compute_35,code=sm_35 -gencode=arch=compute_60,code=sm_60|'
'';
makeFlags = [
"PREFIX=\"$(out)\""
"INSTALL_LIB=$(out)/lib"
"INSTALL_INCLUDE=$(out)/include"
"BLAS=-lblas"
"LAPACK=-llapack"
];
NIX_CFLAGS_COMPILE = lib.optionalString stdenv.isDarwin " -DNTIMER";
postInstall = ''
# Build and install shared library
(
cd "$(mktemp -d)"
for i in "$out"/lib/lib*.a; do
ar -x $i
done
${if enableCuda then cudatoolkit else stdenv.cc.outPath}/bin/${if enableCuda then "nvcc" else "cc"} *.o ${if stdenv.isDarwin then "-dynamiclib" else "--shared"} -o "$out/lib/libsuitesparse${SHLIB_EXT}" -lblas ${lib.optionalString enableCuda "-lcublas"}
)
for i in umfpack cholmod amd camd colamd spqr; do
ln -s libsuitesparse${SHLIB_EXT} "$out"/lib/lib$i${SHLIB_EXT}
done
# Install documentation
outdoc=$out/share/doc/suitesparse-${version}
mkdir -p $outdoc
cp -r AMD/Doc $outdoc/amd
cp -r BTF/Doc $outdoc/bft
cp -r CAMD/Doc $outdoc/camd
cp -r CCOLAMD/Doc $outdoc/ccolamd
cp -r CHOLMOD/Doc $outdoc/cholmod
cp -r COLAMD/Doc $outdoc/colamd
cp -r CXSparse/Doc $outdoc/cxsparse
cp -r KLU/Doc $outdoc/klu
cp -r LDL/Doc $outdoc/ldl
cp -r RBio/Doc $outdoc/rbio
cp -r SPQR/Doc $outdoc/spqr
cp -r UMFPACK/Doc $outdoc/umfpack
'';
nativeBuildInputs = [ gfortran ];
buildInputs = [ blas lapack ];
meta = with lib; {
homepage = "http://faculty.cse.tamu.edu/davis/suitesparse.html";
description = "A suite of sparse matrix algorithms";
license = with licenses; [ bsd2 gpl2Plus lgpl21Plus ];
maintainers = with maintainers; [ ttuegel ];
platforms = with platforms; unix;
};
}

74
pkgs/development/libraries/science/math/suitesparse/default.nix Normal file
View file

@ -0,0 +1,74 @@
{ lib, stdenv
, fetchFromGitHub
, gfortran
, blas, lapack
, metis
, fixDarwinDylibNames
, gmp
, mpfr
, enableCuda ? false
, cudatoolkit
}:
stdenv.mkDerivation rec {
pname = "suitesparse";
version = "5.11.0";
outputs = [ "out" "dev" "doc" ];
src = fetchFromGitHub {
owner = "DrTimothyAldenDavis";
repo = "SuiteSparse";
rev = "v${version}";
sha256 = "sha256-AM16ngJ/CoSV6BOb80Pi9EqWoRILryOO4Rk+S5DffLU=";
};
nativeBuildInputs = [
] ++ lib.optional stdenv.isDarwin fixDarwinDylibNames;
# Use compatible indexing for lapack and blas used
buildInputs = assert (blas.isILP64 == lapack.isILP64); [
blas lapack
metis
gfortran.cc.lib
gmp
mpfr
] ++ lib.optional enableCuda cudatoolkit;
preConfigure = ''
# Mongoose and GraphBLAS are packaged separately
sed -i "Makefile" -e '/GraphBLAS\|Mongoose/d'
'';
makeFlags = [
"INSTALL=${placeholder "out"}"
"INSTALL_INCLUDE=${placeholder "dev"}/include"
"JOBS=$(NIX_BUILD_CORES)"
"MY_METIS_LIB=-lmetis"
] ++ lib.optionals blas.isILP64 [
"CFLAGS=-DBLAS64"
] ++ lib.optionals enableCuda [
"CUDA_PATH=${cudatoolkit}"
"CUDART_LIB=${cudatoolkit.lib}/lib/libcudart.so"
"CUBLAS_LIB=${cudatoolkit}/lib/libcublas.so"
] ++ lib.optionals stdenv.isDarwin [
# Unless these are set, the build will attempt to use `Accelerate` on darwin, see:
# https://github.com/DrTimothyAldenDavis/SuiteSparse/blob/v5.11.0/SuiteSparse_config/SuiteSparse_config.mk#L368
"BLAS=-lblas"
"LAPACK=-llapack"
]
;
buildFlags = [
# Build individual shared libraries, not demos
"library"
];
meta = with lib; {
homepage = "http://faculty.cse.tamu.edu/davis/suitesparse.html";
description = "A suite of sparse matrix algorithms";
license = with licenses; [ bsd2 gpl2Plus lgpl21Plus ];
maintainers = with maintainers; [ ttuegel ];
platforms = with platforms; unix;
};
}

7
pkgs/development/libraries/science/math/superlu/add-superlu-lib-as-dependency-for-the-unit-tests.patch Normal file
View file

@ -0,0 +1,7 @@
--- a/TESTING/MATGEN/CMakeLists.txt
+++ b/TESTING/MATGEN/CMakeLists.txt
@@ -97,3 +97,4 @@ if(enable_complex16)
endif()
add_library(matgen ${sources})
+target_link_libraries(matgen superlu)

37
pkgs/development/libraries/science/math/superlu/default.nix Normal file
View file

@ -0,0 +1,37 @@
{ lib, stdenv, fetchurl, cmake,
gfortran, blas, lapack}:
assert (!blas.isILP64) && (!lapack.isILP64);
stdenv.mkDerivation rec {
version = "5.2.1";
pname = "superlu";
src = fetchurl {
url = "http://crd-legacy.lbl.gov/~xiaoye/SuperLU/superlu_${version}.tar.gz";
sha256 = "0qzlb7cd608q62kyppd0a8c65l03vrwqql6gsm465rky23b6dyr8";
};
nativeBuildInputs = [ cmake gfortran ];
propagatedBuildInputs = [ blas ];
cmakeFlags = [
"-DBUILD_SHARED_LIBS=true"
"-DUSE_XSDK_DEFAULTS=true"
];
patches = [
./add-superlu-lib-as-dependency-for-the-unit-tests.patch
];
doCheck = true;
checkTarget = "test";
meta = {
homepage = "http://crd-legacy.lbl.gov/~xiaoye/SuperLU/";
license = "http://crd-legacy.lbl.gov/~xiaoye/SuperLU/License.txt";
description = "A library for the solution of large, sparse, nonsymmetric systems of linear equations";
platforms = lib.platforms.unix;
};
}

39
pkgs/development/libraries/science/math/sympow/clean-extra-logfile-output-from-pari.patch Normal file
View file

@ -0,0 +1,39 @@
commit 433a8b99da9d71e96434bd421c2468cbda29d37c
Author: Mauricio Collares <mauricio@collares.org>
Date: Tue Mar 2 22:07:11 2021 -0300
trim logfile information from pari 2.13 output
Pari (since commit 609fb01faf827d91dfa9136849a647a3bbfe8036) prints
extra logfile information such as
[logfile is "/tmp/nix-shell.2BquN9/home/.sympow/datafiles/P02HM.txt"]
which messes up sympow's parsing. This commit reuses the same trimming
mechanism already in sympow to trim this new message.
diff --git a/Configure b/Configure
index 1ef9756..776bec2 100755
--- a/Configure
+++ b/Configure
@@ -322,7 +322,7 @@ echo "datafiles/param_data: \$(OTHERb)" >> $FILE
echo " \$(MKDIR) -p datafiles" >> $FILE
echo " \$(TOUCH) datafiles/param_data" >> $FILE
echo " \$(SH) armd.sh" >> $FILE
-echo " \$(SED) -i -e '/logfile =/d' datafiles/*.txt" >> $FILE
+echo " \$(SED) -i -e '/logfile /d' datafiles/*.txt" >> $FILE
echo "sympow.1: sympow" >> $FILE
echo " \$(HELP2MAN) \$(H2MFLAGS) -s 1 -n \"SYMPOW program\" -I sympow.h2m -o \$@ ./\$<" >> $FILE
echo "clean:" >> $FILE
diff --git a/generate.c b/generate.c
index dbb811f..783320c 100644
--- a/generate.c
+++ b/generate.c
@@ -148,6 +148,7 @@ static void trimit(char *A)
" -e '"
"/^\?/d" ";"
"/^(/d" ";"
+ "/logfile /d" ";"
"/Warning:/d" ";"
"/^About to find TOO_BIG/d" ";"
"/^Now working backwards/d" ";"

76
pkgs/development/libraries/science/math/sympow/default.nix Normal file
View file

@ -0,0 +1,76 @@
{ lib, stdenv
, fetchFromGitLab
, makeWrapper
, which
, autoconf
, help2man
, file
, pari
}:
stdenv.mkDerivation rec {
version = "2.023.6";
pname = "sympow";
src = fetchFromGitLab {
group = "rezozer";
owner = "forks";
repo = "sympow";
rev = "v${version}";
sha256 = "132l0xv00ld1svvv9wh99wfra4zzjv2885h2sq0dsl98wiyvi5zl";
};
patches = [ ./clean-extra-logfile-output-from-pari.patch ];
postUnpack = ''
patchShebangs .
'';
nativeBuildInputs = [
makeWrapper
which
autoconf
help2man
file
pari
];
configurePhase = ''
runHook preConfigure
export PREFIX="$out"
export VARPREFIX="$out" # see comment on postInstall
./Configure # doesn't take any options
runHook postConfigure
'';
# Usually, sympow has 3 levels of caching: statically distributed in /usr/,
# shared in /var and per-user in ~/.sympow. The shared cache assumes trust in
# other users and a shared /var is not compatible with nix's approach, so we
# set VARPREFIX to the read-only $out. This effectively disables shared
# caching. See https://trac.sagemath.org/ticket/3360#comment:36 and sympow's
# README for more details on caching.
# sympow will complain at runtime about the lack of write-permissions on the
# shared cache. We pass the `-quiet` flag by default to disable this.
postInstall = ''
wrapProgram "$out/bin/sympow" --add-flags '-quiet'
'';
# Example from the README as a sanity check.
doInstallCheck = true;
installCheckPhase = ''
export HOME="$TMP/home"
mkdir -p "$HOME"
"$out/bin/sympow" -sp 2p16 -curve "[1,2,3,4,5]" | grep '8.3705'
'';
meta = with lib; {
description = "Compute special values of symmetric power elliptic curve L-functions";
license = {
shortName = "sympow";
fullName = "Custom, BSD-like. See COPYING file.";
free = true;
};
maintainers = teams.sage.members;
platforms = platforms.linux;
};
}

Some files were not shown because too many files have changed in this diff Show more