| 1 | ;;; GNU Guix --- Functional package management for GNU |
| 2 | ;;; Copyright © 2020, 2021 Nicolò Balzarotti <nicolo@nixo.xyz> |
| 3 | ;;; Copyright © 2021, 2022 Simon Tournier <zimon.toutoune@gmail.com> |
| 4 | ;;; Copyright © 2021, 2022 Efraim Flashner <efraim@flashner.co.il> |
| 5 | ;;; Copyright © 2021 Vinicius Monego <monego@posteo.net> |
| 6 | ;;; Copyright © 2021 jgart <jgart@dismail.de> |
| 7 | ;;; |
| 8 | ;;; This file is part of GNU Guix. |
| 9 | ;;; |
| 10 | ;;; GNU Guix is free software; you can redistribute it and/or modify it |
| 11 | ;;; under the terms of the GNU General Public License as published by |
| 12 | ;;; the Free Software Foundation; either version 3 of the License, or (at |
| 13 | ;;; your option) any later version. |
| 14 | ;;; |
| 15 | ;;; GNU Guix is distributed in the hope that it will be useful, but |
| 16 | ;;; WITHOUT ANY WARRANTY; without even the implied warranty of |
| 17 | ;;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
| 18 | ;;; GNU General Public License for more details. |
| 19 | ;;; |
| 20 | ;;; You should have received a copy of the GNU General Public License |
| 21 | ;;; along with GNU Guix. If not, see <http://www.gnu.org/licenses/>. |
| 22 | |
| 23 | (define-module (gnu packages julia-xyz) |
| 24 | #:use-module ((guix licenses) #:prefix license:) |
| 25 | #:use-module (gnu packages) |
| 26 | #:use-module (guix gexp) |
| 27 | #:use-module (guix utils) |
| 28 | #:use-module (guix packages) |
| 29 | #:use-module (guix git-download) |
| 30 | #:use-module (guix build-system julia) |
| 31 | #:use-module (gnu packages gcc) |
| 32 | #:use-module (gnu packages julia-jll) |
| 33 | #:use-module (gnu packages python) |
| 34 | #:use-module (gnu packages python-xyz) |
| 35 | #:use-module (gnu packages version-control)) |
| 36 | |
| 37 | (define-public julia-abstractffts |
| 38 | (package |
| 39 | (name "julia-abstractffts") |
| 40 | (version "1.0.1") |
| 41 | (source |
| 42 | (origin |
| 43 | (method git-fetch) |
| 44 | (uri (git-reference |
| 45 | (url "https://github.com/JuliaMath/AbstractFFTS.jl") |
| 46 | (commit (string-append "v" version)))) |
| 47 | (file-name (git-file-name name version)) |
| 48 | (sha256 |
| 49 | (base32 "0083pwdyxjb04i330ir9pc8kmp4bwk59lx1jgc9qi05y8j7xzbp0")))) |
| 50 | (build-system julia-build-system) |
| 51 | (inputs ;required for tests |
| 52 | (list julia-unitful)) |
| 53 | (home-page "https://github.com/JuliaGPU/Adapt.jl") |
| 54 | (synopsis "General framework for fast Fourier transforms (FFTs)") |
| 55 | (description "This package allows multiple FFT packages to co-exist with |
| 56 | the same underlying @code{fft(x)} and @code{plan_fft(x)} interface. It is |
| 57 | mainly not intended to be used directly. Instead, developers of packages that |
| 58 | implement FFTs (such as @code{FFTW.jl} or @code{FastTransforms.jl}) extend the |
| 59 | types/functions defined in AbstractFFTs.") |
| 60 | (license license:expat))) |
| 61 | |
| 62 | (define-public julia-abstracttrees |
| 63 | (package |
| 64 | (name "julia-abstracttrees") |
| 65 | (version "0.3.4") |
| 66 | (source |
| 67 | (origin |
| 68 | (method git-fetch) |
| 69 | (uri (git-reference |
| 70 | (url "https://github.com/JuliaCollections/AbstractTrees.jl") |
| 71 | (commit (string-append "v" version)))) |
| 72 | (file-name (git-file-name name version)) |
| 73 | (sha256 |
| 74 | (base32 "16is5n2qa69cci34vfazxsa7ik6q0hbnnqrbrhkq8frh142f1xs8")))) |
| 75 | (build-system julia-build-system) |
| 76 | (home-page "https://juliacollections.github.io/AbstractTrees.jl/stable/") |
| 77 | (synopsis "Abstract Julia interfaces for working with trees") |
| 78 | (description "This Julia package provides several utilities for working |
| 79 | with tree-like data structures. Most importantly, it defines the |
| 80 | @code{children} method that any package that contains such a data structure |
| 81 | may import and extend in order to take advantage of any generic tree algorithm |
| 82 | in this package.") |
| 83 | (license license:expat))) |
| 84 | |
| 85 | (define-public julia-adapt |
| 86 | (package |
| 87 | (name "julia-adapt") |
| 88 | (version "3.3.1") |
| 89 | (source |
| 90 | (origin |
| 91 | (method git-fetch) |
| 92 | (uri (git-reference |
| 93 | (url "https://github.com/JuliaGPU/Adapt.jl") |
| 94 | (commit (string-append "v" version)))) |
| 95 | (file-name (git-file-name name version)) |
| 96 | (sha256 |
| 97 | (base32 "009fj59fzhvfsyw35kakllsh36k3xlwyzq8qa5f5k598i3pq14i7")))) |
| 98 | (build-system julia-build-system) |
| 99 | (home-page "https://github.com/JuliaGPU/Adapt.jl") |
| 100 | (synopsis "Package providing the @code{adapt} function, similar to @code{convert}") |
| 101 | (description "This Julia package provides the @code{adapt(T, x)} function |
| 102 | acts like @code{convert(T, x)}, but without the restriction of returning a |
| 103 | @code{T}. This allows you to \"convert\" wrapper types like @code{Adjoint} to |
| 104 | be GPU compatible without throwing away the wrapper.") |
| 105 | (license license:expat))) |
| 106 | |
| 107 | (define-public julia-ansicoloredprinters |
| 108 | (package |
| 109 | (name "julia-ansicoloredprinters") |
| 110 | (version "0.0.1") |
| 111 | (source |
| 112 | (origin |
| 113 | (method git-fetch) |
| 114 | (uri (git-reference |
| 115 | (url "https://github.com/JuliaDocs/ANSIColoredPrinters.jl") |
| 116 | (commit (string-append "v" version)))) |
| 117 | (file-name (git-file-name name version)) |
| 118 | (sha256 |
| 119 | (base32 "0dp5agljr0g50s5gn0pr70wrz01ggck6pb40ay3l4szhswq7mqzf")))) |
| 120 | (build-system julia-build-system) |
| 121 | (home-page "https://github.com/JuliaDocs/ANSIColoredPrinters.jl") |
| 122 | (synopsis "ANSI escape code translator") |
| 123 | (description "@code{ANSIColoredPrinters.jl} converts a text qualified by |
| 124 | ANSI escape codes to another format.") |
| 125 | (license license:expat))) |
| 126 | |
| 127 | (define-public julia-aqua |
| 128 | (package |
| 129 | (name "julia-aqua") |
| 130 | (version "0.5.1") |
| 131 | (source |
| 132 | (origin |
| 133 | (method git-fetch) |
| 134 | (uri (git-reference |
| 135 | (url "https://github.com/JuliaTesting/Aqua.jl") |
| 136 | (commit (string-append "v" version)))) |
| 137 | (file-name (git-file-name name version)) |
| 138 | (sha256 |
| 139 | (base32 "1g0kyzcdykgs247j72jpc2qqall696jwgb3hnn4cxmbi8bkf7wpk")))) |
| 140 | (build-system julia-build-system) |
| 141 | (arguments |
| 142 | (list #:parallel-tests? #f)) |
| 143 | (home-page "https://github.com/JuliaTesting/Aqua.jl") |
| 144 | (synopsis "Automated quality assurance for Julia packages") |
| 145 | (description "@acronym{Aqua.jl, Auto QUality Assurance for Julia packages}, |
| 146 | provides functions to run a few automatable checks for Julia packages.") |
| 147 | (license license:expat))) |
| 148 | |
| 149 | (define-public julia-arrayinterface |
| 150 | (package |
| 151 | (name "julia-arrayinterface") |
| 152 | (version "3.1.19") |
| 153 | (source |
| 154 | (origin |
| 155 | (method git-fetch) |
| 156 | (uri (git-reference |
| 157 | (url "https://github.com/JuliaArrays/ArrayInterface.jl") |
| 158 | (commit (string-append "v" version)))) |
| 159 | (file-name (git-file-name name version)) |
| 160 | (sha256 |
| 161 | (base32 "0cmldnzvdgmfnrnrzgj6v1mfr2rvk5096392rwmhd3iyx7v0pq33")))) |
| 162 | (build-system julia-build-system) |
| 163 | (arguments |
| 164 | ;; XXXX: Unexpected failures for i686, e.g., |
| 165 | ;; Expression: @inferred(ArrayInterface.size(Rnr)) === (StaticInt(4),) |
| 166 | ;; Evaluated: (static(2),) === (static(4),) |
| 167 | ;; Disable as stopgap. |
| 168 | (list #:tests? (not (target-x86-32?)))) |
| 169 | (propagated-inputs |
| 170 | (list julia-ifelse |
| 171 | julia-requires |
| 172 | julia-static)) |
| 173 | (native-inputs |
| 174 | (list julia-aqua |
| 175 | julia-bandedmatrices |
| 176 | julia-blockbandedmatrices |
| 177 | julia-ifelse |
| 178 | julia-offsetarrays |
| 179 | julia-staticarrays)) |
| 180 | (home-page "https://github.com/JuliaArrays/ArrayInterface.jl") |
| 181 | (synopsis "Base array interface primitives") |
| 182 | (description "The purpose of this library is to solidify extensions to the |
| 183 | current @code{AbstractArray} interface, which are put to use in package |
| 184 | ecosystems like @code{DifferentialEquations.jl}. Since these libraries are |
| 185 | live, this package will serve as a staging ground for ideas before they are |
| 186 | merged into Base Julia. For this reason, no functionality is exported so that |
| 187 | if such functions are added and exported in a future Base Julia, there will be |
| 188 | no issues with the upgrade.") |
| 189 | (license license:expat))) |
| 190 | |
| 191 | (define-public julia-arraylayouts |
| 192 | (package |
| 193 | (name "julia-arraylayouts") |
| 194 | (version "0.7.6") |
| 195 | (source |
| 196 | (origin |
| 197 | (method git-fetch) |
| 198 | (uri (git-reference |
| 199 | (url "https://github.com/JuliaMatrices/ArrayLayouts.jl") |
| 200 | (commit (string-append "v" version)))) |
| 201 | (file-name (git-file-name name version)) |
| 202 | (sha256 |
| 203 | (base32 "05q62pks8j23pgbrfny072rrwzrz6q19l68srnjxxv39ncmdmrvg")))) |
| 204 | (build-system julia-build-system) |
| 205 | (propagated-inputs |
| 206 | (list julia-fillarrays)) |
| 207 | (home-page "https://github.com/JuliaMatrices/ArrayLayouts.jl") |
| 208 | (synopsis "Array layouts and general fast linear algebra") |
| 209 | (description "This package implements a trait-based framework for describing |
| 210 | array layouts such as column major, row major, etc. that can be dispatched to |
| 211 | appropriate BLAS or optimised Julia linear algebra routines. This supports a |
| 212 | much wider class of matrix types than Julia's in-built @code{StridedArray}.") |
| 213 | (license license:expat))) |
| 214 | |
| 215 | (define-public julia-automa |
| 216 | (package |
| 217 | (name "julia-automa") |
| 218 | (version "0.8.2") |
| 219 | (source |
| 220 | (origin |
| 221 | (method git-fetch) |
| 222 | (uri (git-reference |
| 223 | (url "https://github.com/BioJulia/Automa.jl") |
| 224 | (commit (string-append "v" version)))) |
| 225 | (file-name (git-file-name name version)) |
| 226 | (sha256 |
| 227 | (base32 "0hmwvk3qw54p7f63a2dnzlmvkynfs62x9n8x952bcmczp35csgq0")))) |
| 228 | (build-system julia-build-system) |
| 229 | (propagated-inputs |
| 230 | (list julia-scanbyte |
| 231 | julia-transcodingstreams)) |
| 232 | (home-page "https://github.com/BioJulia/Automa.jl") |
| 233 | (synopsis "Validation, parsing, and tokenizing based on state machine compiler") |
| 234 | (description "This package compiles regular expressions into Julia code, |
| 235 | which is then compiled into low-level machine code by the Julia compiler. The |
| 236 | package is designed to generate very efficient code to scan large text data, |
| 237 | which is often much faster than handcrafted code. @code{Automa.jl} can insert |
| 238 | arbitrary Julia code that will be executed in state transitions. This makes |
| 239 | it possible, for example, to extract substrings that match a part of a regular |
| 240 | expression.") |
| 241 | (license license:expat))) |
| 242 | |
| 243 | (define-public julia-axisalgorithms |
| 244 | (package |
| 245 | (name "julia-axisalgorithms") |
| 246 | (version "1.0.0") |
| 247 | (source |
| 248 | (origin |
| 249 | (method git-fetch) |
| 250 | (uri (git-reference |
| 251 | (url "https://github.com/timholy/AxisAlgorithms.jl") |
| 252 | (commit (string-append "v" version)))) |
| 253 | (file-name (git-file-name name version)) |
| 254 | (sha256 |
| 255 | (base32 "00x85lnfln7xkfnirpplzyi8r6q92nfqwya8il156bf7b1pa20gk")))) |
| 256 | (build-system julia-build-system) |
| 257 | (propagated-inputs |
| 258 | (list julia-woodburymatrices)) |
| 259 | (home-page "https://github.com/timholy/AxisAlgorithms.jl") |
| 260 | (synopsis "Filtering and linear algebra routines for multidimensional arrays") |
| 261 | (description "@code{AxisAlgorithms} is a collection of filtering and linear |
| 262 | algebra algorithms for multidimensional arrays. For algorithms that would |
| 263 | typically apply along the columns of a matrix, you can instead pick an arbitrary |
| 264 | axis (dimension).") |
| 265 | (license license:expat))) |
| 266 | |
| 267 | (define-public julia-axisarrays |
| 268 | (package |
| 269 | (name "julia-axisarrays") |
| 270 | (version "0.4.4") |
| 271 | (source |
| 272 | (origin |
| 273 | (method git-fetch) |
| 274 | (uri (git-reference |
| 275 | (url "https://github.com/JuliaArrays/AxisArrays.jl") |
| 276 | (commit (string-append "v" version)))) |
| 277 | (file-name (git-file-name name version)) |
| 278 | (sha256 |
| 279 | (base32 "03kzan1lm4fxfhzv1xjg3ysf6y7nagcc61vfz15kvdrp1dqxlynk")))) |
| 280 | (build-system julia-build-system) |
| 281 | (propagated-inputs |
| 282 | (list julia-rangearrays |
| 283 | julia-intervalsets |
| 284 | julia-itertools)) |
| 285 | (native-inputs |
| 286 | (list julia-offsetarrays |
| 287 | julia-unitful)) |
| 288 | (home-page "http://juliaarrays.github.io/AxisArrays.jl/latest/") |
| 289 | (synopsis "Arrays where each dimension can have a named axis with values") |
| 290 | (description "This package for the Julia language provides an array type |
| 291 | (the AxisArray) that knows about its dimension names and axis values. This |
| 292 | allows for indexing by name without incurring any runtime overhead. This |
| 293 | permits one to implement algorithms that are oblivious to the storage order of |
| 294 | the underlying arrays. AxisArrays can also be indexed by the values along their |
| 295 | axes, allowing column names or interval selections.") |
| 296 | (license license:expat))) |
| 297 | |
| 298 | (define-public julia-bandedmatrices |
| 299 | (package |
| 300 | (name "julia-bandedmatrices") |
| 301 | (version "0.16.10") |
| 302 | (source |
| 303 | (origin |
| 304 | (method git-fetch) |
| 305 | (uri (git-reference |
| 306 | (url "https://github.com/JuliaMatrices/BandedMatrices.jl") |
| 307 | (commit (string-append "v" version)))) |
| 308 | (file-name (git-file-name name version)) |
| 309 | (sha256 |
| 310 | (base32 "0rlfj9gr9ss621v5kw5b06206yaak21s2vq9vk7r8a7p2ylncism")))) |
| 311 | (build-system julia-build-system) |
| 312 | (propagated-inputs |
| 313 | (list julia-arraylayouts |
| 314 | julia-fillarrays)) |
| 315 | (native-inputs |
| 316 | (list julia-genericlinearalgebra)) |
| 317 | (home-page "https://github.com/JuliaMatrices/BandedMatrices.jl") |
| 318 | (synopsis "Julia package for representing banded matrices") |
| 319 | (description "This package supports representing banded matrices by only |
| 320 | the entries on the bands.") |
| 321 | (license license:expat))) |
| 322 | |
| 323 | (define-public julia-benchmarktools |
| 324 | (package |
| 325 | (name "julia-benchmarktools") |
| 326 | (version "1.1.1") |
| 327 | (source |
| 328 | (origin |
| 329 | (method git-fetch) |
| 330 | (uri (git-reference |
| 331 | (url "https://github.com/JuliaCI/BenchmarkTools.jl") |
| 332 | (commit (string-append "v" version)))) |
| 333 | (file-name (git-file-name name version)) |
| 334 | (sha256 |
| 335 | (base32 "1xz3kdrphp4b158pg7dwkiry49phs2fjjpdvk1hjpww5ykxacks8")))) |
| 336 | (build-system julia-build-system) |
| 337 | (arguments |
| 338 | (list |
| 339 | #:phases |
| 340 | (if (target-x86-32?) |
| 341 | #~(modify-phases %standard-phases |
| 342 | (add-after 'unpack 'remove-failing-tests-i686 |
| 343 | (lambda _ |
| 344 | (substitute* "test/GroupsTests.jl" |
| 345 | (("@test sprint\\(show, g1\\)") |
| 346 | "@test_broken sprint(show, g1)") |
| 347 | (("@test sprint\\(show, g1; context = :boundto => 1\\)") |
| 348 | "@test_broken sprint(show, g1; context = :boundto => 1)") |
| 349 | (("@test sprint\\(show, g1; context = :limit => false\\)") |
| 350 | "@test_broken sprint(show, g1; context = :limit => false)") |
| 351 | (("@test @test_deprecated") "@test_broken")) |
| 352 | (substitute* "test/ExecutionTests.jl" |
| 353 | ;; Evaluated: 12 == 8 |
| 354 | (("@test @ballocated\\(Ref\\(1\\)\\)") |
| 355 | "@test_broken @ballocated(Ref(1))"))))) |
| 356 | #~%standard-phases))) |
| 357 | (propagated-inputs |
| 358 | (list julia-json)) |
| 359 | (home-page "https://github.com/JuliaCI/BenchmarkTools.jl") |
| 360 | (synopsis "Benchmarking framework for the Julia language") |
| 361 | (description "@code{BenchmarkTools.jl} makes performance tracking of Julia |
| 362 | code easy by supplying a framework for writing and running groups of |
| 363 | benchmarks as well as comparing benchmark results.") |
| 364 | (license license:expat))) |
| 365 | |
| 366 | (define-public julia-bfloat16s |
| 367 | ;; Not tagged upstream |
| 368 | (let ((commit "ef6051e4308ed0c02f10168b99d226237e0ae33c") |
| 369 | (version "0.2.0")) |
| 370 | (package |
| 371 | (name "julia-bfloat16s") |
| 372 | (version version) |
| 373 | (source |
| 374 | (origin |
| 375 | (method git-fetch) |
| 376 | (uri (git-reference |
| 377 | (url "https://github.com/JuliaMath/BFloat16s.jl") |
| 378 | (commit commit))) |
| 379 | (file-name (git-file-name name version)) |
| 380 | (sha256 |
| 381 | (base32 "16sr578k4i47lhziri47nvspdrsni2wc1qjhs6hzffh9si6a7jfq")))) |
| 382 | (build-system julia-build-system) |
| 383 | (home-page "https://github.com/JuliaMath/BFloat16s.jl") |
| 384 | (synopsis "Define BFloat16 data type") |
| 385 | (description "This package defines the @code{BFloat16} data type. The |
| 386 | only currently available hardware implementation of this datatype are Google's |
| 387 | Cloud TPUs. As such, this package is suitable to evaluate whether using TPUs |
| 388 | would cause precision problems for any particular algorithm, even without |
| 389 | access to TPU hardware. Note that this package is designed for functionality, |
| 390 | not performance, so this package should be used for precision experiments |
| 391 | only, not performance experiments.") |
| 392 | (license license:expat)))) |
| 393 | |
| 394 | (define-public julia-bioalignments |
| 395 | (package |
| 396 | (name "julia-bioalignments") |
| 397 | (version "2.0.0") |
| 398 | (source |
| 399 | (origin |
| 400 | (method git-fetch) |
| 401 | (uri (git-reference |
| 402 | (url "https://github.com/BioJulia/BioAlignments.jl") |
| 403 | (commit (string-append "v" version)))) |
| 404 | (file-name (git-file-name name version)) |
| 405 | (sha256 |
| 406 | (base32 "1wf6qgsada59r2fykxfj9hcr635wl8maqxbd3w8qpa01k9glxa0k")))) |
| 407 | (build-system julia-build-system) |
| 408 | (arguments |
| 409 | (list |
| 410 | #:phases |
| 411 | #~(modify-phases %standard-phases |
| 412 | (add-after 'unpack 'skip-test |
| 413 | (lambda _ |
| 414 | ;; Test fails because an unexpected type representation from |
| 415 | ;; BioSequences. The aligned value is correct though. |
| 416 | (substitute* "test/runtests.jl" |
| 417 | (("@test sprint\\(show, aln\\)") |
| 418 | "@test_broken sprint(show, aln)"))))))) |
| 419 | (propagated-inputs |
| 420 | (list julia-biogenerics |
| 421 | julia-biosequences |
| 422 | julia-biosymbols |
| 423 | julia-intervaltrees)) |
| 424 | (home-page "https://github.com/BioJulia/BioAlignments.jl") |
| 425 | (synopsis "Sequence alignment algorithm and data structures") |
| 426 | (description "This package provides alignment algorithms and data |
| 427 | structures for sequence of DNA, RNA, and amino acid sequences.") |
| 428 | (license license:expat))) |
| 429 | |
| 430 | (define-public julia-biogenerics |
| 431 | ;; No upstream release |
| 432 | (let ((commit "a75abaf459250e2b5e22b4d9adf25fd36d2acab6") |
| 433 | (revision "1")) |
| 434 | (package |
| 435 | (name "julia-biogenerics") |
| 436 | (version (git-version "0.0.0" revision commit)) |
| 437 | (source |
| 438 | (origin |
| 439 | (method git-fetch) |
| 440 | (uri (git-reference |
| 441 | (url "https://github.com/BioJulia/BioGenerics.jl") |
| 442 | (commit commit))) |
| 443 | (file-name (git-file-name name version)) |
| 444 | (sha256 |
| 445 | (base32 "17d222vi9nssjwr5l349fss7jnglnjimp1z62kmfmxa4fsn8lk8l")))) |
| 446 | (build-system julia-build-system) |
| 447 | (inputs |
| 448 | (list julia-transcodingstreams)) |
| 449 | (home-page "https://github.com/BioJulia/BioGenerics.jl") |
| 450 | (synopsis "Generic methods used by BioJulia packages") |
| 451 | (description "This package provides generic methods and modules used in |
| 452 | many of the other BioJulia packages. This package defines IO, exceptions, and |
| 453 | other types or methods used by other BioJulia packages.") |
| 454 | (license license:expat)))) |
| 455 | |
| 456 | (define-public julia-biosequences |
| 457 | (package |
| 458 | (name "julia-biosequences") |
| 459 | (version "2.0.5") |
| 460 | (source |
| 461 | (origin |
| 462 | (method git-fetch) |
| 463 | (uri (git-reference |
| 464 | (url "https://github.com/BioJulia/BioSequences.jl") |
| 465 | (commit (string-append "v" version)))) |
| 466 | (file-name (git-file-name name version)) |
| 467 | (sha256 |
| 468 | (base32 "0ns6zk0zvnsf4hlsys9ck2xrn20qck0b0aghh484vc6n458zq2gw")))) |
| 469 | (build-system julia-build-system) |
| 470 | (propagated-inputs |
| 471 | (list julia-biogenerics |
| 472 | julia-biosymbols |
| 473 | julia-combinatorics |
| 474 | julia-indexablebitvectors |
| 475 | julia-stablerngs |
| 476 | julia-twiddle)) |
| 477 | (native-inputs |
| 478 | (list julia-statsbase |
| 479 | julia-yaml)) |
| 480 | (home-page "https://biojulia.net/BioSequences.jl/stable/") |
| 481 | (synopsis "Data types and methods for common operations with biological sequences") |
| 482 | (description "This package provides Data types and methods for common |
| 483 | operations with biological sequences, including DNA, RNA, and amino acid |
| 484 | sequences.") |
| 485 | (license license:expat))) |
| 486 | |
| 487 | (define-public julia-biosymbols |
| 488 | (package |
| 489 | (name "julia-biosymbols") |
| 490 | ;; Older release for compatibility with julia-biosequences. |
| 491 | (version "4.0.4") |
| 492 | (source |
| 493 | (origin |
| 494 | (method git-fetch) |
| 495 | (uri (git-reference |
| 496 | (url "https://github.com/BioJulia/BioSymbols.jl") |
| 497 | (commit (string-append "v" version)))) |
| 498 | (file-name (git-file-name name version)) |
| 499 | (sha256 |
| 500 | (base32 "1222rwdndi777lai8a6dwrh35i5rgmj75kcrhn8si72sxgz0syjm")))) |
| 501 | (build-system julia-build-system) |
| 502 | (arguments |
| 503 | (list |
| 504 | #:phases |
| 505 | #~(modify-phases %standard-phases |
| 506 | (add-after 'unpack 'adjust-tests |
| 507 | (lambda _ |
| 508 | (substitute* "test/runtests.jl" |
| 509 | (("\\@testset \\\"Range.*" all) |
| 510 | (string-append all " return\n")))))))) |
| 511 | (propagated-inputs |
| 512 | (list julia-automa)) |
| 513 | (home-page "https://github.com/BioJulia/BioSymbols.jl") |
| 514 | (synopsis "Primitive types for nucleic acids and amino acids") |
| 515 | (description "This package defines the primitive types for nucleic acids |
| 516 | and amino acids that are used ny otherBioJulia packages.") |
| 517 | (license license:expat))) |
| 518 | |
| 519 | (define-public julia-blockarrays |
| 520 | (package |
| 521 | (name "julia-blockarrays") |
| 522 | (version "0.16.8") |
| 523 | (source |
| 524 | (origin |
| 525 | (method git-fetch) |
| 526 | (uri (git-reference |
| 527 | (url "https://github.com/JuliaArrays/BlockArrays.jl") |
| 528 | (commit (string-append "v" version)))) |
| 529 | (file-name (git-file-name name version)) |
| 530 | (sha256 |
| 531 | (base32 "1by26036fk9mawmcgqxpwizgbs398v9p6vrbsgg7h6llqn3q9iw1")))) |
| 532 | (build-system julia-build-system) |
| 533 | (arguments |
| 534 | (list |
| 535 | #:phases |
| 536 | (if (target-64bit?) |
| 537 | #~%standard-phases |
| 538 | #~(modify-phases %standard-phases |
| 539 | (add-after 'unpack 'fix-tests-int32-i686 |
| 540 | (lambda _ |
| 541 | (substitute* "test/test_blockarrays.jl" |
| 542 | (("Int64") "Int32")))))))) |
| 543 | (propagated-inputs |
| 544 | (list julia-arraylayouts |
| 545 | julia-fillarrays)) |
| 546 | (native-inputs |
| 547 | (list julia-lazyarrays |
| 548 | julia-offsetarrays |
| 549 | julia-staticarrays)) |
| 550 | (home-page "https://github.com/JuliaArrays/BlockArrays.jl") |
| 551 | (synopsis "BlockArrays for Julia") |
| 552 | (description "A block array is a partition of an array into blocks or |
| 553 | subarrays. This package has two purposes. Firstly, it defines an interface for |
| 554 | an @code{AbstractBlockArray} block arrays that can be shared among types |
| 555 | representing different types of block arrays. The advantage to this is that it |
| 556 | provides a consistent API for block arrays. |
| 557 | Secondly, it also implements two different type of block arrays that follow the |
| 558 | @code{AbstractBlockArray} interface. The type @code{BlockArray} stores each |
| 559 | block contiguously while the type @code{PseudoBlockArray} stores the full matrix |
| 560 | contiguously. This means that @code{BlockArray} supports fast non copying |
| 561 | extraction and insertion of blocks while @code{PseudoBlockArray} supports fast |
| 562 | access to the full matrix to use in in for example a linear solver.") |
| 563 | (license license:expat))) |
| 564 | |
| 565 | (define-public julia-blockbandedmatrices |
| 566 | (package |
| 567 | (name "julia-blockbandedmatrices") |
| 568 | (version "0.10.7") |
| 569 | (source |
| 570 | (origin |
| 571 | (method git-fetch) |
| 572 | (uri (git-reference |
| 573 | (url "https://github.com/JuliaMatrices/BlockBandedMatrices.jl") |
| 574 | (commit (string-append "v" version)))) |
| 575 | (file-name (git-file-name name version)) |
| 576 | (sha256 |
| 577 | (base32 "10n1r6kmmv2wa307jfg9y2m6p16j8hngjp3fjavpbdy1r5haasm9")))) |
| 578 | (build-system julia-build-system) |
| 579 | (propagated-inputs |
| 580 | (list julia-arraylayouts |
| 581 | julia-bandedmatrices |
| 582 | julia-blockarrays |
| 583 | julia-fillarrays |
| 584 | julia-matrixfactorizations)) |
| 585 | (home-page "https://github.com/JuliaMatrices/BlockBandedMatrices.jl") |
| 586 | (synopsis "Block-banded matrices and banded-block-banded matrices") |
| 587 | (description "This package supports representing block-banded and |
| 588 | banded-block-banded matrices by only storing the entries in the non-zero bands. |
| 589 | A @code{BlockBandedMatrix} is a subtype of @code{BlockMatrix} of |
| 590 | @code{BlockArrays.jl} whose layout of non-zero blocks is banded.") |
| 591 | (license license:expat))) |
| 592 | |
| 593 | (define-public julia-bson |
| 594 | (package |
| 595 | (name "julia-bson") |
| 596 | (version "0.3.3") |
| 597 | (source |
| 598 | (origin |
| 599 | (method git-fetch) |
| 600 | (uri (git-reference |
| 601 | (url "https://github.com/JuliaIO/BSON.jl") |
| 602 | (commit (string-append "v" version)))) |
| 603 | (file-name (git-file-name name version)) |
| 604 | (sha256 |
| 605 | (base32 "1l5608ma2ys7v2gpcqbiv9mwfc6yrlqkihrfx1pf7fgv5llhd4fn")))) |
| 606 | (build-system julia-build-system) |
| 607 | (native-inputs |
| 608 | (list julia-dataframes)) |
| 609 | (home-page "https://github.com/JuliaIO/BSON.jl") |
| 610 | (synopsis "Binary JSON serialisation format") |
| 611 | (description "@code{BSON.jl} is a Julia package for working with the Binary |
| 612 | JSON serialisation format. It can be used as a general store for Julia data |
| 613 | structures.") |
| 614 | (license license:expat))) |
| 615 | |
| 616 | (define-public julia-bufferedstreams |
| 617 | (package |
| 618 | (name "julia-bufferedstreams") |
| 619 | (version "1.0.0") |
| 620 | (source |
| 621 | (origin |
| 622 | (method git-fetch) |
| 623 | (uri (git-reference |
| 624 | (url "https://github.com/BioJulia/BufferedStreams.jl") |
| 625 | (commit (string-append "v" version)))) |
| 626 | (file-name (git-file-name name version)) |
| 627 | (sha256 |
| 628 | (base32 "0sf4sxbq55mg2pwxyxf0c839z1lk0yxg8nmb7617bfbvw31cp88z")))) |
| 629 | (build-system julia-build-system) |
| 630 | ;; The package is old and tests are using undefined functions. They also |
| 631 | ;; freeze, see |
| 632 | ;; https://travis-ci.org/BioJulia/BufferedStreams.jl/jobs/491050182 |
| 633 | (arguments |
| 634 | (list |
| 635 | #:tests? #f |
| 636 | #:julia-package-name "BufferedStreams" |
| 637 | #:julia-package-uuid "e1450e63-4bb3-523b-b2a4-4ffa8c0fd77d")) |
| 638 | (propagated-inputs |
| 639 | (list julia-compat)) |
| 640 | (home-page "https://github.com/BioJulia/BufferedStreams.jl") |
| 641 | (synopsis "Fast composable IO streams") |
| 642 | (description "@code{BufferedStreams.jl} provides buffering for IO |
| 643 | operations. It can wrap any @code{IO} type automatically making incremental |
| 644 | reading and writing faster.") |
| 645 | (license license:expat))) |
| 646 | |
| 647 | (define-public julia-calculus |
| 648 | (package |
| 649 | (name "julia-calculus") |
| 650 | (version "0.5.1") |
| 651 | (source |
| 652 | (origin |
| 653 | (method git-fetch) |
| 654 | (uri (git-reference |
| 655 | (url "https://github.com/JuliaMath/Calculus.jl") |
| 656 | (commit (string-append "v" version)))) |
| 657 | (file-name (git-file-name name version)) |
| 658 | (sha256 |
| 659 | (base32 "0xh0ak2ycsjw2h86ja24ch3kn2d18zx3frrds78aimwdnqb1gdc2")))) |
| 660 | (build-system julia-build-system) |
| 661 | (home-page "https://github.com/JuliaMath/Calculus.jl") |
| 662 | (synopsis "Common utilities for automatic differentiation") |
| 663 | (description "This package provides tools for working with the basic |
| 664 | calculus operations of differentiation and integration. The @code{Calculus} |
| 665 | package produces approximate derivatives by several forms of finite |
| 666 | differencing or produces exact derivative using symbolic differentiation. It |
| 667 | can also be used to compute definite integrals by different numerical |
| 668 | methods.") |
| 669 | (license license:expat))) |
| 670 | |
| 671 | (define-public julia-categoricalarrays |
| 672 | (package |
| 673 | (name "julia-categoricalarrays") |
| 674 | (version "0.9.7") |
| 675 | (source |
| 676 | (origin |
| 677 | (method git-fetch) |
| 678 | (uri (git-reference |
| 679 | (url "https://github.com/JuliaData/CategoricalArrays.jl") |
| 680 | (commit (string-append "v" version)))) |
| 681 | (file-name (git-file-name name version)) |
| 682 | (sha256 |
| 683 | (base32 "1bcfylxdaizgasnmlkjjkf4dgfvy2y9ycnphw2d0z6mm9vx3n04x")))) |
| 684 | (build-system julia-build-system) |
| 685 | (native-inputs |
| 686 | (list julia-pooledarrays)) |
| 687 | (propagated-inputs |
| 688 | (list julia-dataapi |
| 689 | julia-json |
| 690 | julia-json3 |
| 691 | julia-missings |
| 692 | julia-recipesbase |
| 693 | julia-structtypes)) |
| 694 | (home-page "https://github.com/JuliaData/CategoricalArrays.jl") |
| 695 | (synopsis "Arrays for working with categorical data") |
| 696 | (description "This package provides tools for working with categorical |
| 697 | variables, both with unordered (nominal variables) and ordered categories |
| 698 | (ordinal variables), optionally with missing values.") |
| 699 | (license license:expat))) |
| 700 | |
| 701 | (define-public julia-cenum |
| 702 | (package |
| 703 | (name "julia-cenum") |
| 704 | (version "0.4.1") |
| 705 | (source |
| 706 | (origin |
| 707 | (method git-fetch) |
| 708 | (uri (git-reference |
| 709 | (url "https://github.com/JuliaInterop/CEnum.jl") |
| 710 | (commit (string-append "v" version)))) |
| 711 | (file-name (git-file-name name version)) |
| 712 | (sha256 |
| 713 | (base32 "0h079mggvv420bw87j8s3hsgk7vavjgm4j1cvk0pnzrrh8ib1381")))) |
| 714 | (build-system julia-build-system) |
| 715 | (home-page "https://github.com/JuliaInterop/CEnum.jl") |
| 716 | (synopsis "C-compatible enum for Julia") |
| 717 | (description "This package provides a C-compatible enum for Julia.") |
| 718 | (license license:expat))) |
| 719 | |
| 720 | (define-public julia-chainrules |
| 721 | (package |
| 722 | (name "julia-chainrules") |
| 723 | (version "1.1.0") |
| 724 | (source |
| 725 | (origin |
| 726 | (method git-fetch) |
| 727 | (uri (git-reference |
| 728 | (url "https://github.com/JuliaDiff/ChainRules.jl") |
| 729 | (commit (string-append "v" version)))) |
| 730 | (file-name (git-file-name name version)) |
| 731 | (sha256 |
| 732 | (base32 "0if93pd3b3scg2x3gmk1cbwjk0ax1n792vy8c38y3xl7jpd5cb70")))) |
| 733 | (build-system julia-build-system) |
| 734 | (inputs ;required for test |
| 735 | (list julia-chainrulestestutils |
| 736 | julia-finitedifferences |
| 737 | julia-nanmath |
| 738 | julia-specialfunctions)) |
| 739 | (propagated-inputs |
| 740 | (list julia-chainrulescore |
| 741 | julia-compat |
| 742 | julia-reexport |
| 743 | julia-requires)) |
| 744 | (home-page "https://github.com/JuliaDiff/ChainRules.jl") |
| 745 | (synopsis "Common utilities for automatic differentiation") |
| 746 | (description "The is package provides a variety of common utilities that |
| 747 | can be used by downstream automatic differentiation (AD) tools to define and |
| 748 | execute forward-, reverse-, and mixed-mode primitives.") |
| 749 | (license license:expat))) |
| 750 | |
| 751 | (define-public julia-chainrulescore |
| 752 | (package |
| 753 | (name "julia-chainrulescore") |
| 754 | (version "1.0.2") |
| 755 | (source |
| 756 | (origin |
| 757 | (method git-fetch) |
| 758 | (uri (git-reference |
| 759 | (url "https://github.com/JuliaDiff/ChainRulesCore.jl") |
| 760 | (commit (string-append "v" version)))) |
| 761 | (file-name (git-file-name name version)) |
| 762 | (sha256 |
| 763 | (base32 "1866xv30h1bi7f2m993nljzf58wwmv8zlgn6ffn9j3wckch1nfpb")))) |
| 764 | (build-system julia-build-system) |
| 765 | (inputs ;required for tests |
| 766 | (list julia-benchmarktools |
| 767 | julia-staticarrays)) |
| 768 | (propagated-inputs |
| 769 | (list julia-compat)) |
| 770 | (home-page "https://github.com/JuliaDiff/ChainRulesCore.jl") |
| 771 | (synopsis "Common utilities used by downstream automatic differentiation tools") |
| 772 | (description "The package provides a light-weight dependency for defining |
| 773 | sensitivities for functions without the need to depend on ChainRules itself.") |
| 774 | (license license:expat))) |
| 775 | |
| 776 | (define-public julia-chainrulestestutils |
| 777 | (package |
| 778 | (name "julia-chainrulestestutils") |
| 779 | (version "1.2.3") |
| 780 | (source |
| 781 | (origin |
| 782 | (method git-fetch) |
| 783 | (uri (git-reference |
| 784 | (url "https://github.com/JuliaDiff/ChainRulesTestUtils.jl") |
| 785 | (commit (string-append "v" version)))) |
| 786 | (file-name (git-file-name name version)) |
| 787 | (sha256 |
| 788 | (base32 "1vlkyp72d514gyb4k3yhjl1g7f24ncmz61j56p4sdi9f76rk9fx9")))) |
| 789 | (build-system julia-build-system) |
| 790 | (propagated-inputs |
| 791 | (list julia-chainrulescore |
| 792 | julia-compat |
| 793 | julia-finitedifferences)) |
| 794 | (home-page "https://github.com/JuliaDiff/ChainRulesTestUtils.jl") |
| 795 | (synopsis "Common utilities used by downstream automatic differentiation tools") |
| 796 | (description "This package is designed to help in testing |
| 797 | @code{ChainRulesCore.frule} and @code{ChainRulesCore.rrule} methods. The main |
| 798 | entry points are @code{ChainRulesTestUtils.frule_test}, |
| 799 | @code{ChainRulesTestUtils.rrule_test}, and |
| 800 | @code{ChainRulesTestUtils.test_scalar}. Currently this is done via testing the |
| 801 | rules against numerical differentiation (using @code{FiniteDifferences.jl}). |
| 802 | |
| 803 | @code{ChainRulesTestUtils.jl} is separated from @code{ChainRulesCore.jl} so that it |
| 804 | can be a test-only dependency, allowing it to have potentially heavy |
| 805 | dependencies, while keeping @code{ChainRulesCore.jl} as light-weight as possible.") |
| 806 | (license license:expat))) |
| 807 | |
| 808 | (define-public julia-codeczlib |
| 809 | (package |
| 810 | (name "julia-codeczlib") |
| 811 | (version "0.7.0") |
| 812 | (source |
| 813 | (origin |
| 814 | (method git-fetch) |
| 815 | (uri (git-reference |
| 816 | (url "https://github.com/JuliaIO/CodecZlib.jl") |
| 817 | (commit (string-append "v" version)))) |
| 818 | (file-name (git-file-name name version)) |
| 819 | (sha256 |
| 820 | (base32 "0xm603nylkwk4bzx66zv1g3syzrvn3jh9spdx7kvcvgszzyrrgh4")))) |
| 821 | (build-system julia-build-system) |
| 822 | (propagated-inputs |
| 823 | (list julia-transcodingstreams |
| 824 | julia-zlib-jll)) |
| 825 | (home-page "https://github.com/JuliaIO/CodecZlib.jl") |
| 826 | (synopsis "Zlib codecs for @code{TranscodingStreams.jl}") |
| 827 | (description "This package provides zlib codecs for |
| 828 | @code{TranscodingStreams.jl}.") |
| 829 | (license license:expat))) |
| 830 | |
| 831 | (define-public julia-colors |
| 832 | (package |
| 833 | (name "julia-colors") |
| 834 | (version "0.12.8") |
| 835 | (source |
| 836 | (origin |
| 837 | (method git-fetch) |
| 838 | (uri (git-reference |
| 839 | (url "https://github.com/JuliaGraphics/Colors.jl") |
| 840 | (commit (string-append "v" version)))) |
| 841 | (file-name (git-file-name name version)) |
| 842 | (sha256 |
| 843 | (base32 "0kx3hq7rf8p5zx6ly9k5j90zijmc7yrwmy96cgkl2ibdfbnhmya3")))) |
| 844 | (build-system julia-build-system) |
| 845 | (propagated-inputs |
| 846 | (list julia-colortypes |
| 847 | julia-fixedpointnumbers |
| 848 | julia-reexport)) |
| 849 | (home-page "https://github.com/JuliaGraphics/Colors.jl") |
| 850 | (synopsis "Tools for dealing with color") |
| 851 | (description "This package provides a wide array of functions for dealing |
| 852 | with color. This includes conversion between colorspaces, measuring distance |
| 853 | between colors, simulating color blindness, parsing colors, and generating |
| 854 | color scales for graphics.") |
| 855 | (license license:expat))) |
| 856 | |
| 857 | (define-public julia-colorschemes |
| 858 | (package |
| 859 | (name "julia-colorschemes") |
| 860 | (version "3.15.0") |
| 861 | (source |
| 862 | (origin |
| 863 | (method git-fetch) |
| 864 | (uri (git-reference |
| 865 | (url "https://github.com/JuliaGraphics/ColorSchemes.jl") |
| 866 | (commit (string-append "v" version)))) |
| 867 | (file-name (git-file-name name version)) |
| 868 | (sha256 |
| 869 | (base32 "0kpjhmqd5cj8dh8bmh9b5g6bscyp7h23hzpr2s93pnrp57q1wvhq")))) |
| 870 | (build-system julia-build-system) |
| 871 | (propagated-inputs |
| 872 | (list julia-colors |
| 873 | julia-colortypes |
| 874 | julia-fixedpointnumbers |
| 875 | julia-staticarrays)) |
| 876 | (home-page "https://github.com/JuliaGraphics/ColorSchemes.jl") |
| 877 | (synopsis "Colorschemes, colormaps, gradients, and palettes") |
| 878 | (description "This package provides a collection of colorschemes.") |
| 879 | (license license:expat))) |
| 880 | |
| 881 | (define-public julia-colortypes |
| 882 | (package |
| 883 | (name "julia-colortypes") |
| 884 | (version "0.11.0") |
| 885 | (source |
| 886 | (origin |
| 887 | (method git-fetch) |
| 888 | (uri (git-reference |
| 889 | (url "https://github.com/JuliaGraphics/ColorTypes.jl") |
| 890 | (commit (string-append "v" version)))) |
| 891 | (file-name (git-file-name name version)) |
| 892 | (sha256 |
| 893 | (base32 "0n7h70caqv7yd0khjhn90iax62r73mcif8qzkwj5b4q46li1r8ih")))) |
| 894 | (build-system julia-build-system) |
| 895 | (propagated-inputs |
| 896 | (list julia-fixedpointnumbers)) |
| 897 | (native-inputs |
| 898 | (list julia-documenter)) |
| 899 | (home-page "https://github.com/JuliaGraphics/ColorTypes.jl") |
| 900 | (synopsis "Basic color types and constructor") |
| 901 | (description "This minimalistic package serves as the foundation for |
| 902 | working with colors in Julia. It defines basic color types and their |
| 903 | constructors, and sets up traits and show methods to make them easier to work |
| 904 | with.") |
| 905 | (license license:expat))) |
| 906 | |
| 907 | (define-public julia-colorvectorspace |
| 908 | (package |
| 909 | (name "julia-colorvectorspace") |
| 910 | (version "0.9.7") |
| 911 | (source |
| 912 | (origin |
| 913 | (method git-fetch) |
| 914 | (uri (git-reference |
| 915 | (url "https://github.com/JuliaGraphics/ColorVectorSpace.jl") |
| 916 | (commit (string-append "v" version)))) |
| 917 | (file-name (git-file-name name version)) |
| 918 | (sha256 |
| 919 | (base32 "02gk7f5g5wjxdasbjf8bvv1m7clksh7mw1xmygjdirjz1q0d6dwi")))) |
| 920 | (build-system julia-build-system) |
| 921 | (propagated-inputs |
| 922 | (list julia-colortypes |
| 923 | julia-specialfunctions |
| 924 | julia-tensorcore)) |
| 925 | (native-inputs |
| 926 | (list julia-colors)) |
| 927 | (home-page "https://github.com/JuliaGraphics/ColorVectorSpace.jl") |
| 928 | (synopsis "Treat colors as n-vectors for the purposes of arithmetic") |
| 929 | (description "This package is an add-on to @code{ColorTypes.jl} and provides |
| 930 | fast mathematical operations for objects with types such as RGB and Gray. |
| 931 | Specifically, with this package both grayscale and RGB colors are treated as if |
| 932 | they are points in a normed vector space.") |
| 933 | (license license:expat))) |
| 934 | |
| 935 | (define-public julia-combinatorics |
| 936 | (package |
| 937 | (name "julia-combinatorics") |
| 938 | (version "1.0.2") |
| 939 | (source |
| 940 | (origin |
| 941 | (method git-fetch) |
| 942 | (uri (git-reference |
| 943 | (url "https://github.com/JuliaMath/Combinatorics.jl") |
| 944 | (commit (string-append "v" version)))) |
| 945 | (file-name (git-file-name name version)) |
| 946 | (sha256 |
| 947 | (base32 "0gafqkqi874zfm9h99akw9q95lk3ih5gip2h8p12fj9h7rvyf4j5")))) |
| 948 | (build-system julia-build-system) |
| 949 | (home-page "https://github.com/JuliaMath/Combinatorics.jl") |
| 950 | (synopsis "Combinatorics library for Julia") |
| 951 | (description "This package provides a combinatorics library for Julia, |
| 952 | focusing mostly (as of now) on enumerative combinatorics and permutations.") |
| 953 | (license license:expat))) |
| 954 | |
| 955 | (define-public julia-commonsubexpressions |
| 956 | (package |
| 957 | (name "julia-commonsubexpressions") |
| 958 | (version "0.3.0") |
| 959 | (source |
| 960 | (origin |
| 961 | (method git-fetch) |
| 962 | (uri (git-reference |
| 963 | (url "https://github.com/rdeits/CommonSubexpressions.jl") |
| 964 | (commit (string-append "v" version)))) |
| 965 | (file-name (git-file-name name version)) |
| 966 | (sha256 |
| 967 | (base32 "0mgy90kk8ksv3l720kkk04gnhn4aqhh2dj4sp3x8yy3limngfjay")))) |
| 968 | (build-system julia-build-system) |
| 969 | (propagated-inputs |
| 970 | (list julia-macrotools)) |
| 971 | (home-page "https://github.com/rdeits/CommonSubexpressions.jl") |
| 972 | (synopsis "@code{@@cse} macro for Julia") |
| 973 | (description "This package provides the @code{@@cse} macro, which performs |
| 974 | common subexpression elimination.") |
| 975 | (license license:expat))) |
| 976 | |
| 977 | (define-public julia-compat |
| 978 | (package |
| 979 | (name "julia-compat") |
| 980 | (version "3.39.0") |
| 981 | (source |
| 982 | (origin |
| 983 | (method git-fetch) |
| 984 | (uri (git-reference |
| 985 | (url "https://github.com/JuliaLang/Compat.jl") |
| 986 | (commit (string-append "v" version)))) |
| 987 | (file-name (git-file-name name version)) |
| 988 | (sha256 |
| 989 | (base32 "0qzvaqi5gqgc747fnajbvvf5vqbh6cwykwky00c7glvmvdsgk3z0")))) |
| 990 | (build-system julia-build-system) |
| 991 | (home-page "https://github.com/JuliaLang/Compat.jl") |
| 992 | (synopsis "Compatibility across Julia versions") |
| 993 | (description "The Compat package is designed to ease interoperability |
| 994 | between older and newer versions of the Julia language. The Compat package |
| 995 | provides a macro that lets you use the latest syntax in a backwards-compatible |
| 996 | way.") |
| 997 | (license license:expat))) |
| 998 | |
| 999 | (define-public julia-configurations |
| 1000 | (package |
| 1001 | (name "julia-configurations") |
| 1002 | (version "0.16.4") |
| 1003 | (source |
| 1004 | (origin |
| 1005 | (method git-fetch) |
| 1006 | (uri (git-reference |
| 1007 | (url "https://github.com/Roger-luo/Configurations.jl") |
| 1008 | (commit (string-append "v" version)))) |
| 1009 | (file-name (git-file-name name version)) |
| 1010 | (sha256 |
| 1011 | (base32 "1b23p0zk8dx2sf01cnw177mqci7qd81b9s32ixz9clsh0r0icl1b")))) |
| 1012 | (build-system julia-build-system) |
| 1013 | (arguments |
| 1014 | (list |
| 1015 | #:phases |
| 1016 | #~(modify-phases %standard-phases |
| 1017 | (add-after 'link-depot 'fix-tests |
| 1018 | (lambda _ |
| 1019 | (substitute* "test/runtests.jl" |
| 1020 | (("option.toml") "test/option.toml")))) |
| 1021 | (add-after 'link-depot 'dont-use-exproniconlite |
| 1022 | (lambda _ |
| 1023 | (substitute* '("Project.toml" |
| 1024 | "src/Configurations.jl" |
| 1025 | "test/runtests.jl") |
| 1026 | (("ExproniconLite") "Expronicon")) |
| 1027 | (substitute* "Project.toml" |
| 1028 | (("55351af7-c7e9-48d6-89ff-24e801d99491") |
| 1029 | "6b7a57c9-7cc1-4fdf-b7f5-e857abae3636")))) |
| 1030 | #$@(if (target-64bit?) |
| 1031 | '() |
| 1032 | '((add-after 'unpack 'fix-tests-int32-i686 |
| 1033 | (lambda _ |
| 1034 | (substitute* "test/runtests.jl" |
| 1035 | (("Int64") "Int32"))))))))) |
| 1036 | (propagated-inputs |
| 1037 | (list julia-crayons |
| 1038 | julia-expronicon |
| 1039 | julia-orderedcollections)) |
| 1040 | (home-page "https://configurations.rogerluo.dev/stable/") |
| 1041 | (synopsis "Tools for options and configurations in Julia") |
| 1042 | (description "@code{Configurations.jl} provides a macro @code{@@option} to |
| 1043 | let you define @code{structs} to represent options/configurations, and serialize |
| 1044 | between different option/configuration file formats such as @code{TOML}.") |
| 1045 | (license license:expat))) |
| 1046 | |
| 1047 | (define-public julia-constructionbase |
| 1048 | (package |
| 1049 | (name "julia-constructionbase") |
| 1050 | (version "1.3.0") |
| 1051 | (source |
| 1052 | (origin |
| 1053 | (method git-fetch) |
| 1054 | (uri (git-reference |
| 1055 | (url "https://github.com/JuliaObjects/ConstructionBase.jl") |
| 1056 | (commit (string-append "v" version)))) |
| 1057 | (file-name (git-file-name name version)) |
| 1058 | (sha256 |
| 1059 | (base32 "1jk3h446vkv4yaavgm1hf1az7cwhppvhklvr08s49hhg02cm750q")))) |
| 1060 | (build-system julia-build-system) |
| 1061 | (home-page "https://juliaobjects.github.io/ConstructionBase.jl/dev/") |
| 1062 | (synopsis "Primitive functions for construction of objects") |
| 1063 | (description "This very lightweight package provides primitive functions |
| 1064 | for construction of objects.") |
| 1065 | (license license:expat))) |
| 1066 | |
| 1067 | (define-public julia-coordinatetransformations |
| 1068 | (package |
| 1069 | (name "julia-coordinatetransformations") |
| 1070 | (version "0.6.1") |
| 1071 | (source |
| 1072 | (origin |
| 1073 | (method git-fetch) |
| 1074 | (uri (git-reference |
| 1075 | (url "https://github.com/JuliaGeometry/CoordinateTransformations.jl") |
| 1076 | (commit (string-append "v" version)))) |
| 1077 | (file-name (git-file-name name version)) |
| 1078 | (sha256 |
| 1079 | (base32 "15zbkn32v7xlz7559s0r5a0vkwmjwsswxaqpzijly4lky4jnp33d")))) |
| 1080 | (build-system julia-build-system) |
| 1081 | (propagated-inputs |
| 1082 | (list julia-staticarrays)) |
| 1083 | (native-inputs |
| 1084 | (list julia-documenter |
| 1085 | julia-forwarddiff |
| 1086 | julia-unitful)) |
| 1087 | (home-page "https://github.com/JuliaGeometry/CoordinateTransformations.jl") |
| 1088 | (synopsis "Coordinate transformations in Julia") |
| 1089 | (description "@code{CoordinateTransformations} is a Julia package to manage |
| 1090 | simple or complex networks of coordinate system transformations. |
| 1091 | Transformations can be easily applied, inverted, composed, and differentiated |
| 1092 | (both with respect to the input coordinates and with respect to transformation |
| 1093 | parameters such as rotation angle). Transformations are designed to be |
| 1094 | light-weight and efficient enough for, e.g., real-time graphical applications, |
| 1095 | while support for both explicit and automatic differentiation makes it easy to |
| 1096 | perform optimization and therefore ideal for computer vision applications such |
| 1097 | as SLAM (simultaneous localization and mapping).") |
| 1098 | (license license:expat))) |
| 1099 | |
| 1100 | (define-public julia-crayons |
| 1101 | (package |
| 1102 | (name "julia-crayons") |
| 1103 | (version "4.0.4") |
| 1104 | (source |
| 1105 | (origin |
| 1106 | (method git-fetch) |
| 1107 | (uri (git-reference |
| 1108 | (url "https://github.com/KristofferC/Crayons.jl") |
| 1109 | (commit (string-append "v" version)))) |
| 1110 | (file-name (git-file-name name version)) |
| 1111 | (sha256 |
| 1112 | (base32 "0v3zhjlnb2914bxcj4myl8pgb7m31p77aj2k1bckmqs96jdph10z")))) |
| 1113 | (build-system julia-build-system) |
| 1114 | (home-page "https://github.com/KristofferC/Crayons.jl") |
| 1115 | (synopsis "Colored and styled strings for terminals") |
| 1116 | (description "Crayons is a package that makes it simple to write strings in |
| 1117 | different colors and styles to terminals. It supports the 16 system colors, |
| 1118 | both the 256 color and 24 bit true color extensions, and the different text |
| 1119 | styles available to terminals.") |
| 1120 | (license license:expat))) |
| 1121 | |
| 1122 | (define-public julia-dataapi |
| 1123 | (package |
| 1124 | (name "julia-dataapi") |
| 1125 | (version "1.7.0") |
| 1126 | (source |
| 1127 | (origin |
| 1128 | (method git-fetch) |
| 1129 | (uri (git-reference |
| 1130 | (url "https://github.com/JuliaData/DataAPI.jl") |
| 1131 | (commit (string-append "v" version)))) |
| 1132 | (file-name (git-file-name name version)) |
| 1133 | (sha256 |
| 1134 | (base32 "0swk31p83fycz5cdj4fg6b0wfqj473lnx94q2fl7ybxkkc6afba7")))) |
| 1135 | (build-system julia-build-system) |
| 1136 | (home-page "https://github.com/JuliaData/DataAPI.jl") |
| 1137 | (synopsis "Data-focused namespace for packages to share functions") |
| 1138 | (description "This package provides a namespace for data-related generic |
| 1139 | function definitions to solve the optional dependency problem; packages wishing |
| 1140 | to share and/or extend functions can avoid depending directly on each other by |
| 1141 | moving the function definition to DataAPI.jl and each package taking a |
| 1142 | dependency on it.") |
| 1143 | (license license:expat))) |
| 1144 | |
| 1145 | (define-public julia-dataframes |
| 1146 | (package |
| 1147 | (name "julia-dataframes") |
| 1148 | (version "1.2.2") |
| 1149 | (source |
| 1150 | (origin |
| 1151 | (method git-fetch) |
| 1152 | (uri (git-reference |
| 1153 | (url "https://github.com/JuliaData/DataFrames.jl") |
| 1154 | (commit (string-append "v" version)))) |
| 1155 | (file-name (git-file-name name version)) |
| 1156 | (sha256 |
| 1157 | (base32 "1bk0amrghgjrkyn1mm4ac23swwbgszl1d0qyl9137qj5zvv9dasp")))) |
| 1158 | (build-system julia-build-system) |
| 1159 | (arguments |
| 1160 | (list |
| 1161 | #:phases |
| 1162 | #~(modify-phases %standard-phases |
| 1163 | (add-after 'link-depot 'skip-failing-test |
| 1164 | (lambda _ |
| 1165 | ;; Tests with non-standard colors. |
| 1166 | (substitute* "test/show.jl" |
| 1167 | (("test (sprint\\(show, df, context=:color=>true)" _ test) |
| 1168 | (string-append "test_nowarn " test))) |
| 1169 | (substitute* "test/io.jl" |
| 1170 | (("testset \\\"improved.*" all) |
| 1171 | (string-append all "return\n"))) |
| 1172 | (substitute* "test/join.jl" |
| 1173 | (("test (levels\\(outerjoin\\(B)" _ test) |
| 1174 | (string-append "test_nowarn " test)))))))) |
| 1175 | (propagated-inputs |
| 1176 | (list julia-dataapi |
| 1177 | julia-invertedindices |
| 1178 | julia-iteratorinterfaceextensions |
| 1179 | julia-missings |
| 1180 | julia-pooledarrays |
| 1181 | julia-prettytables |
| 1182 | julia-reexport |
| 1183 | julia-sortingalgorithms |
| 1184 | julia-tables |
| 1185 | julia-tabletraits)) |
| 1186 | (native-inputs |
| 1187 | (list julia-categoricalarrays |
| 1188 | julia-combinatorics |
| 1189 | julia-datastructures |
| 1190 | julia-datavalues |
| 1191 | julia-offsetarrays |
| 1192 | julia-unitful)) |
| 1193 | (home-page "https://dataframes.juliadata.org/stable/") |
| 1194 | (synopsis "In-memory tabular data") |
| 1195 | (description "This package provides a set of tools for working with tabular |
| 1196 | data in Julia. Its design and functionality are similar to those of Pandas from |
| 1197 | Python or @code{data.frame}, @code{data.table} and @code{dplyr} from R, making |
| 1198 | it a great general purpose data science tool, especially for those coming to |
| 1199 | Julia from R or Python.") |
| 1200 | (license license:expat))) |
| 1201 | |
| 1202 | (define-public julia-datastructures |
| 1203 | (package |
| 1204 | (name "julia-datastructures") |
| 1205 | (version "0.18.9") |
| 1206 | (source |
| 1207 | (origin |
| 1208 | (method git-fetch) |
| 1209 | (uri (git-reference |
| 1210 | (url "https://github.com/JuliaCollections/DataStructures.jl") |
| 1211 | (commit (string-append "v" version)))) |
| 1212 | (file-name (git-file-name name version)) |
| 1213 | (sha256 |
| 1214 | (base32 "0hdqp8ipsqdw5bqqkdvz4j6n67x80sj5azr9vzyxwjfsgkfbnk2l")))) |
| 1215 | (propagated-inputs |
| 1216 | (list julia-compat |
| 1217 | julia-orderedcollections)) |
| 1218 | (build-system julia-build-system) |
| 1219 | (arguments |
| 1220 | (list |
| 1221 | #:phases |
| 1222 | (if (target-x86-32?) |
| 1223 | #~(modify-phases %standard-phases |
| 1224 | (add-after 'unpack 'remove-failing-test-i686 |
| 1225 | (lambda _ |
| 1226 | ;; The evaluation returns the correct value, |
| 1227 | ;; Evaluated: "Accumulator(1 => 3, 3 => 4)" |
| 1228 | ;; but, for some reasons, is considered as failed. |
| 1229 | (substitute* "test/test_accumulator.jl" |
| 1230 | (("@test sprint\\(show,Accumulator\\(1 => 3, 3 => 4\\)\\)") |
| 1231 | "@test_broken sprint(show, Accumulator(1 => 3, 3 => 4))"))))) |
| 1232 | #~%standard-phases))) |
| 1233 | (home-page "https://github.com/JuliaCollections/DataStructures.jl") |
| 1234 | (synopsis "Julia module providing different data structures") |
| 1235 | (description "This package implements a variety of data structures, |
| 1236 | including, @code{CircularBuffer}, @code{Queue}, @code{Stack}, |
| 1237 | @code{Accumulators}, @code{LinkedLists}, @code{SortedDicts} and many others.") |
| 1238 | (license license:expat))) |
| 1239 | |
| 1240 | (define-public julia-datavalueinterfaces |
| 1241 | (package |
| 1242 | (name "julia-datavalueinterfaces") |
| 1243 | (version "1.0.0") |
| 1244 | (source |
| 1245 | (origin |
| 1246 | (method git-fetch) |
| 1247 | (uri (git-reference |
| 1248 | (url "https://github.com/queryverse/DataValueInterfaces.jl") |
| 1249 | (commit (string-append "v" version)))) |
| 1250 | (file-name (git-file-name name version)) |
| 1251 | (sha256 |
| 1252 | (base32 "0g2wj6q7jj956nx6g7dk8x7w1c4l2xcmnr1kq5x8s8fild9kslg8")))) |
| 1253 | (build-system julia-build-system) |
| 1254 | (home-page "https://github.com/queryverse/DataValueInterfaces.jl") |
| 1255 | (synopsis "Interface for DataValues.jl") |
| 1256 | (description "This package allows a few \"forward\" definitions for the |
| 1257 | @code{DataValues.jl} package that other packages can utilize for integration |
| 1258 | without having to take direct dependencies.") |
| 1259 | (license license:expat))) |
| 1260 | |
| 1261 | (define-public julia-datavalues |
| 1262 | (package |
| 1263 | (name "julia-datavalues") |
| 1264 | (version "0.4.13") |
| 1265 | (source |
| 1266 | (origin |
| 1267 | (method git-fetch) |
| 1268 | (uri (git-reference |
| 1269 | (url "https://github.com/queryverse/DataValues.jl") |
| 1270 | (commit (string-append "v" version)))) |
| 1271 | (file-name (git-file-name name version)) |
| 1272 | (sha256 |
| 1273 | (base32 "15j3hrqq6nazn533bfsvg32xznacbzsl303j1qs48av59ppnvhhv")))) |
| 1274 | (build-system julia-build-system) |
| 1275 | (arguments |
| 1276 | (list |
| 1277 | #:tests? #f ; Tests need upgrading with newer Julia version. |
| 1278 | #:phases |
| 1279 | #~(modify-phases %standard-phases |
| 1280 | (add-after 'link-depot 'skip-known-failing-tests |
| 1281 | (lambda _ |
| 1282 | ;; See upstream report: |
| 1283 | ;; https://github.com/queryverse/DataValues.jl/issues/83 |
| 1284 | (substitute* "test/array/test_reduce.jl" |
| 1285 | ((".*DataValue\\(mapreduce.*") "") |
| 1286 | ((".*DataValue\\(method\\(f.*") ""))))))) |
| 1287 | (propagated-inputs |
| 1288 | (list julia-datavalueinterfaces)) |
| 1289 | (home-page "https://github.com/queryverse/DataValues.jl") |
| 1290 | (synopsis "Missing values for Julia") |
| 1291 | (description "This package provides the type @code{DataValue} that is used |
| 1292 | to represent missing data.") |
| 1293 | (license license:expat))) |
| 1294 | |
| 1295 | (define-public julia-deepdiffs |
| 1296 | (package |
| 1297 | (name "julia-deepdiffs") |
| 1298 | (version "1.2.0") |
| 1299 | (source |
| 1300 | (origin |
| 1301 | (method git-fetch) |
| 1302 | (uri (git-reference |
| 1303 | (url "https://github.com/ssfrr/DeepDiffs.jl") |
| 1304 | (commit (string-append "v" version)))) |
| 1305 | (file-name (git-file-name name version)) |
| 1306 | (sha256 |
| 1307 | (base32 "1gsbxb1d67g05h5bvzz3swdfih6404jrydy724a8dvbdgqvm3sds")))) |
| 1308 | (build-system julia-build-system) |
| 1309 | (home-page "https://github.com/ssfrr/DeepDiffs.jl") |
| 1310 | (synopsis "Compute and pretty-print diffs for data structures") |
| 1311 | (description "@code{DeepDiffs.jl} provides the @code{deepdiff} function, |
| 1312 | which finds and displays differences (diffs) between Julia data structures. It |
| 1313 | supports @code{Vectors}, @code{Dicts}, and @code{String}s. When diffing |
| 1314 | dictionaries where values associated with a particular key may change, |
| 1315 | @code{deepdiff} will recurse into value to provide a more detailed diff.") |
| 1316 | (license license:expat))) |
| 1317 | |
| 1318 | (define-public julia-dictionaries |
| 1319 | (package |
| 1320 | (name "julia-dictionaries") |
| 1321 | (version "0.3.10") |
| 1322 | (source |
| 1323 | (origin |
| 1324 | (method git-fetch) |
| 1325 | (uri (git-reference |
| 1326 | (url "https://github.com/andyferris/Dictionaries.jl") |
| 1327 | (commit (string-append "v" version)))) |
| 1328 | (file-name (git-file-name name version)) |
| 1329 | (sha256 |
| 1330 | (base32 "1mm43hm8hd6sgmkkpqhbqhvap7mpkjwzmz5algxi6manp580gkr5")))) |
| 1331 | (build-system julia-build-system) |
| 1332 | (propagated-inputs |
| 1333 | (list julia-indexing)) |
| 1334 | (home-page "https://github.com/andyferris/Dictionaries.jl") |
| 1335 | (synopsis "Alternative interface for dictionaries in Julia") |
| 1336 | (description "This package provides an alternative interface for |
| 1337 | dictionaries in Julia, for improved productivity and performance.") |
| 1338 | (license license:expat))) |
| 1339 | |
| 1340 | (define-public julia-distances |
| 1341 | (package |
| 1342 | (name "julia-distances") |
| 1343 | (version "0.10.3") |
| 1344 | (source |
| 1345 | (origin |
| 1346 | (method git-fetch) |
| 1347 | (uri (git-reference |
| 1348 | (url "https://github.com/JuliaStats/Distances.jl") |
| 1349 | (commit (string-append "v" version)))) |
| 1350 | (file-name (git-file-name name version)) |
| 1351 | (sha256 |
| 1352 | (base32 "1yqd9wg4z15k42mrp4y14j2x0sq7yrjhm5zpqklrw6w6j1c367ig")))) |
| 1353 | (build-system julia-build-system) |
| 1354 | (arguments |
| 1355 | (list |
| 1356 | #:phases |
| 1357 | #~(modify-phases %standard-phases |
| 1358 | (add-after 'link-depot 'skip-flakey-tests |
| 1359 | (lambda _ |
| 1360 | ;; Some combination of these tests fail nondeterministically |
| 1361 | ;; each of the times this package is built. |
| 1362 | (substitute* "test/test_dists.jl" |
| 1363 | (("test dyz ≥") "test_nowarn dyz ≥") |
| 1364 | (("test dist\\(y, x") "test_nowarn dist(y, x") |
| 1365 | (("test dist\\(z, x") "test_nowarn dist(z, x") |
| 1366 | (("test dist\\(z, y") "test_nowarn dist(z, y"))))))) |
| 1367 | (propagated-inputs |
| 1368 | (list julia-statsapi)) |
| 1369 | (native-inputs |
| 1370 | (list julia-offsetarrays |
| 1371 | julia-unitful)) |
| 1372 | (home-page "https://github.com/JuliaStats/Distances.jl") |
| 1373 | (synopsis "Julia package for evaluating distances (metrics) between vectors") |
| 1374 | (description "A Julia package for evaluating distances(metrics) between |
| 1375 | vectors. This package also provides optimized functions to compute column-wise |
| 1376 | and pairwise distances, which are often substantially faster than a |
| 1377 | straightforward loop implementation.") |
| 1378 | (license license:expat))) |
| 1379 | |
| 1380 | (define-public julia-docstringextensions |
| 1381 | (package |
| 1382 | (name "julia-docstringextensions") |
| 1383 | (version "0.8.5") |
| 1384 | (source |
| 1385 | (origin |
| 1386 | (method git-fetch) |
| 1387 | (uri (git-reference |
| 1388 | (url "https://github.com/JuliaDocs/DocStringExtensions.jl") |
| 1389 | (commit (string-append "v" version)))) |
| 1390 | (file-name (git-file-name name version)) |
| 1391 | (sha256 |
| 1392 | (base32 "0fy4kfnfacyfmlly6nqxn77dk2gqw80b69zb4m1i0i39zv3cpqfb")))) |
| 1393 | (build-system julia-build-system) |
| 1394 | (arguments |
| 1395 | (list #:tests? #f)) ; Tests try to read SSL certificates. |
| 1396 | (home-page "https://juliadocs.github.io/DocStringExtensions.jl/latest/") |
| 1397 | (synopsis "Extensions for Julia's docsystem") |
| 1398 | (description "This package provides a collection of useful extensions for |
| 1399 | Julia's built-in docsystem. These are features that are not yet mature enough |
| 1400 | to be considered for inclusion in Base, or that have sufficiently niche use |
| 1401 | cases that including them with the default Julia installation is not seen as |
| 1402 | valuable enough at this time.") |
| 1403 | (license license:expat))) |
| 1404 | |
| 1405 | ;; By removing all the javascript and css downloads any HTML documentation |
| 1406 | ;; produced by this package will not be very useful. |
| 1407 | (define-public julia-documenter |
| 1408 | (package |
| 1409 | (name "julia-documenter") |
| 1410 | (version "0.27.7") |
| 1411 | (source |
| 1412 | (origin |
| 1413 | (method git-fetch) |
| 1414 | (uri (git-reference |
| 1415 | (url "https://github.com/JuliaDocs/Documenter.jl") |
| 1416 | (commit (string-append "v" version)))) |
| 1417 | (file-name (git-file-name name version)) |
| 1418 | (sha256 |
| 1419 | (base32 "00ai3c24i3fkn5plmavampcxm0ijhwk0v5cn9xwm7rvbjnnvaaam")))) |
| 1420 | (build-system julia-build-system) |
| 1421 | (arguments |
| 1422 | (list |
| 1423 | #:phases |
| 1424 | #~(modify-phases %standard-phases |
| 1425 | (add-after 'link-depot 'patch-source |
| 1426 | (lambda* (#:key inputs #:allow-other-keys) |
| 1427 | (substitute* "src/Deps.jl" |
| 1428 | (("pip install") |
| 1429 | (string-append (search-input-file inputs "bin/pip") |
| 1430 | " install"))))) |
| 1431 | (add-after 'link-depot 'remove-javascript-downloads |
| 1432 | (lambda _ |
| 1433 | (substitute* "src/Writers/HTMLWriter.jl" |
| 1434 | (("cdnjs.cloudflare.com") "example.com")) |
| 1435 | ;; Removing the javascript downloads causes these tests fail. |
| 1436 | (substitute* "test/examples/tests.jl" |
| 1437 | ((".*Main\\.examples_html_doc.*") "") |
| 1438 | ((".*Main\\.examples_html_mathjax3_doc.*") ""))))))) |
| 1439 | (propagated-inputs |
| 1440 | (list julia-ansicoloredprinters |
| 1441 | julia-docstringextensions |
| 1442 | julia-iocapture |
| 1443 | julia-json)) |
| 1444 | (inputs |
| 1445 | (list python-wrapper)) |
| 1446 | (native-inputs |
| 1447 | (list git-minimal |
| 1448 | julia-documentermarkdown |
| 1449 | julia-documentertools)) |
| 1450 | (home-page "https://juliadocs.github.io/Documenter.jl") |
| 1451 | (synopsis "Documentation generator for Julia") |
| 1452 | (description "This package provides a documentation generator for Julia.") |
| 1453 | (license license:expat))) |
| 1454 | |
| 1455 | (define julia-documenter-bootstrap |
| 1456 | (package |
| 1457 | (inherit julia-documenter) |
| 1458 | (name "julia-documenter-bootstrap") |
| 1459 | (arguments |
| 1460 | (substitute-keyword-arguments (package-arguments julia-documenter) |
| 1461 | ((#:phases phases) |
| 1462 | `(modify-phases ,phases |
| 1463 | (delete 'patch-source))) |
| 1464 | ;; Not all dependencies available in bootstrap version. |
| 1465 | ((#:tests? _ #f) #f))) |
| 1466 | (inputs `()) |
| 1467 | (native-inputs `()))) |
| 1468 | |
| 1469 | (define-public julia-documentermarkdown |
| 1470 | (package |
| 1471 | (name "julia-documentermarkdown") |
| 1472 | (version "0.2.2") |
| 1473 | (source |
| 1474 | (origin |
| 1475 | (method git-fetch) |
| 1476 | (uri (git-reference |
| 1477 | (url "https://github.com/JuliaDocs/DocumenterMarkdown.jl") |
| 1478 | (commit (string-append "v" version)))) |
| 1479 | (file-name (git-file-name name version)) |
| 1480 | (sha256 |
| 1481 | (base32 "0sx89hi5p2f8zi2rp5qrv06m270d90pxj5d2y5cxls1spax7wqx8")))) |
| 1482 | (build-system julia-build-system) |
| 1483 | (inputs |
| 1484 | ;; We don't want to propagate the bootstrap version. |
| 1485 | ;; Cycle with Documenter.jl in later versions. |
| 1486 | (list julia-documenter-bootstrap)) |
| 1487 | (home-page "https://github.com/JuliaDocs/DocumenterMarkdown.jl") |
| 1488 | (synopsis "Documenter's Markdown") |
| 1489 | (description "This package enables the Markdown / MkDocs backend of |
| 1490 | @code{Documenter.jl}.") |
| 1491 | (license license:expat))) |
| 1492 | |
| 1493 | (define-public julia-documentertools |
| 1494 | (package |
| 1495 | (name "julia-documentertools") |
| 1496 | (version "0.1.13") |
| 1497 | (source |
| 1498 | (origin |
| 1499 | (method git-fetch) |
| 1500 | (uri (git-reference |
| 1501 | (url "https://github.com/JuliaDocs/DocumenterTools.jl") |
| 1502 | (commit (string-append "v" version)))) |
| 1503 | (file-name (git-file-name name version)) |
| 1504 | (sha256 |
| 1505 | (base32 "05p57p8xlkn42m1lv9gq4hl96vp7hpj19d51p828ai1rbpcpi3a6")))) |
| 1506 | (build-system julia-build-system) |
| 1507 | (arguments |
| 1508 | (list #:tests? #f)) ; Tests require network. |
| 1509 | (inputs |
| 1510 | ;; We don't want to propagate the bootstrap version. |
| 1511 | ;; Cycle with Documenter.jl in later versions. |
| 1512 | (list julia-documenter-bootstrap)) |
| 1513 | (propagated-inputs |
| 1514 | (list julia-docstringextensions |
| 1515 | julia-gumbo |
| 1516 | julia-sass)) |
| 1517 | (native-inputs |
| 1518 | (list julia-example)) |
| 1519 | (home-page "https://github.com/JuliaDocs/DocumenterTools.jl") |
| 1520 | (synopsis "Extra tools for setting up Documenter.jl") |
| 1521 | (description "This package contains utilities for setting up documentation |
| 1522 | generation with @code{Documenter.jl}.") |
| 1523 | (license license:expat))) |
| 1524 | |
| 1525 | (define-public julia-diffresults |
| 1526 | (package |
| 1527 | (name "julia-diffresults") |
| 1528 | (version "1.0.3") |
| 1529 | (source |
| 1530 | (origin |
| 1531 | (method git-fetch) |
| 1532 | (uri (git-reference |
| 1533 | (url "https://github.com/JuliaDiff/DiffResults.jl") |
| 1534 | (commit (string-append "v" version)))) |
| 1535 | (file-name (git-file-name name version)) |
| 1536 | (sha256 |
| 1537 | (base32 "1w6p3yxajvclax5b9g7cr2jmbc7lvr5nk4gq0aljxdycdq1d2y3v")))) |
| 1538 | (build-system julia-build-system) |
| 1539 | (propagated-inputs |
| 1540 | (list julia-staticarrays)) |
| 1541 | (home-page "https://github.com/JuliaDiff/DiffResults.jl") |
| 1542 | (synopsis "In-place differentiation methods of primal values at multi-order") |
| 1543 | (description "This package provides the @code{DiffResult} type, which can |
| 1544 | be passed to in-place differentiation methods instead of an output buffer.") |
| 1545 | (license license:expat))) |
| 1546 | |
| 1547 | (define-public julia-diffrules |
| 1548 | (package |
| 1549 | (name "julia-diffrules") |
| 1550 | (version "1.0.2") |
| 1551 | (source |
| 1552 | (origin |
| 1553 | (method git-fetch) |
| 1554 | (uri (git-reference |
| 1555 | (url "https://github.com/JuliaDiff/DiffRules.jl") |
| 1556 | (commit (string-append "v" version)))) |
| 1557 | (file-name (git-file-name name version)) |
| 1558 | (sha256 |
| 1559 | (base32 "0cwjvj4gma7924fm3yas0nf0jlnwwx4v7fi79ii3s290lkdldzfl")))) |
| 1560 | (build-system julia-build-system) |
| 1561 | (propagated-inputs |
| 1562 | (list julia-nanmath |
| 1563 | julia-specialfunctions)) |
| 1564 | (home-page "https://github.com/JuliaDiff/DiffRules.jl") |
| 1565 | (synopsis "Primitive differentiation rules") |
| 1566 | (description "This package provides primitive differentiation rules that |
| 1567 | can be composed via various formulations of the chain rule. Using |
| 1568 | @code{DiffRules}, new differentiation rules can defined, query whether or not |
| 1569 | a given rule exists, and symbolically apply rules to simple Julia expressions.") |
| 1570 | (license license:expat))) |
| 1571 | |
| 1572 | (define-public julia-difftests |
| 1573 | (package |
| 1574 | (name "julia-difftests") |
| 1575 | (version "0.1.1") |
| 1576 | (source |
| 1577 | (origin |
| 1578 | (method git-fetch) |
| 1579 | (uri (git-reference |
| 1580 | (url "https://github.com/JuliaDiff/DiffTests.jl") |
| 1581 | (commit (string-append "v" version)))) |
| 1582 | (file-name (git-file-name name version)) |
| 1583 | (sha256 |
| 1584 | (base32 "1rxpnd5zi3pxgdd38l5jm2sxc3q6p7g57fqgll2dsiin07y3my57")))) |
| 1585 | (build-system julia-build-system) |
| 1586 | (home-page "https://github.com/JuliaDiff/DiffTests.jl") |
| 1587 | (synopsis "Common test functions for differentiation tools") |
| 1588 | (description "This package contains a common suite of test functions for |
| 1589 | stressing the robustness of differentiation tools.") |
| 1590 | (license license:expat))) |
| 1591 | |
| 1592 | (define-public julia-dualnumbers |
| 1593 | (package |
| 1594 | (name "julia-dualnumbers") |
| 1595 | (version "0.6.5") |
| 1596 | (source |
| 1597 | (origin |
| 1598 | (method git-fetch) |
| 1599 | (uri (git-reference |
| 1600 | (url "https://github.com/JuliaDiff/DualNumbers.jl") |
| 1601 | (commit (string-append "v" version)))) |
| 1602 | (file-name (git-file-name name version)) |
| 1603 | (sha256 |
| 1604 | (base32 "05vr5wbzqpchnb96b3pmn67x196mbfnkv7r9bdlz3gm56if4awk5")))) |
| 1605 | (build-system julia-build-system) |
| 1606 | (arguments |
| 1607 | (list |
| 1608 | #:phases |
| 1609 | #~(modify-phases %standard-phases |
| 1610 | (add-after 'link-depot 'adjust-test-suite |
| 1611 | (lambda _ |
| 1612 | (substitute* "test/runtests.jl" |
| 1613 | ;; Seems to not play nicely with SpecialFunctions |
| 1614 | ((".*isempty.*") ""))))))) |
| 1615 | (propagated-inputs |
| 1616 | (list julia-calculus |
| 1617 | julia-nanmath |
| 1618 | julia-specialfunctions)) |
| 1619 | (home-page "https://github.com/JuliaDiff/DualNumbers.jl") |
| 1620 | (synopsis "Represent dual numbers and for perform dual algebra") |
| 1621 | (description "The @code{DualNumbers} Julia package defines the @code{Dual} |
| 1622 | type to represent dual numbers, and supports standard mathematical operations on |
| 1623 | them. Conversions and promotions are defined to allow performing operations on |
| 1624 | combinations of dual numbers with predefined Julia numeric types.") |
| 1625 | (license license:expat))) |
| 1626 | |
| 1627 | (define-public julia-ellipsisnotation |
| 1628 | (package |
| 1629 | (name "julia-ellipsisnotation") |
| 1630 | (version "1.1.0") |
| 1631 | (source |
| 1632 | (origin |
| 1633 | (method git-fetch) |
| 1634 | (uri (git-reference |
| 1635 | (url "https://github.com/ChrisRackauckas/EllipsisNotation.jl") |
| 1636 | (commit (string-append "v" version)))) |
| 1637 | (file-name (git-file-name name version)) |
| 1638 | (sha256 |
| 1639 | (base32 "0py46kxl702r8pw3v7x4cqllf7yc91b0dr7vb60xh2qi7d6y3jc7")))) |
| 1640 | (build-system julia-build-system) |
| 1641 | (arguments |
| 1642 | (list |
| 1643 | #:phases |
| 1644 | #~(modify-phases %standard-phases |
| 1645 | (add-after 'link-depot 'adjust-test-suite |
| 1646 | (lambda _ |
| 1647 | (substitute* "test/runtests.jl" |
| 1648 | ;; Seems to not play nicely with Julia-1.6. |
| 1649 | ((".*basic.jl.*") ""))))))) |
| 1650 | (propagated-inputs |
| 1651 | (list julia-arrayinterface)) |
| 1652 | (home-page "https://github.com/ChrisRackauckas/EllipsisNotation.jl") |
| 1653 | (synopsis "Elipsis notation implementation") |
| 1654 | (description "This implements the notation @code{..} for indexing arrays. |
| 1655 | It's similar to the Python @code{...} in that it means \"all of the columns |
| 1656 | before (or after)\".") |
| 1657 | (license license:expat))) |
| 1658 | |
| 1659 | (define-public julia-example |
| 1660 | (let ((commit "f968c69dea24f851d0c7e686db23fa55826b5388")) |
| 1661 | (package |
| 1662 | (name "julia-example") |
| 1663 | (version "0.5.4") ;tag not created upstream |
| 1664 | (source |
| 1665 | (origin |
| 1666 | (method git-fetch) |
| 1667 | (uri (git-reference |
| 1668 | (url "https://github.com/JuliaLang/Example.jl") |
| 1669 | (commit commit))) |
| 1670 | (file-name (git-file-name name version)) |
| 1671 | (sha256 |
| 1672 | (base32 "1v3z0d6gh6wfbypffy9m9rhh36px6fm5wjzq0y6rbmc95r0qpqlx")))) |
| 1673 | (build-system julia-build-system) |
| 1674 | (home-page "https://github.com/JuliaLang/Example.jl") |
| 1675 | (synopsis "Module providing examples") |
| 1676 | (description "This package provides various examples.") |
| 1677 | (license license:expat)))) |
| 1678 | |
| 1679 | ;; ExproniconLite.jl is autogenerated from this package. |
| 1680 | (define-public julia-expronicon |
| 1681 | (package |
| 1682 | (name "julia-expronicon") |
| 1683 | (version "0.6.10") |
| 1684 | (source |
| 1685 | (origin |
| 1686 | (method git-fetch) |
| 1687 | (uri (git-reference |
| 1688 | (url "https://github.com/Roger-luo/Expronicon.jl") |
| 1689 | (commit (string-append "v" version)))) |
| 1690 | (file-name (git-file-name name version)) |
| 1691 | (sha256 |
| 1692 | (base32 "0h8aaynqlxrkn8575k5vqmhzil4vvxchhf0bcxa6zwawp558gj2y")))) |
| 1693 | (build-system julia-build-system) |
| 1694 | (arguments |
| 1695 | (list |
| 1696 | #:phases |
| 1697 | #~(modify-phases %standard-phases |
| 1698 | (add-after 'link-depot 'skip-network-tests |
| 1699 | (lambda _ |
| 1700 | (substitute* "test/runtests.jl" |
| 1701 | ;; This test tries to access the Julia package registry. |
| 1702 | ((".*expand\\.jl.*") ""))))))) |
| 1703 | (propagated-inputs |
| 1704 | (list julia-mlstyle)) |
| 1705 | (native-inputs |
| 1706 | (list julia-documenter)) |
| 1707 | (home-page "https://expronicon.rogerluo.dev/dev/") |
| 1708 | (synopsis "Collective tools for metaprogramming on Julia Expr") |
| 1709 | (description "This package provides a collection of tools for |
| 1710 | metaprogramming on Julia Expr, the meta programming standard library for |
| 1711 | @code{MLStyle}.") |
| 1712 | (license license:expat))) |
| 1713 | |
| 1714 | (define-public julia-exprtools |
| 1715 | (package |
| 1716 | (name "julia-exprtools") |
| 1717 | (version "0.1.6") |
| 1718 | (source |
| 1719 | (origin |
| 1720 | (method git-fetch) |
| 1721 | (uri (git-reference |
| 1722 | (url "https://github.com/invenia/ExprTools.jl") |
| 1723 | (commit (string-append "v" version)))) |
| 1724 | (file-name (git-file-name name version)) |
| 1725 | (sha256 |
| 1726 | (base32 "058ax5d96jpym5w3g37ah1c4xq3fskwpjdhchakzax15vqzy7ab4")))) |
| 1727 | (build-system julia-build-system) |
| 1728 | (home-page "https://github.com/invenia/ExprTools.jl") |
| 1729 | (synopsis "Light-weight expression manipulation tools") |
| 1730 | (description "@code{ExprTools} provides tooling for working with Julia |
| 1731 | expressions during metaprogramming. This package aims to provide light-weight |
| 1732 | performant tooling without requiring additional package dependencies.") |
| 1733 | (license license:expat))) |
| 1734 | |
| 1735 | (define-public julia-ffmpeg |
| 1736 | (package |
| 1737 | (name "julia-ffmpeg") |
| 1738 | (version "0.4.1") |
| 1739 | (source |
| 1740 | (origin |
| 1741 | (method git-fetch) |
| 1742 | (uri (git-reference |
| 1743 | (url "https://github.com/JuliaIO/FFMPEG.jl") |
| 1744 | (commit (string-append "v" version)))) |
| 1745 | (file-name (git-file-name name version)) |
| 1746 | (sha256 |
| 1747 | (base32 "1ldxbp0kq3ip67x7sp82dz56aq4p5i0chspbgx2zgskr6jcbjj1b")))) |
| 1748 | (build-system julia-build-system) |
| 1749 | (propagated-inputs |
| 1750 | (list julia-ffmpeg-jll |
| 1751 | julia-x264-jll)) |
| 1752 | (home-page "https://github.com/JuliaIO/FFMPEG.jl") |
| 1753 | (synopsis "Julia Package for ffmpeg") |
| 1754 | (description "This package is made to be included into packages that just |
| 1755 | need the ffmpeg binaries + executables, and don't want the overhead of |
| 1756 | @code{VideoIO.jl}.") |
| 1757 | (license license:expat))) |
| 1758 | |
| 1759 | (define-public julia-fileio |
| 1760 | (package |
| 1761 | (name "julia-fileio") |
| 1762 | (version "1.9.1") |
| 1763 | (source |
| 1764 | (origin |
| 1765 | (method git-fetch) |
| 1766 | (uri (git-reference |
| 1767 | (url "https://github.com/JuliaIO/FileIO.jl") |
| 1768 | (commit (string-append "v" version)))) |
| 1769 | (file-name (git-file-name name version)) |
| 1770 | (sha256 |
| 1771 | (base32 "1b18x43i737g5q41n9818xbnc2pgd98q1m6yw3h29yri0clg4gfx")))) |
| 1772 | (build-system julia-build-system) |
| 1773 | (arguments |
| 1774 | (list |
| 1775 | #:phases |
| 1776 | #~(modify-phases %standard-phases |
| 1777 | (delete 'reset-gzip-timestamps) |
| 1778 | (add-after 'link-depot 'skip-network-tests |
| 1779 | (lambda _ |
| 1780 | ;; These tests try to download audio/video files. |
| 1781 | (substitute* "test/query.jl" |
| 1782 | (("testset.*(MP4|OGG|MATROSKA).*" all) |
| 1783 | (string-append all "return\n"))) |
| 1784 | (substitute* "test/loadsave.jl" |
| 1785 | (("testset.*CSVFiles.*" all) |
| 1786 | (string-append all "return\n"))) |
| 1787 | ;; This test tries to download a Julia package. |
| 1788 | (substitute* "test/error_handling.jl" |
| 1789 | (("testset.*Not installed.*" all) |
| 1790 | (string-append all "return\n"))) |
| 1791 | ;; This test tries to write to the store. |
| 1792 | ;; (Error says can't find User 0) |
| 1793 | (substitute* "test/runtests.jl" |
| 1794 | ((".*test_mimesave.*") ""))))))) |
| 1795 | (propagated-inputs |
| 1796 | (list julia-requires)) |
| 1797 | (native-inputs |
| 1798 | (list julia-colortypes |
| 1799 | julia-filepathsbase |
| 1800 | julia-http)) |
| 1801 | (home-page "https://github.com/JuliaIO/FileIO.jl") |
| 1802 | (synopsis "Main Package for IO, loading all different kind of files") |
| 1803 | (description "@code{FileIO} aims to provide a common framework for detecting |
| 1804 | file formats and dispatching to appropriate readers/writers. The two core |
| 1805 | functions in this package are called @code{load} and @code{save}, and offer |
| 1806 | high-level support for formatted files (in contrast with Julia's low-level |
| 1807 | @code{read} and @code{write}).") |
| 1808 | (license license:expat))) |
| 1809 | |
| 1810 | (define-public julia-filepathsbase |
| 1811 | (package |
| 1812 | (name "julia-filepathsbase") |
| 1813 | (version "0.9.10") |
| 1814 | (source |
| 1815 | (origin |
| 1816 | (method git-fetch) |
| 1817 | (uri (git-reference |
| 1818 | (url "https://github.com/rofinn/FilePathsBase.jl") |
| 1819 | (commit (string-append "v" version)))) |
| 1820 | (file-name (git-file-name name version)) |
| 1821 | (sha256 |
| 1822 | (base32 "136wm4ik6isrdanmpi4gdr1qw0qhr15i925qzjxbawk5hnyzwng9")))) |
| 1823 | (build-system julia-build-system) |
| 1824 | (arguments |
| 1825 | (list #:tests? #f)) ; Cycle with JLSO.jl |
| 1826 | (home-page "https://github.com/rofinn/FilePathsBase.jl") |
| 1827 | (synopsis "Filesystem path types in Julia") |
| 1828 | (description "@code{FilePathsBase.jl} provides a type based approach to |
| 1829 | working with filesystem paths in Julia.") |
| 1830 | (license license:expat))) |
| 1831 | |
| 1832 | (define-public julia-fillarrays |
| 1833 | (package |
| 1834 | (name "julia-fillarrays") |
| 1835 | (version "0.12.6") |
| 1836 | (source |
| 1837 | (origin |
| 1838 | (method git-fetch) |
| 1839 | (uri (git-reference |
| 1840 | (url "https://github.com/JuliaArrays/FillArrays.jl") |
| 1841 | (commit (string-append "v" version)))) |
| 1842 | (file-name (git-file-name name version)) |
| 1843 | (sha256 |
| 1844 | (base32 "1sx96pzrgyh8k7x2w8vmyi6cazlmp7rg1n7wbl47qfzqjggka6kz")))) |
| 1845 | (build-system julia-build-system) |
| 1846 | (inputs ;required by tests |
| 1847 | (list julia-staticarrays)) |
| 1848 | (home-page "https://github.com/JuliaArrays/FillArrays.jl") |
| 1849 | (synopsis "Lazy matrix representation") |
| 1850 | (description "This package lazily represents matrices filled with |
| 1851 | a single entry, as well as identity matrices. This package exports the |
| 1852 | following types: @code{Eye}, @code{Fill}, @code{Ones}, @code{Zeros}, |
| 1853 | @code{Trues} and @code{Falses}.") |
| 1854 | (license license:expat))) |
| 1855 | |
| 1856 | (define-public julia-finitediff |
| 1857 | (package |
| 1858 | (name "julia-finitediff") |
| 1859 | (version "2.8.1") |
| 1860 | (source |
| 1861 | (origin |
| 1862 | (method git-fetch) |
| 1863 | (uri (git-reference |
| 1864 | (url "https://github.com/JuliaDiff/FiniteDiff.jl") |
| 1865 | (commit (string-append "v" version)))) |
| 1866 | (file-name (git-file-name name version)) |
| 1867 | (sha256 |
| 1868 | (base32 "105f6r0hq97n9mxf1nacmz94dpca66vzqj5p3zh4h0brshmggqnq")))) |
| 1869 | (build-system julia-build-system) |
| 1870 | (arguments |
| 1871 | (list |
| 1872 | #:phases |
| 1873 | #~(modify-phases %standard-phases |
| 1874 | (add-before 'check 'pre-check |
| 1875 | (lambda _ |
| 1876 | ;; We don't want to run all the tests; the Downstream tests |
| 1877 | ;; try to download the package registry. |
| 1878 | (setenv "GROUP" "Core")))))) |
| 1879 | (propagated-inputs |
| 1880 | (list julia-arrayinterface |
| 1881 | julia-requires |
| 1882 | julia-staticarrays)) |
| 1883 | (native-inputs |
| 1884 | (list julia-bandedmatrices |
| 1885 | julia-blockbandedmatrices |
| 1886 | julia-safetestsets)) |
| 1887 | (home-page "https://github.com/JuliaDiff/FiniteDiff.jl") |
| 1888 | (synopsis "Calculations of gradients, Jacobians, and Hessians") |
| 1889 | (description "This package is for calculating derivatives, gradients, |
| 1890 | Jacobians, Hessians, etc. numerically. This library is for maximizing speed |
| 1891 | while giving a usable interface to end users in a way that specializes on array |
| 1892 | types and sparsity.") |
| 1893 | (license license:expat))) |
| 1894 | |
| 1895 | (define-public julia-finitedifferences |
| 1896 | (package |
| 1897 | (name "julia-finitedifferences") |
| 1898 | (version "0.12.17") |
| 1899 | (source |
| 1900 | (origin |
| 1901 | (method git-fetch) |
| 1902 | (uri (git-reference |
| 1903 | (url "https://github.com/JuliaDiff/FiniteDifferences.jl") |
| 1904 | (commit (string-append "v" version)))) |
| 1905 | (file-name (git-file-name name version)) |
| 1906 | (sha256 |
| 1907 | (base32 "09nsf9cgk49yrvprflnhd9h5rrgs280rgj8sad3csghxdx6jqk5c")))) |
| 1908 | (build-system julia-build-system) |
| 1909 | (arguments |
| 1910 | (list |
| 1911 | #:phases |
| 1912 | (if (target-x86-32?) |
| 1913 | #~(modify-phases %standard-phases |
| 1914 | (add-after 'unpack 'remove-failing-test-i686 |
| 1915 | (lambda _ |
| 1916 | ;; Machine Precision incorrectly handled |
| 1917 | (substitute* "test/methods.jl" |
| 1918 | (("@test central_fdm\\(15, 5, adapt=2\\)\\(exp, 1.0\\)") |
| 1919 | "@test_broken central_fdm(15, 5, adapt=2)(exp, 1.0)"))))) |
| 1920 | #~%standard-phases))) |
| 1921 | (inputs |
| 1922 | (list julia-benchmarktools)) |
| 1923 | (propagated-inputs |
| 1924 | (list julia-chainrulescore |
| 1925 | julia-richardson |
| 1926 | julia-staticarrays)) |
| 1927 | (home-page "https://github.com/JuliaDiff/FiniteDifferences.jl") |
| 1928 | (synopsis "Estimates derivatives with finite differences") |
| 1929 | (description "This package calculates approximate derivatives numerically |
| 1930 | using finite difference.") |
| 1931 | (license license:expat))) |
| 1932 | |
| 1933 | (define-public julia-fixedpointnumbers |
| 1934 | (package |
| 1935 | (name "julia-fixedpointnumbers") |
| 1936 | (version "0.8.4") |
| 1937 | (source |
| 1938 | (origin |
| 1939 | (method git-fetch) |
| 1940 | (uri (git-reference |
| 1941 | (url "https://github.com/JuliaMath/FixedPointNumbers.jl") |
| 1942 | (commit (string-append "v" version)))) |
| 1943 | (file-name (git-file-name name version)) |
| 1944 | (sha256 |
| 1945 | (base32 "0j0n40n04q9sk68wh9jq90m6c67k4ws02k41djjzkrqmpzv4rcdi")))) |
| 1946 | (build-system julia-build-system) |
| 1947 | (arguments |
| 1948 | (list |
| 1949 | #:phases |
| 1950 | #~(modify-phases %standard-phases |
| 1951 | (add-after 'link-depot 'disable-failing-test |
| 1952 | (lambda* (#:key outputs #:allow-other-keys) |
| 1953 | (substitute* "test/fixed.jl" |
| 1954 | ;; A deprecation warning is not thrown |
| 1955 | (("@test_logs.*:warn" all) (string-append "# " all)))))))) |
| 1956 | (propagated-inputs |
| 1957 | (list julia-compat)) |
| 1958 | (home-page "https://github.com/JuliaMath/FixedPointNumbers.jl") |
| 1959 | (synopsis "Fixed point types for Julia") |
| 1960 | (description "@code{FixedPointNumbers.jl} implements fixed-point number |
| 1961 | types for Julia. A fixed-point number represents a fractional, or |
| 1962 | non-integral, number. In contrast with the more widely known floating-point |
| 1963 | numbers, with fixed-point numbers the decimal point doesn't \"float\": |
| 1964 | fixed-point numbers are effectively integers that are interpreted as being |
| 1965 | scaled by a constant factor. Consequently, they have a fixed number of |
| 1966 | digits (bits) after the decimal (radix) point.") |
| 1967 | (license license:expat))) |
| 1968 | |
| 1969 | (define-public julia-formatting |
| 1970 | (package |
| 1971 | (name "julia-formatting") |
| 1972 | (version "0.4.2") |
| 1973 | (source |
| 1974 | (origin |
| 1975 | (method git-fetch) |
| 1976 | (uri (git-reference |
| 1977 | (url "https://github.com/JuliaIO/Formatting.jl") |
| 1978 | (commit (string-append "v" version)))) |
| 1979 | (file-name (git-file-name name version)) |
| 1980 | (sha256 |
| 1981 | (base32 "0ma3q9my51rr38bb5712xkc4h3rq0wsfjb4ac6mdh9ywn8rqvrmh")))) |
| 1982 | (build-system julia-build-system) |
| 1983 | (home-page "https://github.com/JuliaIO/Formatting.jl") |
| 1984 | (synopsis "Julia package to provide Python-like formatting support") |
| 1985 | (description "This package offers Python-style general formatting and |
| 1986 | c-style numerical formatting.") |
| 1987 | (license license:expat))) |
| 1988 | |
| 1989 | (define-public julia-forwarddiff |
| 1990 | (package |
| 1991 | (name "julia-forwarddiff") |
| 1992 | (version "0.10.18") |
| 1993 | (source |
| 1994 | (origin |
| 1995 | (method git-fetch) |
| 1996 | (uri (git-reference |
| 1997 | (url "https://github.com/JuliaDiff/ForwardDiff.jl") |
| 1998 | (commit (string-append "v" version)))) |
| 1999 | (file-name (git-file-name name version)) |
| 2000 | (sha256 |
| 2001 | (base32 "1vb46x8mcn61g1l14qrk22c043khg2ml4q1ci7h4k2v34f2ak5fs")))) |
| 2002 | (build-system julia-build-system) |
| 2003 | (arguments |
| 2004 | ;; XXXX: Unexpected and non-deterministic failures for i686, e.g., |
| 2005 | ;; Expression: dual_isapprox(FDNUM ^ PRIMAL, exp(PRIMAL * log(FDNUM))) |
| 2006 | ;; ERROR: LoadError: LoadError: There was an error during testing |
| 2007 | ;; Disable as stopgap. |
| 2008 | (list #:tests? (not (target-x86-32?)))) |
| 2009 | (inputs ;required for tests |
| 2010 | (list julia-calculus |
| 2011 | julia-difftests)) |
| 2012 | (propagated-inputs |
| 2013 | (list julia-commonsubexpressions |
| 2014 | julia-diffresults |
| 2015 | julia-diffrules |
| 2016 | julia-nanmath |
| 2017 | julia-specialfunctions |
| 2018 | julia-staticarrays)) |
| 2019 | (home-page "https://github.com/JuliaDiff/ForwardDiff.jl") |
| 2020 | (synopsis "Methods to take multidimensional derivatives") |
| 2021 | (description "This package implements methods to take derivatives, |
| 2022 | gradients, Jacobians, Hessians, and higher-order derivatives of native Julia |
| 2023 | functions (or any callable object, really) using forward mode automatic |
| 2024 | differentiation (AD).") |
| 2025 | (license license:expat))) |
| 2026 | |
| 2027 | (define-public julia-functionwrappers |
| 2028 | (package |
| 2029 | (name "julia-functionwrappers") |
| 2030 | (version "1.1.2") |
| 2031 | (source |
| 2032 | (origin |
| 2033 | (method git-fetch) |
| 2034 | (uri (git-reference |
| 2035 | (url "https://github.com/yuyichao/FunctionWrappers.jl") |
| 2036 | (commit (string-append "v" version)))) |
| 2037 | (file-name (git-file-name name version)) |
| 2038 | (sha256 |
| 2039 | (base32 "02jilpjr7px6138dx2w7ixricvfgsxqdk84d9dgviranibhnjcxa")))) |
| 2040 | (build-system julia-build-system) |
| 2041 | (arguments |
| 2042 | (list |
| 2043 | #:phases |
| 2044 | #~(modify-phases %standard-phases |
| 2045 | (add-after 'link-depot 'adjust-tests |
| 2046 | (lambda _ |
| 2047 | (substitute* "test/runtests.jl" |
| 2048 | (("testset \\\"Abstract.*" all) |
| 2049 | (string-append all "return\n")))))))) |
| 2050 | (home-page "https://github.com/yuyichao/FunctionWrappers.jl") |
| 2051 | (synopsis "Type stable and efficient wrapper of arbitrary functions") |
| 2052 | (description "This package provides a type stable and efficient wrapper of |
| 2053 | arbitrary functions.") |
| 2054 | (license license:expat))) |
| 2055 | |
| 2056 | (define-public julia-functors |
| 2057 | (package |
| 2058 | (name "julia-functors") |
| 2059 | (version "0.2.7") |
| 2060 | (source |
| 2061 | (origin |
| 2062 | (method git-fetch) |
| 2063 | (uri (git-reference |
| 2064 | (url "https://github.com/FluxML/Functors.jl") |
| 2065 | (commit (string-append "v" version)))) |
| 2066 | (file-name (git-file-name name version)) |
| 2067 | (sha256 |
| 2068 | (base32 "03ry1wn1y2jssq65l29bi6q4ki041aa6gl1nd2w6cgl00k2mrxf3")))) |
| 2069 | (build-system julia-build-system) |
| 2070 | (home-page "https://fluxml.ai/Functors.jl/stable/") |
| 2071 | (synopsis "Design pattern for structures as in machine learning") |
| 2072 | (description "This package provides tools to express a design pattern for |
| 2073 | dealing with large/ nested structures, as in machine learning and |
| 2074 | optimisation. For large machine learning models it can be cumbersome or |
| 2075 | inefficient to work with parameters as one big, flat vector, and structs help |
| 2076 | in managing complexity; but it is also desirable to easily operate over all |
| 2077 | parameters at once, e.g. for changing precision or applying an optimiser |
| 2078 | update step.") |
| 2079 | (license license:expat))) |
| 2080 | |
| 2081 | (define-public julia-fuzzycompletions |
| 2082 | (package |
| 2083 | (name "julia-fuzzycompletions") |
| 2084 | (version "0.4.1") |
| 2085 | (source |
| 2086 | (origin |
| 2087 | (method git-fetch) |
| 2088 | (uri (git-reference |
| 2089 | (url "https://github.com/JunoLab/FuzzyCompletions.jl") |
| 2090 | (commit (string-append "v" version)))) |
| 2091 | (file-name (git-file-name name version)) |
| 2092 | (sha256 |
| 2093 | (base32 "07sv88c472n6w4x7diy952igbcfm1s104ysnnvprld83312siw06")))) |
| 2094 | (build-system julia-build-system) |
| 2095 | (arguments |
| 2096 | (list |
| 2097 | #:phases |
| 2098 | #~(modify-phases %standard-phases |
| 2099 | (add-after 'link-depot 'skip-failing-test |
| 2100 | (lambda _ |
| 2101 | (substitute* "test/runtests.jl" |
| 2102 | ((".*RPLE.*") ""))))))) |
| 2103 | (home-page "https://github.com/JunoLab/FuzzyCompletions.jl") |
| 2104 | (synopsis "Fuzzy completion provider for Julia") |
| 2105 | (description |
| 2106 | "FuzzyCompletions provides fuzzy completions for a Julia runtime session.") |
| 2107 | (license license:expat))) |
| 2108 | |
| 2109 | (define-public julia-genericlinearalgebra |
| 2110 | (package |
| 2111 | (name "julia-genericlinearalgebra") |
| 2112 | (version "0.2.5") |
| 2113 | (source |
| 2114 | (origin |
| 2115 | (method git-fetch) |
| 2116 | (uri (git-reference |
| 2117 | (url "https://github.com/JuliaLinearAlgebra/GenericLinearAlgebra.jl") |
| 2118 | (commit (string-append "v" version)))) |
| 2119 | (file-name (git-file-name name version)) |
| 2120 | (sha256 |
| 2121 | (base32 "0ndwypa397z3pwzdgc3s9plaqlqf63g3d4px5pvym5psgr6lnm3l")))) |
| 2122 | (build-system julia-build-system) |
| 2123 | (arguments |
| 2124 | (list |
| 2125 | #:phases |
| 2126 | #~(modify-phases %standard-phases |
| 2127 | (add-after 'link-depot 'adjust-test-suite |
| 2128 | (lambda _ |
| 2129 | (substitute* "test/runtests.jl" |
| 2130 | ((".*lapack.*") ""))))))) |
| 2131 | (native-inputs |
| 2132 | (list julia-quaternions)) |
| 2133 | (home-page "https://github.com/JuliaLinearAlgebra/GenericLinearAlgebra.jl") |
| 2134 | (synopsis "Generic numerical linear algebra") |
| 2135 | (description "The purpose of this package is partly to extend linear algebra |
| 2136 | functionality in base to cover generic element types, e.g. @code{BigFloat} and |
| 2137 | @code{Quaternion}, and partly to be a place to experiment with fast linear |
| 2138 | algebra routines written in Julia (except for optimized BLAS).") |
| 2139 | (license license:expat))) |
| 2140 | |
| 2141 | (define-public julia-genericschur |
| 2142 | (package |
| 2143 | (name "julia-genericschur") |
| 2144 | (version "0.5.1") |
| 2145 | (source |
| 2146 | (origin |
| 2147 | (method git-fetch) |
| 2148 | (uri (git-reference |
| 2149 | (url "https://github.com/RalphAS/GenericSchur.jl") |
| 2150 | (commit (string-append "v" version)))) |
| 2151 | (file-name (git-file-name name version)) |
| 2152 | (sha256 |
| 2153 | (base32 "12x6lxzxm91y3k6s9dam46dq5hrby5sr0gy0fdfnp0xhjzdy2j0d")))) |
| 2154 | (build-system julia-build-system) |
| 2155 | (arguments |
| 2156 | (list |
| 2157 | #:phases |
| 2158 | #~(modify-phases %standard-phases |
| 2159 | (add-after 'link-depot 'adjust-test-suite |
| 2160 | (lambda _ |
| 2161 | (substitute* "test/complex.jl" |
| 2162 | ;; expected Array{Int32,1}, got a value of type Array{Int64,1} |
| 2163 | (("A = _example") "#A = _example") |
| 2164 | (("schurtest\\(A,20\\)") "")) |
| 2165 | (substitute* "test/runtests.jl" |
| 2166 | ;; Test errors relating to liblapack.so |
| 2167 | ((".*complex\\.jl.*") "") |
| 2168 | ((".*real\\.jl.*") "") |
| 2169 | ;; GenericSVD is deprecated upstream |
| 2170 | ((".*gordschur\\.jl.*") ""))))))) |
| 2171 | (home-page "https://github.com/RalphAS/GenericSchur.jl") |
| 2172 | (synopsis "Schur decomposition of matrices with generic element types") |
| 2173 | (description "The Schur decomposition is the workhorse for eigensystem |
| 2174 | analysis of dense matrices. The diagonal eigen-decomposition of normal |
| 2175 | (especially Hermitian) matrices is an important special case, but for non-normal |
| 2176 | matrices the Schur form is often more useful.") |
| 2177 | (license license:expat))) |
| 2178 | |
| 2179 | (define-public julia-geometrybasics |
| 2180 | (package |
| 2181 | (name "julia-geometrybasics") |
| 2182 | (version "0.4.1") |
| 2183 | (source |
| 2184 | (origin |
| 2185 | (method git-fetch) |
| 2186 | (uri (git-reference |
| 2187 | (url "https://github.com/JuliaGeometry/GeometryBasics.jl") |
| 2188 | (commit (string-append "v" version)))) |
| 2189 | (file-name (git-file-name name version)) |
| 2190 | (sha256 |
| 2191 | (base32 "057j3hjpli3q5b98cqkpi4p10x2k9pyksrz62hjmv1kb5qzdvhsj")))) |
| 2192 | (build-system julia-build-system) |
| 2193 | (arguments |
| 2194 | (list |
| 2195 | #:phases |
| 2196 | #~(modify-phases %standard-phases |
| 2197 | (add-after 'link-depot 'remove-earcut |
| 2198 | (lambda _ |
| 2199 | (substitute* '("Project.toml" |
| 2200 | "src/GeometryBasics.jl") |
| 2201 | ((".*EarCut.*") "")))) |
| 2202 | (add-after 'link-depot 'skip-incompatible-test |
| 2203 | (lambda _ |
| 2204 | (substitute* "test/runtests.jl" |
| 2205 | (("@testset.*MetaT and heterogeneous data.*" all) |
| 2206 | (string-append all "return\n"))))) |
| 2207 | #$@(if (target-64bit?) |
| 2208 | '() |
| 2209 | '((add-after 'unpack 'fix-tests-int32-i686 |
| 2210 | (lambda _ |
| 2211 | (substitute* "test/runtests.jl" |
| 2212 | (("Int64") "Int32"))))))))) |
| 2213 | (propagated-inputs |
| 2214 | (list julia-itertools |
| 2215 | julia-staticarrays |
| 2216 | julia-structarrays |
| 2217 | julia-tables)) |
| 2218 | (native-inputs |
| 2219 | (list julia-offsetarrays)) |
| 2220 | (home-page "https://github.com/JuliaGeometry/GeometryBasics.jl") |
| 2221 | (synopsis "Basic Geometry Types") |
| 2222 | (description "This package aims to offer a standard set of Geometry types, |
| 2223 | which easily work with metadata, query frameworks on geometries and different |
| 2224 | memory layouts. The aim is to create a solid basis for Graphics/Plotting, |
| 2225 | finite elements analysis, Geo applications, and general geometry manipulations |
| 2226 | - while offering a Julian API, that still allows performant C-interop.") |
| 2227 | (license license:expat))) |
| 2228 | |
| 2229 | (define-public julia-gpuarrays |
| 2230 | (package |
| 2231 | (name "julia-gpuarrays") |
| 2232 | (version "8.1.3") |
| 2233 | (source |
| 2234 | (origin |
| 2235 | (method git-fetch) |
| 2236 | (uri (git-reference |
| 2237 | (url "https://github.com/JuliaGPU/GPUArrays.jl") |
| 2238 | (commit (string-append "v" version)))) |
| 2239 | (file-name (git-file-name name version)) |
| 2240 | (sha256 |
| 2241 | (base32 "129q8m94b2xq3vij28pkb7dry3r7qbiqrz72a26ma9kilcr35gk4")))) |
| 2242 | (build-system julia-build-system) |
| 2243 | (inputs |
| 2244 | (list julia-adapt)) |
| 2245 | (home-page "https://github.com/JuliaGPU/GPUArrays.jl") |
| 2246 | (synopsis "Reusable GPU array functionality for various GPU backends") |
| 2247 | (description "This package is the counterpart of AbstractArray interface, |
| 2248 | but for GPU array types. It provides functionality and tooling to speed-up |
| 2249 | development of new GPU array types. This package is not intended for end |
| 2250 | users; instead, you should use one of the packages that builds on |
| 2251 | @code{GPUArrays.jl}, such as @code{CUDA.jl}, @code{oneAPI.jl} or |
| 2252 | @code{AMDGPU.jl}.") |
| 2253 | (license license:expat))) |
| 2254 | |
| 2255 | (define-public julia-gr |
| 2256 | (package |
| 2257 | (name "julia-gr") |
| 2258 | (version "0.58.1") |
| 2259 | (source |
| 2260 | (origin |
| 2261 | (method git-fetch) |
| 2262 | (uri (git-reference |
| 2263 | (url "https://github.com/jheinen/GR.jl") |
| 2264 | (commit (string-append "v" version)))) |
| 2265 | (file-name (git-file-name name version)) |
| 2266 | (sha256 |
| 2267 | (base32 "18zxa1w2wmrf44c5l10qbh99zjdp7h94gxlymh47cf5kj5fc4xmx")))) |
| 2268 | (build-system julia-build-system) |
| 2269 | (propagated-inputs |
| 2270 | (list julia-gr-jll)) |
| 2271 | (home-page "https://github.com/jheinen/GR.jl") |
| 2272 | (synopsis "Plotting for Julia based on GR") |
| 2273 | (description "This module provides a Julia interface to GR, a framework for |
| 2274 | visualisation applications.") |
| 2275 | (license license:expat))) |
| 2276 | |
| 2277 | (define-public julia-graphics |
| 2278 | (package |
| 2279 | (name "julia-graphics") |
| 2280 | (version "1.1.0") |
| 2281 | (source |
| 2282 | (origin |
| 2283 | (method git-fetch) |
| 2284 | (uri (git-reference |
| 2285 | (url "https://github.com/JuliaGraphics/Graphics.jl") |
| 2286 | (commit (string-append "v" version)))) |
| 2287 | (file-name (git-file-name name version)) |
| 2288 | (sha256 |
| 2289 | (base32 "10h1s09v7qkvrjr6l678zamb1p248n8jv4rrwkf8g7d2bpfz9amn")))) |
| 2290 | (build-system julia-build-system) |
| 2291 | (propagated-inputs |
| 2292 | (list julia-colors |
| 2293 | julia-nanmath)) |
| 2294 | (home-page "https://github.com/JuliaGraphics/Graphics.jl") |
| 2295 | (synopsis "Base graphics in Julia") |
| 2296 | (description "@code{Graphics.jl} is an abstraction layer for graphical |
| 2297 | operations in Julia.") |
| 2298 | (license license:expat))) |
| 2299 | |
| 2300 | (define-public julia-gumbo |
| 2301 | (package |
| 2302 | (name "julia-gumbo") |
| 2303 | (version "0.8.0") |
| 2304 | (source |
| 2305 | (origin |
| 2306 | (method git-fetch) |
| 2307 | (uri (git-reference |
| 2308 | (url "https://github.com/JuliaWeb/Gumbo.jl") |
| 2309 | (commit (string-append "v" version)))) |
| 2310 | (file-name (git-file-name name version)) |
| 2311 | (sha256 |
| 2312 | (base32 "1g22dv3v7caakspv3pdahnqn937fzzsg9y87rj72hid9g8lxl1gm")))) |
| 2313 | (build-system julia-build-system) |
| 2314 | (propagated-inputs |
| 2315 | (list julia-abstracttrees |
| 2316 | julia-gumbo-jll)) |
| 2317 | (home-page "https://github.com/JuliaWeb/Gumbo.jl") |
| 2318 | (synopsis "Julia wrapper around Google's gumbo C library for parsing HTML") |
| 2319 | (description "@code{Gumbo.jl} is a Julia wrapper around Google's gumbo |
| 2320 | library for parsing HTML.") |
| 2321 | (license license:expat))) |
| 2322 | |
| 2323 | (define-public julia-http |
| 2324 | (package |
| 2325 | (name "julia-http") |
| 2326 | (version "0.9.12") |
| 2327 | (source |
| 2328 | (origin |
| 2329 | (method git-fetch) |
| 2330 | (uri (git-reference |
| 2331 | (url "https://github.com/JuliaWeb/HTTP.jl") |
| 2332 | (commit (string-append "v" version)))) |
| 2333 | (file-name (git-file-name name version)) |
| 2334 | (sha256 |
| 2335 | (base32 "1jsyk3mhnwj4h19cxclx26igdqdrw51fd3k1hgav0nm67dy4cxyk")))) |
| 2336 | (build-system julia-build-system) |
| 2337 | (arguments |
| 2338 | (list |
| 2339 | #:phases |
| 2340 | #~(modify-phases %standard-phases |
| 2341 | (add-before 'install 'disable-network-tests |
| 2342 | (lambda _ |
| 2343 | (substitute* "test/runtests.jl" |
| 2344 | (("\"async.jl") "# \"async.jl") |
| 2345 | (("\"client.jl") "# \"client.jl")) |
| 2346 | (substitute* "test/aws4.jl" |
| 2347 | (("@testset.*HTTP.request with AWS authentication.*" all) |
| 2348 | (string-append all "return\n"))) |
| 2349 | (substitute* "test/insert_layers.jl" |
| 2350 | (("@testset.*Inserted final layer runs handler.*" all) |
| 2351 | (string-append all "return\n"))) |
| 2352 | (substitute* "test/multipart.jl" |
| 2353 | (("@testset \"Setting of Content-Type.*" all) |
| 2354 | (string-append all "return\n")) |
| 2355 | (("@testset \"Deprecation of .*" all) |
| 2356 | (string-append all "return\n"))) |
| 2357 | (substitute* "test/websockets.jl" |
| 2358 | (("@testset.*External Host.*" all) |
| 2359 | (string-append all "return\n"))) |
| 2360 | (substitute* "test/messages.jl" |
| 2361 | (("@testset.*Read methods.*" all) |
| 2362 | (string-append all "return\n")) |
| 2363 | (("@testset.*Body - .*" all) |
| 2364 | (string-append all "return\n")) |
| 2365 | (("@testset.*Write to file.*" all) |
| 2366 | (string-append all "return\n")))))))) |
| 2367 | (propagated-inputs |
| 2368 | (list julia-inifile |
| 2369 | julia-mbedtls |
| 2370 | julia-uris)) |
| 2371 | ;; required for tests |
| 2372 | (inputs |
| 2373 | (list julia-json |
| 2374 | julia-bufferedstreams)) |
| 2375 | (home-page "https://juliaweb.github.io/HTTP.jl/") |
| 2376 | (synopsis "HTTP support for Julia") |
| 2377 | (description "@code{HTTP.jl} is a Julia library for HTTP Messages, |
| 2378 | implementing both a client and a server.") |
| 2379 | (license license:expat))) |
| 2380 | |
| 2381 | (define-public julia-identityranges |
| 2382 | (package |
| 2383 | (name "julia-identityranges") |
| 2384 | (version "0.3.1") |
| 2385 | (source |
| 2386 | (origin |
| 2387 | (method git-fetch) |
| 2388 | (uri (git-reference |
| 2389 | (url "https://github.com/JuliaArrays/IdentityRanges.jl") |
| 2390 | (commit (string-append "v" version)))) |
| 2391 | (file-name (git-file-name name version)) |
| 2392 | (sha256 |
| 2393 | (base32 "0jvl4xn8f8k70sn473li5q62wbiycl5qi25b5k456h3a0j1lbiml")))) |
| 2394 | (build-system julia-build-system) |
| 2395 | (propagated-inputs |
| 2396 | (list julia-offsetarrays)) |
| 2397 | (home-page "https://github.com/JuliaArrays/IdentityRanges.jl") |
| 2398 | (synopsis "Ranges that preserve indices of views") |
| 2399 | (description "@code{IdentityRanges} are Julia-language a helper type for |
| 2400 | creating \"views\" of arrays. They are a custom type of AbstractUnitRange that |
| 2401 | makes it easy to preserve the indices of array views. The key property of an |
| 2402 | @code{IdentityRange r} is that @code{r[i] == i} (hence the name of the |
| 2403 | type/package), and that they support arbitrary start/stop indices (i.e., not |
| 2404 | just starting at 1).") |
| 2405 | (license license:expat))) |
| 2406 | |
| 2407 | (define-public julia-ifelse |
| 2408 | (package |
| 2409 | (name "julia-ifelse") |
| 2410 | (version "0.1.0") |
| 2411 | (source |
| 2412 | (origin |
| 2413 | (method git-fetch) |
| 2414 | (uri (git-reference |
| 2415 | (url "https://github.com/sciml/ifelse.jl") |
| 2416 | (commit (string-append "v" version)))) |
| 2417 | (file-name (git-file-name name version)) |
| 2418 | (sha256 |
| 2419 | (base32 "1wrw842r8708fryf2ihp9mkmdrg27saa9nix2c31vs995k2fgr9w")))) |
| 2420 | (build-system julia-build-system) |
| 2421 | (home-page "https://github.com/sciml/ifelse.jl") |
| 2422 | (synopsis "Function form of the if-else conditional statement") |
| 2423 | (description "This package provides a convenient function form of the |
| 2424 | conditional ifelse. It is similar to @code{Core.ifelse} but it is extendable.") |
| 2425 | (license license:expat))) |
| 2426 | |
| 2427 | (define-public julia-imageaxes |
| 2428 | (package |
| 2429 | (name "julia-imageaxes") |
| 2430 | (version "0.6.9") |
| 2431 | (source |
| 2432 | (origin |
| 2433 | (method git-fetch) |
| 2434 | (uri (git-reference |
| 2435 | (url "https://github.com/JuliaImages/ImageAxes.jl") |
| 2436 | (commit (string-append "v" version)))) |
| 2437 | (file-name (git-file-name name version)) |
| 2438 | (sha256 |
| 2439 | (base32 "15zqxani1jjh8849s7rdps6b6prqdwv8yxx893y536vkpk7i07qd")))) |
| 2440 | (build-system julia-build-system) |
| 2441 | (propagated-inputs |
| 2442 | (list julia-axisarrays |
| 2443 | julia-imagecore |
| 2444 | julia-reexport |
| 2445 | julia-simpletraits)) |
| 2446 | (native-inputs |
| 2447 | (list julia-unitful)) |
| 2448 | (home-page "https://github.com/JuliaImages/ImageAxes.jl") |
| 2449 | (synopsis "Julia package for giving \"meaning\" to the axes of an image") |
| 2450 | (description "This small package supports the representation of images as |
| 2451 | @code{AxisArrays} to endow the axes with \"meaning,\" and makes programming with |
| 2452 | such arrays easy via traits.") |
| 2453 | (license license:expat))) |
| 2454 | |
| 2455 | (define-public julia-imagebase |
| 2456 | (package |
| 2457 | (name "julia-imagebase") |
| 2458 | (version "0.1.1") |
| 2459 | (source |
| 2460 | (origin |
| 2461 | (method git-fetch) |
| 2462 | (uri (git-reference |
| 2463 | (url "https://github.com/JuliaImages/ImageBase.jl") |
| 2464 | (commit (string-append "v" version)))) |
| 2465 | (file-name (git-file-name name version)) |
| 2466 | (sha256 |
| 2467 | (base32 "1n63f2zs6ail9pcl7rzgv3l0z8v1idjsaza3zgvgy7iacxsdpcj2")))) |
| 2468 | (build-system julia-build-system) |
| 2469 | (arguments |
| 2470 | (list #:tests? #f)) ; Cycle with ImageMagick.jl. |
| 2471 | (propagated-inputs |
| 2472 | (list julia-imagecore |
| 2473 | julia-reexport)) |
| 2474 | ;(native-inputs |
| 2475 | ; `(("julia-imagemagick" ,julia-imagemagick) |
| 2476 | ; ("julia-offsetarrays" ,julia-offsetarrays) |
| 2477 | ; ("julia-testimages" ,julia-testimages))) |
| 2478 | (home-page "https://github.com/JuliaImages/ImageBase.jl") |
| 2479 | (synopsis "Wrapper package around ImageCore") |
| 2480 | (description "This is a twin package to @code{ImageCore} with functions that |
| 2481 | are used among many of the packages in JuliaImages. The main purpose of this |
| 2482 | package is to reduce unnecessary compilation overhead from external |
| 2483 | dependencies.") |
| 2484 | (license license:expat))) |
| 2485 | |
| 2486 | (define-public julia-imagecore |
| 2487 | (package |
| 2488 | (name "julia-imagecore") |
| 2489 | (version "0.9.1") |
| 2490 | (source |
| 2491 | (origin |
| 2492 | (method git-fetch) |
| 2493 | (uri (git-reference |
| 2494 | (url "https://github.com/JuliaImages/ImageCore.jl") |
| 2495 | (commit (string-append "v" version)))) |
| 2496 | (file-name (git-file-name name version)) |
| 2497 | (sha256 |
| 2498 | (base32 "0h9m3pl3wic1jrgaqkdifz24cya5vxd3m6qdmm37pxg2y2ii2vcq")))) |
| 2499 | (build-system julia-build-system) |
| 2500 | (arguments |
| 2501 | (list #:tests? #f)) ; Cycle with ImageMagick.jl. |
| 2502 | (propagated-inputs |
| 2503 | (list julia-abstractffts |
| 2504 | julia-colors |
| 2505 | julia-colorvectorspace |
| 2506 | julia-fixedpointnumbers |
| 2507 | julia-graphics |
| 2508 | julia-mappedarrays |
| 2509 | julia-mosaicviews |
| 2510 | julia-offsetarrays |
| 2511 | julia-paddedviews |
| 2512 | julia-reexport)) |
| 2513 | ;(native-inputs |
| 2514 | ; `(("julia-aqua" ,julia-aqua) |
| 2515 | ; ("julia-colorvectorspace" ,julia-colorvectorspace) |
| 2516 | ; ("julia-documenter" ,julia-documenter) |
| 2517 | ; ("julia-fftw" ,julia-fftw) |
| 2518 | ; ("julia-imageinterminal" ,julia-imageinterminal) |
| 2519 | ; ("julia-imagemagick" ,julia-imagemagick) |
| 2520 | ; ("julia-referencetests" ,julia-referencetests) |
| 2521 | ; ("julia-statistics" ,julia-statistics))) |
| 2522 | (home-page "https://github.com/JuliaImages/ImageCore.jl") |
| 2523 | (synopsis "Julia types for representing images") |
| 2524 | (description "@code{ImageCore} is the lowest-level component of the system |
| 2525 | of packages designed to support image processing and computer vision.") |
| 2526 | (license license:expat))) |
| 2527 | |
| 2528 | (define-public julia-imageinterminal |
| 2529 | (package |
| 2530 | (name "julia-imageinterminal") |
| 2531 | (version "0.4.7") |
| 2532 | (source |
| 2533 | (origin |
| 2534 | (method git-fetch) |
| 2535 | (uri (git-reference |
| 2536 | (url "https://github.com/JuliaImages/ImageInTerminal.jl") |
| 2537 | (commit (string-append "v" version)))) |
| 2538 | (file-name (git-file-name name version)) |
| 2539 | (sha256 |
| 2540 | (base32 "0bbpzi7bv8jdiggq1wmcn67vnf96qagvwg0fk95s125wy5980xsl")))) |
| 2541 | (build-system julia-build-system) |
| 2542 | (arguments |
| 2543 | (list #:tests? #f)) ; Cycle with ReferenceTests.jl. |
| 2544 | (propagated-inputs |
| 2545 | (list julia-crayons |
| 2546 | julia-imagebase |
| 2547 | julia-imagecore |
| 2548 | julia-requires)) |
| 2549 | ;(native-inputs |
| 2550 | ; `(("julia-coordinatetransformations" ,julia-coordinatetransformations) |
| 2551 | ; ("julia-imagemagick" ,julia-imagemagick) |
| 2552 | ; ("julia-imagetransformations" ,julia-imagetransformations) |
| 2553 | ; ("julia-offsetarrays" ,julia-offsetarrays) |
| 2554 | ; ("julia-referencetests" ,julia-referencetests) |
| 2555 | ; ("julia-rotations" ,julia-rotations) |
| 2556 | ; ("julia-sparsearrays" ,julia-sparsearrays) |
| 2557 | ; ("julia-testimages" ,julia-testimages))) |
| 2558 | (home-page "https://github.com/JuliaImages/ImageInTerminal.jl") |
| 2559 | (synopsis "Julia package for displaying images in the terminal") |
| 2560 | (description "@code{ImageInTerminal.jl} is a drop-in package that once |
| 2561 | imported changes a how a single @code{Colorant} and whole @code{Colorant} arrays |
| 2562 | (i.e. Images) are displayed in the interactive REPL. The displayed images will |
| 2563 | be downscaled to fit into the size of your active terminal session.") |
| 2564 | (license license:expat))) |
| 2565 | |
| 2566 | (define-public julia-imagemagick |
| 2567 | (package |
| 2568 | (name "julia-imagemagick") |
| 2569 | (version "1.2.1") |
| 2570 | (source |
| 2571 | (origin |
| 2572 | (method git-fetch) |
| 2573 | (uri (git-reference |
| 2574 | (url "https://github.com/JuliaIO/ImageMagick.jl") |
| 2575 | (commit (string-append "v" version)))) |
| 2576 | (file-name (git-file-name name version)) |
| 2577 | (sha256 |
| 2578 | (base32 "05vzv4jsj3l9pv6yrix28hlw7wnag0mqdfjwv8shn4x71hcfxl1p")))) |
| 2579 | (build-system julia-build-system) |
| 2580 | (arguments |
| 2581 | (list |
| 2582 | #:phases |
| 2583 | #~(modify-phases %standard-phases |
| 2584 | (add-after 'link-depot 'skip-failing-test |
| 2585 | (lambda _ |
| 2586 | ;; These tests try to download from the imagemagick.org |
| 2587 | (substitute* "test/runtests.jl" |
| 2588 | ((".*readremote\\.jl.*") "")) |
| 2589 | ;; Tests with the color gray are hard. |
| 2590 | (substitute* "test/constructed_images.jl" |
| 2591 | (("test (b == aa)" _ test) (string-append "test_nowarn " test)) |
| 2592 | (("test (B == map)" _ test) (string-append "test_nowarn " test)))))))) |
| 2593 | (propagated-inputs |
| 2594 | (list julia-fileio |
| 2595 | julia-imagecore |
| 2596 | julia-imagemagick-jll)) |
| 2597 | (native-inputs |
| 2598 | (list julia-colors |
| 2599 | julia-colorvectorspace |
| 2600 | julia-imagemetadata |
| 2601 | julia-imageshow |
| 2602 | julia-imagetransformations |
| 2603 | julia-indirectarrays |
| 2604 | julia-offsetarrays |
| 2605 | julia-zipfile)) |
| 2606 | (home-page "https://github.com/JuliaIO/ImageMagick.jl") |
| 2607 | (synopsis "Thin wrapper for ImageMagick") |
| 2608 | (description "This package provides a wrapper around ImageMagick version 6. |
| 2609 | It was split off from @code{Images.jl} to make image I/O more modular.") |
| 2610 | (license license:expat))) |
| 2611 | |
| 2612 | (define-public julia-imagemetadata |
| 2613 | (package |
| 2614 | (name "julia-imagemetadata") |
| 2615 | (version "0.9.6") |
| 2616 | (source |
| 2617 | (origin |
| 2618 | (method git-fetch) |
| 2619 | (uri (git-reference |
| 2620 | (url "https://github.com/JuliaImages/ImageMetadata.jl") |
| 2621 | (commit (string-append "v" version)))) |
| 2622 | (file-name (git-file-name name version)) |
| 2623 | (sha256 |
| 2624 | (base32 "0iv154ms370xgcr56bwsjl13iwmy671cbxjl9ld5yfj85pclcwi1")))) |
| 2625 | (build-system julia-build-system) |
| 2626 | (propagated-inputs |
| 2627 | (list julia-axisarrays |
| 2628 | julia-imageaxes |
| 2629 | julia-imagecore |
| 2630 | julia-indirectarrays)) |
| 2631 | (native-inputs |
| 2632 | (list julia-offsetarrays |
| 2633 | julia-simpletraits |
| 2634 | julia-unitful)) |
| 2635 | (home-page "https://github.com/JuliaImages/ImageMetadata.jl") |
| 2636 | (synopsis "Julia package for images having metadata") |
| 2637 | (description "@code{ImageMetadata} is a simple package providing utilities |
| 2638 | for working with images that have metadata attached. For example, you might |
| 2639 | want to associate an image with the date on which the picture was taken, or an |
| 2640 | MRI scan with patient data, or an astronomical image with sky coordinates and |
| 2641 | information about the detector used to acquire the image.") |
| 2642 | (license license:expat))) |
| 2643 | |
| 2644 | (define-public julia-imageshow |
| 2645 | (package |
| 2646 | (name "julia-imageshow") |
| 2647 | (version "0.3.2") |
| 2648 | (source |
| 2649 | (origin |
| 2650 | (method git-fetch) |
| 2651 | (uri (git-reference |
| 2652 | (url "https://github.com/JuliaImages/ImageShow.jl") |
| 2653 | (commit (string-append "v" version)))) |
| 2654 | (file-name (git-file-name name version)) |
| 2655 | (sha256 |
| 2656 | (base32 "00wq3ab8y6nyhxwc5lpz9dnslsmcr1vg3cjdkh7wb7k6a8bw98mh")))) |
| 2657 | (build-system julia-build-system) |
| 2658 | (arguments |
| 2659 | (list #:tests? #f)) ; cycle with ImageMagick.jl. |
| 2660 | (propagated-inputs |
| 2661 | (list julia-fileio |
| 2662 | julia-imagebase |
| 2663 | julia-imagecore |
| 2664 | julia-offsetarrays |
| 2665 | julia-stackviews)) |
| 2666 | ;(native-inputs |
| 2667 | ; `(("julia-imagedistances" ,julia-imagedistances) |
| 2668 | ; ("julia-imagemagick" ,julia-imagemagick) |
| 2669 | ; ("julia-suppressor" ,julia-suppressor) |
| 2670 | ; ("julia-testimages" ,julia-testimages))) |
| 2671 | (home-page "https://github.com/JuliaImages/ImageShow.jl") |
| 2672 | (synopsis |
| 2673 | "Inline graphical display of images in Julia graphical environments") |
| 2674 | (description "This package implements image @code{show} methods suitable |
| 2675 | for graphical platforms such as IJulia. It is intended to provide convenient |
| 2676 | inline presentation of greyscale or color images.") |
| 2677 | (license license:expat))) |
| 2678 | |
| 2679 | (define-public julia-imagetransformations |
| 2680 | (package |
| 2681 | (name "julia-imagetransformations") |
| 2682 | (version "0.8.12") |
| 2683 | (source |
| 2684 | (origin |
| 2685 | (method git-fetch) |
| 2686 | (uri (git-reference |
| 2687 | (url "https://github.com/JuliaImages/ImageTransformations.jl") |
| 2688 | (commit (string-append "v" version)))) |
| 2689 | (file-name (git-file-name name version)) |
| 2690 | (sha256 |
| 2691 | (base32 "0i8gw68hljshsy9wdl5mrpbb31irhmayqyglsxi7jwm88iy9pxhm")))) |
| 2692 | (build-system julia-build-system) |
| 2693 | (arguments |
| 2694 | (list #:tests? #f)) ; Cycle with ImageMagick.jl. |
| 2695 | (propagated-inputs |
| 2696 | (list julia-axisalgorithms |
| 2697 | julia-colorvectorspace |
| 2698 | julia-coordinatetransformations |
| 2699 | julia-identityranges |
| 2700 | julia-imagecore |
| 2701 | julia-interpolations |
| 2702 | julia-offsetarrays |
| 2703 | julia-rotations |
| 2704 | julia-staticarrays)) |
| 2705 | ;(native-inputs |
| 2706 | ; `(("julia-imagemagick" ,julia-imagemagick) |
| 2707 | ; ("julia-referencetests" ,julia-referencetests) |
| 2708 | ; ("julia-testimages" ,julia-testimages))) |
| 2709 | (home-page "https://github.com/JuliaImages/ImageTransformations.jl") |
| 2710 | (synopsis "Geometric transformations on images for Julia") |
| 2711 | (description "This package provides support for image resizing, image |
| 2712 | rotation, and other spatial transformations of arrays.") |
| 2713 | (license license:expat))) |
| 2714 | |
| 2715 | (define-public julia-indexablebitvectors |
| 2716 | (package |
| 2717 | (name "julia-indexablebitvectors") |
| 2718 | (version "1.0.0") |
| 2719 | (source |
| 2720 | (origin |
| 2721 | (method git-fetch) |
| 2722 | (uri (git-reference |
| 2723 | (url "https://github.com/BioJulia/IndexableBitVectors.jl") |
| 2724 | (commit (string-append "v" version)))) |
| 2725 | (file-name (git-file-name name version)) |
| 2726 | (sha256 |
| 2727 | (base32 "1khaycydwa31sxwvrrvvlylpzdb77kkxfmb8cax3i22ix0c2nmlc")))) |
| 2728 | (build-system julia-build-system) |
| 2729 | ;; Package without Project.toml |
| 2730 | (arguments |
| 2731 | (list |
| 2732 | #:julia-package-name "IndexableBitVectors" |
| 2733 | #:julia-package-uuid "1cb3b9ac-1ffd-5777-9e6b-a3d42300664d")) |
| 2734 | (home-page "https://github.com/BioJulia/IndexableBitVectors.jl") |
| 2735 | (synopsis "Bit vectors operations with extremely fast speed") |
| 2736 | (description "This package exports following operations over bit vectors |
| 2737 | with extremely fast speed while keeping extra memory usage small: |
| 2738 | @itemize |
| 2739 | @item @code{getindex(bv::IndexableBitVectors, i::Integer)}: @code{i}-th |
| 2740 | element of @code{bv} |
| 2741 | @item @code{rank(b::Bool, bv::AbstractIndexableBitVector, i::Integer)}: the |
| 2742 | number of occurrences of bit @code{b} in @code{bv[1:i]} |
| 2743 | @item @code{select(b::Bool, bv::AbstractIndexableBitVector, i::Integer)}: the |
| 2744 | index of i-th occurrence of @code{b} in @code{bv}. |
| 2745 | @end itemize |
| 2746 | and other shortcuts or types.") |
| 2747 | (license license:expat))) |
| 2748 | |
| 2749 | (define-public julia-indexing |
| 2750 | (package |
| 2751 | (name "julia-indexing") |
| 2752 | (version "1.1.1") |
| 2753 | (source |
| 2754 | (origin |
| 2755 | (method git-fetch) |
| 2756 | (uri (git-reference |
| 2757 | (url "https://github.com/andyferris/Indexing.jl") |
| 2758 | (commit (string-append "v" version)))) |
| 2759 | (file-name (git-file-name name version)) |
| 2760 | (sha256 |
| 2761 | (base32 "1s7bz5aaj9sx753pcaixq83jgbk33adxgybpinjgzb9lzdv1ddgx")))) |
| 2762 | (build-system julia-build-system) |
| 2763 | (home-page "https://github.com/andyferris/Indexing.jl") |
| 2764 | (synopsis "Generalized indexing for Julia") |
| 2765 | (description "This package defines functions for getting multiple indices |
| 2766 | out of dictionaries, tuples, etc, extending this ability beyond |
| 2767 | @code{AbstractArray}.") |
| 2768 | (license license:expat))) |
| 2769 | |
| 2770 | (define-public julia-indirectarrays |
| 2771 | (package |
| 2772 | (name "julia-indirectarrays") |
| 2773 | (version "0.5.1") |
| 2774 | (source |
| 2775 | (origin |
| 2776 | (method git-fetch) |
| 2777 | (uri (git-reference |
| 2778 | (url "https://github.com/JuliaArrays/IndirectArrays.jl") |
| 2779 | (commit (string-append "v" version)))) |
| 2780 | (file-name (git-file-name name version)) |
| 2781 | (sha256 |
| 2782 | (base32 "0l0jq0jnr9z3k431ni82xycq7mqapgxrbrx4yyk6lycvi41ipm4s")))) |
| 2783 | (build-system julia-build-system) |
| 2784 | (native-inputs |
| 2785 | (list julia-colors |
| 2786 | julia-fixedpointnumbers |
| 2787 | julia-mappedarrays)) |
| 2788 | (home-page "https://github.com/JuliaArrays/IndirectArrays.jl") |
| 2789 | (synopsis "Julia implementation of indexed arrays") |
| 2790 | (description "An @code{IndirectArray} is one that encodes data using a |
| 2791 | combination of an @code{index} and a @code{value} table. Each element is |
| 2792 | assigned its own index, which is used to retrieve the value from the |
| 2793 | @code{value} table. Among other uses, @code{IndirectArrays} can represent |
| 2794 | indexed images, sometimes called \"colormap images\" or \"paletted images.\"") |
| 2795 | (license license:expat))) |
| 2796 | |
| 2797 | (define-public julia-infinity |
| 2798 | (package |
| 2799 | (name "julia-infinity") |
| 2800 | (version "0.2.4") |
| 2801 | (source |
| 2802 | (origin |
| 2803 | (method git-fetch) |
| 2804 | (uri (git-reference |
| 2805 | (url "https://github.com/cjdoris/Infinity.jl") |
| 2806 | (commit (string-append "v" version)))) |
| 2807 | (file-name (git-file-name name version)) |
| 2808 | (sha256 |
| 2809 | (base32 "1941lwvrdjnrynigzixxin3chpg1ba6xplvcwc89x0f6z658hwmm")))) |
| 2810 | (build-system julia-build-system) |
| 2811 | (arguments |
| 2812 | (list |
| 2813 | #:phases |
| 2814 | #~(modify-phases %standard-phases |
| 2815 | (add-after 'link-depot 'remove-timezones.jl |
| 2816 | (lambda _ |
| 2817 | (substitute* "test/runtests.jl" |
| 2818 | (("using TimeZones.*") "") |
| 2819 | ((".*infextendedtime.*") ""))))))) |
| 2820 | (propagated-inputs |
| 2821 | (list julia-requires)) |
| 2822 | (native-inputs |
| 2823 | (list julia-compat)) |
| 2824 | (home-page "https://docs.juliahub.com/Infinity/") |
| 2825 | (synopsis "Representation of infinity in Julia") |
| 2826 | (description "This package provides representations for infinity and |
| 2827 | negative infinity in Julia.") |
| 2828 | (license license:expat))) |
| 2829 | |
| 2830 | (define-public julia-inifile |
| 2831 | (package |
| 2832 | (name "julia-inifile") |
| 2833 | (version "0.5.0") |
| 2834 | (source |
| 2835 | (origin |
| 2836 | (method git-fetch) |
| 2837 | (uri (git-reference |
| 2838 | (url "https://github.com/JuliaIO/IniFile.jl") |
| 2839 | (commit "8ba59958495fa276d6489d2c3903e765d75e0bc0"))) |
| 2840 | (file-name (git-file-name name version)) |
| 2841 | (sha256 |
| 2842 | (base32 "11h6f99jpbg729lplw841m68jprka7q3n8yw390bndlmcdsjabpd")))) |
| 2843 | (build-system julia-build-system) |
| 2844 | (home-page "https://github.com/JuliaIO/IniFile.jl") |
| 2845 | (synopsis "Reading Windows-style INI files") |
| 2846 | (description "This is a Julia package that defines an IniFile type that |
| 2847 | interfaces with @file{.ini} files.") |
| 2848 | (license license:expat))) |
| 2849 | |
| 2850 | (define-public julia-interpolations |
| 2851 | (package |
| 2852 | (name "julia-interpolations") |
| 2853 | (version "0.13.3") |
| 2854 | (source |
| 2855 | (origin |
| 2856 | (method git-fetch) |
| 2857 | (uri (git-reference |
| 2858 | (url "https://github.com/JuliaMath/Interpolations.jl") |
| 2859 | (commit (string-append "v" version)))) |
| 2860 | (file-name (git-file-name name version)) |
| 2861 | (sha256 |
| 2862 | (base32 "1236c20k388qlh7k74mhf7hkbn0vf7ss8b1rgh1a6aj0234ayfnc")))) |
| 2863 | (build-system julia-build-system) |
| 2864 | (arguments |
| 2865 | (list |
| 2866 | #:parallel-tests? #f |
| 2867 | ;; XXXX: Unexpected failures for i686, e.g., |
| 2868 | ;; Got exception outside of a @test |
| 2869 | ;; OverflowError: 96908232 * 106943408 overflowed for type Int32 |
| 2870 | ;; Disable as stopgap. |
| 2871 | #:tests? (not (target-x86-32?)))) |
| 2872 | (propagated-inputs |
| 2873 | (list julia-axisalgorithms |
| 2874 | julia-offsetarrays |
| 2875 | julia-ratios |
| 2876 | julia-requires |
| 2877 | julia-staticarrays |
| 2878 | julia-woodburymatrices)) |
| 2879 | (native-inputs |
| 2880 | (list julia-dualnumbers |
| 2881 | julia-forwarddiff |
| 2882 | julia-offsetarrays |
| 2883 | julia-unitful julia-zygote)) |
| 2884 | (home-page "https://github.com/JuliaMath/Interpolations.jl") |
| 2885 | (synopsis "Continuous interpolation of discrete datasets") |
| 2886 | (description "This package implements a variety of interpolation schemes for |
| 2887 | the Julia language. It has the goals of ease-of-use, broad algorithmic support, |
| 2888 | and exceptional performance.") |
| 2889 | (license license:expat))) |
| 2890 | |
| 2891 | (define-public julia-intervalsets |
| 2892 | (package |
| 2893 | (name "julia-intervalsets") |
| 2894 | (version "0.5.3") |
| 2895 | (source |
| 2896 | (origin |
| 2897 | (method git-fetch) |
| 2898 | (uri (git-reference |
| 2899 | (url "https://github.com/JuliaMath/IntervalSets.jl") |
| 2900 | (commit (string-append "v" version)))) |
| 2901 | (file-name (git-file-name name version)) |
| 2902 | (sha256 |
| 2903 | (base32 "0gsz89cd3iygbl5qr389k9vwpg7w1nk0s90g25nsmk34y9hifxag")))) |
| 2904 | (build-system julia-build-system) |
| 2905 | (arguments |
| 2906 | (list |
| 2907 | #:phases |
| 2908 | (if (target-x86-32?) |
| 2909 | #~(modify-phases %standard-phases |
| 2910 | (add-after 'unpack 'remove-failing-test-i686 |
| 2911 | (lambda _ |
| 2912 | (substitute* "test/runtests.jl" |
| 2913 | ;; For some reason, the output is correct but the test |
| 2914 | ;; is considered as failed: |
| 2915 | ;; Expression: duration(ClosedInterval(A, B)) ≡ 60 |
| 2916 | ;; Evaluated: 60 ≡ 60 |
| 2917 | (("@test duration\\(ClosedInterval") |
| 2918 | "@test_broken duration(ClosedInterval"))))) |
| 2919 | #~%standard-phases))) |
| 2920 | (propagated-inputs |
| 2921 | (list julia-ellipsisnotation)) |
| 2922 | (native-inputs |
| 2923 | (list julia-offsetarrays)) |
| 2924 | (home-page "https://github.com/JuliaMath/IntervalSets.jl") |
| 2925 | (synopsis "Interval Sets for Julia") |
| 2926 | (description "This package is intended to implement a \"minimal\" foundation |
| 2927 | for intervals upon which other packages might build. In particular, we |
| 2928 | encourage type-piracy for the reason that only one interval package can |
| 2929 | unambiguously define the @code{..} and @code{±} operators.") |
| 2930 | (license license:expat))) |
| 2931 | |
| 2932 | (define-public julia-intervaltrees |
| 2933 | ;; Last upstream release on May 2020 and this last release does not contain |
| 2934 | ;; the file Project.toml. |
| 2935 | (let ((commit "e37edab61568d08141a3e9c25ec55caac21e5aa5") |
| 2936 | (revision "1")) |
| 2937 | (package |
| 2938 | (name "julia-intervaltrees") |
| 2939 | (version (git-version "1.0.0" revision commit)) |
| 2940 | (source |
| 2941 | (origin |
| 2942 | (method git-fetch) |
| 2943 | (uri (git-reference |
| 2944 | (url "https://github.com/BioJulia/IntervalTrees.jl") |
| 2945 | (commit commit))) |
| 2946 | (file-name (git-file-name name version)) |
| 2947 | (sha256 |
| 2948 | (base32 "01x48a5zrx0833s1kjhf0ml4x9xz8xja4ymran770akmf6968yl9")))) |
| 2949 | (build-system julia-build-system) |
| 2950 | (home-page "https://github.com/BioJulia/IntervalTrees.jl") |
| 2951 | (synopsis "Interval Trees for Julia") |
| 2952 | (description "This package provides an implementation of an associative |
| 2953 | container mapping @code{(K,V)} pairs via the type @code{IntervalTree{K, V}}. |
| 2954 | The type @code{K} may be any ordered type.") |
| 2955 | (license license:expat)))) |
| 2956 | |
| 2957 | (define-public julia-invertedindices |
| 2958 | (package |
| 2959 | (name "julia-invertedindices") |
| 2960 | (version "1.0.0") |
| 2961 | (source |
| 2962 | (origin |
| 2963 | (method git-fetch) |
| 2964 | (uri (git-reference |
| 2965 | (url "https://github.com/mbauman/InvertedIndices.jl") |
| 2966 | (commit (string-append "v" version)))) |
| 2967 | (file-name (git-file-name name version)) |
| 2968 | (sha256 |
| 2969 | (base32 "1179z20yxnkyziip7gn26wr1g3k3ssl1ci7pig3khc900f62di46")))) |
| 2970 | (build-system julia-build-system) |
| 2971 | (native-inputs |
| 2972 | (list julia-offsetarrays)) |
| 2973 | (home-page "https://github.com/mbauman/InvertedIndices.jl") |
| 2974 | (synopsis "Index type that allows for inverted selections") |
| 2975 | (description "This package just exports one type: the @code{InvertedIndex}, |
| 2976 | or @code{Not} for short. It can wrap any supported index type and may be used |
| 2977 | as an index into any @code{AbstractArray} subtype, including OffsetArrays.") |
| 2978 | (license license:expat))) |
| 2979 | |
| 2980 | (define-public julia-iocapture |
| 2981 | (package |
| 2982 | (name "julia-iocapture") |
| 2983 | (version "0.2.2") |
| 2984 | (source |
| 2985 | (origin |
| 2986 | (method git-fetch) |
| 2987 | (uri (git-reference |
| 2988 | (url "https://github.com/JuliaDocs/IOCapture.jl") |
| 2989 | (commit (string-append "v" version)))) |
| 2990 | (file-name (git-file-name name version)) |
| 2991 | (sha256 |
| 2992 | (base32 "0v76wbvg80g9nx0rjbcna82zk61krly1y9yhyfrjv2pf7mcr4idb")))) |
| 2993 | (build-system julia-build-system) |
| 2994 | (home-page "https://github.com/JuliaDocs/IOCapture.jl") |
| 2995 | (synopsis "Capture standard output and error streams") |
| 2996 | (description "This package provides the @code{IOCapture.capture(f)} |
| 2997 | function, which captures the standard output and standard error, and returns it |
| 2998 | as a string together with the return value.") |
| 2999 | (license license:expat))) |
| 3000 | |
| 3001 | (define-public julia-irtools |
| 3002 | (package |
| 3003 | (name "julia-irtools") |
| 3004 | (version "0.4.3") |
| 3005 | (source |
| 3006 | (origin |
| 3007 | (method git-fetch) |
| 3008 | (uri (git-reference |
| 3009 | (url "https://github.com/FluxML/IRTools.jl") |
| 3010 | (commit (string-append "v" version)))) |
| 3011 | (file-name (git-file-name name version)) |
| 3012 | (sha256 |
| 3013 | (base32 "11334fcg2slpwcj0raxf457brhf7pxglgxc6cy8q58ggrpxqfqql")))) |
| 3014 | (build-system julia-build-system) |
| 3015 | (propagated-inputs |
| 3016 | (list julia-macrotools)) |
| 3017 | (native-inputs |
| 3018 | (list julia-documenter)) |
| 3019 | (home-page "https://github.com/FluxML/IRTools.jl") |
| 3020 | (synopsis "Simple and flexible IR format") |
| 3021 | (description "This package provides a simple and flexible IR format, |
| 3022 | expressive enough to work with both lowered and typed Julia code, as well as |
| 3023 | external IRs. It can be used with Julia metaprogramming tools such as |
| 3024 | Cassette.") |
| 3025 | (license license:expat))) |
| 3026 | |
| 3027 | (define-public julia-iteratorinterfaceextensions |
| 3028 | (package |
| 3029 | (name "julia-iteratorinterfaceextensions") |
| 3030 | (version "1.0.0") |
| 3031 | (source |
| 3032 | (origin |
| 3033 | (method git-fetch) |
| 3034 | (uri (git-reference |
| 3035 | (url "https://github.com/queryverse/IteratorInterfaceExtensions.jl") |
| 3036 | (commit (string-append "v" version)))) |
| 3037 | (file-name (git-file-name name version)) |
| 3038 | (sha256 |
| 3039 | (base32 "1slpay1dhja8f9gy6z7b3psgvgcknn963dvfqqakvg1grk9ppa09")))) |
| 3040 | (build-system julia-build-system) |
| 3041 | (home-page "https://github.com/queryverse/IteratorInterfaceExtensions.jl") |
| 3042 | (synopsis "Traits for Julia iterators") |
| 3043 | (description "IteratorInterfaceExtensions defines a small number of |
| 3044 | extensions to the iterator interface.") |
| 3045 | (license license:expat))) |
| 3046 | |
| 3047 | (define-public julia-itertools |
| 3048 | (package |
| 3049 | (name "julia-itertools") |
| 3050 | (version "1.3.0") |
| 3051 | (source |
| 3052 | (origin |
| 3053 | (method git-fetch) |
| 3054 | (uri (git-reference |
| 3055 | (url "https://github.com/JuliaCollections/IterTools.jl") |
| 3056 | (commit (string-append "v" version)))) |
| 3057 | (file-name (git-file-name name version)) |
| 3058 | (sha256 |
| 3059 | (base32 "0haf974kcqj6arv4if97ahs4w3dmvslh6ab3hl57r9s41ic36xdq")))) |
| 3060 | (build-system julia-build-system) |
| 3061 | (home-page "https://github.com/JuliaCollections/IterTools.jl") |
| 3062 | (synopsis "Common functional iterator patterns") |
| 3063 | (description |
| 3064 | "Common functional iterator patterns (formerly @code{Iterators.jl}).") |
| 3065 | (license license:expat))) |
| 3066 | |
| 3067 | (define-public julia-jive |
| 3068 | (package |
| 3069 | (name "julia-jive") |
| 3070 | (version "0.2.20") |
| 3071 | (source |
| 3072 | (origin |
| 3073 | (method git-fetch) |
| 3074 | (uri (git-reference |
| 3075 | (url "https://github.com/wookay/Jive.jl") |
| 3076 | (commit (string-append "v" version)))) |
| 3077 | (file-name (git-file-name name version)) |
| 3078 | (sha256 |
| 3079 | (base32 "0khwsdh8472jxcfi9lqw14l49sqlbsixql1jb4irnyajxkdjrcsf")))) |
| 3080 | (build-system julia-build-system) |
| 3081 | (home-page "https://github.com/wookay/Jive.jl") |
| 3082 | (synopsis "Julia package to help with writing tests") |
| 3083 | (description "@code{Jive.jl} is a Julia package to help with writing tests.") |
| 3084 | (license license:expat))) |
| 3085 | |
| 3086 | (define-public julia-json |
| 3087 | (package |
| 3088 | (name "julia-json") |
| 3089 | (version "0.21.1") |
| 3090 | (source |
| 3091 | (origin |
| 3092 | (method git-fetch) |
| 3093 | (uri (git-reference |
| 3094 | (url "https://github.com/JuliaIO/JSON.jl") |
| 3095 | (commit (string-append "v" version)))) |
| 3096 | (file-name (git-file-name name version)) |
| 3097 | (sha256 |
| 3098 | (base32 "1f9k613kbknmp4fgjxvjaw4d5sfbx8a5hmcszmp1w9rqfqngjx9m")))) |
| 3099 | (build-system julia-build-system) |
| 3100 | (propagated-inputs |
| 3101 | (list julia-datastructures |
| 3102 | julia-fixedpointnumbers |
| 3103 | julia-parsers |
| 3104 | julia-offsetarrays)) |
| 3105 | (home-page "https://github.com/JuliaIO/JSON.jl") |
| 3106 | (synopsis "JSON parsing and printing library for Julia") |
| 3107 | (description "@code{JSON.jl} is a pure Julia module which supports parsing |
| 3108 | and printing JSON documents.") |
| 3109 | (license license:expat))) |
| 3110 | |
| 3111 | (define-public julia-json3 |
| 3112 | (package |
| 3113 | (name "julia-json3") |
| 3114 | (version "1.9.0") |
| 3115 | (source |
| 3116 | (origin |
| 3117 | (method git-fetch) |
| 3118 | (uri (git-reference |
| 3119 | (url "https://github.com/quinnj/JSON3.jl") |
| 3120 | (commit (string-append "v" version)))) |
| 3121 | (file-name (git-file-name name version)) |
| 3122 | (sha256 |
| 3123 | (base32 "11z5maz7v50wd99id8z7838higza0cllh2amkdkrlskbri3v2f17")))) |
| 3124 | (build-system julia-build-system) |
| 3125 | (propagated-inputs |
| 3126 | (list julia-parsers |
| 3127 | julia-structtypes)) |
| 3128 | (home-page "https://github.com/quinnj/JSON3.jl") |
| 3129 | (synopsis "JSON package for Julia") |
| 3130 | (description "This package provides another JSON package for Julia, with a |
| 3131 | focus on speed and slick struct mapping.") |
| 3132 | (license license:expat))) |
| 3133 | |
| 3134 | (define-public julia-juno |
| 3135 | (package |
| 3136 | (name "julia-juno") |
| 3137 | (version "0.8.4") |
| 3138 | (source |
| 3139 | (origin |
| 3140 | (method git-fetch) |
| 3141 | (uri (git-reference |
| 3142 | (url "https://github.com/JunoLab/Juno.jl") |
| 3143 | (commit (string-append "v" version)))) |
| 3144 | (file-name (git-file-name name version)) |
| 3145 | (sha256 |
| 3146 | (base32 "02ryj5blnrmck3jisrpwn1x563i7rsg65d7zms52njsvv499gygk")))) |
| 3147 | (build-system julia-build-system) |
| 3148 | (inputs |
| 3149 | (list julia-media)) |
| 3150 | (home-page "https://github.com/JunoLab/Juno.jl") |
| 3151 | (synopsis "Integrated Development Environment (IDE) for Julia") |
| 3152 | (description "This package provides tools to help you develop code. Juno |
| 3153 | is built on the Atom text editor. Juno consists of both Julia and Atom |
| 3154 | packages in order to add Julia-specific enhancements, such as syntax |
| 3155 | highlighting, a plot pane, integration with Julia's debugger, a console for |
| 3156 | running code, and much more. |
| 3157 | |
| 3158 | Consider that the package is “maintenance-only mode” and only receives bug |
| 3159 | fixes. The Julia IDE effort is pointed to extension for VSCode.") |
| 3160 | (license license:expat))) |
| 3161 | |
| 3162 | (define-public julia-latexstrings |
| 3163 | (package |
| 3164 | (name "julia-latexstrings") |
| 3165 | (version "1.2.1") |
| 3166 | (source |
| 3167 | (origin |
| 3168 | (method git-fetch) |
| 3169 | (uri (git-reference |
| 3170 | (url "https://github.com/stevengj/LaTeXStrings.jl") |
| 3171 | (commit (string-append "v" version)))) |
| 3172 | (file-name (git-file-name name version)) |
| 3173 | (sha256 |
| 3174 | (base32 "117z27krcf8fydgp6mb0pgn75r4gng9qs7v90qb4bqzsry3faadp")))) |
| 3175 | (build-system julia-build-system) |
| 3176 | (native-inputs |
| 3177 | (list julia-documenter)) |
| 3178 | (home-page "https://github.com/stevengj/LaTeXStrings.jl") |
| 3179 | (synopsis "Input and display of LaTeX equation strings") |
| 3180 | (description "This is a small package to make it easier to type LaTeX |
| 3181 | equations in string literals in the Julia language.") |
| 3182 | (license license:expat))) |
| 3183 | |
| 3184 | (define-public julia-lazyarrays |
| 3185 | (package |
| 3186 | (name "julia-lazyarrays") |
| 3187 | (version "0.22.2") |
| 3188 | (source |
| 3189 | (origin |
| 3190 | (method git-fetch) |
| 3191 | (uri (git-reference |
| 3192 | (url "https://github.com/JuliaArrays/LazyArrays.jl") |
| 3193 | (commit (string-append "v" version)))) |
| 3194 | (file-name (git-file-name name version)) |
| 3195 | (sha256 |
| 3196 | (base32 "17rhlrmgfvdw8w62pg32ikr9j4xy2ylr7mx7ar0hnpzryv929rp5")))) |
| 3197 | (build-system julia-build-system) |
| 3198 | (arguments |
| 3199 | (list |
| 3200 | #:phases |
| 3201 | (if (target-64bit?) |
| 3202 | #~%standard-phases |
| 3203 | #~(modify-phases %standard-phases |
| 3204 | (add-after 'unpack 'fix-tests-int32-i686 |
| 3205 | (lambda _ |
| 3206 | (substitute* "test/multests.jl" |
| 3207 | (("Int64") "Int32")))))))) |
| 3208 | (propagated-inputs |
| 3209 | (list julia-arraylayouts |
| 3210 | julia-fillarrays |
| 3211 | julia-macrotools |
| 3212 | julia-matrixfactorizations |
| 3213 | julia-staticarrays)) |
| 3214 | (native-inputs |
| 3215 | (list julia-tracker)) |
| 3216 | (home-page "https://github.com/JuliaArrays/LazyArrays.jl") |
| 3217 | (synopsis "Lazy arrays and linear algebra") |
| 3218 | (description "This package supports lazy analogues of array operations like |
| 3219 | @code{vcat}, @code{hcat}, and multiplication. This helps with the |
| 3220 | implementation of matrix-free methods for iterative solvers.") |
| 3221 | (license license:expat))) |
| 3222 | |
| 3223 | (define-public julia-linesearches |
| 3224 | (package |
| 3225 | (name "julia-linesearches") |
| 3226 | (version "7.1.1") |
| 3227 | (source |
| 3228 | (origin |
| 3229 | (method git-fetch) |
| 3230 | (uri (git-reference |
| 3231 | (url "https://github.com/JuliaNLSolvers/LineSearches.jl") |
| 3232 | (commit (string-append "v" version)))) |
| 3233 | (file-name (git-file-name name version)) |
| 3234 | (sha256 |
| 3235 | (base32 "1qc4la07w6s1xhcyd0hvbnpr31zc1a2ssgyybc8biv5m00g0dnr0")))) |
| 3236 | (build-system julia-build-system) |
| 3237 | (arguments |
| 3238 | (list |
| 3239 | #:phases |
| 3240 | #~(modify-phases %standard-phases |
| 3241 | (add-after 'link-depot 'skip-optim-tests |
| 3242 | (lambda _ |
| 3243 | (substitute* "test/examples.jl" |
| 3244 | ;; Prevent a cycle with Optim.jl. |
| 3245 | (("^ SKIPFILE.*") "") |
| 3246 | (("^ #SKIPFILE") " SKIPFILE")))) |
| 3247 | (add-after 'link-depot 'skip-doublefloats-tests |
| 3248 | (lambda _ |
| 3249 | (substitute* "test/runtests.jl" |
| 3250 | (("using DoubleFloats.*") "") |
| 3251 | ((".*arbitrary_precision\\.jl.*") ""))))))) |
| 3252 | (propagated-inputs |
| 3253 | (list julia-nlsolversbase |
| 3254 | julia-nanmath |
| 3255 | julia-parameters)) |
| 3256 | (native-inputs |
| 3257 | ;; DoubleFloats.jl transitively depends on TimeZones.jl, which is currently |
| 3258 | ;; unpackageable due to its oversized Artifacts.toml. |
| 3259 | (list ;julia-doublefloats |
| 3260 | julia-optimtestproblems)) |
| 3261 | (home-page "https://github.com/JuliaNLSolvers/LineSearches.jl") |
| 3262 | (synopsis "Line search methods for optimization and root-finding") |
| 3263 | (description "This package provides an interface to line search algorithms |
| 3264 | implemented in Julia.") |
| 3265 | (license license:expat))) |
| 3266 | |
| 3267 | (define-public julia-logexpfunctions |
| 3268 | (package |
| 3269 | (name "julia-logexpfunctions") |
| 3270 | (version "0.2.4") |
| 3271 | (source |
| 3272 | (origin |
| 3273 | (method git-fetch) |
| 3274 | (uri (git-reference |
| 3275 | (url "https://github.com/JuliaStats/LogExpFunctions.jl") |
| 3276 | (commit (string-append "v" version)))) |
| 3277 | (file-name (git-file-name name version)) |
| 3278 | (sha256 |
| 3279 | (base32 "0rvms3mmq8a1viqlyzdgs2ccddcy6j0c677dlb8m5nk6hkiwr16n")))) |
| 3280 | (build-system julia-build-system) |
| 3281 | (propagated-inputs |
| 3282 | (list julia-docstringextensions)) |
| 3283 | (native-inputs |
| 3284 | (list julia-offsetarrays)) |
| 3285 | (home-page "https://github.com/JuliaStats/LogExpFunctions.jl") |
| 3286 | (synopsis "Special functions based on @code{log} and @code{exp}") |
| 3287 | (description "Various special functions based on log and exp moved from |
| 3288 | @code{StatsFuns.jl} into a separate package, to minimize dependencies. These |
| 3289 | functions only use native Julia code, so there is no need to depend on |
| 3290 | @code{librmath} or similar libraries.") |
| 3291 | (license license:expat))) |
| 3292 | |
| 3293 | (define-public julia-macrotools |
| 3294 | (package |
| 3295 | (name "julia-macrotools") |
| 3296 | (version "0.5.6") |
| 3297 | (source |
| 3298 | (origin |
| 3299 | (method git-fetch) |
| 3300 | (uri (git-reference |
| 3301 | (url "https://github.com/FluxML/MacroTools.jl") |
| 3302 | (commit (string-append "v" version)))) |
| 3303 | (file-name (git-file-name name version)) |
| 3304 | (sha256 |
| 3305 | (base32 "0k4z2hyasd9cwxf4l61zk3w4ajs44k69wx6z1ghdn8f5p8xy217f")))) |
| 3306 | (build-system julia-build-system) |
| 3307 | (home-page "https://fluxml.ai/MacroTools.jl") |
| 3308 | (synopsis "Tools for working with Julia code and expressions") |
| 3309 | (description "This library provides tools for working with Julia code and |
| 3310 | expressions. This includes a template-matching system and code-walking tools |
| 3311 | that let you do deep transformations of code.") |
| 3312 | (license license:expat))) |
| 3313 | |
| 3314 | (define-public julia-mappedarrays |
| 3315 | (package |
| 3316 | (name "julia-mappedarrays") |
| 3317 | (version "0.4.0") |
| 3318 | (source |
| 3319 | (origin |
| 3320 | (method git-fetch) |
| 3321 | (uri (git-reference |
| 3322 | (url "https://github.com/JuliaArrays/MappedArrays.jl") |
| 3323 | (commit (string-append "v" version)))) |
| 3324 | (file-name (git-file-name name version)) |
| 3325 | (sha256 |
| 3326 | (base32 "0l5adird8m1cmnsxwhzi5hcr7q9bm1rf7a6018zc7kcn2yxdshy3")))) |
| 3327 | (build-system julia-build-system) |
| 3328 | (arguments |
| 3329 | (list |
| 3330 | #:phases |
| 3331 | (if (target-64bit?) |
| 3332 | #~%standard-phases |
| 3333 | #~(modify-phases %standard-phases |
| 3334 | (add-after 'unpack 'fix-tests-int32-i686 |
| 3335 | (lambda _ |
| 3336 | (substitute* "test/runtests.jl" |
| 3337 | (("Int64") "Int32")))))))) |
| 3338 | (propagated-inputs |
| 3339 | (list julia-fixedpointnumbers)) |
| 3340 | (native-inputs |
| 3341 | (list julia-colortypes |
| 3342 | julia-fixedpointnumbers |
| 3343 | julia-offsetarrays)) |
| 3344 | (home-page "https://github.com/JuliaArrays/MappedArrays.jl") |
| 3345 | (synopsis "Lazy in-place transformations of arrays") |
| 3346 | (description "This package implements \"lazy\" in-place elementwise |
| 3347 | transformations of arrays for the Julia programming language. Explicitly, it |
| 3348 | provides a \"view\" M of an array A so that @code{M[i] = f(A[i])} for a |
| 3349 | specified (but arbitrary) function f, without ever having to compute M |
| 3350 | explicitly (in the sense of allocating storage for M). The name of the package |
| 3351 | comes from the fact that @code{M == map(f, A)}.") |
| 3352 | (license license:expat))) |
| 3353 | |
| 3354 | (define-public julia-matrixfactorizations |
| 3355 | (package |
| 3356 | (name "julia-matrixfactorizations") |
| 3357 | (version "0.8.4") |
| 3358 | (source |
| 3359 | (origin |
| 3360 | (method git-fetch) |
| 3361 | (uri (git-reference |
| 3362 | (url "https://github.com/JuliaMatrices/MatrixFactorizations.jl") |
| 3363 | (commit (string-append "v" version)))) |
| 3364 | (file-name (git-file-name name version)) |
| 3365 | (sha256 |
| 3366 | (base32 "15zvcv2l4iqmjpnqjyx2kry7a85p652nbjy9pj3wq0piksqcz4jb")))) |
| 3367 | (build-system julia-build-system) |
| 3368 | (arguments |
| 3369 | (list |
| 3370 | #:phases |
| 3371 | #~(modify-phases %standard-phases |
| 3372 | (add-after 'link-depot 'skip-failing-test |
| 3373 | (lambda _ |
| 3374 | ;; Tests with math functions are hard. |
| 3375 | (substitute* "test/test_ul.jl" |
| 3376 | (("@test @inferred\\(logdet") "@test @test_nowarn(logdet") |
| 3377 | ;; Also skip the REPL test. |
| 3378 | (("test String") "test_nowarn String"))))))) |
| 3379 | (propagated-inputs |
| 3380 | (list julia-arraylayouts)) |
| 3381 | (home-page "https://github.com/JuliaMatrices/MatrixFactorizations.jl") |
| 3382 | (synopsis "Julia package to contain non-standard matrix factorizations") |
| 3383 | (description "A Julia package to contain non-standard matrix factorizations. |
| 3384 | At the moment it implements the QL, RQ, and UL factorizations, a combined |
| 3385 | Cholesky factorization with inverse, and polar decompositions. In the future it |
| 3386 | may include other factorizations such as the LQ factorization.") |
| 3387 | (license license:expat))) |
| 3388 | |
| 3389 | (define-public julia-mbedtls |
| 3390 | (package |
| 3391 | (name "julia-mbedtls") |
| 3392 | (version "1.0.3") |
| 3393 | (source |
| 3394 | (origin |
| 3395 | (method git-fetch) |
| 3396 | (uri (git-reference |
| 3397 | (url "https://github.com/JuliaLang/MbedTLS.jl") |
| 3398 | (commit (string-append "v" version)))) |
| 3399 | (file-name (git-file-name name version)) |
| 3400 | (sha256 |
| 3401 | (base32 "0zjzf2r57l24n3k0gcqkvx3izwn5827iv9ak0lqix0aa5967wvfb")))) |
| 3402 | (build-system julia-build-system) |
| 3403 | (arguments |
| 3404 | (list |
| 3405 | #:phases |
| 3406 | #~(modify-phases %standard-phases |
| 3407 | (add-before 'install 'disable-network-tests |
| 3408 | ;; Tries to connect to httpbin.org |
| 3409 | (lambda _ |
| 3410 | (substitute* "test/runtests.jl" |
| 3411 | (("testhost =") "return #"))))))) |
| 3412 | (propagated-inputs |
| 3413 | (list julia-mbedtls-jll)) |
| 3414 | (home-page "https://github.com/JuliaLang/MbedTLS.jl") |
| 3415 | (synopsis "Apache's mbed TLS library wrapper") |
| 3416 | (description "@code{MbedTLS.jl} provides a wrapper around the @code{mbed |
| 3417 | TLS} and cryptography C library for Julia.") |
| 3418 | (license license:expat))) |
| 3419 | |
| 3420 | (define-public julia-measurements |
| 3421 | (package |
| 3422 | (name "julia-measurements") |
| 3423 | (version "2.6.0") |
| 3424 | (source |
| 3425 | (origin |
| 3426 | (method git-fetch) |
| 3427 | (uri (git-reference |
| 3428 | (url "https://github.com/JuliaPhysics/Measurements.jl") |
| 3429 | (commit (string-append "v" version)))) |
| 3430 | (file-name (git-file-name name version)) |
| 3431 | (sha256 |
| 3432 | (base32 "05p3f0gr4sv4maq8cix5fi8ldq0zagswqsd43xn6fhy046f936mz")))) |
| 3433 | (build-system julia-build-system) |
| 3434 | (propagated-inputs |
| 3435 | (list julia-calculus |
| 3436 | julia-recipesbase |
| 3437 | julia-requires)) |
| 3438 | (native-inputs |
| 3439 | (list julia-quadgk |
| 3440 | julia-specialfunctions |
| 3441 | julia-unitful)) |
| 3442 | (home-page "https://juliaphysics.github.io/Measurements.jl/stable/") |
| 3443 | (synopsis "Error propagation calculator and library") |
| 3444 | (description "@code{Measurements.jl} is an error propagation calculator and |
| 3445 | library for physical measurements. It supports real and complex numbers with |
| 3446 | uncertainty, arbitrary precision calculations, operations with arrays, and |
| 3447 | numerical integration. The linear error propagation theory is employed to |
| 3448 | propagate the errors.") |
| 3449 | (license license:expat))) |
| 3450 | |
| 3451 | (define-public julia-measures |
| 3452 | (package |
| 3453 | (name "julia-measures") |
| 3454 | (version "0.3.1") |
| 3455 | (source |
| 3456 | (origin |
| 3457 | (method git-fetch) |
| 3458 | (uri (git-reference |
| 3459 | (url "https://github.com/JuliaGraphics/Measures.jl") |
| 3460 | (commit (string-append "v" version)))) |
| 3461 | (file-name (git-file-name name version)) |
| 3462 | (sha256 |
| 3463 | (base32 "0j34psrdijnqqn9zv0r2sknr1p9q0mmbjvjhmjra37bb5fh2gk8l")))) |
| 3464 | (build-system julia-build-system) |
| 3465 | (home-page "https://github.com/JuliaGraphics/Measures.jl") |
| 3466 | (synopsis "Unified measure and coordinates types") |
| 3467 | (description "This library generalizes and unifies the notion of measures |
| 3468 | used in Compose, Compose3D, and Escher. It allows building up and representing |
| 3469 | expressions involving differing types of units that are then evaluated, |
| 3470 | resolving them into absolute units.") |
| 3471 | (license license:expat))) |
| 3472 | |
| 3473 | (define-public julia-media |
| 3474 | (package |
| 3475 | (name "julia-media") |
| 3476 | (version "0.5.0") |
| 3477 | (source |
| 3478 | (origin |
| 3479 | (method git-fetch) |
| 3480 | (uri (git-reference |
| 3481 | (url "https://github.com/JunoLab/Media.jl") |
| 3482 | (commit (string-append "v" version)))) |
| 3483 | (file-name (git-file-name name version)) |
| 3484 | (sha256 |
| 3485 | (base32 "05jq9j3vs8yfj2lwz3sh1vk5rha06xdcikp9s2q3dn316vryy6di")))) |
| 3486 | (build-system julia-build-system) |
| 3487 | ;; Package without Project.toml |
| 3488 | (arguments |
| 3489 | (list |
| 3490 | #:julia-package-name "Media" |
| 3491 | #:julia-package-uuid "e89f7d12-3494-54d1-8411-f7d8b9ae1f27" |
| 3492 | #:julia-package-dependencies |
| 3493 | #~(list '("MacroTools" . "1914dd2f-81c6-5fcd-8719-6d5c9610ff09")))) |
| 3494 | (propagated-inputs |
| 3495 | (list julia-macrotools)) |
| 3496 | (home-page "https://github.com/JunoLab/Media.jl") |
| 3497 | (synopsis "Unified measure and coordinates types") |
| 3498 | (description "This package provides a display system which enables the |
| 3499 | user handle multiple input/output devices and decide what media types get |
| 3500 | displayed where.") |
| 3501 | (license license:expat))) |
| 3502 | |
| 3503 | (define-public julia-millboard |
| 3504 | (package |
| 3505 | (name "julia-millboard") |
| 3506 | (version "0.2.5") |
| 3507 | (source |
| 3508 | (origin |
| 3509 | (method git-fetch) |
| 3510 | (uri (git-reference |
| 3511 | (url "https://github.com/wookay/Millboard.jl") |
| 3512 | (commit (string-append "v" version)))) |
| 3513 | (file-name (git-file-name name version)) |
| 3514 | (sha256 |
| 3515 | (base32 "0k9jqgp285qhckldvvsmfk6s69dcr8s74m2fijgm2vxjj2gqjs1n")))) |
| 3516 | (build-system julia-build-system) |
| 3517 | (native-inputs |
| 3518 | (list julia-jive)) |
| 3519 | (home-page "https://github.com/wookay/Millboard.jl") |
| 3520 | (synopsis "Displaying data in tables for Julia") |
| 3521 | (description |
| 3522 | "@code{Millboard.jl} provides a library for getting data in a tablized |
| 3523 | format to arrange into rows and columns of cells.") |
| 3524 | (license license:expat))) |
| 3525 | |
| 3526 | (define-public julia-missings |
| 3527 | (package |
| 3528 | (name "julia-missings") |
| 3529 | (version "1.0.2") |
| 3530 | (source |
| 3531 | (origin |
| 3532 | (method git-fetch) |
| 3533 | (uri (git-reference |
| 3534 | (url "https://github.com/JuliaData/Missings.jl") |
| 3535 | (commit (string-append "v" version)))) |
| 3536 | (file-name (git-file-name name version)) |
| 3537 | (sha256 |
| 3538 | (base32 "1k481rm5lahmjyh34j177d4n10svgr0wm7ps5m3ar3xx6nr26ad5")))) |
| 3539 | (build-system julia-build-system) |
| 3540 | (propagated-inputs |
| 3541 | (list julia-dataapi)) |
| 3542 | (home-page "https://github.com/JuliaData/Missings.jl") |
| 3543 | (synopsis "Additional missing value support for Julia") |
| 3544 | (description "This package provides additional functionality for working |
| 3545 | with @code{missing} values in Julia.") |
| 3546 | (license license:expat))) |
| 3547 | |
| 3548 | (define-public julia-mlstyle |
| 3549 | (package |
| 3550 | (name "julia-mlstyle") |
| 3551 | (version "0.4.10") |
| 3552 | (source |
| 3553 | (origin |
| 3554 | (method git-fetch) |
| 3555 | (uri (git-reference |
| 3556 | (url "https://github.com/thautwarm/MLStyle.jl") |
| 3557 | (commit (string-append "v" version)))) |
| 3558 | (file-name (git-file-name name version)) |
| 3559 | (sha256 |
| 3560 | (base32 "0h1cd7cr4c4cnpqyj3180113gdbvcc047lqphp8a8gq5smp3c059")))) |
| 3561 | (build-system julia-build-system) |
| 3562 | (native-inputs |
| 3563 | (list julia-datastructures)) |
| 3564 | (home-page "https://thautwarm.github.io/MLStyle.jl/latest/") |
| 3565 | (synopsis "Julia functional programming infrastructures") |
| 3566 | (description "This package provides consistent and extensible functional |
| 3567 | programming infrastructures, and metaprogramming facilities.") |
| 3568 | (license license:expat))) |
| 3569 | |
| 3570 | (define-public julia-mocking |
| 3571 | (package |
| 3572 | (name "julia-mocking") |
| 3573 | (version "0.7.3") |
| 3574 | (source |
| 3575 | (origin |
| 3576 | (method git-fetch) |
| 3577 | (uri (git-reference |
| 3578 | (url "https://github.com/invenia/Mocking.jl") |
| 3579 | (commit (string-append "v" version)))) |
| 3580 | (file-name (git-file-name name version)) |
| 3581 | (sha256 |
| 3582 | (base32 "1cg2is83bjmrchmmxcgx57k8c9b9vlamrw38v4fdhbb6d4six5cg")))) |
| 3583 | (build-system julia-build-system) |
| 3584 | (propagated-inputs |
| 3585 | (list julia-compat |
| 3586 | julia-exprtools)) |
| 3587 | (home-page "https://github.com/invenia/Mocking.jl") |
| 3588 | (synopsis "Overload Julia function calls") |
| 3589 | (description "The purpose of this package is to allow Julia function calls |
| 3590 | to be temporarily overloaded for the purpose of testing.") |
| 3591 | (license license:expat))) |
| 3592 | |
| 3593 | (define-public julia-mosaicviews |
| 3594 | (package |
| 3595 | (name "julia-mosaicviews") |
| 3596 | (version "0.3.3") |
| 3597 | (source |
| 3598 | (origin |
| 3599 | (method git-fetch) |
| 3600 | (uri (git-reference |
| 3601 | (url "https://github.com/JuliaArrays/MosaicViews.jl") |
| 3602 | (commit (string-append "v" version)))) |
| 3603 | (file-name (git-file-name name version)) |
| 3604 | (sha256 |
| 3605 | (base32 "04fgxghyb7n2ji76xkb1r1fjhzsdbgmp5wsfyyn3yjcsdqbyp8pz")))) |
| 3606 | (build-system julia-build-system) |
| 3607 | (arguments |
| 3608 | (list #:tests? #f)) ; Cycle with ImageCore.jl |
| 3609 | (propagated-inputs |
| 3610 | (list julia-mappedarrays |
| 3611 | julia-paddedviews |
| 3612 | julia-stackviews)) |
| 3613 | ;(native-inputs |
| 3614 | ; `(("julia-colorvectorspace" ,julia-colorvectorspace) |
| 3615 | ; ("julia-imagecore" ,julia-imagecore))) |
| 3616 | (home-page "https://github.com/JuliaArrays/MosaicViews.jl") |
| 3617 | (synopsis |
| 3618 | "Lazily view a 3D or 4D array as an expanded 2D array as a matrix of slices") |
| 3619 | (description "When visualizing images, it is not uncommon to provide a 2D |
| 3620 | view of different image sources. For example, comparing multiple images of |
| 3621 | different sizes, getting a preview of machine learning dataset. This package |
| 3622 | aims to provide easy-to-use tools for such tasks.") |
| 3623 | (license license:expat))) |
| 3624 | |
| 3625 | (define-public julia-msgpack |
| 3626 | (package |
| 3627 | (name "julia-msgpack") |
| 3628 | (version "1.1.0") |
| 3629 | (source |
| 3630 | (origin |
| 3631 | (method git-fetch) |
| 3632 | (uri (git-reference |
| 3633 | (url "https://github.com/JuliaIO/MsgPack.jl") |
| 3634 | (commit (string-append "v" version)))) |
| 3635 | (file-name (git-file-name name version)) |
| 3636 | (sha256 |
| 3637 | (base32 "1layiqjf9si38pfdcszppgcy4zbfqgld7jlw8x645sm9b17b19fg")))) |
| 3638 | (build-system julia-build-system) |
| 3639 | (home-page "https://github.com/JuliaIO/MsgPack.jl") |
| 3640 | (synopsis "Julia MsgPack implementation") |
| 3641 | (description "@code{MsgPack.jl} is a MessagePack implementation in pure |
| 3642 | Julia, with type-driven, overloadable packing/unpacking functionality.") |
| 3643 | (license license:expat))) |
| 3644 | |
| 3645 | (define-public julia-mutablearithmetics |
| 3646 | (package |
| 3647 | (name "julia-mutablearithmetics") |
| 3648 | (version "0.2.20") |
| 3649 | (source |
| 3650 | (origin |
| 3651 | (method git-fetch) |
| 3652 | (uri (git-reference |
| 3653 | (url "https://github.com/jump-dev/MutableArithmetics.jl") |
| 3654 | (commit (string-append "v" version)))) |
| 3655 | (file-name (git-file-name name version)) |
| 3656 | (sha256 |
| 3657 | (base32 "1isyj8h4nx96cr6892d154v8pw1nhr7mjyz5bd6ffr2mkzb2bq4f")))) |
| 3658 | (build-system julia-build-system) |
| 3659 | (arguments |
| 3660 | (list |
| 3661 | #:phases |
| 3662 | (if (target-x86-32?) |
| 3663 | #~(modify-phases %standard-phases |
| 3664 | (add-after 'unpack 'remove-failing-test-i686 |
| 3665 | (lambda _ |
| 3666 | (substitute* "test/utilities.jl" |
| 3667 | ;; Non-deterministic returned value, e.g., |
| 3668 | ;; Expression: n == @allocated(f()) |
| 3669 | ;; Evaluated: 240 == 120 |
| 3670 | ;; and for some other values: |
| 3671 | ;; Got correct result, please change to @test |
| 3672 | ;; so @test_broken is not enough. |
| 3673 | (("@test n == @allocated f\\(\\)") |
| 3674 | " "))))) |
| 3675 | #~%standard-phases))) |
| 3676 | (propagated-inputs |
| 3677 | (list julia-offsetarrays)) |
| 3678 | (home-page "https://github.com/jump-dev/MutableArithmetics.jl") |
| 3679 | (synopsis "Interface for arithmetics on mutable types in Julia") |
| 3680 | (description "MutableArithmetics is a Julia package which allows: |
| 3681 | @itemize |
| 3682 | @item mutable types to implement mutable arithmetics |
| 3683 | @item algorithms that could exploit mutable arithmetics to exploit them while |
| 3684 | still being completely generic |
| 3685 | @end itemize") |
| 3686 | (license license:mpl2.0))) |
| 3687 | |
| 3688 | (define-public julia-nanmath |
| 3689 | (package |
| 3690 | (name "julia-nanmath") |
| 3691 | (version "0.3.5") |
| 3692 | (source |
| 3693 | (origin |
| 3694 | (method git-fetch) |
| 3695 | (uri (git-reference |
| 3696 | (url "https://github.com/mlubin/NaNMath.jl") |
| 3697 | (commit (string-append "v" version)))) |
| 3698 | (file-name (git-file-name name version)) |
| 3699 | (sha256 |
| 3700 | (base32 "1hczhz00qj99w63vp627kwk02l2sr2qmzc2rkwwkdwvzy670p25q")))) |
| 3701 | (build-system julia-build-system) |
| 3702 | (home-page "https://github.com/mlubin/NaNMath.jl") |
| 3703 | (synopsis "Implementations of basic math functions") |
| 3704 | (description "Implementations of basic math functions which return |
| 3705 | @code{NaN} instead of throwing a @code{DomainError}.") |
| 3706 | (license license:expat))) |
| 3707 | |
| 3708 | (define-public julia-nlsolversbase |
| 3709 | (package |
| 3710 | (name "julia-nlsolversbase") |
| 3711 | (version "7.8.0") |
| 3712 | (source |
| 3713 | (origin |
| 3714 | (method git-fetch) |
| 3715 | (uri (git-reference |
| 3716 | (url "https://github.com/JuliaNLSolvers/NLSolversBase.jl") |
| 3717 | (commit (string-append "v" version)))) |
| 3718 | (file-name (git-file-name name version)) |
| 3719 | (sha256 |
| 3720 | (base32 "0n8qh5a2ghjx1j70zxn0hmh8gzpa46kmjg8di879y9974bfk0f98")))) |
| 3721 | (build-system julia-build-system) |
| 3722 | (propagated-inputs |
| 3723 | (list julia-diffresults |
| 3724 | julia-finitediff |
| 3725 | julia-forwarddiff)) |
| 3726 | (native-inputs |
| 3727 | (list julia-optimtestproblems |
| 3728 | julia-recursivearraytools)) |
| 3729 | (home-page "https://github.com/JuliaNLSolvers/NLSolversBase.jl") |
| 3730 | (synopsis "Optimization and equation solver software in JuliaNLSolvers") |
| 3731 | (description "This package aims at establishing common ground for Optim.jl, |
| 3732 | LineSearches.jl, and NLsolve.jl. The common ground is mainly the types used to |
| 3733 | hold objective related callables, information about the objectives, and an |
| 3734 | interface to interact with these types.") |
| 3735 | (license license:expat))) |
| 3736 | |
| 3737 | (define-public julia-nnlib |
| 3738 | (package |
| 3739 | (name "julia-nnlib") |
| 3740 | (version "0.7.29") |
| 3741 | (source |
| 3742 | (origin |
| 3743 | (method git-fetch) |
| 3744 | (uri (git-reference |
| 3745 | (url "https://github.com/FluxML/NNlib.jl") |
| 3746 | (commit (string-append "v" version)))) |
| 3747 | (file-name (git-file-name name version)) |
| 3748 | (sha256 |
| 3749 | (base32 "16vn5w5274kcywh1xp0zqjk5q10xrk125aznz5av6wifwrvghk8s")))) |
| 3750 | (build-system julia-build-system) |
| 3751 | (arguments |
| 3752 | (list |
| 3753 | #:phases |
| 3754 | #~(modify-phases %standard-phases |
| 3755 | (add-after 'link-depot 'skip-cuda-tests |
| 3756 | (lambda _ |
| 3757 | (substitute* "test/runtests.jl" |
| 3758 | (("using CUDA") "") |
| 3759 | (("&& CUDA\\.functional\\(\\)") "")) |
| 3760 | (setenv "NNLIB_TEST_CUDA" "false")))))) |
| 3761 | (propagated-inputs |
| 3762 | (list julia-adapt |
| 3763 | julia-chainrulescore |
| 3764 | julia-requires)) |
| 3765 | (native-inputs |
| 3766 | (list julia-chainrulestestutils |
| 3767 | julia-stablerngs |
| 3768 | julia-zygote)) |
| 3769 | (home-page "https://github.com/FluxML/NNlib.jl") |
| 3770 | (synopsis "Neural Network primitives with multiple backends") |
| 3771 | (description "This package will provide a library of functions useful for |
| 3772 | machine learning, such as softmax, sigmoid, convolutions and pooling. It |
| 3773 | doesn't provide any other \"high-level\" functionality like layers or AD.") |
| 3774 | (license license:expat))) |
| 3775 | |
| 3776 | (define-public julia-optim |
| 3777 | (package |
| 3778 | (name "julia-optim") |
| 3779 | (version "1.6.0") |
| 3780 | (source |
| 3781 | (origin |
| 3782 | (method git-fetch) |
| 3783 | (uri (git-reference |
| 3784 | (url "https://github.com/JuliaNLSolvers/Optim.jl") |
| 3785 | (commit (string-append "v" version)))) |
| 3786 | (file-name (git-file-name name version)) |
| 3787 | (sha256 |
| 3788 | (base32 "0nvl3xp9c6r80y9n7fic4zyq2443apfmbcpnx0wvgkv4vsy08x5j")))) |
| 3789 | (build-system julia-build-system) |
| 3790 | (arguments |
| 3791 | (list |
| 3792 | #:phases |
| 3793 | #~(modify-phases %standard-phases |
| 3794 | (add-after 'unpack 'adjust-tests |
| 3795 | (lambda _ |
| 3796 | ;; TODO: Figure out why this test fails. |
| 3797 | (substitute* "test/runtests.jl" |
| 3798 | ((".*l_bfgs.*") ""))))))) |
| 3799 | (propagated-inputs |
| 3800 | (list julia-compat |
| 3801 | julia-fillarrays |
| 3802 | julia-forwarddiff |
| 3803 | julia-linesearches |
| 3804 | julia-nanmath |
| 3805 | julia-nlsolversbase |
| 3806 | julia-parameters |
| 3807 | julia-positivefactorizations |
| 3808 | julia-statsbase)) |
| 3809 | (native-inputs |
| 3810 | (list julia-linesearches |
| 3811 | julia-measurements |
| 3812 | julia-nlsolversbase |
| 3813 | julia-optimtestproblems |
| 3814 | julia-positivefactorizations |
| 3815 | julia-recursivearraytools |
| 3816 | julia-stablerngs)) |
| 3817 | (home-page "https://github.com/JuliaNLSolvers/Optim.jl") |
| 3818 | (synopsis "Optimization functions for Julia") |
| 3819 | (description "@code{Optim.jl} is a package for univariate and multivariate |
| 3820 | optimization of functions.") |
| 3821 | (license license:expat))) |
| 3822 | |
| 3823 | (define-public julia-optimtestproblems |
| 3824 | (package |
| 3825 | (name "julia-optimtestproblems") |
| 3826 | (version "2.0.2") |
| 3827 | (source |
| 3828 | (origin |
| 3829 | (method git-fetch) |
| 3830 | (uri (git-reference |
| 3831 | (url "https://github.com/JuliaNLSolvers/OptimTestProblems.jl") |
| 3832 | (commit (string-append "v" version)))) |
| 3833 | (file-name (git-file-name name version)) |
| 3834 | (sha256 |
| 3835 | (base32 "10h47x5ws42pkqjccimaz0yxfvz41w0yazq6inamfk4lg5g2g3d9")))) |
| 3836 | (build-system julia-build-system) |
| 3837 | (arguments |
| 3838 | (list |
| 3839 | #:julia-package-name "OptimTestProblems" |
| 3840 | #:julia-package-uuid "cec144fc-5a64-5bc6-99fb-dde8f63e154c")) |
| 3841 | (home-page "https://github.com/JuliaNLSolvers/OptimTestProblems.jl") |
| 3842 | (synopsis "Collection of optimization test problems") |
| 3843 | (description "The purpose of this package is to provide test problems for |
| 3844 | JuliaNLSolvers packages.") |
| 3845 | (license license:expat))) |
| 3846 | |
| 3847 | (define-public julia-orderedcollections |
| 3848 | (package |
| 3849 | (name "julia-orderedcollections") |
| 3850 | (version "1.4.1") |
| 3851 | (source |
| 3852 | (origin |
| 3853 | (method git-fetch) |
| 3854 | (uri (git-reference |
| 3855 | (url "https://github.com/JuliaCollections/OrderedCollections.jl") |
| 3856 | (commit (string-append "v" version)))) |
| 3857 | (file-name (git-file-name name version)) |
| 3858 | (sha256 |
| 3859 | (base32 "0jaxcmvkp8zpqrz101yikdigz90s70i7in5wn8kybwzf0na3lhwf")))) |
| 3860 | (build-system julia-build-system) |
| 3861 | (home-page "https://github.com/JuliaCollections/OrderedCollections.jl") |
| 3862 | (synopsis "Associative containers that preserve insertion order") |
| 3863 | (description "This package implements @code{OrderedDicts} and |
| 3864 | @code{OrderedSets}, which are similar to containers in base Julia. However, |
| 3865 | during iteration the @code{Ordered*} containers return items in the order in |
| 3866 | which they were added to the collection.") |
| 3867 | (license license:expat))) |
| 3868 | |
| 3869 | (define-public julia-offsetarrays |
| 3870 | (package |
| 3871 | (name "julia-offsetarrays") |
| 3872 | (version "1.10.3") |
| 3873 | (source |
| 3874 | (origin |
| 3875 | (method git-fetch) |
| 3876 | (uri (git-reference |
| 3877 | (url "https://github.com/JuliaArrays/OffsetArrays.jl") |
| 3878 | (commit (string-append "v" version)))) |
| 3879 | (file-name (git-file-name name version)) |
| 3880 | (sha256 |
| 3881 | (base32 "0j5a8ar8yc0j9h87gwfyrcqm23wpyv5yv5gn8vzilpg4vr0fiasc")))) |
| 3882 | (build-system julia-build-system) |
| 3883 | (propagated-inputs |
| 3884 | (list julia-adapt)) |
| 3885 | ;; CatIndices depends on OffsetArrays, introducing a recursive dependency |
| 3886 | (arguments (list #:tests? #f)) |
| 3887 | (home-page "https://juliaarrays.github.io/OffsetArrays.jl/stable/") |
| 3888 | (synopsis "Fortran-like arrays with arbitrary, zero or negative indices") |
| 3889 | (description "@code{OffsetArrays.jl} provides Julia users with arrays that |
| 3890 | have arbitrary indices, similar to those found in some other programming |
| 3891 | languages like Fortran.") |
| 3892 | (license license:expat))) |
| 3893 | |
| 3894 | (define-public julia-paddedviews |
| 3895 | (package |
| 3896 | (name "julia-paddedviews") |
| 3897 | (version "0.5.8") |
| 3898 | (source |
| 3899 | (origin |
| 3900 | (method git-fetch) |
| 3901 | (uri (git-reference |
| 3902 | (url "https://github.com/JuliaArrays/PaddedViews.jl") |
| 3903 | (commit (string-append "v" version)))) |
| 3904 | (file-name (git-file-name name version)) |
| 3905 | (sha256 |
| 3906 | (base32 "0ran2vj6ahlzib0g77y7g0jhavy3k9s2mqq23ybpgp9z677wf26h")))) |
| 3907 | (build-system julia-build-system) |
| 3908 | (propagated-inputs |
| 3909 | (list julia-offsetarrays)) |
| 3910 | (native-inputs |
| 3911 | (list julia-documenter)) |
| 3912 | (home-page "https://github.com/JuliaArrays/PaddedViews.jl") |
| 3913 | (synopsis "Add virtual padding to the edges of an array") |
| 3914 | (description "@code{PaddedViews} provides a simple wrapper type, |
| 3915 | @code{PaddedView}, to add \"virtual\" padding to any array without copying data. |
| 3916 | Edge values not specified by the array are assigned a @code{fillvalue}. |
| 3917 | Multiple arrays may be \"promoted\" to have common indices using the |
| 3918 | @code{paddedviews} function.") |
| 3919 | (license license:expat))) |
| 3920 | |
| 3921 | (define-public julia-parameters |
| 3922 | (package |
| 3923 | (name "julia-parameters") |
| 3924 | (version "0.12.2") |
| 3925 | (source |
| 3926 | (origin |
| 3927 | (method git-fetch) |
| 3928 | (uri (git-reference |
| 3929 | (url "https://github.com/mauro3/Parameters.jl") |
| 3930 | (commit (string-append "v" version)))) |
| 3931 | (file-name (git-file-name name version)) |
| 3932 | (sha256 |
| 3933 | (base32 "0b8lawi7kcws4axfsdf023gyxca15irl648ciyi1kw3wghz3pfi2")))) |
| 3934 | (build-system julia-build-system) |
| 3935 | (propagated-inputs |
| 3936 | (list julia-orderedcollections |
| 3937 | julia-unpack)) |
| 3938 | (home-page "https://github.com/mauro3/Parameters.jl") |
| 3939 | (synopsis "Numerical-model parameter helpers") |
| 3940 | (description "This package contains types with default field values, keyword |
| 3941 | constructors and (un-)pack macros. Keyword functions can be slow in Julia, |
| 3942 | however, the normal positional constructor is also provided and could be used in |
| 3943 | performance critical code.") |
| 3944 | (license license:expat))) |
| 3945 | |
| 3946 | (define-public julia-parsers |
| 3947 | (package |
| 3948 | (name "julia-parsers") |
| 3949 | (version "1.1.0") |
| 3950 | (source |
| 3951 | (origin |
| 3952 | (method git-fetch) |
| 3953 | (uri (git-reference |
| 3954 | (url "https://github.com/JuliaData/Parsers.jl") |
| 3955 | (commit (string-append "v" version)))) |
| 3956 | (file-name (git-file-name name version)) |
| 3957 | (sha256 |
| 3958 | (base32 "1gz3drd5334xrbx2ms33hiifkd0q1in4ywc92xvrkq3xgzdjqjdk")))) |
| 3959 | (build-system julia-build-system) |
| 3960 | (home-page "https://github.com/JuliaData/Parsers.jl") |
| 3961 | (synopsis "Fast parsing machinery for basic types in Julia") |
| 3962 | (description "@code{Parsers.jl} is a collection of type parsers and |
| 3963 | utilities for Julia.") |
| 3964 | (license license:expat))) |
| 3965 | |
| 3966 | (define-public julia-pdmats |
| 3967 | (package |
| 3968 | (name "julia-pdmats") |
| 3969 | (version "0.11.1") |
| 3970 | (source |
| 3971 | (origin |
| 3972 | (method git-fetch) |
| 3973 | (uri (git-reference |
| 3974 | (url "https://github.com/JuliaStats/PDMats.jl") |
| 3975 | (commit (string-append "v" version)))) |
| 3976 | (file-name (git-file-name name version)) |
| 3977 | (sha256 |
| 3978 | (base32 "0bc2gmpd30rkclvxyfnssjllp0pk63h0vvgr8862phm5ia83r8j0")))) |
| 3979 | (build-system julia-build-system) |
| 3980 | (home-page "https://github.com/JuliaStats/PDMats.jl") |
| 3981 | (synopsis |
| 3982 | "Uniform Interface for positive definite matrices of various structures") |
| 3983 | (description "PDMats.jl supports efficient computation on positive definite |
| 3984 | matrices of various structures. In particular, it provides uniform interfaces |
| 3985 | to use positive definite matrices of various structures for writing generic |
| 3986 | algorithms, while ensuring that the most efficient implementation is used in |
| 3987 | actual computation.") |
| 3988 | (license license:expat))) |
| 3989 | |
| 3990 | (define-public julia-plotthemes |
| 3991 | (package |
| 3992 | (name "julia-plotthemes") |
| 3993 | (version "2.0.1") |
| 3994 | (source |
| 3995 | (origin |
| 3996 | (method git-fetch) |
| 3997 | (uri (git-reference |
| 3998 | (url "https://github.com/JuliaPlots/PlotThemes.jl") |
| 3999 | (commit (string-append "v" version)))) |
| 4000 | (file-name (git-file-name name version)) |
| 4001 | (sha256 |
| 4002 | (base32 "1fd27w9z1vhz0d1bzrs5vcavpb5r5jviyh27d9c4ka37phz4xvmh")))) |
| 4003 | (build-system julia-build-system) |
| 4004 | (propagated-inputs |
| 4005 | (list julia-plotutils |
| 4006 | julia-requires)) |
| 4007 | (home-page "https://github.com/JuliaPlots/PlotThemes.jl") |
| 4008 | (synopsis "Themes for the Julia plotting package Plots.jl") |
| 4009 | (description |
| 4010 | "PlotThemes is a package to spice up the plots made with @code{Plots.jl}.") |
| 4011 | (license license:expat))) |
| 4012 | |
| 4013 | (define-public julia-plotutils |
| 4014 | (package |
| 4015 | (name "julia-plotutils") |
| 4016 | (version "1.0.15") |
| 4017 | (source |
| 4018 | (origin |
| 4019 | (method git-fetch) |
| 4020 | (uri (git-reference |
| 4021 | (url "https://github.com/JuliaPlots/PlotUtils.jl") |
| 4022 | (commit (string-append "v" version)))) |
| 4023 | (file-name (git-file-name name version)) |
| 4024 | (sha256 |
| 4025 | (base32 "12aw5gkkcfhpczv2w510k65w1j0hjnh825ihimi223v8plsi5105")))) |
| 4026 | (build-system julia-build-system) |
| 4027 | (propagated-inputs |
| 4028 | (list julia-colors |
| 4029 | julia-colorschemes |
| 4030 | julia-reexport)) |
| 4031 | (native-inputs |
| 4032 | (list julia-stablerngs)) |
| 4033 | (home-page "https://github.com/JuliaPlots/PlotUtils.jl") |
| 4034 | (synopsis "Helper algorithms for building plotting components") |
| 4035 | (description "This package contains generic helper algorithms for building |
| 4036 | plotting components.") |
| 4037 | (license license:expat))) |
| 4038 | |
| 4039 | (define-public julia-pooledarrays |
| 4040 | (package |
| 4041 | (name "julia-pooledarrays") |
| 4042 | (version "1.3.0") |
| 4043 | (source |
| 4044 | (origin |
| 4045 | (method git-fetch) |
| 4046 | (uri (git-reference |
| 4047 | (url "https://github.com/JuliaData/PooledArrays.jl") |
| 4048 | (commit (string-append "v" version)))) |
| 4049 | (file-name (git-file-name name version)) |
| 4050 | (sha256 |
| 4051 | (base32 "0qdwvf1p5z6z0q4s4hn85ysd8wq47zy6hlzddc5ijvhk86ccqlrr")))) |
| 4052 | (build-system julia-build-system) |
| 4053 | (propagated-inputs |
| 4054 | (list julia-dataapi)) |
| 4055 | (home-page "https://github.com/JuliaData/PooledArrays.jl") |
| 4056 | (synopsis "Pooled representation of arrays in Julia") |
| 4057 | (description "This package provides a pooled representation of arrays for |
| 4058 | purposes of compression when there are few unique elements.") |
| 4059 | (license license:expat))) |
| 4060 | |
| 4061 | (define-public julia-positivefactorizations |
| 4062 | (package |
| 4063 | (name "julia-positivefactorizations") |
| 4064 | (version "0.2.4") |
| 4065 | (source |
| 4066 | (origin |
| 4067 | (method git-fetch) |
| 4068 | (uri (git-reference |
| 4069 | (url "https://github.com/timholy/PositiveFactorizations.jl") |
| 4070 | (commit (string-append "v" version)))) |
| 4071 | (file-name (git-file-name name version)) |
| 4072 | (sha256 |
| 4073 | (base32 "1wxy6ak7f3hvibcgc8q88cgkf9zvi649mmjy1zlkx1qk80hgvz23")))) |
| 4074 | (build-system julia-build-system) |
| 4075 | (native-inputs |
| 4076 | (list julia-forwarddiff |
| 4077 | julia-reversediff)) |
| 4078 | (home-page "https://github.com/timholy/PositiveFactorizations.jl") |
| 4079 | (synopsis "Positive-definite \"approximations\" to matrices") |
| 4080 | (description "@code{PositiveFactorizations} is a package for computing a |
| 4081 | positive definite matrix decomposition (factorization) from an arbitrary |
| 4082 | symmetric input. The motivating application is optimization (Newton or |
| 4083 | quasi-Newton methods), in which the canonical search direction -H/g (H being the |
| 4084 | Hessian and g the gradient) may not be a descent direction if H is not positive |
| 4085 | definite.") |
| 4086 | (license license:expat))) |
| 4087 | |
| 4088 | (define-public julia-preferences |
| 4089 | (package |
| 4090 | (name "julia-preferences") |
| 4091 | (version "1.2.2") |
| 4092 | (source |
| 4093 | (origin |
| 4094 | (method git-fetch) |
| 4095 | (uri (git-reference |
| 4096 | (url "https://github.com/JuliaPackaging/Preferences.jl") |
| 4097 | (commit (string-append "v" version)))) |
| 4098 | (file-name (git-file-name name version)) |
| 4099 | (sha256 |
| 4100 | (base32 "1cail43iqzbi6m9v6981rhz47zf2lcvhs5ds5gdqvc9nx5frghxq")))) |
| 4101 | (build-system julia-build-system) |
| 4102 | (arguments |
| 4103 | (list #:tests? #f)) ; Tests try to mkdir /.julia |
| 4104 | (home-page "https://github.com/JuliaPackaging/Preferences.jl") |
| 4105 | (synopsis "Store configuration switches to TOML files") |
| 4106 | (description "The @code{Preferences} package provides an integrated way for |
| 4107 | packages to store configuration switches to persistent TOML files, and use those |
| 4108 | pieces of information at both run time and compile time in Julia. This enables |
| 4109 | the user to modify the behavior of a package, and have that choice reflected in |
| 4110 | everything from run time algorithm choice to code generation at compile time.") |
| 4111 | (license license:expat))) |
| 4112 | |
| 4113 | (define-public julia-prettytables |
| 4114 | (package |
| 4115 | (name "julia-prettytables") |
| 4116 | (version "1.0.1") |
| 4117 | (source |
| 4118 | (origin |
| 4119 | (method git-fetch) |
| 4120 | (uri (git-reference |
| 4121 | (url "https://github.com/ronisbr/PrettyTables.jl") |
| 4122 | (commit (string-append "v" version)))) |
| 4123 | (file-name (git-file-name name version)) |
| 4124 | (sha256 |
| 4125 | (base32 "1d1sd87kkwbar3l608h0adzws42cwdrmp1idxx7an6mfqcsdrijw")))) |
| 4126 | (build-system julia-build-system) |
| 4127 | (arguments |
| 4128 | (list |
| 4129 | #:phases |
| 4130 | #~(modify-phases %standard-phases |
| 4131 | (add-after 'link-depot 'skip-color-tests |
| 4132 | (lambda _ |
| 4133 | (substitute* "test/text_backend.jl" |
| 4134 | ((".*colors\\.jl.*") ""))))))) |
| 4135 | (propagated-inputs |
| 4136 | (list julia-crayons |
| 4137 | julia-formatting |
| 4138 | julia-reexport |
| 4139 | julia-tables)) |
| 4140 | (home-page "https://github.com/ronisbr/PrettyTables.jl") |
| 4141 | (synopsis "Print data in formatted tables") |
| 4142 | (description "This package has the purpose to print data in matrices in a |
| 4143 | human-readable format.") |
| 4144 | (license license:expat))) |
| 4145 | |
| 4146 | (define-public julia-pycall |
| 4147 | (package |
| 4148 | (name "julia-pycall") |
| 4149 | (version "1.92.5") |
| 4150 | (source |
| 4151 | (origin |
| 4152 | (method git-fetch) |
| 4153 | (uri (git-reference |
| 4154 | (url "https://github.com/JuliaPy/PyCall.jl") |
| 4155 | (commit (string-append "v" version)))) |
| 4156 | (file-name (git-file-name name version)) |
| 4157 | (sha256 |
| 4158 | (base32 |
| 4159 | "1fj5d1ihnhnm0pl4hbx6hcd2bpdyhm8jiaqah2axsbd069j70saf")))) |
| 4160 | (build-system julia-build-system) |
| 4161 | (arguments |
| 4162 | (list |
| 4163 | #:imported-modules `((guix build python-build-system) |
| 4164 | ,@%julia-build-system-modules) |
| 4165 | #:modules '((guix build julia-build-system) |
| 4166 | (guix build utils) |
| 4167 | ((guix build python-build-system) #:prefix python:)) |
| 4168 | #:phases |
| 4169 | #~(modify-phases %standard-phases |
| 4170 | (add-after 'link-depot 'remove-conda |
| 4171 | (lambda _ |
| 4172 | (substitute* "Project.toml" |
| 4173 | ((".*Conda.*") "")) |
| 4174 | (substitute* (list "src/PyCall.jl" |
| 4175 | "test/runtests.jl") |
| 4176 | (("import Conda") "")) |
| 4177 | (substitute* "deps/depsutils.jl" |
| 4178 | (("Conda.PYTHONDIR") "\"/\"")))) |
| 4179 | (add-after 'link-depot 'set-python |
| 4180 | (lambda* (#:key inputs outputs #:allow-other-keys) |
| 4181 | (let ((python (assoc-ref inputs "python"))) |
| 4182 | (setenv "PYCALL_JL_RUNTIME_PYTHON" |
| 4183 | (string-append python "/bin/python3")) |
| 4184 | (with-output-to-file "deps/deps.jl" |
| 4185 | (lambda _ |
| 4186 | (format #t |
| 4187 | "const python = \"~a/bin/python3\"~@ |
| 4188 | const pyprogramname = \"~a/bin/python3\"~@ |
| 4189 | const libpython = \"~a/lib/libpython~a.so.1.0\"~@ |
| 4190 | const PYTHONHOME = \"~a\"~@ |
| 4191 | const pyversion_build = v\"~a\"~@ |
| 4192 | const conda = false~%" |
| 4193 | python |
| 4194 | python |
| 4195 | python |
| 4196 | (python:python-version python) |
| 4197 | python |
| 4198 | #$(package-version python))))))) |
| 4199 | (add-before 'check 'pre-check |
| 4200 | (lambda _ |
| 4201 | (setenv "CI" "true") |
| 4202 | (setenv "JULIA_PKGEVAL" "true")))))) |
| 4203 | (propagated-inputs |
| 4204 | (list julia-macrotools |
| 4205 | julia-versionparsing)) |
| 4206 | (inputs |
| 4207 | (list python)) |
| 4208 | (native-inputs |
| 4209 | (list python-numpy)) |
| 4210 | (home-page "https://github.com/JuliaPy/PyCall.jl") |
| 4211 | (synopsis "Call Python functions from the Julia language") |
| 4212 | (description "This package provides the ability to directly call and fully |
| 4213 | interoperate with Python from the Julia language. You can import arbitrary |
| 4214 | Python modules from Julia, call Python functions (with automatic conversion of |
| 4215 | types between Julia and Python), define Python classes from Julia methods, and |
| 4216 | share large data structures between Julia and Python without copying them.") |
| 4217 | (license license:expat))) |
| 4218 | |
| 4219 | (define-public julia-pyplot |
| 4220 | (package |
| 4221 | (name "julia-pyplot") |
| 4222 | (version "2.10.0") |
| 4223 | (source |
| 4224 | (origin |
| 4225 | (method git-fetch) |
| 4226 | (uri (git-reference |
| 4227 | (url "https://github.com/JuliaPy/PyPlot.jl") |
| 4228 | (commit (string-append "v" version)))) |
| 4229 | (file-name (git-file-name name version)) |
| 4230 | (sha256 |
| 4231 | (base32 "007zs0imfgs69f30pp2a3rc93kl0qiq7qjx6ig35z4wzkmps4skd")))) |
| 4232 | (build-system julia-build-system) |
| 4233 | (propagated-inputs |
| 4234 | (list julia-colors |
| 4235 | julia-latexstrings |
| 4236 | julia-pycall |
| 4237 | julia-versionparsing |
| 4238 | ;; python-matplotlib is expected to be available at runtime. |
| 4239 | python-matplotlib)) |
| 4240 | (home-page "https://github.com/JuliaPy/PyPlot.jl") |
| 4241 | (synopsis "Plotting for Julia based on matplotlib.pyplot") |
| 4242 | (description "This package provides a Julia interface to the Matplotlib |
| 4243 | plotting library from Python, and specifically to the @code{matplotlib.pyplot} |
| 4244 | module. PyPlot uses the Julia PyCall package to call Matplotlib directly from |
| 4245 | Julia with little or no overhead (arrays are passed without making a copy).") |
| 4246 | (license license:expat))) |
| 4247 | |
| 4248 | (define-public julia-quadgk |
| 4249 | (package |
| 4250 | (name "julia-quadgk") |
| 4251 | (version "2.4.1") |
| 4252 | (source |
| 4253 | (origin |
| 4254 | (method git-fetch) |
| 4255 | (uri (git-reference |
| 4256 | (url "https://github.com/JuliaMath/QuadGK.jl") |
| 4257 | (commit (string-append "v" version)))) |
| 4258 | (file-name (git-file-name name version)) |
| 4259 | (sha256 |
| 4260 | (base32 "1hy0629yai6xflgxaflk9764lzr1lzhlghimxk1aqi212q9c6n33")))) |
| 4261 | (build-system julia-build-system) |
| 4262 | (propagated-inputs |
| 4263 | (list julia-datastructures)) |
| 4264 | (home-page "https://github.com/JuliaMath/QuadGK.jl") |
| 4265 | (synopsis "Adaptive 1d numerical Gauss–Kronrod integration") |
| 4266 | (description "This package provides support for one-dimensional numerical |
| 4267 | integration in Julia using adaptive Gauss-Kronrod quadrature. The code was |
| 4268 | originally part of Base Julia. It supports integration of arbitrary numeric |
| 4269 | types, including arbitrary precision (@code{BigFloat}), and even integration of |
| 4270 | arbitrary normed vector spaces (e.g. matrix-valued integrands).") |
| 4271 | (license license:expat))) |
| 4272 | |
| 4273 | (define-public julia-quadmath |
| 4274 | (package |
| 4275 | (name "julia-quadmath") |
| 4276 | (version "0.5.5") |
| 4277 | (source |
| 4278 | (origin |
| 4279 | (method git-fetch) |
| 4280 | (uri (git-reference |
| 4281 | (url "https://github.com/JuliaMath/Quadmath.jl") |
| 4282 | (commit (string-append "v" version)))) |
| 4283 | (file-name (git-file-name name version)) |
| 4284 | (sha256 |
| 4285 | (base32 "051biw4b9zni7cmh2f1yzifp1v8wazlfxrdz4p44lyd1wba6379w")))) |
| 4286 | (build-system julia-build-system) |
| 4287 | (arguments |
| 4288 | (list |
| 4289 | #:phases |
| 4290 | #~(modify-phases %standard-phases |
| 4291 | (add-after 'link-depot 'hardcode-libmath-location |
| 4292 | (lambda* (#:key inputs #:allow-other-keys) |
| 4293 | (let ((gcclib (assoc-ref inputs "gcc:lib"))) |
| 4294 | (substitute* "src/Quadmath.jl" |
| 4295 | (("libgcc_s.so.1" lib) (string-append gcclib "/lib/" lib)) |
| 4296 | (("libquadmath.so.0" lib) (string-append gcclib "/lib/" lib))))))))) |
| 4297 | (propagated-inputs |
| 4298 | (list julia-requires)) |
| 4299 | (inputs |
| 4300 | `(("gcc:lib" ,gcc "lib"))) |
| 4301 | (native-inputs |
| 4302 | (list julia-specialfunctions)) |
| 4303 | (home-page "https://github.com/JuliaMath/Quadmath.jl") |
| 4304 | (synopsis "Float128 and libquadmath for the Julia language") |
| 4305 | (description "This is a Julia interface to @code{libquadmath}, providing a |
| 4306 | @code{Float128} type corresponding to the IEEE754 binary128 floating point |
| 4307 | format.") |
| 4308 | (license license:expat))) |
| 4309 | |
| 4310 | (define-public julia-quaternions |
| 4311 | (package |
| 4312 | (name "julia-quaternions") |
| 4313 | (version "0.4.2") |
| 4314 | (source |
| 4315 | (origin |
| 4316 | (method git-fetch) |
| 4317 | (uri (git-reference |
| 4318 | (url "https://github.com/JuliaGeometry/Quaternions.jl") |
| 4319 | (commit (string-append "v" version)))) |
| 4320 | (file-name (git-file-name name version)) |
| 4321 | (sha256 |
| 4322 | (base32 "1zhynyvchc50hywws2jznpkwydr3njh8cv84d2ylyabhcwwmil9s")))) |
| 4323 | (build-system julia-build-system) |
| 4324 | (propagated-inputs |
| 4325 | (list julia-dualnumbers)) |
| 4326 | (home-page "https://github.com/JuliaGeometry/Quaternions.jl") |
| 4327 | (synopsis "Quaternion and dual-quaternion functionality") |
| 4328 | (description "Quaternions are best known for their suitability as |
| 4329 | representations of 3D rotational orientation. They can also be viewed as an |
| 4330 | extension of complex numbers.") |
| 4331 | (license license:expat))) |
| 4332 | |
| 4333 | (define-public julia-queryoperators |
| 4334 | (package |
| 4335 | (name "julia-queryoperators") |
| 4336 | (version "0.9.3") |
| 4337 | (source |
| 4338 | (origin |
| 4339 | (method git-fetch) |
| 4340 | (uri (git-reference |
| 4341 | (url "https://github.com/queryverse/QueryOperators.jl") |
| 4342 | (commit (string-append "v" version)))) |
| 4343 | (file-name (git-file-name name version)) |
| 4344 | (sha256 |
| 4345 | (base32 "06zm4cbn3x49lbpgshhdfvvmgz066qkc8q0d57igm5p8bcp6js22")))) |
| 4346 | (build-system julia-build-system) |
| 4347 | (propagated-inputs |
| 4348 | (list julia-datastructures |
| 4349 | julia-iteratorinterfaceextensions |
| 4350 | julia-tableshowutils)) |
| 4351 | (home-page "https://github.com/queryverse/QueryOperators.jl") |
| 4352 | (synopsis "Query operators for Julia") |
| 4353 | (description "This package contains the underlying query operators that are |
| 4354 | exposed to users in @code{Query.jl}.") |
| 4355 | (license license:expat))) |
| 4356 | |
| 4357 | (define-public julia-rangearrays |
| 4358 | (package |
| 4359 | (name "julia-rangearrays") |
| 4360 | (version "0.3.2") |
| 4361 | (source |
| 4362 | (origin |
| 4363 | (method git-fetch) |
| 4364 | (uri (git-reference |
| 4365 | (url "https://github.com/JuliaArrays/RangeArrays.jl") |
| 4366 | (commit (string-append "v" version)))) |
| 4367 | (file-name (git-file-name name version)) |
| 4368 | (sha256 |
| 4369 | (base32 "1ihzfyfq1xihkjcvn7xmzfbn6igzidb4fkzdcxwfr5qkvi52gnmg")))) |
| 4370 | (build-system julia-build-system) |
| 4371 | (home-page "https://github.com/JuliaArrays/RangeArrays.jl") |
| 4372 | (synopsis "Array data structures with autogenerated columns") |
| 4373 | (description "The goal of RangeArrays is to provide efficient and convenient |
| 4374 | array data structures where the columns of the arrays are generated (on the fly) |
| 4375 | by Ranges.") |
| 4376 | (license license:expat))) |
| 4377 | |
| 4378 | (define-public julia-ratios |
| 4379 | (package |
| 4380 | (name "julia-ratios") |
| 4381 | (version "0.4.0") |
| 4382 | (source |
| 4383 | (origin |
| 4384 | (method git-fetch) |
| 4385 | (uri (git-reference |
| 4386 | (url "https://github.com/timholy/Ratios.jl") |
| 4387 | (commit (string-append "v" version)))) |
| 4388 | (file-name (git-file-name name version)) |
| 4389 | (sha256 |
| 4390 | (base32 "1a4fd4jq4qjply29rkwg3m1clfndjsbckj1b1dab1bc35h2c6yxh")))) |
| 4391 | (build-system julia-build-system) |
| 4392 | (home-page "https://github.com/timholy/Ratios.jl") |
| 4393 | (synopsis "Faster Rational-like types for Julia") |
| 4394 | (description "This package provides types similar to Julia's @code{Rational} |
| 4395 | type, which make some sacrifices but have better computational performance.") |
| 4396 | (license license:expat))) |
| 4397 | |
| 4398 | (define-public julia-recipesbase |
| 4399 | (package |
| 4400 | (name "julia-recipesbase") |
| 4401 | (version "1.1.1") |
| 4402 | (source |
| 4403 | (origin |
| 4404 | (method git-fetch) |
| 4405 | (uri (git-reference |
| 4406 | (url "https://github.com/JuliaPlots/RecipesBase.jl") |
| 4407 | (commit (string-append "v" version)))) |
| 4408 | (file-name (git-file-name name version)) |
| 4409 | (sha256 |
| 4410 | (base32 "1b6m5rz6wprj30rwvlxz4r1jv5gl0ay0f52kfmy2w7lqly7zhap5")))) |
| 4411 | (build-system julia-build-system) |
| 4412 | (home-page "https://github.com/JuliaPlots/RecipesBase.jl") |
| 4413 | (synopsis "Define transformation recipes on user types") |
| 4414 | (description "This package implements handy macros @code{@@recipe} and |
| 4415 | @code{@@series} which will define a custom transformation and attach attributes |
| 4416 | for user types. Its design is an attempt to simplify and generalize the summary |
| 4417 | and display of types and data from external packages. With this package it is |
| 4418 | possible to describe visualization routines that can be used as components in |
| 4419 | more complex visualizations.") |
| 4420 | (license license:expat))) |
| 4421 | |
| 4422 | (define-public julia-recipespipeline |
| 4423 | (package |
| 4424 | (name "julia-recipespipeline") |
| 4425 | (version "0.3.4") |
| 4426 | (source |
| 4427 | (origin |
| 4428 | (method git-fetch) |
| 4429 | (uri (git-reference |
| 4430 | (url "https://github.com/JuliaPlots/RecipesPipeline.jl") |
| 4431 | (commit (string-append "v" version)))) |
| 4432 | (file-name (git-file-name name version)) |
| 4433 | (sha256 |
| 4434 | (base32 "0zq4bzxvq36zr0va6iip3x97mgq5b4fwza8avszx1ryfqm3lg1f7")))) |
| 4435 | (build-system julia-build-system) |
| 4436 | (arguments |
| 4437 | (list #:tests? #f)) ; Cycle with Plots.jl. |
| 4438 | (propagated-inputs |
| 4439 | (list julia-nanmath |
| 4440 | julia-plotutils |
| 4441 | julia-recipesbase)) |
| 4442 | (home-page "http://juliaplots.org/RecipesPipeline.jl/dev/") |
| 4443 | (synopsis "Utilities for processing recipes") |
| 4444 | (description "This package was factored out of @code{Plots.jl} to allow any |
| 4445 | other plotting package to use the recipe pipeline. In short, the extremely |
| 4446 | lightweight @code{RecipesBase.jl} package can be depended on by any package to |
| 4447 | define \"recipes\": plot specifications of user-defined types, as well as custom |
| 4448 | plot types. @code{RecipePipeline.jl} contains the machinery to translate these |
| 4449 | recipes to full specifications for a plot.") |
| 4450 | (license license:expat))) |
| 4451 | |
| 4452 | (define-public julia-recursivearraytools |
| 4453 | (package |
| 4454 | (name "julia-recursivearraytools") |
| 4455 | (version "2.16.1") |
| 4456 | (source |
| 4457 | (origin |
| 4458 | (method git-fetch) |
| 4459 | (uri (git-reference |
| 4460 | (url "https://github.com/SciML/RecursiveArrayTools.jl") |
| 4461 | (commit (string-append "v" version)))) |
| 4462 | (file-name (git-file-name name version)) |
| 4463 | (sha256 |
| 4464 | (base32 "0vx8ndxrii53na7jsc2lki47wfpi77rn3y2r6xhiysx1qwr14msf")))) |
| 4465 | (build-system julia-build-system) |
| 4466 | (arguments |
| 4467 | (list #:tests? #f)) ; Cycle with OrdinaryDiffEq.jl. |
| 4468 | (propagated-inputs |
| 4469 | (list julia-arrayinterface |
| 4470 | julia-chainrulescore |
| 4471 | julia-docstringextensions |
| 4472 | julia-recipesbase |
| 4473 | julia-requires |
| 4474 | julia-staticarrays |
| 4475 | julia-zygoterules)) |
| 4476 | ;(native-inputs |
| 4477 | ; `(("julia-forwarddiff" ,julia-forwarddiff) |
| 4478 | ; ("julia-nlsolve" ,julia-nlsolve) |
| 4479 | ; ("julia-ordinarydiffeq" ,julia-ordinarydiffeq) |
| 4480 | ; ("julia-structarrays" ,julia-structarrays) |
| 4481 | ; ("julia-zygote" ,julia-zygote))) |
| 4482 | (home-page "https://github.com/SciML/RecursiveArrayTools.jl") |
| 4483 | (synopsis "Tools for handling objects like arrays of arrays and deeper nestings") |
| 4484 | (description "@code{RecursiveArrayTools.jl} is a set of tools for dealing with |
| 4485 | recursive arrays like arrays of arrays.") |
| 4486 | (license license:expat))) |
| 4487 | |
| 4488 | (define-public julia-reexport |
| 4489 | (package |
| 4490 | (name "julia-reexport") |
| 4491 | (version "1.2.2") |
| 4492 | (source |
| 4493 | (origin |
| 4494 | (method git-fetch) |
| 4495 | (uri (git-reference |
| 4496 | (url "https://github.com/simonster/Reexport.jl") |
| 4497 | (commit (string-append "v" version)))) |
| 4498 | (file-name (git-file-name name version)) |
| 4499 | (sha256 |
| 4500 | (base32 "0inf5q6f01ncd5c5wm8mwzv2hs627ng6xlh8dhrlflp321hbamwf")))) |
| 4501 | (build-system julia-build-system) |
| 4502 | (home-page "https://github.com/simonster/Reexport.jl") |
| 4503 | (synopsis "Re-export modules and symbols") |
| 4504 | (description "This package provides tools to re-export modules and symbols.") |
| 4505 | (license license:expat))) |
| 4506 | |
| 4507 | (define-public julia-referencetests |
| 4508 | (package |
| 4509 | (name "julia-referencetests") |
| 4510 | (version "0.9.7") |
| 4511 | (source |
| 4512 | (origin |
| 4513 | (method git-fetch) |
| 4514 | (uri (git-reference |
| 4515 | (url "https://github.com/JuliaTesting/ReferenceTests.jl") |
| 4516 | (commit (string-append "v" version)))) |
| 4517 | (file-name (git-file-name name version)) |
| 4518 | (sha256 |
| 4519 | (base32 "0mm6bjhs8a21pippww6b08b5frmnb9m6k8xrszrwq9zhc879zpc9")))) |
| 4520 | (build-system julia-build-system) |
| 4521 | (arguments |
| 4522 | (list #:tests? #f)) ; Cycle with ImageCore.jl through ImageMagick.jl. |
| 4523 | (propagated-inputs |
| 4524 | (list julia-deepdiffs |
| 4525 | julia-distances |
| 4526 | julia-fileio |
| 4527 | julia-imagecore |
| 4528 | julia-imageinterminal)) |
| 4529 | ;(native-inputs |
| 4530 | ; `(("julia-csvfiles" ,julia-csvfiles) |
| 4531 | ; ("julia-dataframes" ,julia-dataframes) |
| 4532 | ; ("julia-gr" ,julia-gr) |
| 4533 | ; ("julia-imagemagick" ,julia-imagemagick) |
| 4534 | ; ("julia-imagetransformations" ,julia-imagetransformations) |
| 4535 | ; ("julia-plots" ,julia-plots) |
| 4536 | ; ("julia-testimages" ,julia-testimages))) |
| 4537 | (home-page "https://juliatesting.github.io/ReferenceTests.jl/latest/") |
| 4538 | (synopsis "Utility package for comparing data against reference files") |
| 4539 | (description "@code{ReferenceTests.jl} is a Julia package that adds a couple |
| 4540 | of additional macros to your testing toolbox. In particular, it focuses on |
| 4541 | functionality for testing values against reference files, which in turn the |
| 4542 | package can help create and update if need be.") |
| 4543 | (license license:expat))) |
| 4544 | |
| 4545 | (define-public julia-requires |
| 4546 | (package |
| 4547 | (name "julia-requires") |
| 4548 | (version "1.1.3") |
| 4549 | (source |
| 4550 | (origin |
| 4551 | (method git-fetch) |
| 4552 | (uri (git-reference |
| 4553 | (url "https://github.com/JuliaPackaging/Requires.jl/") |
| 4554 | (commit (string-append "v" version)))) |
| 4555 | (file-name (git-file-name name version)) |
| 4556 | (sha256 |
| 4557 | (base32 "03hyfy7c0ma45b0y756j76awi3az2ii4bz4s8cxm3xw9yy1z7b01")))) |
| 4558 | (build-system julia-build-system) |
| 4559 | (arguments |
| 4560 | (list #:parallel-tests? #f)) |
| 4561 | (inputs ;required for test |
| 4562 | (list julia-example)) |
| 4563 | (propagated-inputs |
| 4564 | (list julia-colors)) |
| 4565 | (home-page "https://github.com/JuliaPackaging/Requires.jl/") |
| 4566 | (synopsis "Faster package loader") |
| 4567 | (description "This package make loading packages faster, maybe. It |
| 4568 | supports specifying glue code in packages which will load automatically when |
| 4569 | another package is loaded, so that explicit dependencies (and long load times) |
| 4570 | can be avoided.") |
| 4571 | (license license:expat))) |
| 4572 | |
| 4573 | (define-public julia-reversediff |
| 4574 | (package |
| 4575 | (name "julia-reversediff") |
| 4576 | (version "1.9.0") |
| 4577 | (source |
| 4578 | (origin |
| 4579 | (method git-fetch) |
| 4580 | (uri (git-reference |
| 4581 | (url "https://github.com/JuliaDiff/ReverseDiff.jl") |
| 4582 | (commit (string-append "v" version)))) |
| 4583 | (file-name (git-file-name name version)) |
| 4584 | (sha256 |
| 4585 | (base32 "1wrr6sqj2xl9grkvdp88rw3manxy9vbx28zq2wssya5ns1xabsnl")))) |
| 4586 | (build-system julia-build-system) |
| 4587 | (arguments |
| 4588 | ;; XXXX: Test suite failing for i686, e.g., |
| 4589 | ;; Expression: hash(tr_float, hash(1)) === hash(v_float, hash(1)) |
| 4590 | ;; MethodError: no method matching decompose(::ReverseDiff.TrackedReal{Float64, Float64, Nothing}) |
| 4591 | ;; Disable as stopgap. |
| 4592 | (list #:tests? (not (target-x86-32?)))) |
| 4593 | (propagated-inputs |
| 4594 | (list julia-diffresults |
| 4595 | julia-diffrules |
| 4596 | julia-forwarddiff |
| 4597 | julia-functionwrappers |
| 4598 | julia-macrotools |
| 4599 | julia-nanmath |
| 4600 | julia-specialfunctions |
| 4601 | julia-staticarrays)) |
| 4602 | (native-inputs |
| 4603 | (list julia-difftests |
| 4604 | julia-fillarrays)) |
| 4605 | (home-page "https://github.com/JuliaDiff/ReverseDiff.jl") |
| 4606 | (synopsis "Reverse Mode Automatic Differentiation for Julia") |
| 4607 | (description "@code{ReverseDiff.jl} is a fast and compile-able tape-based |
| 4608 | reverse mode @acronym{AD, automatic differentiation}, that implements methods to |
| 4609 | take gradients, Jacobians, Hessians, and higher-order derivatives of native |
| 4610 | Julia functions (or any callable object, really).") |
| 4611 | (license license:expat))) |
| 4612 | |
| 4613 | (define-public julia-richardson |
| 4614 | (package |
| 4615 | (name "julia-richardson") |
| 4616 | (version "1.4.0") |
| 4617 | (source |
| 4618 | (origin |
| 4619 | (method git-fetch) |
| 4620 | (uri (git-reference |
| 4621 | (url "https://github.com/JuliaMath/Richardson.jl") |
| 4622 | (commit (string-append "v" version)))) |
| 4623 | (file-name (git-file-name name version)) |
| 4624 | (sha256 |
| 4625 | (base32 "06v9ii3d7hh41fsrfklaa8ap55z5s017f888mrd1c18y4fx9i4nx")))) |
| 4626 | (build-system julia-build-system) |
| 4627 | (home-page "https://juliapackages.com/p/richardson") |
| 4628 | (synopsis "Extrapolate function using Richardson method") |
| 4629 | (description "This package provides a function extrapolate that |
| 4630 | extrapolates a given function @code{f(x)} to @code{f(x0)}, evaluating @code{f} |
| 4631 | only at a geometric sequence of points @code{> x0} (or optionally @code{< |
| 4632 | x0}). The key algorithm is Richardson extrapolation using a Neville–Aitken |
| 4633 | tableau, which adaptively increases the degree of an extrapolation polynomial |
| 4634 | until convergence is achieved to a desired tolerance (or convergence stalls |
| 4635 | due to e.g. floating-point errors). This allows one to obtain @code{f(x0)} to |
| 4636 | high-order accuracy, assuming that @code{f(x0+h)} has a Taylor series or some |
| 4637 | other power series in @code{h}.") |
| 4638 | (license license:expat))) |
| 4639 | |
| 4640 | (define-public julia-rotations |
| 4641 | ;; This is the first commit with support for julia-1.6. |
| 4642 | (let ((commit "b599102535bc3534252c76f3fd4cf521f4741788") |
| 4643 | (revision "1")) |
| 4644 | (package |
| 4645 | (name "julia-rotations") |
| 4646 | (version (git-version "1.0.2" revision commit)) |
| 4647 | (source |
| 4648 | (origin |
| 4649 | (method git-fetch) |
| 4650 | (uri (git-reference |
| 4651 | (url "https://github.com/JuliaGeometry/Rotations.jl") |
| 4652 | (commit commit))) |
| 4653 | (file-name (git-file-name name version)) |
| 4654 | (sha256 |
| 4655 | (base32 "01wwqbdmj61yiz7rkmams4xg7gb9hbmg325173846ky4b9x1wb19")))) |
| 4656 | (build-system julia-build-system) |
| 4657 | (propagated-inputs |
| 4658 | (list julia-staticarrays)) |
| 4659 | (native-inputs |
| 4660 | (list julia-benchmarktools |
| 4661 | julia-forwarddiff |
| 4662 | julia-unitful)) |
| 4663 | (home-page "https://github.com/JuliaGeometry/Rotations.jl") |
| 4664 | (synopsis "Julia implementations for different rotation parameterisations") |
| 4665 | (description "This package implements various 3D rotation parameterizations |
| 4666 | and defines conversions between them. At their heart, each rotation |
| 4667 | parameterization is a 3×3 unitary (orthogonal) matrix (based on the |
| 4668 | @code{StaticArrays.jl} package), and acts to rotate a 3-vector about the origin |
| 4669 | through matrix-vector multiplication.") |
| 4670 | (license license:expat)))) |
| 4671 | |
| 4672 | (define-public julia-safetestsets |
| 4673 | ;; The only release tag is the first commit in the repository. |
| 4674 | (let ((commit "e553edc4c753344d38349304b9ff5483c3b8ff21") |
| 4675 | (revision "1")) |
| 4676 | (package |
| 4677 | (name "julia-safetestsets") |
| 4678 | (version (git-version "0.0.1" revision commit)) |
| 4679 | (source |
| 4680 | (origin |
| 4681 | (method git-fetch) |
| 4682 | (uri (git-reference |
| 4683 | (url "https://github.com/YingboMa/SafeTestsets.jl") |
| 4684 | (commit commit))) |
| 4685 | (file-name (git-file-name name version)) |
| 4686 | (sha256 |
| 4687 | (base32 "1fb1dfdmiw2ggx60hf70954xlps0r48fcb3k3dvxynlz7ylphp96")))) |
| 4688 | (build-system julia-build-system) |
| 4689 | (arguments |
| 4690 | (list |
| 4691 | #:julia-package-name "SafeTestsets" |
| 4692 | #:julia-package-uuid "1bc83da4-3b8d-516f-aca4-4fe02f6d838f")) |
| 4693 | (native-inputs |
| 4694 | (list julia-staticarrays)) |
| 4695 | (home-page "https://github.com/YingboMa/SafeTestsets.jl") |
| 4696 | (synopsis "Julia's testset in a module") |
| 4697 | (description "This package contains the testset from Julia, packaged into |
| 4698 | a loadable module.") |
| 4699 | (license license:expat)))) |
| 4700 | |
| 4701 | (define-public julia-sass |
| 4702 | (package |
| 4703 | (name "julia-sass") |
| 4704 | (version "0.2.0") |
| 4705 | (source |
| 4706 | (origin |
| 4707 | (method git-fetch) |
| 4708 | (uri (git-reference |
| 4709 | (url "https://github.com/piever/Sass.jl") |
| 4710 | (commit (string-append "v" version)))) |
| 4711 | (file-name (git-file-name name version)) |
| 4712 | (sha256 |
| 4713 | (base32 "0y7kkkj717h5cj659ssry89i5r64symr6pvhr6vv4qmaxrnjxj92")))) |
| 4714 | (build-system julia-build-system) |
| 4715 | (propagated-inputs |
| 4716 | (list julia-libsass-jll)) |
| 4717 | (home-page "https://github.com/piever/Sass.jl") |
| 4718 | (synopsis "Compile scss and sass file to css") |
| 4719 | (description "This package provides a simple Julian API to use the |
| 4720 | @code{libsass} library to compile scss and sass files to css.") |
| 4721 | (license license:expat))) |
| 4722 | |
| 4723 | (define-public julia-scanbyte |
| 4724 | (package |
| 4725 | (name "julia-scanbyte") |
| 4726 | (version "0.3") |
| 4727 | (source |
| 4728 | (origin |
| 4729 | (method git-fetch) |
| 4730 | (uri (git-reference |
| 4731 | (url "https://github.com/jakobnissen/ScanByte.jl") |
| 4732 | (commit (string-append "v" version)))) |
| 4733 | (file-name (git-file-name name version)) |
| 4734 | (sha256 |
| 4735 | (base32 "0dqqa3d7c87358144pji6ik8xlki2hj0hkvjs72j5aypfms8rwn3")))) |
| 4736 | (build-system julia-build-system) |
| 4737 | (propagated-inputs |
| 4738 | (list julia-simd)) |
| 4739 | (home-page "https://github.com/jakobnissen/ScanByte.jl") |
| 4740 | (synopsis "Find the first occurrence of set of bytes in a chunk of memory") |
| 4741 | (description "This package finds the first occurrence of a byte or set of |
| 4742 | bytes in a chunk of memory. Think of it like a much faster version of |
| 4743 | @code{findfirst} that only iterates over bytes in memory.") |
| 4744 | (license license:expat))) |
| 4745 | |
| 4746 | (define-public julia-scratch |
| 4747 | (package |
| 4748 | (name "julia-scratch") |
| 4749 | (version "1.1.0") |
| 4750 | (source |
| 4751 | (origin |
| 4752 | (method git-fetch) |
| 4753 | (uri (git-reference |
| 4754 | (url "https://github.com/JuliaPackaging/Scratch.jl") |
| 4755 | (commit (string-append "v" version)))) |
| 4756 | (file-name (git-file-name name version)) |
| 4757 | (sha256 |
| 4758 | (base32 |
| 4759 | "09xni9rrrax17fxjz04j1b48mk9ffww5rcbagh66jklr89mrkqhx")))) |
| 4760 | (build-system julia-build-system) |
| 4761 | (arguments |
| 4762 | (list #:tests? #f)) ; Test suite tries to access the Julia package registry. |
| 4763 | (home-page "https://github.com/JuliaPackaging/Scratch.jl") |
| 4764 | (synopsis "Scratch spaces for all your persistent mutable data needs") |
| 4765 | (description "This repository implements the scratch spaces API for |
| 4766 | package-specific mutable containers of data. These spaces can contain datasets, |
| 4767 | text, binaries, or any other kind of data that would be convenient to store in |
| 4768 | a location specific to your package. As compared to Artifacts, these containers |
| 4769 | of data are mutable. Because the scratch space location on disk is not very |
| 4770 | user-friendly, scratch spaces should, in general, not be used for a storing |
| 4771 | files that the user must interact with through a file browser.") |
| 4772 | (license license:expat))) |
| 4773 | |
| 4774 | (define-public julia-showoff |
| 4775 | (package |
| 4776 | (name "julia-showoff") |
| 4777 | (version "1.0.2") |
| 4778 | (source |
| 4779 | (origin |
| 4780 | (method git-fetch) |
| 4781 | (uri (git-reference |
| 4782 | (url "https://github.com/JuliaGraphics/Showoff.jl") |
| 4783 | (commit (string-append "v" version)))) |
| 4784 | (file-name (git-file-name name version)) |
| 4785 | (sha256 |
| 4786 | (base32 "1g4hqvjjpwbrs7fnllyl5w66yj6qlvpvzpygym2nvf01m1ps6m53")))) |
| 4787 | (build-system julia-build-system) |
| 4788 | (home-page "https://github.com/JuliaGraphics/Showoff.jl") |
| 4789 | (synopsis "Nicely format an array of n things for tables and plots") |
| 4790 | (description "@code{Showoff} provides an interface for consistently |
| 4791 | formatting an array of n things, e.g. numbers, dates, unitful values. It's used |
| 4792 | in @code{Gadfly}, @code{Plots} and @code{Makie} to label axes and keys.") |
| 4793 | (license license:expat))) |
| 4794 | |
| 4795 | (define-public julia-simd |
| 4796 | (package |
| 4797 | (name "julia-simd") |
| 4798 | (version "3.4.0") |
| 4799 | (source |
| 4800 | (origin |
| 4801 | (method git-fetch) |
| 4802 | (uri (git-reference |
| 4803 | (url "https://github.com/eschnett/SIMD.jl") |
| 4804 | (commit (string-append "v" version)))) |
| 4805 | (file-name (git-file-name name version)) |
| 4806 | (sha256 |
| 4807 | (base32 "0z7m5fykc6r4bxz4hfm6d3v1h7gg0c322l4zv8r3vrb8hrd6h263")))) |
| 4808 | (build-system julia-build-system) |
| 4809 | (home-page "https://github.com/eschnett/SIMD.jl") |
| 4810 | (synopsis "Explicit SIMD vectorization") |
| 4811 | (description "This package allows programmers to explicitly SIMD-vectorize |
| 4812 | their Julia code. By exposing SIMD vector types and corresponding operations, |
| 4813 | the programmer can explicitly vectorize their code. While this does not |
| 4814 | guarantee that the generated machine code is efficient, it relieves the |
| 4815 | compiler from determining whether it is legal to vectorize the code, deciding |
| 4816 | whether it is beneficial to do so, and rearranging the code to synthesize |
| 4817 | vector instructions.") |
| 4818 | (license license:expat))) |
| 4819 | |
| 4820 | (define-public julia-simpletraits |
| 4821 | (package |
| 4822 | (name "julia-simpletraits") |
| 4823 | (version "0.9.4") |
| 4824 | (source |
| 4825 | (origin |
| 4826 | (method git-fetch) |
| 4827 | (uri (git-reference |
| 4828 | (url "https://github.com/mauro3/SimpleTraits.jl") |
| 4829 | (commit (string-append "v" version)))) |
| 4830 | (file-name (git-file-name name version)) |
| 4831 | (sha256 |
| 4832 | (base32 "1qvmkqcvhc2nilvkk36szccxdlcv9ls2i0ksxgl2yfjr3b3qlr05")))) |
| 4833 | (build-system julia-build-system) |
| 4834 | (propagated-inputs |
| 4835 | (list julia-macrotools)) |
| 4836 | (home-page "https://github.com/mauro3/SimpleTraits.jl") |
| 4837 | (synopsis "Simple Traits for Julia") |
| 4838 | (description "This package provides a macro-based implementation of traits. |
| 4839 | The main idea behind traits is to group types outside the type-hierarchy and to |
| 4840 | make dispatch work with that grouping. The difference to Union-types is that |
| 4841 | types can be added to a trait after the creation of the trait, whereas Union |
| 4842 | types are fixed after creation.") |
| 4843 | (license license:expat))) |
| 4844 | |
| 4845 | (define-public julia-softglobalscope |
| 4846 | (package |
| 4847 | (name "julia-softglobalscope") |
| 4848 | (version "1.1.0") |
| 4849 | (source |
| 4850 | (origin |
| 4851 | (method git-fetch) |
| 4852 | (uri (git-reference |
| 4853 | (url "https://github.com/stevengj/SoftGlobalScope.jl") |
| 4854 | (commit (string-append "v" version)))) |
| 4855 | (file-name (git-file-name name version)) |
| 4856 | (sha256 |
| 4857 | (base32 "1n3l0al1vw5jpb4k9a29a71666cdb617nmiqg34wcmyfzrxpvv39")))) |
| 4858 | (build-system julia-build-system) |
| 4859 | (home-page "https://github.com/stevengj/SoftGlobalScope.jl") |
| 4860 | (synopsis "Utilities for soft global scope in interactive Julia environments") |
| 4861 | (description |
| 4862 | "SoftGlobalScope is a package for the Julia language that simplifies the |
| 4863 | variable scoping rules for code in global scope. It is intended for interactive |
| 4864 | shells to make it easier to work interactively with Julia, especially for |
| 4865 | beginners.") |
| 4866 | (license license:expat))) |
| 4867 | |
| 4868 | (define-public julia-sortingalgorithms |
| 4869 | (package |
| 4870 | (name "julia-sortingalgorithms") |
| 4871 | (version "1.0.1") |
| 4872 | (source |
| 4873 | (origin |
| 4874 | (method git-fetch) |
| 4875 | (uri (git-reference |
| 4876 | (url "https://github.com/JuliaCollections/SortingAlgorithms.jl") |
| 4877 | (commit (string-append "v" version)))) |
| 4878 | (file-name (git-file-name name version)) |
| 4879 | (sha256 |
| 4880 | (base32 "173x77a80xnh99viqa3r7rgdaksvxaw8xyfqw09gwvp4p2zrxivb")))) |
| 4881 | (build-system julia-build-system) |
| 4882 | (arguments |
| 4883 | (list #:tests? #f)) ; cycle with StatsBase.jl |
| 4884 | (propagated-inputs |
| 4885 | (list julia-datastructures)) |
| 4886 | ;(native-inputs |
| 4887 | ; `(("julia-statsbase" ,julia-statsbase))) |
| 4888 | (home-page "https://github.com/JuliaCollections/SortingAlgorithms.jl") |
| 4889 | (synopsis "Extra sorting algorithms extending Julia's sorting API") |
| 4890 | (description "The SortingAlgorithms package provides three sorting |
| 4891 | algorithms that can be used with Julia's standard sorting API: heapsort, |
| 4892 | timsort and radixsort.") |
| 4893 | (license license:expat))) |
| 4894 | |
| 4895 | (define-public julia-specialfunctions |
| 4896 | (package |
| 4897 | (name "julia-specialfunctions") |
| 4898 | (version "1.6.0") |
| 4899 | (source |
| 4900 | (origin |
| 4901 | (method git-fetch) |
| 4902 | (uri (git-reference |
| 4903 | (url "https://github.com/JuliaMath/SpecialFunctions.jl") |
| 4904 | (commit (string-append "v" version)))) |
| 4905 | (file-name (git-file-name name version)) |
| 4906 | (sha256 |
| 4907 | (base32 "0nfpnglx7zl9g20w2mgfkg17hcw9ri0shaq2rwplj0ij5pwz8yf0")))) |
| 4908 | (build-system julia-build-system) |
| 4909 | (inputs |
| 4910 | (list julia-chainrulestestutils)) |
| 4911 | (propagated-inputs |
| 4912 | (list julia-chainrulescore |
| 4913 | julia-logexpfunctions |
| 4914 | julia-openspecfun-jll)) |
| 4915 | (home-page "https://github.com/JuliaMath/SpecialFunctions.jl") |
| 4916 | (synopsis "Special mathematical functions") |
| 4917 | (description "This package provides special mathematical functions, |
| 4918 | including Bessel, Hankel, Airy, error, Dawson, exponential (or sine and |
| 4919 | cosine) integrals, eta, zeta, digamma, inverse digamma, trigamma, and |
| 4920 | polygamma functions.") |
| 4921 | (license license:expat))) |
| 4922 | |
| 4923 | (define-public julia-splitapplycombine |
| 4924 | (package |
| 4925 | (name "julia-splitapplycombine") |
| 4926 | (version "1.1.4") |
| 4927 | (source |
| 4928 | (origin |
| 4929 | (method git-fetch) |
| 4930 | (uri (git-reference |
| 4931 | (url "https://github.com/JuliaData/SplitApplyCombine.jl") |
| 4932 | (commit (string-append "v" version)))) |
| 4933 | (file-name (git-file-name name version)) |
| 4934 | (sha256 |
| 4935 | (base32 "1qzaqvk57b0s5krzn8bxkzmr5kz6hi9dm3jbf2sl7z4vznsgbn9x")))) |
| 4936 | (build-system julia-build-system) |
| 4937 | (propagated-inputs |
| 4938 | (list julia-dictionaries |
| 4939 | julia-indexing)) |
| 4940 | (home-page "https://github.com/JuliaData/SplitApplyCombine.jl") |
| 4941 | (synopsis "Split-apply-combine strategies for Julia") |
| 4942 | (description "@code{SplitApplyCombine.jl} provides high-level, generic tools |
| 4943 | for manipulating data - particularly focussing on data in nested containers. An |
| 4944 | emphasis is placed on ensuring split-apply-combine strategies are easy to apply, |
| 4945 | and work reliably for arbitrary iterables and in an optimized way with the data |
| 4946 | structures included in Julia's standard library.") |
| 4947 | (license license:expat))) |
| 4948 | |
| 4949 | (define-public julia-stablerngs |
| 4950 | (package |
| 4951 | (name "julia-stablerngs") |
| 4952 | (version "1.0.0") |
| 4953 | (source |
| 4954 | (origin |
| 4955 | (method git-fetch) |
| 4956 | (uri (git-reference |
| 4957 | (url "https://github.com/JuliaRandom/StableRNGs.jl") |
| 4958 | (commit (string-append "v" version)))) |
| 4959 | (file-name (git-file-name name version)) |
| 4960 | (sha256 |
| 4961 | (base32 "1cw4wc38qbgmrrx0jjwjhynnarrzjkh0yyz242zj272brbci7p1r")))) |
| 4962 | (build-system julia-build-system) |
| 4963 | (home-page "https://github.com/JuliaRandom/StableRNGs.jl") |
| 4964 | (synopsis "Julia RNG with stable streams") |
| 4965 | (description "This package intends to provide a simple RNG with stable |
| 4966 | streams, suitable for tests in packages which need reproducible streams of |
| 4967 | random numbers across Julia versions. Indeed, the Julia RNGs provided by |
| 4968 | default are documented to have non-stable streams (which for example enables |
| 4969 | some performance improvements).") |
| 4970 | (license license:expat))) |
| 4971 | |
| 4972 | (define-public julia-stackviews |
| 4973 | (package |
| 4974 | (name "julia-stackviews") |
| 4975 | (version "0.1.1") |
| 4976 | (source |
| 4977 | (origin |
| 4978 | (method git-fetch) |
| 4979 | (uri (git-reference |
| 4980 | (url "https://github.com/JuliaArrays/StackViews.jl") |
| 4981 | (commit (string-append "v" version)))) |
| 4982 | (file-name (git-file-name name version)) |
| 4983 | (sha256 |
| 4984 | (base32 "1fwiaxdpx1z9dli3jr8kyraych0jbdiny3qklynf0r13px25r6i7")))) |
| 4985 | (build-system julia-build-system) |
| 4986 | (arguments |
| 4987 | (list |
| 4988 | #:phases |
| 4989 | #~(modify-phases %standard-phases |
| 4990 | (add-after 'link-depot 'skip-doctest |
| 4991 | (lambda _ |
| 4992 | (substitute* "test/runtests.jl" |
| 4993 | ((".*doctest.*") ""))))))) |
| 4994 | (propagated-inputs |
| 4995 | (list julia-offsetarrays)) |
| 4996 | (native-inputs |
| 4997 | (list julia-aqua |
| 4998 | julia-documenter)) |
| 4999 | (home-page "https://github.com/JuliaArrays/StackViews.jl") |
| 5000 | (synopsis "No more catcat") |
| 5001 | (description "StackViews provides only one array type: @code{StackView}. |
| 5002 | There are multiple ways to understand @code{StackView}: |
| 5003 | @itemize |
| 5004 | @item inverse of @code{eachslice} |
| 5005 | @item @code{cat} variant |
| 5006 | @item view object |
| 5007 | @item lazy version of @code{repeat} special case |
| 5008 | @end itemize") |
| 5009 | (license license:expat))) |
| 5010 | |
| 5011 | (define-public julia-static |
| 5012 | (package |
| 5013 | (name "julia-static") |
| 5014 | (version "0.3.0") |
| 5015 | (source |
| 5016 | (origin |
| 5017 | (method git-fetch) |
| 5018 | (uri (git-reference |
| 5019 | (url "https://github.com/SciML/Static.jl") |
| 5020 | (commit (string-append "v" version)))) |
| 5021 | (file-name (git-file-name name version)) |
| 5022 | (sha256 |
| 5023 | (base32 "19k7h47zhz3zz28i0l4b3cc0r07pzp8kf35z0yammpy361b644l2")))) |
| 5024 | (build-system julia-build-system) |
| 5025 | (propagated-inputs |
| 5026 | (list julia-ifelse)) |
| 5027 | (native-inputs |
| 5028 | (list julia-aqua)) |
| 5029 | (home-page "https://github.com/SciML/Static.jl") |
| 5030 | (synopsis "Static types useful for dispatch and generated functions") |
| 5031 | (description "Static.jl defines a limited set of statically parameterized |
| 5032 | types and a common interface that is shared between them.") |
| 5033 | (license license:expat))) |
| 5034 | |
| 5035 | (define-public julia-staticarrays |
| 5036 | (package |
| 5037 | (name "julia-staticarrays") |
| 5038 | (version "1.2.13") |
| 5039 | (source |
| 5040 | (origin |
| 5041 | (method git-fetch) |
| 5042 | (uri (git-reference |
| 5043 | (url "https://github.com/JuliaArrays/StaticArrays.jl") |
| 5044 | (commit (string-append "v" version)))) |
| 5045 | (file-name (git-file-name name version)) |
| 5046 | (sha256 |
| 5047 | (base32 "041mijzgzm8r61a3gwspr2wcxjikqksvj2rbnl4gmcy41alqmx79")))) |
| 5048 | (build-system julia-build-system) |
| 5049 | (inputs |
| 5050 | (list julia-benchmarktools)) |
| 5051 | (home-page "https://github.com/JuliaArrays/StaticArrays.jl") |
| 5052 | (synopsis "Statically sized arrays") |
| 5053 | (description "This package provides a framework for implementing |
| 5054 | statically sized arrays in Julia, using the abstract type |
| 5055 | @code{StaticArray{Size,T,N} <: AbstractArray{T,N}}. Subtypes of |
| 5056 | @code{StaticArray} will provide fast implementations of common array and |
| 5057 | linear algebra operations.") |
| 5058 | (license license:expat))) |
| 5059 | |
| 5060 | (define-public julia-statsapi |
| 5061 | (package |
| 5062 | (name "julia-statsapi") |
| 5063 | (version "1.0.0") |
| 5064 | (source |
| 5065 | (origin |
| 5066 | (method git-fetch) |
| 5067 | (uri (git-reference |
| 5068 | (url "https://github.com/JuliaStats/StatsAPI.jl") |
| 5069 | (commit (string-append "v" version)))) |
| 5070 | (file-name (git-file-name name version)) |
| 5071 | (sha256 |
| 5072 | (base32 "1k1c3s7i5wzkz4r9fyy4gd7wb97p0qgbc7bmaajm16zqipfmy2bv")))) |
| 5073 | (build-system julia-build-system) |
| 5074 | (home-page "https://juliastats.org/") |
| 5075 | (synopsis "Statistics-focused namespace for packages to share functions") |
| 5076 | (description "This package provides a namespace for data-related generic |
| 5077 | function definitions to solve the optional dependency problem; packages wishing |
| 5078 | to share and/or extend functions can avoid depending directly on each other by |
| 5079 | moving the function definition to @code{StatsAPI.jl} and each package taking a |
| 5080 | dependency on it.") |
| 5081 | (license license:expat))) |
| 5082 | |
| 5083 | (define-public julia-statsbase |
| 5084 | (package |
| 5085 | (name "julia-statsbase") |
| 5086 | (version "0.33.8") |
| 5087 | (source |
| 5088 | (origin |
| 5089 | (method git-fetch) |
| 5090 | (uri (git-reference |
| 5091 | (url "https://github.com/JuliaStats/StatsBase.jl") |
| 5092 | (commit (string-append "v" version)))) |
| 5093 | (file-name (git-file-name name version)) |
| 5094 | (sha256 |
| 5095 | (base32 "02y4pm5yvg713a2pn970bbcfkrn2h133rxbxk1da18svhqw3czhi")))) |
| 5096 | (build-system julia-build-system) |
| 5097 | (propagated-inputs |
| 5098 | (list julia-dataapi |
| 5099 | julia-datastructures |
| 5100 | julia-missings |
| 5101 | julia-sortingalgorithms |
| 5102 | julia-statsapi)) |
| 5103 | (native-inputs |
| 5104 | (list julia-stablerngs)) |
| 5105 | (home-page "https://github.com/JuliaStats/StatsBase.jl") |
| 5106 | (synopsis "Basic statistics for Julia") |
| 5107 | (description "StatsBase.jl is a Julia package that provides basic support |
| 5108 | for statistics. Particularly, it implements a variety of statistics-related |
| 5109 | functions, such as scalar statistics, high-order moment computation, counting, |
| 5110 | ranking, covariances, sampling, and empirical density estimation.") |
| 5111 | (license license:expat))) |
| 5112 | |
| 5113 | (define-public julia-stringdistances |
| 5114 | (package |
| 5115 | (name "julia-stringdistances") |
| 5116 | (version "0.10.0") |
| 5117 | (source |
| 5118 | (origin |
| 5119 | (method git-fetch) |
| 5120 | (uri (git-reference |
| 5121 | (url "https://github.com/matthieugomez/StringDistances.jl") |
| 5122 | (commit (string-append "v" version)))) |
| 5123 | (file-name (git-file-name name version)) |
| 5124 | (sha256 |
| 5125 | (base32 "0n5707wplbibzhhv1xmshvc025d7xk6mnikclc3hvq5cdc0gy9f7")))) |
| 5126 | (build-system julia-build-system) |
| 5127 | (propagated-inputs |
| 5128 | (list julia-distances)) |
| 5129 | (home-page "https://github.com/matthieugomez/StringDistances.jl") |
| 5130 | (synopsis "String Distances in Julia") |
| 5131 | (description "This package provides string distances in Julia. Distances |
| 5132 | are defined for @code{AbstractStrings}, and any iterator that define |
| 5133 | @code{length()}. The package also defines Distance \"modifiers\" that can be |
| 5134 | applied to any distance.") |
| 5135 | (license license:expat))) |
| 5136 | |
| 5137 | (define-public julia-stringencodings |
| 5138 | (package |
| 5139 | (name "julia-stringencodings") |
| 5140 | (version "0.3.5") |
| 5141 | (source |
| 5142 | (origin |
| 5143 | (method git-fetch) |
| 5144 | (uri (git-reference |
| 5145 | (url "https://github.com/JuliaStrings/StringEncodings.jl") |
| 5146 | (commit (string-append "v" version)))) |
| 5147 | (file-name (git-file-name name version)) |
| 5148 | (sha256 |
| 5149 | (base32 "1qwc5ll68ng80b5921ww6fvifxbsmiylakfgsbsjbzg7lzyb5i67")))) |
| 5150 | (build-system julia-build-system) |
| 5151 | (arguments |
| 5152 | (list |
| 5153 | #:phases |
| 5154 | #~(modify-phases %standard-phases |
| 5155 | (add-after 'unpack 'skip-failing-test |
| 5156 | (lambda _ |
| 5157 | ;; https://github.com/JuliaStrings/StringEncodings.jl/issues/49 |
| 5158 | (substitute* "test/runtests.jl" |
| 5159 | (("\"SHIFT_JIS\", \"SHIFT_JISX0213\"") |
| 5160 | " "))))))) |
| 5161 | (propagated-inputs |
| 5162 | (list julia-libiconv-jll)) |
| 5163 | (home-page "https://github.com/JuliaStrings/StringEncodings.jl") |
| 5164 | (synopsis "Support for decoding and encoding texts") |
| 5165 | (description "This package provides support for decoding and encoding |
| 5166 | texts between multiple character encodings. It is currently based on the |
| 5167 | @code{iconv} interface, and supports all major platforms using GNU libiconv.") |
| 5168 | (license license:expat))) |
| 5169 | |
| 5170 | (define-public julia-structarrays |
| 5171 | (package |
| 5172 | (name "julia-structarrays") |
| 5173 | (version "0.6.3") |
| 5174 | (source |
| 5175 | (origin |
| 5176 | (method git-fetch) |
| 5177 | (uri (git-reference |
| 5178 | (url "https://github.com/JuliaArrays/StructArrays.jl") |
| 5179 | (commit (string-append "v" version)))) |
| 5180 | (file-name (git-file-name name version)) |
| 5181 | (sha256 |
| 5182 | (base32 "0rjcpyjwzg70n87q5r9c5i1qzigavncslxssm3rk5a3y549py56v")))) |
| 5183 | (build-system julia-build-system) |
| 5184 | (arguments |
| 5185 | (list |
| 5186 | #:phases |
| 5187 | (if (target-64bit?) |
| 5188 | #~%standard-phases |
| 5189 | #~(modify-phases %standard-phases |
| 5190 | (add-after 'unpack 'fix-tests-int32-i686 |
| 5191 | (lambda _ |
| 5192 | (substitute* '("src/utils.jl" |
| 5193 | "test/runtests.jl") |
| 5194 | (("Int64") "Int32")))))))) |
| 5195 | (propagated-inputs |
| 5196 | (list julia-dataapi |
| 5197 | julia-staticarrays |
| 5198 | julia-tables)) |
| 5199 | (native-inputs |
| 5200 | (list julia-documenter |
| 5201 | julia-offsetarrays |
| 5202 | julia-pooledarrays |
| 5203 | julia-typedtables |
| 5204 | julia-weakrefstrings)) |
| 5205 | (home-page "https://github.com/JuliaArrays/StructArrays.jl") |
| 5206 | (synopsis "Efficient implementation of struct arrays in Julia") |
| 5207 | (description "This package introduces the type @code{StructArray} which is |
| 5208 | an @code{AbstractArray} whose elements are @code{struct} (for example |
| 5209 | @code{NamedTuples}, or @code{ComplexF64}, or a custom user defined |
| 5210 | @code{struct}). While a @code{StructArray} iterates @code{structs}, the layout |
| 5211 | is column based (meaning each field of the @code{struct} is stored in a separate |
| 5212 | @code{Array}).") |
| 5213 | (license license:expat))) |
| 5214 | |
| 5215 | (define-public julia-structtypes |
| 5216 | (package |
| 5217 | (name "julia-structtypes") |
| 5218 | (version "1.7.2") |
| 5219 | (source |
| 5220 | (origin |
| 5221 | (method git-fetch) |
| 5222 | (uri (git-reference |
| 5223 | (url "https://github.com/JuliaData/StructTypes.jl") |
| 5224 | (commit (string-append "v" version)))) |
| 5225 | (file-name (git-file-name name version)) |
| 5226 | (sha256 |
| 5227 | (base32 "02mn4kkhn3927dk7945c9bjwlldihydxgn5ilmqqvs8dknvbw8p1")))) |
| 5228 | (build-system julia-build-system) |
| 5229 | (home-page "https://juliadata.github.io/StructTypes.jl/stable/") |
| 5230 | (synopsis "Abstract definitions and convenience methods for Julia objects") |
| 5231 | (description "This package provides the @code{StructTypes.StructType} trait |
| 5232 | for Julia types to declare the kind of \"struct\" they are, providing |
| 5233 | serialization/deserialization packages patterns and strategies to automatically |
| 5234 | construct objects.") |
| 5235 | (license license:expat))) |
| 5236 | |
| 5237 | (define-public julia-suppressor |
| 5238 | (package |
| 5239 | (name "julia-suppressor") |
| 5240 | (version "0.2.0") |
| 5241 | (source |
| 5242 | (origin |
| 5243 | (method git-fetch) |
| 5244 | (uri (git-reference |
| 5245 | (url "https://github.com/JuliaIO/Suppressor.jl") |
| 5246 | (commit (string-append "v" version)))) |
| 5247 | (file-name (git-file-name name version)) |
| 5248 | (sha256 |
| 5249 | (base32 "0v6pxvf8lzrqjc676snvlszh14ridl442g2h6syfjiy75pk7mdyc")))) |
| 5250 | (build-system julia-build-system) |
| 5251 | (home-page "https://github.com/JuliaIO/Suppressor.jl") |
| 5252 | (synopsis "Capture stdout and sterr") |
| 5253 | (description "Julia macros for suppressing and/or capturing output (stdout), |
| 5254 | warnings (stderr) or both streams at the same time.") |
| 5255 | (license license:expat))) |
| 5256 | |
| 5257 | (define-public julia-tableiointerface |
| 5258 | (package |
| 5259 | (name "julia-tableiointerface") |
| 5260 | (version "0.1.6") |
| 5261 | (source |
| 5262 | (origin |
| 5263 | (method git-fetch) |
| 5264 | (uri (git-reference |
| 5265 | (url "https://github.com/lungben/TableIOInterface.jl") |
| 5266 | (commit (string-append "v" version)))) |
| 5267 | (file-name (git-file-name name version)) |
| 5268 | (sha256 |
| 5269 | (base32 "0p2fi9jbyfg2j6rysv4if7dx8qw2mssb04i75j1zq607j8707kvn")))) |
| 5270 | (build-system julia-build-system) |
| 5271 | (home-page "https://github.com/lungben/TableIOInterface.jl") |
| 5272 | (synopsis "File formats based on file extensions") |
| 5273 | (description "This package determines tabular file formats based on file |
| 5274 | extensions. It is intended to be the base both for @code{TableIO.jl} and for |
| 5275 | the @code{Pluto.jl} tabular data import functionality.") |
| 5276 | (license license:expat))) |
| 5277 | |
| 5278 | (define-public julia-tables |
| 5279 | (package |
| 5280 | (name "julia-tables") |
| 5281 | (version "1.4.4") |
| 5282 | (source |
| 5283 | (origin |
| 5284 | (method git-fetch) |
| 5285 | (uri (git-reference |
| 5286 | (url "https://github.com/JuliaData/Tables.jl") |
| 5287 | (commit (string-append "v" version)))) |
| 5288 | (file-name (git-file-name name version)) |
| 5289 | (sha256 |
| 5290 | (base32 "1sqqagzqvav8b1rv5ywwbgy9ixvlmipq95fkwfwn0m8769i8jwzb")))) |
| 5291 | (build-system julia-build-system) |
| 5292 | (propagated-inputs |
| 5293 | (list julia-dataapi |
| 5294 | julia-datavalueinterfaces |
| 5295 | julia-iteratorinterfaceextensions |
| 5296 | julia-tabletraits)) |
| 5297 | (native-inputs |
| 5298 | (list julia-datavalues |
| 5299 | julia-queryoperators)) |
| 5300 | (home-page "https://github.com/JuliaData/Tables.jl") |
| 5301 | (synopsis "Interface for tables in Julia") |
| 5302 | (description "The @code{Tables.jl} package provides simple, yet powerful |
| 5303 | interface functions for working with all kinds tabular data.") |
| 5304 | (license license:expat))) |
| 5305 | |
| 5306 | (define-public julia-tableshowutils |
| 5307 | ;; The 0.2.5 release is not fully compatable with newer versions of Julia. |
| 5308 | (let ((commit "c4e02d8b9bbb31fc81ed6618955e9b1c7cb04460") |
| 5309 | (revision "1")) |
| 5310 | (package |
| 5311 | (name "julia-tableshowutils") |
| 5312 | (version "0.2.5") |
| 5313 | (source |
| 5314 | (origin |
| 5315 | (method git-fetch) |
| 5316 | (uri (git-reference |
| 5317 | (url "https://github.com/queryverse/TableShowUtils.jl") |
| 5318 | (commit commit))) |
| 5319 | (file-name (git-file-name name version)) |
| 5320 | (sha256 |
| 5321 | (base32 "0gp3hpj3jvzfhkp9r345vfic2j2n2s60729wv38hwn75csp74cg5")))) |
| 5322 | (build-system julia-build-system) |
| 5323 | (propagated-inputs |
| 5324 | (list julia-datavalues |
| 5325 | julia-json)) |
| 5326 | (home-page "https://github.com/queryverse/TableShowUtils.jl") |
| 5327 | (synopsis "Implement show for TableTraits.jl types") |
| 5328 | (description "This package provides some common helper functions that make |
| 5329 | it easier to implement various @code{Base.show} functions for types that |
| 5330 | participate in the @code{TableTraits.jl} ecosystem.") |
| 5331 | (license license:expat)))) |
| 5332 | |
| 5333 | (define-public julia-tabletraits |
| 5334 | (package |
| 5335 | (name "julia-tabletraits") |
| 5336 | (version "1.0.1") |
| 5337 | (source |
| 5338 | (origin |
| 5339 | (method git-fetch) |
| 5340 | (uri (git-reference |
| 5341 | (url "https://github.com/queryverse/TableTraits.jl") |
| 5342 | (commit (string-append "v" version)))) |
| 5343 | (file-name (git-file-name name version)) |
| 5344 | (sha256 |
| 5345 | (base32 "08ssb2630wm6j8f2qa985mn2vfibfm5kjcn4ayl2qkhfcyp8daw4")))) |
| 5346 | (build-system julia-build-system) |
| 5347 | (propagated-inputs |
| 5348 | (list julia-iteratorinterfaceextensions)) |
| 5349 | (home-page "https://github.com/queryverse/TableTraits.jl") |
| 5350 | (synopsis "Traits for Julia tables") |
| 5351 | (description "TableTraits defines a generic interface for tabular data.") |
| 5352 | (license license:expat))) |
| 5353 | |
| 5354 | (define-public julia-tensorcore |
| 5355 | (package |
| 5356 | (name "julia-tensorcore") |
| 5357 | (version "0.1.1") |
| 5358 | (source |
| 5359 | (origin |
| 5360 | (method git-fetch) |
| 5361 | (uri (git-reference |
| 5362 | (url "https://github.com/JuliaMath/TensorCore.jl") |
| 5363 | (commit (string-append "v" version)))) |
| 5364 | (file-name (git-file-name name version)) |
| 5365 | (sha256 |
| 5366 | (base32 "1sy3in4a1rl3l2vk0cm9mzg2nkva7syhr7i35si0kbzhkdwpbqjy")))) |
| 5367 | (build-system julia-build-system) |
| 5368 | (home-page "https://github.com/JuliaMath/TensorCore.jl") |
| 5369 | (synopsis "Tensor-algebra definitions") |
| 5370 | (description "This package is intended as a lightweight foundation for |
| 5371 | tensor operations across the Julia ecosystem. Currently it exports three |
| 5372 | operations: @acronym{hadamard, elementwise multiplication}, @acronym{tensor, |
| 5373 | product preserves all dimensions}, and @acronym{boxdot, contracts neighboring |
| 5374 | dimensions}.") |
| 5375 | (license license:expat))) |
| 5376 | |
| 5377 | (define-public julia-testimages |
| 5378 | (package |
| 5379 | (name "julia-testimages") |
| 5380 | (version "1.5.0") |
| 5381 | (source |
| 5382 | (origin |
| 5383 | (method git-fetch) |
| 5384 | (uri (git-reference |
| 5385 | (url "https://github.com/JuliaImages/TestImages.jl") |
| 5386 | (commit (string-append "v" version)))) |
| 5387 | (file-name (git-file-name name version)) |
| 5388 | (sha256 |
| 5389 | (base32 "1lnfsmx33qspyvxw0cykwh7il8xykjpcw1080sisn95ngz2qhdmy")))) |
| 5390 | (build-system julia-build-system) |
| 5391 | (arguments |
| 5392 | (list #:tests? #f)) ; cycle with ImageMagick.jl |
| 5393 | (propagated-inputs |
| 5394 | (list julia-axisarrays |
| 5395 | julia-colortypes |
| 5396 | julia-fileio |
| 5397 | julia-offsetarrays |
| 5398 | julia-stringdistances)) |
| 5399 | ;(native-inputs |
| 5400 | ; `(("julia-colors" ,julia-colors) |
| 5401 | ; ("julia-fixedpointnumbers" ,julia-fixedpointnumbers) |
| 5402 | ; ("julia-imagecontrastadjustment" ,julia-imagecontrastadjustment) |
| 5403 | ; ("julia-imagemagick" ,julia-imagemagick) |
| 5404 | ; ("julia-ometiff" ,julia-ometiff) |
| 5405 | ; ("julia-referencetests" ,julia-referencetests))) |
| 5406 | (home-page "https://testimages.juliaimages.org/") |
| 5407 | (synopsis "Standard test images for Julia") |
| 5408 | (description "This package provides a convenient Julia interface for loading |
| 5409 | standard named test images and example images for the internal usage in |
| 5410 | @code{JuliaImages}. This can be used in conjunction with the @code{Images} |
| 5411 | package.") |
| 5412 | (license license:expat))) |
| 5413 | |
| 5414 | (define-public julia-tracker |
| 5415 | (package |
| 5416 | (name "julia-tracker") |
| 5417 | (version "0.2.12") |
| 5418 | (source |
| 5419 | (origin |
| 5420 | (method git-fetch) |
| 5421 | (uri (git-reference |
| 5422 | (url "https://github.com/FluxML/Tracker.jl") |
| 5423 | (commit (string-append "v" version)))) |
| 5424 | (file-name (git-file-name name version)) |
| 5425 | (sha256 |
| 5426 | (base32 "1s4mdywbp7nli7z985fqaj1rs4i6d92b1jx3lhg0qhk1s5wc0v8j")) |
| 5427 | (patches (search-patches "julia-tracker-16-compat.patch")))) |
| 5428 | (build-system julia-build-system) |
| 5429 | (propagated-inputs |
| 5430 | (list julia-adapt |
| 5431 | julia-diffrules |
| 5432 | julia-forwarddiff |
| 5433 | julia-macrotools |
| 5434 | julia-nanmath |
| 5435 | julia-nnlib |
| 5436 | julia-requires |
| 5437 | julia-specialfunctions)) |
| 5438 | (native-inputs |
| 5439 | (list julia-pdmats)) |
| 5440 | (home-page "https://github.com/FluxML/Tracker.jl") |
| 5441 | (synopsis "Operator overloading reverse-mode automatic differentiator") |
| 5442 | (description "@code{Tracker.jl} previously provided @code{Flux.jl} with |
| 5443 | automatic differentiation for its machine learning platform.") |
| 5444 | (license license:expat))) |
| 5445 | |
| 5446 | (define-public julia-transcodingstreams |
| 5447 | (package |
| 5448 | (name "julia-transcodingstreams") |
| 5449 | (version "0.9.6") |
| 5450 | (source |
| 5451 | (origin |
| 5452 | (method git-fetch) |
| 5453 | (uri (git-reference |
| 5454 | (url "https://github.com/JuliaIO/TranscodingStreams.jl") |
| 5455 | (commit (string-append "v" version)))) |
| 5456 | (file-name (git-file-name name version)) |
| 5457 | (sha256 |
| 5458 | (base32 "1w3klii293caqiclfh28jggv7f53xclm9fr6xmw38brwrn1hjb48")))) |
| 5459 | (build-system julia-build-system) |
| 5460 | (arguments |
| 5461 | (list #:tests? #f)) ; Circular dependency with various codecs. |
| 5462 | (home-page "https://github.com/JuliaIO/TranscodingStreams.jl") |
| 5463 | (synopsis "Fast I/O transcoding data streams") |
| 5464 | (description "This package provides tools for transcoding data streams |
| 5465 | which are: |
| 5466 | @itemize |
| 5467 | @item fast: small overhead and specialized methods |
| 5468 | @item consistent: basic I/O operations work as expected |
| 5469 | @item generic: support any I/O objects like files, buffers, pipes, etc. |
| 5470 | @item extensible: easy definition for new codec to transcode data |
| 5471 | @end itemize") |
| 5472 | (license license:expat))) |
| 5473 | |
| 5474 | (define-public julia-twiddle |
| 5475 | (package |
| 5476 | (name "julia-twiddle") |
| 5477 | (version "1.1.2") |
| 5478 | (source |
| 5479 | (origin |
| 5480 | (method git-fetch) |
| 5481 | (uri (git-reference |
| 5482 | (url "https://github.com/SabrinaJaye/Twiddle.jl") |
| 5483 | (commit (string-append "v" version)))) |
| 5484 | (file-name (git-file-name name version)) |
| 5485 | (sha256 |
| 5486 | (base32 "1c2gdv7sy4n1d8687w2q0yzwmwmanf4p6mvzvkz5gm4baxyzmbh2")))) |
| 5487 | (build-system julia-build-system) |
| 5488 | (home-page "https://ben-ward.science/Twiddle.jl/stable") |
| 5489 | (synopsis "Ready to use bit-twiddling tricks") |
| 5490 | (description "This package provides a collection of useful bit-twiddling |
| 5491 | tricks, ready to use as functions, with detailed documentation and example |
| 5492 | real-world use cases.") |
| 5493 | (license license:expat))) |
| 5494 | |
| 5495 | (define-public julia-typedtables |
| 5496 | (package |
| 5497 | (name "julia-typedtables") |
| 5498 | (version "1.4.0") |
| 5499 | (source |
| 5500 | (origin |
| 5501 | (method git-fetch) |
| 5502 | (uri (git-reference |
| 5503 | (url "https://github.com/JuliaData/TypedTables.jl") |
| 5504 | (commit (string-append "v" version)))) |
| 5505 | (file-name (git-file-name name version)) |
| 5506 | (sha256 |
| 5507 | (base32 "0nk6zhqvl2r8yhjdhb59kxq0srd3vy4ysg4d8rszj9a43dnn3w3i")))) |
| 5508 | (build-system julia-build-system) |
| 5509 | (propagated-inputs |
| 5510 | (list julia-adapt |
| 5511 | julia-splitapplycombine |
| 5512 | julia-tables)) |
| 5513 | (home-page "https://github.com/JuliaData/TypedTables.jl") |
| 5514 | (synopsis "Column-based storage for data analysis in Julia") |
| 5515 | (description "@code{TypedTables.jl} provides two column-based storage |
| 5516 | containers: @code{Table} and @code{FlexTable}, both of which represent an array |
| 5517 | of @code{NamedTuples}. This package is designed to be lightweight, easy-to-use |
| 5518 | and fast, and presents a very minimal new interface to learn.") |
| 5519 | (license license:expat))) |
| 5520 | |
| 5521 | (define-public julia-unpack |
| 5522 | (package |
| 5523 | (name "julia-unpack") |
| 5524 | (version "1.0.2") |
| 5525 | (source |
| 5526 | (origin |
| 5527 | (method git-fetch) |
| 5528 | (uri (git-reference |
| 5529 | (url "https://github.com/mauro3/UnPack.jl") |
| 5530 | (commit (string-append "v" version)))) |
| 5531 | (file-name (git-file-name name version)) |
| 5532 | (sha256 |
| 5533 | (base32 "066v1px72zidnvhl0rczhh07rcfwvli0jx5nprrgyi1dvj3mps2a")))) |
| 5534 | (build-system julia-build-system) |
| 5535 | (home-page "https://github.com/mauro3/UnPack.jl") |
| 5536 | (synopsis "Pack and Unpack macros for Julia") |
| 5537 | (description "The @code{@@unpack} and @code{@@pack!} macros work to unpack |
| 5538 | types, modules, and dictionaries.") |
| 5539 | (license license:expat))) |
| 5540 | |
| 5541 | (define-public julia-uris |
| 5542 | (package |
| 5543 | (name "julia-uris") |
| 5544 | (version "1.3.0") |
| 5545 | (source |
| 5546 | (origin |
| 5547 | (method git-fetch) |
| 5548 | (uri (git-reference |
| 5549 | (url "https://github.com/JuliaWeb/URIs.jl") |
| 5550 | (commit (string-append "v" version)))) |
| 5551 | (file-name (git-file-name name version)) |
| 5552 | (sha256 |
| 5553 | (base32 "0kp4hg3kknkm2smlcizqfd33l9x4vkahc2714gnbjp39fj285b92")))) |
| 5554 | (build-system julia-build-system) |
| 5555 | (arguments |
| 5556 | (list |
| 5557 | #:julia-package-name "URIs" ;required to run tests |
| 5558 | #:julia-package-uuid "5c2747f8-b7ea-4ff2-ba2e-563bfd36b1d4" |
| 5559 | #:phases |
| 5560 | #~(modify-phases %standard-phases |
| 5561 | (add-before 'check 'change-dir |
| 5562 | ;; Tests must be run from the testdir |
| 5563 | (lambda* (#:key source outputs #:allow-other-keys) |
| 5564 | (let ((out (assoc-ref outputs "out"))) |
| 5565 | (chdir |
| 5566 | (string-append out "/share/julia/loadpath/URIs/test"))) |
| 5567 | #t))))) |
| 5568 | ;; required for tests |
| 5569 | (inputs (list julia-json)) |
| 5570 | (home-page "https://github.com/JuliaWeb/URIs.jl") |
| 5571 | (synopsis "URI parsing in Julia") |
| 5572 | (description "@code{URIs.jl} is a Julia package that allows parsing and |
| 5573 | working with @acronym{URIs,Uniform Resource Identifiers}, as defined in RFC |
| 5574 | 3986.") |
| 5575 | (license license:expat))) |
| 5576 | |
| 5577 | (define-public julia-unitful |
| 5578 | (package |
| 5579 | (name "julia-unitful") |
| 5580 | (version "1.9.0") |
| 5581 | (source |
| 5582 | (origin |
| 5583 | (method git-fetch) |
| 5584 | (uri (git-reference |
| 5585 | (url "https://github.com/PainterQubits/Unitful.jl") |
| 5586 | (commit (string-append "v" version)))) |
| 5587 | (file-name (git-file-name name version)) |
| 5588 | (sha256 |
| 5589 | (base32 "10qwscd15dnmvx116dwvg99m7kmwgmj5ahdkq7psiq48lcc554gq")))) |
| 5590 | (build-system julia-build-system) |
| 5591 | (arguments |
| 5592 | (list #:parallel-tests? #f)) |
| 5593 | (propagated-inputs |
| 5594 | (list julia-constructionbase)) |
| 5595 | (home-page "https://painterqubits.github.io/Unitful.jl/stable/") |
| 5596 | (synopsis "Physical units in Julia") |
| 5597 | (description "This package supports SI units and also many other unit |
| 5598 | system.") |
| 5599 | (license license:expat))) |
| 5600 | |
| 5601 | (define-public julia-versionparsing |
| 5602 | (package |
| 5603 | (name "julia-versionparsing") |
| 5604 | (version "1.2.0") |
| 5605 | (source |
| 5606 | (origin |
| 5607 | (method git-fetch) |
| 5608 | (uri (git-reference |
| 5609 | (url "https://github.com/JuliaInterop/VersionParsing.jl") |
| 5610 | (commit (string-append "v" version)))) |
| 5611 | (file-name (git-file-name name version)) |
| 5612 | (sha256 |
| 5613 | (base32 "060s72dsnpavgilf7f7315lw2sn4npk8lkndmj6bg7i23hppiwva")))) |
| 5614 | (build-system julia-build-system) |
| 5615 | (home-page "https://github.com/JuliaInterop/VersionParsing.jl") |
| 5616 | (synopsis "Flexible VersionNumber parsing in Julia") |
| 5617 | (description "The @code{VersionParsing} package implements flexible parsing |
| 5618 | of version-number strings into Julia's built-in @code{VersionNumber} type, via |
| 5619 | the @code{vparse(string)} function. Unlike the @code{VersionNumber(string)} |
| 5620 | constructor, @code{vparse(string)} can handle version-number strings in a much |
| 5621 | wider range of formats than are encompassed by the semver standard. This is |
| 5622 | useful in order to support @code{VersionNumber} comparisons applied to |
| 5623 | \"foreign\" version numbers from external packages.") |
| 5624 | (license license:expat))) |
| 5625 | |
| 5626 | (define-public julia-weakrefstrings |
| 5627 | (package |
| 5628 | (name "julia-weakrefstrings") |
| 5629 | (version "1.1.0") |
| 5630 | (source |
| 5631 | (origin |
| 5632 | (method git-fetch) |
| 5633 | (uri (git-reference |
| 5634 | (url "https://github.com/JuliaData/WeakRefStrings.jl") |
| 5635 | (commit (string-append "v" version)))) |
| 5636 | (file-name (git-file-name name version)) |
| 5637 | (sha256 |
| 5638 | (base32 "14h1vdnc3rx87w6v2rr59lgb4kai2hd1wzqpxhmzsi8karg2z219")))) |
| 5639 | (build-system julia-build-system) |
| 5640 | (propagated-inputs |
| 5641 | (list julia-dataapi |
| 5642 | julia-parsers)) |
| 5643 | (home-page "https://github.com/JuliaData/WeakRefStrings.jl") |
| 5644 | (synopsis "Efficient string representation and transfer in Julia") |
| 5645 | (description "This package provides a minimal String type for Julia that |
| 5646 | allows for efficient string representation and transfer") |
| 5647 | (license license:expat))) |
| 5648 | |
| 5649 | (define-public julia-woodburymatrices |
| 5650 | (package |
| 5651 | (name "julia-woodburymatrices") |
| 5652 | (version "0.5.3") |
| 5653 | (source |
| 5654 | (origin |
| 5655 | (method git-fetch) |
| 5656 | (uri (git-reference |
| 5657 | (url "https://github.com/timholy/WoodburyMatrices.jl") |
| 5658 | (commit (string-append "v" version)))) |
| 5659 | (file-name (git-file-name name version)) |
| 5660 | (sha256 |
| 5661 | (base32 "04yykivi8zrbryxlmb0p5xa6lma8iq22r5s863117dnnqj5gaffd")))) |
| 5662 | (build-system julia-build-system) |
| 5663 | (arguments |
| 5664 | (list |
| 5665 | #:phases |
| 5666 | (if (target-x86-32?) |
| 5667 | #~(modify-phases %standard-phases |
| 5668 | (add-after 'unpack 'remove-failing-test-i686 |
| 5669 | (lambda _ |
| 5670 | (substitute* "test/woodbury.jl" |
| 5671 | (("@test logdet\\(W\\)") |
| 5672 | "@test_broken logdet(W)"))))) |
| 5673 | #~%standard-phases))) |
| 5674 | (home-page "https://github.com/timholy/WoodburyMatrices.jl") |
| 5675 | (synopsis "Support for the Woodbury matrix identity for Julia") |
| 5676 | (description "This package provides support for the Woodbury matrix identity |
| 5677 | for the Julia programming language. This is a generalization of the |
| 5678 | Sherman-Morrison formula. Note that the Woodbury matrix identity is notorious |
| 5679 | for floating-point roundoff errors, so be prepared for a certain amount of |
| 5680 | inaccuracy in the result.") |
| 5681 | (license license:expat))) |
| 5682 | |
| 5683 | (define-public julia-yaml |
| 5684 | (package |
| 5685 | (name "julia-yaml") |
| 5686 | (version "0.4.7") |
| 5687 | (source |
| 5688 | (origin |
| 5689 | (method git-fetch) |
| 5690 | (uri (git-reference |
| 5691 | (url "https://github.com/JuliaData/YAML.jl") |
| 5692 | (commit (string-append "v" version)))) |
| 5693 | (file-name (git-file-name name version)) |
| 5694 | (sha256 |
| 5695 | (base32 "00k8456ffldbf75k2q5yxim7cgz3p0pbshsvmpm1331g8qy6liin")))) |
| 5696 | (build-system julia-build-system) |
| 5697 | (propagated-inputs |
| 5698 | (list julia-stringencodings)) |
| 5699 | (native-inputs |
| 5700 | (list julia-datastructures |
| 5701 | julia-orderedcollections)) |
| 5702 | (home-page "https://github.com/JuliaData/YAML.jl") |
| 5703 | (synopsis "Parses YAML documents into native Julia types") |
| 5704 | (description "This package parses YAML documents into native Julia types |
| 5705 | and dumps them back into YAML documents.") |
| 5706 | (license license:expat))) |
| 5707 | |
| 5708 | (define-public julia-zipfile |
| 5709 | (package |
| 5710 | (name "julia-zipfile") |
| 5711 | (version "0.9.3") |
| 5712 | (source |
| 5713 | (origin |
| 5714 | (method git-fetch) |
| 5715 | (uri (git-reference |
| 5716 | (url "https://github.com/fhs/ZipFile.jl") |
| 5717 | (commit (string-append "v" version)))) |
| 5718 | (file-name (git-file-name name version)) |
| 5719 | (sha256 |
| 5720 | (base32 |
| 5721 | "15bm3ki5mb9nvqs2byznrryq0bilnjcvsfy3k05hxhk9vapilw7k")))) |
| 5722 | (build-system julia-build-system) |
| 5723 | (propagated-inputs |
| 5724 | (list julia-zlib-jll)) |
| 5725 | (home-page "https://github.com/fhs/ZipFile.jl") |
| 5726 | (synopsis "Read/Write ZIP archives in Julia") |
| 5727 | (description "This module provides support for reading and writing ZIP |
| 5728 | archives in Julia.") |
| 5729 | (license license:expat))) |
| 5730 | |
| 5731 | (define-public julia-zygoterules |
| 5732 | (package |
| 5733 | (name "julia-zygoterules") |
| 5734 | (version "0.2.1") |
| 5735 | (source |
| 5736 | (origin |
| 5737 | (method git-fetch) |
| 5738 | (uri (git-reference |
| 5739 | (url "https://github.com/FluxML/ZygoteRules.jl") |
| 5740 | (commit (string-append "v" version)))) |
| 5741 | (file-name (git-file-name name version)) |
| 5742 | (sha256 |
| 5743 | (base32 "07i2mf6rr5b8i6l82qgwl5arsb5pwyyzyfasgnszhdqllk9501bs")))) |
| 5744 | (build-system julia-build-system) |
| 5745 | (propagated-inputs |
| 5746 | (list julia-macrotools)) |
| 5747 | (home-page "https://github.com/FluxML/ZygoteRules.jl") |
| 5748 | (synopsis "Add minimal custom gradients to Zygote") |
| 5749 | (description "Minimal package which enables to add custom gradients to |
| 5750 | Zygote, without depending on Zygote itself.") |
| 5751 | (license license:expat))) |
| 5752 | |
| 5753 | (define-public julia-zygote |
| 5754 | (package |
| 5755 | (name "julia-zygote") |
| 5756 | (version "0.6.17") |
| 5757 | (source |
| 5758 | (origin |
| 5759 | (method git-fetch) |
| 5760 | (uri (git-reference |
| 5761 | (url "https://github.com/FluxML/Zygote.jl") |
| 5762 | (commit (string-append "v" version)))) |
| 5763 | (file-name (git-file-name name version)) |
| 5764 | (sha256 |
| 5765 | (base32 "1cx66sp30s34ln6p0fpqk1ggjxfxg2gp8791zz3cl85dmk4dl14b")))) |
| 5766 | (build-system julia-build-system) |
| 5767 | (arguments |
| 5768 | (list #:tests? #f)) ;require CUDA, not packaged yet |
| 5769 | (propagated-inputs |
| 5770 | (list julia-abstractffts |
| 5771 | julia-chainrules |
| 5772 | julia-diffrules |
| 5773 | julia-fillarrays |
| 5774 | julia-forwarddiff |
| 5775 | julia-irtools |
| 5776 | julia-macrotools |
| 5777 | julia-nanmath |
| 5778 | julia-requires |
| 5779 | julia-specialfunctions |
| 5780 | julia-zygoterules)) |
| 5781 | (home-page "https://fluxml.ai/Zygote.jl") |
| 5782 | (synopsis "Automatic differentiation in Julia") |
| 5783 | (description "Zygote provides source-to-source automatic |
| 5784 | differentiation (AD) in Julia, and is the next-generation AD system for the |
| 5785 | Flux differentiable programming framework.") |
| 5786 | (license license:expat))) |