diff options
Diffstat (limited to 'nixpkgs/pkgs/development/libraries/science/math')
59 files changed, 3490 insertions, 0 deletions
diff --git a/nixpkgs/pkgs/development/libraries/science/math/QuadProgpp/default.nix b/nixpkgs/pkgs/development/libraries/science/math/QuadProgpp/default.nix new file mode 100644 index 000000000000..b5fa5c8825e0 --- /dev/null +++ b/nixpkgs/pkgs/development/libraries/science/math/QuadProgpp/default.nix @@ -0,0 +1,27 @@ +{ stdenv, fetchFromGitHub, cmake }: + +stdenv.mkDerivation rec { + pname = "QuadProgpp"; + version = "4b6bd65f09fbff99c172a86d6e96ca74449b323f"; + + src = fetchFromGitHub { + owner = "liuq"; + repo = "QuadProgpp"; + rev = version; + sha256 = "02r0dlk2yjpafknvm945vbgs4sl26w2i1gw3pllar9hi364y8hnx"; + }; + + nativeBuildInputs = [ cmake ]; + buildInputs = [ ]; + + meta = with stdenv.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 = with platforms; linux; + }; +} diff --git a/nixpkgs/pkgs/development/libraries/science/math/arpack/default.nix b/nixpkgs/pkgs/development/libraries/science/math/arpack/default.nix new file mode 100644 index 000000000000..a5fbb679df5b --- /dev/null +++ b/nixpkgs/pkgs/development/libraries/science/math/arpack/default.nix @@ -0,0 +1,58 @@ +{ stdenv, fetchFromGitHub, cmake +, gfortran, blas, lapack, eigen }: + +with stdenv.lib; + +let + version = "3.7.0"; +in +stdenv.mkDerivation { + pname = "arpack"; + inherit version; + + src = fetchFromGitHub { + owner = "opencollab"; + repo = "arpack-ng"; + rev = version; + sha256 = "1x7a1dj3dg43nlpvjlh8jzzbadjyr3mbias6f0256qkmgdyk4izr"; + }; + + nativeBuildInputs = [ cmake ]; + buildInputs = [ gfortran blas lapack eigen ]; + + doCheck = true; + + BLAS_LIBS = "-L${blas}/lib -lblas"; + LAPACK_LIBS = "-L${lapack}/lib -llapack"; + + cmakeFlags = [ + "-DBUILD_SHARED_LIBS=ON" + "-DINTERFACE64=${optionalString blas.is64bit "1"}" + ]; + + preCheck = if stdenv.isDarwin then '' + export DYLD_LIBRARY_PATH=$DYLD_LIBRARY_PATH''${DYLD_LIBRARY_PATH:+:}`pwd`/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 + ''; + + postInstall = '' + mkdir -p $out/lib/pkgconfig + cp arpack.pc $out/lib/pkgconfig/ + ''; + + + meta = { + homepage = "https://github.com/opencollab/arpack-ng"; + description = '' + A collection of Fortran77 subroutines to solve large scale eigenvalue + problems. + ''; + license = stdenv.lib.licenses.bsd3; + maintainers = [ stdenv.lib.maintainers.ttuegel ]; + platforms = stdenv.lib.platforms.unix; + }; +} diff --git a/nixpkgs/pkgs/development/libraries/science/math/blas/default.nix b/nixpkgs/pkgs/development/libraries/science/math/blas/default.nix new file mode 100644 index 000000000000..c240a19cca67 --- /dev/null +++ b/nixpkgs/pkgs/development/libraries/science/math/blas/default.nix @@ -0,0 +1,71 @@ +{ stdenv, fetchurl, gfortran }: + +stdenv.mkDerivation rec { + pname = "blas"; + version = "3.8.0"; + + src = fetchurl { + url = "http://www.netlib.org/blas/${pname}-${version}.tgz"; + sha256 = "1s24iry5197pskml4iygasw196bdhplj0jmbsb9jhabcjqj2mpsm"; + }; + + buildInputs = [ gfortran ]; + + configurePhase = '' + echo >make.inc "SHELL = ${stdenv.shell}" + echo >>make.inc "PLAT = _LINUX" + echo >>make.inc "FORTRAN = gfortran" + echo >>make.inc "OPTS = -O2 -fPIC" + echo >>make.inc "DRVOPTS = $$(OPTS)" + echo >>make.inc "NOOPT = -O0 -fPIC" + echo >>make.inc "LOADER = gfortran" + echo >>make.inc "LOADOPTS =" + echo >>make.inc "ARCH = gfortran" + echo >>make.inc "ARCHFLAGS = -shared -o" + echo >>make.inc "RANLIB = echo" + echo >>make.inc "BLASLIB = libblas.so.${version}" + ''; + + buildPhase = '' + make + echo >>make.inc "ARCHFLAGS = " + echo >>make.inc "BLASLIB = libblas.a" + echo >>make.inc "ARCH = ar rcs" + echo >>make.inc "RANLIB = ranlib" + make + ''; + + installPhase = + # FreeBSD's stdenv doesn't use Coreutils. + let dashD = if stdenv.isFreeBSD then "" else "-D"; in + (stdenv.lib.optionalString stdenv.isFreeBSD "mkdir -p $out/lib ;") + + '' + install ${dashD} -m755 libblas.a "$out/lib/libblas.a" + install ${dashD} -m755 libblas.so.${version} "$out/lib/libblas.so.${version}" + ln -s libblas.so.${version} "$out/lib/libblas.so.3" + ln -s libblas.so.${version} "$out/lib/libblas.so" + # Write pkgconfig alias. + # See also openblas/default.nix + mkdir $out/lib/pkgconfig + cat <<EOF > $out/lib/pkgconfig/blas.pc +Name: blas +Version: ${version} +Description: blas provided by the BLAS package. +Libs: -L$out/lib -lblas +EOF + ''; + + preFixup = stdenv.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 = { + description = "Basic Linear Algebra Subprograms"; + license = stdenv.lib.licenses.publicDomain; + homepage = "http://www.netlib.org/blas/"; + platforms = stdenv.lib.platforms.unix; + }; +} diff --git a/nixpkgs/pkgs/development/libraries/science/math/brial/default.nix b/nixpkgs/pkgs/development/libraries/science/math/brial/default.nix new file mode 100644 index 000000000000..90d7357cc07e --- /dev/null +++ b/nixpkgs/pkgs/development/libraries/science/math/brial/default.nix @@ -0,0 +1,46 @@ +{ stdenv +, fetchFromGitHub +, autoreconfHook +, pkgconfig +, boost +, m4ri +, gd +}: + +stdenv.mkDerivation rec { + version = "1.2.8"; + pname = "brial"; + + src = fetchFromGitHub { + owner = "BRiAl"; + repo = "BRiAl"; + rev = version; + sha256 = "0qhgckd4fvbs40jw14mvw89rccv94d3df27kipd27hxd4cx7y80y"; + }; + + # FIXME package boost-test and enable checks + doCheck = false; + + configureFlags = [ + "--with-boost-unit-test-framework=no" + ]; + + buildInputs = [ + boost + m4ri + gd + ]; + + nativeBuildInputs = [ + autoreconfHook + pkgconfig + ]; + + meta = with stdenv.lib; { + homepage = "https://github.com/BRiAl/BRiAl"; + description = "Legacy version of PolyBoRi maintained by sagemath developers"; + license = licenses.gpl2Plus; + maintainers = with maintainers; [ timokau ]; + platforms = platforms.unix; + }; +} diff --git a/nixpkgs/pkgs/development/libraries/science/math/caffe2/default.nix b/nixpkgs/pkgs/development/libraries/science/math/caffe2/default.nix new file mode 100644 index 000000000000..7755efb30658 --- /dev/null +++ b/nixpkgs/pkgs/development/libraries/science/math/caffe2/default.nix @@ -0,0 +1,144 @@ +{ stdenv, lib, config, fetchFromGitHub +, cmake +, glog, gflags, gtest +, protobuf, snappy +, python, future, six, python-protobuf, numpy, pydot +, eigen +, doxygen +, useCuda ? (config.cudaSupport or false), cudatoolkit ? null +, useCudnn ? (config.cudnnSupport or false), cudnn ? null +, useOpenmp ? false, openmp ? null +, useOpencv3 ? true, opencv3 ? null +, useLeveldb ? false, leveldb ? null +, useLmdb ? true, lmdb ? null +, useRocksdb ? false, rocksdb ? null +, useZeromq ? false, zeromq ? null +, useMpi ? false, mpi ? null +# TODO: distributed computations +#, useGloo ? false +#, useNccl ? false +#, useNnpack ? false +}: + +assert useCuda -> cudatoolkit != null; +assert useCudnn -> (useCuda && cudnn != null); +assert useOpencv3 -> opencv3 != null; +assert useLeveldb -> leveldb != null; +assert useLmdb -> lmdb != null; +assert useRocksdb -> rocksdb != null; +assert useZeromq -> zeromq != null; +assert useMpi -> mpi != null; + +let + # Third party modules that caffe2 holds as git submodules. + # Download them and create symlinks from caffe2/third_party. + installExtraSrc = extra: '' + rmdir "third_party/${extra.dst}" + ln -s "${extra.src}" "third_party/${extra.dst}" + ''; + + cub = { + src = fetchFromGitHub { + owner = "NVlabs"; + repo = "cub"; + rev = "v1.7.4"; + sha256 = "0ksd5n1lxqhm5l5cd2lps4cszhjkf6gmzahaycs7nxb06qci8c66"; + }; + dst = "cub"; + }; + + pybind11 = { + src = fetchFromGitHub { + owner = "pybind"; + repo = "pybind11"; + rev = "86e2ad4f77442c3350f9a2476650da6bee253c52"; + sha256 = "05gi58dirvc8fgm0avpydvidzsbh2zrzgfaq671ym09f6dz0bcgz"; + }; + dst = "pybind11"; + }; + + ccVersion = lib.getVersion stdenv.cc; +in + +stdenv.mkDerivation rec { + pname = "caffe2"; + version = "0.8.1"; + src = fetchFromGitHub { + owner = "caffe2"; + repo = "caffe2"; + rev = "v${version}"; + sha256 = "18y7zjc69j6n5642l9caddl641b0djf3pjn4wacdsc1wk1jiyqk8"; + }; + + nativeBuildInputs = [ cmake doxygen gtest ]; + outputs = [ "bin" "out" ]; + propagatedBuildOutputs = [ ]; # otherwise propagates out -> bin cycle + + buildInputs = [ glog gflags protobuf snappy eigen ] + ++ lib.optional useCuda cudatoolkit + ++ lib.optional useCudnn cudnn + ++ lib.optional useOpenmp openmp + ++ lib.optional useOpencv3 opencv3 + ++ lib.optional useLeveldb leveldb + ++ lib.optional useLmdb lmdb + ++ lib.optional useRocksdb rocksdb + ++ lib.optional useZeromq zeromq + ; + propagatedBuildInputs = [ numpy future six python-protobuf pydot ]; + + patches = lib.optional (stdenv.cc.isGNU && lib.versionAtLeast ccVersion "7.0.0") [ + ./fix_compilation_on_gcc7.patch + ] ++ lib.optional stdenv.cc.isClang [ ./update_clang_cvtsh_bugfix.patch ]; + + cmakeFlags = [ ''-DBUILD_TEST=OFF'' + ''-DBUILD_PYTHON=ON'' + ''-DUSE_CUDA=${if useCuda then ''ON''else ''OFF''}'' + ''-DUSE_OPENMP=${if useOpenmp then ''ON''else ''OFF''}'' + ''-DUSE_OPENCV=${if useOpencv3 then ''ON''else ''OFF''}'' + ''-DUSE_MPI=${if useMpi then ''ON''else ''OFF''}'' + ''-DUSE_LEVELDB=${if useLeveldb then ''ON''else ''OFF''}'' + ''-DUSE_LMDB=${if useLmdb then ''ON''else ''OFF''}'' + ''-DUSE_ROCKSDB=${if useRocksdb then ''ON''else ''OFF''}'' + ''-DUSE_ZMQ=${if useZeromq then ''ON''else ''OFF''}'' + ''-DUSE_GLOO=OFF'' + ''-DUSE_NNPACK=OFF'' + ''-DUSE_NCCL=OFF'' + ''-DUSE_REDIS=OFF'' + ''-DUSE_FFMPEG=OFF'' + ] + ++ lib.optional useCuda [ + ''-DCUDA_TOOLKIT_ROOT_DIR=${cudatoolkit}'' + ''-DCUDA_FAST_MATH=ON'' + ''-DCUDA_HOST_COMPILER=${cudatoolkit.cc}/bin/gcc'' + ]; + + preConfigure = '' + ${installExtraSrc cub} + ${installExtraSrc pybind11} + # XXX hack + export NIX_CFLAGS_COMPILE="-I ${eigen}/include/eigen3/ $NIX_CFLAGS_COMPILE" + ''; + + postInstall = '' + moveToOutput "bin" "$bin" + mkdir -p $out/lib/${python.libPrefix} + ln -s $out/ $out/${python.sitePackages} + ''; + + doCheck = false; + enableParallelBuilding = true; + + meta = { + homepage = "https://caffe2.ai/"; + description = "A new lightweight, modular, and scalable deep learning framework"; + longDescription = '' + Caffe2 aims to provide an easy and straightforward way for you to experiment + with deep learning and leverage community contributions of new models and + algorithms. You can bring your creations to scale using the power of GPUs in the + cloud or to the masses on mobile with Caffe2's cross-platform libraries. + ''; + platforms = with stdenv.lib.platforms; linux; + license = stdenv.lib.licenses.asl20; + maintainers = with stdenv.lib.maintainers; [ yuriaisaka ]; + }; +} diff --git a/nixpkgs/pkgs/development/libraries/science/math/caffe2/fix_compilation_on_gcc7.patch b/nixpkgs/pkgs/development/libraries/science/math/caffe2/fix_compilation_on_gcc7.patch new file mode 100644 index 000000000000..f319f20233a2 --- /dev/null +++ b/nixpkgs/pkgs/development/libraries/science/math/caffe2/fix_compilation_on_gcc7.patch @@ -0,0 +1,46 @@ +diff --git a/caffe2/operators/recurrent_network_op.cc b/caffe2/operators/recurrent_network_op.cc +index dd4fded..5995e8a 100644 +--- a/caffe2/operators/recurrent_network_op.cc ++++ b/caffe2/operators/recurrent_network_op.cc +@@ -1,4 +1,4 @@ +-#include "recurrent_network_op.h" ++#include "caffe2/operators/recurrent_network_op.h" + #include "caffe2/core/workspace.h" + + namespace caffe2 { +diff --git a/caffe2/operators/recurrent_network_op.h b/caffe2/operators/recurrent_network_op.h +index 55328e5..ea898bc 100644 +--- a/caffe2/operators/recurrent_network_op.h ++++ b/caffe2/operators/recurrent_network_op.h +@@ -762,8 +762,8 @@ class AccumulateInputGradientOp : public Operator<Context> { + USE_OPERATOR_CONTEXT_FUNCTIONS; + + bool RunOnDevice() override { +- const auto t = +- OperatorBase::Input<Tensor<CPUContext>>(0).template data<int32_t>()[0]; ++ const auto& t0 = OperatorBase::Input<Tensor<CPUContext>>(0); ++ const auto t = t0.template data<int32_t>()[0]; + auto& og = Input(1); + auto* g = Output(0); + +diff --git a/caffe2/queue/queue_ops.h b/caffe2/queue/queue_ops.h +index f2c0a33..642343f 100644 +--- a/caffe2/queue/queue_ops.h ++++ b/caffe2/queue/queue_ops.h +@@ -17,13 +17,10 @@ class CreateBlobsQueueOp final : public Operator<Context> { + name(operator_def.output().Get(0)) {} + + bool RunOnDevice() override { +- const auto capacity = +- OperatorBase::template GetSingleArgument<int>("capacity", 1); +- const auto numBlobs = +- OperatorBase::template GetSingleArgument<int>("num_blobs", 1); ++ const auto capacity = GetSingleArgument("capacity", 1); ++ const auto numBlobs = GetSingleArgument("num_blobs", 1); + const auto enforceUniqueName = +- OperatorBase::template GetSingleArgument<int>( +- "enforce_unique_name", false); ++ GetSingleArgument("enforce_unique_name", false); + const auto fieldNames = + OperatorBase::template GetRepeatedArgument<std::string>("field_names"); + CAFFE_ENFORCE_EQ(this->OutputSize(), 1); diff --git a/nixpkgs/pkgs/development/libraries/science/math/caffe2/update_clang_cvtsh_bugfix.patch b/nixpkgs/pkgs/development/libraries/science/math/caffe2/update_clang_cvtsh_bugfix.patch new file mode 100644 index 000000000000..d908cb6ba80b --- /dev/null +++ b/nixpkgs/pkgs/development/libraries/science/math/caffe2/update_clang_cvtsh_bugfix.patch @@ -0,0 +1,55 @@ +diff --git a/caffe2/perfkernels/cvtsh_ss_bugfix.h b/caffe2/perfkernels/cvtsh_ss_bugfix.h +index bd06681..00172b7 100644 +--- a/caffe2/perfkernels/cvtsh_ss_bugfix.h ++++ b/caffe2/perfkernels/cvtsh_ss_bugfix.h +@@ -1,10 +1,36 @@ ++/** ++ * Copyright (c) 2016-present, Facebook, Inc. ++ * ++ * Licensed under the Apache License, Version 2.0 (the "License"); ++ * you may not use this file except in compliance with the License. ++ * You may obtain a copy of the License at ++ * ++ * http://www.apache.org/licenses/LICENSE-2.0 ++ * ++ * Unless required by applicable law or agreed to in writing, software ++ * distributed under the License is distributed on an "AS IS" BASIS, ++ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. ++ * See the License for the specific language governing permissions and ++ * limitations under the License. ++ */ ++ + #pragma once + +-#if defined(__APPLE__) && (__clang_major__ < 8) ++// Apple clang was fixed in 8.1 ++#if defined(__apple_build_version__) && ((__clang_major__ < 8) || ((__clang_major__ == 8) && (__clang_minor__ < 1))) ++#define __APPLE_NEED_FIX 1 ++#endif ++ ++// Regular clang was fixed in 3.9 ++#if defined(__clang__) && (__clang_major__ < 4) && (__clang_minor__ < 9) ++#define __CLANG_NEED_FIX 1 ++#endif ++ ++#if __APPLE_NEED_FIX || __CLANG_NEED_FIX + + #include <emmintrin.h> + +-// This version of apple clang has a bug that _cvtsh_ss is not defined, see ++// This version of clang has a bug that _cvtsh_ss is not defined, see + // https://reviews.llvm.org/D16177 + static __inline float + __attribute__((__always_inline__, __nodebug__, __target__("f16c"))) +@@ -15,7 +41,10 @@ _cvtsh_ss(unsigned short a) + return r[0]; + } + +-#endif // defined(__APPLE__) && (__clang_major__ < 8) ++#endif // __APPLE_NEED_FIX || __CLANG_NEED_FIX ++ ++#undef __APPLE_NEED_FIX ++#undef __CLANG_NEED_FIX + + #ifdef _MSC_VER + diff --git a/nixpkgs/pkgs/development/libraries/science/math/cholmod-extra/default.nix b/nixpkgs/pkgs/development/libraries/science/math/cholmod-extra/default.nix new file mode 100644 index 000000000000..c381f56277e8 --- /dev/null +++ b/nixpkgs/pkgs/development/libraries/science/math/cholmod-extra/default.nix @@ -0,0 +1,34 @@ +{ 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"; + }; + + buildInputs = [ suitesparse gfortran blas lapack ]; + + makeFlags = [ + "BLAS=-lcblas" + ]; + + installFlags = [ + "INSTALL_LIB=$(out)/lib" + "INSTALL_INCLUDE=$(out)/include" + ]; + + doCheck = true; + + meta = with stdenv.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; + }; + +} diff --git a/nixpkgs/pkgs/development/libraries/science/math/clblas/default.nix b/nixpkgs/pkgs/development/libraries/science/math/clblas/default.nix new file mode 100644 index 000000000000..8a474e06e556 --- /dev/null +++ b/nixpkgs/pkgs/development/libraries/science/math/clblas/default.nix @@ -0,0 +1,69 @@ +{ stdenv +, fetchFromGitHub +, cmake +, gfortran +, blas +, boost +, python +, 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" + ]; + + buildInputs = [ + cmake + gfortran + blas + python + boost + ] ++ stdenv.lib.optionals (!stdenv.isDarwin) [ + ocl-icd + opencl-headers + ] ++ stdenv.lib.optionals stdenv.isDarwin [ + Accelerate + CoreGraphics + CoreVideo + ]; + propagatedBuildInputs = stdenv.lib.optionals stdenv.isDarwin [ + OpenCL + ]; + + enableParallelBuilding = true; + + meta = with stdenv.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; + }; + +} diff --git a/nixpkgs/pkgs/development/libraries/science/math/clblas/platform.patch b/nixpkgs/pkgs/development/libraries/science/math/clblas/platform.patch new file mode 100644 index 000000000000..87404a426a4b --- /dev/null +++ b/nixpkgs/pkgs/development/libraries/science/math/clblas/platform.patch @@ -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); diff --git a/nixpkgs/pkgs/development/libraries/science/math/cliquer/default.nix b/nixpkgs/pkgs/development/libraries/science/math/cliquer/default.nix new file mode 100644 index 000000000000..c473fcedde3a --- /dev/null +++ b/nixpkgs/pkgs/development/libraries/science/math/cliquer/default.nix @@ -0,0 +1,38 @@ +{ stdenv +, fetchFromGitHub +, autoreconfHook +}: + +stdenv.mkDerivation rec { + version = "1.21"; + pname = "cliquer"; + + # autotoolized version of the original cliquer + src = fetchFromGitHub { + owner = "dimpase"; + repo = "autocliquer"; + rev = "v${version}"; + sha256 = "180i4qj1a25qfp75ig2d3144xfpb1dgcgpha0iqqghd7di4awg7z"; + }; + + doCheck = true; + + buildInputs = [ + autoreconfHook + ]; + + meta = with stdenv.lib; { + homepage = "https://users.aalto.fi/~pat/cliquer.html"; + downloadPage = src.meta.homepage; # autocliquer + 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. + ''; + license = licenses.gpl2Plus; + maintainers = with maintainers; [ timokau ]; + platforms = platforms.unix; + }; +} diff --git a/nixpkgs/pkgs/development/libraries/science/math/clmagma/default.nix b/nixpkgs/pkgs/development/libraries/science/math/clmagma/default.nix new file mode 100644 index 000000000000..2e798a6b83e7 --- /dev/null +++ b/nixpkgs/pkgs/development/libraries/science/math/clmagma/default.nix @@ -0,0 +1,75 @@ +{ stdenv, fetchurl, gfortran, opencl-headers, clblas, ocl-icd, mkl, intel-ocl }: + +with stdenv.lib; + +let + version = "1.3.0"; + 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 { + name = "clmagma-${version}"; + src = fetchurl { + url = "http://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 stdenv.lib; { + description = "Matrix Algebra on GPU and Multicore Architectures, OpenCL port"; + license = licenses.bsd3; + homepage = "http://icl.cs.utk.edu/magma/index.html"; + platforms = platforms.linux; + maintainers = with maintainers; [ volhovm ]; + }; +} diff --git a/nixpkgs/pkgs/development/libraries/science/math/cudnn/default.nix b/nixpkgs/pkgs/development/libraries/science/math/cudnn/default.nix new file mode 100644 index 000000000000..765d634a91f9 --- /dev/null +++ b/nixpkgs/pkgs/development/libraries/science/math/cudnn/default.nix @@ -0,0 +1,83 @@ +{ callPackage, cudatoolkit_7, cudatoolkit_7_5, cudatoolkit_8, cudatoolkit_9_0, cudatoolkit_9_1, cudatoolkit_9_2, cudatoolkit_10_0, cudatoolkit_10_1, cudatoolkit_10_2 }: + +let + generic = args: callPackage (import ./generic.nix (removeAttrs args ["cudatoolkit"])) { + inherit (args) cudatoolkit; + }; + +in rec { + cudnn_cudatoolkit_7 = generic rec { + # Old URL is v4 instead of v4.0 for some reason... + version = "4"; + cudatoolkit = cudatoolkit_7; + srcName = "cudnn-${cudatoolkit.majorVersion}-linux-x64-v4.0-prod.tgz"; + sha256 = "01a4v5j4v9n2xjqcc4m28c3m67qrvsx87npvy7zhx7w8smiif2fd"; + }; + + cudnn_cudatoolkit_7_5 = generic rec { + version = "6.0"; + cudatoolkit = cudatoolkit_7_5; + srcName = "cudnn-${cudatoolkit.majorVersion}-linux-x64-v${version}.tgz"; + sha256 = "0b68hv8pqcvh7z8xlgm4cxr9rfbjs0yvg1xj2n5ap4az1h3lp3an"; + }; + + cudnn6_cudatoolkit_8 = generic rec { + version = "6.0"; + cudatoolkit = cudatoolkit_8; + srcName = "cudnn-${cudatoolkit.majorVersion}-linux-x64-v${version}.tgz"; + sha256 = "173zpgrk55ri8if7s5yngsc89ajd6hz4pss4cdxlv6lcyh5122cv"; + }; + + cudnn_cudatoolkit_8 = generic rec { + version = "7.0.5"; + cudatoolkit = cudatoolkit_8; + srcName = "cudnn-${cudatoolkit.majorVersion}-linux-x64-v7.tgz"; + sha256 = "9e0b31735918fe33a79c4b3e612143d33f48f61c095a3b993023cdab46f6d66e"; + }; + + cudnn_cudatoolkit_9_0 = generic rec { + version = "7.3.0"; + cudatoolkit = cudatoolkit_9_0; + srcName = "cudnn-${cudatoolkit.majorVersion}-linux-x64-v7.3.0.29.tgz"; + sha256 = "16z4vgbcmbayk4hppz0xshgs3g07blkp4j25cxcjqyrczx1r0gs0"; + }; + + cudnn_cudatoolkit_9_1 = generic rec { + version = "7.1.3"; + cudatoolkit = cudatoolkit_9_1; + srcName = "cudnn-${cudatoolkit.majorVersion}-linux-x64-v7.1.tgz"; + sha256 = "0a0237gpr0p63s92njai0xvxmkbailzgfsvh7n9fnz0njhvnsqfx"; + }; + + cudnn_cudatoolkit_9_2 = generic rec { + version = "7.2.1"; + cudatoolkit = cudatoolkit_9_2; + srcName = "cudnn-${cudatoolkit.majorVersion}-linux-x64-v7.2.1.38.tgz"; + sha256 = "1sf215wm6zgr17gs6sxfhw61b7a0qmcxiwhgy1b4nqdyxpqgay1y"; + }; + + cudnn_cudatoolkit_9 = cudnn_cudatoolkit_9_2; + + cudnn_cudatoolkit_10_0 = generic rec { + version = "7.4.2"; + cudatoolkit = cudatoolkit_10_0; + srcName = "cudnn-${cudatoolkit.majorVersion}-linux-x64-v7.4.2.24.tgz"; + sha256 = "18ys0apiz9afid2s6lvy9qbyi8g66aimb2a7ikl1f3dm09mciprf"; + }; + + cudnn_cudatoolkit_10_1 = generic rec { + version = "7.6.3"; + cudatoolkit = cudatoolkit_10_1; + srcName = "cudnn-${cudatoolkit.majorVersion}-linux-x64-v7.6.3.30.tgz"; + sha256 = "0qc9f1xpyfibwqrpqxxq2v9h6w90j0dbx564akwy44c1dls5f99m"; + }; + + cudnn_cudatoolkit_10_2 = generic rec { + version = "7.6.5"; + cudatoolkit = cudatoolkit_10_2; + srcName = "cudnn-${cudatoolkit.majorVersion}-linux-x64-v7.6.5.32.tgz"; + sha256 = "084c13vzjdkb5s1996yilybg6dgav1lscjr1xdcgvlmfrbr6f0k0"; + }; + + cudnn_cudatoolkit_10 = cudnn_cudatoolkit_10_1; +} diff --git a/nixpkgs/pkgs/development/libraries/science/math/cudnn/generic.nix b/nixpkgs/pkgs/development/libraries/science/math/cudnn/generic.nix new file mode 100644 index 000000000000..5a17e807bd43 --- /dev/null +++ b/nixpkgs/pkgs/development/libraries/science/math/cudnn/generic.nix @@ -0,0 +1,59 @@ +{ version +, srcName +, sha256 +}: + +{ stdenv +, lib +, cudatoolkit +, fetchurl +, addOpenGLRunpath +}: + +stdenv.mkDerivation { + name = "cudatoolkit-${cudatoolkit.majorVersion}-cudnn-${version}"; + + inherit version; + src = fetchurl { + # URL from NVIDIA docker containers: https://gitlab.com/nvidia/cuda/blob/centos7/7.0/runtime/cudnn4/Dockerfile + url = "https://developer.download.nvidia.com/compute/redist/cudnn/v${version}/${srcName}"; + inherit sha256; + }; + + nativeBuildInputs = [ addOpenGLRunpath ]; + + installPhase = '' + function fixRunPath { + p=$(patchelf --print-rpath $1) + patchelf --set-rpath "$p:${lib.makeLibraryPath [ stdenv.cc.cc ]}" $1 + } + fixRunPath lib64/libcudnn.so + + mkdir -p $out + cp -a include $out/include + cp -a lib64 $out/lib64 + ''; + + # Set RUNPATH so that libcuda in /run/opengl-driver(-32)/lib can be found. + # See the explanation in addOpenGLRunpath. + postFixup = '' + addOpenGLRunpath $out/lib/lib*.so + ''; + + propagatedBuildInputs = [ + cudatoolkit + ]; + + passthru = { + inherit cudatoolkit; + majorVersion = lib.versions.major version; + }; + + meta = with stdenv.lib; { + description = "NVIDIA CUDA Deep Neural Network library (cuDNN)"; + homepage = "https://developer.nvidia.com/cudnn"; + license = licenses.unfree; + platforms = [ "x86_64-linux" ]; + maintainers = with maintainers; [ mdaiter ]; + }; +} diff --git a/nixpkgs/pkgs/development/libraries/science/math/ecos/default.nix b/nixpkgs/pkgs/development/libraries/science/math/ecos/default.nix new file mode 100644 index 000000000000..2ba69a34a4a7 --- /dev/null +++ b/nixpkgs/pkgs/development/libraries/science/math/ecos/default.nix @@ -0,0 +1,38 @@ +{ 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 stdenv.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 ]; + }; +} diff --git a/nixpkgs/pkgs/development/libraries/science/math/fenics/default.nix b/nixpkgs/pkgs/development/libraries/science/math/fenics/default.nix new file mode 100644 index 000000000000..4e89aeebe2b7 --- /dev/null +++ b/nixpkgs/pkgs/development/libraries/science/math/fenics/default.nix @@ -0,0 +1,261 @@ +{ stdenv +, fetchurl +, fetchpatch +, boost +, cmake +, doxygen +, eigen +, mpi4py +, numpy +, pkg-config +, pybind11 +, pytest +, pythonPackages +, six +, sympy +, gtest +, hdf5 +, mpi +, ply +, python +, scotch +, setuptools +, sphinx +, suitesparse +, swig +, zlib +, blas +, lapack +}: +let + version = "2019.1.0"; + + dijitso = pythonPackages.buildPythonPackage { + pname = "dijitso"; + inherit version; + src = fetchurl { + url = "https://bitbucket.org/fenics-project/dijitso/downloads/dijitso-${version}.tar.gz"; + sha256 = "1ncgbr0bn5cvv16f13g722a0ipw6p9y6p4iasxjziwsp8kn5x97a"; + }; + propagatedBuildInputs = [ numpy six ]; + checkInputs = [ pytest ]; + preCheck = '' + export HOME=$PWD + ''; + checkPhase = '' + runHook preCheck + py.test test/ + runHook postCheck + ''; + meta = { + description = "Distributed just-in-time shared library building"; + homepage = "https://fenicsproject.org/"; + platforms = stdenv.lib.platforms.all; + license = stdenv.lib.licenses.lgpl3; + }; + }; + + fiat = pythonPackages.buildPythonPackage { + pname = "fiat"; + inherit version; + src = fetchurl { + url = "https://bitbucket.org/fenics-project/fiat/downloads/fiat-${version}.tar.gz"; + sha256 = "1sbi0fbr7w9g9ajr565g3njxrc3qydqjy3334vmz5xg0rd3106il"; + }; + propagatedBuildInputs = [ numpy six sympy ]; + checkInputs = [ pytest ]; + + preCheck = '' + # Workaround pytest 4.6.3 issue. + # See: https://bitbucket.org/fenics-project/fiat/pull-requests/59 + rm test/unit/test_quadrature.py + rm test/unit/test_reference_element.py + rm test/unit/test_fiat.py + ''; + checkPhase = '' + runHook preCheck + py.test test/unit/ + runHook postCheck + ''; + meta = { + description = "Automatic generation of finite element basis functions"; + homepage = "https://fenicsproject.org/"; + platforms = stdenv.lib.platforms.all; + license = stdenv.lib.licenses.lgpl3; + }; + }; + + ufl = pythonPackages.buildPythonPackage { + pname = "ufl"; + inherit version; + src = fetchurl { + url = "https://bitbucket.org/fenics-project/ufl/downloads/ufl-${version}.tar.gz"; + sha256 = "04daxwg4y9c51sdgvwgmlc82nn0fjw7i2vzs15ckdc7dlazmcfi1"; + }; + propagatedBuildInputs = [ numpy six ]; + checkInputs = [ pytest ]; + checkPhase = '' + runHook preCheck + py.test test/ + runHook postCheck + ''; + meta = { + description = "A domain-specific language for finite element variational forms"; + homepage = "https://fenicsproject.org/"; + platforms = stdenv.lib.platforms.all; + license = stdenv.lib.licenses.lgpl3; + }; + }; + + ffc = pythonPackages.buildPythonPackage { + pname = "ffc"; + inherit version; + src = fetchurl { + url = "https://bitbucket.org/fenics-project/ffc/downloads/ffc-${version}.tar.gz"; + sha256 = "1zdg6pziss4va74pd7jjl8sc3ya2gmhpypccmyd8p7c66ji23y2g"; + }; + nativeBuildInputs = [ + pybind11 + ]; + propagatedBuildInputs = [ + dijitso + fiat + numpy + six + sympy + ufl + setuptools + ]; + checkInputs = [ pytest ]; + preCheck = '' + export HOME=$PWD + rm test/unit/ufc/finite_element/test_evaluate.py + ''; + checkPhase = '' + runHook preCheck + py.test test/unit/ + runHook postCheck + ''; + meta = { + description = "A compiler for finite element variational forms"; + homepage = "https://fenicsproject.org/"; + platforms = stdenv.lib.platforms.all; + license = stdenv.lib.licenses.lgpl3; + }; + }; + dolfin = stdenv.mkDerivation { + pname = "dolfin"; + inherit version; + src = fetchurl { + url = "https://bitbucket.org/fenics-project/dolfin/downloads/dolfin-${version}.tar.gz"; + sha256 = "0kbyi4x5f6j4zpasch0swh0ch81w2h92rqm1nfp3ydi4a93vky33"; + }; + patches = [ + (fetchpatch { + name = "fix-double-prefix.patch"; + url = "https://bitbucket.org/josef_kemetmueller/dolfin/commits/328e94acd426ebaf2243c072b806be3379fd4340/raw"; + sha256 = "1zj7k3y7vsx0hz3gwwlxhq6gdqamqpcw90d4ishwx5ps5ckcsb9r"; + }) + ]; + propagatedBuildInputs = [ + dijitso + fiat + numpy + six + ufl + ]; + nativeBuildInputs = [ + cmake + doxygen + pkg-config + ]; + buildInputs = [ + boost + dijitso + eigen + ffc + fiat + hdf5 + mpi + numpy + blas + lapack + ply + python + scotch + six + sphinx + suitesparse + swig + sympy + ufl + zlib + ]; + cmakeFlags = [ + "-DDOLFIN_CXX_FLAGS=-std=c++11" + "-DDOLFIN_AUTO_DETECT_MPI=ON" + "-DDOLFIN_ENABLE_CHOLMOD=ON" + "-DDOLFIN_ENABLE_DOCS=ON" + "-DDOLFIN_ENABLE_HDF5=ON" + "-DDOLFIN_ENABLE_MPI=ON" + "-DDOLFIN_ENABLE_SCOTCH=ON" + "-DDOLFIN_ENABLE_UMFPACK=ON" + "-DDOLFIN_ENABLE_ZLIB=ON" + "-DDOLFIN_SKIP_BUILD_TESTS=ON" # Otherwise SCOTCH is not found + # TODO: Enable the following features + "-DDOLFIN_ENABLE_PARMETIS=OFF" + "-DDOLFIN_ENABLE_PETSC=OFF" + "-DDOLFIN_ENABLE_SLEPC=OFF" + "-DDOLFIN_ENABLE_TRILINOS=OFF" + ]; + installCheckPhase = '' + source $out/share/dolfin/dolfin.conf + make runtests + ''; + meta = { + description = "The FEniCS Problem Solving Environment in Python and C++"; + homepage = "https://fenicsproject.org/"; + license = stdenv.lib.licenses.lgpl3; + }; + }; + python-dolfin = pythonPackages.buildPythonPackage rec { + pname = "dolfin"; + inherit version; + disabled = pythonPackages.isPy27; + src = dolfin.src; + sourceRoot = "${pname}-${version}/python"; + nativeBuildInputs = [ + pybind11 + cmake + ]; + dontUseCmakeConfigure = true; + preConfigure = '' + export CMAKE_PREFIX_PATH=${pybind11}/share/cmake/pybind11:$CMAKE_PREFIX_PATH + substituteInPlace setup.py --replace "pybind11==2.2.4" "pybind11" + substituteInPlace dolfin/jit/jit.py \ + --replace 'pkgconfig.exists("dolfin")' 'pkgconfig.exists("${dolfin}/lib/pkgconfig/dolfin.pc")' \ + --replace 'pkgconfig.parse("dolfin")' 'pkgconfig.parse("${dolfin}/lib/pkgconfig/dolfin.pc")' + ''; + buildInputs = [ + dolfin + boost + ]; + + propagatedBuildInputs = [ + dijitso + ffc + mpi4py + numpy + ufl + pythonPackages.pkgconfig + pythonPackages.pybind11 + ]; + doCheck = false; # Tries to orte_ess_init and call ssh to localhost + meta = { + description = "Python bindings for the DOLFIN FEM compiler"; + homepage = "https://fenicsproject.org/"; + platforms = stdenv.lib.platforms.all; + license = stdenv.lib.licenses.lgpl3; + }; + }; +in python-dolfin diff --git a/nixpkgs/pkgs/development/libraries/science/math/flintqs/default.nix b/nixpkgs/pkgs/development/libraries/science/math/flintqs/default.nix new file mode 100644 index 000000000000..327fea3955d2 --- /dev/null +++ b/nixpkgs/pkgs/development/libraries/science/math/flintqs/default.nix @@ -0,0 +1,39 @@ +{ 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 stdenv.lib; { + homepage = "https://github.com/sagemath/FlintQS"; + description = "Highly optimized multi-polynomial quadratic sieve for integer factorization"; + license = with licenses; [ gpl2 ]; + maintainers = with maintainers; [ timokau ]; + platforms = platforms.all; + }; +} diff --git a/nixpkgs/pkgs/development/libraries/science/math/ipopt/default.nix b/nixpkgs/pkgs/development/libraries/science/math/ipopt/default.nix new file mode 100644 index 000000000000..647fd82ec0e9 --- /dev/null +++ b/nixpkgs/pkgs/development/libraries/science/math/ipopt/default.nix @@ -0,0 +1,34 @@ +{ stdenv, fetchurl, unzip, blas, lapack, gfortran }: + +assert (!blas.is64bit) && (!lapack.is64bit); + +stdenv.mkDerivation rec { + pname = "ipopt"; + version = "3.12.13"; + + src = fetchurl { + url = "https://www.coin-or.org/download/source/Ipopt/Ipopt-${version}.zip"; + sha256 = "0kzf05aypx8q5mr3sciclk926ans0yi2d2chjdxxgpi3sza609dx"; + }; + + CXXDEFS = [ "-DHAVE_RAND" "-DHAVE_CSTRING" "-DHAVE_CSTDIO" ]; + + configureFlags = [ + "--with-blas-lib=-lblas" + "--with-lapack-lib=-llapack" + ]; + + nativeBuildInputs = [ unzip ]; + + buildInputs = [ gfortran blas lapack ]; + + enableParallelBuilding = true; + + meta = with stdenv.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 ]; + }; +} diff --git a/nixpkgs/pkgs/development/libraries/science/math/lcalc/default.nix b/nixpkgs/pkgs/development/libraries/science/math/lcalc/default.nix new file mode 100644 index 000000000000..3f00547efcec --- /dev/null +++ b/nixpkgs/pkgs/development/libraries/science/math/lcalc/default.nix @@ -0,0 +1,97 @@ +{ stdenv +, fetchurl +, fetchpatch +, pari +}: + +stdenv.mkDerivation rec { + version = "1.23"; + pname = "lcalc"; + + src = fetchurl { + # original at http://oto.math.uwaterloo.ca/~mrubinst/L_function_public/CODE/L-${version}.tar.gz, no longer available + # "newer" version at google code https://code.google.com/archive/p/l-calc/source/default/source + url = "mirror://sageupstream/lcalc/lcalc-${version}.tar.bz2"; + sha256 = "1c6dsdshgxhqppjxvxhp8yhpxaqvnz3d1mlh26r571gkq8z2bm43"; + }; + + preConfigure = "cd src"; + + buildInputs = [ + pari + ]; + + patches = [ + # Port to newer pari + (fetchpatch { + url = "https://git.sagemath.org/sage.git/plain/build/pkgs/lcalc/patches/pari-2.7.patch?id=07d6c37d18811e2b377a9689790a7c5e24da16ba"; + sha256 = "1x3aslldm8njjm7p9g9s9w2c91kphnci2vpkxkrcxfihw3ayss6c"; + }) + + # Uncomment the definition of lcalc_to_double(const long double& x). + # (Necessary for GCC >= 4.6.0, cf. https://trac.sagemath.org/ticket/10892) + (fetchpatch { + url = "https://git.sagemath.org/sage.git/plain/build/pkgs/lcalc/patches/Lcommon.h.patch?id=07d6c37d18811e2b377a9689790a7c5e24da16ba"; + sha256 = "0g4ybvsrcv48rmlh1xjnkms19jp25k58azv6ds1f2cm34hxs8fdx"; + }) + + # Include also <time.h> in Lcommandline_numbertheory.h (at least required + # on Cygwin, cf. https://trac.sagemath.org/ticket/9845) + (fetchpatch { + url = "https://git.sagemath.org/sage.git/plain/build/pkgs/lcalc/patches/time.h.patch?id=07d6c37d18811e2b377a9689790a7c5e24da16ba"; + sha256 = "1brf04n11kkc43ylagf8dm32j5r2g9zv51dp5wag1mpm4p04l7cl"; + }) + + # Fix for gcc >4.6 + (fetchpatch { + url = "https://git.sagemath.org/sage.git/plain/build/pkgs/lcalc/patches/lcalc-1.23_default_parameters_1.patch?id=07d6c37d18811e2b377a9689790a7c5e24da16ba"; + sha256 = "0i2yvxm5fx4z0v6m4srgh8rj98kijmlvyirlxf1ky0bp2si6bpka"; + }) + + # gcc 5.1 + (fetchpatch { + url = "https://git.sagemath.org/sage.git/plain/build/pkgs/lcalc/patches/lcalc-1.23_default_parameters_2.patch?id=07d6c37d18811e2b377a9689790a7c5e24da16ba"; + sha256 = "0dqwmxpm9wb53qbypsyfkgsvk2f8nf67sydphd4dkc2vw4yz6vlh"; + }) + + # based on gentoos makefile patch -- fix paths, adhere to flags + ./makefile.patch + + # (fetchpatch { + # name = "default-double.patch"; + # url = "https://github.com/dimpase/lcalc/pull/1/commits/0500c67b6aa1f492715591669f6647c8f7a3ea59.patch"; + # sha256 = "0dqwmxpm9wb53qbypsyfkgsvk2f8nf67sydphd4dkc2vw4yz6vla"; + # }) + + (fetchpatch { + name = "c++11.patch"; + url = "https://git.archlinux.org/svntogit/community.git/plain/trunk/lcalc-c++11.patch?h=packages/lcalc&id=3607b97df5a8c231191115b0cb5c62426b339e71"; + sha256 = "1ccrl61lv2vvx8ggldq54m5d0n1iy6mym7qz0i8nj6yj0dshnpk3"; + }) + ] ++ stdenv.lib.optional stdenv.isDarwin + (fetchpatch { + url = "https://git.sagemath.org/sage.git/plain/build/pkgs/lcalc/patches/clang.patch"; + sha256 = "0bb7656z6cp6i4p2qj745cmq0lhh52v2akl9whi760dynfdxbl18"; + }); + + postPatch = stdenv.lib.optionalString stdenv.isDarwin '' + substituteInPlace src/Makefile --replace g++ c++ + ''; + + installFlags = [ + "DESTDIR=$(out)" + ]; + + makeFlags = [ + "PARI_DEFINE=-DINCLUDE_PARI" + "PARI_PREFIX=${pari}" + ]; + + meta = with stdenv.lib; { + homepage = "http://oto.math.uwaterloo.ca/~mrubinst/L_function_public/L.html"; + description = "A program for calculating with L-functions"; + license = with licenses; [ gpl2 ]; + maintainers = with maintainers; [ timokau ]; + platforms = platforms.all; + }; +} diff --git a/nixpkgs/pkgs/development/libraries/science/math/lcalc/makefile.patch b/nixpkgs/pkgs/development/libraries/science/math/lcalc/makefile.patch new file mode 100644 index 000000000000..5c22cf0b84e8 --- /dev/null +++ b/nixpkgs/pkgs/development/libraries/science/math/lcalc/makefile.patch @@ -0,0 +1,113 @@ +diff --git a/src/Makefile b/src/Makefile +index 84e4e88..56ca676 100644 +--- a/src/Makefile ++++ b/src/Makefile +@@ -58,7 +58,7 @@ ifeq ($(G5),TRUE) + #MACHINE_SPECIFIC_FLAGS = -mpowerpc -mpowerpc64 -m64 + endif + +-CCFLAGS = -Wa,-W -O3 $(OPENMP_FLAG) -Wno-deprecated $(PREPROCESSOR_DEFINE) $(MACHINE_SPECIFIC_FLAGS) $(EXTRA) ++CCFLAGS = $(CXXFLAGS) $(OPENMP_FLAG) $(PREPROCESSOR_DEFINE) $(MACHINE_SPECIFIC_FLAGS) + #CCFLAGS = -Wa,-W -O3 $(OPENMP_FLAG) $(PREPROCESSOR_DEFINE) $(MACHINE_SPECIFIC_FLAGS) $(EXTRA) + #CCFLAGS = -Wa,-W -O2 -fno-exceptions -Wno-deprecated $(PREPROCESSOR_DEFINE) $(MACHINE_SPECIFIC_FLAGS) $(EXTRA) + +@@ -68,12 +68,12 @@ CCFLAGS = -Wa,-W -O3 $(OPENMP_FLAG) -Wno-deprecated $(PREPROCESSOR_DEFINE) $(MA + + ifeq ($(PARI_DEFINE),-DINCLUDE_PARI) + #location of pari.h. +- LOCATION_PARI_H = /usr/local/include/pari #usual location ++ LOCATION_PARI_H = $(PARI_PREFIX)/include/pari #usual location + + #location of libpari.a or of libpari.so + #depending on whether static or dynamic libraries are being used. + #On mac os x it's the former, on linux I think usually the latter. +- LOCATION_PARI_LIBRARY = /usr/local/lib #usual location ++ LOCATION_PARI_LIBRARY = $(PARI_PREFIX)/lib #usual location + else + #supplied as a dummy so as to avoid more ifeq's below + LOCATION_PARI_H = . +@@ -89,24 +89,24 @@ INCLUDEFILES= -I../include + + ifeq ($(OS_NAME),Darwin) + LDFLAGS2 = +- DYN_OPTION=dynamiclib ++ DYN_OPTION=-dynamiclib + else +- LDFLAGS1 = -Xlinker -export-dynamic #not sure why pari calls these when linking but on the web I found ++ LDFLAGS1 = #not sure why pari calls these when linking but on the web I found + #'Libtool provides the `-export-dynamic' link flag (see section Link mode), which does this declaration. + #You need to use this flag if you are linking a shared library that will be dlopened' + #see notes below + #ifeq ($(PARI_DEFINE),-DINCLUDE_PARI) +- LDFLAGS2 = $(LDFLAGS1) -Xlinker -rpath -Xlinker $(LOCATION_PARI_LIBRARY) ++ LDFLAGS2 = $(LDFLAGS) + #else + # LDFLAGS2 = $(LDFLAGS1) + #endif +- DYN_OPTION=shared ++ DYN_OPTION=$(LDFLAGS) -shared -Wl,-soname,libLfunction.so + endif + + ifeq ($(PARI_DEFINE),-DINCLUDE_PARI) +- LDFLAGS = $(LDFLAGS2) -L$(LOCATION_PARI_LIBRARY) -lpari ++ MYLDFLAGS = $(LDFLAGS2) -L$(LOCATION_PARI_LIBRARY) -lpari + else +- LDFLAGS = $(LDFLAGS2) ++ MYLDFLAGS = $(LDFLAGS2) + endif + + +@@ -129,7 +129,8 @@ endif + #become clear which libraries the computer can find. + + +-INSTALL_DIR= /usr/local ++INSTALL_DIR= $(DESTDIR) ++LIB_DIR ?=lib + + #object files for the libLfunction library + OBJ_L = Lglobals.o Lgamma.o Lriemannsiegel.o Lriemannsiegel_blfi.o Ldokchitser.o +@@ -141,9 +142,8 @@ OBJECTS = $(OBJ3) + + all: + # make print_vars +- make libLfunction.so +- make lcalc +- make examples ++ ${MAKE} libLfunction.so ++ ${MAKE} lcalc + # make find_L + # make test + +@@ -151,7 +151,7 @@ print_vars: + @echo OS_NAME = $(OS_NAME) + + lcalc: $(OBJECTS) +- $(CC) $(CCFLAGS) $(INCLUDEFILES) $(OBJECTS) $(LDFLAGS) -o lcalc $(GMP_FLAGS) ++ $(CC) $(CCFLAGS) $(INCLUDEFILES) $(OBJECTS) $(MYLDFLAGS) -o lcalc $(GMP_FLAGS) + + examples: + $(CC) $(CCFLAGS) $(INCLUDEFILES) example_programs/example.cc libLfunction.so -o example_programs/example $(GMP_FLAGS) +@@ -262,15 +262,18 @@ Lcommandline.o: ../include/Lcommandline_values_zeros.h + + + libLfunction.so: $(OBJ_L) +- g++ -$(DYN_OPTION) -o libLfunction.so $(OBJ_L) ++ g++ $(DYN_OPTION) -o libLfunction.so $(OBJ_L) + + clean: + rm -f *.o lcalc libLfunction.so example_programs/example + + install: +- cp -f lcalc $(INSTALL_DIR)/bin/. +- cp -f libLfunction.so $(INSTALL_DIR)/lib/. +- cp -rf ../include $(INSTALL_DIR)/include/Lfunction ++ install -d $(INSTALL_DIR)/bin ++ install -d $(INSTALL_DIR)/$(LIB_DIR) ++ install -d $(INSTALL_DIR)/include/Lfunction ++ install lcalc $(INSTALL_DIR)/bin ++ install libLfunction.so $(INSTALL_DIR)/$(LIB_DIR) ++ install -m 644 -t $(INSTALL_DIR)/include/Lfunction ../include/*.h + + + SRCS = Lcommandline.cc Lcommandline_elliptic.cc Lcommandline_globals.cc Lcommandline_misc.cc Lcommandline_numbertheory.cc Lcommandline_twist.cc Lcommandline_values_zeros.cc Lgamma.cc Lglobals.cc Lmisc.cc Lriemannsiegel.cc Lriemannsiegel_blfi.cc cmdline.c diff --git a/nixpkgs/pkgs/development/libraries/science/math/libbraiding/default.nix b/nixpkgs/pkgs/development/libraries/science/math/libbraiding/default.nix new file mode 100644 index 000000000000..aac66e4fe05b --- /dev/null +++ b/nixpkgs/pkgs/development/libraries/science/math/libbraiding/default.nix @@ -0,0 +1,34 @@ +{ stdenv +, fetchFromGitHub +, autoreconfHook +}: + +stdenv.mkDerivation rec { + version = "1.0"; + pname = "libbraiding"; + + src = fetchFromGitHub { + owner = "miguelmarco"; + repo = "libbraiding"; + rev = version; + sha256 = "0l68rikfr7k2l547gb3pp3g8cj5zzxwipm79xrb5r8ffj466ydxg"; + }; + + nativeBuildInputs = [ + autoreconfHook + ]; + + # no tests included for now (2018-08-05), but can't hurt to activate + doCheck = true; + + meta = with stdenv.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 = with maintainers; [ timokau ]; + platforms = platforms.all; + }; +} diff --git a/nixpkgs/pkgs/development/libraries/science/math/libhomfly/default.nix b/nixpkgs/pkgs/development/libraries/science/math/libhomfly/default.nix new file mode 100644 index 000000000000..d9b50a0fb2d1 --- /dev/null +++ b/nixpkgs/pkgs/development/libraries/science/math/libhomfly/default.nix @@ -0,0 +1,35 @@ +{ stdenv +, fetchFromGitHub +, autoreconfHook +, boehmgc +}: + +stdenv.mkDerivation rec { + version = "1.02r5"; + pname = "llibhomfly"; + + src = fetchFromGitHub { + owner = "miguelmarco"; + repo = "libhomfly"; + rev = version; + sha256 = "1szv8iwlhvmy3saigi15xz8vgch92p2lbsm6440v5s8vxj455bvd"; + }; + + buildInputs = [ + boehmgc + ]; + + nativeBuildInputs = [ + autoreconfHook + ]; + + doCheck = true; + + meta = with stdenv.lib; { + homepage = "https://github.com/miguelmarco/libhomfly/"; + description = "Library to compute the homfly polynomial of knots and links"; + license = licenses.unlicense; + maintainers = with maintainers; [ timokau ]; + platforms = platforms.all; + }; +} diff --git a/nixpkgs/pkgs/development/libraries/science/math/liblapack/default.nix b/nixpkgs/pkgs/development/libraries/science/math/liblapack/default.nix new file mode 100644 index 000000000000..045cccbd2ebf --- /dev/null +++ b/nixpkgs/pkgs/development/libraries/science/math/liblapack/default.nix @@ -0,0 +1,45 @@ +{ + stdenv, + fetchFromGitHub, + gfortran, + cmake, + python2, + shared ? true +}: +let + inherit (stdenv.lib) optional; + version = "3.9.0"; +in + +stdenv.mkDerivation { + pname = "liblapack"; + inherit version; + + src = fetchFromGitHub { + owner = "Reference-LAPACK"; + repo = "lapack"; + rev = "v${version}"; + sha256 = "0sxnc97z67i7phdmcnq8f8lmxgw10wdwvr8ami0w3pb179cgrbpb"; + }; + + nativeBuildInputs = [ gfortran python2 cmake ]; + + cmakeFlags = [ + "-DCMAKE_Fortran_FLAGS=-fPIC" + "-DLAPACKE=ON" + "-DCBLAS=ON" + ] + ++ optional shared "-DBUILD_SHARED_LIBS=ON"; + + doCheck = true; + + enableParallelBuilding = true; + + meta = with stdenv.lib; { + inherit version; + description = "Linear Algebra PACKage"; + homepage = "http://www.netlib.org/lapack/"; + license = licenses.bsd3; + platforms = platforms.all; + }; +} diff --git a/nixpkgs/pkgs/development/libraries/science/math/liblbfgs/default.nix b/nixpkgs/pkgs/development/libraries/science/math/liblbfgs/default.nix new file mode 100644 index 000000000000..49108e5e3305 --- /dev/null +++ b/nixpkgs/pkgs/development/libraries/science/math/liblbfgs/default.nix @@ -0,0 +1,17 @@ +{ stdenv, fetchurl }: +stdenv.mkDerivation { + name = "liblbfgs-1.10"; + + configureFlags = [ "--enable-sse2" ]; + src = fetchurl { + url = "https://github.com/downloads/chokkan/liblbfgs/liblbfgs-1.10.tar.gz"; + sha256 = "1kv8d289rbz38wrpswx5dkhr2yh4fg4h6sszkp3fawxm09sann21"; + }; + + meta = { + description = "Library of Limited-memory Broyden-Fletcher-Goldfarb-Shanno (L-BFGS)"; + homepage = "http://www.chokkan.org/software/liblbfgs/"; + license = stdenv.lib.licenses.mit; + platforms = stdenv.lib.platforms.unix; + }; +} diff --git a/nixpkgs/pkgs/development/libraries/science/math/lrs/default.nix b/nixpkgs/pkgs/development/libraries/science/math/lrs/default.nix new file mode 100644 index 000000000000..b0cfbca5aa33 --- /dev/null +++ b/nixpkgs/pkgs/development/libraries/science/math/lrs/default.nix @@ -0,0 +1,26 @@ +{stdenv, fetchurl, gmp}: + +stdenv.mkDerivation rec { + pname = "lrs"; + version = "7.0"; + + src = fetchurl { + url = "http://cgm.cs.mcgill.ca/~avis/C/lrslib/archive/lrslib-070.tar.gz"; + sha256 = "1zjdmkjracz695k73c2pvipc0skpyn1wzagkhilsvcw9pqljpwg9"; + }; + + buildInputs = [ gmp ]; + + preBuild = '' + export makeFlags="$makeFlags prefix=$out"; + ''; + + meta = { + inherit version; + description = "Implementation of the reverse search algorithm for vertex enumeration/convex hull problems"; + license = stdenv.lib.licenses.gpl2 ; + maintainers = [stdenv.lib.maintainers.raskin]; + platforms = stdenv.lib.platforms.linux; + homepage = "http://cgm.cs.mcgill.ca/~avis/C/lrs.html"; + }; +} diff --git a/nixpkgs/pkgs/development/libraries/science/math/m4ri/default.nix b/nixpkgs/pkgs/development/libraries/science/math/m4ri/default.nix new file mode 100644 index 000000000000..d8b4cbbffb48 --- /dev/null +++ b/nixpkgs/pkgs/development/libraries/science/math/m4ri/default.nix @@ -0,0 +1,30 @@ +{ 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 stdenv.lib; { + homepage = "https://malb.bitbucket.io/m4ri/"; + description = "Library to do fast arithmetic with dense matrices over F_2"; + license = licenses.gpl2Plus; + maintainers = with maintainers; [ timokau ]; + platforms = platforms.unix; + }; +} diff --git a/nixpkgs/pkgs/development/libraries/science/math/m4rie/default.nix b/nixpkgs/pkgs/development/libraries/science/math/m4rie/default.nix new file mode 100644 index 000000000000..e1f86b346d7f --- /dev/null +++ b/nixpkgs/pkgs/development/libraries/science/math/m4rie/default.nix @@ -0,0 +1,39 @@ +{ 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 stdenv.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 = with maintainers; [ timokau ]; + platforms = platforms.unix; + }; +} diff --git a/nixpkgs/pkgs/development/libraries/science/math/magma/default.nix b/nixpkgs/pkgs/development/libraries/science/math/magma/default.nix new file mode 100644 index 000000000000..b34139e7f484 --- /dev/null +++ b/nixpkgs/pkgs/development/libraries/science/math/magma/default.nix @@ -0,0 +1,58 @@ +{ stdenv, fetchurl, cmake, gfortran, cudatoolkit, libpthreadstubs, lapack, blas +, mklSupport ? false, mkl ? null +}: + +assert !mklSupport || mkl != null; + +with stdenv.lib; + +let version = "2.5.0"; + +in stdenv.mkDerivation { + pname = "magma"; + inherit version; + src = fetchurl { + url = "https://icl.cs.utk.edu/projectsfiles/magma/downloads/magma-${version}.tar.gz"; + sha256 = "0czspk93cv1fy37zyrrc9k306q4yzfxkhy1y4lj937dx8rz5rm2g"; + name = "magma-${version}.tar.gz"; + }; + + buildInputs = [ gfortran cudatoolkit libpthreadstubs cmake ] + ++ (if mklSupport then [ mkl ] else [ lapack blas ]); + + doCheck = false; + + MKLROOT = optionalString mklSupport mkl; + + preConfigure = '' + export CC=${cudatoolkit.cc}/bin/gcc CXX=${cudatoolkit.cc}/bin/g++ + ''; + + enableParallelBuilding=true; + buildFlags = [ "magma" "magma_sparse" ]; + + # MAGMA's default CMake setup does not care about installation. So we copy files directly. + installPhase = '' + mkdir -p $out + mkdir -p $out/include + mkdir -p $out/lib + mkdir -p $out/lib/pkgconfig + cp -a ../include/*.h $out/include + #cp -a sparse-iter/include/*.h $out/include + cp -a lib/*.a $out/lib + cat ../lib/pkgconfig/magma.pc.in | \ + sed -e s:@INSTALL_PREFIX@:"$out": | \ + sed -e s:@CFLAGS@:"-I$out/include": | \ + sed -e s:@LIBS@:"-L$out/lib -lmagma -lmagma_sparse": | \ + sed -e s:@MAGMA_REQUIRED@:: \ + > $out/lib/pkgconfig/magma.pc + ''; + + meta = with stdenv.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 ]; + }; +} diff --git a/nixpkgs/pkgs/development/libraries/science/math/metis/default.nix b/nixpkgs/pkgs/development/libraries/science/math/metis/default.nix new file mode 100644 index 000000000000..8d6381c8d48d --- /dev/null +++ b/nixpkgs/pkgs/development/libraries/science/math/metis/default.nix @@ -0,0 +1,20 @@ +{ stdenv, fetchurl, unzip, cmake }: + +stdenv.mkDerivation { + name = "metis-5.1.0"; + + src = fetchurl { + url = "http://glaros.dtc.umn.edu/gkhome/fetch/sw/metis/metis-5.1.0.tar.gz"; + sha256 = "1cjxgh41r8k6j029yxs8msp3z6lcnpm16g5pvckk35kc7zhfpykn"; + }; + + cmakeFlags = [ "-DGKLIB_PATH=../GKlib" ]; + buildInputs = [ unzip cmake ]; + + meta = { + description = "Serial graph partitioning and fill-reducing matrix ordering"; + homepage = "http://glaros.dtc.umn.edu/gkhome/metis/metis/overview"; + license = stdenv.lib.licenses.asl20; + platforms = stdenv.lib.platforms.all; + }; +} diff --git a/nixpkgs/pkgs/development/libraries/science/math/mkl/default.nix b/nixpkgs/pkgs/development/libraries/science/math/mkl/default.nix new file mode 100644 index 000000000000..f9026ec7b997 --- /dev/null +++ b/nixpkgs/pkgs/development/libraries/science/math/mkl/default.nix @@ -0,0 +1,152 @@ +{ stdenvNoCC, fetchurl, rpmextract, undmg, darwin, enableStatic ? false }: +/* + 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 = "${year}.${spot}.${rel}"; + + # Darwin is pinned to 2019.3 because the DMG does not unpack; see here for details: + # https://github.com/matthewbauer/undmg/issues/4 + year = if stdenvNoCC.isDarwin then "2019" else "2020"; + spot = if stdenvNoCC.isDarwin then "3" else "1"; + rel = if stdenvNoCC.isDarwin then "199" else "217"; + + rpm-ver = "${year}.${spot}-${rel}-${year}.${spot}-${rel}"; + + # Intel openmp uses its own versioning, but shares the spot release patch. + openmp = if stdenvNoCC.isDarwin then "19.0" else "19.1"; + openmp-ver = "${openmp}.${spot}-${rel}-${openmp}.${spot}-${rel}"; + +in stdenvNoCC.mkDerivation { + pname = "mkl"; + inherit version; + + src = if stdenvNoCC.isDarwin + then + (fetchurl { + url = "http://registrationcenter-download.intel.com/akdlm/irc_nas/tec/15235/m_mkl_${version}.dmg"; + sha256 = "14b3ciz7995sqcd6jz7hc8g2x4zwvqxmgxgni46vrlb7n523l62f"; + }) + else + (fetchurl { + url = "https://registrationcenter-download.intel.com/akdlm/irc_nas/tec/16533/l_mkl_${version}.tgz"; + sha256 = "0v86hrqg15mbc78m9qk8dbkaaq3mlwashgbf9n79kxpl1gilnah8"; + }); + + nativeBuildInputs = 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 '' + # Common stuff + rpmextract rpm/intel-mkl-core-${rpm-ver}.x86_64.rpm + rpmextract rpm/intel-mkl-common-c-${rpm-ver}.noarch.rpm + rpmextract rpm/intel-mkl-common-f-${rpm-ver}.noarch.rpm + + # Dynamic libraries + rpmextract rpm/intel-mkl-cluster-rt-${rpm-ver}.x86_64.rpm + rpmextract rpm/intel-mkl-core-rt-${rpm-ver}.x86_64.rpm + rpmextract rpm/intel-mkl-gnu-f-rt-${rpm-ver}.x86_64.rpm + rpmextract rpm/intel-mkl-gnu-rt-${rpm-ver}.x86_64.rpm + + # Intel OpenMP runtime + rpmextract rpm/intel-openmp-${openmp-ver}.x86_64.rpm + '' + (if enableStatic then '' + # Static libraries + rpmextract rpm/intel-mkl-cluster-${rpm-ver}.x86_64.rpm + rpmextract rpm/intel-mkl-gnu-${rpm-ver}.x86_64.rpm + rpmextract rpm/intel-mkl-gnu-f-${rpm-ver}.x86_64.rpm + '' else '' + # Take care of installing dynamic-only PkgConfig files during the installPhase + '' + ); + + installPhase = '' + for f in $(find . -name 'mkl*.pc') ; do + bn=$(basename $f) + substituteInPlace $f \ + --replace "prefix=<INSTALLDIR>/mkl" "prefix=$out" \ + --replace "lib/intel64_lin" "lib" + done + + for f in $(find opt/intel -name 'mkl*iomp.pc') ; do + substituteInPlace $f \ + --replace "../compiler/lib" "lib" + done + '' + + (if stdenvNoCC.isDarwin then '' + 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 '' + mkdir -p $out/lib + cp license.txt $out/lib/ + + cp -r opt/intel/compilers_and_libraries_${version}/linux/mkl/include $out/ + + mkdir -p $out/lib/pkgconfig + '') + + (if enableStatic then '' + cp -r opt/intel/compilers_and_libraries_${version}/linux/compiler/lib/intel64_lin/* $out/lib/ + cp -r opt/intel/compilers_and_libraries_${version}/linux/mkl/lib/intel64_lin/* $out/lib/ + cp -r opt/intel/compilers_and_libraries_${version}/linux/mkl/bin/pkgconfig/* $out/lib/pkgconfig + '' else '' + cp -r opt/intel/compilers_and_libraries_${version}/linux/compiler/lib/intel64_lin/*.so* $out/lib/ + cp -r opt/intel/compilers_and_libraries_${version}/linux/mkl/lib/intel64_lin/*.so* $out/lib/ + cp -r opt/intel/compilers_and_libraries_${version}/linux/mkl/bin/pkgconfig/*dynamic*.pc $out/lib/pkgconfig + '') + '' + + # Setup symlinks for blas / lapack + ln -s $out/lib/libmkl_rt${stdenvNoCC.hostPlatform.extensions.sharedLibrary} $out/lib/libblas${stdenvNoCC.hostPlatform.extensions.sharedLibrary} + ln -s $out/lib/libmkl_rt${stdenvNoCC.hostPlatform.extensions.sharedLibrary} $out/lib/libcblas${stdenvNoCC.hostPlatform.extensions.sharedLibrary} + ln -s $out/lib/libmkl_rt${stdenvNoCC.hostPlatform.extensions.sharedLibrary} $out/lib/liblapack${stdenvNoCC.hostPlatform.extensions.sharedLibrary} + ln -s $out/lib/libmkl_rt${stdenvNoCC.hostPlatform.extensions.sharedLibrary} $out/lib/liblapacke${stdenvNoCC.hostPlatform.extensions.sharedLibrary} + ''; + + # 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 = stdenvNoCC.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; + + meta = with stdenvNoCC.lib; { + description = "Intel Math Kernel Library"; + longDescription = '' + Intel Math Kernel Library (Intel MKL) 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 ]; + }; +} diff --git a/nixpkgs/pkgs/development/libraries/science/math/mongoose/default.nix b/nixpkgs/pkgs/development/libraries/science/math/mongoose/default.nix new file mode 100644 index 000000000000..36c53b2994f5 --- /dev/null +++ b/nixpkgs/pkgs/development/libraries/science/math/mongoose/default.nix @@ -0,0 +1,30 @@ +{ 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 stdenv.lib; { + description = "Graph Coarsening and Partitioning Library"; + homepage = "https://github.com/ScottKolo/Mongoose"; + license = licenses.gpl3; + maintainers = with maintainers; []; + platforms = with platforms; unix; + }; +} diff --git a/nixpkgs/pkgs/development/libraries/science/math/nccl/default.nix b/nixpkgs/pkgs/development/libraries/science/math/nccl/default.nix new file mode 100644 index 000000000000..5f38d45fc4d8 --- /dev/null +++ b/nixpkgs/pkgs/development/libraries/science/math/nccl/default.nix @@ -0,0 +1,48 @@ +{ stdenv, fetchFromGitHub, which, cudatoolkit, addOpenGLRunpath }: + +stdenv.mkDerivation rec { + name = "nccl-${version}-cuda-${cudatoolkit.majorVersion}"; + version = "2.4.8-1"; + + src = fetchFromGitHub { + owner = "NVIDIA"; + repo = "nccl"; + rev = "v${version}"; + sha256 = "05m66y64rgsdyybvjybhy6clikwv438b1m484ikai78fb2b7mvyq"; + }; + + 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; + + meta = with stdenv.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 ]; + }; +} diff --git a/nixpkgs/pkgs/development/libraries/science/math/openblas/0001-Disable-optimised-aarch64-dgemm_beta-pending-fix.patch b/nixpkgs/pkgs/development/libraries/science/math/openblas/0001-Disable-optimised-aarch64-dgemm_beta-pending-fix.patch new file mode 100644 index 000000000000..1da1f3fb3190 --- /dev/null +++ b/nixpkgs/pkgs/development/libraries/science/math/openblas/0001-Disable-optimised-aarch64-dgemm_beta-pending-fix.patch @@ -0,0 +1,26 @@ +From 6cb9aa7c69c20a677ca9fb1bc5fa1580e3236fbd Mon Sep 17 00:00:00 2001 +From: Tom Hall <tahall256@protonmail.ch> +Date: Sat, 14 Mar 2020 11:55:45 +0000 +Subject: [PATCH] Disable optimised aarch64 dgemm_beta pending fix + +Identified as source of https://github.com/xianyi/OpenBLAS/issues/2496, +but not yet fixed. +--- + kernel/arm64/KERNEL.ARMV8 | 1 - + 1 file changed, 1 deletion(-) + +diff --git a/kernel/arm64/KERNEL.ARMV8 b/kernel/arm64/KERNEL.ARMV8 +index fe32d313..33d12f94 100644 +--- a/kernel/arm64/KERNEL.ARMV8 ++++ b/kernel/arm64/KERNEL.ARMV8 +@@ -102,7 +102,6 @@ CDOTKERNEL = zdot.S + ZDOTKERNEL = zdot.S + DSDOTKERNEL = dot.S + +-DGEMM_BETA = dgemm_beta.S + SGEMM_BETA = sgemm_beta.S + + SGEMMKERNEL = sgemm_kernel_$(SGEMM_UNROLL_M)x$(SGEMM_UNROLL_N).S +-- +2.24.1 + diff --git a/nixpkgs/pkgs/development/libraries/science/math/openblas/default.nix b/nixpkgs/pkgs/development/libraries/science/math/openblas/default.nix new file mode 100644 index 000000000000..c55a5cb7878f --- /dev/null +++ b/nixpkgs/pkgs/development/libraries/science/math/openblas/default.nix @@ -0,0 +1,194 @@ +{ 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 +, enableStatic ? false +, enableShared ? true +}: + +with stdenv.lib; + +let blas64_ = blas64; in + +let + setTarget = x: if target == null then x else target; + + # To add support for a new platform, add an element to this set. + configs = { + armv6l-linux = { + BINARY = 32; + TARGET = setTarget "ARMV6"; + DYNAMIC_ARCH = false; + USE_OPENMP = true; + }; + + armv7l-linux = { + BINARY = 32; + TARGET = setTarget "ARMV7"; + DYNAMIC_ARCH = false; + USE_OPENMP = true; + }; + + aarch64-linux = { + BINARY = 64; + TARGET = setTarget "ARMV8"; + DYNAMIC_ARCH = true; + USE_OPENMP = true; + }; + + i686-linux = { + BINARY = 32; + TARGET = setTarget "P2"; + DYNAMIC_ARCH = true; + USE_OPENMP = true; + }; + + x86_64-darwin = { + BINARY = 64; + TARGET = setTarget "ATHLON"; + DYNAMIC_ARCH = true; + USE_OPENMP = false; + MACOSX_DEPLOYMENT_TARGET = "10.7"; + }; + + x86_64-linux = { + BINARY = 64; + TARGET = setTarget "ATHLON"; + DYNAMIC_ARCH = true; + NO_AVX512 = true; + USE_OPENMP = !stdenv.hostPlatform.isMusl; + }; + }; +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}"); +in +stdenv.mkDerivation rec { + pname = "openblas"; + version = "0.3.8"; + src = fetchFromGitHub { + owner = "xianyi"; + repo = "OpenBLAS"; + rev = "v${version}"; + sha256 = "0s017qqi4n6jzrxl9cyx625wj26smnyn5g8s699s7h8v1srlrw6p"; + }; + + 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 + ]; + + # Disable an optimisation which seems to cause issues, pending an + # upstream fix: https://github.com/xianyi/OpenBLAS/issues/2496 + patches = stdenv.lib.optionals stdenv.hostPlatform.isAarch64 [ + ./0001-Disable-optimised-aarch64-dgemm_beta-pending-fix.patch + ]; + + 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; + } // (stdenv.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 + ln -s $out/lib/libopenblas${stdenv.hostPlatform.extensions.sharedLibrary} $out/lib/libblas${stdenv.hostPlatform.extensions.sharedLibrary} + ln -s $out/lib/libopenblas${stdenv.hostPlatform.extensions.sharedLibrary} $out/lib/libcblas${stdenv.hostPlatform.extensions.sharedLibrary} + ln -s $out/lib/libopenblas${stdenv.hostPlatform.extensions.sharedLibrary} $out/lib/liblapack${stdenv.hostPlatform.extensions.sharedLibrary} + ln -s $out/lib/libopenblas${stdenv.hostPlatform.extensions.sharedLibrary} $out/lib/liblapacke${stdenv.hostPlatform.extensions.sharedLibrary} + ''; + + meta = with stdenv.lib; { + description = "Basic Linear Algebra Subprograms"; + license = licenses.bsd3; + homepage = "https://github.com/xianyi/OpenBLAS"; + platforms = platforms.unix; + maintainers = with maintainers; [ ttuegel ]; + }; +} diff --git a/nixpkgs/pkgs/development/libraries/science/math/openlibm/default.nix b/nixpkgs/pkgs/development/libraries/science/math/openlibm/default.nix new file mode 100644 index 000000000000..7517ca9c6cb5 --- /dev/null +++ b/nixpkgs/pkgs/development/libraries/science/math/openlibm/default.nix @@ -0,0 +1,20 @@ +{ stdenv, fetchurl }: + +stdenv.mkDerivation rec { + pname = "openlibm"; + version = "0.7.0"; + src = fetchurl { + url = "https://github.com/JuliaLang/openlibm/archive/v${version}.tar.gz"; + sha256 = "18q6mrq4agvlpvhix2k13qcyvqqzh30vj7b329dva64035rzg68n"; + }; + + makeFlags = [ "prefix=$(out)" ]; + + meta = { + description = "High quality system independent, portable, open source libm implementation"; + homepage = "https://www.openlibm.org/"; + license = stdenv.lib.licenses.mit; + maintainers = [ stdenv.lib.maintainers.ttuegel ]; + platforms = stdenv.lib.platforms.all; + }; +} diff --git a/nixpkgs/pkgs/development/libraries/science/math/openspecfun/default.nix b/nixpkgs/pkgs/development/libraries/science/math/openspecfun/default.nix new file mode 100644 index 000000000000..3689df607074 --- /dev/null +++ b/nixpkgs/pkgs/development/libraries/science/math/openspecfun/default.nix @@ -0,0 +1,21 @@ +{ stdenv, fetchurl, gfortran }: + +stdenv.mkDerivation { + name = "openspecfun-0.5.3"; + src = fetchurl { + url = "https://github.com/JuliaLang/openspecfun/archive/v0.5.3.tar.gz"; + sha256 = "1rs1bv8jq751fv9vq79890wqf9xlbjc7lvz3ighzyfczbyjcf18m"; + }; + + makeFlags = [ "prefix=$(out)" ]; + + nativeBuildInputs = [ gfortran ]; + + meta = { + description = "A collection of special mathematical functions"; + homepage = "https://github.com/JuliaLang/openspecfun"; + license = stdenv.lib.licenses.mit; + maintainers = [ stdenv.lib.maintainers.ttuegel ]; + platforms = stdenv.lib.platforms.all; + }; +} diff --git a/nixpkgs/pkgs/development/libraries/science/math/or-tools/default.nix b/nixpkgs/pkgs/development/libraries/science/math/or-tools/default.nix new file mode 100644 index 000000000000..ce6780f0046a --- /dev/null +++ b/nixpkgs/pkgs/development/libraries/science/math/or-tools/default.nix @@ -0,0 +1,73 @@ +{ stdenv, fetchFromGitHub, cmake, abseil-cpp, gflags, which +, lsb-release, glog, protobuf3_11, cbc, zlib +, ensureNewerSourcesForZipFilesHook, python, swig }: + +let + protobuf = protobuf3_11; + pythonProtobuf = python.pkgs.protobuf.override { inherit protobuf; }; + +in stdenv.mkDerivation rec { + pname = "or-tools"; + version = "7.5"; + + src = fetchFromGitHub { + owner = "google"; + repo = "or-tools"; + rev = "v${version}"; + sha256 = "1p9jwdwzcsaa58ap912hdf2w27vna3xl9g4lh6kjskddwi8l3wac"; + }; + + # 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. + configurePhase = '' + cat <<EOF > Makefile.local + UNIX_ABSL_DIR=${abseil-cpp} + UNIX_GFLAGS_DIR=${gflags} + UNIX_GLOG_DIR=${glog} + UNIX_PROTOBUF_DIR=${protobuf} + UNIX_CBC_DIR=${cbc} + EOF + ''; + + makeFlags = [ + "prefix=${placeholder "out"}" + "PROTOBUF_PYTHON_DESC=${pythonProtobuf}/${python.sitePackages}/google/protobuf/descriptor_pb2.py" + ]; + buildFlags = [ "cc" "pypi_archive" ]; + + checkTarget = "test_cc"; + doCheck = true; + + 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') + ''; + + nativeBuildInputs = [ + cmake lsb-release swig which zlib python + ensureNewerSourcesForZipFilesHook + python.pkgs.setuptools python.pkgs.wheel + ]; + propagatedBuildInputs = [ + abseil-cpp gflags glog protobuf cbc + pythonProtobuf python.pkgs.six + ]; + + enableParallelBuilding = true; + + outputs = [ "out" "python" ]; + + meta = with stdenv.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; + }; +} diff --git a/nixpkgs/pkgs/development/libraries/science/math/osi/default.nix b/nixpkgs/pkgs/development/libraries/science/math/osi/default.nix new file mode 100644 index 000000000000..b6f367ff4fe9 --- /dev/null +++ b/nixpkgs/pkgs/development/libraries/science/math/osi/default.nix @@ -0,0 +1,42 @@ +{ stdenv, lib, fetchurl, gfortran, pkgconfig +, 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 pkgconfig ]; + 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 stdenv.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 ]; + }; +} diff --git a/nixpkgs/pkgs/development/libraries/science/math/parmetis/default.nix b/nixpkgs/pkgs/development/libraries/science/math/parmetis/default.nix new file mode 100644 index 000000000000..97023d07c7f3 --- /dev/null +++ b/nixpkgs/pkgs/development/libraries/science/math/parmetis/default.nix @@ -0,0 +1,33 @@ +{ 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"; + }; + + buildInputs = [ cmake 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 stdenv.lib; { + description = "ParMETIS is 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 ]; + }; +} diff --git a/nixpkgs/pkgs/development/libraries/science/math/petsc/default.nix b/nixpkgs/pkgs/development/libraries/science/math/petsc/default.nix new file mode 100644 index 000000000000..200dd58a4357 --- /dev/null +++ b/nixpkgs/pkgs/development/libraries/science/math/petsc/default.nix @@ -0,0 +1,42 @@ +{ stdenv , fetchurl , blas , gfortran , lapack , python }: + +stdenv.mkDerivation rec { + pname = "petsc"; + version = "3.13.0"; + + src = fetchurl { + url = "http://ftp.mcs.anl.gov/pub/petsc/release-snapshots/petsc-${version}.tar.gz"; + sha256 = "0943bydmsq3sjwj3rxhb8hx58b1fm8vymny731557fs10g5zfbyz"; + }; + + nativeBuildInputs = [ blas gfortran.cc.lib lapack python ]; + + prePatch = stdenv.lib.optionalString stdenv.isDarwin '' + substituteInPlace config/install.py \ + --replace /usr/bin/install_name_tool install_name_tool + ''; + + preConfigure = '' + patchShebangs . + configureFlagsArray=( + $configureFlagsArray + "--CC=$CC" + "--with-cxx=$CXX" + "--with-fc=0" + "--with-mpi=0" + "--with-blas-lib=[${blas}/lib/libblas.so,${gfortran.cc.lib}/lib/libgfortran.a]" + "--with-lapack-lib=[${lapack}/lib/liblapack.so,${gfortran.cc.lib}/lib/libgfortran.a]" + ) + ''; + + meta = with stdenv.lib; { + description = '' + Library of linear algebra algorithms for solving partial differential + equations + ''; + homepage = "https://www.mcs.anl.gov/petsc/index.html"; + license = licenses.bsd2; + maintainers = with maintainers; [ wucke13 ]; + platforms = platforms.all; + }; +} diff --git a/nixpkgs/pkgs/development/libraries/science/math/planarity/default.nix b/nixpkgs/pkgs/development/libraries/science/math/planarity/default.nix new file mode 100644 index 000000000000..7767e23934cf --- /dev/null +++ b/nixpkgs/pkgs/development/libraries/science/math/planarity/default.nix @@ -0,0 +1,39 @@ +{ stdenv +, fetchFromGitHub +, fetchpatch +, autoreconfHook +}: + +stdenv.mkDerivation rec { + pname = "planarity"; + version = "3.0.0.5"; + + src = fetchFromGitHub { + owner = "graph-algorithms"; + repo = "edge-addition-planarity-suite"; + rev = "Version_${version}"; + sha256 = "01cm7ay1njkfsdnmnvh5zwc7wg7x189hq1vbfhh9p3ihrbnmqzh8"; + }; + + nativeBuildInputs = [ + autoreconfHook + ]; + + doCheck = true; + + patches = [ + # declare variables declared in headers as extern, not yet merged upstream + (fetchpatch { + url = "https://github.com/graph-algorithms/edge-addition-planarity-suite/pull/3.patch"; + sha256 = "1nqjc4clr326imz4jxqxcxv2hgh1sjgzll27k5cwkdin8lnmmil8"; + }) + ]; + + meta = with stdenv.lib; { + homepage = "https://github.com/graph-algorithms/edge-addition-planarity-suite"; + description = "A library for implementing graph algorithms"; + license = licenses.bsd3; + maintainers = with maintainers; [ timokau ]; + platforms = platforms.unix; + }; +} diff --git a/nixpkgs/pkgs/development/libraries/science/math/primesieve/default.nix b/nixpkgs/pkgs/development/libraries/science/math/primesieve/default.nix new file mode 100644 index 000000000000..46709ff218a0 --- /dev/null +++ b/nixpkgs/pkgs/development/libraries/science/math/primesieve/default.nix @@ -0,0 +1,21 @@ +{ stdenv, fetchurl, cmake }: + +stdenv.mkDerivation rec { + pname = "primesieve"; + version = "7.5"; + + nativeBuildInputs = [cmake]; + + src = fetchurl { + url = "https://github.com/kimwalisch/primesieve/archive/v${version}.tar.gz"; + sha256 = "0g60br3p8di92jx3pr2bb51xh15gg57l7qvwzwn7xf7l585hgi7v"; + }; + + meta = with stdenv.lib; { + description = "Fast C/C++ prime number generator"; + homepage = "https://primesieve.org/"; + license = licenses.bsd2; + platforms = platforms.unix; + maintainers = with maintainers; [ abbradar ]; + }; +} diff --git a/nixpkgs/pkgs/development/libraries/science/math/rankwidth/default.nix b/nixpkgs/pkgs/development/libraries/science/math/rankwidth/default.nix new file mode 100644 index 000000000000..ded7b7dc90ac --- /dev/null +++ b/nixpkgs/pkgs/development/libraries/science/math/rankwidth/default.nix @@ -0,0 +1,27 @@ +{ stdenv +, fetchurl +}: + +stdenv.mkDerivation rec { + pname = "rankwidth"; + version = "0.7"; + + src = fetchurl { + url = "mirror://sageupstream/rw/rw-${version}.tar.gz"; + sha256 = "1rv2v42x2506x7f10349m1wpmmfxrv9l032bkminni2gbip9cjg0"; + }; + + configureFlags = [ + "--enable-executable=no" # no igraph dependency + ]; + + # check phase is empty for now (as of version 0.7) + doCheck = true; + + meta = with stdenv.lib; { + description = "Calculates rank-width and rank-decompositions"; + license = with licenses; [ gpl2Plus ]; + maintainers = with maintainers; [ timokau ]; + platforms = platforms.unix; + }; +} diff --git a/nixpkgs/pkgs/development/libraries/science/math/rubiks/default.nix b/nixpkgs/pkgs/development/libraries/science/math/rubiks/default.nix new file mode 100644 index 000000000000..6eeaddba0418 --- /dev/null +++ b/nixpkgs/pkgs/development/libraries/science/math/rubiks/default.nix @@ -0,0 +1,81 @@ +{ 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 stdenv.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 = with maintainers; [ timokau ]; + platforms = platforms.unix; + }; +} diff --git a/nixpkgs/pkgs/development/libraries/science/math/scalapack/default.nix b/nixpkgs/pkgs/development/libraries/science/math/scalapack/default.nix new file mode 100644 index 000000000000..d20219860296 --- /dev/null +++ b/nixpkgs/pkgs/development/libraries/science/math/scalapack/default.nix @@ -0,0 +1,55 @@ +{ stdenv, fetchFromGitHub, cmake, openssh +, gfortran, mpi, blas, lapack +} : + +assert (!blas.is64bit) && (!lapack.is64bit); + +stdenv.mkDerivation rec { + pname = "scalapack"; + version = "2.1.0"; + + src = fetchFromGitHub { + owner = "Reference-ScaLAPACK"; + repo = pname; + rev = "v${version}"; + sha256 = "1c10d18gj3kvpmyv5q246x35hjxaqn4ygy1cygaydhyxnm4klzdj"; + }; + + nativeBuildInputs = [ cmake openssh ]; + buildInputs = [ mpi gfortran blas lapack ]; + + enableParallelBuilding = true; + + doCheck = true; + + preConfigure = '' + cmakeFlagsArray+=( + -DBUILD_SHARED_LIBS=ON -DBUILD_STATIC_LIBS=OFF + -DLAPACK_LIBRARIES="-llapack" + -DBLAS_LIBRARIES="-lblas" + ) + ''; + + # 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 + + # Run single threaded + export OMP_NUM_THREADS=1 + + export LD_LIBRARY_PATH=$LD_LIBRARY_PATH''${LD_LIBRARY_PATH:+:}`pwd`/lib + ''; + + meta = with stdenv.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 ]; + }; + +} diff --git a/nixpkgs/pkgs/development/libraries/science/math/scs/default.nix b/nixpkgs/pkgs/development/libraries/science/math/scs/default.nix new file mode 100644 index 000000000000..2dcb47f11baa --- /dev/null +++ b/nixpkgs/pkgs/development/libraries/science/math/scs/default.nix @@ -0,0 +1,52 @@ +{ stdenv, fetchFromGitHub, blas, lapack, gfortran, fixDarwinDylibNames }: + +assert (!blas.is64bit) && (!lapack.is64bit); + +stdenv.mkDerivation rec { + pname = "scs"; + version = "2.1.1"; + + src = fetchFromGitHub { + owner = "cvxgrp"; + repo = "scs"; + rev = version; + sha256 = "14g5m3lcvrbwpq1bq0liq00jh0gm1947lg3z4jfsp43f6p5alb20"; + }; + + # Actually link and add libgfortran to the rpath + postPatch = '' + substituteInPlace scs.mk \ + --replace "#-lgfortran" "-lgfortran" \ + --replace "gcc" "cc" + ''; + + nativeBuildInputs = stdenv.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 stdenv.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 ]; + }; +} diff --git a/nixpkgs/pkgs/development/libraries/science/math/spooles/default.nix b/nixpkgs/pkgs/development/libraries/science/math/spooles/default.nix new file mode 100644 index 000000000000..953f5a70b8aa --- /dev/null +++ b/nixpkgs/pkgs/development/libraries/science/math/spooles/default.nix @@ -0,0 +1,48 @@ +{ stdenv, fetchurl, gfortran, 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 + ]; + + 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 stdenv.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; + }; +} diff --git a/nixpkgs/pkgs/development/libraries/science/math/spooles/spooles.patch b/nixpkgs/pkgs/development/libraries/science/math/spooles/spooles.patch new file mode 100644 index 000000000000..c0c93c9365c9 --- /dev/null +++ b/nixpkgs/pkgs/development/libraries/science/math/spooles/spooles.patch @@ -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 ++ gcc -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 + diff --git a/nixpkgs/pkgs/development/libraries/science/math/suitesparse-graphblas/default.nix b/nixpkgs/pkgs/development/libraries/science/math/suitesparse-graphblas/default.nix new file mode 100644 index 000000000000..599c1be66461 --- /dev/null +++ b/nixpkgs/pkgs/development/libraries/science/math/suitesparse-graphblas/default.nix @@ -0,0 +1,32 @@ +{ stdenv +, fetchFromGitHub +, cmake +, gnum4 +}: + +stdenv.mkDerivation rec { + pname = "suitesparse-graphblas"; + version = "3.2.1"; + + outputs = [ "out" "dev" ]; + + src = fetchFromGitHub { + owner = "DrTimothyAldenDavis"; + repo = "GraphBLAS"; + rev = "v${version}"; + sha256 = "AAwwzrpKFHy40Ldm6hTO6L0FWPYwi3kJj3zrshFwYas="; + }; + + nativeBuildInputs = [ + cmake + gnum4 + ]; + + meta = with stdenv.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; + }; +} diff --git a/nixpkgs/pkgs/development/libraries/science/math/suitesparse/4.2.nix b/nixpkgs/pkgs/development/libraries/science/math/suitesparse/4.2.nix new file mode 100644 index 000000000000..34a1fb7ad9e6 --- /dev/null +++ b/nixpkgs/pkgs/development/libraries/science/math/suitesparse/4.2.nix @@ -0,0 +1,43 @@ +{ stdenv, fetchurl, gfortran, blas, lapack }: + +let + int_t = if blas.is64bit 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 stdenv.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; + }; +} diff --git a/nixpkgs/pkgs/development/libraries/science/math/suitesparse/4.4.nix b/nixpkgs/pkgs/development/libraries/science/math/suitesparse/4.4.nix new file mode 100644 index 000000000000..b2b7e666b7ef --- /dev/null +++ b/nixpkgs/pkgs/development/libraries/science/math/suitesparse/4.4.nix @@ -0,0 +1,100 @@ +{ stdenv, fetchurl, gfortran, blas, lapack +, enableCuda ? false, cudatoolkit +}: + +let + version = "4.4.4"; + name = "suitesparse-${version}"; + + int_t = if blas.is64bit then "int64_t" else "int32_t"; + SHLIB_EXT = stdenv.hostPlatform.extensions.sharedLibrary; +in +stdenv.mkDerivation { + inherit name; + + 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}/' + '' + + stdenv.lib.optionalString stdenv.isDarwin '' + sed -i "SuiteSparse_config/SuiteSparse_config.mk" \ + -e 's/^[[:space:]]*\(LIB = -lm\) -lrt/\1/' + '' + + stdenv.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 = stdenv.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 ${stdenv.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/${name} + 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 stdenv.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; + }; +} diff --git a/nixpkgs/pkgs/development/libraries/science/math/suitesparse/default.nix b/nixpkgs/pkgs/development/libraries/science/math/suitesparse/default.nix new file mode 100644 index 000000000000..48177987a7a2 --- /dev/null +++ b/nixpkgs/pkgs/development/libraries/science/math/suitesparse/default.nix @@ -0,0 +1,90 @@ +{ stdenv +, fetchFromGitHub +, gfortran +, blas, lapack +, metis +, fixDarwinDylibNames +, gnum4 +, enableCuda ? false +, cudatoolkit +}: + +stdenv.mkDerivation rec { + pname = "suitesparse"; + version = "5.7.2"; + + outputs = [ "out" "dev" "doc" ]; + + src = fetchFromGitHub { + owner = "DrTimothyAldenDavis"; + repo = "SuiteSparse"; + rev = "v${version}"; + sha256 = "1imndff7yygjrbbrcscsmirdi8w0lkwj5dbhydxmf7lklwn4j3q6"; + }; + + nativeBuildInputs = [ + gnum4 + ] ++ stdenv.lib.optional stdenv.isDarwin fixDarwinDylibNames; + + buildInputs = [ + blas lapack + metis + gfortran.cc.lib + ] ++ stdenv.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)" + "BLAS=-lblas" + "LAPACK=-llapack" + "MY_METIS_LIB=-lmetis" + ] ++ stdenv.lib.optionals blas.is64bit [ + "CFLAGS=-DBLAS64" + ] ++ stdenv.lib.optionals enableCuda [ + "CUDA_PATH=${cudatoolkit}" + "CUDART_LIB=${cudatoolkit.lib}/lib/libcudart.so" + "CUBLAS_LIB=${cudatoolkit}/lib/libcublas.so" + ]; + + buildFlags = [ + # Build individual shared libraries, not demos + "library" + ]; + + # Likely fixed after 5.7.2 + # https://github.com/DrTimothyAldenDavis/SuiteSparse/commit/f6daae26ee391e475e2295e77c839aa7c1a8b784 + postInstall = stdenv.lib.optionalString stdenv.isDarwin '' + # The fixDarwinDylibNames in nixpkgs can't seem to fix all the libraries. + # We manually fix them up here. + fixDarwinDylibNames() { + local flags=() + local old_id + + for fn in "$@"; do + flags+=(-change "$PWD/lib/$(basename "$fn")" "$fn") + done + + for fn in "$@"; do + if [ -L "$fn" ]; then continue; fi + echo "$fn: fixing dylib" + install_name_tool -id "$fn" "''${flags[@]}" "$fn" + done + } + + fixDarwinDylibNames $(find "$out" -name "*.dylib") + ''; + + meta = with stdenv.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; + }; +} diff --git a/nixpkgs/pkgs/development/libraries/science/math/superlu/add-superlu-lib-as-dependency-for-the-unit-tests.patch b/nixpkgs/pkgs/development/libraries/science/math/superlu/add-superlu-lib-as-dependency-for-the-unit-tests.patch new file mode 100644 index 000000000000..29d86238af08 --- /dev/null +++ b/nixpkgs/pkgs/development/libraries/science/math/superlu/add-superlu-lib-as-dependency-for-the-unit-tests.patch @@ -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) diff --git a/nixpkgs/pkgs/development/libraries/science/math/superlu/default.nix b/nixpkgs/pkgs/development/libraries/science/math/superlu/default.nix new file mode 100644 index 000000000000..05ceb21387d3 --- /dev/null +++ b/nixpkgs/pkgs/development/libraries/science/math/superlu/default.nix @@ -0,0 +1,37 @@ +{ stdenv, fetchurl, cmake, + gfortran, blas, lapack}: + +assert (!blas.is64bit) && (!lapack.is64bit); + +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"; + }; + + buildInputs = [ 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 = stdenv.lib.platforms.unix; + }; +} diff --git a/nixpkgs/pkgs/development/libraries/science/math/sympow/default.nix b/nixpkgs/pkgs/development/libraries/science/math/sympow/default.nix new file mode 100644 index 000000000000..e67f61599b57 --- /dev/null +++ b/nixpkgs/pkgs/development/libraries/science/math/sympow/default.nix @@ -0,0 +1,74 @@ +{ stdenv +, fetchFromGitLab +, makeWrapper +, which +, autoconf +, help2man +, file +, pari +}: + +stdenv.mkDerivation rec { + version = "2.023.5"; + pname = "sympow"; + + src = fetchFromGitLab { + group = "rezozer"; + owner = "forks"; + repo = "sympow"; + rev = "v${version}"; + sha256 = "1c5a2pizgqsf3pjkf7rfj20022ym4ixhrddp8ivs2nbzxwz6qvv9"; + }; + + 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 stdenv.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 = with maintainers; [ timokau ]; + platforms = platforms.linux; + }; +} diff --git a/nixpkgs/pkgs/development/libraries/science/math/tensorflow/bin.nix b/nixpkgs/pkgs/development/libraries/science/math/tensorflow/bin.nix new file mode 100644 index 000000000000..dc0ca5da4cfa --- /dev/null +++ b/nixpkgs/pkgs/development/libraries/science/math/tensorflow/bin.nix @@ -0,0 +1,77 @@ +{ stdenv +, fetchurl +, addOpenGLRunpath +, cudaSupport ? false, symlinkJoin, cudatoolkit, cudnn, nvidia_x11 +}: + +with stdenv.lib; +let + unavailable = throw "libtensorflow is not available for this platform!"; + + tfType = if cudaSupport then "gpu" else "cpu"; + + system = + if stdenv.isLinux then "linux" + else if stdenv.isDarwin then "darwin" + else unavailable; + + platform = + if stdenv.isx86_64 then "x86_64" + else unavailable; + + rpath = makeLibraryPath ([stdenv.cc.libc stdenv.cc.cc.lib] ++ + optionals cudaSupport [ cudatoolkit.out cudatoolkit.lib cudnn nvidia_x11 ]); + + packages = import ./binary-hashes.nix; + packageName = "${tfType}-${system}-${platform}"; + url = packages.${packageName} or unavailable; + + patchLibs = + if stdenv.isDarwin + then '' + install_name_tool -id $out/lib/libtensorflow.dylib $out/lib/libtensorflow.dylib + install_name_tool -id $out/lib/libtensorflow_framework.dylib $out/lib/libtensorflow_framework.dylib + '' + else '' + patchelf --set-rpath "${rpath}:$out/lib" $out/lib/libtensorflow.so + patchelf --set-rpath "${rpath}" $out/lib/libtensorflow_framework.so + ${optionalString cudaSupport '' + addOpenGLRunpath $out/lib/libtensorflow.so $out/lib/libtensorflow_framework.so + ''} + ''; + +in stdenv.mkDerivation rec { + pname = "libtensorflow"; + inherit (packages) version; + + src = fetchurl url; + + nativeBuildInputs = optional cudaSupport addOpenGLRunpath; + + # Patch library to use our libc, libstdc++ and others + buildCommand = '' + mkdir -pv $out + tar -C $out -xzf $src + chmod -R +w $out + ${patchLibs} + + # Write pkgconfig file. + mkdir $out/lib/pkgconfig + cat > $out/lib/pkgconfig/tensorflow.pc << EOF + Name: TensorFlow + Version: ${version} + Description: Library for computation using data flow graphs for scalable machine learning + Requires: + Libs: -L$out/lib -ltensorflow + Cflags: -I$out/include/tensorflow + EOF + ''; + + meta = { + description = "C API for TensorFlow"; + homepage = "https://www.tensorflow.org/install/lang_c"; + license = licenses.asl20; + platforms = [ "x86_64-linux" "x86_64-darwin" ]; + maintainers = with maintainers; [ basvandijk ]; + }; +} diff --git a/nixpkgs/pkgs/development/libraries/science/math/tensorflow/binary-hashes.nix b/nixpkgs/pkgs/development/libraries/science/math/tensorflow/binary-hashes.nix new file mode 100644 index 000000000000..76f0c5eea7fa --- /dev/null +++ b/nixpkgs/pkgs/development/libraries/science/math/tensorflow/binary-hashes.nix @@ -0,0 +1,15 @@ +{ +version = "1.14.0"; +cpu-linux-x86_64 = { + url = "https://storage.googleapis.com/tensorflow/libtensorflow/libtensorflow-cpu-linux-x86_64-1.14.0.tar.gz"; + sha256 = "04bi3ijq4sbb8c5vk964zlv0j9mrjnzzxd9q9knq3h273nc1a36k"; +}; +gpu-linux-x86_64 = { + url = "https://storage.googleapis.com/tensorflow/libtensorflow/libtensorflow-gpu-linux-x86_64-1.14.0.tar.gz"; + sha256 = "1ffnpyj9jjgwxpjfiyjvq4dm3n6nwiksim5jld9zw7fdswh215x6"; +}; +cpu-darwin-x86_64 = { + url = "https://storage.googleapis.com/tensorflow/libtensorflow/libtensorflow-cpu-darwin-x86_64-1.14.0.tar.gz"; + sha256 = "0zsd5ils1a17j6jzh0c7q1z56fw46gkzybbnms7h2rgg8al0rh92"; +}; +} diff --git a/nixpkgs/pkgs/development/libraries/science/math/tensorflow/prefetcher.sh b/nixpkgs/pkgs/development/libraries/science/math/tensorflow/prefetcher.sh new file mode 100755 index 000000000000..515f25df4c1f --- /dev/null +++ b/nixpkgs/pkgs/development/libraries/science/math/tensorflow/prefetcher.sh @@ -0,0 +1,24 @@ +#!/usr/bin/env bash + +version=1.14.0 +hashfile=binary-hashes.nix +rm -f $hashfile +echo "{" >> $hashfile +echo "version = \"$version\";" >> $hashfile +for sys in "linux" "darwin"; do + for tfpref in "cpu" "gpu"; do + for platform in "x86_64"; do + if [ $sys = "darwin" ] && [ $tfpref = "gpu" ]; then + continue + fi + url=https://storage.googleapis.com/tensorflow/libtensorflow/libtensorflow-$tfpref-$sys-$platform-$version.tar.gz + hash=$(nix-prefetch-url $url) + echo "\"${tfpref}-${sys}-${platform}\" = {" >> $hashfile + echo " url = \"$url\";" >> $hashfile + echo " sha256 = \"$hash\";" >> $hashfile + echo "};" >> $hashfile + done + done +done +echo "}" >> $hashfile + diff --git a/nixpkgs/pkgs/development/libraries/science/math/zn_poly/default.nix b/nixpkgs/pkgs/development/libraries/science/math/zn_poly/default.nix new file mode 100644 index 000000000000..a94a52936e8f --- /dev/null +++ b/nixpkgs/pkgs/development/libraries/science/math/zn_poly/default.nix @@ -0,0 +1,74 @@ +{ stdenv +, lib +, fetchFromGitLab +, fetchpatch +, gmp +, python2 +, tune ? false # tune to hardware, impure +}: + +stdenv.mkDerivation rec { + version = "0.9.1"; + pname = "zn_poly"; + + # sage has picked up the maintenance (bug fixes and building, not development) + # from the original, now unmaintained project which can be found at + # http://web.maths.unsw.edu.au/~davidharvey/code/zn_poly/ + src = fetchFromGitLab { + owner = "sagemath"; + repo = "zn_poly"; + rev = version; + sha256 = "0ra5vy585bqq7g3317iw6fp44iqgqvds3j0l1va6mswimypq4vxb"; + }; + + buildInputs = [ + gmp + ]; + + nativeBuildInputs = [ + python2 # needed by ./configure to create the makefile + ]; + + # name of library file ("libzn_poly.so") + libbasename = "libzn_poly"; + libext = stdenv.targetPlatform.extensions.sharedLibrary; + + makeFlags = [ "CC=cc" ]; + + # Tuning (either autotuning or with hand-written paramters) is possible + # but not implemented here. + # It seems buggy anyways (see homepage). + buildFlags = [ "all" "${libbasename}${libext}" ]; + + configureFlags = lib.optionals (!tune) [ + "--disable-tuning" + ]; + + patches = [ + # fix format-security by not passing variables directly to printf + # https://gitlab.com/sagemath/zn_poly/merge_requests/1 + (fetchpatch { + name = "format-security.patch"; + url = "https://gitlab.com/timokau/zn_poly/commit/1950900a80ec898d342b8bcafa148c8027649766.patch"; + sha256 = "1gks9chvsfpc6sg5h3nqqfia4cgvph7jmj9dw67k7dk7kv9y0rk1"; + }) + ]; + + # `make install` fails to install some header files and the lib file. + installPhase = '' + mkdir -p "$out/include/zn_poly" + mkdir -p "$out/lib" + cp "${libbasename}"*"${libext}" "$out/lib" + cp include/*.h "$out/include/zn_poly" + ''; + + doCheck = true; + + meta = with lib; { + homepage = "http://web.maths.unsw.edu.au/~davidharvey/code/zn_poly/"; + description = "Polynomial arithmetic over Z/nZ"; + license = with licenses; [ gpl3 ]; + maintainers = with maintainers; [ timokau ]; + platforms = platforms.unix; + }; +} |