diff options
Diffstat (limited to 'gnu/packages/julia-xyz.scm')
| -rw-r--r-- | gnu/packages/julia-xyz.scm | 1749 |
1 files changed, 1723 insertions, 26 deletions
diff --git a/gnu/packages/julia-xyz.scm b/gnu/packages/julia-xyz.scm index 816ca9c85b..50effa43f4 100644 --- a/gnu/packages/julia-xyz.scm +++ b/gnu/packages/julia-xyz.scm @@ -77,7 +77,7 @@ in this package.") (define-public julia-adapt (package (name "julia-adapt") - (version "3.3.0") + (version "3.3.1") (source (origin (method git-fetch) @@ -86,7 +86,7 @@ in this package.") (commit (string-append "v" version)))) (file-name (git-file-name name version)) (sha256 - (base32 "0zs5mjnql77jvrsm8lrlfkq5524wnrfxqxyqyjk8ka2xpxf9lp7n")))) + (base32 "009fj59fzhvfsyw35kakllsh36k3xlwyzq8qa5f5k598i3pq14i7")))) (build-system julia-build-system) (home-page "https://github.com/JuliaGPU/Adapt.jl") (synopsis "Package providing the @code{adapt} function, similar to @code{convert}") @@ -116,6 +116,42 @@ be GPU compatible without throwing away the wrapper.") provides functions to run a few automatable checks for Julia packages.") (license license:expat))) +(define-public julia-arrayinterface + (package + (name "julia-arrayinterface") + (version "3.1.17") + (source + (origin + (method git-fetch) + (uri (git-reference + (url "https://github.com/JuliaArrays/ArrayInterface.jl") + (commit (string-append "v" version)))) + (file-name (git-file-name name version)) + (sha256 + (base32 "1yfl7wsciqm8ggfs6grxdrvpkxniy4c63d05f65v2j0c55z8a6mn")))) + (build-system julia-build-system) + (propagated-inputs + `(("julia-ifelse" ,julia-ifelse) + ("julia-requires" ,julia-requires) + ("julia-static" ,julia-static))) + (native-inputs + `(("julia-aqua" ,julia-aqua) + ("julia-bandedmatrices" ,julia-bandedmatrices) + ("julia-blockbandedmatrices" ,julia-blockbandedmatrices) + ("julia-ifelse" ,julia-ifelse) + ("julia-offsetarrays" ,julia-offsetarrays) + ("julia-staticarrays" ,julia-staticarrays))) + (home-page "https://github.com/JuliaArrays/ArrayInterface.jl") + (synopsis "Base array interface primitives") + (description "The purpose of this library is to solidify extensions to the +current @code{AbstractArray} interface, which are put to use in package +ecosystems like @code{DifferentialEquations.jl}. Since these libraries are +live, this package will serve as a staging ground for ideas before they are +merged into Base Julia. For this reason, no functionality is exported so that +if such functions are added and exported in a future Base Julia, there will be +no issues with the upgrade.") + (license license:expat))) + (define-public julia-arraylayouts (package (name "julia-arraylayouts") @@ -140,6 +176,86 @@ appropriate BLAS or optimised Julia linear algebra routines. This supports a much wider class of matrix types than Julia's in-built @code{StridedArray}.") (license license:expat))) +(define-public julia-axisalgorithms + (package + (name "julia-axisalgorithms") + (version "1.0.0") + (source + (origin + (method git-fetch) + (uri (git-reference + (url "https://github.com/timholy/AxisAlgorithms.jl") + (commit (string-append "v" version)))) + (file-name (git-file-name name version)) + (sha256 + (base32 "00x85lnfln7xkfnirpplzyi8r6q92nfqwya8il156bf7b1pa20gk")))) + (build-system julia-build-system) + (propagated-inputs + `(("julia-woodburymatrices" ,julia-woodburymatrices))) + (home-page "https://github.com/timholy/AxisAlgorithms.jl") + (synopsis "Filtering and linear algebra routines for multidimensional arrays") + (description "@code{AxisAlgorithms} is a collection of filtering and linear +algebra algorithms for multidimensional arrays. For algorithms that would +typically apply along the columns of a matrix, you can instead pick an arbitrary +axis (dimension).") + (license license:expat))) + +(define-public julia-axisarrays + (package + (name "julia-axisarrays") + (version "0.4.3") + (source + (origin + (method git-fetch) + (uri (git-reference + (url "https://github.com/JuliaArrays/AxisArrays.jl") + (commit (string-append "v" version)))) + (file-name (git-file-name name version)) + (sha256 + (base32 "079rj7wvh9ks293g2ih1yah5k0sg8wazw08z3vg2bxj4s16wr64p")))) + (build-system julia-build-system) + (propagated-inputs + `(("julia-rangearrays" ,julia-rangearrays) + ("julia-intervalsets" ,julia-intervalsets) + ("julia-itertools" ,julia-itertools))) + (native-inputs + `(("julia-offsetarrays" ,julia-offsetarrays) + ("julia-unitful" ,julia-unitful))) + (home-page "http://juliaarrays.github.io/AxisArrays.jl/latest/") + (synopsis "Arrays where each dimension can have a named axis with values") + (description "This package for the Julia language provides an array type +(the AxisArray) that knows about its dimension names and axis values. This +allows for indexing by name without incurring any runtime overhead. This +permits one to implement algorithms that are oblivious to the storage order of +the underlying arrays. AxisArrays can also be indexed by the values along their +axes, allowing column names or interval selections.") + (license license:expat))) + +(define-public julia-bandedmatrices + (package + (name "julia-bandedmatrices") + (version "0.16.9") + (source + (origin + (method git-fetch) + (uri (git-reference + (url "https://github.com/JuliaMatrices/BandedMatrices.jl") + (commit (string-append "v" version)))) + (file-name (git-file-name name version)) + (sha256 + (base32 "105y5d3208s0byk3p0469sfy79lhjpdblk6karbwj8x7hl26na00")))) + (build-system julia-build-system) + (propagated-inputs + `(("julia-arraylayouts" ,julia-arraylayouts) + ("julia-fillarrays" ,julia-fillarrays))) + (native-inputs + `(("julia-genericlinearalgebra" ,julia-genericlinearalgebra))) + (home-page "https://github.com/JuliaMatrices/BandedMatrices.jl") + (synopsis "Julia package for representing banded matrices") + (description "This package supports representing banded matrices by only +the entries on the bands.") + (license license:expat))) + (define-public julia-benchmarktools (package (name "julia-benchmarktools") @@ -162,6 +278,70 @@ code easy by supplying a framework for writing and running groups of benchmarks as well as comparing benchmark results.") (license license:expat))) +(define-public julia-blockarrays + (package + (name "julia-blockarrays") + (version "0.15.3") + (source + (origin + (method git-fetch) + (uri (git-reference + (url "https://github.com/JuliaArrays/BlockArrays.jl") + (commit (string-append "v" version)))) + (file-name (git-file-name name version)) + (sha256 + (base32 "15nd493bfkx92ihnr8dj8mb155dj44iqw266igv0qr5q0wad2bfr")))) + (build-system julia-build-system) + (propagated-inputs + `(("julia-arraylayouts" ,julia-arraylayouts) + ("julia-fillarrays" ,julia-fillarrays))) + (native-inputs + `(("julia-lazyarrays" ,julia-lazyarrays) + ("julia-offsetarrays" ,julia-offsetarrays) + ("julia-staticarrays" ,julia-staticarrays))) + (home-page "https://github.com/JuliaArrays/BlockArrays.jl") + (synopsis "BlockArrays for Julia") + (description "A block array is a partition of an array into blocks or +subarrays. This package has two purposes. Firstly, it defines an interface for +an @code{AbstractBlockArray} block arrays that can be shared among types +representing different types of block arrays. The advantage to this is that it +provides a consistent API for block arrays. +Secondly, it also implements two different type of block arrays that follow the +@code{AbstractBlockArray} interface. The type @code{BlockArray} stores each +block contiguously while the type @code{PseudoBlockArray} stores the full matrix +contiguously. This means that @code{BlockArray} supports fast non copying +extraction and insertion of blocks while @code{PseudoBlockArray} supports fast +access to the full matrix to use in in for example a linear solver.") + (license license:expat))) + +(define-public julia-blockbandedmatrices + (package + (name "julia-blockbandedmatrices") + (version "0.10.6") + (source + (origin + (method git-fetch) + (uri (git-reference + (url "https://github.com/JuliaMatrices/BlockBandedMatrices.jl") + (commit (string-append "v" version)))) + (file-name (git-file-name name version)) + (sha256 + (base32 "0q9ni4pgdkb00jb42fdzlhx745852xx2666vr96k0c4l0cn5mi0y")))) + (build-system julia-build-system) + (propagated-inputs + `(("julia-arraylayouts" ,julia-arraylayouts) + ("julia-bandedmatrices" ,julia-bandedmatrices) + ("julia-blockarrays" ,julia-blockarrays) + ("julia-fillarrays" ,julia-fillarrays) + ("julia-matrixfactorizations" ,julia-matrixfactorizations))) + (home-page "https://github.com/JuliaMatrices/BlockBandedMatrices.jl") + (synopsis "Block-banded matrices and banded-block-banded matrices") + (description "This package supports representing block-banded and +banded-block-banded matrices by only storing the entries in the non-zero bands. +A @code{BlockBandedMatrix} is a subtype of @code{BlockMatrix} of +@code{BlockArrays.jl} whose layout of non-zero blocks is banded.") + (license license:expat))) + (define-public julia-bufferedstreams (package (name "julia-bufferedstreams") @@ -379,6 +559,54 @@ constructors, and sets up traits and show methods to make them easier to work with.") (license license:expat))) +(define-public julia-colorvectorspace + (package + (name "julia-colorvectorspace") + (version "0.9.5") + (source + (origin + (method git-fetch) + (uri (git-reference + (url "https://github.com/JuliaGraphics/ColorVectorSpace.jl") + (commit (string-append "v" version)))) + (file-name (git-file-name name version)) + (sha256 + (base32 "1gx4k1bvf6lkzxphnvpkw857ihrkifhb68yvsj889k9pf1vda3fq")))) + (build-system julia-build-system) + (propagated-inputs + `(("julia-colortypes" ,julia-colortypes) + ("julia-specialfunctions" ,julia-specialfunctions) + ("julia-tensorcore" ,julia-tensorcore))) + (native-inputs + `(("julia-colors" ,julia-colors))) + (home-page "https://github.com/JuliaGraphics/ColorVectorSpace.jl") + (synopsis "Treat colors as n-vectors for the purposes of arithmetic") + (description "This package is an add-on to @code{ColorTypes.jl} and provides +fast mathematical operations for objects with types such as RGB and Gray. +Specifically, with this package both grayscale and RGB colors are treated as if +they are points in a normed vector space.") + (license license:expat))) + +(define-public julia-combinatorics + (package + (name "julia-combinatorics") + (version "1.0.2") + (source + (origin + (method git-fetch) + (uri (git-reference + (url "https://github.com/JuliaMath/Combinatorics.jl") + (commit (string-append "v" version)))) + (file-name (git-file-name name version)) + (sha256 + (base32 "0gafqkqi874zfm9h99akw9q95lk3ih5gip2h8p12fj9h7rvyf4j5")))) + (build-system julia-build-system) + (home-page "https://github.com/JuliaMath/Combinatorics.jl") + (synopsis "Combinatorics library for Julia") + (description "This package provides a combinatorics library for Julia, +focusing mostly (as of now) on enumerative combinatorics and permutations.") + (license license:expat))) + (define-public julia-commonsubexpressions (package (name "julia-commonsubexpressions") @@ -404,7 +632,7 @@ common subexpression elimination.") (define-public julia-compat (package (name "julia-compat") - (version "3.29.0") + (version "3.30.0") (source (origin (method git-fetch) @@ -413,7 +641,7 @@ common subexpression elimination.") (commit (string-append "v" version)))) (file-name (git-file-name name version)) (sha256 - (base32 "00wn28kmzn61fpj3i8f6p987927h9315j9pzzvjpfk5c0ppd1p6q")))) + (base32 "1qs6fm58dicdjy69qk5p0ndj2b7qsvg7rmydq7igvrvirad55v56")))) (build-system julia-build-system) (home-page "https://github.com/JuliaLang/Compat.jl") (synopsis "Compatibility across Julia versions") @@ -443,6 +671,41 @@ way.") for construction of objects.") (license license:expat))) +(define-public julia-coordinatetransformations + (package + (name "julia-coordinatetransformations") + (version "0.6.1") + (source + (origin + (method git-fetch) + (uri (git-reference + (url "https://github.com/JuliaGeometry/CoordinateTransformations.jl") + (commit (string-append "v" version)))) + (file-name (git-file-name name version)) + (sha256 + (base32 "15zbkn32v7xlz7559s0r5a0vkwmjwsswxaqpzijly4lky4jnp33d")))) + (build-system julia-build-system) + (arguments + `(#:tests? #f)) ; Documenter.jl not packaged yet. + (propagated-inputs + `(("julia-staticarrays" ,julia-staticarrays))) + ;(native-inputs + ; `(("julia-documenter" ,julia-documenter) + ; ("julia-forwarddiff" ,julia-forwarddiff) + ; ("julia-unitful" ,julia-unitful))) + (home-page "https://github.com/JuliaGeometry/CoordinateTransformations.jl") + (synopsis "Coordinate transformations in Julia") + (description "@code{CoordinateTransformations} is a Julia package to manage +simple or complex networks of coordinate system transformations. +Transformations can be easily applied, inverted, composed, and differentiated +(both with respect to the input coordinates and with respect to transformation +parameters such as rotation angle). Transformations are designed to be +light-weight and efficient enough for, e.g., real-time graphical applications, +while support for both explicit and automatic differentiation makes it easy to +perform optimization and therefore ideal for computer vision applications such +as SLAM (simultaneous localization and mapping).") + (license license:expat))) + (define-public julia-crayons (package (name "julia-crayons") @@ -566,6 +829,29 @@ without having to take direct dependencies.") to represent missing data.") (license license:expat))) +(define-public julia-deepdiffs + (package + (name "julia-deepdiffs") + (version "1.2.0") + (source + (origin + (method git-fetch) + (uri (git-reference + (url "https://github.com/ssfrr/DeepDiffs.jl") + (commit (string-append "v" version)))) + (file-name (git-file-name name version)) + (sha256 + (base32 "1gsbxb1d67g05h5bvzz3swdfih6404jrydy724a8dvbdgqvm3sds")))) + (build-system julia-build-system) + (home-page "https://github.com/ssfrr/DeepDiffs.jl") + (synopsis "Compute and pretty-print diffs for data structures") + (description "@code{DeepDiffs.jl} provides the @code{deepdiff} function, +which finds and displays differences (diffs) between Julia data structures. It +supports @code{Vectors}, @code{Dicts}, and @code{String}s. When diffing +dictionaries where values associated with a particular key may change, +@code{deepdiff} will recurse into value to provide a more detailed diff.") + (license license:expat))) + (define-public julia-dictionaries (package (name "julia-dictionaries") @@ -588,10 +874,46 @@ to represent missing data.") dictionaries in Julia, for improved productivity and performance.") (license license:expat))) +(define-public julia-distances + (package + (name "julia-distances") + (version "0.10.3") + (source + (origin + (method git-fetch) + (uri (git-reference + (url "https://github.com/JuliaStats/Distances.jl") + (commit (string-append "v" version)))) + (file-name (git-file-name name version)) + (sha256 + (base32 "1yqd9wg4z15k42mrp4y14j2x0sq7yrjhm5zpqklrw6w6j1c367ig")))) + (build-system julia-build-system) + (arguments + `(#:phases + (modify-phases %standard-phases + (add-after 'unpack 'skip-flakey-tests + (lambda _ + (substitute* "test/test_dists.jl" + (("test dyz ≥") "test_nowarn dyz ≥") + (("test dist\\(y, x") "test_nowarn dist(y, x") + (("test dist\\(z, x") "test_nowarn dist(z, x"))))))) + (propagated-inputs + `(("julia-statsapi" ,julia-statsapi))) + (native-inputs + `(("julia-offsetarrays" ,julia-offsetarrays) + ("julia-unitful" ,julia-unitful))) + (home-page "https://github.com/JuliaStats/Distances.jl") + (synopsis "Julia package for evaluating distances (metrics) between vectors") + (description "A Julia package for evaluating distances(metrics) between +vectors. This package also provides optimized functions to compute column-wise +and pairwise distances, which are often substantially faster than a +straightforward loop implementation.") + (license license:expat))) + (define-public julia-docstringextensions (package (name "julia-docstringextensions") - (version "0.8.4") + (version "0.8.5") (source (origin (method git-fetch) @@ -600,7 +922,7 @@ dictionaries in Julia, for improved productivity and performance.") (commit (string-append "v" version)))) (file-name (git-file-name name version)) (sha256 - (base32 "1fazv87f0j6hw03frx0gqgq9qpjbddqgccm9998a3329wrrs6gwd")))) + (base32 "0fy4kfnfacyfmlly6nqxn77dk2gqw80b69zb4m1i0i39zv3cpqfb")))) (build-system julia-build-system) (home-page "https://juliadocs.github.io/DocStringExtensions.jl/latest/") (synopsis "Extensions for Julia's docsystem") @@ -678,6 +1000,63 @@ a given rule exists, and symbolically apply rules to simple Julia expressions.") stressing the robustness of differentiation tools.") (license license:expat))) +(define-public julia-dualnumbers + (package + (name "julia-dualnumbers") + (version "0.6.5") + (source + (origin + (method git-fetch) + (uri (git-reference + (url "https://github.com/JuliaDiff/DualNumbers.jl") + (commit (string-append "v" version)))) + (file-name (git-file-name name version)) + (sha256 + (base32 "05vr5wbzqpchnb96b3pmn67x196mbfnkv7r9bdlz3gm56if4awk5")))) + (build-system julia-build-system) + (arguments + `(#:phases + (modify-phases %standard-phases + (add-after 'unpack 'adjust-test-suite + (lambda _ + (substitute* "test/runtests.jl" + ;; Seems to not play nicely with SpecialFunctions + ((".*isempty.*") ""))))))) + (propagated-inputs + `(("julia-calculus" ,julia-calculus) + ("julia-nanmath" ,julia-nanmath) + ("julia-specialfunctions" ,julia-specialfunctions))) + (home-page "https://github.com/JuliaDiff/DualNumbers.jl") + (synopsis "Represent dual numbers and for perform dual algebra") + (description "The @code{DualNumbers} Julia package defines the @code{Dual} +type to represent dual numbers, and supports standard mathematical operations on +them. Conversions and promotions are defined to allow performing operations on +combinations of dual numbers with predefined Julia numeric types.") + (license license:expat))) + +(define-public julia-ellipsisnotation + (package + (name "julia-ellipsisnotation") + (version "1.1.0") + (source + (origin + (method git-fetch) + (uri (git-reference + (url "https://github.com/ChrisRackauckas/EllipsisNotation.jl") + (commit (string-append "v" version)))) + (file-name (git-file-name name version)) + (sha256 + (base32 "0py46kxl702r8pw3v7x4cqllf7yc91b0dr7vb60xh2qi7d6y3jc7")))) + (build-system julia-build-system) + (propagated-inputs + `(("julia-arrayinterface" ,julia-arrayinterface))) + (home-page "https://github.com/ChrisRackauckas/EllipsisNotation.jl") + (synopsis "Elipsis notation implementation") + (description "This implements the notation @code{..} for indexing arrays. +It's similar to the Python @code{...} in that it means \"all of the columns +before (or after)\".") + (license license:expat))) + (define-public julia-example (let ((commit "f968c69dea24f851d0c7e686db23fa55826b5388")) (package @@ -722,7 +1101,7 @@ performant tooling without requiring additional package dependencies.") (define-public julia-ffmpeg (package (name "julia-ffmpeg") - (version "0.4.0") + (version "0.4.1") (source (origin (method git-fetch) @@ -731,7 +1110,7 @@ performant tooling without requiring additional package dependencies.") (commit (string-append "v" version)))) (file-name (git-file-name name version)) (sha256 - (base32 "1kwqixwhnnxs59xsw2k44xxnkx5fn4y49g58l5snfbszycxq7lls")))) + (base32 "1ldxbp0kq3ip67x7sp82dz56aq4p5i0chspbgx2zgskr6jcbjj1b")))) (build-system julia-build-system) (propagated-inputs `(("julia-ffmpeg-jll" ,julia-ffmpeg-jll) @@ -743,6 +1122,78 @@ need the ffmpeg binaries + executables, and don't want the overhead of @code{VideoIO.jl}.") (license license:expat))) +(define-public julia-fileio + (package + (name "julia-fileio") + (version "1.9.1") + (source + (origin + (method git-fetch) + (uri (git-reference + (url "https://github.com/JuliaIO/FileIO.jl") + (commit (string-append "v" version)))) + (file-name (git-file-name name version)) + (sha256 + (base32 "1b18x43i737g5q41n9818xbnc2pgd98q1m6yw3h29yri0clg4gfx")))) + (build-system julia-build-system) + (arguments + `(#:phases + (modify-phases %standard-phases + (delete 'reset-gzip-timestamps) + (add-after 'unpack 'skip-network-tests + (lambda _ + ;; These tests try to download audio/video files. + (substitute* "test/query.jl" + (("testset.*(MP4|OGG|MATROSKA).*" all) + (string-append all "return\n"))) + (substitute* "test/loadsave.jl" + (("testset.*CSVFiles.*" all) + (string-append all "return\n"))) + ;; This test tries to download a Julia package. + (substitute* "test/error_handling.jl" + (("testset.*Not installed.*" all) + (string-append all "return\n"))) + ;; This test tries to write to the store. + ;; (Error says can't find User 0) + (substitute* "test/runtests.jl" + ((".*test_mimesave.*") ""))))))) + (propagated-inputs + `(("julia-requires" ,julia-requires))) + (native-inputs + `(("julia-colortypes" ,julia-colortypes) + ("julia-filepathsbase" ,julia-filepathsbase) + ("julia-http" ,julia-http))) + (home-page "https://github.com/JuliaIO/FileIO.jl") + (synopsis "Main Package for IO, loading all different kind of files") + (description "@code{FileIO} aims to provide a common framework for detecting +file formats and dispatching to appropriate readers/writers. The two core +functions in this package are called @code{load} and @code{save}, and offer +high-level support for formatted files (in contrast with Julia's low-level +@code{read} and @code{write}).") + (license license:expat))) + +(define-public julia-filepathsbase + (package + (name "julia-filepathsbase") + (version "0.9.10") + (source + (origin + (method git-fetch) + (uri (git-reference + (url "https://github.com/rofinn/FilePathsBase.jl") + (commit (string-append "v" version)))) + (file-name (git-file-name name version)) + (sha256 + (base32 "136wm4ik6isrdanmpi4gdr1qw0qhr15i925qzjxbawk5hnyzwng9")))) + (build-system julia-build-system) + (arguments + `(#:tests? #f)) ; Cycle with JLSO.jl + (home-page "https://github.com/rofinn/FilePathsBase.jl") + (synopsis "Filesystem path types in Julia") + (description "@code{FilePathsBase.jl} provides a type based approach to +working with filesystem paths in Julia.") + (license license:expat))) + (define-public julia-fillarrays (package (name "julia-fillarrays") @@ -767,6 +1218,45 @@ following types: @code{Eye}, @code{Fill}, @code{Ones}, @code{Zeros}, @code{Trues} and @code{Falses}.") (license license:expat))) +(define-public julia-finitediff + (package + (name "julia-finitediff") + (version "2.8.0") + (source + (origin + (method git-fetch) + (uri (git-reference + (url "https://github.com/JuliaDiff/FiniteDiff.jl") + (commit (string-append "v" version)))) + (file-name (git-file-name name version)) + (sha256 + (base32 "0ndazn02wn8ddwgjh1i32y7pbaqpw06f42ccilz5ya78cyrjhq2m")))) + (build-system julia-build-system) + (arguments + `(#:phases + (modify-phases %standard-phases + (add-before 'check 'pre-check + (lambda _ + ;; We don't want to run all the tests; the Downstream tests + ;; try to download the package registry. + (setenv "GROUP" "Core") + #t))))) + (propagated-inputs + `(("julia-arrayinterface" ,julia-arrayinterface) + ("julia-requires" ,julia-requires) + ("julia-staticarrays" ,julia-staticarrays))) + (native-inputs + `(("julia-bandedmatrices" ,julia-bandedmatrices) + ("julia-blockbandedmatrices" ,julia-blockbandedmatrices) + ("julia-safetestsets" ,julia-safetestsets))) + (home-page "https://github.com/JuliaDiff/FiniteDiff.jl") + (synopsis "Calculations of gradients, Jacobians, and Hessians") + (description "This package is for calculating derivatives, gradients, +Jacobians, Hessians, etc. numerically. This library is for maximizing speed +while giving a usable interface to end users in a way that specializes on array +types and sparsity.") + (license license:expat))) + (define-public julia-finitedifferences (package (name "julia-finitedifferences") @@ -880,6 +1370,34 @@ functions (or any callable object, really) using forward mode automatic differentiation (AD).") (license license:expat))) +(define-public julia-functionwrappers + (package + (name "julia-functionwrappers") + (version "1.1.2") + (source + (origin + (method git-fetch) + (uri (git-reference + (url "https://github.com/yuyichao/FunctionWrappers.jl") + (commit (string-append "v" version)))) + (file-name (git-file-name name version)) + (sha256 + (base32 "02jilpjr7px6138dx2w7ixricvfgsxqdk84d9dgviranibhnjcxa")))) + (build-system julia-build-system) + (arguments + `(#:phases + (modify-phases %standard-phases + (add-after 'unpack 'adjust-tests + (lambda _ + (substitute* "test/runtests.jl" + (("testset \\\"Abstract.*" all) + (string-append all "return\n")))))))) + (home-page "https://github.com/yuyichao/FunctionWrappers.jl") + (synopsis "Type stable and efficient wrapper of arbitrary functions") + (description "This package provides a type stable and efficient wrapper of +arbitrary functions.") + (license license:expat))) + (define-public julia-fuzzycompletions (package (name "julia-fuzzycompletions") @@ -900,6 +1418,74 @@ differentiation (AD).") "FuzzyCompletions provides fuzzy completions for a Julia runtime session.") (license license:expat))) +(define-public julia-genericlinearalgebra + (package + (name "julia-genericlinearalgebra") + (version "0.2.5") + (source + (origin + (method git-fetch) + (uri (git-reference + (url "https://github.com/JuliaLinearAlgebra/GenericLinearAlgebra.jl") + (commit (string-append "v" version)))) + (file-name (git-file-name name version)) + (sha256 + (base32 "0ndwypa397z3pwzdgc3s9plaqlqf63g3d4px5pvym5psgr6lnm3l")))) + (build-system julia-build-system) + (arguments + `(#:phases + (modify-phases %standard-phases + (add-after 'unpack 'adjust-test-suite + (lambda _ + (substitute* "test/runtests.jl" + ((".*lapack.*") ""))))))) + (native-inputs + `(("julia-quaternions" ,julia-quaternions))) + (home-page "https://github.com/JuliaLinearAlgebra/GenericLinearAlgebra.jl") + (synopsis "Generic numerical linear algebra") + (description "The purpose of this package is partly to extend linear algebra +functionality in base to cover generic element types, e.g. @code{BigFloat} and +@code{Quaternion}, and partly to be a place to experiment with fast linear +algebra routines written in Julia (except for optimized BLAS).") + (license license:expat))) + +(define-public julia-genericschur + (package + (name "julia-genericschur") + (version "0.5.0") + (source + (origin + (method git-fetch) + (uri (git-reference + (url "https://github.com/RalphAS/GenericSchur.jl") + (commit (string-append "v" version)))) + (file-name (git-file-name name version)) + (sha256 + (base32 "0kklc2niylvynhq0v49kdmy58m9jmr5jxjf287k1wr9r81fya3sz")))) + (build-system julia-build-system) + (arguments + `(#:phases + (modify-phases %standard-phases + (add-after 'unpack 'adjust-test-suite + (lambda _ + (substitute* "test/complex.jl" + ;; expected Array{Int32,1}, got a value of type Array{Int64,1} + (("A = _example") "#A = _example") + (("schurtest\\(A,20\\)") "")) + (substitute* "test/runtests.jl" + ;; Test errors relating to liblapack.so + ((".*complex\\.jl.*") "") + ((".*real\\.jl.*") "") + ;; GenericSVD is deprecated upstream + ((".*gordschur\\.jl.*") ""))))))) + (home-page "https://github.com/RalphAS/GenericSchur.jl") + (synopsis "Schur decomposition of matrices with generic element types") + (description "The Schur decomposition is the workhorse for eigensystem +analysis of dense matrices. The diagonal eigen-decomposition of normal +(especially Hermitian) matrices is an important special case, but for non-normal +matrices the Schur form is often more useful.") + (license license:expat))) + (define-public julia-graphics (package (name "julia-graphics") @@ -1004,6 +1590,32 @@ library for parsing HTML.") implementing both a client and a server.") (license license:expat))) +(define-public julia-identityranges + (package + (name "julia-identityranges") + (version "0.3.1") + (source + (origin + (method git-fetch) + (uri (git-reference + (url "https://github.com/JuliaArrays/IdentityRanges.jl") + (commit (string-append "v" version)))) + (file-name (git-file-name name version)) + (sha256 + (base32 "0jvl4xn8f8k70sn473li5q62wbiycl5qi25b5k456h3a0j1lbiml")))) + (build-system julia-build-system) + (propagated-inputs + `(("julia-offsetarrays" ,julia-offsetarrays))) + (home-page "https://github.com/JuliaArrays/IdentityRanges.jl") + (synopsis "Ranges that preserve indices of views") + (description "@code{IdentityRanges} are Julia-language a helper type for +creating \"views\" of arrays. They are a custom type of AbstractUnitRange that +makes it easy to preserve the indices of array views. The key property of an +@code{IdentityRange r} is that @code{r[i] == i} (hence the name of the +type/package), and that they support arbitrary start/stop indices (i.e., not +just starting at 1).") + (license license:expat))) + (define-public julia-ifelse (package (name "julia-ifelse") @@ -1024,6 +1636,292 @@ implementing both a client and a server.") conditional ifelse. It is similar to @code{Core.ifelse} but it is extendable.") (license license:expat))) +(define-public julia-imageaxes + (package + (name "julia-imageaxes") + (version "0.6.9") + (source + (origin + (method git-fetch) + (uri (git-reference + (url "https://github.com/JuliaImages/ImageAxes.jl") + (commit (string-append "v" version)))) + (file-name (git-file-name name version)) + (sha256 + (base32 "15zqxani1jjh8849s7rdps6b6prqdwv8yxx893y536vkpk7i07qd")))) + (build-system julia-build-system) + (propagated-inputs + `(("julia-axisarrays" ,julia-axisarrays) + ("julia-imagecore" ,julia-imagecore) + ("julia-reexport" ,julia-reexport) + ("julia-simpletraits" ,julia-simpletraits))) + (native-inputs + `(("julia-unitful" ,julia-unitful))) + (home-page "https://github.com/JuliaImages/ImageAxes.jl") + (synopsis "Julia package for giving \"meaning\" to the axes of an image") + (description "This small package supports the representation of images as +@code{AxisArrays} to endow the axes with \"meaning,\" and makes programming with +such arrays easy via traits.") + (license license:expat))) + +(define-public julia-imagebase + (package + (name "julia-imagebase") + (version "0.1.1") + (source + (origin + (method git-fetch) + (uri (git-reference + (url "https://github.com/JuliaImages/ImageBase.jl") + (commit (string-append "v" version)))) + (file-name (git-file-name name version)) + (sha256 + (base32 "1n63f2zs6ail9pcl7rzgv3l0z8v1idjsaza3zgvgy7iacxsdpcj2")))) + (build-system julia-build-system) + (arguments + `(#:tests? #f)) ; Cycle with ImageMagick.jl. + (propagated-inputs + `(("julia-imagecore" ,julia-imagecore) + ("julia-reexport" ,julia-reexport))) + ;(native-inputs + ; `(("julia-imagemagick" ,julia-imagemagick) + ; ("julia-offsetarrays" ,julia-offsetarrays) + ; ("julia-testimages" ,julia-testimages))) + (home-page "https://github.com/JuliaImages/ImageBase.jl") + (synopsis "Wrapper package around ImageCore") + (description "This is a twin package to @code{ImageCore} with functions that +are used among many of the packages in JuliaImages. The main purpose of this +package is to reduce unnecessary compilation overhead from external +dependencies.") + (license license:expat))) + +(define-public julia-imagecore + (package + (name "julia-imagecore") + (version "0.9.0") + (source + (origin + (method git-fetch) + (uri (git-reference + (url "https://github.com/JuliaImages/ImageCore.jl") + (commit (string-append "v" version)))) + (file-name (git-file-name name version)) + (sha256 + (base32 "0d844lrilw7zjpax8zr5272a9s292wg4qk53mvm0n88yai598zd6")))) + (build-system julia-build-system) + (arguments + `(#:tests? #f)) ; Cycle with ImageMagick.jl. + (propagated-inputs + `(("julia-abstractffts" ,julia-abstractffts) + ("julia-colors" ,julia-colors) + ("julia-colorvectorspace" ,julia-colorvectorspace) + ("julia-fixedpointnumbers" ,julia-fixedpointnumbers) + ("julia-graphics" ,julia-graphics) + ("julia-mappedarrays" ,julia-mappedarrays) + ("julia-mosaicviews" ,julia-mosaicviews) + ("julia-offsetarrays" ,julia-offsetarrays) + ("julia-paddedviews" ,julia-paddedviews) + ("julia-reexport" ,julia-reexport))) + ;(native-inputs + ; `(("julia-aqua" ,julia-aqua) + ; ("julia-colorvectorspace" ,julia-colorvectorspace) + ; ("julia-documenter" ,julia-documenter) + ; ("julia-fftw" ,julia-fftw) + ; ("julia-imageinterminal" ,julia-imageinterminal) + ; ("julia-imagemagick" ,julia-imagemagick) + ; ("julia-referencetests" ,julia-referencetests) + ; ("julia-statistics" ,julia-statistics))) + (home-page "https://github.com/JuliaImages/ImageCore.jl") + (synopsis "Julia types for representing images") + (description "@code{ImageCore} is the lowest-level component of the system +of packages designed to support image processing and computer vision.") + (license license:expat))) + +(define-public julia-imageinterminal + (package + (name "julia-imageinterminal") + (version "0.4.6") + (source + (origin + (method git-fetch) + (uri (git-reference + (url "https://github.com/JuliaImages/ImageInTerminal.jl") + (commit (string-append "v" version)))) + (file-name (git-file-name name version)) + (sha256 + (base32 "1mqbv27qmnsr6wqvklzb4gawi7hp4wnaspszhaxny1m53q6wbifl")))) + (build-system julia-build-system) + (arguments + `(#:tests? #f)) ; Cycle with ReferenceTests.jl. + (propagated-inputs + `(("julia-crayons" ,julia-crayons) + ("julia-imagecore" ,julia-imagecore) + ("julia-imagetransformations" ,julia-imagetransformations))) + ;(native-inputs + ; `(("julia-coordinatetransformations" ,julia-coordinatetransformations) + ; ("julia-imagemagick" ,julia-imagemagick) + ; ("julia-offsetarrays" ,julia-offsetarrays) + ; ("julia-referencetests" ,julia-referencetests) + ; ("julia-rotations" ,julia-rotations) + ; ("julia-sparsearrays" ,julia-sparsearrays) + ; ("julia-testimages" ,julia-testimages))) + (home-page "https://github.com/JuliaImages/ImageInTerminal.jl") + (synopsis "Julia package for displaying images in the terminal") + (description "@code{ImageInTerminal.jl} is a drop-in package that once +imported changes a how a single @code{Colorant} and whole @code{Colorant} arrays +(i.e. Images) are displayed in the interactive REPL. The displayed images will +be downscaled to fit into the size of your active terminal session.") + (license license:expat))) + +(define-public julia-imagemagick + (package + (name "julia-imagemagick") + (version "1.2.1") + (source + (origin + (method git-fetch) + (uri (git-reference + (url "https://github.com/JuliaIO/ImageMagick.jl") + (commit (string-append "v" version)))) + (file-name (git-file-name name version)) + (sha256 + (base32 "05vzv4jsj3l9pv6yrix28hlw7wnag0mqdfjwv8shn4x71hcfxl1p")))) + (build-system julia-build-system) + (arguments + `(#:phases + (modify-phases %standard-phases + (add-after 'unpack 'skip-failing-test + (lambda _ + ;; These tests try to download from the imagemagick.org + (substitute* "test/runtests.jl" + ((".*readremote\\.jl.*") "")) + ;; Tests with the color gray are hard. + (substitute* "test/constructed_images.jl" + (("test (b == aa)" _ test) (string-append "test_nowarn " test)) + (("test (B == map)" _ test) (string-append "test_nowarn " test))) + #t))))) + (propagated-inputs + `(("julia-fileio" ,julia-fileio) + ("julia-imagecore" ,julia-imagecore) + ("julia-imagemagick-jll" ,julia-imagemagick-jll))) + (native-inputs + `(("julia-colors" ,julia-colors) + ("julia-colorvectorspace" ,julia-colorvectorspace) + ("julia-imagemetadata" ,julia-imagemetadata) + ("julia-imageshow" ,julia-imageshow) + ("julia-imagetransformations" ,julia-imagetransformations) + ("julia-indirectarrays" ,julia-indirectarrays) + ("julia-offsetarrays" ,julia-offsetarrays) + ("julia-zipfile" ,julia-zipfile))) + (home-page "https://github.com/JuliaIO/ImageMagick.jl") + (synopsis "Thin wrapper for ImageMagick") + (description "This package provides a wrapper around ImageMagick version 6. +It was split off from @code{Images.jl} to make image I/O more modular.") + (license license:expat))) + +(define-public julia-imagemetadata + (package + (name "julia-imagemetadata") + (version "0.9.6") + (source + (origin + (method git-fetch) + (uri (git-reference + (url "https://github.com/JuliaImages/ImageMetadata.jl") + (commit (string-append "v" version)))) + (file-name (git-file-name name version)) + (sha256 + (base32 "0iv154ms370xgcr56bwsjl13iwmy671cbxjl9ld5yfj85pclcwi1")))) + (build-system julia-build-system) + (propagated-inputs + `(("julia-axisarrays" ,julia-axisarrays) + ("julia-imageaxes" ,julia-imageaxes) + ("julia-imagecore" ,julia-imagecore) + ("julia-indirectarrays" ,julia-indirectarrays))) + (native-inputs + `(("julia-offsetarrays" ,julia-offsetarrays) + ("julia-simpletraits" ,julia-simpletraits) + ("julia-unitful" ,julia-unitful))) + (home-page "https://github.com/JuliaImages/ImageMetadata.jl") + (synopsis "Julia package for images having metadata") + (description "@code{ImageMetadata} is a simple package providing utilities +for working with images that have metadata attached. For example, you might +want to associate an image with the date on which the picture was taken, or an +MRI scan with patient data, or an astronomical image with sky coordinates and +information about the detector used to acquire the image.") + (license license:expat))) + +(define-public julia-imageshow + (package + (name "julia-imageshow") + (version "0.3.2") + (source + (origin + (method git-fetch) + (uri (git-reference + (url "https://github.com/JuliaImages/ImageShow.jl") + (commit (string-append "v" version)))) + (file-name (git-file-name name version)) + (sha256 + (base32 "00wq3ab8y6nyhxwc5lpz9dnslsmcr1vg3cjdkh7wb7k6a8bw98mh")))) + (build-system julia-build-system) + (arguments + `(#:tests? #f)) ; cycle with ImageMagick.jl. + (propagated-inputs + `(("julia-fileio" ,julia-fileio) + ("julia-imagebase" ,julia-imagebase) + ("julia-imagecore" ,julia-imagecore) + ("julia-offsetarrays" ,julia-offsetarrays) + ("julia-stackviews" ,julia-stackviews))) + ;(native-inputs + ; `(("julia-imagedistances" ,julia-imagedistances) + ; ("julia-imagemagick" ,julia-imagemagick) + ; ("julia-suppressor" ,julia-suppressor) + ; ("julia-testimages" ,julia-testimages))) + (home-page "https://github.com/JuliaImages/ImageShow.jl") + (synopsis + "Inline graphical display of images in Julia graphical environments") + (description "This package implements image @code{show} methods suitable +for graphical platforms such as IJulia. It is intended to provide convenient +inline presentation of greyscale or color images.") + (license license:expat))) + +(define-public julia-imagetransformations + (package + (name "julia-imagetransformations") + (version "0.8.12") + (source + (origin + (method git-fetch) + (uri (git-reference + (url "https://github.com/JuliaImages/ImageTransformations.jl") + (commit (string-append "v" version)))) + (file-name (git-file-name name version)) + (sha256 + (base32 "0i8gw68hljshsy9wdl5mrpbb31irhmayqyglsxi7jwm88iy9pxhm")))) + (build-system julia-build-system) + (arguments + `(#:tests? #f)) ; Cycle with ImageMagick.jl. + (propagated-inputs + `(("julia-axisalgorithms" ,julia-axisalgorithms) + ("julia-colorvectorspace" ,julia-colorvectorspace) + ("julia-coordinatetransformations" ,julia-coordinatetransformations) + ("julia-identityranges" ,julia-identityranges) + ("julia-imagecore" ,julia-imagecore) + ("julia-interpolations" ,julia-interpolations) + ("julia-offsetarrays" ,julia-offsetarrays) + ("julia-rotations" ,julia-rotations) + ("julia-staticarrays" ,julia-staticarrays))) + ;(native-inputs + ; `(("julia-imagemagick" ,julia-imagemagick) + ; ("julia-referencetests" ,julia-referencetests) + ; ("julia-testimages" ,julia-testimages))) + (home-page "https://github.com/JuliaImages/ImageTransformations.jl") + (synopsis "Geometric transformations on images for Julia") + (description "This package provides support for image resizing, image +rotation, and other spatial transformations of arrays.") + (license license:expat))) + (define-public julia-indexing (package (name "julia-indexing") @@ -1092,6 +1990,64 @@ indexed images, sometimes called \"colormap images\" or \"paletted images.\"") interfaces with @file{.ini} files.") (license license:expat))) +(define-public julia-interpolations + (package + (name "julia-interpolations") + (version "0.13.2") + (source + (origin + (method git-fetch) + (uri (git-reference + (url "https://github.com/JuliaMath/Interpolations.jl") + (commit (string-append "v" version)))) + (file-name (git-file-name name version)) + (sha256 + (base32 "06wh4fc7hy20kq9iipk3w8v50vd09k7vkii43k8z1vw036f6l7x3")))) + (build-system julia-build-system) + (propagated-inputs + `(("julia-axisalgorithms" ,julia-axisalgorithms) + ("julia-offsetarrays" ,julia-offsetarrays) + ("julia-ratios" ,julia-ratios) + ("julia-staticarrays" ,julia-staticarrays) + ("julia-woodburymatrices" ,julia-woodburymatrices))) + (native-inputs + `(("julia-dualnumbers" ,julia-dualnumbers) + ("julia-forwarddiff" ,julia-forwarddiff) + ("julia-offsetarrays" ,julia-offsetarrays) + ("julia-unitful" ,julia-unitful))) + (home-page "https://github.com/JuliaMath/Interpolations.jl") + (synopsis "Continuous interpolation of discrete datasets") + (description "This package implements a variety of interpolation schemes for +the Julia language. It has the goals of ease-of-use, broad algorithmic support, +and exceptional performance.") + (license license:expat))) + +(define-public julia-intervalsets + (package + (name "julia-intervalsets") + (version "0.5.3") + (source + (origin + (method git-fetch) + (uri (git-reference + (url "https://github.com/JuliaMath/IntervalSets.jl") + (commit (string-append "v" version)))) + (file-name (git-file-name name version)) + (sha256 + (base32 "0gsz89cd3iygbl5qr389k9vwpg7w1nk0s90g25nsmk34y9hifxag")))) + (build-system julia-build-system) + (propagated-inputs + `(("julia-ellipsisnotation" ,julia-ellipsisnotation))) + (native-inputs + `(("julia-offsetarrays" ,julia-offsetarrays))) + (home-page "https://github.com/JuliaMath/IntervalSets.jl") + (synopsis "Interval Sets for Julia") + (description "This package is intended to implement a \"minimal\" foundation +for intervals upon which other packages might build. In particular, we +encourage type-piracy for the reason that only one interval package can +unambiguously define the @code{..} and @code{±} operators.") + (license license:expat))) + (define-public julia-invertedindices (package (name "julia-invertedindices") @@ -1118,7 +2074,7 @@ as an index into any @code{AbstractArray} subtype, including OffsetArrays.") (define-public julia-iocapture (package (name "julia-iocapture") - (version "0.2.1") + (version "0.2.2") (source (origin (method git-fetch) @@ -1127,7 +2083,7 @@ as an index into any @code{AbstractArray} subtype, including OffsetArrays.") (commit (string-append "v" version)))) (file-name (git-file-name name version)) (sha256 - (base32 "0ajlfh8f1g23bx5f8h70nrgr0zfwxaqnpxlka8l4qhjmnfqxl43a")))) + (base32 "0v76wbvg80g9nx0rjbcna82zk61krly1y9yhyfrjv2pf7mcr4idb")))) (build-system julia-build-system) (home-page "https://github.com/JuliaDocs/IOCapture.jl") (synopsis "Capture standard output and error streams") @@ -1182,6 +2138,26 @@ Cassette.") extensions to the iterator interface.") (license license:expat))) +(define-public julia-itertools + (package + (name "julia-itertools") + (version "1.3.0") + (source + (origin + (method git-fetch) + (uri (git-reference + (url "https://github.com/JuliaCollections/IterTools.jl") + (commit (string-append "v" version)))) + (file-name (git-file-name name version)) + (sha256 + (base32 "0haf974kcqj6arv4if97ahs4w3dmvslh6ab3hl57r9s41ic36xdq")))) + (build-system julia-build-system) + (home-page "https://github.com/JuliaCollections/IterTools.jl") + (synopsis "Common functional iterator patterns") + (description + "Common functional iterator patterns (formerly @code{Iterators.jl}).") + (license license:expat))) + (define-public julia-json (package (name "julia-json") @@ -1207,6 +2183,84 @@ extensions to the iterator interface.") and printing JSON documents.") (license license:expat))) +(define-public julia-json3 + (package + (name "julia-json3") + (version "1.8.2") + (source + (origin + (method git-fetch) + (uri (git-reference + (url "https://github.com/quinnj/JSON3.jl") + (commit (string-append "v" version)))) + (file-name (git-file-name name version)) + (sha256 + (base32 "1mc3byqm6ygg4mjpdrx6grkr4gn06p25nr7050jgq1k2cf06iqba")))) + (build-system julia-build-system) + (propagated-inputs + `(("julia-parsers" ,julia-parsers) + ("julia-structtypes" ,julia-structtypes))) + (home-page "https://github.com/quinnj/JSON3.jl") + (synopsis "JSON package for Julia") + (description "This package provides another JSON package for Julia, with a +focus on speed and slick struct mapping.") + (license license:expat))) + +(define-public julia-lazyarrays + (package + (name "julia-lazyarrays") + (version "0.21.6") + (source + (origin + (method git-fetch) + (uri (git-reference + (url "https://github.com/JuliaArrays/LazyArrays.jl") + (commit (string-append "v" version)))) + (file-name (git-file-name name version)) + (sha256 + (base32 "0zm1ihvi8v2823ap59ajqcs46s5z0nai8l70n51f6j9dzp8lc3cy")))) + (build-system julia-build-system) + (propagated-inputs + `(("julia-arraylayouts" ,julia-arraylayouts) + ("julia-fillarrays" ,julia-fillarrays) + ("julia-macrotools" ,julia-macrotools) + ("julia-matrixfactorizations" ,julia-matrixfactorizations) + ("julia-staticarrays" ,julia-staticarrays))) + (native-inputs + `(("julia-tracker" ,julia-tracker))) + (home-page "https://github.com/JuliaArrays/LazyArrays.jl") + (synopsis "Lazy arrays and linear algebra") + (description "This package supports lazy analogues of array operations like +@code{vcat}, @code{hcat}, and multiplication. This helps with the +implementation of matrix-free methods for iterative solvers.") + (license license:expat))) + +(define-public julia-logexpfunctions + (package + (name "julia-logexpfunctions") + (version "0.2.4") + (source + (origin + (method git-fetch) + (uri (git-reference + (url "https://github.com/JuliaStats/LogExpFunctions.jl") + (commit (string-append "v" version)))) + (file-name (git-file-name name version)) + (sha256 + (base32 "0rvms3mmq8a1viqlyzdgs2ccddcy6j0c677dlb8m5nk6hkiwr16n")))) + (build-system julia-build-system) + (propagated-inputs + `(("julia-docstringextensions" ,julia-docstringextensions))) + (native-inputs + `(("julia-offsetarrays" ,julia-offsetarrays))) + (home-page "https://github.com/JuliaStats/LogExpFunctions.jl") + (synopsis "Special functions based on @code{log} and @code{exp}") + (description "Various special functions based on log and exp moved from +@code{StatsFuns.jl} into a separate package, to minimize dependencies. These +functions only use native Julia code, so there is no need to depend on +@code{librmath} or similar libraries.") + (license license:expat))) + (define-public julia-macrotools (package (name "julia-macrotools") @@ -1389,6 +2443,38 @@ with @code{missing} values in Julia.") to be temporarily overloaded for the purpose of testing.") (license license:expat))) +(define-public julia-mosaicviews + (package + (name "julia-mosaicviews") + (version "0.3.3") + (source + (origin + (method git-fetch) + (uri (git-reference + (url "https://github.com/JuliaArrays/MosaicViews.jl") + (commit (string-append "v" version)))) + (file-name (git-file-name name version)) + (sha256 + (base32 "04fgxghyb7n2ji76xkb1r1fjhzsdbgmp5wsfyyn3yjcsdqbyp8pz")))) + (build-system julia-build-system) + (arguments + `(#:tests? #f)) ; Cycle with ImageCore.jl + (propagated-inputs + `(("julia-mappedarrays" ,julia-mappedarrays) + ("julia-paddedviews" ,julia-paddedviews) + ("julia-stackviews" ,julia-stackviews))) + ;(native-inputs + ; `(("julia-colorvectorspace" ,julia-colorvectorspace) + ; ("julia-imagecore" ,julia-imagecore))) + (home-page "https://github.com/JuliaArrays/MosaicViews.jl") + (synopsis + "Lazily view a 3D or 4D array as an expanded 2D array as a matrix of slices") + (description "When visualizing images, it is not uncommon to provide a 2D +view of different image sources. For example, comparing multiple images of +different sizes, getting a preview of machine learning dataset. This package +aims to provide easy-to-use tools for such tasks.") + (license license:expat))) + (define-public julia-msgpack (package (name "julia-msgpack") @@ -1409,6 +2495,32 @@ to be temporarily overloaded for the purpose of testing.") Julia, with type-driven, overloadable packing/unpacking functionality.") (license license:expat))) +(define-public julia-mutablearithmetics + (package + (name "julia-mutablearithmetics") + (version "0.2.19") + (source + (origin + (method git-fetch) + (uri (git-reference + (url "https://github.com/jump-dev/MutableArithmetics.jl") + (commit (string-append "v" version)))) + (file-name (git-file-name name version)) + (sha256 + (base32 "1zjfq5sh0rc941pbc9kvnr6a2lpr4yd276mw62vbncbz9jg52rrg")))) + (build-system julia-build-system) + (propagated-inputs + `(("julia-offsetarrays" ,julia-offsetarrays))) + (home-page "https://github.com/jump-dev/MutableArithmetics.jl") + (synopsis "Interface for arithmetics on mutable types in Julia") + (description "MutableArithmetics is a Julia package which allows: +@itemize +@item mutable types to implement mutable arithmetics +@item algorithms that could exploit mutable arithmetics to exploit them while +still being completely generic +@end itemize") + (license license:mpl2.0))) + (define-public julia-nanmath (package (name "julia-nanmath") @@ -1429,6 +2541,72 @@ Julia, with type-driven, overloadable packing/unpacking functionality.") @code{NaN} instead of throwing a @code{DomainError}.") (license license:expat))) +(define-public julia-nlsolversbase + (package + (name "julia-nlsolversbase") + (version "7.8.0") + (source + (origin + (method git-fetch) + (uri (git-reference + (url "https://github.com/JuliaNLSolvers/NLSolversBase.jl") + (commit (string-append "v" version)))) + (file-name (git-file-name name version)) + (sha256 + (base32 "0n8qh5a2ghjx1j70zxn0hmh8gzpa46kmjg8di879y9974bfk0f98")))) + (build-system julia-build-system) + (propagated-inputs + `(("julia-diffresults" ,julia-diffresults) + ("julia-finitediff" ,julia-finitediff) + ("julia-forwarddiff" ,julia-forwarddiff))) + (native-inputs + `(("julia-optimtestproblems" ,julia-optimtestproblems) + ("julia-recursivearraytools" ,julia-recursivearraytools))) + (home-page "https://github.com/JuliaNLSolvers/NLSolversBase.jl") + (synopsis "Optimization and equation solver software in JuliaNLSolvers") + (description "This package aims at establishing common ground for Optim.jl, +LineSearches.jl, and NLsolve.jl. The common ground is mainly the types used to +hold objective related callables, information about the objectives, and an +interface to interact with these types.") + (license license:expat))) + +(define-public julia-nnlib + (package + (name "julia-nnlib") + (version "0.7.19") + (source + (origin + (method git-fetch) + (uri (git-reference + (url "https://github.com/FluxML/NNlib.jl") + (commit (string-append "v" version)))) + (file-name (git-file-name name version)) + (sha256 + (base32 "163v7hkmbxxgnq7qigmqjdqcdywi2njxbh54w8v0hf4bddnalbba")))) + (build-system julia-build-system) + (arguments + `(#:phases + (modify-phases %standard-phases + (add-after 'unpack 'drop-cuda-support + (lambda _ + (substitute* "test/runtests.jl" + (("using CUDA") "")) + (setenv "NNLIB_TEST_CUDA" "false")))))) + (propagated-inputs + `(("julia-adapt" ,julia-adapt) + ("julia-chainrulescore" ,julia-chainrulescore) + ("julia-requires" ,julia-requires))) + (native-inputs + `(("julia-chainrulestestutils" ,julia-chainrulestestutils) + ("julia-stablerngs" ,julia-stablerngs) + ("julia-zygote" ,julia-zygote))) + (home-page "https://github.com/FluxML/NNlib.jl") + (synopsis "Neural Network primitives with multiple backends") + (description "This package will provide a library of functions useful for +machine learning, such as softmax, sigmoid, convolutions and pooling. It +doesn't provide any other \"high-level\" functionality like layers or AD.") + (license license:expat))) + (define-public julia-optimtestproblems (package (name "julia-optimtestproblems") @@ -1476,7 +2654,7 @@ which they were added to the collection.") (define-public julia-offsetarrays (package (name "julia-offsetarrays") - (version "1.8.0") + (version "1.9.2") (source (origin (method git-fetch) @@ -1485,7 +2663,7 @@ which they were added to the collection.") (commit (string-append "v" version)))) (file-name (git-file-name name version)) (sha256 - (base32 "0s02175pb2pkwg87g7vva2hsrh2ksj9ariw9ccd7axbdm2vd2zcs")))) + (base32 "10mycjmjlp80c1bsdmk1hnb5hg81zqd2dcxyaa9p55ykla051a9q")))) (build-system julia-build-system) (propagated-inputs `(("julia-adapt" ,julia-adapt))) @@ -1498,6 +2676,33 @@ have arbitrary indices, similar to those found in some other programming languages like Fortran.") (license license:expat))) +(define-public julia-paddedviews + (package + (name "julia-paddedviews") + (version "0.5.8") + (source + (origin + (method git-fetch) + (uri (git-reference + (url "https://github.com/JuliaArrays/PaddedViews.jl") + (commit (string-append "v" version)))) + (file-name (git-file-name name version)) + (sha256 + (base32 "0ran2vj6ahlzib0g77y7g0jhavy3k9s2mqq23ybpgp9z677wf26h")))) + (build-system julia-build-system) + (arguments + '(#:tests? #f)) ;require Documenter, not packaged yet + (propagated-inputs + `(("julia-offsetarrays" ,julia-offsetarrays))) + (home-page "https://github.com/JuliaArrays/PaddedViews.jl") + (synopsis "Add virtual padding to the edges of an array") + (description "@code{PaddedViews} provides a simple wrapper type, +@code{PaddedView}, to add \"virtual\" padding to any array without copying data. +Edge values not specified by the array are assigned a @code{fillvalue}. +Multiple arrays may be \"promoted\" to have common indices using the +@code{paddedviews} function.") + (license license:expat))) + (define-public julia-parameters (package (name "julia-parameters") @@ -1546,7 +2751,7 @@ utilities for Julia.") (define-public julia-pdmats (package (name "julia-pdmats") - (version "0.11.0") + (version "0.11.1") (source (origin (method git-fetch) @@ -1555,7 +2760,7 @@ utilities for Julia.") (commit (string-append "v" version)))) (file-name (git-file-name name version)) (sha256 - (base32 "1gyhfjmb0qlqgx2398b356cph25bnpjagcslckv41bzyf8pg3ybl")))) + (base32 "0bc2gmpd30rkclvxyfnssjllp0pk63h0vvgr8862phm5ia83r8j0")))) (build-system julia-build-system) (home-page "https://github.com/JuliaStats/PDMats.jl") (synopsis @@ -1639,6 +2844,33 @@ plotting components.") purposes of compression when there are few unique elements.") (license license:expat))) +(define-public julia-positivefactorizations + (package + (name "julia-positivefactorizations") + (version "0.2.4") + (source + (origin + (method git-fetch) + (uri (git-reference + (url "https://github.com/timholy/PositiveFactorizations.jl") + (commit (string-append "v" version)))) + (file-name (git-file-name name version)) + (sha256 + (base32 "1wxy6ak7f3hvibcgc8q88cgkf9zvi649mmjy1zlkx1qk80hgvz23")))) + (build-system julia-build-system) + (native-inputs + `(("julia-forwarddiff" ,julia-forwarddiff) + ("julia-reversediff" ,julia-reversediff))) + (home-page "https://github.com/timholy/PositiveFactorizations.jl") + (synopsis "Positive-definite \"approximations\" to matrices") + (description "@code{PositiveFactorizations} is a package for computing a +positive definite matrix decomposition (factorization) from an arbitrary +symmetric input. The motivating application is optimization (Newton or +quasi-Newton methods), in which the canonical search direction -H/g (H being the +Hessian and g the gradient) may not be a descent direction if H is not positive +definite.") + (license license:expat))) + (define-public julia-prettytables (package (name "julia-prettytables") @@ -1709,6 +2941,29 @@ human-readable format.") format.") (license license:expat))) +(define-public julia-quaternions + (package + (name "julia-quaternions") + (version "0.4.2") + (source + (origin + (method git-fetch) + (uri (git-reference + (url "https://github.com/JuliaGeometry/Quaternions.jl") + (commit (string-append "v" version)))) + (file-name (git-file-name name version)) + (sha256 + (base32 "1zhynyvchc50hywws2jznpkwydr3njh8cv84d2ylyabhcwwmil9s")))) + (build-system julia-build-system) + (propagated-inputs + `(("julia-dualnumbers" ,julia-dualnumbers))) + (home-page "https://github.com/JuliaGeometry/Quaternions.jl") + (synopsis "Quaternion and dual-quaternion functionality") + (description "Quaternions are best known for their suitability as +representations of 3D rotational orientation. They can also be viewed as an +extension of complex numbers.") + (license license:expat))) + (define-public julia-queryoperators (package (name "julia-queryoperators") @@ -1754,6 +3009,26 @@ array data structures where the columns of the arrays are generated (on the fly) by Ranges.") (license license:expat))) +(define-public julia-ratios + (package + (name "julia-ratios") + (version "0.4.0") + (source + (origin + (method git-fetch) + (uri (git-reference + (url "https://github.com/timholy/Ratios.jl") + (commit (string-append "v" version)))) + (file-name (git-file-name name version)) + (sha256 + (base32 "1a4fd4jq4qjply29rkwg3m1clfndjsbckj1b1dab1bc35h2c6yxh")))) + (build-system julia-build-system) + (home-page "https://github.com/timholy/Ratios.jl") + (synopsis "Faster Rational-like types for Julia") + (description "This package provides types similar to Julia's @code{Rational} +type, which make some sacrifices but have better computational performance.") + (license license:expat))) + (define-public julia-recipesbase (package (name "julia-recipesbase") @@ -1778,25 +3053,130 @@ possible to describe visualization routines that can be used as components in more complex visualizations.") (license license:expat))) +(define-public julia-recipespipeline + (package + (name "julia-recipespipeline") + (version "0.3.2") + (source + (origin + (method git-fetch) + (uri (git-reference + (url "https://github.com/JuliaPlots/RecipesPipeline.jl") + (commit (string-append "v" version)))) + (file-name (git-file-name name version)) + (sha256 + (base32 + "0wa342m2d9k4kihr6g9i0wpbsipp0n11kh9jmlw4pc5msmz4rxr0")))) + (build-system julia-build-system) + (arguments + `(#:tests? #f)) ; Cycle with Plots.jl. + (propagated-inputs + `(("julia-nanmath" ,julia-nanmath) + ("julia-plotutils" ,julia-plotutils) + ("julia-recipesbase" ,julia-recipesbase))) + (home-page "http://juliaplots.org/RecipesPipeline.jl/dev/") + (synopsis "Utilities for processing recipes") + (description "This package was factored out of @code{Plots.jl} to allow any +other plotting package to use the recipe pipeline. In short, the extremely +lightweight @code{RecipesBase.jl} package can be depended on by any package to +define \"recipes\": plot specifications of user-defined types, as well as custom +plot types. @code{RecipePipeline.jl} contains the machinery to translate these +recipes to full specifications for a plot.") + (license license:expat))) + +(define-public julia-recursivearraytools + (package + (name "julia-recursivearraytools") + (version "2.11.4") + (source + (origin + (method git-fetch) + (uri (git-reference + (url "https://github.com/SciML/RecursiveArrayTools.jl") + (commit (string-append "v" version)))) + (file-name (git-file-name name version)) + (sha256 + (base32 "14wh39g3l0fzzrkxgxijklilqcgpxsk1d44dfpfl48gsp0n6icjm")))) + (build-system julia-build-system) + (arguments + `(#:tests? #f)) ; Cycle with OrdinaryDiffEq.jl. + (propagated-inputs + `(("julia-arrayinterface" ,julia-arrayinterface) + ("julia-docstringextensions" ,julia-docstringextensions) + ("julia-requires" ,julia-requires) + ("julia-recipesbase" ,julia-recipesbase) + ("julia-staticarrays" ,julia-staticarrays) + ("julia-zygoterules" ,julia-zygoterules))) + ;(native-inputs + ; `(("julia-forwarddiff" ,julia-forwarddiff) + ; ("julia-nlsolve" ,julia-nlsolve) + ; ("julia-ordinarydiffeq" ,julia-ordinarydiffeq) + ; ("julia-structarrays" ,julia-structarrays) + ; ("julia-unitful" ,julia-unitful) + ; ("julia-zygote" ,julia-zygote))) + (home-page "https://github.com/SciML/RecursiveArrayTools.jl") + (synopsis "Tools for handling objects like arrays of arrays and deeper nestings") + (description "@code{RecursiveArrayTools.jl} is a set of tools for dealing with +recursive arrays like arrays of arrays.") + (license license:expat))) + (define-public julia-reexport (package (name "julia-reexport") - (version "1.0.0") + (version "1.1.0") (source (origin (method git-fetch) (uri (git-reference (url "https://github.com/simonster/Reexport.jl") - (commit version))) + (commit (string-append "v" version)))) (file-name (git-file-name name version)) (sha256 - (base32 "1yhhja1zz6dy5f4fd19bdwd6jwgj7q4w3avzgyg1hjhmdl8jrh0s")))) + (base32 "1wj4vnxxmnblm6ajkkdvwb7v4835qrrc406q5is74qv1n68xql7l")))) (build-system julia-build-system) (home-page "https://github.com/simonster/Reexport.jl") (synopsis "Re-export modules and symbols") (description "This package provides tools to re-export modules and symbols.") (license license:expat))) +(define-public julia-referencetests + (package + (name "julia-referencetests") + (version "0.9.7") + (source + (origin + (method git-fetch) + (uri (git-reference + (url "https://github.com/JuliaTesting/ReferenceTests.jl") + (commit (string-append "v" version)))) + (file-name (git-file-name name version)) + (sha256 + (base32 "0mm6bjhs8a21pippww6b08b5frmnb9m6k8xrszrwq9zhc879zpc9")))) + (build-system julia-build-system) + (arguments + `(#:tests? #f)) ; Cycle with ImageCore.jl through ImageMagick.jl. + (propagated-inputs + `(("julia-deepdiffs" ,julia-deepdiffs) + ("julia-distances" ,julia-distances) + ("julia-fileio" ,julia-fileio) + ("julia-imagecore" ,julia-imagecore) + ("julia-imageinterminal" ,julia-imageinterminal))) + ;(native-inputs + ; `(("julia-csvfiles" ,julia-csvfiles) + ; ("julia-dataframes" ,julia-dataframes) + ; ("julia-gr" ,julia-gr) + ; ("julia-imagemagick" ,julia-imagemagick) + ; ("julia-imagetransformations" ,julia-imagetransformations) + ; ("julia-plots" ,julia-plots) + ; ("julia-testimages" ,julia-testimages))) + (home-page "https://juliatesting.github.io/ReferenceTests.jl/latest/") + (synopsis "Utility package for comparing data against reference files") + (description "@code{ReferenceTests.jl} is a Julia package that adds a couple +of additional macros to your testing toolbox. In particular, it focuses on +functionality for testing values against reference files, which in turn the +package can help create and update if need be.") + (license license:expat))) + (define-public julia-requires (package (name "julia-requires") @@ -1823,6 +3203,40 @@ another package is loaded, so that explicit dependencies (and long load times) can be avoided.") (license license:expat))) +(define-public julia-reversediff + (package + (name "julia-reversediff") + (version "1.9.0") + (source + (origin + (method git-fetch) + (uri (git-reference + (url "https://github.com/JuliaDiff/ReverseDiff.jl") + (commit (string-append "v" version)))) + (file-name (git-file-name name version)) + (sha256 + (base32 "1wrr6sqj2xl9grkvdp88rw3manxy9vbx28zq2wssya5ns1xabsnl")))) + (build-system julia-build-system) + (propagated-inputs + `(("julia-diffresults" ,julia-diffresults) + ("julia-diffrules" ,julia-diffrules) + ("julia-forwarddiff" ,julia-forwarddiff) + ("julia-functionwrappers" ,julia-functionwrappers) + ("julia-macrotools" ,julia-macrotools) + ("julia-nanmath" ,julia-nanmath) + ("julia-specialfunctions" ,julia-specialfunctions) + ("julia-staticarrays" ,julia-staticarrays))) + (native-inputs + `(("julia-difftests" ,julia-difftests) + ("julia-fillarrays" ,julia-fillarrays))) + (home-page "https://github.com/JuliaDiff/ReverseDiff.jl") + (synopsis "Reverse Mode Automatic Differentiation for Julia") + (description "@code{ReverseDiff.jl} is a fast and compile-able tape-based +reverse mode @acronym{AD, automatic differentiation}, that implements methods to +take gradients, Jacobians, Hessians, and higher-order derivatives of native +Julia functions (or any callable object, really).") + (license license:expat))) + (define-public julia-richardson (package (name "julia-richardson") @@ -1850,6 +3264,35 @@ high-order accuracy, assuming that @code{f(x0+h)} has a Taylor series or some other power series in @code{h}.") (license license:expat))) +(define-public julia-rotations + (package + (name "julia-rotations") + (version "1.0.2") + (source + (origin + (method git-fetch) + (uri (git-reference + (url "https://github.com/JuliaGeometry/Rotations.jl") + (commit (string-append "v" version)))) + (file-name (git-file-name name version)) + (sha256 + (base32 "1l1a3bnrpv9qdksnk3c8j82ik3yrnpsmnyxyiy3gc1yjya5pajqj")))) + (build-system julia-build-system) + (propagated-inputs + `(("julia-staticarrays" ,julia-staticarrays))) + (native-inputs + `(("julia-benchmarktools" ,julia-benchmarktools) + ("julia-forwarddiff" ,julia-forwarddiff) + ("julia-unitful" ,julia-unitful))) + (home-page "https://github.com/JuliaGeometry/Rotations.jl") + (synopsis "Julia implementations for different rotation parameterisations") + (description "This package implements various 3D rotation parameterizations +and defines conversions between them. At their heart, each rotation +parameterization is a 3×3 unitary (orthogonal) matrix (based on the +@code{StaticArrays.jl} package), and acts to rotate a 3-vector about the origin +through matrix-vector multiplication.") + (license license:expat))) + (define-public julia-safetestsets ;; The only release tag is the first commit in the repository. (let ((commit "e553edc4c753344d38349304b9ff5483c3b8ff21") @@ -1880,7 +3323,7 @@ a loadable module.") (define-public julia-scratch (package (name "julia-scratch") - (version "1.0.3") + (version "1.1.0") (source (origin (method git-fetch) @@ -1890,7 +3333,7 @@ a loadable module.") (file-name (git-file-name name version)) (sha256 (base32 - "06n0rc7grlg9igkdlrql83q0zpc97bh2hfzj5mw4spfik8ahw2aa")))) + "09xni9rrrax17fxjz04j1b48mk9ffww5rcbagh66jklr89mrkqhx")))) (build-system julia-build-system) (arguments `(#:tests? #f)) ; Test suite tries to access the Julia package registry. @@ -1905,6 +3348,52 @@ user-friendly, scratch spaces should, in general, not be used for a storing files that the user must interact with through a file browser.") (license license:expat))) +(define-public julia-showoff + (package + (name "julia-showoff") + (version "1.0.2") + (source + (origin + (method git-fetch) + (uri (git-reference + (url "https://github.com/JuliaGraphics/Showoff.jl") + (commit (string-append "v" version)))) + (file-name (git-file-name name version)) + (sha256 + (base32 "1g4hqvjjpwbrs7fnllyl5w66yj6qlvpvzpygym2nvf01m1ps6m53")))) + (build-system julia-build-system) + (home-page "https://github.com/JuliaGraphics/Showoff.jl") + (synopsis "Nicely format an array of n things for tables and plots") + (description "@code{Showoff} provides an interface for consistently +formatting an array of n things, e.g. numbers, dates, unitful values. It's used +in @code{Gadfly}, @code{Plots} and @code{Makie} to label axes and keys.") + (license license:expat))) + +(define-public julia-simpletraits + (package + (name "julia-simpletraits") + (version "0.9.3") + (source + (origin + (method git-fetch) + (uri (git-reference + (url "https://github.com/mauro3/SimpleTraits.jl") + (commit (string-append "v" version)))) + (file-name (git-file-name name version)) + (sha256 + (base32 "1aaq91klwxb0r3ckwihf7rd7jvg70757nkhp5ip4cc3lspnnip23")))) + (build-system julia-build-system) + (propagated-inputs + `(("julia-macrotools" ,julia-macrotools))) + (home-page "https://github.com/mauro3/SimpleTraits.jl") + (synopsis "Simple Traits for Julia") + (description "This package provides a macro-based implementation of traits. +The main idea behind traits is to group types outside the type-hierarchy and to +make dispatch work with that grouping. The difference to Union-types is that +types can be added to a trait after the creation of the trait, whereas Union +types are fixed after creation.") + (license license:expat))) + (define-public julia-sortingalgorithms (package (name "julia-sortingalgorithms") @@ -2010,10 +3499,50 @@ default are documented to have non-stable streams (which for example enables some performance improvements).") (license license:expat))) +(define-public julia-stackviews + (package + (name "julia-stackviews") + (version "0.1.1") + (source + (origin + (method git-fetch) + (uri (git-reference + (url "https://github.com/JuliaArrays/StackViews.jl") + (commit (string-append "v" version)))) + (file-name (git-file-name name version)) + (sha256 + (base32 "1fwiaxdpx1z9dli3jr8kyraych0jbdiny3qklynf0r13px25r6i7")))) + (build-system julia-build-system) + (arguments + `(#:tests? #f ; Documenter.jl not packaged yet + #:phases + (modify-phases %standard-phases + (add-after 'unpack 'skip-doctest + (lambda _ + (substitute* "test/runtests.jl" + ((".*doctest.*") "")) + #t))))) + (propagated-inputs + `(("julia-offsetarrays" ,julia-offsetarrays))) + ;(native-inputs + ; `(("julia-aqua" ,julia-aqua) + ; ("julia-documenter" ,julia-documenter))) + (home-page "https://github.com/JuliaArrays/StackViews.jl") + (synopsis "No more catcat") + (description "StackViews provides only one array type: @code{StackView}. +There are multiple ways to understand @code{StackView}: +@itemize +@item inverse of @code{eachslice} +@item @code{cat} variant +@item view object +@item lazy version of @code{repeat} special case +@end itemize") + (license license:expat))) + (define-public julia-static (package (name "julia-static") - (version "0.2.4") + (version "0.2.5") (source (origin (method git-fetch) @@ -2022,7 +3551,7 @@ some performance improvements).") (commit (string-append "v" version)))) (file-name (git-file-name name version)) (sha256 - (base32 "01rbiysrkaca03gh55rc5zykkp63bhzaqgrxxj88lnisrbzmf0d2")))) + (base32 "1sxfp169c7caaklpp7mz8770ayk9w8xw133m95kf7v11sya1lb7v")))) (build-system julia-build-system) (propagated-inputs `(("julia-ifelse" ,julia-ifelse))) @@ -2082,6 +3611,82 @@ moving the function definition to @code{StatsAPI.jl} and each package taking a dependency on it.") (license license:expat))) +(define-public julia-statsbase + (package + (name "julia-statsbase") + (version "0.33.8") + (source + (origin + (method git-fetch) + (uri (git-reference + (url "https://github.com/JuliaStats/StatsBase.jl") + (commit (string-append "v" version)))) + (file-name (git-file-name name version)) + (sha256 + (base32 "02y4pm5yvg713a2pn970bbcfkrn2h133rxbxk1da18svhqw3czhi")))) + (build-system julia-build-system) + (propagated-inputs + `(("julia-dataapi" ,julia-dataapi) + ("julia-datastructures" ,julia-datastructures) + ("julia-missings" ,julia-missings) + ("julia-sortingalgorithms" ,julia-sortingalgorithms) + ("julia-statsapi" ,julia-statsapi))) + (native-inputs + `(("julia-stablerngs" ,julia-stablerngs))) + (home-page "https://github.com/JuliaStats/StatsBase.jl") + (synopsis "Basic statistics for Julia") + (description "StatsBase.jl is a Julia package that provides basic support +for statistics. Particularly, it implements a variety of statistics-related +functions, such as scalar statistics, high-order moment computation, counting, +ranking, covariances, sampling, and empirical density estimation.") + (license license:expat))) + +(define-public julia-stringdistances + (package + (name "julia-stringdistances") + (version "0.10.0") + (source + (origin + (method git-fetch) + (uri (git-reference + (url "https://github.com/matthieugomez/StringDistances.jl") + (commit (string-append "v" version)))) + (file-name (git-file-name name version)) + (sha256 + (base32 "0n5707wplbibzhhv1xmshvc025d7xk6mnikclc3hvq5cdc0gy9f7")))) + (build-system julia-build-system) + (propagated-inputs + `(("julia-distances" ,julia-distances))) + (home-page "https://github.com/matthieugomez/StringDistances.jl") + (synopsis "String Distances in Julia") + (description "This package provides string distances in Julia. Distances +are defined for @code{AbstractStrings}, and any iterator that define +@code{length()}. The package also defines Distance \"modifiers\" that can be +applied to any distance.") + (license license:expat))) + +(define-public julia-structtypes + (package + (name "julia-structtypes") + (version "1.7.2") + (source + (origin + (method git-fetch) + (uri (git-reference + (url "https://github.com/JuliaData/StructTypes.jl") + (commit (string-append "v" version)))) + (file-name (git-file-name name version)) + (sha256 + (base32 "02mn4kkhn3927dk7945c9bjwlldihydxgn5ilmqqvs8dknvbw8p1")))) + (build-system julia-build-system) + (home-page "https://juliadata.github.io/StructTypes.jl/stable/") + (synopsis "Abstract definitions and convenience methods for Julia objects") + (description "This package provides the @code{StructTypes.StructType} trait +for Julia types to declare the kind of \"struct\" they are, providing +serialization/deserialization packages patterns and strategies to automatically +construct objects.") + (license license:expat))) + (define-public julia-suppressor (package (name "julia-suppressor") @@ -2222,6 +3827,74 @@ product preserves all dimensions}, and @acronym{boxdot, contracts neighboring dimensions}.") (license license:expat))) +(define-public julia-testimages + (package + (name "julia-testimages") + (version "1.5.0") + (source + (origin + (method git-fetch) + (uri (git-reference + (url "https://github.com/JuliaImages/TestImages.jl") + (commit (string-append "v" version)))) + (file-name (git-file-name name version)) + (sha256 + (base32 "1lnfsmx33qspyvxw0cykwh7il8xykjpcw1080sisn95ngz2qhdmy")))) + (build-system julia-build-system) + (arguments + `(#:tests? #f)) ; cycle with ImageMagick.jl + (propagated-inputs + `(("julia-axisarrays" ,julia-axisarrays) + ("julia-colortypes" ,julia-colortypes) + ("julia-fileio" ,julia-fileio) + ("julia-offsetarrays" ,julia-offsetarrays) + ("julia-stringdistances" ,julia-stringdistances))) + ;(native-inputs + ; `(("julia-colors" ,julia-colors) + ; ("julia-fixedpointnumbers" ,julia-fixedpointnumbers) + ; ("julia-imagecontrastadjustment" ,julia-imagecontrastadjustment) + ; ("julia-imagemagick" ,julia-imagemagick) + ; ("julia-ometiff" ,julia-ometiff) + ; ("julia-referencetests" ,julia-referencetests))) + (home-page "https://testimages.juliaimages.org/") + (synopsis "Standard test images for Julia") + (description "This package provides a convenient Julia interface for loading +standard named test images and example images for the internal usage in +@code{JuliaImages}. This can be used in conjunction with the @code{Images} +package.") + (license license:expat))) + +(define-public julia-tracker + (package + (name "julia-tracker") + (version "0.2.12") + (source + (origin + (method git-fetch) + (uri (git-reference + (url "https://github.com/FluxML/Tracker.jl") + (commit (string-append "v" version)))) + (file-name (git-file-name name version)) + (sha256 + (base32 "1s4mdywbp7nli7z985fqaj1rs4i6d92b1jx3lhg0qhk1s5wc0v8j")))) + (build-system julia-build-system) + (propagated-inputs + `(("julia-adapt" ,julia-adapt) + ("julia-diffrules" ,julia-diffrules) + ("julia-forwarddiff" ,julia-forwarddiff) + ("julia-macrotools" ,julia-macrotools) + ("julia-nanmath" ,julia-nanmath) + ("julia-nnlib" ,julia-nnlib) + ("julia-requires" ,julia-requires) + ("julia-specialfunctions" ,julia-specialfunctions))) + (native-inputs + `(("julia-pdmats" ,julia-pdmats))) + (home-page "https://github.com/FluxML/Tracker.jl") + (synopsis "Operator overloading reverse-mode automatic differentiator") + (description "@code{Tracker.jl} previously provided @code{Flux.jl} with +automatic differentiation for its machine learning platform.") + (license license:expat))) + (define-public julia-typedtables (package (name "julia-typedtables") @@ -2305,7 +3978,7 @@ working with @acronym{URIs,Uniform Resource Identifiers}, as defined in RFC (define-public julia-unitful (package (name "julia-unitful") - (version "1.7.0") + (version "1.8.0") (source (origin (method git-fetch) @@ -2314,7 +3987,7 @@ working with @acronym{URIs,Uniform Resource Identifiers}, as defined in RFC (commit (string-append "v" version)))) (file-name (git-file-name name version)) (sha256 - (base32 "03nq2nc2mwiqg3z1gksfsnyd7dmsjsya5c2v1n5h0ab22vm59f0m")))) + (base32 "0n9z4skj04h033qbn22cn6f5jby6584j6pizvs7bdbk93h39ch1g")))) (build-system julia-build-system) (propagated-inputs `(("julia-constructionbase" ,julia-constructionbase))) @@ -2352,7 +4025,7 @@ useful in order to support @code{VersionNumber} comparisons applied to (define-public julia-weakrefstrings (package (name "julia-weakrefstrings") - (version "0.6.2") + (version "1.0.0") (source (origin (method git-fetch) @@ -2361,16 +4034,40 @@ useful in order to support @code{VersionNumber} comparisons applied to (commit (string-append "v" version)))) (file-name (git-file-name name version)) (sha256 - (base32 "0129mf1axxycb1ans3idlvw8ch0hmdrl80q98jw63f99zz3ddipr")))) + (base32 "1p8q62zsmi02vyckgy25ddmxns223xrhx575x9lfgvr7jrw1kl2p")))) (build-system julia-build-system) (propagated-inputs - `(("julia-dataapi" ,julia-dataapi))) + `(("julia-dataapi" ,julia-dataapi) + ("julia-parsers" ,julia-parsers))) (home-page "https://github.com/JuliaData/WeakRefStrings.jl") (synopsis "Efficient string representation and transfer in Julia") (description "This package provides a minimal String type for Julia that allows for efficient string representation and transfer") (license license:expat))) +(define-public julia-woodburymatrices + (package + (name "julia-woodburymatrices") + (version "0.5.3") + (source + (origin + (method git-fetch) + (uri (git-reference + (url "https://github.com/timholy/WoodburyMatrices.jl") + (commit (string-append "v" version)))) + (file-name (git-file-name name version)) + (sha256 + (base32 "04yykivi8zrbryxlmb0p5xa6lma8iq22r5s863117dnnqj5gaffd")))) + (build-system julia-build-system) + (home-page "https://github.com/timholy/WoodburyMatrices.jl") + (synopsis "Support for the Woodbury matrix identity for Julia") + (description "This package provides support for the Woodbury matrix identity +for the Julia programming language. This is a generalization of the +Sherman-Morrison formula. Note that the Woodbury matrix identity is notorious +for floating-point roundoff errors, so be prepared for a certain amount of +inaccuracy in the result.") + (license license:expat))) + (define-public julia-zipfile (package (name "julia-zipfile") |