commit aca03db0910ec01c3717f107dfef7626bf252a51 · pyrox.dev/nixpkgs

+83

pkgs/development/interpreters/octave/build-env.nix

···

       1
       1
       +
       { stdenv, octave, buildEnv

     

       2
       2
       +
       , makeWrapper, texinfo

     

       3
       3
       +
       , octavePackages

     

       4
       4
       +
       , wrapOctave

     

       5
       5
       +
       , computeRequiredOctavePackages

     

       6
       6
       +
       , extraLibs ? []

     

       7
       7
       +
       , extraOutputsToInstall ? []

     

       8
       8
       +
       , postBuild ? ""

     

       9
       9
       +
       , ignoreCollisions ? false

     

       10
       10
       +
       }:

     

       11
       11
       +
       

     

       12
       12
       +
       # Create an octave executable that knows about additional packages

     

       13
       13
       +
       let

     

       14
       14
       +
         packages = computeRequiredOctavePackages extraLibs;

     

       15
       15
       +
       

     

       16
       16
       +
       in buildEnv {

     

       17
       17
       +
         name = "${octave.name}-env";

     

       18
       18
       +
         paths = extraLibs ++ [ octave ];

     

       19
       19
       +
       

     

       20
       20
       +
         inherit ignoreCollisions;

     

       21
       21
       +
         extraOutputsToInstall = [ "out" ] ++ extraOutputsToInstall;

     

       22
       22
       +
       

     

       23
       23
       +
         buildInputs = [ makeWrapper texinfo wrapOctave ];

     

       24
       24
       +
       

     

       25
       25
       +
         # During "build" we must first unlink the /share symlink to octave's /share

     

       26
       26
       +
         # Then, we can re-symlink the all of octave/share, except for /share/octave

     

       27
       27
       +
         # in env/share/octave, re-symlink everything from octave/share/octave and then

     

       28
       28
       +
         # perform the pkg install.

     

       29
       29
       +
         postBuild = ''

     

       30
       30
       +
             . "${makeWrapper}/nix-support/setup-hook"

     

       31
       31
       +
             # The `makeWrapper` used here is the one defined in

     

       32
       32
       +
             # ${makeWrapper}/nix-support/setup-hook

     

       33
       33
       +
       

     

       34
       34
       +
             if [ -L "$out/bin" ]; then

     

       35
       35
       +
                unlink $out/bin

     

       36
       36
       +
                mkdir -p "$out/bin"

     

       37
       37
       +
                cd "${octave}/bin"

     

       38
       38
       +
                for prg in *; do

     

       39
       39
       +
                    if [ -x $prg ]; then

     

       40
       40
       +
                       makeWrapper "${octave}/bin/$prg" "$out/bin/$prg" --set OCTAVE_SITE_INITFILE "$out/share/octave/site/m/startup/octaverc"

     

       41
       41
       +
                    fi

     

       42
       42
       +
                done

     

       43
       43
       +
                cd $out

     

       44
       44
       +
             fi

     

       45
       45
       +
       

     

       46
       46
       +
             # Remove symlinks to the input tarballs, they aren't needed.

     

       47
       47
       +
             rm $out/*.tar.gz

     

       48
       48
       +
       

     

       49
       49
       +
             createOctavePackagesPath $out ${octave}

     

       50
       50
       +
       

     

       51
       51
       +
             for path in ${stdenv.lib.concatStringsSep " " packages}; do

     

       52
       52
       +
                 if [ -e $path/*.tar.gz ]; then

     

       53
       53
       +
                    $out/bin/octave-cli --eval "pkg local_list $out/.octave_packages; \

     

       54
       54
       +
                                                pkg prefix $out/${octave.octPkgsPath} $out/${octave.octPkgsPath}; \

     

       55
       55
       +
                                                pfx = pkg (\"prefix\"); \

     

       56
       56
       +
                                                pkg install -nodeps -local $path/*.tar.gz"

     

       57
       57
       +
                 fi

     

       58
       58
       +
             done

     

       59
       59
       +
       

     

       60
       60
       +
             # Re-write the octave-wide startup file (share/octave/site/m/startup/octaverc)

     

       61
       61
       +
             # To point to the new local_list in $out

     

       62
       62
       +
             addPkgLocalList $out ${octave}

     

       63
       63
       +
       

     

       64
       64
       +
             wrapOctavePrograms "${stdenv.lib.concatStringsSep " " packages}"

     

       65
       65
       +
            '' + postBuild;

     

       66
       66
       +
       

     

       67
       67
       +
         inherit (octave) meta;

     

       68
       68
       +
       

     

       69
       69
       +
         passthru = octave.passthru // {

     

       70
       70
       +
           interpreter = "$out/bin/octave";

     

       71
       71
       +
           inherit octave;

     

       72
       72
       +
           env = stdenv.mkDerivation {

     

       73
       73
       +
             name = "interactive-${octave.name}-environment";

     

       74
       74
       +
       

     

       75
       75
       +
             buildCommand = ''

     

       76
       76
       +
               echo >&2 ""

     

       77
       77
       +
               echo >&2 "*** octave 'env' attributes are intended for interactive nix-shell sessions, not for building! ***"

     

       78
       78
       +
               echo >&2 ""

     

       79
       79
       +
               exit 1

     

       80
       80
       +
             '';

     

       81
       81
       +
           };

     

       82
       82
       +
         };

     

       83
       83
       +
       }

+113

pkgs/development/interpreters/octave/build-octave-package.nix

···

       1
       1
       +
       # Generic builder for GNU Octave libraries.

     

       2
       2
       +
       # This is a file that contains nested functions. The first, outer, function

     

       3
       3
       +
       # is the library- and package-wide details, such as the nixpkgs library, any

     

       4
       4
       +
       # additional configuration provided, and the namePrefix to use (based on the

     

       5
       5
       +
       # pname and version of Octave), the octave package, etc.

     

       6
       6
       +
       

     

       7
       7
       +
       { lib

     

       8
       8
       +
       , stdenv

     

       9
       9
       +
       , config

     

       10
       10
       +
       , octave

     

       11
       11
       +
       , texinfo

     

       12
       12
       +
       , computeRequiredOctavePackages

     

       13
       13
       +
       , writeRequiredOctavePackagesHook

     

       14
       14
       +
       }:

     

       15
       15
       +
       

     

       16
       16
       +
       # The inner function contains information required to build the individual

     

       17
       17
       +
       # libraries.

     

       18
       18
       +
       { fullLibName ? "${attrs.pname}-${attrs.version}"

     

       19
       19
       +
       

     

       20
       20
       +
       , src

     

       21
       21
       +
       

     

       22
       22
       +
       , dontPatch ? false

     

       23
       23
       +
       , patches ? []

     

       24
       24
       +
       , patchPhase ? ""

     

       25
       25
       +
       

     

       26
       26
       +
       , enableParallelBuilding ? true

     

       27
       27
       +
       # Build-time dependencies for the package, which were compiled for the system compiling this.

     

       28
       28
       +
       , nativeBuildInputs ? []

     

       29
       29
       +
       

     

       30
       30
       +
       # Build-time dependencies for the package, which may not have been compiled for the system compiling this.

     

       31
       31
       +
       , buildInputs ? []

     

       32
       32
       +
       

     

       33
       33
       +
       # Propagate build dependencies so in case we have A -> B -> C,

     

       34
       34
       +
       # C can import package A propagated by B

     

       35
       35
       +
       # Run-time dependencies for the package.

     

       36
       36
       +
       , propagatedBuildInputs ? []

     

       37
       37
       +
       

     

       38
       38
       +
       # Octave packages that are required at runtime for this one.

     

       39
       39
       +
       # These behave similarly to propagatedBuildInputs, where if

     

       40
       40
       +
       # package A is needed by B, and C needs B, then C also requires A.

     

       41
       41
       +
       # The main difference between these and propagatedBuildInputs is

     

       42
       42
       +
       # during the package's installation into octave, where all

     

       43
       43
       +
       # requiredOctavePackages are ALSO installed into octave.

     

       44
       44
       +
       , requiredOctavePackages ? []

     

       45
       45
       +
       

     

       46
       46
       +
       , preBuild ? ""

     

       47
       47
       +
       

     

       48
       48
       +
       , meta ? {}

     

       49
       49
       +
       

     

       50
       50
       +
       , passthru ? {}

     

       51
       51
       +
       

     

       52
       52
       +
       , ... } @ attrs:

     

       53
       53
       +
       

     

       54
       54
       +
       let

     

       55
       55
       +
         requiredOctavePackages' = computeRequiredOctavePackages requiredOctavePackages;

     

       56
       56
       +
       

     

       57
       57
       +
       in stdenv.mkDerivation {

     

       58
       58
       +
         packageName = "${fullLibName}";

     

       59
       59
       +
         # The name of the octave package ends up being

     

       60
       60
       +
         # "octave-version-package-version"

     

       61
       61
       +
         name = "${octave.pname}-${octave.version}-${fullLibName}";

     

       62
       62
       +
       

     

       63
       63
       +
         # This states that any package built with the function that this returns

     

       64
       64
       +
         # will be an octave package. This is used for ensuring other octave

     

       65
       65
       +
         # packages are installed into octave during the environment building phase.

     

       66
       66
       +
         isOctavePackage = true;

     

       67
       67
       +
       

     

       68
       68
       +
         OCTAVE_HISTFILE = "/dev/null";

     

       69
       69
       +
       

     

       70
       70
       +
         inherit src;

     

       71
       71
       +
       

     

       72
       72
       +
         inherit dontPatch patches patchPhase;

     

       73
       73
       +
       

     

       74
       74
       +
         dontConfigure = true;

     

       75
       75
       +
       

     

       76
       76
       +
         enableParallelBuilding = enableParallelBuilding;

     

       77
       77
       +
       

     

       78
       78
       +
         requiredOctavePackages = requiredOctavePackages';

     

       79
       79
       +
       

     

       80
       80
       +
         nativeBuildInputs = [

     

       81
       81
       +
           octave

     

       82
       82
       +
           writeRequiredOctavePackagesHook

     

       83
       83
       +
         ]

     

       84
       84
       +
         ++ nativeBuildInputs;

     

       85
       85
       +
       

     

       86
       86
       +
         buildInputs = buildInputs ++ requiredOctavePackages';

     

       87
       87
       +
       

     

       88
       88
       +
         propagatedBuildInputs = propagatedBuildInputs ++ [ texinfo ];

     

       89
       89
       +
       

     

       90
       90
       +
         preBuild = if preBuild == "" then

     

       91
       91
       +
           ''

     

       92
       92
       +
             # This trickery is needed because Octave expects a single directory inside

     

       93
       93
       +
             # at the top-most level of the tarball.

     

       94
       94
       +
             tar --transform 's,^,${fullLibName}/,' -cz * -f ${fullLibName}.tar.gz

     

       95
       95
       +
           ''

     

       96
       96
       +
                    else

     

       97
       97
       +
                      preBuild;

     

       98
       98
       +
       

     

       99
       99
       +
         buildPhase = ''

     

       100
       100
       +
           runHook preBuild

     

       101
       101
       +
       

     

       102
       102
       +
           mkdir -p $out

     

       103
       103
       +
           octave-cli --eval "pkg build $out ${fullLibName}.tar.gz"

     

       104
       104
       +
       

     

       105
       105
       +
           runHook postBuild

     

       106
       106
       +
         '';

     

       107
       107
       +
       

     

       108
       108
       +
         # We don't install here, because that's handled when we build the environment

     

       109
       109
       +
         # together with Octave.

     

       110
       110
       +
         dontInstall = true;

     

       111
       111
       +
       

     

       112
       112
       +
         inherit meta;

     

       113
       113
       +
       }

+132 -99

pkgs/development/interpreters/octave/default.nix

···

       1
       1
        
       { stdenv

     

       2
       2
       +
       , pkgs

     

       2
       3
        
       , lib

     

       3
       4
        
       # Note: either stdenv.mkDerivation or, for octaveFull, the qt-5 mkDerivation

     

       4
       5
        
       # with wrapQtAppsHook (comes from libsForQt5.callPackage)

     
···

       45
       46
        
       , python ? null

     

       46
       47
        
       , overridePlatforms ? null

     

       47
       48
        
       , sundials ? null

     

       49
       49
       +
       # - Packages required for building extra packages.

     

       50
       50
       +
       , newScope

     

       51
       51
       +
       , callPackage

     

       52
       52
       +
       , makeSetupHook

     

       53
       53
       +
       , makeWrapper

     

       48
       54
        
       # - Build Octave Qt GUI:

     

       49
       55
        
       , enableQt ? false

     

       50
       56
        
       , qtbase ? null

     
···

       60
       66
        
       }:

     

       61
       67
        
       

     

       62
       68
        
       let

     

       69
       69
       +
       

     

       63
       70
        
         # Not always evaluated

     

       64
       71
        
         blas' = if use64BitIdx then

     

       65
       72
        
           blas.override {

     
···

       94
       101
        
         else

     

       95
       102
        
           null

     

       96
       103
        
         ;

     

       97
       97
       -
       in mkDerivation rec {

     

       98
       98
       -
         version = "6.2.0";

     

       99
       99
       -
         pname = "octave";

     

       100
       104
        
       

     

       101
       101
       -
         src = fetchurl {

     

       102
       102
       -
           url = "mirror://gnu/octave/${pname}-${version}.tar.gz";

     

       103
       103
       -
           sha256 = "sha256-RX0f2oY0qDni/Xz8VbmL1W82tq5z0xu530Pd4wEsqnw=";

     

       105
       105
       +
         octavePackages = import ../../../top-level/octave-packages.nix {

     

       106
       106
       +
           inherit pkgs;

     

       107
       107
       +
           inherit lib stdenv fetchurl newScope;

     

       108
       108
       +
           octave = self;

     

       104
       109
        
         };

     

       105
       110
        
       

     

       106
       106
       -
         buildInputs = [

     

       107
       107
       -
           readline

     

       108
       108
       -
           ncurses

     

       109
       109
       -
           perl

     

       110
       110
       -
           flex

     

       111
       111
       -
           qhull

     

       112
       112
       -
           graphicsmagick

     

       113
       113
       -
           pcre

     

       114
       114
       -
           fltk

     

       115
       115
       -
           zlib

     

       116
       116
       -
           curl

     

       117
       117
       -
           blas'

     

       118
       118
       -
           lapack'

     

       119
       119
       -
           libsndfile

     

       120
       120
       -
           fftw

     

       121
       121
       -
           fftwSinglePrec

     

       122
       122
       -
           portaudio

     

       123
       123
       -
           qrupdate'

     

       124
       124
       -
           arpack'

     

       125
       125
       -
           libwebp

     

       126
       126
       -
           gl2ps

     

       127
       127
       -
         ]

     

       128
       128
       -
         ++ lib.optionals enableQt [

     

       129
       129
       -
           qtbase

     

       130
       130
       -
           qtsvg

     

       131
       131
       -
           qscintilla

     

       132
       132
       -
         ]

     

       133
       133
       -
         ++ lib.optionals (ghostscript != null) [ ghostscript ]

     

       134
       134
       -
         ++ lib.optionals (hdf5 != null) [ hdf5 ]

     

       135
       135
       -
         ++ lib.optionals (glpk != null) [ glpk ]

     

       136
       136
       -
         ++ lib.optionals (suitesparse != null) [ suitesparse' ]

     

       137
       137
       -
         ++ lib.optionals (enableJava) [ jdk ]

     

       138
       138
       -
         ++ lib.optionals (sundials != null) [ sundials ]

     

       139
       139
       -
         ++ lib.optionals (gnuplot != null) [ gnuplot ]

     

       140
       140
       -
         ++ lib.optionals (python != null) [ python ]

     

       141
       141
       -
         ++ lib.optionals (!stdenv.isDarwin) [ libGL libGLU libX11 ]

     

       142
       142
       -
         ++ lib.optionals stdenv.isDarwin [

     

       143
       143
       -
           libiconv

     

       144
       144
       -
           darwin.apple_sdk.frameworks.Accelerate

     

       145
       145
       -
           darwin.apple_sdk.frameworks.Cocoa

     

       146
       146
       -
         ]

     

       147
       147
       -
         ;

     

       148
       148
       -
         nativeBuildInputs = [

     

       149
       149
       -
           pkg-config

     

       150
       150
       -
           gfortran

     

       151
       151
       -
           # Listed here as well because it's outputs are split

     

       152
       152
       -
           fftw

     

       153
       153
       -
           fftwSinglePrec

     

       154
       154
       -
           texinfo

     

       155
       155
       -
         ]

     

       156
       156
       -
         ++ lib.optionals (sundials != null) [ sundials ]

     

       157
       157
       -
         ++ lib.optionals enableJIT [ llvm ]

     

       158
       158
       -
         ++ lib.optionals enableQt [

     

       159
       159
       -
           qtscript

     

       160
       160
       -
           qttools

     

       161
       161
       -
         ]

     

       162
       162
       -
         ;

     

       111
       111
       +
         wrapOctave = callPackage ./wrap-octave.nix {

     

       112
       112
       +
           octave = self;

     

       113
       113
       +
           inherit (pkgs) makeSetupHook makeWrapper;

     

       114
       114
       +
         };

     

       115
       115
       +
       

     

       116
       116
       +
         self = mkDerivation rec {

     

       117
       117
       +
           version = "6.2.0";

     

       118
       118
       +
           pname = "octave";

     

       119
       119
       +
       

     

       120
       120
       +
           src = fetchurl {

     

       121
       121
       +
             url = "mirror://gnu/octave/${pname}-${version}.tar.gz";

     

       122
       122
       +
             sha256 = "sha256-RX0f2oY0qDni/Xz8VbmL1W82tq5z0xu530Pd4wEsqnw=";

     

       123
       123
       +
           };

     

       124
       124
       +
       

     

       125
       125
       +
           buildInputs = [

     

       126
       126
       +
             readline

     

       127
       127
       +
             ncurses

     

       128
       128
       +
             perl

     

       129
       129
       +
             flex

     

       130
       130
       +
             qhull

     

       131
       131
       +
             graphicsmagick

     

       132
       132
       +
             pcre

     

       133
       133
       +
             fltk

     

       134
       134
       +
             zlib

     

       135
       135
       +
             curl

     

       136
       136
       +
             blas'

     

       137
       137
       +
             lapack'

     

       138
       138
       +
             libsndfile

     

       139
       139
       +
             fftw

     

       140
       140
       +
             fftwSinglePrec

     

       141
       141
       +
             portaudio

     

       142
       142
       +
             qrupdate'

     

       143
       143
       +
             arpack'

     

       144
       144
       +
             libwebp

     

       145
       145
       +
             gl2ps

     

       146
       146
       +
           ]

     

       147
       147
       +
           ++ lib.optionals enableQt [

     

       148
       148
       +
             qtbase

     

       149
       149
       +
             qtsvg

     

       150
       150
       +
             qscintilla

     

       151
       151
       +
           ]

     

       152
       152
       +
           ++ lib.optionals (ghostscript != null) [ ghostscript ]

     

       153
       153
       +
           ++ lib.optionals (hdf5 != null) [ hdf5 ]

     

       154
       154
       +
           ++ lib.optionals (glpk != null) [ glpk ]

     

       155
       155
       +
           ++ lib.optionals (suitesparse != null) [ suitesparse' ]

     

       156
       156
       +
           ++ lib.optionals (enableJava) [ jdk ]

     

       157
       157
       +
           ++ lib.optionals (sundials != null) [ sundials ]

     

       158
       158
       +
           ++ lib.optionals (gnuplot != null) [ gnuplot ]

     

       159
       159
       +
           ++ lib.optionals (python != null) [ python ]

     

       160
       160
       +
           ++ lib.optionals (!stdenv.isDarwin) [ libGL libGLU libX11 ]

     

       161
       161
       +
           ++ lib.optionals stdenv.isDarwin [

     

       162
       162
       +
             libiconv

     

       163
       163
       +
             darwin.apple_sdk.frameworks.Accelerate

     

       164
       164
       +
             darwin.apple_sdk.frameworks.Cocoa

     

       165
       165
       +
           ]

     

       166
       166
       +
           ;

     

       167
       167
       +
           nativeBuildInputs = [

     

       168
       168
       +
             pkg-config

     

       169
       169
       +
             gfortran

     

       170
       170
       +
             # Listed here as well because it's outputs are split

     

       171
       171
       +
             fftw

     

       172
       172
       +
             fftwSinglePrec

     

       173
       173
       +
             texinfo

     

       174
       174
       +
           ]

     

       175
       175
       +
           ++ lib.optionals (sundials != null) [ sundials ]

     

       176
       176
       +
           ++ lib.optionals enableJIT [ llvm ]

     

       177
       177
       +
           ++ lib.optionals enableQt [

     

       178
       178
       +
             qtscript

     

       179
       179
       +
             qttools

     

       180
       180
       +
           ]

     

       181
       181
       +
           ;

     

       163
       182
        
       

     

       164
       164
       -
         doCheck = !stdenv.isDarwin;

     

       183
       183
       +
           doCheck = !stdenv.isDarwin;

     

       165
       184
        
       

     

       166
       166
       -
         enableParallelBuilding = true;

     

       185
       185
       +
           enableParallelBuilding = true;

     

       167
       186
        
       

     

       168
       168
       -
         # See https://savannah.gnu.org/bugs/?50339

     

       169
       169
       -
         F77_INTEGER_8_FLAG = if use64BitIdx then "-fdefault-integer-8" else "";

     

       187
       187
       +
           # See https://savannah.gnu.org/bugs/?50339

     

       188
       188
       +
           F77_INTEGER_8_FLAG = if use64BitIdx then "-fdefault-integer-8" else "";

     

       170
       189
        
       

     

       171
       171
       -
         configureFlags = [

     

       172
       172
       -
           "--with-blas=blas"

     

       173
       173
       -
           "--with-lapack=lapack"

     

       174
       174
       -
           (if use64BitIdx then "--enable-64" else "--disable-64")

     

       175
       175
       -
         ]

     

       190
       190
       +
           configureFlags = [

     

       191
       191
       +
             "--with-blas=blas"

     

       192
       192
       +
             "--with-lapack=lapack"

     

       193
       193
       +
             (if use64BitIdx then "--enable-64" else "--disable-64")

     

       194
       194
       +
           ]

     

       176
       195
        
           ++ lib.optionals stdenv.isDarwin [ "--enable-link-all-dependencies" ]

     

       177
       196
        
           ++ lib.optionals enableReadline [ "--enable-readline" ]

     

       178
       197
        
           ++ lib.optionals stdenv.isDarwin [ "--with-x=no" ]

     

       179
       198
        
           ++ lib.optionals enableQt [ "--with-qt=5" ]

     

       180
       199
        
           ++ lib.optionals enableJIT [ "--enable-jit" ]

     

       181
       181
       -
         ;

     

       200
       200
       +
           ;

     

       182
       201
        
       

     

       183
       183
       -
         # Keep a copy of the octave tests detailed results in the output

     

       184
       184
       -
         # derivation, because someone may care

     

       185
       185
       -
         postInstall = ''

     

       186
       186
       -
           cp test/fntests.log $out/share/octave/${pname}-${version}-fntests.log || true

     

       187
       187
       -
         '';

     

       202
       202
       +
           # Keep a copy of the octave tests detailed results in the output

     

       203
       203
       +
           # derivation, because someone may care

     

       204
       204
       +
           postInstall = ''

     

       205
       205
       +
             cp test/fntests.log $out/share/octave/${pname}-${version}-fntests.log || true

     

       206
       206
       +
           '';

     

       207
       207
       +
       

     

       208
       208
       +
           passthru = rec {

     

       209
       209
       +
             sitePath = "share/octave/${version}/site";

     

       210
       210
       +
             octPkgsPath = "share/octave/octave_packages";

     

       211
       211
       +
             blas = blas';

     

       212
       212
       +
             lapack = lapack';

     

       213
       213
       +
             qrupdate = qrupdate';

     

       214
       214
       +
             arpack = arpack';

     

       215
       215
       +
             suitesparse = suitesparse';

     

       216
       216
       +
             inherit fftw fftwSinglePrec;

     

       217
       217
       +
             inherit portaudio;

     

       218
       218
       +
             inherit jdk;

     

       219
       219
       +
             inherit python;

     

       220
       220
       +
             inherit enableQt enableJIT enableReadline enableJava;

     

       221
       221
       +
             buildEnv = callPackage ./build-env.nix {

     

       222
       222
       +
               octave = self;

     

       223
       223
       +
               inherit octavePackages wrapOctave;

     

       224
       224
       +
               inherit (octavePackages) computeRequiredOctavePackages;

     

       225
       225
       +
             };

     

       226
       226
       +
             withPackages = import ./with-packages.nix { inherit buildEnv octavePackages; };

     

       227
       227
       +
             pkgs = octavePackages;

     

       228
       228
       +
             interpreter = "${self}/bin/octave";

     

       229
       229
       +
           };

     

       188
       230
        
       

     

       189
       189
       -
         passthru = {

     

       190
       190
       -
           sitePath = "share/octave/${version}/site";

     

       191
       191
       -
           blas = blas';

     

       192
       192
       -
           lapack = lapack';

     

       193
       193
       -
           qrupdate = qrupdate';

     

       194
       194
       -
           arpack = arpack';

     

       195
       195
       -
           suitesparse = suitesparse';

     

       196
       196
       -
           inherit python;

     

       197
       197
       -
           inherit enableQt enableJIT enableReadline enableJava;

     

       231
       231
       +
           meta = {

     

       232
       232
       +
             homepage = "https://www.gnu.org/software/octave/";

     

       233
       233
       +
             license = lib.licenses.gpl3Plus;

     

       234
       234
       +
             maintainers = with lib.maintainers; [ raskin doronbehar ];

     

       235
       235
       +
             description = "Scientific Pragramming Language";

     

       236
       236
       +
             # https://savannah.gnu.org/bugs/?func=detailitem&item_id=56425 is the best attempt to fix JIT

     

       237
       237
       +
             broken = enableJIT;

     

       238
       238
       +
             platforms = if overridePlatforms == null then

     

       239
       239
       +
               (lib.platforms.linux ++ lib.platforms.darwin)

     

       240
       240
       +
             else overridePlatforms;

     

       241
       241
       +
           };

     

       198
       242
        
         };

     

       199
       243
        
       

     

       200
       200
       -
         meta = {

     

       201
       201
       -
           homepage = "https://www.gnu.org/software/octave/";

     

       202
       202
       -
           license = lib.licenses.gpl3Plus;

     

       203
       203
       -
           maintainers = with lib.maintainers; [ raskin doronbehar ];

     

       204
       204
       -
           description = "Scientific Pragramming Language";

     

       205
       205
       -
           # https://savannah.gnu.org/bugs/?func=detailitem&item_id=56425 is the best attempt to fix JIT

     

       206
       206
       -
           broken = enableJIT;

     

       207
       207
       -
           platforms = if overridePlatforms == null then

     

       208
       208
       -
             (lib.platforms.linux ++ lib.platforms.darwin)

     

       209
       209
       -
           else overridePlatforms;

     

       210
       210
       -
         };

     

       211
       211
       -
       }

     

       244
       244
       +
       in self

+13

pkgs/development/interpreters/octave/hooks/default.nix

···

       1
       1
       +
       # Hooks for building Octave packages.

     

       2
       2
       +
       { octave

     

       3
       3
       +
       , lib

     

       4
       4
       +
       , callPackage

     

       5
       5
       +
       , makeSetupHook

     

       6
       6
       +
       }:

     

       7
       7
       +
       

     

       8
       8
       +
       rec {

     

       9
       9
       +
         writeRequiredOctavePackagesHook = callPackage ({ }:

     

       10
       10
       +
           makeSetupHook {

     

       11
       11
       +
             name = "write-required-octave-packages-hook";

     

       12
       12
       +
           } ./write-required-octave-packages-hook.sh) {};

     

       13
       13
       +
       }

+17

pkgs/development/interpreters/octave/hooks/octave-write-required-octave-packages-hook.sh

···

       1
       1
       +
       # Setup hook for writing octave packages that are run-time dependencies for

     

       2
       2
       +
       # another package to a nix-support file.

     

       3
       3
       +
       # `echo`s the full path name to the package derivation that is required.

     

       4
       4
       +
       echo "Sourcing octave-write-required-octave-packages-hook.sh"

     

       5
       5
       +
       

     

       6
       6
       +
       octaveWriteRequiredOctavePackagesPhase() {

     

       7
       7
       +
           echo "Executing octaveWriteRequiredOctavePackagesPhase"

     

       8
       8
       +
       

     

       9
       9
       +
           mkdir -p $out/nix-support

     

       10
       10
       +
           echo ${requiredOctavePackages} > $out/nix-support/required-octave-packages

     

       11
       11
       +
       }

     

       12
       12
       +
       

     

       13
       13
       +
       # Yes its a bit long...

     

       14
       14
       +
       if [ -z "${dontWriteRequiredOctavePackagesPhase-}" ]; then

     

       15
       15
       +
           echo "Using octaveWriteRequiredOctavePackagesPhase"

     

       16
       16
       +
           preDistPhases+=" octaveWriteRequiredOctavePackagesPhase"

     

       17
       17
       +
       fi

+17

pkgs/development/interpreters/octave/hooks/write-required-octave-packages-hook.sh

···

       1
       1
       +
       # Setup hook for writing octave packages that are run-time dependencies for

     

       2
       2
       +
       # another package to a nix-support file.

     

       3
       3
       +
       # `echo`s the full path name to the package derivation that is required.

     

       4
       4
       +
       echo "Sourcing write-required-octave-packages-hook.sh"

     

       5
       5
       +
       

     

       6
       6
       +
       writeRequiredOctavePackagesPhase() {

     

       7
       7
       +
           echo "Executing writeRequiredOctavePackagesPhase"

     

       8
       8
       +
       

     

       9
       9
       +
           mkdir -p $out/nix-support

     

       10
       10
       +
           echo ${requiredOctavePackages} > $out/nix-support/required-octave-packages

     

       11
       11
       +
       }

     

       12
       12
       +
       

     

       13
       13
       +
       # Yes its a bit long...

     

       14
       14
       +
       if [ -z "${dontWriteRequiredOctavePackagesPhase-}" ]; then

     

       15
       15
       +
           echo "Using writeRequiredOctavePackagesPhase"

     

       16
       16
       +
           preDistPhases+=" writeRequiredOctavePackagesPhase"

     

       17
       17
       +
       fi

+6

pkgs/development/interpreters/octave/with-packages.nix

···

       1
       1
       +
       { buildEnv, octavePackages }:

     

       2
       2
       +
       

     

       3
       3
       +
       # Takes the buildEnv defined for Octave and the set of octavePackages, and returns

     

       4
       4
       +
       # a function, which when given a function whose return value is a list of extra

     

       5
       5
       +
       # packages to install, builds and returns that environment.

     

       6
       6
       +
       f: let packages = f octavePackages; in buildEnv.override { extraLibs = packages; }

+16

pkgs/development/interpreters/octave/wrap-octave.nix

···

       1
       1
       +
       { lib

     

       2
       2
       +
       , octave

     

       3
       3
       +
       , makeSetupHook

     

       4
       4
       +
       , makeWrapper

     

       5
       5
       +
       }:

     

       6
       6
       +
       

     

       7
       7
       +
       # Defined in trivial-builders.nix

     

       8
       8
       +
       # Imported as wrapOctave in octave/default.nix and passed to octave's buildEnv

     

       9
       9
       +
       # as nativeBuildInput

     

       10
       10
       +
       # Each of the substitutions is available in the wrap.sh script as @thingSubstituted@

     

       11
       11
       +
       makeSetupHook {

     

       12
       12
       +
         name = "${octave.name}-pkgs-setup-hook";

     

       13
       13
       +
         deps = makeWrapper;

     

       14
       14
       +
         substitutions.executable = octave.interpreter;

     

       15
       15
       +
         substitutions.octave = octave;

     

       16
       16
       +
       } ./wrap.sh

+132

pkgs/development/interpreters/octave/wrap.sh

···

       1
       1
       +
       # Unlinks a directory (given as the first argument), and re-creates that

     

       2
       2
       +
       # directory as an actual directory. Then descends into the directory of

     

       3
       3
       +
       # the same name in the origin (arg_2/arg_3) and symlinks the contents of

     

       4
       4
       +
       # that directory into the passed end-location.

     

       5
       5
       +
       unlinkDirReSymlinkContents() {

     

       6
       6
       +
           local dirToUnlink="$1"

     

       7
       7
       +
           local origin="$2"

     

       8
       8
       +
           local contentsLocation="$3"

     

       9
       9
       +
       

     

       10
       10
       +
           unlink $dirToUnlink/$contentsLocation

     

       11
       11
       +
           mkdir -p $dirToUnlink/$contentsLocation

     

       12
       12
       +
           for f in $origin/$contentsLocation/*; do

     

       13
       13
       +
               ln -s -t "$dirToUnlink/$contentsLocation" "$f"

     

       14
       14
       +
           done

     

       15
       15
       +
       }

     

       16
       16
       +
       

     

       17
       17
       +
       # Using unlinkDirReSymlinkContents, un-symlinks directories down to

     

       18
       18
       +
       # $out/share/octave, and then creates the octave_packages directory.

     

       19
       19
       +
       createOctavePackagesPath() {

     

       20
       20
       +
           local desiredOut=$1

     

       21
       21
       +
           local origin=$2

     

       22
       22
       +
       

     

       23
       23
       +
           if [ -L "$out/share" ]; then

     

       24
       24
       +
               unlinkDirReSymlinkContents "$desiredOut" "$origin" "share"

     

       25
       25
       +
           fi

     

       26
       26
       +
       

     

       27
       27
       +
           if [ -L "$out/share/octave" ]; then

     

       28
       28
       +
               unlinkDirReSymlinkContents "$desiredOut" "$origin" "share/octave"

     

       29
       29
       +
           fi

     

       30
       30
       +
       

     

       31
       31
       +
           # Now that octave_packages has a path rather than symlinks, create the

     

       32
       32
       +
           # octave_packages directory for installed packages.

     

       33
       33
       +
           mkdir -p "$desiredOut/share/octave/octave_packages"

     

       34
       34
       +
       }

     

       35
       35
       +
       

     

       36
       36
       +
       # First, descends down to $out/share/octave/site/m/startup/octaverc, and

     

       37
       37
       +
       # copies that start-up file. Once done, it performs a `chmod` to allow

     

       38
       38
       +
       # writing. Lastly, it `echo`s the location of the locally installed packages

     

       39
       39
       +
       # to the startup file, allowing octave to discover installed packages.

     

       40
       40
       +
       addPkgLocalList() {

     

       41
       41
       +
           local desiredOut=$1

     

       42
       42
       +
           local origin=$2

     

       43
       43
       +
           local octaveSite="share/octave/site"

     

       44
       44
       +
           local octaveSiteM="$octaveSite/m"

     

       45
       45
       +
           local octaveSiteStartup="$octaveSiteM/startup"

     

       46
       46
       +
           local siteOctavercStartup="$octaveSiteStartup/octaverc"

     

       47
       47
       +
       

     

       48
       48
       +
           unlinkDirReSymlinkContents "$desiredOut" "$origin" "$octaveSite"

     

       49
       49
       +
           unlinkDirReSymlinkContents "$desiredOut" "$origin" "$octaveSiteM"

     

       50
       50
       +
           unlinkDirReSymlinkContents "$desiredOut" "$origin" "$octaveSiteStartup"

     

       51
       51
       +
       

     

       52
       52
       +
           unlink "$out/$siteOctavercStartup"

     

       53
       53
       +
           cp "$origin/$siteOctavercStartup" "$desiredOut/$siteOctavercStartup"

     

       54
       54
       +
           chmod u+w "$desiredOut/$siteOctavercStartup"

     

       55
       55
       +
           echo "pkg local_list $out/.octave_packages" >> "$desiredOut/$siteOctavercStartup"

     

       56
       56
       +
       }

     

       57
       57
       +
       

     

       58
       58
       +
       # Wrapper function for wrapOctaveProgramsIn. Takes one argument, a

     

       59
       59
       +
       # space-delimited string of packages' paths that will be installed.

     

       60
       60
       +
       wrapOctavePrograms() {

     

       61
       61
       +
           wrapOctaveProgramsIn "$out/bin" "$out" "$@"

     

       62
       62
       +
       }

     

       63
       63
       +
       

     

       64
       64
       +
       # Wraps all octave programs in $out/bin with all the propagated inputs that

     

       65
       65
       +
       # a particular package requires. $1 is the directory to look for binaries in

     

       66
       66
       +
       # to wrap. $2 is the path to the octave ENVIRONMENT. $3 is the space-delimited

     

       67
       67
       +
       # string of packages.

     

       68
       68
       +
       wrapOctaveProgramsIn() {

     

       69
       69
       +
           local dir="$1"

     

       70
       70
       +
           local octavePath="$2"

     

       71
       71
       +
           local pkgs="$3"

     

       72
       72
       +
           local f

     

       73
       73
       +
       

     

       74
       74
       +
           buildOctavePath "$octavePath" "$pkgs"

     

       75
       75
       +
       

     

       76
       76
       +
           # Find all regular files in the output directory that are executable.

     

       77
       77
       +
           if [ -d "$dir" ]; then

     

       78
       78
       +
               find "$dir" -type f -perm -0100 -print0 | while read -d "" f; do

     

       79
       79
       +
                   echo "wrapping \`$f'..."

     

       80
       80
       +
                   local -a wrap_args=("$f"

     

       81
       81
       +
                       --prefix PATH ':' "$program_PATH"

     

       82
       82
       +
                          )

     

       83
       83
       +
                   local -a wrapProgramArgs=("${wrap_args[@]}")

     

       84
       84
       +
                   wrapProgram "${wrapProgramArgs[@]}"

     

       85
       85
       +
           done

     

       86
       86
       +
           fi

     

       87
       87
       +
       }

     

       88
       88
       +
       

     

       89
       89
       +
       # Build the PATH environment variable by walking through the closure of

     

       90
       90
       +
       # dependencies. Starts by constructing the `program_PATH` variable with the

     

       91
       91
       +
       # environment's path, then adding the original octave's location, and marking

     

       92
       92
       +
       # them in `octavePathsSeen`.

     

       93
       93
       +
       buildOctavePath() {

     

       94
       94
       +
           local octavePath="$1"

     

       95
       95
       +
           local packages="$2"

     

       96
       96
       +
       

     

       97
       97
       +
           local pathsToSearch="$octavePath $packages"

     

       98
       98
       +
       

     

       99
       99
       +
           # Create an empty table of Octave paths.

     

       100
       100
       +
           declare -A octavePathsSeen=()

     

       101
       101
       +
           program_PATH=

     

       102
       102
       +
           octavePathsSeen["$out"]=1

     

       103
       103
       +
           octavePathsSeen["@octave@"]=1

     

       104
       104
       +
           addToSearchPath program_PATH "$out/bin"

     

       105
       105
       +
           addToSearchPath program_PATH "@octave@/bin"

     

       106
       106
       +
           echo "program_PATH to change to is: $program_PATH"

     

       107
       107
       +
           for path in $pathsToSearch; do

     

       108
       108
       +
           echo "Recurse to propagated-build-input: $path"

     

       109
       109
       +
           _addToOctavePath $path

     

       110
       110
       +
           done

     

       111
       111
       +
       }

     

       112
       112
       +
       

     

       113
       113
       +
       # Adds the bin directories to the program_PATH variable.

     

       114
       114
       +
       # Recurses on any paths declared in `propagated-build-inputs`, while avoiding

     

       115
       115
       +
       # duplicating paths by flagging the directires it has seen in `octavePathsSeen`.

     

       116
       116
       +
       _addToOctavePath() {

     

       117
       117
       +
           local dir="$1"

     

       118
       118
       +
           # Stop if we've already visited this path.

     

       119
       119
       +
           if [ -n "${octavePathsSeen[$dir]}" ]; then return; fi

     

       120
       120
       +
           octavePathsSeen[$dir]=1

     

       121
       121
       +
           # addToSearchPath is defined in stdenv/generic/setup.sh. It has the effect

     

       122
       122
       +
           # of calling `export X=$dir/...:$X`.

     

       123
       123
       +
           addToSearchPath program_PATH $dir/bin

     

       124
       124
       +
       

     

       125
       125
       +
           # Inspect the propagated inputs (if they exist) and recur on them.

     

       126
       126
       +
           local prop="$dir/nix-support/propagated-build-inputs"

     

       127
       127
       +
           if [ -e $prop ]; then

     

       128
       128
       +
           for new_path in $(cat $prop); do

     

       129
       129
       +
               _addToOctavePath $new_path

     

       130
       130
       +
           done

     

       131
       131
       +
           fi

     

       132
       132
       +
       }

+33

pkgs/development/octave-modules/arduino/default.nix

···

       1
       1
       +
       { buildOctavePackage

     

       2
       2
       +
       , lib

     

       3
       3
       +
       , fetchurl

     

       4
       4
       +
       , instrument-control

     

       5
       5
       +
       , arduino

     

       6
       6
       +
       }:

     

       7
       7
       +
       

     

       8
       8
       +
       buildOctavePackage rec {

     

       9
       9
       +
         pname = "arduino";

     

       10
       10
       +
         version = "0.6.0";

     

       11
       11
       +
       

     

       12
       12
       +
         src = fetchurl {

     

       13
       13
       +
           url = "mirror://sourceforge/octave/${pname}-${version}.tar.gz";

     

       14
       14
       +
           sha256 = "0fnfk206n31s7diijaylmqhxnr88z6l3l3vsxq4z8gcp9ylm9nkj";

     

       15
       15
       +
         };

     

       16
       16
       +
       

     

       17
       17
       +
         requiredOctavePackages = [

     

       18
       18
       +
           instrument-control

     

       19
       19
       +
         ];

     

       20
       20
       +
       

     

       21
       21
       +
         # Might be able to use pkgs.arduino-core

     

       22
       22
       +
         propagatedBuildInputs = [

     

       23
       23
       +
           arduino

     

       24
       24
       +
         ];

     

       25
       25
       +
       

     

       26
       26
       +
         meta = with lib; {

     

       27
       27
       +
           name = "Octave Arduino Toolkit";

     

       28
       28
       +
           homepage = "https://octave.sourceforge.io/arduino/index.html";

     

       29
       29
       +
           license = licenses.gpl3Plus;

     

       30
       30
       +
           maintainers = with maintainers; [ KarlJoad ];

     

       31
       31
       +
           description = "Basic Octave implementation of the matlab arduino extension, allowing communication to a programmed arduino board to control its hardware";

     

       32
       32
       +
         };

     

       33
       33
       +
       }

+36

pkgs/development/octave-modules/audio/default.nix

···

       1
       1
       +
       { buildOctavePackage

     

       2
       2
       +
       , lib

     

       3
       3
       +
       , fetchurl

     

       4
       4
       +
       , jack2

     

       5
       5
       +
       , alsaLib

     

       6
       6
       +
       , rtmidi

     

       7
       7
       +
       , pkg-config

     

       8
       8
       +
       }:

     

       9
       9
       +
       

     

       10
       10
       +
       buildOctavePackage rec {

     

       11
       11
       +
         pname = "audio";

     

       12
       12
       +
         version = "2.0.2";

     

       13
       13
       +
       

     

       14
       14
       +
         src = fetchurl {

     

       15
       15
       +
           url = "mirror://sourceforge/octave/${pname}-${version}.tar.gz";

     

       16
       16
       +
           sha256 = "18lyvwmdy4b9pcv5sm7g17n3is32q23daw8fcsalkf4rj6cc6qdk";

     

       17
       17
       +
         };

     

       18
       18
       +
       

     

       19
       19
       +
         nativeBuildInputs = [

     

       20
       20
       +
           pkg-config

     

       21
       21
       +
         ];

     

       22
       22
       +
       

     

       23
       23
       +
         propagatedBuildInputs = [

     

       24
       24
       +
           jack2

     

       25
       25
       +
           alsaLib

     

       26
       26
       +
           rtmidi

     

       27
       27
       +
         ];

     

       28
       28
       +
       

     

       29
       29
       +
         meta = with lib; {

     

       30
       30
       +
           homepage = "https://octave.sourceforge.io/audio/index.html";

     

       31
       31
       +
           license = licenses.gpl3Plus;

     

       32
       32
       +
           maintainers = with maintainers; [ KarlJoad ];

     

       33
       33
       +
           description = "Audio and MIDI Toolbox for GNU Octave";

     

       34
       34
       +
           platforms = platforms.linux; # Because of run-time dependency on jack2 and alsaLib

     

       35
       35
       +
         };

     

       36
       36
       +
       }

+28

pkgs/development/octave-modules/bim/default.nix

···

       1
       1
       +
       { buildOctavePackage

     

       2
       2
       +
       , lib

     

       3
       3
       +
       , fetchurl

     

       4
       4
       +
       , fpl

     

       5
       5
       +
       , msh

     

       6
       6
       +
       }:

     

       7
       7
       +
       

     

       8
       8
       +
       buildOctavePackage rec {

     

       9
       9
       +
         pname = "bim";

     

       10
       10
       +
         version = "1.1.5";

     

       11
       11
       +
       

     

       12
       12
       +
         src = fetchurl {

     

       13
       13
       +
           url = "mirror://sourceforge/octave/${pname}-${version}.tar.gz";

     

       14
       14
       +
           sha256 = "0y70w8mj80c5yns1j7nwngwwrxp1pa87kyz2n2yvmc3zdigcd6g8";

     

       15
       15
       +
         };

     

       16
       16
       +
       

     

       17
       17
       +
         requiredOctavePackages = [

     

       18
       18
       +
           fpl

     

       19
       19
       +
           msh

     

       20
       20
       +
         ];

     

       21
       21
       +
       

     

       22
       22
       +
         meta = with lib; {

     

       23
       23
       +
           homepage = "https://octave.sourceforge.io/bim/index.html";

     

       24
       24
       +
           license = licenses.gpl2Plus;

     

       25
       25
       +
           maintainers = with maintainers; [ KarlJoad ];

     

       26
       26
       +
           description = "Package for solving Diffusion Advection Reaction (DAR) Partial Differential Equations";

     

       27
       27
       +
         };

     

       28
       28
       +
       }

+21

pkgs/development/octave-modules/bsltl/default.nix

···

       1
       1
       +
       { buildOctavePackage

     

       2
       2
       +
       , lib

     

       3
       3
       +
       , fetchurl

     

       4
       4
       +
       }:

     

       5
       5
       +
       

     

       6
       6
       +
       buildOctavePackage rec {

     

       7
       7
       +
         pname = "bsltl";

     

       8
       8
       +
         version = "1.3.1";

     

       9
       9
       +
       

     

       10
       10
       +
         src = fetchurl {

     

       11
       11
       +
           url = "mirror://sourceforge/octave/${pname}-${version}.tar.gz";

     

       12
       12
       +
           sha256 = "0i8ry347y5f5db3702nhpsmfys9v18ks2fsmpdqpy3fcvrwaxdsb";

     

       13
       13
       +
         };

     

       14
       14
       +
       

     

       15
       15
       +
         meta = with lib; {

     

       16
       16
       +
           homepage = "https://octave.sourceforge.io/bsltl/index.html";

     

       17
       17
       +
           license = licenses.gpl3Plus;

     

       18
       18
       +
           maintainers = with maintainers; [ KarlJoad ];

     

       19
       19
       +
           description = "Free collection of OCTAVE/MATLAB routines for working with the biospeckle laser technique";

     

       20
       20
       +
         };

     

       21
       21
       +
       }

+21

pkgs/development/octave-modules/cgi/default.nix

···

       1
       1
       +
       { buildOctavePackage

     

       2
       2
       +
       , lib

     

       3
       3
       +
       , fetchurl

     

       4
       4
       +
       }:

     

       5
       5
       +
       

     

       6
       6
       +
       buildOctavePackage rec {

     

       7
       7
       +
         pname = "cgi";

     

       8
       8
       +
         version = "0.1.2";

     

       9
       9
       +
       

     

       10
       10
       +
         src = fetchurl {

     

       11
       11
       +
           url = "mirror://sourceforge/octave/${pname}-${version}.tar.gz";

     

       12
       12
       +
           sha256 = "0hygj7cpwrs2w9bfb7qrvv7gq410bfiddqvza8smg766pqmfp1s1";

     

       13
       13
       +
         };

     

       14
       14
       +
       

     

       15
       15
       +
         meta = with lib; {

     

       16
       16
       +
           homepage = "https://octave.sourceforge.io/cgi/index.html";

     

       17
       17
       +
           license = licenses.gpl2Plus;

     

       18
       18
       +
           maintainers = with maintainers; [ KarlJoad ];

     

       19
       19
       +
           description = "Common Gateway Interface for Octave";

     

       20
       20
       +
         };

     

       21
       21
       +
       }

+31

pkgs/development/octave-modules/communications/default.nix

···

       1
       1
       +
       { buildOctavePackage

     

       2
       2
       +
       , lib

     

       3
       3
       +
       , fetchurl

     

       4
       4
       +
       , signal

     

       5
       5
       +
       , hdf5

     

       6
       6
       +
       }:

     

       7
       7
       +
       

     

       8
       8
       +
       buildOctavePackage rec {

     

       9
       9
       +
         pname = "communications";

     

       10
       10
       +
         version = "1.2.2";

     

       11
       11
       +
       

     

       12
       12
       +
         src = fetchurl {

     

       13
       13
       +
           url = "mirror://sourceforge/octave/${pname}-${version}.tar.gz";

     

       14
       14
       +
           sha256 = "1xay2vjyadv3ja8dmqqzm2his8s0rvidz23nq1c2yl3xh1gavyck";

     

       15
       15
       +
         };

     

       16
       16
       +
       

     

       17
       17
       +
         buildInputs = [

     

       18
       18
       +
           hdf5

     

       19
       19
       +
         ];

     

       20
       20
       +
       

     

       21
       21
       +
         requiredOctavePackages = [

     

       22
       22
       +
           signal

     

       23
       23
       +
         ];

     

       24
       24
       +
       

     

       25
       25
       +
         meta = with lib; {

     

       26
       26
       +
           homepage = "https://octave.sourceforge.io/communications/index.html";

     

       27
       27
       +
           license = licenses.gpl3Plus;

     

       28
       28
       +
           maintainers = with maintainers; [ KarlJoad ];

     

       29
       29
       +
           description = " Digital Communications, Error Correcting Codes (Channel Code), Source Code functions, Modulation and Galois Fields";

     

       30
       30
       +
         };

     

       31
       31
       +
       }

+31

pkgs/development/octave-modules/control/default.nix

···

       1
       1
       +
       { buildOctavePackage

     

       2
       2
       +
       , lib

     

       3
       3
       +
       , fetchurl

     

       4
       4
       +
       , gfortran

     

       5
       5
       +
       , lapack, blas

     

       6
       6
       +
       }:

     

       7
       7
       +
       

     

       8
       8
       +
       buildOctavePackage rec {

     

       9
       9
       +
         pname = "control";

     

       10
       10
       +
         version = "3.2.0";

     

       11
       11
       +
       

     

       12
       12
       +
         src = fetchurl {

     

       13
       13
       +
           url = "mirror://sourceforge/octave/${pname}-${version}.tar.gz";

     

       14
       14
       +
           sha256 = "0gjyjsxs01x0nyc4cgn3d5af17l3lzs8h4hsm57nxd3as48dbwgs";

     

       15
       15
       +
         };

     

       16
       16
       +
       

     

       17
       17
       +
         nativeBuildInputs = [

     

       18
       18
       +
           gfortran

     

       19
       19
       +
         ];

     

       20
       20
       +
       

     

       21
       21
       +
         buildInputs = [

     

       22
       22
       +
           lapack blas

     

       23
       23
       +
         ];

     

       24
       24
       +
       

     

       25
       25
       +
         meta = with lib; {

     

       26
       26
       +
           homepage = "https://octave.sourceforge.io/control/index.html";

     

       27
       27
       +
           license = licenses.gpl3Plus;

     

       28
       28
       +
           maintainers = with maintainers; [ KarlJoad ];

     

       29
       29
       +
           description = "Computer-Aided Control System Design (CACSD) Tools for GNU Octave, based on the proven SLICOT Library";

     

       30
       30
       +
         };

     

       31
       31
       +
       }

+26

pkgs/development/octave-modules/data-smoothing/default.nix

···

       1
       1
       +
       { buildOctavePackage

     

       2
       2
       +
       , lib

     

       3
       3
       +
       , fetchurl

     

       4
       4
       +
       , optim

     

       5
       5
       +
       }:

     

       6
       6
       +
       

     

       7
       7
       +
       buildOctavePackage rec {

     

       8
       8
       +
         pname = "data-smoothing";

     

       9
       9
       +
         version = "1.3.0";

     

       10
       10
       +
       

     

       11
       11
       +
         src = fetchurl {

     

       12
       12
       +
           url = "mirror://sourceforge/octave/${pname}-${version}.tar.gz";

     

       13
       13
       +
           sha256 = "0q0vqdmp8ygyfhk296xbxcpsh5wvpa2kfgv4v0rys68nd2lxfaq1";

     

       14
       14
       +
         };

     

       15
       15
       +
       

     

       16
       16
       +
         requiredOctavePackages = [

     

       17
       17
       +
           optim

     

       18
       18
       +
         ];

     

       19
       19
       +
       

     

       20
       20
       +
         meta = with lib; {

     

       21
       21
       +
           homepage = "https://octave.sourceforge.io/data-smoothing/index.html";

     

       22
       22
       +
           license = licenses.gpl3Plus;

     

       23
       23
       +
           maintainers = with maintainers; [ KarlJoad ];

     

       24
       24
       +
           description = "Algorithms for smoothing noisy data";

     

       25
       25
       +
         };

     

       26
       26
       +
       }

+31

pkgs/development/octave-modules/database/default.nix

···

       1
       1
       +
       { buildOctavePackage

     

       2
       2
       +
       , lib

     

       3
       3
       +
       , fetchurl

     

       4
       4
       +
       , struct

     

       5
       5
       +
       , postgresql

     

       6
       6
       +
       }:

     

       7
       7
       +
       

     

       8
       8
       +
       buildOctavePackage rec {

     

       9
       9
       +
         pname = "database";

     

       10
       10
       +
         version = "2.4.4";

     

       11
       11
       +
       

     

       12
       12
       +
         src = fetchurl {

     

       13
       13
       +
           url = "mirror://sourceforge/octave/${pname}-${version}.tar.gz";

     

       14
       14
       +
           sha256 = "1c0n76adi0jw6bx62s04vjyda6kb6ca8lzz2vam43vdy10prcq9p";

     

       15
       15
       +
         };

     

       16
       16
       +
       

     

       17
       17
       +
         propagatedBuildInputs = [

     

       18
       18
       +
           postgresql

     

       19
       19
       +
         ];

     

       20
       20
       +
       

     

       21
       21
       +
         requiredOctavePackages = [

     

       22
       22
       +
           struct

     

       23
       23
       +
         ];

     

       24
       24
       +
       

     

       25
       25
       +
         meta = with lib; {

     

       26
       26
       +
           homepage = "https://octave.sourceforge.io/database/index.html";

     

       27
       27
       +
           license = licenses.gpl3Plus;

     

       28
       28
       +
           maintainers = with maintainers; [ KarlJoad ];

     

       29
       29
       +
           description = "Interface to SQL databases, currently only postgresql using libpq";

     

       30
       30
       +
         };

     

       31
       31
       +
       }

+21

pkgs/development/octave-modules/dataframe/default.nix

···

       1
       1
       +
       { buildOctavePackage

     

       2
       2
       +
       , lib

     

       3
       3
       +
       , fetchurl

     

       4
       4
       +
       }:

     

       5
       5
       +
       

     

       6
       6
       +
       buildOctavePackage rec {

     

       7
       7
       +
         pname = "dataframe";

     

       8
       8
       +
         version = "1.2.0";

     

       9
       9
       +
       

     

       10
       10
       +
         src = fetchurl {

     

       11
       11
       +
           url = "mirror://sourceforge/octave/${pname}-${version}.tar.gz";

     

       12
       12
       +
           sha256 = "10ara084gkb7d5vxv9qv7zpj8b4mm5y06nccrdy3skw5nfbb4djx";

     

       13
       13
       +
         };

     

       14
       14
       +
       

     

       15
       15
       +
         meta = with lib; {

     

       16
       16
       +
           homepage = "https://octave.sourceforge.io/dataframe/index.html";

     

       17
       17
       +
           license = licenses.gpl3Plus;

     

       18
       18
       +
           maintainers = with maintainers; [ KarlJoad ];

     

       19
       19
       +
           description = "Data manipulation toolbox similar to R data.frame";

     

       20
       20
       +
         };

     

       21
       21
       +
       }

+33

pkgs/development/octave-modules/dicom/default.nix

···

       1
       1
       +
       { buildOctavePackage

     

       2
       2
       +
       , lib

     

       3
       3
       +
       , fetchurl

     

       4
       4
       +
       , gdcm

     

       5
       5
       +
       , cmake

     

       6
       6
       +
       }:

     

       7
       7
       +
       

     

       8
       8
       +
       buildOctavePackage rec {

     

       9
       9
       +
         pname = "dicom";

     

       10
       10
       +
         version = "0.4.0";

     

       11
       11
       +
       

     

       12
       12
       +
         src = fetchurl {

     

       13
       13
       +
           url = "mirror://sourceforge/octave/${pname}-${version}.tar.gz";

     

       14
       14
       +
           sha256 = "131wn6mrv20np10plirvqia8dlpz3g0aqi3mmn2wyl7r95p3dnza";

     

       15
       15
       +
         };

     

       16
       16
       +
       

     

       17
       17
       +
         nativeBuildInputs = [

     

       18
       18
       +
           cmake

     

       19
       19
       +
         ];

     

       20
       20
       +
       

     

       21
       21
       +
         dontUseCmakeConfigure = true;

     

       22
       22
       +
       

     

       23
       23
       +
         propagatedBuildInputs = [

     

       24
       24
       +
           gdcm

     

       25
       25
       +
         ];

     

       26
       26
       +
       

     

       27
       27
       +
         meta = with lib; {

     

       28
       28
       +
           homepage = "https://octave.sourceforge.io/dicom/index.html";

     

       29
       29
       +
           license = licenses.gpl3Plus;

     

       30
       30
       +
           maintainers = with maintainers; [ KarlJoad ];

     

       31
       31
       +
           description = "Digital communications in medicine (DICOM) file io";

     

       32
       32
       +
         };

     

       33
       33
       +
       }

+21

pkgs/development/octave-modules/divand/default.nix

···

       1
       1
       +
       { buildOctavePackage

     

       2
       2
       +
       , lib

     

       3
       3
       +
       , fetchurl

     

       4
       4
       +
       }:

     

       5
       5
       +
       

     

       6
       6
       +
       buildOctavePackage rec {

     

       7
       7
       +
         pname = "divand";

     

       8
       8
       +
         version = "1.1.2";

     

       9
       9
       +
       

     

       10
       10
       +
         src = fetchurl {

     

       11
       11
       +
           url = "mirror://sourceforge/octave/${pname}-${version}.tar.gz";

     

       12
       12
       +
           sha256 = "0nmaz5j37dflz7p4a4lmwzkh7g1gghdh7ccvkbyy0fpgv9lr1amg";

     

       13
       13
       +
         };

     

       14
       14
       +
       

     

       15
       15
       +
         meta = with lib; {

     

       16
       16
       +
           homepage = "https://octave.sourceforge.io/divand/index.html";

     

       17
       17
       +
           license = licenses.gpl2Plus;

     

       18
       18
       +
           maintainers = with maintainers; [ KarlJoad ];

     

       19
       19
       +
           description = "Performs an n-dimensional variational analysis (interpolation) of arbitrarily located observations";

     

       20
       20
       +
         };

     

       21
       21
       +
       }

+28

pkgs/development/octave-modules/doctest/default.nix

···

       1
       1
       +
       { buildOctavePackage

     

       2
       2
       +
       , lib

     

       3
       3
       +
       , fetchurl

     

       4
       4
       +
       }:

     

       5
       5
       +
       

     

       6
       6
       +
       buildOctavePackage rec {

     

       7
       7
       +
         pname = "doctest";

     

       8
       8
       +
         version = "0.7.0";

     

       9
       9
       +
       

     

       10
       10
       +
         src = fetchurl {

     

       11
       11
       +
           url = "mirror://sourceforge/octave/${pname}-${version}.tar.gz";

     

       12
       12
       +
           sha256 = "0hh9izj9ds69bmrvmmj16fd1c4z7733h50c7isl8f714srw26kf4";

     

       13
       13
       +
         };

     

       14
       14
       +
       

     

       15
       15
       +
         meta = with lib; {

     

       16
       16
       +
           homepage = "https://octave.sourceforge.io/doctest/index.html";

     

       17
       17
       +
           license = licenses.bsd3;

     

       18
       18
       +
           maintainers = with maintainers; [ KarlJoad ];

     

       19
       19
       +
           description = "Find and run example code within documentation";

     

       20
       20
       +
           longDescription = ''

     

       21
       21
       +
             Find and run example code within documentation. Formatted blocks

     

       22
       22
       +
             of example code are extracted from documentation files and executed

     

       23
       23
       +
             to confirm their output is correct. This can be part of a testing

     

       24
       24
       +
             framework or simply to ensure that documentation stays up-to-date

     

       25
       25
       +
             during software development.

     

       26
       26
       +
           '';

     

       27
       27
       +
         };

     

       28
       28
       +
       }

+26

pkgs/development/octave-modules/econometrics/default.nix

···

       1
       1
       +
       { buildOctavePackage

     

       2
       2
       +
       , lib

     

       3
       3
       +
       , fetchurl

     

       4
       4
       +
       , optim

     

       5
       5
       +
       }:

     

       6
       6
       +
       

     

       7
       7
       +
       buildOctavePackage rec {

     

       8
       8
       +
         pname = "econometrics";

     

       9
       9
       +
         version = "1.1.2";

     

       10
       10
       +
       

     

       11
       11
       +
         src = fetchurl {

     

       12
       12
       +
           url = "mirror://sourceforge/octave/${pname}-${version}.tar.gz";

     

       13
       13
       +
           sha256 = "1srx78k90ycla7yisa9h593n9l8br31lsdxlspra8sxiyq0sbk72";

     

       14
       14
       +
         };

     

       15
       15
       +
       

     

       16
       16
       +
         requiredOctavePackages = [

     

       17
       17
       +
           optim

     

       18
       18
       +
         ];

     

       19
       19
       +
       

     

       20
       20
       +
         meta = with lib; {

     

       21
       21
       +
           homepage = "https://octave.sourceforge.io/econometrics/index.html";

     

       22
       22
       +
           license = licenses.gpl3Plus;

     

       23
       23
       +
           maintainers = with maintainers; [ KarlJoad ];

     

       24
       24
       +
           description = "Econometrics functions including MLE and GMM based techniques";

     

       25
       25
       +
         };

     

       26
       26
       +
       }

+35

pkgs/development/octave-modules/fem-fenics/default.nix

···

       1
       1
       +
       { buildOctavePackage

     

       2
       2
       +
       , lib

     

       3
       3
       +
       , fetchurl

     

       4
       4
       +
       , dolfin

     

       5
       5
       +
       , ffc

     

       6
       6
       +
       , pkg-config

     

       7
       7
       +
       }:

     

       8
       8
       +
       

     

       9
       9
       +
       buildOctavePackage rec {

     

       10
       10
       +
         pname = "fem-fenics";

     

       11
       11
       +
         version = "0.0.5";

     

       12
       12
       +
       

     

       13
       13
       +
         src = fetchurl {

     

       14
       14
       +
           url = "mirror://sourceforge/octave/${pname}-${version}.tar.gz";

     

       15
       15
       +
           sha256 = "1xd80nnkschldvrqx0wvrg3fzbf8sck8bvq24phr5x49xs7b8x78";

     

       16
       16
       +
         };

     

       17
       17
       +
       

     

       18
       18
       +
         nativeBuildInputs = [

     

       19
       19
       +
           pkg-config

     

       20
       20
       +
         ];

     

       21
       21
       +
       

     

       22
       22
       +
         propagatedBuildInputs = [

     

       23
       23
       +
           dolfin

     

       24
       24
       +
           ffc

     

       25
       25
       +
         ];

     

       26
       26
       +
       

     

       27
       27
       +
         meta = with lib; {

     

       28
       28
       +
           homepage = "https://octave.sourceforge.io/fem-fenics/index.html";

     

       29
       29
       +
           license = licenses.gpl3Plus;

     

       30
       30
       +
           maintainers = with maintainers; [ KarlJoad ];

     

       31
       31
       +
           description = "Package for the resolution of partial differential equations based on fenics";

     

       32
       32
       +
           # Lots of compilation errors for newer octave versions and syntax errors

     

       33
       33
       +
           broken = true;

     

       34
       34
       +
         };

     

       35
       35
       +
       }

+23

pkgs/development/octave-modules/financial/default.nix

···

       1
       1
       +
       { buildOctavePackage

     

       2
       2
       +
       , lib

     

       3
       3
       +
       , fetchurl

     

       4
       4
       +
       , io

     

       5
       5
       +
       , statistics

     

       6
       6
       +
       }:

     

       7
       7
       +
       

     

       8
       8
       +
       buildOctavePackage rec {

     

       9
       9
       +
         pname = "financial";

     

       10
       10
       +
         version = "0.5.3";

     

       11
       11
       +
       

     

       12
       12
       +
         src = fetchurl {

     

       13
       13
       +
           url = "mirror://sourceforge/octave/${pname}-${version}.tar.gz";

     

       14
       14
       +
           sha256 = "0f963yg6pwvrdk5fg7b71ny47gzy48nqxdzj2ngcfrvmb5az4vmf";

     

       15
       15
       +
         };

     

       16
       16
       +
       

     

       17
       17
       +
         meta = with lib; {

     

       18
       18
       +
           homepage = "https://octave.sourceforge.io/financial/index.html";

     

       19
       19
       +
           license = licenses.gpl3Plus;

     

       20
       20
       +
           maintainers = with maintainers; [ KarlJoad ];

     

       21
       21
       +
           description = "Monte Carlo simulation, options pricing routines, financial manipulation, plotting functions and additional date manipulation tools";

     

       22
       22
       +
         };

     

       23
       23
       +
       }

+41

pkgs/development/octave-modules/fits/default.nix

···

       1
       1
       +
       { buildOctavePackage

     

       2
       2
       +
       , lib

     

       3
       3
       +
       , fetchurl

     

       4
       4
       +
       , cfitsio

     

       5
       5
       +
       , hdf5

     

       6
       6
       +
       , pkg-config

     

       7
       7
       +
       }:

     

       8
       8
       +
       

     

       9
       9
       +
       buildOctavePackage rec {

     

       10
       10
       +
         pname = "fits";

     

       11
       11
       +
         version = "1.0.7";

     

       12
       12
       +
       

     

       13
       13
       +
         src = fetchurl {

     

       14
       14
       +
           url = "mirror://sourceforge/octave/${pname}-${version}.tar.gz";

     

       15
       15
       +
           sha256 = "0jab5wmrpifqphmrfkqcyrlpc0h4y4m735yc3avqqjajz1rl24lm";

     

       16
       16
       +
         };

     

       17
       17
       +
       

     

       18
       18
       +
         # Found here: https://build.opensuse.org/package/view_file/science/octave-forge-fits/octave-forge-fits.spec?expand=1

     

       19
       19
       +
         patchPhase = ''

     

       20
       20
       +
           sed -i -s -e 's/D_NINT/octave::math::x_nint/g' src/*.cc

     

       21
       21
       +
         '';

     

       22
       22
       +
       

     

       23
       23
       +
         nativeBuildInputs = [

     

       24
       24
       +
           pkg-config

     

       25
       25
       +
         ];

     

       26
       26
       +
       

     

       27
       27
       +
         buildInputs = [

     

       28
       28
       +
           hdf5

     

       29
       29
       +
         ];

     

       30
       30
       +
       

     

       31
       31
       +
         propagatedBuildInputs = [

     

       32
       32
       +
           cfitsio

     

       33
       33
       +
         ];

     

       34
       34
       +
       

     

       35
       35
       +
         meta = with lib; {

     

       36
       36
       +
           homepage = "https://octave.sourceforge.io/fits/index.html";

     

       37
       37
       +
           license = licenses.gpl3Plus;

     

       38
       38
       +
           maintainers = with maintainers; [ KarlJoad ];

     

       39
       39
       +
           description = "Functions for reading, and writing FITS (Flexible Image Transport System) files using cfitsio";

     

       40
       40
       +
         };

     

       41
       41
       +
       }

+21

pkgs/development/octave-modules/fpl/default.nix

···

       1
       1
       +
       { buildOctavePackage

     

       2
       2
       +
       , lib

     

       3
       3
       +
       , fetchurl

     

       4
       4
       +
       }:

     

       5
       5
       +
       

     

       6
       6
       +
       buildOctavePackage rec {

     

       7
       7
       +
         pname = "fpl";

     

       8
       8
       +
         version = "1.3.5";

     

       9
       9
       +
       

     

       10
       10
       +
         src = fetchurl {

     

       11
       11
       +
           url = "mirror://sourceforge/octave/${pname}-${version}.tar.gz";

     

       12
       12
       +
           sha256 = "0cbpahn9flrv9ppp5xakhwh8vyyy7wzlsz22i3s93yqg9q2bh4ys";

     

       13
       13
       +
         };

     

       14
       14
       +
       

     

       15
       15
       +
         meta = with lib; {

     

       16
       16
       +
           homepage = "https://octave.sourceforge.io/fpl/index.html";

     

       17
       17
       +
           license = licenses.gpl3Plus;

     

       18
       18
       +
           maintainers = with maintainers; [ KarlJoad ];

     

       19
       19
       +
           description = "Collection of routines to export data produced by Finite Elements or Finite Volume Simulations in formats used by some visualization programs";

     

       20
       20
       +
         };

     

       21
       21
       +
       }

+21

pkgs/development/octave-modules/fuzzy-logic-toolkit/default.nix

···

       1
       1
       +
       { buildOctavePackage

     

       2
       2
       +
       , lib

     

       3
       3
       +
       , fetchurl

     

       4
       4
       +
       }:

     

       5
       5
       +
       

     

       6
       6
       +
       buildOctavePackage rec {

     

       7
       7
       +
         pname = "fuzzy-logic-toolkit";

     

       8
       8
       +
         version = "0.4.5";

     

       9
       9
       +
       

     

       10
       10
       +
         src = fetchurl {

     

       11
       11
       +
           url = "mirror://sourceforge/octave/${pname}-${version}.tar.gz";

     

       12
       12
       +
           sha256 = "0cs1xh594h1psdinicxrsvm27gzax5jja7bjk4sl3kk2hv24mhml";

     

       13
       13
       +
         };

     

       14
       14
       +
       

     

       15
       15
       +
         meta = with lib; {

     

       16
       16
       +
           homepage = "https://octave.sourceforge.io/fuzzy-logic-toolkit/index.html";

     

       17
       17
       +
           license = licenses.gpl3Plus;

     

       18
       18
       +
           maintainers = with maintainers; [ KarlJoad ];

     

       19
       19
       +
           description = "A mostly MATLAB-compatible fuzzy logic toolkit for Octave";

     

       20
       20
       +
         };

     

       21
       21
       +
       }

+21

pkgs/development/octave-modules/ga/default.nix

···

       1
       1
       +
       { buildOctavePackage

     

       2
       2
       +
       , lib

     

       3
       3
       +
       , fetchurl

     

       4
       4
       +
       }:

     

       5
       5
       +
       

     

       6
       6
       +
       buildOctavePackage rec {

     

       7
       7
       +
         pname = "ga";

     

       8
       8
       +
         version = "0.10.2";

     

       9
       9
       +
       

     

       10
       10
       +
         src = fetchurl {

     

       11
       11
       +
           url = "mirror://sourceforge/octave/${pname}-${version}.tar.gz";

     

       12
       12
       +
           sha256 = "0s5azn4n174avlmh5gw21zfqfkyxkzn4v09q4l9swv7ldmg3mirv";

     

       13
       13
       +
         };

     

       14
       14
       +
       

     

       15
       15
       +
         meta = with lib; {

     

       16
       16
       +
           homepage = "https://octave.sourceforge.io/ga/index.html";

     

       17
       17
       +
           license = licenses.gpl3Plus;

     

       18
       18
       +
           maintainers = with maintainers; [ KarlJoad ];

     

       19
       19
       +
           description = "Genetic optimization code";

     

       20
       20
       +
         };

     

       21
       21
       +
       }

+31

pkgs/development/octave-modules/general/default.nix

···

       1
       1
       +
       { buildOctavePackage

     

       2
       2
       +
       , lib

     

       3
       3
       +
       , fetchurl

     

       4
       4
       +
       , pkg-config

     

       5
       5
       +
       , nettle

     

       6
       6
       +
       }:

     

       7
       7
       +
       

     

       8
       8
       +
       buildOctavePackage rec {

     

       9
       9
       +
         pname = "general";

     

       10
       10
       +
         version = "2.1.1";

     

       11
       11
       +
       

     

       12
       12
       +
         src = fetchurl {

     

       13
       13
       +
           url = "mirror://sourceforge/octave/${pname}-${version}.tar.gz";

     

       14
       14
       +
           sha256 = "0jmvczssqz1aa665v9h8k9cchb7mg3n9af6b5kh9b2qcjl4r9l7v";

     

       15
       15
       +
         };

     

       16
       16
       +
       

     

       17
       17
       +
         nativeBuildInputs = [

     

       18
       18
       +
           pkg-config

     

       19
       19
       +
         ];

     

       20
       20
       +
       

     

       21
       21
       +
         buildInputs = [

     

       22
       22
       +
           nettle

     

       23
       23
       +
         ];

     

       24
       24
       +
       

     

       25
       25
       +
         meta = with lib; {

     

       26
       26
       +
           homepage = "https://octave.sourceforge.io/general/index.html";

     

       27
       27
       +
           license = licenses.gpl3Plus;

     

       28
       28
       +
           maintainers = with maintainers; [ KarlJoad ];

     

       29
       29
       +
           description = "General tools for Octave";

     

       30
       30
       +
         };

     

       31
       31
       +
       }

+27

pkgs/development/octave-modules/generate_html/default.nix

···

       1
       1
       +
       { buildOctavePackage

     

       2
       2
       +
       , lib

     

       3
       3
       +
       , fetchurl

     

       4
       4
       +
       }:

     

       5
       5
       +
       

     

       6
       6
       +
       buildOctavePackage rec {

     

       7
       7
       +
         pname = "generate_html";

     

       8
       8
       +
         version = "0.3.2";

     

       9
       9
       +
       

     

       10
       10
       +
         src = fetchurl {

     

       11
       11
       +
           url = "mirror://sourceforge/octave/${pname}-${version}.tar.gz";

     

       12
       12
       +
           sha256 = "1ai4h7jf9fqi7w565iprzylsh94pg4rhyf51hfj9kfdgdpb1abfs";

     

       13
       13
       +
         };

     

       14
       14
       +
       

     

       15
       15
       +
         meta = with lib; {

     

       16
       16
       +
           homepage = "https://octave.sourceforge.io/generate_html/index.html";

     

       17
       17
       +
           license = licenses.gpl3Plus;

     

       18
       18
       +
           maintainers = with maintainers; [ KarlJoad ];

     

       19
       19
       +
           description = "Provides functions for generating HTML pages that contain the help texts for a set of functions";

     

       20
       20
       +
           longDescription = ''

     

       21
       21
       +
             This package provides functions for generating HTML pages that contain

     

       22
       22
       +
             the help texts for a set of functions. The package is designed to be as

     

       23
       23
       +
             general as possible, but also contains convenience functions for generating

     

       24
       24
       +
             a set of pages for entire packages.

     

       25
       25
       +
           '';

     

       26
       26
       +
         };

     

       27
       27
       +
       }

+26

pkgs/development/octave-modules/geometry/default.nix

···

       1
       1
       +
       { buildOctavePackage

     

       2
       2
       +
       , lib

     

       3
       3
       +
       , fetchurl

     

       4
       4
       +
       , matgeom

     

       5
       5
       +
       }:

     

       6
       6
       +
       

     

       7
       7
       +
       buildOctavePackage rec {

     

       8
       8
       +
         pname = "geometry";

     

       9
       9
       +
         version = "4.0.0";

     

       10
       10
       +
       

     

       11
       11
       +
         src = fetchurl {

     

       12
       12
       +
           url = "mirror://sourceforge/octave/${pname}-${version}.tar.gz";

     

       13
       13
       +
           sha256 = "1zmd97xir62fr5v57xifh2cvna5fg67h9yb7bp2vm3ll04y41lhs";

     

       14
       14
       +
         };

     

       15
       15
       +
       

     

       16
       16
       +
         requiredOctavePackages = [

     

       17
       17
       +
           matgeom

     

       18
       18
       +
         ];

     

       19
       19
       +
       

     

       20
       20
       +
         meta = with lib; {

     

       21
       21
       +
           homepage = "https://octave.sourceforge.io/geometry/index.html";

     

       22
       22
       +
           license = with licenses; [ gpl3Plus boost ];

     

       23
       23
       +
           maintainers = with maintainers; [ KarlJoad ];

     

       24
       24
       +
           description = "Library for extending MatGeom functionality";

     

       25
       25
       +
         };

     

       26
       26
       +
       }

+26

pkgs/development/octave-modules/gsl/default.nix

···

       1
       1
       +
       { buildOctavePackage

     

       2
       2
       +
       , lib

     

       3
       3
       +
       , fetchurl

     

       4
       4
       +
       , gsl

     

       5
       5
       +
       }:

     

       6
       6
       +
       

     

       7
       7
       +
       buildOctavePackage rec {

     

       8
       8
       +
         pname = "gsl";

     

       9
       9
       +
         version = "2.1.1";

     

       10
       10
       +
       

     

       11
       11
       +
         src = fetchurl {

     

       12
       12
       +
           url = "mirror://sourceforge/octave/${pname}-${version}.tar.gz";

     

       13
       13
       +
           sha256 = "1lvfxbqmw8h1nlrxmvrl6j4xffmbzxfhdpxz3vrc6lg2g4jwaa6h";

     

       14
       14
       +
         };

     

       15
       15
       +
       

     

       16
       16
       +
         buildInputs = [

     

       17
       17
       +
           gsl

     

       18
       18
       +
         ];

     

       19
       19
       +
       

     

       20
       20
       +
         meta = with lib; {

     

       21
       21
       +
           homepage = "https://octave.sourceforge.io/gsl/index.html";

     

       22
       22
       +
           license = licenses.gpl2Plus;

     

       23
       23
       +
           maintainers = with maintainers; [ KarlJoad ];

     

       24
       24
       +
           description = "Octave bindings to the GNU Scientific Library";

     

       25
       25
       +
         };

     

       26
       26
       +
       }

+32

pkgs/development/octave-modules/image-acquisition/default.nix

···

       1
       1
       +
       { buildOctavePackage

     

       2
       2
       +
       , lib

     

       3
       3
       +
       , fetchurl

     

       4
       4
       +
       , libv4l

     

       5
       5
       +
       , fltk

     

       6
       6
       +
       }:

     

       7
       7
       +
       

     

       8
       8
       +
       buildOctavePackage rec {

     

       9
       9
       +
         pname = "image-acquisition";

     

       10
       10
       +
         version = "0.2.2";

     

       11
       11
       +
       

     

       12
       12
       +
         src = fetchurl {

     

       13
       13
       +
           url = "mirror://sourceforge/octave/${pname}-${version}.tar.gz";

     

       14
       14
       +
           sha256 = "1amp6npkddnnz2i5rm6gvn65qrbn0nxzl2cja3dvc2xqg396wrhh";

     

       15
       15
       +
         };

     

       16
       16
       +
       

     

       17
       17
       +
         buildInputs = [

     

       18
       18
       +
           libv4l

     

       19
       19
       +
           fltk

     

       20
       20
       +
         ];

     

       21
       21
       +
       

     

       22
       22
       +
         meta = with lib; {

     

       23
       23
       +
           homepage = "https://octave.sourceforge.io/image-acquisition/index.html";

     

       24
       24
       +
           license = licenses.gpl3Plus;

     

       25
       25
       +
           maintainers = with maintainers; [ KarlJoad ];

     

       26
       26
       +
           description = "Functions to capture images from connected devices";

     

       27
       27
       +
           longDescription = ''

     

       28
       28
       +
             The Octave-forge Image Aquisition package provides functions to

     

       29
       29
       +
             capture images from connected devices. Currently only v4l2 is supported.

     

       30
       30
       +
           '';

     

       31
       31
       +
         };

     

       32
       32
       +
       }

+27

pkgs/development/octave-modules/image/default.nix

···

       1
       1
       +
       { buildOctavePackage

     

       2
       2
       +
       , lib

     

       3
       3
       +
       , fetchurl

     

       4
       4
       +
       }:

     

       5
       5
       +
       

     

       6
       6
       +
       buildOctavePackage rec {

     

       7
       7
       +
         pname = "image";

     

       8
       8
       +
         version = "2.12.0";

     

       9
       9
       +
       

     

       10
       10
       +
         src = fetchurl {

     

       11
       11
       +
           url = "mirror://sourceforge/octave/${pname}-${version}.tar.gz";

     

       12
       12
       +
           sha256 = "1d3kqhbkq9acc29k42fcilfmykk9a0r321mvk46l5iibc7nqrmg7";

     

       13
       13
       +
         };

     

       14
       14
       +
       

     

       15
       15
       +
         meta = with lib; {

     

       16
       16
       +
           homepage = "https://octave.sourceforge.io/image/index.html";

     

       17
       17
       +
           license = licenses.gpl3Plus;

     

       18
       18
       +
           maintainers = with maintainers; [ KarlJoad ];

     

       19
       19
       +
           description = "Functions for processing images";

     

       20
       20
       +
           longDescription = ''

     

       21
       21
       +
              The Octave-forge Image package provides functions for processing

     

       22
       22
       +
              images. The package also provides functions for feature extraction,

     

       23
       23
       +
              image statistics, spatial and geometric transformations, morphological

     

       24
       24
       +
              operations, linear filtering, and much more.

     

       25
       25
       +
           '';

     

       26
       26
       +
         };

     

       27
       27
       +
       }

+21

pkgs/development/octave-modules/instrument-control/default.nix

···

       1
       1
       +
       { buildOctavePackage

     

       2
       2
       +
       , lib

     

       3
       3
       +
       , fetchurl

     

       4
       4
       +
       }:

     

       5
       5
       +
       

     

       6
       6
       +
       buildOctavePackage rec {

     

       7
       7
       +
         pname = "instrument-control";

     

       8
       8
       +
         version = "0.6.0";

     

       9
       9
       +
       

     

       10
       10
       +
         src = fetchurl {

     

       11
       11
       +
           url = "mirror://sourceforge/octave/${pname}-${version}.tar.gz";

     

       12
       12
       +
           sha256 = "0vckax6rx5v3fq5j6kb6n39a5zas9i24x4wvmjlhc8xbykkg5nkk";

     

       13
       13
       +
         };

     

       14
       14
       +
       

     

       15
       15
       +
         meta = with lib; {

     

       16
       16
       +
           homepage = "https://octave.sourceforge.io/instrument-control/index.html";

     

       17
       17
       +
           license = licenses.gpl3Plus;

     

       18
       18
       +
           maintainers = with maintainers; [ KarlJoad ];

     

       19
       19
       +
           description = "Low level I/O functions for serial, i2c, spi, parallel, tcp, gpib, vxi11, udp and usbtmc interfaces";

     

       20
       20
       +
         };

     

       21
       21
       +
       }

+39

pkgs/development/octave-modules/interval/default.nix

···

       1
       1
       +
       { buildOctavePackage

     

       2
       2
       +
       , lib

     

       3
       3
       +
       , fetchurl

     

       4
       4
       +
       , mpfr

     

       5
       5
       +
       }:

     

       6
       6
       +
       

     

       7
       7
       +
       buildOctavePackage rec {

     

       8
       8
       +
         pname = "interval";

     

       9
       9
       +
         version = "3.2.0";

     

       10
       10
       +
       

     

       11
       11
       +
         src = fetchurl {

     

       12
       12
       +
           url = "mirror://sourceforge/octave/${pname}-${version}.tar.gz";

     

       13
       13
       +
           sha256 = "0a0sz7b4y53qgk1xr4pannn4w7xiin2pf74x7r54hrr1wf4abp20";

     

       14
       14
       +
         };

     

       15
       15
       +
       

     

       16
       16
       +
         propagatedBuildInputs = [

     

       17
       17
       +
           mpfr

     

       18
       18
       +
         ];

     

       19
       19
       +
       

     

       20
       20
       +
         meta = with lib; {

     

       21
       21
       +
           homepage = "https://octave.sourceforge.io/interval/index.html";

     

       22
       22
       +
           license = licenses.gpl3Plus;

     

       23
       23
       +
           maintainers = with maintainers; [ KarlJoad ];

     

       24
       24
       +
           description = "Interval arithmetic to evaluate functions over subsets of their domain";

     

       25
       25
       +
           longDescription = ''

     

       26
       26
       +
              The interval package for real-valued interval arithmetic allows one to

     

       27
       27
       +
              evaluate functions over subsets of their domain. All results are verified,

     

       28
       28
       +
              because interval computations automatically keep track of any errors.

     

       29
       29
       +
       

     

       30
       30
       +
              These concepts can be used to handle uncertainties, estimate arithmetic

     

       31
       31
       +
              errors and produce reliable results. Also it can be applied to

     

       32
       32
       +
              computer-assisted proofs, constraint programming, and verified computing.

     

       33
       33
       +
       

     

       34
       34
       +
              The implementation is based on interval boundaries represented by

     

       35
       35
       +
              binary64 numbers and is conforming to IEEE Std 1788-2015, IEEE standard

     

       36
       36
       +
              for interval arithmetic.

     

       37
       37
       +
           '';

     

       38
       38
       +
         };

     

       39
       39
       +
       }

+32

pkgs/development/octave-modules/io/default.nix

···

       1
       1
       +
       { buildOctavePackage

     

       2
       2
       +
       , lib

     

       3
       3
       +
       , fetchurl

     

       4
       4
       +
       , enableJava

     

       5
       5
       +
       , jdk

     

       6
       6
       +
       , unzip

     

       7
       7
       +
       }:

     

       8
       8
       +
       

     

       9
       9
       +
       buildOctavePackage rec {

     

       10
       10
       +
         pname = "io";

     

       11
       11
       +
         version = "2.6.3";

     

       12
       12
       +
       

     

       13
       13
       +
         src = fetchurl {

     

       14
       14
       +
           url = "mirror://sourceforge/octave/${pname}-${version}.tar.gz";

     

       15
       15
       +
           sha256 = "044y8lfp93fx0592mv6x2ss0nvjkjgvlci3c3ahav76pk1j3rikb";

     

       16
       16
       +
         };

     

       17
       17
       +
       

     

       18
       18
       +
         buildInputs = [

     

       19
       19
       +
           (lib.optional enableJava jdk)

     

       20
       20
       +
         ];

     

       21
       21
       +
       

     

       22
       22
       +
         propagatedBuildInputs = [

     

       23
       23
       +
           unzip

     

       24
       24
       +
         ];

     

       25
       25
       +
       

     

       26
       26
       +
         meta = with lib; {

     

       27
       27
       +
           homepage = "https://octave.sourceforge.io/io/index.html";

     

       28
       28
       +
           license = with licenses; [ gpl3Plus bsd2 ];

     

       29
       29
       +
           maintainers = with maintainers; [ KarlJoad ];

     

       30
       30
       +
           description = "Input/Output in external formats";

     

       31
       31
       +
         };

     

       32
       32
       +
       }

+54

pkgs/development/octave-modules/level-set/default.nix

···

       1
       1
       +
       { buildOctavePackage

     

       2
       2
       +
       , lib

     

       3
       3
       +
       , fetchgit

     

       4
       4
       +
       , automake

     

       5
       5
       +
       , autoconf

     

       6
       6
       +
       , autoconf-archive

     

       7
       7
       +
       , parallel

     

       8
       8
       +
       }:

     

       9
       9
       +
       

     

       10
       10
       +
       buildOctavePackage rec {

     

       11
       11
       +
         pname = "level-set";

     

       12
       12
       +
         version = "2019-04-13";

     

       13
       13
       +
       

     

       14
       14
       +
         src = fetchgit {

     

       15
       15
       +
           url = "https://git.code.sf.net/p/octave/${pname}";

     

       16
       16
       +
           rev = "dbf46228a7582eef4fe5470fd00bc5b421dd33a5";

     

       17
       17
       +
           sha256 = "14qwa4j24m2j7njw8gbagkgmp040h6k0h7kyrrzgb9y0jm087qkl";

     

       18
       18
       +
           fetchSubmodules = false;

     

       19
       19
       +
         };

     

       20
       20
       +
       

     

       21
       21
       +
         # The monstrosity of a regex below is to ensure that only error() calls are

     

       22
       22
       +
         # corrected to have a %s format specifier. However, logic_error() also

     

       23
       23
       +
         # exists, (a simple regex also matches that), but logic_error() doesn't

     

       24
       24
       +
         # require a format specifier. So, this regex was born to handle that...

     

       25
       25
       +
         patchPhase = ''

     

       26
       26
       +
           substituteInPlace build.sh --replace "level-set-0.3.1" "${pname}-${version}" \

     

       27
       27
       +
                                      --replace "\`pwd\`" '/build'

     

       28
       28
       +
           sed -i -E 's#[^[:graph:]]error \(# error \(\"%s\", #g' src/*.cpp

     

       29
       29
       +
         '';

     

       30
       30
       +
       

     

       31
       31
       +
         nativeBuildInputs = [

     

       32
       32
       +
           automake

     

       33
       33
       +
           autoconf

     

       34
       34
       +
           autoconf-archive

     

       35
       35
       +
         ];

     

       36
       36
       +
       

     

       37
       37
       +
         requiredOctavePackages = [

     

       38
       38
       +
           parallel

     

       39
       39
       +
         ];

     

       40
       40
       +
       

     

       41
       41
       +
         preBuild = ''

     

       42
       42
       +
           mkdir -p $out

     

       43
       43
       +
           source ./build.sh

     

       44
       44
       +
           cd -

     

       45
       45
       +
         '';

     

       46
       46
       +
       

     

       47
       47
       +
         meta = with lib; {

     

       48
       48
       +
           name = "Level Set";

     

       49
       49
       +
           homepage = "https://octave.sourceforge.io/level-set/index.html";

     

       50
       50
       +
           license = licenses.gpl3Plus;

     

       51
       51
       +
           maintainers = with maintainers; [ KarlJoad ];

     

       52
       52
       +
           description = "Routines for calculating the time-evolution of the level-set equation and extracting geometric information from the level-set function";

     

       53
       53
       +
         };

     

       54
       54
       +
       }

+22

pkgs/development/octave-modules/linear-algebra/default.nix

···

       1
       1
       +
       { buildOctavePackage

     

       2
       2
       +
       , lib

     

       3
       3
       +
       , fetchurl

     

       4
       4
       +
       }:

     

       5
       5
       +
       

     

       6
       6
       +
       buildOctavePackage rec {

     

       7
       7
       +
         pname = "linear-algebra";

     

       8
       8
       +
         version = "2.2.3";

     

       9
       9
       +
       

     

       10
       10
       +
         src = fetchurl {

     

       11
       11
       +
           url = "mirror://sourceforge/octave/${pname}-${version}.tar.gz";

     

       12
       12
       +
           sha256 = "1wwjpxp9vjc6lszh0z3kgy4hyzpib8rvvh6b74ijh9qk9r9nmvjk";

     

       13
       13
       +
         };

     

       14
       14
       +
       

     

       15
       15
       +
         meta = with lib; {

     

       16
       16
       +
           homepage = "https://octave.sourceforge.io/linear-algebra/index.html";

     

       17
       17
       +
           license = with licenses; [ gpl3Plus lgpl3Plus ];

     

       18
       18
       +
           # They claim to have a FreeBSD license, but none of their code seems to have it.

     

       19
       19
       +
           maintainers = with maintainers; [ KarlJoad ];

     

       20
       20
       +
           description = "Additional linear algebra code, including matrix functions";

     

       21
       21
       +
         };

     

       22
       22
       +
       }

+27

pkgs/development/octave-modules/lssa/default.nix

···

       1
       1
       +
       { buildOctavePackage

     

       2
       2
       +
       , lib

     

       3
       3
       +
       , fetchurl

     

       4
       4
       +
       }:

     

       5
       5
       +
       

     

       6
       6
       +
       buildOctavePackage rec {

     

       7
       7
       +
         pname = "lssa";

     

       8
       8
       +
         version = "0.1.4";

     

       9
       9
       +
       

     

       10
       10
       +
         src = fetchurl {

     

       11
       11
       +
           url = "mirror://sourceforge/octave/${pname}-${version}.tar.gz";

     

       12
       12
       +
           sha256 = "10h9lzsi7pqh93i7y50b618g05fnbw9n0i505bz5kz4avfa990zh";

     

       13
       13
       +
         };

     

       14
       14
       +
       

     

       15
       15
       +
         meta = with lib; {

     

       16
       16
       +
           homepage = "https://octave.sourceforge.io/lssa/index.html";

     

       17
       17
       +
           license = licenses.gpl3Plus;

     

       18
       18
       +
           maintainers = with maintainers; [ KarlJoad ];

     

       19
       19
       +
           description = "Tools to compute spectral decompositions of irregularly-spaced time series";

     

       20
       20
       +
           longDescription = ''

     

       21
       21
       +
              A package implementing tools to compute spectral decompositions of

     

       22
       22
       +
              irregularly-spaced time series. Currently includes functions based off

     

       23
       23
       +
              the Lomb-Scargle periodogram and Adolf Mathias' implementation for R

     

       24
       24
       +
              and C.

     

       25
       25
       +
           '';

     

       26
       26
       +
         };

     

       27
       27
       +
       }

+54

pkgs/development/octave-modules/ltfat/default.nix

···

       1
       1
       +
       { buildOctavePackage

     

       2
       2
       +
       , lib

     

       3
       3
       +
       , fetchurl

     

       4
       4
       +
       , fftw

     

       5
       5
       +
       , fftwSinglePrec

     

       6
       6
       +
       , fftwFloat

     

       7
       7
       +
       , fftwLongDouble

     

       8
       8
       +
       , lapack

     

       9
       9
       +
       , blas

     

       10
       10
       +
       , portaudio

     

       11
       11
       +
       , jdk

     

       12
       12
       +
       }:

     

       13
       13
       +
       

     

       14
       14
       +
       buildOctavePackage rec {

     

       15
       15
       +
         pname = "ltfat";

     

       16
       16
       +
         version = "2.3.1";

     

       17
       17
       +
       

     

       18
       18
       +
         src = fetchurl {

     

       19
       19
       +
           url = "mirror://sourceforge/octave/${pname}-${version}.tar.gz";

     

       20
       20
       +
           sha256 = "0gghh5a4w649ff776wvidfvqas87m0n7rqs960pid1d11bnyqqrh";

     

       21
       21
       +
         };

     

       22
       22
       +
       

     

       23
       23
       +
         patches = [

     

       24
       24
       +
           # Fixes a syntax error with performing multiplication.

     

       25
       25
       +
           ./syntax-error.patch

     

       26
       26
       +
         ];

     

       27
       27
       +
       

     

       28
       28
       +
         buildInputs = [

     

       29
       29
       +
           fftw

     

       30
       30
       +
           fftwSinglePrec

     

       31
       31
       +
           fftwFloat

     

       32
       32
       +
           fftwLongDouble

     

       33
       33
       +
           lapack

     

       34
       34
       +
           blas

     

       35
       35
       +
           portaudio

     

       36
       36
       +
           jdk

     

       37
       37
       +
         ];

     

       38
       38
       +
       

     

       39
       39
       +
         meta = with lib; {

     

       40
       40
       +
           name = "The Large Time-Frequency Analysis Toolbox";

     

       41
       41
       +
           homepage = "https://octave.sourceforge.io/ltfat/index.html";

     

       42
       42
       +
           license = licenses.gpl3Plus;

     

       43
       43
       +
           maintainers = with maintainers; [ KarlJoad ];

     

       44
       44
       +
           description = "Toolbox for working with time-frequency analysis, wavelets and signal processing";

     

       45
       45
       +
           longDescription = ''

     

       46
       46
       +
             The Large Time/Frequency Analysis Toolbox (LTFAT) is a Matlab/Octave

     

       47
       47
       +
             toolbox for working with time-frequency analysis, wavelets and signal

     

       48
       48
       +
             processing. It is intended both as an educational and a computational

     

       49
       49
       +
             tool. The toolbox provides a large number of linear transforms including

     

       50
       50
       +
             Gabor and wavelet transforms along with routines for constructing windows

     

       51
       51
       +
             (filter prototypes) and routines for manipulating coefficients.

     

       52
       52
       +
           '';

     

       53
       53
       +
         };

     

       54
       54
       +
       }

+15

pkgs/development/octave-modules/ltfat/syntax-error.patch

···

       1
       1
       +
       diff --git a/inst/nonstatgab/nsdgt.m b/inst/nonstatgab/nsdgt.m

     

       2
       2
       +
       index ac53963..81656cb 100644

     

       3
       3
       +
       --- a/inst/nonstatgab/nsdgt.m

     

       4
       4
       +
       +++ b/inst/nonstatgab/nsdgt.m

     

       5
       5
       +
       @@ -149,8 +149,8 @@ for ii = 1:N

     

       6
       6
       +
                col = ceil(Lg/M(ii));

     

       7
       7
       +
                

     

       8
       8
       +
                temp = zeros(col*M(ii),W,assert_classname(f,g{1}));

     

       9
       9
       +
       -        temp([end-floor(Lg/2)+1:end,1:ceil(Lg/2)],:) = bsxfun(@ ...

     

       10
       10
       +
       -                                                          times,f(win_range,:),g{ii}(idx));

     

       11
       11
       +
       +        temp([end-floor(Lg/2)+1:end,1:ceil(Lg/2)],:) = bsxfun(@times, ...

     

       12
       12
       +
       +                                                          f(win_range,:),g{ii}(idx));

     

       13
       13
       +
                

     

       14
       14
       +
                temp = reshape(temp,M(ii),col,W);

     

       15
       15
       +
                X = squeeze(fft(sum(temp,2)));

+28

pkgs/development/octave-modules/mapping/default.nix

···

       1
       1
       +
       { buildOctavePackage

     

       2
       2
       +
       , lib

     

       3
       3
       +
       , fetchurl

     

       4
       4
       +
       , io # >= 2.2.7

     

       5
       5
       +
       , geometry # >= 4.0.0

     

       6
       6
       +
       }:

     

       7
       7
       +
       

     

       8
       8
       +
       buildOctavePackage rec {

     

       9
       9
       +
         pname = "mapping";

     

       10
       10
       +
         version = "1.4.1";

     

       11
       11
       +
       

     

       12
       12
       +
         src = fetchurl {

     

       13
       13
       +
           url = "mirror://sourceforge/octave/${pname}-${version}.tar.gz";

     

       14
       14
       +
           sha256 = "0wj0q1rkrqs4qgpjh4vn9kcpdh94pzr6v4jc1vcrjwkp87yjv8c0";

     

       15
       15
       +
         };

     

       16
       16
       +
       

     

       17
       17
       +
         requiredOctavePackages = [

     

       18
       18
       +
           io

     

       19
       19
       +
           geometry

     

       20
       20
       +
         ];

     

       21
       21
       +
       

     

       22
       22
       +
         meta = with lib; {

     

       23
       23
       +
           homepage = "https://octave.sourceforge.io/mapping/index.html";

     

       24
       24
       +
           license = licenses.gpl3Plus;

     

       25
       25
       +
           maintainers = with maintainers; [ KarlJoad ];

     

       26
       26
       +
           description = "Simple mapping and GIS .shp .dxf and raster file functions";

     

       27
       27
       +
         };

     

       28
       28
       +
       }

+21

pkgs/development/octave-modules/matgeom/default.nix

···

       1
       1
       +
       { buildOctavePackage

     

       2
       2
       +
       , lib

     

       3
       3
       +
       , fetchurl

     

       4
       4
       +
       }:

     

       5
       5
       +
       

     

       6
       6
       +
       buildOctavePackage rec {

     

       7
       7
       +
         pname = "matgeom";

     

       8
       8
       +
         version = "1.2.2";

     

       9
       9
       +
       

     

       10
       10
       +
         src = fetchurl {

     

       11
       11
       +
           url = "mirror://sourceforge/octave/${pname}-${version}.tar.gz";

     

       12
       12
       +
           sha256 = "05xfmlh1k3mhq8yag7gr8q1ysl1s43vm46fr1i3gcg9b1kkwi8by";

     

       13
       13
       +
         };

     

       14
       14
       +
       

     

       15
       15
       +
         meta = with lib; {

     

       16
       16
       +
           homepage = "https://octave.sourceforge.io/matgeom/index.html";

     

       17
       17
       +
           license = with licenses; [ bsd2 gpl3Plus ];

     

       18
       18
       +
           maintainers = with maintainers; [ KarlJoad ];

     

       19
       19
       +
           description = "Geometry toolbox for 2D/3D geometric computing";

     

       20
       20
       +
         };

     

       21
       21
       +
       }

+34

pkgs/development/octave-modules/miscellaneous/default.nix

···

       1
       1
       +
       { buildOctavePackage

     

       2
       2
       +
       , lib

     

       3
       3
       +
       , fetchurl

     

       4
       4
       +
       # Build-time dependencies

     

       5
       5
       +
       , mlterm

     

       6
       6
       +
       , ncurses # >= 5

     

       7
       7
       +
       , units

     

       8
       8
       +
       }:

     

       9
       9
       +
       

     

       10
       10
       +
       buildOctavePackage rec {

     

       11
       11
       +
         pname = "miscellaneous";

     

       12
       12
       +
         version = "1.3.0";

     

       13
       13
       +
       

     

       14
       14
       +
         src = fetchurl {

     

       15
       15
       +
           url = "mirror://sourceforge/octave/${pname}-${version}.tar.gz";

     

       16
       16
       +
           sha256 = "10n107njz24ln7v9a1l3dkh7s7vd6qwgbinrj1nl4wflxsir4l9k";

     

       17
       17
       +
         };

     

       18
       18
       +
       

     

       19
       19
       +
         buildInputs = [

     

       20
       20
       +
           mlterm

     

       21
       21
       +
           ncurses

     

       22
       22
       +
         ];

     

       23
       23
       +
       

     

       24
       24
       +
         propagatedBuildInputs = [

     

       25
       25
       +
           units

     

       26
       26
       +
         ];

     

       27
       27
       +
       

     

       28
       28
       +
         meta = with lib; {

     

       29
       29
       +
           homepage = "https://octave.sourceforge.io/miscellaneous/index.html";

     

       30
       30
       +
           license = licenses.gpl3Plus;

     

       31
       31
       +
           maintainers = with maintainers; [ KarlJoad ];

     

       32
       32
       +
           description = "Miscellaneous tools that don't fit somewhere else";

     

       33
       33
       +
         };

     

       34
       34
       +
       }

+56

pkgs/development/octave-modules/msh/default.nix

···

       1
       1
       +
       { buildOctavePackage

     

       2
       2
       +
       , lib

     

       3
       3
       +
       , fetchurl

     

       4
       4
       +
       # Octave Dependencies

     

       5
       5
       +
       , splines

     

       6
       6
       +
       # Other Dependencies

     

       7
       7
       +
       , gmsh

     

       8
       8
       +
       , gawk

     

       9
       9
       +
       , pkg-config

     

       10
       10
       +
       , dolfin

     

       11
       11
       +
       , autoconf, automake

     

       12
       12
       +
       }:

     

       13
       13
       +
       

     

       14
       14
       +
       buildOctavePackage rec {

     

       15
       15
       +
         pname = "msh";

     

       16
       16
       +
         version = "1.0.10";

     

       17
       17
       +
       

     

       18
       18
       +
         src = fetchurl {

     

       19
       19
       +
           url = "mirror://sourceforge/octave/${pname}-${version}.tar.gz";

     

       20
       20
       +
           sha256 = "1mb5qrp9y1w1cbzrd9v84430ldy57ca843yspnrgbcqpxyyxbgfz";

     

       21
       21
       +
         };

     

       22
       22
       +
       

     

       23
       23
       +
         nativeBuildInputs = [

     

       24
       24
       +
           pkg-config

     

       25
       25
       +
           autoconf automake

     

       26
       26
       +
           dolfin

     

       27
       27
       +
         ];

     

       28
       28
       +
       

     

       29
       29
       +
         buildInputs = [

     

       30
       30
       +
           dolfin

     

       31
       31
       +
         ];

     

       32
       32
       +
       

     

       33
       33
       +
         propagatedBuildInputs = [

     

       34
       34
       +
           gmsh

     

       35
       35
       +
           gawk

     

       36
       36
       +
           dolfin

     

       37
       37
       +
         ];

     

       38
       38
       +
       

     

       39
       39
       +
         requiredOctavePackages = [

     

       40
       40
       +
           splines

     

       41
       41
       +
         ];

     

       42
       42
       +
       

     

       43
       43
       +
         meta = with lib; {

     

       44
       44
       +
           homepage = "https://octave.sourceforge.io/msh/index.html";

     

       45
       45
       +
           license = licenses.gpl2Plus;

     

       46
       46
       +
           maintainers = with maintainers; [ KarlJoad ];

     

       47
       47
       +
           description = "Create and manage triangular and tetrahedral meshes for Finite Element or Finite Volume PDE solvers";

     

       48
       48
       +
           longDescription = ''

     

       49
       49
       +
             Create and manage triangular and tetrahedral meshes for Finite Element or

     

       50
       50
       +
             Finite Volume PDE solvers. Use a mesh data structure compatible with

     

       51
       51
       +
             PDEtool. Rely on gmsh for unstructured mesh generation.

     

       52
       52
       +
           '';

     

       53
       53
       +
           # Not technically broken, but missing some functionality.

     

       54
       54
       +
           # dolfin needs to be its own stand-alone library for the last tests to pass.

     

       55
       55
       +
         };

     

       56
       56
       +
       }

+21

pkgs/development/octave-modules/mvn/default.nix

···

       1
       1
       +
       { buildOctavePackage

     

       2
       2
       +
       , lib

     

       3
       3
       +
       , fetchurl

     

       4
       4
       +
       }:

     

       5
       5
       +
       

     

       6
       6
       +
       buildOctavePackage rec {

     

       7
       7
       +
         pname = "mvn";

     

       8
       8
       +
         version = "1.1.0";

     

       9
       9
       +
       

     

       10
       10
       +
         src = fetchurl {

     

       11
       11
       +
           url = "mirror://sourceforge/octave/${pname}-${version}.tar.gz";

     

       12
       12
       +
           sha256 = "00w69hxqnqdm3744z6p7gvzci44a3gy228x6bgq3xf5n3jwicnmg";

     

       13
       13
       +
         };

     

       14
       14
       +
       

     

       15
       15
       +
         meta = with lib; {

     

       16
       16
       +
           homepage = "https://octave.sourceforge.io/mvn/index.html";

     

       17
       17
       +
           license = licenses.gpl3Plus;

     

       18
       18
       +
           maintainers = with maintainers; [ KarlJoad ];

     

       19
       19
       +
           description = "Multivariate normal distribution clustering and utility functions";

     

       20
       20
       +
         };

     

       21
       21
       +
       }

+26

pkgs/development/octave-modules/nan/default.nix

···

       1
       1
       +
       { buildOctavePackage

     

       2
       2
       +
       , lib

     

       3
       3
       +
       , fetchurl

     

       4
       4
       +
       , blas

     

       5
       5
       +
       }:

     

       6
       6
       +
       

     

       7
       7
       +
       buildOctavePackage rec {

     

       8
       8
       +
         pname = "nan";

     

       9
       9
       +
         version = "3.5.2";

     

       10
       10
       +
       

     

       11
       11
       +
         src = fetchurl {

     

       12
       12
       +
           url = "mirror://sourceforge/octave/${pname}-${version}.tar.gz";

     

       13
       13
       +
           sha256 = "0bp8zl50f8qj5sivl88kjdswm035v4li33fiq3v1gmh0pvgbcw7a";

     

       14
       14
       +
         };

     

       15
       15
       +
       

     

       16
       16
       +
         buildInputs = [

     

       17
       17
       +
           blas

     

       18
       18
       +
         ];

     

       19
       19
       +
       

     

       20
       20
       +
         meta = with lib; {

     

       21
       21
       +
           homepage = "https://octave.sourceforge.io/nan/index.html";

     

       22
       22
       +
           license = licenses.gpl3Plus;

     

       23
       23
       +
           maintainers = with maintainers; [ KarlJoad ];

     

       24
       24
       +
           description = "A statistics and machine learning toolbox for data with and w/o missing values";

     

       25
       25
       +
         };

     

       26
       26
       +
       }

+31

pkgs/development/octave-modules/ncarray/default.nix

···

       1
       1
       +
       { buildOctavePackage

     

       2
       2
       +
       , lib

     

       3
       3
       +
       , fetchurl

     

       4
       4
       +
       , netcdf

     

       5
       5
       +
       , statistics

     

       6
       6
       +
       }:

     

       7
       7
       +
       

     

       8
       8
       +
       buildOctavePackage rec {

     

       9
       9
       +
         pname = "ncarray";

     

       10
       10
       +
         version = "1.0.4";

     

       11
       11
       +
       

     

       12
       12
       +
         src = fetchurl {

     

       13
       13
       +
           url = "mirror://sourceforge/octave/${pname}-${version}.tar.gz";

     

       14
       14
       +
           sha256 = "0v96iziikvq2v7hczhbfs9zmk49v99kn6z3lgibqqpwam175yqgd";

     

       15
       15
       +
         };

     

       16
       16
       +
       

     

       17
       17
       +
         buildInputs = [

     

       18
       18
       +
           netcdf

     

       19
       19
       +
         ];

     

       20
       20
       +
       

     

       21
       21
       +
         requiredOctavePackages = [

     

       22
       22
       +
           statistics

     

       23
       23
       +
         ];

     

       24
       24
       +
       

     

       25
       25
       +
         meta = with lib; {

     

       26
       26
       +
           homepage = "https://octave.sourceforge.io/ncarray/index.html";

     

       27
       27
       +
           license = licenses.gpl2Plus;

     

       28
       28
       +
           maintainers = with maintainers; [ KarlJoad ];

     

       29
       29
       +
           description = "Access a single or a collection of NetCDF files as a multi-dimensional array";

     

       30
       30
       +
         };

     

       31
       31
       +
       }

+26

pkgs/development/octave-modules/netcdf/default.nix

···

       1
       1
       +
       { buildOctavePackage

     

       2
       2
       +
       , lib

     

       3
       3
       +
       , fetchurl

     

       4
       4
       +
       , netcdf

     

       5
       5
       +
       }:

     

       6
       6
       +
       

     

       7
       7
       +
       buildOctavePackage rec {

     

       8
       8
       +
         pname = "netcdf";

     

       9
       9
       +
         version = "1.0.14";

     

       10
       10
       +
       

     

       11
       11
       +
         src = fetchurl {

     

       12
       12
       +
           url = "mirror://sourceforge/octave/${pname}-${version}.tar.gz";

     

       13
       13
       +
           sha256 = "1wdwl76zgcg7kkdxjfjgf23ylzb0x4dyfliffylyl40g6cjym9lf";

     

       14
       14
       +
         };

     

       15
       15
       +
       

     

       16
       16
       +
         buildInputs = [

     

       17
       17
       +
           netcdf

     

       18
       18
       +
         ];

     

       19
       19
       +
       

     

       20
       20
       +
         meta = with lib; {

     

       21
       21
       +
           homepage = "https://octave.sourceforge.io/netcdf/index.html";

     

       22
       22
       +
           license = licenses.gpl2Plus;

     

       23
       23
       +
           maintainers = with maintainers; [ KarlJoad ];

     

       24
       24
       +
           description = "A NetCDF interface for Octave";

     

       25
       25
       +
         };

     

       26
       26
       +
       }

+30

pkgs/development/octave-modules/nurbs/default.nix

···

       1
       1
       +
       { buildOctavePackage

     

       2
       2
       +
       , lib

     

       3
       3
       +
       , fetchurl

     

       4
       4
       +
       }:

     

       5
       5
       +
       

     

       6
       6
       +
       buildOctavePackage rec {

     

       7
       7
       +
         pname = "nurbs";

     

       8
       8
       +
         version = "1.3.13";

     

       9
       9
       +
       

     

       10
       10
       +
         src = fetchurl {

     

       11
       11
       +
           url = "mirror://sourceforge/octave/${pname}-${version}.tar.gz";

     

       12
       12
       +
           sha256 = "0zkyldm63pc3pcal3yvj6af24cvpjvv9qfhf0ihhwcsh4w3yggyv";

     

       13
       13
       +
         };

     

       14
       14
       +
       

     

       15
       15
       +
         # Has been fixed in more recent commits, but has not been pushed out as a

     

       16
       16
       +
         # new version yet.

     

       17
       17
       +
         # The sed changes allow nurbs to compile.

     

       18
       18
       +
         patchPhase = ''

     

       19
       19
       +
           sed -i s/feval/octave::feval/g src/*.cc

     

       20
       20
       +
           sed -i s/is_real_type/isreal/g src/*.cc

     

       21
       21
       +
           sed -i s/is_cell/iscell/g src/*.cc

     

       22
       22
       +
         '';

     

       23
       23
       +
       

     

       24
       24
       +
         meta = with lib; {

     

       25
       25
       +
           homepage = "https://octave.sourceforge.io/nurbs/index.html";

     

       26
       26
       +
           license = licenses.gpl3Plus;

     

       27
       27
       +
           maintainers = with maintainers; [ KarlJoad ];

     

       28
       28
       +
           description = "Collection of routines for the creation, and manipulation of Non-Uniform Rational B-Splines (NURBS), based on the NURBS toolbox by Mark Spink";

     

       29
       29
       +
         };

     

       30
       30
       +
       }

+26

pkgs/development/octave-modules/ocl/default.nix

···

       1
       1
       +
       { buildOctavePackage

     

       2
       2
       +
       , lib

     

       3
       3
       +
       , fetchurl

     

       4
       4
       +
       }:

     

       5
       5
       +
       

     

       6
       6
       +
       buildOctavePackage rec {

     

       7
       7
       +
         pname = "ocl";

     

       8
       8
       +
         version = "1.1.1";

     

       9
       9
       +
       

     

       10
       10
       +
         src = fetchurl {

     

       11
       11
       +
           url = "mirror://sourceforge/octave/${pname}-${version}.tar.gz";

     

       12
       12
       +
           sha256 = "0ayi5x9zk9p4zm0qsr3i94lyp5468c9d1a7mqrqjqpdvkhrw0xnm";

     

       13
       13
       +
         };

     

       14
       14
       +
       

     

       15
       15
       +
         meta = with lib; {

     

       16
       16
       +
           homepage = "https://octave.sourceforge.io/ocl/index.html";

     

       17
       17
       +
           license = licenses.gpl3Plus;

     

       18
       18
       +
           maintainers = with maintainers; [ KarlJoad ];

     

       19
       19
       +
           description = "Use OpenCL for parallelization";

     

       20
       20
       +
           longDescription = ''

     

       21
       21
       +
              Package using OpenCL for parallelization, mostly suitable to

     

       22
       22
       +
              Single-Instruction-Multiple-Data (SIMD) computations, selectively

     

       23
       23
       +
              using available OpenCL hardware and drivers.

     

       24
       24
       +
           '';

     

       25
       25
       +
         };

     

       26
       26
       +
       }

+29

pkgs/development/octave-modules/octclip/default.nix

···

       1
       1
       +
       { buildOctavePackage

     

       2
       2
       +
       , lib

     

       3
       3
       +
       , fetchurl

     

       4
       4
       +
       }:

     

       5
       5
       +
       

     

       6
       6
       +
       buildOctavePackage rec {

     

       7
       7
       +
         pname = "octclip";

     

       8
       8
       +
         version = "2.0.1";

     

       9
       9
       +
       

     

       10
       10
       +
         src = fetchurl {

     

       11
       11
       +
           url = "mirror://sourceforge/octave/${pname}-${version}.tar.gz";

     

       12
       12
       +
           sha256 = "05ijh3izgfaan84n6zp690nap9vnz0zicjd0cgvd1c6askm7vxql";

     

       13
       13
       +
         };

     

       14
       14
       +
       

     

       15
       15
       +
         # The only compilation problem is that no formatting specifier was provided

     

       16
       16
       +
         # for the error function. Because errorText is a string, I provide such a

     

       17
       17
       +
         # formatting specifier.

     

       18
       18
       +
         patchPhase = ''

     

       19
       19
       +
           sed -i s/"error(errorText)"/"error(\"%s\", errorText)"/g src/*.cc

     

       20
       20
       +
         '';

     

       21
       21
       +
       

     

       22
       22
       +
         meta = with lib; {

     

       23
       23
       +
           name = "GNU Octave Clipping Polygons Tool";

     

       24
       24
       +
           homepage = "https://octave.sourceforge.io/octclip/index.html";

     

       25
       25
       +
           license = with licenses; [ gpl3Plus ]; # modified BSD?

     

       26
       26
       +
           maintainers = with maintainers; [ KarlJoad ];

     

       27
       27
       +
           description = "Perform boolean operations with polygons using the Greiner-Hormann algorithm";

     

       28
       28
       +
         };

     

       29
       29
       +
       }

+32

pkgs/development/octave-modules/octproj/default.nix

···

       1
       1
       +
       { buildOctavePackage

     

       2
       2
       +
       , lib

     

       3
       3
       +
       , fetchurl

     

       4
       4
       +
       , proj # >= 6.3.0

     

       5
       5
       +
       }:

     

       6
       6
       +
       

     

       7
       7
       +
       buildOctavePackage rec {

     

       8
       8
       +
         pname = "octproj";

     

       9
       9
       +
         version = "2.0.1";

     

       10
       10
       +
       

     

       11
       11
       +
         src = fetchurl {

     

       12
       12
       +
           url = "mirror://sourceforge/octave/${pname}-${version}.tar.gz";

     

       13
       13
       +
           sha256 = "1mb8gb0r8kky47ap85h9qqdvs40mjp3ya0nkh45gqhy67ml06paq";

     

       14
       14
       +
         };

     

       15
       15
       +
       

     

       16
       16
       +
         # The sed changes below allow for the package to be compiled.

     

       17
       17
       +
         patchPhase = ''

     

       18
       18
       +
           sed -i s/"error(errorText)"/"error(\"%s\", errorText)"/g src/*.cc

     

       19
       19
       +
           sed -i s/"warning(errorText)"/"warning(\"%s\", errorText)"/g src/*.cc

     

       20
       20
       +
         '';

     

       21
       21
       +
       

     

       22
       22
       +
         propagatedBuildInputs = [

     

       23
       23
       +
           proj

     

       24
       24
       +
         ];

     

       25
       25
       +
       

     

       26
       26
       +
         meta = with lib; {

     

       27
       27
       +
           homepage = "https://octave.sourceforge.io/octproj/index.html";

     

       28
       28
       +
           license = licenses.gpl3Plus;

     

       29
       29
       +
           maintainers = with maintainers; [ KarlJoad ];

     

       30
       30
       +
           description = "GNU Octave bindings to PROJ library for cartographic projections and CRS transformations";

     

       31
       31
       +
         };

     

       32
       32
       +
       }

+21

pkgs/development/octave-modules/optics/default.nix

···

       1
       1
       +
       { buildOctavePackage

     

       2
       2
       +
       , lib

     

       3
       3
       +
       , fetchurl

     

       4
       4
       +
       }:

     

       5
       5
       +
       

     

       6
       6
       +
       buildOctavePackage rec {

     

       7
       7
       +
         pname = "optics";

     

       8
       8
       +
         version = "0.1.4";

     

       9
       9
       +
       

     

       10
       10
       +
         src = fetchurl {

     

       11
       11
       +
           url = "mirror://sourceforge/octave/${pname}-${version}.tar.gz";

     

       12
       12
       +
           sha256 = "1d9z82241a1zmr8m1vgw10pyk81vn0q4dcyx7d05pigfn5gykrgc";

     

       13
       13
       +
         };

     

       14
       14
       +
       

     

       15
       15
       +
         meta = with lib; {

     

       16
       16
       +
           homepage = "https://octave.sourceforge.io/optics/index.html";

     

       17
       17
       +
           license = licenses.gpl3Plus;

     

       18
       18
       +
           maintainers = with maintainers; [ KarlJoad ];

     

       19
       19
       +
           description = "Functions covering various aspects of optics";

     

       20
       20
       +
         };

     

       21
       21
       +
       }

+36

pkgs/development/octave-modules/optim/default.nix

···

       1
       1
       +
       { buildOctavePackage

     

       2
       2
       +
       , lib

     

       3
       3
       +
       , fetchurl

     

       4
       4
       +
       , struct

     

       5
       5
       +
       , statistics

     

       6
       6
       +
       , lapack

     

       7
       7
       +
       , blas

     

       8
       8
       +
       }:

     

       9
       9
       +
       

     

       10
       10
       +
       buildOctavePackage rec {

     

       11
       11
       +
         pname = "optim";

     

       12
       12
       +
         version = "1.6.0";

     

       13
       13
       +
       

     

       14
       14
       +
         src = fetchurl {

     

       15
       15
       +
           url = "mirror://sourceforge/octave/${pname}-${version}.tar.gz";

     

       16
       16
       +
           sha256 = "1z2h8gy99glxh5qi3r22am2vdirlbklkq0lx4r8jrx1ak7awh47r";

     

       17
       17
       +
         };

     

       18
       18
       +
       

     

       19
       19
       +
         buildInputs = [

     

       20
       20
       +
           lapack

     

       21
       21
       +
           blas

     

       22
       22
       +
         ];

     

       23
       23
       +
       

     

       24
       24
       +
         requiredOctavePackages = [

     

       25
       25
       +
           struct

     

       26
       26
       +
           statistics

     

       27
       27
       +
         ];

     

       28
       28
       +
       

     

       29
       29
       +
         meta = with lib; {

     

       30
       30
       +
           homepage = "https://octave.sourceforge.io/optim/index.html";

     

       31
       31
       +
           license = with licenses; [ gpl3Plus publicDomain ];

     

       32
       32
       +
           # Modified BSD code seems removed

     

       33
       33
       +
           maintainers = with maintainers; [ KarlJoad ];

     

       34
       34
       +
           description = "Non-linear optimization toolkit";

     

       35
       35
       +
         };

     

       36
       36
       +
       }

+31

pkgs/development/octave-modules/optiminterp/default.nix

···

       1
       1
       +
       { buildOctavePackage

     

       2
       2
       +
       , lib

     

       3
       3
       +
       , fetchurl

     

       4
       4
       +
       , gfortran

     

       5
       5
       +
       }:

     

       6
       6
       +
       

     

       7
       7
       +
       buildOctavePackage rec {

     

       8
       8
       +
         pname = "optiminterp";

     

       9
       9
       +
         version = "0.3.6";

     

       10
       10
       +
       

     

       11
       11
       +
         src = fetchurl {

     

       12
       12
       +
           url = "mirror://sourceforge/octave/${pname}-${version}.tar.gz";

     

       13
       13
       +
           sha256 = "05nzj2jmrczbnsr64w2a7kww19s6yialdqnsbg797v11ii7aiylc";

     

       14
       14
       +
         };

     

       15
       15
       +
       

     

       16
       16
       +
         nativeBuildInputs = [

     

       17
       17
       +
           gfortran

     

       18
       18
       +
         ];

     

       19
       19
       +
       

     

       20
       20
       +
         meta = with lib; {

     

       21
       21
       +
           homepage = "https://octave.sourceforge.io/optiminterp/index.html";

     

       22
       22
       +
           license = licenses.gpl3Plus;

     

       23
       23
       +
           maintainers = with maintainers; [ KarlJoad ];

     

       24
       24
       +
           description = "An optimal interpolation toolbox for octave";

     

       25
       25
       +
           longDescription = ''

     

       26
       26
       +
              An optimal interpolation toolbox for octave. This package provides

     

       27
       27
       +
              functions to perform a n-dimensional optimal interpolations of

     

       28
       28
       +
              arbitrarily distributed data points.

     

       29
       29
       +
           '';

     

       30
       30
       +
         };

     

       31
       31
       +
       }

+36

pkgs/development/octave-modules/parallel/default.nix

···

       1
       1
       +
       { buildOctavePackage

     

       2
       2
       +
       , lib

     

       3
       3
       +
       , fetchurl

     

       4
       4
       +
       , struct

     

       5
       5
       +
       , gnutls

     

       6
       6
       +
       , pkg-config

     

       7
       7
       +
       }:

     

       8
       8
       +
       

     

       9
       9
       +
       buildOctavePackage rec {

     

       10
       10
       +
         pname = "parallel";

     

       11
       11
       +
         version = "4.0.0";

     

       12
       12
       +
       

     

       13
       13
       +
         src = fetchurl {

     

       14
       14
       +
           url = "mirror://sourceforge/octave/${pname}-${version}.tar.gz";

     

       15
       15
       +
           sha256 = "0wmpak01rsccrnb8is7fsjdlxw15157sqyf9s2fabr16yykfmvi8";

     

       16
       16
       +
         };

     

       17
       17
       +
       

     

       18
       18
       +
         nativeBuildInputs = [

     

       19
       19
       +
           pkg-config

     

       20
       20
       +
         ];

     

       21
       21
       +
       

     

       22
       22
       +
         buildInputs = [

     

       23
       23
       +
           gnutls

     

       24
       24
       +
         ];

     

       25
       25
       +
       

     

       26
       26
       +
         requiredOctavePackages = [

     

       27
       27
       +
           struct

     

       28
       28
       +
         ];

     

       29
       29
       +
       

     

       30
       30
       +
         meta = with lib; {

     

       31
       31
       +
           homepage = "https://octave.sourceforge.io/parallel/index.html";

     

       32
       32
       +
           license = licenses.gpl3Plus;

     

       33
       33
       +
           maintainers = with maintainers; [ KarlJoad ];

     

       34
       34
       +
           description = "Parallel execution package";

     

       35
       35
       +
         };

     

       36
       36
       +
       }

+29

pkgs/development/octave-modules/quaternion/default.nix

···

       1
       1
       +
       { buildOctavePackage

     

       2
       2
       +
       , lib

     

       3
       3
       +
       , fetchurl

     

       4
       4
       +
       }:

     

       5
       5
       +
       

     

       6
       6
       +
       buildOctavePackage rec {

     

       7
       7
       +
         pname = "quaternion";

     

       8
       8
       +
         version = "2.4.0";

     

       9
       9
       +
       

     

       10
       10
       +
         src = fetchurl {

     

       11
       11
       +
           url = "mirror://sourceforge/octave/${pname}-${version}.tar.gz";

     

       12
       12
       +
           sha256 = "040ncksf0xz32qmi4484xs3q01nappxrsvwwa60g04yjy7c4sbac";

     

       13
       13
       +
         };

     

       14
       14
       +
       

     

       15
       15
       +
         # Octave replaced many of the is_thing_type check function with isthing.

     

       16
       16
       +
         # The patch changes the occurrences of the old functions.

     

       17
       17
       +
         patchPhase = ''

     

       18
       18
       +
           sed -i s/is_numeric_type/isnumeric/g src/*.cc

     

       19
       19
       +
           sed -i s/is_real_type/isreal/g src/*.cc

     

       20
       20
       +
           sed -i s/is_bool_type/islogical/g src/*.cc

     

       21
       21
       +
         '';

     

       22
       22
       +
       

     

       23
       23
       +
         meta = with lib; {

     

       24
       24
       +
           homepage = "https://octave.sourceforge.io/quaternion/index.html";

     

       25
       25
       +
           license = licenses.gpl3Plus;

     

       26
       26
       +
           maintainers = with maintainers; [ KarlJoad ];

     

       27
       27
       +
           description = "Quaternion package for GNU Octave, includes a quaternion class with overloaded operators";

     

       28
       28
       +
         };

     

       29
       29
       +
       }

+32

pkgs/development/octave-modules/queueing/default.nix

···

       1
       1
       +
       { buildOctavePackage

     

       2
       2
       +
       , lib

     

       3
       3
       +
       , fetchurl

     

       4
       4
       +
       }:

     

       5
       5
       +
       

     

       6
       6
       +
       buildOctavePackage rec {

     

       7
       7
       +
         pname = "queueing";

     

       8
       8
       +
         version = "1.2.7";

     

       9
       9
       +
       

     

       10
       10
       +
         src = fetchurl {

     

       11
       11
       +
           url = "mirror://sourceforge/octave/${pname}-${version}.tar.gz";

     

       12
       12
       +
           sha256 = "1yhw277i1qgmddf6wbfb6a4zrfhvplkmfr20q1l15z4xi8afnm6d";

     

       13
       13
       +
         };

     

       14
       14
       +
       

     

       15
       15
       +
         meta = with lib; {

     

       16
       16
       +
           homepage = "https://octave.sourceforge.io/queueing/index.html";

     

       17
       17
       +
           license = licenses.gpl3Plus;

     

       18
       18
       +
           maintainers = with maintainers; [ KarlJoad ];

     

       19
       19
       +
           description = "Provides functions for queueing networks and Markov chains analysis";

     

       20
       20
       +
           longDescription = ''

     

       21
       21
       +
             The queueing package provides functions for queueing networks and Markov

     

       22
       22
       +
             chains analysis. This package can be used to compute steady-state

     

       23
       23
       +
             performance measures for open, closed and mixed networks with single or

     

       24
       24
       +
             multiple job classes. Mean Value Analysis (MVA), convolution, and various

     

       25
       25
       +
             bounding techniques are implemented. Furthermore, several transient and

     

       26
       26
       +
             steady-state performance measures for Markov chains can be computed, such

     

       27
       27
       +
             as state occupancy probabilities, mean time to absorption, time-averaged

     

       28
       28
       +
             sojourn times and so forth. Discrete- and continuous-time Markov chains

     

       29
       29
       +
             are supported.

     

       30
       30
       +
           '';

     

       31
       31
       +
         };

     

       32
       32
       +
       }

+26

pkgs/development/octave-modules/signal/default.nix

···

       1
       1
       +
       { buildOctavePackage

     

       2
       2
       +
       , lib

     

       3
       3
       +
       , fetchurl

     

       4
       4
       +
       , control

     

       5
       5
       +
       }:

     

       6
       6
       +
       

     

       7
       7
       +
       buildOctavePackage rec {

     

       8
       8
       +
         pname = "signal";

     

       9
       9
       +
         version = "1.4.1";

     

       10
       10
       +
       

     

       11
       11
       +
         src = fetchurl {

     

       12
       12
       +
           url = "mirror://sourceforge/octave/${pname}-${version}.tar.gz";

     

       13
       13
       +
           sha256 = "1amfh7ifjqxz2kr34hgq2mq8ygmd5j3cjdk1k2dk6qcgic7n0y6r";

     

       14
       14
       +
         };

     

       15
       15
       +
       

     

       16
       16
       +
         requiredOctavePackages = [

     

       17
       17
       +
           control

     

       18
       18
       +
         ];

     

       19
       19
       +
       

     

       20
       20
       +
         meta = with lib; {

     

       21
       21
       +
           homepage = "https://octave.sourceforge.io/signal/index.html";

     

       22
       22
       +
           license = licenses.gpl3Plus;

     

       23
       23
       +
           maintainers = with maintainers; [ KarlJoad ];

     

       24
       24
       +
           description = "Signal processing tools, including filtering, windowing and display functions";

     

       25
       25
       +
         };

     

       26
       26
       +
       }

+21

pkgs/development/octave-modules/sockets/default.nix

···

       1
       1
       +
       { buildOctavePackage

     

       2
       2
       +
       , lib

     

       3
       3
       +
       , fetchurl

     

       4
       4
       +
       }:

     

       5
       5
       +
       

     

       6
       6
       +
       buildOctavePackage rec {

     

       7
       7
       +
         pname = "sockets";

     

       8
       8
       +
         version = "1.2.1";

     

       9
       9
       +
       

     

       10
       10
       +
         src = fetchurl {

     

       11
       11
       +
           url = "mirror://sourceforge/octave/${pname}-${version}.tar.gz";

     

       12
       12
       +
           sha256 = "18f1zpqcf6h9b4fb0x2c5nvc3mvgj1141f1s8d9gnlhlrjlq8vqg";

     

       13
       13
       +
         };

     

       14
       14
       +
       

     

       15
       15
       +
         meta = with lib; {

     

       16
       16
       +
           homepage = "https://octave.sourceforge.io/sockets/index.html";

     

       17
       17
       +
           license = licenses.gpl3Plus;

     

       18
       18
       +
           maintainers = with maintainers; [ KarlJoad ];

     

       19
       19
       +
           description = "Socket functions for networking from within octave";

     

       20
       20
       +
         };

     

       21
       21
       +
       }

+28

pkgs/development/octave-modules/sparsersb/default.nix

···

       1
       1
       +
       { buildOctavePackage

     

       2
       2
       +
       , lib

     

       3
       3
       +
       , fetchurl

     

       4
       4
       +
       , librsb

     

       5
       5
       +
       }:

     

       6
       6
       +
       

     

       7
       7
       +
       buildOctavePackage rec {

     

       8
       8
       +
         pname = "sparsersb";

     

       9
       9
       +
         version = "1.0.8";

     

       10
       10
       +
       

     

       11
       11
       +
         src = fetchurl {

     

       12
       12
       +
           url = "mirror://sourceforge/octave/${pname}-${version}.tar.gz";

     

       13
       13
       +
           sha256 = "0nl7qppa1cm51188hqhbfswlih9hmy1yz7v0f5i07z0g0kbd62xw";

     

       14
       14
       +
         };

     

       15
       15
       +
       

     

       16
       16
       +
         buildInputs = [

     

       17
       17
       +
           librsb

     

       18
       18
       +
         ];

     

       19
       19
       +
       

     

       20
       20
       +
         meta = with lib; {

     

       21
       21
       +
           homepage = "https://octave.sourceforge.io/sparsersb/index.html";

     

       22
       22
       +
           license = licenses.gpl3Plus;

     

       23
       23
       +
           maintainers = with maintainers; [ KarlJoad ];

     

       24
       24
       +
           description = "Interface to the librsb package implementing the RSB sparse matrix format for fast shared-memory sparse matrix computations";

     

       25
       25
       +
           # Mark this way until KarlJoad builds librsb specifically for this package.

     

       26
       26
       +
           broken = true;

     

       27
       27
       +
         };

     

       28
       28
       +
       }

+21

pkgs/development/octave-modules/splines/default.nix

···

       1
       1
       +
       { buildOctavePackage

     

       2
       2
       +
       , lib

     

       3
       3
       +
       , fetchurl

     

       4
       4
       +
       }:

     

       5
       5
       +
       

     

       6
       6
       +
       buildOctavePackage rec {

     

       7
       7
       +
         pname = "splines";

     

       8
       8
       +
         version = "1.3.3";

     

       9
       9
       +
       

     

       10
       10
       +
         src = fetchurl {

     

       11
       11
       +
           url = "mirror://sourceforge/octave/${pname}-${version}.tar.gz";

     

       12
       12
       +
           sha256 = "16wisph8axc5xci0h51zj0y0x2wj6c9zybi2sjpb9v8z9dagjjqa";

     

       13
       13
       +
         };

     

       14
       14
       +
       

     

       15
       15
       +
         meta = with lib; {

     

       16
       16
       +
           homepage = "https://octave.sourceforge.io/splines/index.html";

     

       17
       17
       +
           license = with licenses; [ gpl3Plus publicDomain ];

     

       18
       18
       +
           maintainers = with maintainers; [ KarlJoad ];

     

       19
       19
       +
           description = "Additional spline functions";

     

       20
       20
       +
         };

     

       21
       21
       +
       }

+26

pkgs/development/octave-modules/statistics/default.nix

···

       1
       1
       +
       { buildOctavePackage

     

       2
       2
       +
       , lib

     

       3
       3
       +
       , fetchurl

     

       4
       4
       +
       , io

     

       5
       5
       +
       }:

     

       6
       6
       +
       

     

       7
       7
       +
       buildOctavePackage rec {

     

       8
       8
       +
         pname = "statistics";

     

       9
       9
       +
         version = "1.4.2";

     

       10
       10
       +
       

     

       11
       11
       +
         src = fetchurl {

     

       12
       12
       +
           url = "mirror://sourceforge/octave/${pname}-${version}.tar.gz";

     

       13
       13
       +
           sha256 = "0iv2hw3zp7h69n8ncfjfgm29xaihdl5gp2slcw1yf23mhd7q2xkr";

     

       14
       14
       +
         };

     

       15
       15
       +
       

     

       16
       16
       +
         requiredOctavePackages = [

     

       17
       17
       +
           io

     

       18
       18
       +
         ];

     

       19
       19
       +
       

     

       20
       20
       +
         meta = with lib; {

     

       21
       21
       +
           homepage = "https://octave.sourceforge.io/statistics/index.html";

     

       22
       22
       +
           license = with licenses; [ gpl3Plus publicDomain ];

     

       23
       23
       +
           maintainers = with maintainers; [ KarlJoad ];

     

       24
       24
       +
           description = "Additional statistics functions for Octave";

     

       25
       25
       +
         };

     

       26
       26
       +
       }

+32

pkgs/development/octave-modules/stk/default.nix

···

       1
       1
       +
       { buildOctavePackage

     

       2
       2
       +
       , lib

     

       3
       3
       +
       , fetchurl

     

       4
       4
       +
       }:

     

       5
       5
       +
       

     

       6
       6
       +
       buildOctavePackage rec {

     

       7
       7
       +
         pname = "stk";

     

       8
       8
       +
         version = "2.6.1";

     

       9
       9
       +
       

     

       10
       10
       +
         src = fetchurl {

     

       11
       11
       +
           url = "mirror://sourceforge/octave/${pname}-${version}.tar.gz";

     

       12
       12
       +
           sha256 = "1rqndfankwlwm4igw3xqpnrrl749zz1d5pjzh1qbfns7ixwrm19a";

     

       13
       13
       +
         };

     

       14
       14
       +
       

     

       15
       15
       +
         meta = with lib; {

     

       16
       16
       +
           homepage = "https://octave.sourceforge.io/stk/index.html";

     

       17
       17
       +
           license = licenses.gpl3Plus;

     

       18
       18
       +
           maintainers = with maintainers; [ KarlJoad ];

     

       19
       19
       +
           description = "STK is a (not so) Small Toolbox for Kriging";

     

       20
       20
       +
           longDescription = ''

     

       21
       21
       +
             The STK is a (not so) Small Toolbox for Kriging. Its primary focus is on

     

       22
       22
       +
             the interpolation/regression technique known as kriging, which is very

     

       23
       23
       +
             closely related to Splines and Radial Basis Functions, and can be

     

       24
       24
       +
             interpreted as a non-parametric Bayesian method using a Gaussian Process

     

       25
       25
       +
             (GP) prior. The STK also provides tools for the sequential and non-sequential

     

       26
       26
       +
             design of experiments. Even though it is, currently, mostly geared towards

     

       27
       27
       +
             the Design and Analysis of Computer Experiments (DACE), the STK can be

     

       28
       28
       +
             useful for other applications areas (such as Geostatistics, Machine

     

       29
       29
       +
             Learning, Non-parametric Regression, etc.).

     

       30
       30
       +
           '';

     

       31
       31
       +
         };

     

       32
       32
       +
       }

+37

pkgs/development/octave-modules/strings/default.nix

···

       1
       1
       +
       { buildOctavePackage

     

       2
       2
       +
       , lib

     

       3
       3
       +
       , fetchurl

     

       4
       4
       +
       , pcre

     

       5
       5
       +
       }:

     

       6
       6
       +
       

     

       7
       7
       +
       buildOctavePackage rec {

     

       8
       8
       +
         pname = "strings";

     

       9
       9
       +
         version = "1.2.0";

     

       10
       10
       +
       

     

       11
       11
       +
         src = fetchurl {

     

       12
       12
       +
           url = "mirror://sourceforge/octave/${pname}-${version}.tar.gz";

     

       13
       13
       +
           sha256 = "1b0ravfvq3bxd0w3axjfsx13mmmkifmqz6pfdgyf2s8vkqnp1qng";

     

       14
       14
       +
         };

     

       15
       15
       +
       

     

       16
       16
       +
         buildInputs = [

     

       17
       17
       +
           pcre

     

       18
       18
       +
         ];

     

       19
       19
       +
       

     

       20
       20
       +
         # The gripes library no longer exists.

     

       21
       21
       +
         # https://build.opensuse.org/package/view_file/openSUSE:Backports:SLE-15-SP3/octave-forge-strings/octave-forge-strings.spec

     

       22
       22
       +
         # toascii is a deprecated function. Has been fixed in recent commits, but has

     

       23
       23
       +
         # not been released yet.

     

       24
       24
       +
         # https://sourceforge.net/p/octave/strings/ci/2db1dbb75557eef94605cb4ac682783ab78ac8d8/

     

       25
       25
       +
         patchPhase = ''

     

       26
       26
       +
           sed -i -s -e 's/gripes.h/errwarn.h/' -e 's/gripe_/err_/g' src/*.cc

     

       27
       27
       +
           sed -i s/toascii/double/g inst/*.m

     

       28
       28
       +
         '';

     

       29
       29
       +
       

     

       30
       30
       +
         meta = with lib; {

     

       31
       31
       +
           homepage = "https://octave.sourceforge.io/strings/index.html";

     

       32
       32
       +
           license = licenses.gpl3Plus;

     

       33
       33
       +
           # Claims to have a freebsd license, but I found none.

     

       34
       34
       +
           maintainers = with maintainers; [ KarlJoad ];

     

       35
       35
       +
           description = "Additional functions for manipulation and analysis of strings";

     

       36
       36
       +
         };

     

       37
       37
       +
       }

+21

pkgs/development/octave-modules/struct/default.nix

···

       1
       1
       +
       { buildOctavePackage

     

       2
       2
       +
       , lib

     

       3
       3
       +
       , fetchurl

     

       4
       4
       +
       }:

     

       5
       5
       +
       

     

       6
       6
       +
       buildOctavePackage rec {

     

       7
       7
       +
         pname = "struct";

     

       8
       8
       +
         version = "1.0.16";

     

       9
       9
       +
       

     

       10
       10
       +
         src = fetchurl {

     

       11
       11
       +
           url = "mirror://sourceforge/octave/${pname}-${version}.tar.gz";

     

       12
       12
       +
           sha256 = "0gx20r126f0ccl4yflp823xi77p8fh4acx1fv0mmcsglmx4c4vgm";

     

       13
       13
       +
         };

     

       14
       14
       +
       

     

       15
       15
       +
         meta = with lib; {

     

       16
       16
       +
           homepage = "https://octave.sourceforge.io/struct/index.html";

     

       17
       17
       +
           license = licenses.gpl3Plus;

     

       18
       18
       +
           maintainers = with maintainers; [ KarlJoad ];

     

       19
       19
       +
           description = "Additional structure manipulation functions";

     

       20
       20
       +
         };

     

       21
       21
       +
       }

+46

pkgs/development/octave-modules/symbolic/default.nix

···

       1
       1
       +
       { buildOctavePackage

     

       2
       2
       +
       , lib

     

       3
       3
       +
       , fetchurl

     

       4
       4
       +
       # Octave's Python (Python 3)

     

       5
       5
       +
       , python

     

       6
       6
       +
       # Needed only to get the correct version of sympy needed

     

       7
       7
       +
       , python2Packages

     

       8
       8
       +
       }:

     

       9
       9
       +
       

     

       10
       10
       +
       let

     

       11
       11
       +
         # Need to use sympy 1.5.1 for https://github.com/cbm755/octsympy/issues/1023

     

       12
       12
       +
         # It has been addressed, but not merged yet.

     

       13
       13
       +
         # In the meantime, we create a Python environment with Python 3, its mpmath

     

       14
       14
       +
         # version and sympy 1.5 from python2Packages.

     

       15
       15
       +
         pythonEnv = (let

     

       16
       16
       +
             overridenPython = let

     

       17
       17
       +
               packageOverrides = self: super: {

     

       18
       18
       +
                 sympy = super.sympy.overridePythonAttrs (old: rec {

     

       19
       19
       +
                   version = python2Packages.sympy.version;

     

       20
       20
       +
                   src = python2Packages.sympy.src;

     

       21
       21
       +
                 });

     

       22
       22
       +
               };

     

       23
       23
       +
             in python.override {inherit packageOverrides; self = overridenPython; };

     

       24
       24
       +
           in overridenPython.withPackages (ps: [

     

       25
       25
       +
             ps.sympy

     

       26
       26
       +
             ps.mpmath

     

       27
       27
       +
           ]));

     

       28
       28
       +
       

     

       29
       29
       +
       in buildOctavePackage rec {

     

       30
       30
       +
         pname = "symbolic";

     

       31
       31
       +
         version = "2.9.0";

     

       32
       32
       +
       

     

       33
       33
       +
         src = fetchurl {

     

       34
       34
       +
           url = "mirror://sourceforge/octave/${pname}-${version}.tar.gz";

     

       35
       35
       +
           sha256 = "1jr3kg9q6r4r4h3hiwq9fli6wsns73rqfzkrg25plha9195c97h8";

     

       36
       36
       +
         };

     

       37
       37
       +
       

     

       38
       38
       +
         propagatedBuildInputs = [ pythonEnv ];

     

       39
       39
       +
       

     

       40
       40
       +
         meta = with lib; {

     

       41
       41
       +
           homepage = "https://octave.sourceforge.io/symbolic/index.html";

     

       42
       42
       +
           license = licenses.gpl3Plus;

     

       43
       43
       +
           maintainers = with maintainers; [ KarlJoad ];

     

       44
       44
       +
           description = "Adds symbolic calculation features to GNU Octave";

     

       45
       45
       +
         };

     

       46
       46
       +
       }

+33

pkgs/development/octave-modules/tisean/default.nix

···

       1
       1
       +
       { buildOctavePackage

     

       2
       2
       +
       , lib

     

       3
       3
       +
       , fetchurl

     

       4
       4
       +
       # Octave dependencies

     

       5
       5
       +
       , signal # >= 1.3.0

     

       6
       6
       +
       # Build dependencies

     

       7
       7
       +
       , gfortran

     

       8
       8
       +
       }:

     

       9
       9
       +
       

     

       10
       10
       +
       buildOctavePackage rec {

     

       11
       11
       +
         pname = "tisean";

     

       12
       12
       +
         version = "0.2.3";

     

       13
       13
       +
       

     

       14
       14
       +
         src = fetchurl {

     

       15
       15
       +
           url = "mirror://sourceforge/octave/${pname}-${version}.tar.gz";

     

       16
       16
       +
           sha256 = "0nc2d9h91glxzmpizxdrc2dablw4bqhqhzs37a394c36myk4xjdv";

     

       17
       17
       +
         };

     

       18
       18
       +
       

     

       19
       19
       +
         nativeBuildInputs = [

     

       20
       20
       +
           gfortran

     

       21
       21
       +
         ];

     

       22
       22
       +
       

     

       23
       23
       +
         requiredOctavePackages = [

     

       24
       24
       +
           signal

     

       25
       25
       +
         ];

     

       26
       26
       +
       

     

       27
       27
       +
         meta = with lib; {

     

       28
       28
       +
           homepage = "https://octave.sourceforge.io/tisean/index.html";

     

       29
       29
       +
           license = licenses.gpl3Plus;

     

       30
       30
       +
           maintainers = with maintainers; [ KarlJoad ];

     

       31
       31
       +
           description = "Port of TISEAN 3.0.1";

     

       32
       32
       +
         };

     

       33
       33
       +
       }

+26

pkgs/development/octave-modules/tsa/default.nix

···

       1
       1
       +
       { buildOctavePackage

     

       2
       2
       +
       , lib

     

       3
       3
       +
       , fetchurl

     

       4
       4
       +
       , nan # > 3.0.0

     

       5
       5
       +
       }:

     

       6
       6
       +
       

     

       7
       7
       +
       buildOctavePackage rec {

     

       8
       8
       +
         pname = "tsa";

     

       9
       9
       +
         version = "4.6.2";

     

       10
       10
       +
       

     

       11
       11
       +
         src = fetchurl {

     

       12
       12
       +
           url = "mirror://sourceforge/octave/${pname}-${version}.tar.gz";

     

       13
       13
       +
           sha256 = "0p2cjszzjwhp4ih3q3r67qnikgxc0fwxc12p3727jbdvzq2h10mn";

     

       14
       14
       +
         };

     

       15
       15
       +
       

     

       16
       16
       +
         requiredOctavePackages = [

     

       17
       17
       +
           nan

     

       18
       18
       +
         ];

     

       19
       19
       +
       

     

       20
       20
       +
         meta = with lib; {

     

       21
       21
       +
           homepage = "https://octave.sourceforge.io/tsa/index.html";

     

       22
       22
       +
           license = licenses.gpl3Plus;

     

       23
       23
       +
           maintainers = with maintainers; [ KarlJoad ];

     

       24
       24
       +
           description = "Stochastic concepts and maximum entropy methods for time series analysis";

     

       25
       25
       +
         };

     

       26
       26
       +
       }

+39

pkgs/development/octave-modules/vibes/default.nix

···

       1
       1
       +
       { buildOctavePackage

     

       2
       2
       +
       , lib

     

       3
       3
       +
       , fetchurl

     

       4
       4
       +
       , vibes

     

       5
       5
       +
       }:

     

       6
       6
       +
       

     

       7
       7
       +
       buildOctavePackage rec {

     

       8
       8
       +
         pname = "vibes";

     

       9
       9
       +
         version = "0.2.0";

     

       10
       10
       +
       

     

       11
       11
       +
         src = fetchurl {

     

       12
       12
       +
           url = "mirror://sourceforge/octave/${pname}-${version}.tar.gz";

     

       13
       13
       +
           sha256 = "1zn86rcsjkqg67hphz5inxc5xkgr18sby8za68zhppc2z7pd91ng";

     

       14
       14
       +
         };

     

       15
       15
       +
       

     

       16
       16
       +
         buildInputs = [

     

       17
       17
       +
           vibes

     

       18
       18
       +
         ];

     

       19
       19
       +
       

     

       20
       20
       +
         meta = with lib; {

     

       21
       21
       +
           homepage = "https://octave.sourceforge.io/vibes/index.html";

     

       22
       22
       +
           license = with licenses; [ gpl3Plus mit ];

     

       23
       23
       +
           maintainers = with maintainers; [ KarlJoad ];

     

       24
       24
       +
           description = "Easily display results (boxes, pavings) from interval methods";

     

       25
       25
       +
           longDescription = ''

     

       26
       26
       +
             The VIBes API allows one to easily display results (boxes, pavings) from

     

       27
       27
       +
             interval methods. VIBes consists in two parts: (1) the VIBes application

     

       28
       28
       +
             that features viewing, annotating and exporting figures, and (2) the

     

       29
       29
       +
             VIBes API that enables your program to communicate with the viewer in order

     

       30
       30
       +
             to draw figures. This package integrates the VIBes API into Octave. The

     

       31
       31
       +
             VIBes application is required for operation and must be installed

     

       32
       32
       +
             seperately. Data types from third-party interval arithmetic libraries for

     

       33
       33
       +
             Octave are also supported.

     

       34
       34
       +
           '';

     

       35
       35
       +
           # Marked this way until KarlJoad gets around to packaging the vibes program.

     

       36
       36
       +
           # https://github.com/ENSTABretagneRobotics/VIBES

     

       37
       37
       +
           broken = true;

     

       38
       38
       +
         };

     

       39
       39
       +
       }

+31

pkgs/development/octave-modules/video/default.nix

···

       1
       1
       +
       { buildOctavePackage

     

       2
       2
       +
       , lib

     

       3
       3
       +
       , fetchurl

     

       4
       4
       +
       , pkg-config

     

       5
       5
       +
       , ffmpeg

     

       6
       6
       +
       }:

     

       7
       7
       +
       

     

       8
       8
       +
       buildOctavePackage rec {

     

       9
       9
       +
         pname = "video";

     

       10
       10
       +
         version = "2.0.0";

     

       11
       11
       +
       

     

       12
       12
       +
         src = fetchurl {

     

       13
       13
       +
           url = "mirror://sourceforge/octave/${pname}-${version}.tar.gz";

     

       14
       14
       +
           sha256 = "0s6j3c4dh5nsbh84s7vnd2ajcayy1gn07b4fcyrcynch3wl28mrv";

     

       15
       15
       +
         };

     

       16
       16
       +
       

     

       17
       17
       +
         nativeBuildInputs = [

     

       18
       18
       +
           pkg-config

     

       19
       19
       +
         ];

     

       20
       20
       +
       

     

       21
       21
       +
         propagatedBuildInputs = [

     

       22
       22
       +
           ffmpeg

     

       23
       23
       +
         ];

     

       24
       24
       +
       

     

       25
       25
       +
         meta = with lib; {

     

       26
       26
       +
           homepage = "https://octave.sourceforge.io/video/index.html";

     

       27
       27
       +
           license = with licenses; [ gpl3Plus bsd3 ];

     

       28
       28
       +
           maintainers = with maintainers; [ KarlJoad ];

     

       29
       29
       +
           description = "Wrapper for OpenCV's CvCapture_FFMPEG and CvVideoWriter_FFMPEG";

     

       30
       30
       +
         };

     

       31
       31
       +
       }

+41

pkgs/development/octave-modules/vrml/default.nix

···

       1
       1
       +
       { buildOctavePackage

     

       2
       2
       +
       , lib

     

       3
       3
       +
       , fetchurl

     

       4
       4
       +
       # Octave dependencies

     

       5
       5
       +
       , linear-algebra

     

       6
       6
       +
       , miscellaneous

     

       7
       7
       +
       , struct

     

       8
       8
       +
       , statistics

     

       9
       9
       +
       # Runtime dependencies

     

       10
       10
       +
       , freewrl

     

       11
       11
       +
       }:

     

       12
       12
       +
       

     

       13
       13
       +
       buildOctavePackage rec {

     

       14
       14
       +
         pname = "vrml";

     

       15
       15
       +
         version = "1.0.13";

     

       16
       16
       +
       

     

       17
       17
       +
         src = fetchurl {

     

       18
       18
       +
           url = "mirror://sourceforge/octave/${pname}-${version}.tar.gz";

     

       19
       19
       +
           sha256 = "1mx93k150agd27mbzvds13v9z0x36j68hwpdvlvjmcl2fga5fly4";

     

       20
       20
       +
         };

     

       21
       21
       +
       

     

       22
       22
       +
         propagatedBuildInputs = [

     

       23
       23
       +
           freewrl

     

       24
       24
       +
         ];

     

       25
       25
       +
       

     

       26
       26
       +
         requiredOctavePackages = [

     

       27
       27
       +
           linear-algebra

     

       28
       28
       +
           miscellaneous

     

       29
       29
       +
           struct

     

       30
       30
       +
           statistics

     

       31
       31
       +
         ];

     

       32
       32
       +
       

     

       33
       33
       +
         meta = with lib; {

     

       34
       34
       +
           homepage = "https://octave.sourceforge.io/vrml/index.html";

     

       35
       35
       +
           license = with licenses; [ gpl3Plus fdl12Plus ];

     

       36
       36
       +
           maintainers = with maintainers; [ KarlJoad ];

     

       37
       37
       +
           description = "3D graphics using VRML";

     

       38
       38
       +
           # Marked this way until KarlJoad gets freewrl as a runtime dependency.

     

       39
       39
       +
           broken = true;

     

       40
       40
       +
         };

     

       41
       41
       +
       }

+21

pkgs/development/octave-modules/windows/default.nix

···

       1
       1
       +
       { buildOctavePackage

     

       2
       2
       +
       , lib

     

       3
       3
       +
       , fetchurl

     

       4
       4
       +
       }:

     

       5
       5
       +
       

     

       6
       6
       +
       buildOctavePackage rec {

     

       7
       7
       +
         pname = "windows";

     

       8
       8
       +
         version = "1.5.0";

     

       9
       9
       +
       

     

       10
       10
       +
         src = fetchurl {

     

       11
       11
       +
           url = "mirror://sourceforge/octave/${pname}-${version}.tar.gz";

     

       12
       12
       +
           sha256 = "05bsf3q816b9vwgmjdm761ybhmk8raq6dzxqvd11brma0granx3a";

     

       13
       13
       +
         };

     

       14
       14
       +
       

     

       15
       15
       +
         meta = with lib; {

     

       16
       16
       +
           homepage = "https://octave.sourceforge.io/windows/index.html";

     

       17
       17
       +
           license = licenses.gpl3Plus;

     

       18
       18
       +
           maintainers = with maintainers; [ KarlJoad ];

     

       19
       19
       +
           description = "Provides COM interface and additional functionality on Windows";

     

       20
       20
       +
         };

     

       21
       21
       +
       }

+26

pkgs/development/octave-modules/zeromq/default.nix

···

       1
       1
       +
       { buildOctavePackage

     

       2
       2
       +
       , lib

     

       3
       3
       +
       , fetchurl

     

       4
       4
       +
       , zeromq

     

       5
       5
       +
       }:

     

       6
       6
       +
       

     

       7
       7
       +
       buildOctavePackage rec {

     

       8
       8
       +
         pname = "zeromq";

     

       9
       9
       +
         version = "1.5.2";

     

       10
       10
       +
       

     

       11
       11
       +
         src = fetchurl {

     

       12
       12
       +
           url = "mirror://sourceforge/octave/${pname}-${version}.tar.gz";

     

       13
       13
       +
           sha256 = "18h1039ri7dr37jv20cvj5vhw7b57frrda0hhbvlgixinbqmn9j7";

     

       14
       14
       +
         };

     

       15
       15
       +
       

     

       16
       16
       +
         propagatedBuildInputs = [

     

       17
       17
       +
           zeromq

     

       18
       18
       +
         ];

     

       19
       19
       +
       

     

       20
       20
       +
         meta = with lib; {

     

       21
       21
       +
           homepage = "https://octave.sourceforge.io/zeromq/index.html";

     

       22
       22
       +
           license = licenses.gpl3Plus;

     

       23
       23
       +
           maintainers = with maintainers; [ KarlJoad ];

     

       24
       24
       +
           description = "ZeroMQ bindings for GNU Octave";

     

       25
       25
       +
         };

     

       26
       26
       +
       }

+2

pkgs/top-level/all-packages.nix

···

       11353
       11353
        
           overridePlatforms = ["x86_64-linux" "x86_64-darwin"];

     

       11354
       11354
        
         };

     

       11355
       11355
        
       

     

       11356
       11356
       +
         octavePackages = recurseIntoAttrs octave.pkgs;

     

       11357
       11357
       +
       

     

       11356
       11358
        
         ocropus = callPackage ../applications/misc/ocropus { };

     

       11357
       11359
        
       

     

       11358
       11360
        
         pachyderm = callPackage ../applications/networking/cluster/pachyderm { };

+224

pkgs/top-level/octave-packages.nix

···

       1
       1
       +
       # This file contains the GNU Octave add-on packages set.

     

       2
       2
       +
       # Each attribute is an Octave library.

     

       3
       3
       +
       # Expressions for the Octave libraries are supposed to be in `pkgs/development/octave-modules/<name>/default.nix`.

     

       4
       4
       +
       

     

       5
       5
       +
       # When contributing a new package, if that package has a dependency on another

     

       6
       6
       +
       # octave package, then you DO NOT need to explicitly list it as such when

     

       7
       7
       +
       # performing the callPackage. It will be passed implicitly.

     

       8
       8
       +
       # In addition, try to use the same dependencies as the ones octave needs, which

     

       9
       9
       +
       # should ensure greater compatibility between Octave itself and its packages.

     

       10
       10
       +
       

     

       11
       11
       +
       # Like python-packages.nix, packages from top-level.nix are not in the scope

     

       12
       12
       +
       # of the `callPackage` used for packages here. So, when we do need packages

     

       13
       13
       +
       # from outside, we can `inherit` them from `pkgs`.

     

       14
       14
       +
       { pkgs

     

       15
       15
       +
       , lib

     

       16
       16
       +
       , stdenv

     

       17
       17
       +
       , fetchurl

     

       18
       18
       +
       , newScope

     

       19
       19
       +
       , octave

     

       20
       20
       +
       }:

     

       21
       21
       +
       

     

       22
       22
       +
       with lib;

     

       23
       23
       +
       

     

       24
       24
       +
       makeScope newScope (self:

     

       25
       25
       +
         let

     

       26
       26
       +
           inherit (octave) blas lapack gfortran python texinfo gnuplot;

     

       27
       27
       +
       

     

       28
       28
       +
           callPackage = self.callPackage;

     

       29
       29
       +
       

     

       30
       30
       +
           buildOctavePackage = callPackage ../development/interpreters/octave/build-octave-package.nix {

     

       31
       31
       +
             inherit lib stdenv;

     

       32
       32
       +
             inherit octave;

     

       33
       33
       +
             inherit computeRequiredOctavePackages;

     

       34
       34
       +
           };

     

       35
       35
       +
       

     

       36
       36
       +
           wrapOctave = callPackage ../development/interpreters/octave/wrap-octave.nix {

     

       37
       37
       +
             inherit octave;

     

       38
       38
       +
             inherit (pkgs) makeSetupHook makeWrapper;

     

       39
       39
       +
           };

     

       40
       40
       +
       

     

       41
       41
       +
           # Given a list of required Octave package derivations, get a list of

     

       42
       42
       +
           # ALL required Octave packages needed for the ones specified to run.

     

       43
       43
       +
           computeRequiredOctavePackages = drvs: let

     

       44
       44
       +
             # Check whether a derivation is an octave package

     

       45
       45
       +
             hasOctavePackage = drv: drv?isOctavePackage;

     

       46
       46
       +
             packages = filter hasOctavePackage drvs;

     

       47
       47
       +
           in unique (packages ++ concatLists (catAttrs "requiredOctavePackages" packages));

     

       48
       48
       +
       

     

       49
       49
       +
         in {

     

       50
       50
       +
       

     

       51
       51
       +
           inherit callPackage buildOctavePackage computeRequiredOctavePackages;

     

       52
       52
       +
       

     

       53
       53
       +
           inherit (callPackage ../development/interpreters/octave/hooks { })

     

       54
       54
       +
             writeRequiredOctavePackagesHook;

     

       55
       55
       +
       

     

       56
       56
       +
           arduino = callPackage ../development/octave-modules/arduino {

     

       57
       57
       +
             inherit (pkgs) arduino;

     

       58
       58
       +
           };

     

       59
       59
       +
       

     

       60
       60
       +
           audio = callPackage ../development/octave-modules/audio { };

     

       61
       61
       +
       

     

       62
       62
       +
           bim = callPackage ../development/octave-modules/bim { };

     

       63
       63
       +
       

     

       64
       64
       +
           bsltl = callPackage ../development/octave-modules/bsltl { };

     

       65
       65
       +
       

     

       66
       66
       +
           cgi = callPackage ../development/octave-modules/cgi { };

     

       67
       67
       +
       

     

       68
       68
       +
           communications = callPackage ../development/octave-modules/communications { };

     

       69
       69
       +
       

     

       70
       70
       +
           control = callPackage ../development/octave-modules/control { };

     

       71
       71
       +
       

     

       72
       72
       +
           data-smoothing = callPackage ../development/octave-modules/data-smoothing { };

     

       73
       73
       +
       

     

       74
       74
       +
           database = callPackage ../development/octave-modules/database { };

     

       75
       75
       +
       

     

       76
       76
       +
           dataframe = callPackage ../development/octave-modules/dataframe { };

     

       77
       77
       +
       

     

       78
       78
       +
           dicom = callPackage ../development/octave-modules/dicom { };

     

       79
       79
       +
       

     

       80
       80
       +
           divand = callPackage ../development/octave-modules/divand { };

     

       81
       81
       +
       

     

       82
       82
       +
           doctest = callPackage ../development/octave-modules/doctest { };

     

       83
       83
       +
       

     

       84
       84
       +
           econometrics = callPackage ../development/octave-modules/econometrics { };

     

       85
       85
       +
       

     

       86
       86
       +
           fem-fenics = callPackage ../development/octave-modules/fem-fenics {

     

       87
       87
       +
             # PLACEHOLDER until KarlJoad gets dolfin packaged.

     

       88
       88
       +
             dolfin = null;

     

       89
       89
       +
             ffc = null;

     

       90
       90
       +
           };

     

       91
       91
       +
       

     

       92
       92
       +
           fits = callPackage ../development/octave-modules/fits { };

     

       93
       93
       +
       

     

       94
       94
       +
           financial = callPackage ../development/octave-modules/financial { };

     

       95
       95
       +
       

     

       96
       96
       +
           fpl = callPackage ../development/octave-modules/fpl { };

     

       97
       97
       +
       

     

       98
       98
       +
           fuzzy-logic-toolkit = callPackage ../development/octave-modules/fuzzy-logic-toolkit { };

     

       99
       99
       +
       

     

       100
       100
       +
           ga = callPackage ../development/octave-modules/ga { };

     

       101
       101
       +
       

     

       102
       102
       +
           general = callPackage ../development/octave-modules/general {

     

       103
       103
       +
             nettle = pkgs.nettle;

     

       104
       104
       +
           };

     

       105
       105
       +
       

     

       106
       106
       +
           generate_html = callPackage ../development/octave-modules/generate_html { };

     

       107
       107
       +
       

     

       108
       108
       +
           geometry = callPackage ../development/octave-modules/geometry { };

     

       109
       109
       +
       

     

       110
       110
       +
           gsl = callPackage ../development/octave-modules/gsl {

     

       111
       111
       +
             inherit (pkgs) gsl;

     

       112
       112
       +
           };

     

       113
       113
       +
       

     

       114
       114
       +
           image = callPackage ../development/octave-modules/image { };

     

       115
       115
       +
       

     

       116
       116
       +
           image-acquisition = callPackage ../development/octave-modules/image-acquisition { };

     

       117
       117
       +
       

     

       118
       118
       +
           instrument-control = callPackage ../development/octave-modules/instrument-control { };

     

       119
       119
       +
       

     

       120
       120
       +
           io = callPackage ../development/octave-modules/io {

     

       121
       121
       +
             inherit (octave) enableJava;

     

       122
       122
       +
           };

     

       123
       123
       +
       

     

       124
       124
       +
           interval = callPackage ../development/octave-modules/interval { };

     

       125
       125
       +
       

     

       126
       126
       +
           level-set = callPackage ../development/octave-modules/level-set { };

     

       127
       127
       +
       

     

       128
       128
       +
           linear-algebra = callPackage ../development/octave-modules/linear-algebra { };

     

       129
       129
       +
       

     

       130
       130
       +
           lssa = callPackage ../development/octave-modules/lssa { };

     

       131
       131
       +
       

     

       132
       132
       +
           ltfat = callPackage ../development/octave-modules/ltfat {

     

       133
       133
       +
             inherit (octave) fftw fftwSinglePrec portaudio jdk;

     

       134
       134
       +
             inherit (pkgs) fftwFloat fftwLongDouble;

     

       135
       135
       +
           };

     

       136
       136
       +
       

     

       137
       137
       +
           mapping = callPackage ../development/octave-modules/mapping { };

     

       138
       138
       +
       

     

       139
       139
       +
           matgeom = callPackage ../development/octave-modules/matgeom { };

     

       140
       140
       +
       

     

       141
       141
       +
           miscellaneous = callPackage ../development/octave-modules/miscellaneous { };

     

       142
       142
       +
       

     

       143
       143
       +
           msh = callPackage ../development/octave-modules/msh {

     

       144
       144
       +
             # PLACEHOLDER until KarlJoad gets dolfin packaged.

     

       145
       145
       +
             dolfin = null;

     

       146
       146
       +
           };

     

       147
       147
       +
       

     

       148
       148
       +
           mvn = callPackage ../development/octave-modules/mvn { };

     

       149
       149
       +
       

     

       150
       150
       +
           nan = callPackage ../development/octave-modules/nan { };

     

       151
       151
       +
       

     

       152
       152
       +
           ncarray = callPackage ../development/octave-modules/ncarray { };

     

       153
       153
       +
       

     

       154
       154
       +
           netcdf = callPackage ../development/octave-modules/netcdf {

     

       155
       155
       +
             inherit (pkgs) netcdf;

     

       156
       156
       +
           };

     

       157
       157
       +
       

     

       158
       158
       +
           nurbs = callPackage ../development/octave-modules/nurbs { };

     

       159
       159
       +
       

     

       160
       160
       +
           ocl = callPackage ../development/octave-modules/ocl { };

     

       161
       161
       +
       

     

       162
       162
       +
           octclip = callPackage ../development/octave-modules/octclip { };

     

       163
       163
       +
       

     

       164
       164
       +
           octproj = callPackage ../development/octave-modules/octproj { };

     

       165
       165
       +
       

     

       166
       166
       +
           optics = callPackage ../development/octave-modules/optics { };

     

       167
       167
       +
       

     

       168
       168
       +
           optim = callPackage ../development/octave-modules/optim { };

     

       169
       169
       +
       

     

       170
       170
       +
           optiminterp = callPackage ../development/octave-modules/optiminterp { };

     

       171
       171
       +
       

     

       172
       172
       +
           parallel = callPackage ../development/octave-modules/parallel { };

     

       173
       173
       +
       

     

       174
       174
       +
           quaternion = callPackage ../development/octave-modules/quaternion { };

     

       175
       175
       +
       

     

       176
       176
       +
           queueing = callPackage ../development/octave-modules/queueing { };

     

       177
       177
       +
       

     

       178
       178
       +
           signal = callPackage ../development/octave-modules/signal { };

     

       179
       179
       +
       

     

       180
       180
       +
           sockets = callPackage ../development/octave-modules/sockets { };

     

       181
       181
       +
       

     

       182
       182
       +
           sparsersb = callPackage ../development/octave-modules/sparsersb {

     

       183
       183
       +
             librsb = null;

     

       184
       184
       +
             # TODO: Package the librsb library to build this package.

     

       185
       185
       +
             # http://librsb.sourceforge.net/

     

       186
       186
       +
           };

     

       187
       187
       +
       

     

       188
       188
       +
           stk = callPackage ../development/octave-modules/stk { };

     

       189
       189
       +
       

     

       190
       190
       +
           splines = callPackage ../development/octave-modules/splines { };

     

       191
       191
       +
       

     

       192
       192
       +
           statistics = callPackage ../development/octave-modules/statistics { };

     

       193
       193
       +
       

     

       194
       194
       +
           strings = callPackage ../development/octave-modules/strings { };

     

       195
       195
       +
       

     

       196
       196
       +
           struct = callPackage ../development/octave-modules/struct { };

     

       197
       197
       +
       

     

       198
       198
       +
           symbolic = callPackage ../development/octave-modules/symbolic {

     

       199
       199
       +
             inherit (octave) python;

     

       200
       200
       +
           };

     

       201
       201
       +
       

     

       202
       202
       +
           tisean = callPackage ../development/octave-modules/tisean { };

     

       203
       203
       +
       

     

       204
       204
       +
           tsa = callPackage ../development/octave-modules/tsa { };

     

       205
       205
       +
       

     

       206
       206
       +
           vibes = callPackage ../development/octave-modules/vibes {

     

       207
       207
       +
             vibes = null;

     

       208
       208
       +
             # TODO: Need to package vibes:

     

       209
       209
       +
             # https://github.com/ENSTABretagneRobotics/VIBES

     

       210
       210
       +
           };

     

       211
       211
       +
       

     

       212
       212
       +
           video = callPackage ../development/octave-modules/video { };

     

       213
       213
       +
       

     

       214
       214
       +
           vrml = callPackage ../development/octave-modules/vrml {

     

       215
       215
       +
             freewrl = null;

     

       216
       216
       +
           };

     

       217
       217
       +
       

     

       218
       218
       +
           windows = callPackage ../development/octave-modules/windows { };

     

       219
       219
       +
       

     

       220
       220
       +
           zeromq = callPackage ../development/octave-modules/zeromq {

     

       221
       221
       +
             inherit (pkgs) zeromq;

     

       222
       222
       +
           };

     

       223
       223
       +
       

     

       224
       224
       +
         })