;;; Copyright © 2021 Simon Tournier <zimon.toutoune@gmail.com>
;;; Copyright © 2021 Efraim Flashner <efraim@flashner.co.il>
;;; Copyright © 2021 Vinicius Monego <monego@posteo.net>
+;;; Copyright © 2021 jgart <jgart@dismail.de>
;;;
;;; This file is part of GNU Guix.
;;;
(base32 "0083pwdyxjb04i330ir9pc8kmp4bwk59lx1jgc9qi05y8j7xzbp0"))))
(build-system julia-build-system)
(inputs ;required for tests
- `(("julia-unitful" ,julia-unitful)))
+ (list julia-unitful))
(home-page "https://github.com/JuliaGPU/Adapt.jl")
(synopsis "General framework for fast Fourier transforms (FFTs)")
(description "This package allows multiple FFT packages to co-exist with
(sha256
(base32 "1g0kyzcdykgs247j72jpc2qqall696jwgb3hnn4cxmbi8bkf7wpk"))))
(build-system julia-build-system)
+ (arguments
+ `(#:parallel-tests? #f))
(home-page "https://github.com/JuliaTesting/Aqua.jl")
(synopsis "Automated quality assurance for Julia packages")
(description "@acronym{Aqua.jl, Auto QUality Assurance for Julia packages},
(sha256
(base32 "0cmldnzvdgmfnrnrzgj6v1mfr2rvk5096392rwmhd3iyx7v0pq33"))))
(build-system julia-build-system)
+ (arguments
+ ;; XXXX: Unexpected failures for i686, e.g.,
+ ;; Expression: @inferred(ArrayInterface.size(Rnr)) === (StaticInt(4),)
+ ;; Evaluated: (static(2),) === (static(4),)
+ ;; Disable as stopgap.
+ `(#:tests? ,(not (target-x86-32?))))
(propagated-inputs
- `(("julia-ifelse" ,julia-ifelse)
- ("julia-requires" ,julia-requires)
- ("julia-static" ,julia-static)))
+ (list julia-ifelse
+ julia-requires
+ 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)))
+ (list julia-aqua
+ julia-bandedmatrices
+ julia-blockbandedmatrices
+ julia-ifelse
+ julia-offsetarrays
+ 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
(base32 "05q62pks8j23pgbrfny072rrwzrz6q19l68srnjxxv39ncmdmrvg"))))
(build-system julia-build-system)
(propagated-inputs
- `(("julia-fillarrays" ,julia-fillarrays)))
+ (list julia-fillarrays))
(home-page "https://github.com/JuliaMatrices/ArrayLayouts.jl")
(synopsis "Array layouts and general fast linear algebra")
(description "This package implements a trait-based framework for describing
(base32 "00x85lnfln7xkfnirpplzyi8r6q92nfqwya8il156bf7b1pa20gk"))))
(build-system julia-build-system)
(propagated-inputs
- `(("julia-woodburymatrices" ,julia-woodburymatrices)))
+ (list 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
(base32 "03kzan1lm4fxfhzv1xjg3ysf6y7nagcc61vfz15kvdrp1dqxlynk"))))
(build-system julia-build-system)
(propagated-inputs
- `(("julia-rangearrays" ,julia-rangearrays)
- ("julia-intervalsets" ,julia-intervalsets)
- ("julia-itertools" ,julia-itertools)))
+ (list julia-rangearrays
+ julia-intervalsets
+ julia-itertools))
(native-inputs
- `(("julia-offsetarrays" ,julia-offsetarrays)
- ("julia-unitful" ,julia-unitful)))
+ (list julia-offsetarrays
+ 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
(base32 "0rlfj9gr9ss621v5kw5b06206yaak21s2vq9vk7r8a7p2ylncism"))))
(build-system julia-build-system)
(propagated-inputs
- `(("julia-arraylayouts" ,julia-arraylayouts)
- ("julia-fillarrays" ,julia-fillarrays)))
+ (list julia-arraylayouts
+ julia-fillarrays))
(native-inputs
- `(("julia-genericlinearalgebra" ,julia-genericlinearalgebra)))
+ (list 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
(sha256
(base32 "1xz3kdrphp4b158pg7dwkiry49phs2fjjpdvk1hjpww5ykxacks8"))))
(build-system julia-build-system)
- (propagated-inputs `(("julia-json" ,julia-json)))
+ (arguments
+ `(#:phases
+ ,@(if (target-x86-32?)
+ '((modify-phases %standard-phases
+ (add-after 'unpack 'remove-failing-tests-i686
+ (lambda _
+ (substitute* "test/GroupsTests.jl"
+ (("@test sprint\\(show, g1\\)")
+ "@test_broken sprint(show, g1)")
+ (("@test sprint\\(show, g1; context = :boundto => 1\\)")
+ "@test_broken sprint(show, g1; context = :boundto => 1)")
+ (("@test sprint\\(show, g1; context = :limit => false\\)")
+ "@test_broken sprint(show, g1; context = :limit => false)")
+ (("@test @test_deprecated") "@test_broken"))
+ (substitute* "test/ExecutionTests.jl"
+ ;; Evaluated: 12 == 8
+ (("@test @ballocated\\(Ref\\(1\\)\\)")
+ "@test_broken @ballocated(Ref(1))"))))))
+ '(%standard-phases))))
+ (propagated-inputs
+ (list julia-json))
(home-page "https://github.com/JuliaCI/BenchmarkTools.jl")
(synopsis "Benchmarking framework for the Julia language")
(description "@code{BenchmarkTools.jl} makes performance tracking of Julia
(sha256
(base32 "1by26036fk9mawmcgqxpwizgbs398v9p6vrbsgg7h6llqn3q9iw1"))))
(build-system julia-build-system)
+ (arguments
+ `(#:phases
+ ,@(if (target-64bit?)
+ '(%standard-phases)
+ '((modify-phases %standard-phases
+ (add-after 'unpack 'fix-tests-int32-i686
+ (lambda _
+ (substitute* "test/test_blockarrays.jl"
+ (("Int64") "Int32")))))))))
(propagated-inputs
- `(("julia-arraylayouts" ,julia-arraylayouts)
- ("julia-fillarrays" ,julia-fillarrays)))
+ (list julia-arraylayouts
+ julia-fillarrays))
(native-inputs
- `(("julia-lazyarrays" ,julia-lazyarrays)
- ("julia-offsetarrays" ,julia-offsetarrays)
- ("julia-staticarrays" ,julia-staticarrays)))
+ (list julia-lazyarrays
+ julia-offsetarrays
+ 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
(base32 "10n1r6kmmv2wa307jfg9y2m6p16j8hngjp3fjavpbdy1r5haasm9"))))
(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)))
+ (list julia-arraylayouts
+ julia-bandedmatrices
+ julia-blockarrays
+ julia-fillarrays
+ 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
@code{BlockArrays.jl} whose layout of non-zero blocks is banded.")
(license license:expat)))
+(define-public julia-bson
+ (package
+ (name "julia-bson")
+ (version "0.3.3")
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/JuliaIO/BSON.jl")
+ (commit (string-append "v" version))))
+ (file-name (git-file-name name version))
+ (sha256
+ (base32 "1l5608ma2ys7v2gpcqbiv9mwfc6yrlqkihrfx1pf7fgv5llhd4fn"))))
+ (build-system julia-build-system)
+ (native-inputs
+ (list julia-dataframes))
+ (home-page "https://github.com/JuliaIO/BSON.jl")
+ (synopsis "Binary JSON serialisation format")
+ (description "@code{BSON.jl} is a Julia package for working with the Binary
+JSON serialisation format. It can be used as a general store for Julia data
+structures.")
+ (license license:expat)))
+
(define-public julia-bufferedstreams
(package
(name "julia-bufferedstreams")
;; https://travis-ci.org/BioJulia/BufferedStreams.jl/jobs/491050182
(arguments
'(#:tests? #f
- #:julia-package-name "BufferedStreams"))
- (propagated-inputs `(("julia-compat" ,julia-compat)))
+ #:julia-package-name "BufferedStreams"
+ #:julia-package-uuid "e1450e63-4bb3-523b-b2a4-4ffa8c0fd77d"))
+ (propagated-inputs
+ (list julia-compat))
(home-page "https://github.com/BioJulia/BufferedStreams.jl")
(synopsis "Fast composable IO streams")
(description "@code{BufferedStreams.jl} provides buffering for IO
(base32 "1bcfylxdaizgasnmlkjjkf4dgfvy2y9ycnphw2d0z6mm9vx3n04x"))))
(build-system julia-build-system)
(native-inputs
- `(("julia-pooledarrays" ,julia-pooledarrays)))
+ (list julia-pooledarrays))
(propagated-inputs
- `(("julia-dataapi" ,julia-dataapi)
- ("julia-json" ,julia-json)
- ("julia-json3" ,julia-json3)
- ("julia-missings" ,julia-missings)
- ("julia-recipesbase" ,julia-recipesbase)
- ("julia-structtypes" ,julia-structtypes)))
+ (list julia-dataapi
+ julia-json
+ julia-json3
+ julia-missings
+ julia-recipesbase
+ julia-structtypes))
(home-page "https://github.com/JuliaData/CategoricalArrays.jl")
(synopsis "Arrays for working with categorical data")
(description "This package provides tools for working with categorical
(base32 "0if93pd3b3scg2x3gmk1cbwjk0ax1n792vy8c38y3xl7jpd5cb70"))))
(build-system julia-build-system)
(inputs ;required for test
- `(("julia-chainrulestestutils" ,julia-chainrulestestutils)
- ("julia-finitedifferences" ,julia-finitedifferences)
- ("julia-nanmath" ,julia-nanmath)
- ("julia-specialfunctions" ,julia-specialfunctions)))
+ (list julia-chainrulestestutils
+ julia-finitedifferences
+ julia-nanmath
+ julia-specialfunctions))
(propagated-inputs
- `(("julia-chainrulescore" ,julia-chainrulescore)
- ("julia-compat" ,julia-compat)
- ("julia-reexport" ,julia-reexport)
- ("julia-requires" ,julia-requires)))
+ (list julia-chainrulescore
+ julia-compat
+ julia-reexport
+ julia-requires))
(home-page "https://github.com/JuliaDiff/ChainRules.jl")
(synopsis "Common utilities for automatic differentiation")
(description "The is package provides a variety of common utilities that
(base32 "1866xv30h1bi7f2m993nljzf58wwmv8zlgn6ffn9j3wckch1nfpb"))))
(build-system julia-build-system)
(inputs ;required for tests
- `(("julia-benchmarktools" ,julia-benchmarktools)
- ("julia-staticarrays" ,julia-staticarrays)))
+ (list julia-benchmarktools
+ julia-staticarrays))
(propagated-inputs
- `(("julia-compat" ,julia-compat)))
+ (list julia-compat))
(home-page "https://github.com/JuliaDiff/ChainRulesCore.jl")
(synopsis "Common utilities used by downstream automatic differentiation tools")
(description "The package provides a light-weight dependency for defining
(define-public julia-chainrulestestutils
(package
(name "julia-chainrulestestutils")
- (version "1.0.0")
+ (version "1.2.3")
(source
(origin
(method git-fetch)
(commit (string-append "v" version))))
(file-name (git-file-name name version))
(sha256
- (base32 "07l4sjc7avmmp4v1dsym1jyb46q4jsvv7i0yzszf72gj8d9k6lwa"))))
+ (base32 "1vlkyp72d514gyb4k3yhjl1g7f24ncmz61j56p4sdi9f76rk9fx9"))))
(build-system julia-build-system)
(propagated-inputs
- `(("julia-chainrulescore" ,julia-chainrulescore)
- ("julia-compat" ,julia-compat)
- ("julia-finitedifference" ,julia-finitedifferences)))
+ (list julia-chainrulescore
+ julia-compat
+ julia-finitedifferences))
(home-page "https://github.com/JuliaDiff/ChainRulesTestUtils.jl")
(synopsis "Common utilities used by downstream automatic differentiation tools")
(description "This package is designed to help in testing
dependencies, while keeping @code{ChainRulesCore.jl} as light-weight as possible.")
(license license:expat)))
+(define-public julia-codeczlib
+ (package
+ (name "julia-codeczlib")
+ (version "0.7.0")
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/JuliaIO/CodecZlib.jl")
+ (commit (string-append "v" version))))
+ (file-name (git-file-name name version))
+ (sha256
+ (base32 "0xm603nylkwk4bzx66zv1g3syzrvn3jh9spdx7kvcvgszzyrrgh4"))))
+ (build-system julia-build-system)
+ (arguments
+ `(#:phases
+ (modify-phases %standard-phases
+ (add-before 'reset-gzip-timestamps 'make-files-writable
+ (lambda* (#:key outputs #:allow-other-keys)
+ (let ((out (assoc-ref outputs "out")))
+ (for-each make-file-writable
+ (find-files out "\\.gz$"))
+ #t))))))
+ (propagated-inputs
+ (list julia-transcodingstreams
+ julia-zlib-jll))
+ (home-page "https://github.com/JuliaIO/CodecZlib.jl")
+ (synopsis "Zlib codecs for @code{TranscodingStreams.jl}")
+ (description "This package provides zlib codecs for
+@code{TranscodingStreams.jl}.")
+ (license license:expat)))
+
(define-public julia-colors
(package
(name "julia-colors")
(base32 "0kx3hq7rf8p5zx6ly9k5j90zijmc7yrwmy96cgkl2ibdfbnhmya3"))))
(build-system julia-build-system)
(propagated-inputs
- `(("julia-colortypes" ,julia-colortypes)
- ("julia-fixedpointnumbers" ,julia-fixedpointnumbers)
- ("julia-reexport" ,julia-reexport)))
+ (list julia-colortypes
+ julia-fixedpointnumbers
+ julia-reexport))
(home-page "https://github.com/JuliaGraphics/Colors.jl")
(synopsis "Tools for dealing with color")
(description "This package provides a wide array of functions for dealing
(base32 "0kpjhmqd5cj8dh8bmh9b5g6bscyp7h23hzpr2s93pnrp57q1wvhq"))))
(build-system julia-build-system)
(propagated-inputs
- `(("julia-colors" ,julia-colors)
- ("julia-colortypes" ,julia-colortypes)
- ("julia-fixedpointnumbers" ,julia-fixedpointnumbers)
- ("julia-staticarrays" ,julia-staticarrays)))
+ (list julia-colors
+ julia-colortypes
+ julia-fixedpointnumbers
+ julia-staticarrays))
(home-page "https://github.com/JuliaGraphics/ColorSchemes.jl")
(synopsis "Colorschemes, colormaps, gradients, and palettes")
(description "This package provides a collection of colorschemes.")
(file-name (git-file-name name version))
(sha256
(base32 "0n7h70caqv7yd0khjhn90iax62r73mcif8qzkwj5b4q46li1r8ih"))))
- (arguments
- '(#:tests? #f)) ;require Documenter, not packaged yet
(build-system julia-build-system)
(propagated-inputs
- `(("julia-fixedpointnumbers" ,julia-fixedpointnumbers)))
+ (list julia-fixedpointnumbers))
+ (native-inputs
+ (list julia-documenter))
(home-page "https://github.com/JuliaGraphics/ColorTypes.jl")
(synopsis "Basic color types and constructor")
(description "This minimalistic package serves as the foundation for
(base32 "02gk7f5g5wjxdasbjf8bvv1m7clksh7mw1xmygjdirjz1q0d6dwi"))))
(build-system julia-build-system)
(propagated-inputs
- `(("julia-colortypes" ,julia-colortypes)
- ("julia-specialfunctions" ,julia-specialfunctions)
- ("julia-tensorcore" ,julia-tensorcore)))
+ (list julia-colortypes
+ julia-specialfunctions
+ julia-tensorcore))
(native-inputs
- `(("julia-colors" ,julia-colors)))
+ (list 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
(base32 "0mgy90kk8ksv3l720kkk04gnhn4aqhh2dj4sp3x8yy3limngfjay"))))
(build-system julia-build-system)
(propagated-inputs
- `(("julia-macrotools" ,julia-macrotools)))
+ (list julia-macrotools))
(home-page "https://github.com/rdeits/CommonSubexpressions.jl")
(synopsis "@code{@@cse} macro for Julia")
(description "This package provides the @code{@@cse} macro, which performs
way.")
(license license:expat)))
+(define-public julia-configurations
+ (package
+ (name "julia-configurations")
+ (version "0.16.4")
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/Roger-luo/Configurations.jl")
+ (commit (string-append "v" version))))
+ (file-name (git-file-name name version))
+ (sha256
+ (base32 "1b23p0zk8dx2sf01cnw177mqci7qd81b9s32ixz9clsh0r0icl1b"))))
+ (build-system julia-build-system)
+ (arguments
+ `(#:phases
+ (modify-phases %standard-phases
+ (add-after 'link-depot 'fix-tests
+ (lambda _
+ (substitute* "test/runtests.jl"
+ (("option.toml") "test/option.toml"))))
+ (add-after 'link-depot 'dont-use-exproniconlite
+ (lambda _
+ (substitute* '("Project.toml"
+ "src/Configurations.jl"
+ "test/runtests.jl")
+ (("ExproniconLite") "Expronicon"))
+ (substitute* "Project.toml"
+ (("55351af7-c7e9-48d6-89ff-24e801d99491")
+ "6b7a57c9-7cc1-4fdf-b7f5-e857abae3636"))))
+ ,@(if (target-64bit?)
+ '()
+ '((add-after 'unpack 'fix-tests-int32-i686
+ (lambda _
+ (substitute* "test/runtests.jl"
+ (("Int64") "Int32")))))))))
+ (propagated-inputs
+ (list julia-crayons
+ julia-expronicon
+ julia-orderedcollections))
+ (home-page "https://configurations.rogerluo.dev/stable/")
+ (synopsis "Tools for options and configurations in Julia")
+ (description "@code{Configurations.jl} provides a macro @code{@@option} to
+let you define @code{structs} to represent options/configurations, and serialize
+between different option/configuration file formats such as @code{TOML}.")
+ (license license:expat)))
+
(define-public julia-constructionbase
(package
(name "julia-constructionbase")
(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)))
+ (list julia-staticarrays))
+ (native-inputs
+ (list julia-documenter
+ julia-forwarddiff
+ julia-unitful))
(home-page "https://github.com/JuliaGeometry/CoordinateTransformations.jl")
(synopsis "Coordinate transformations in Julia")
(description "@code{CoordinateTransformations} is a Julia package to manage
dependency on it.")
(license license:expat)))
+(define-public julia-dataframes
+ (package
+ (name "julia-dataframes")
+ (version "1.2.2")
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/JuliaData/DataFrames.jl")
+ (commit (string-append "v" version))))
+ (file-name (git-file-name name version))
+ (sha256
+ (base32 "1bk0amrghgjrkyn1mm4ac23swwbgszl1d0qyl9137qj5zvv9dasp"))))
+ (build-system julia-build-system)
+ (arguments
+ `(#:phases
+ (modify-phases %standard-phases
+ (add-after 'link-depot 'skip-failing-test
+ (lambda _
+ ;; Tests with non-standard colors.
+ (substitute* "test/show.jl"
+ (("test (sprint\\(show, df, context=:color=>true)" _ test)
+ (string-append "test_nowarn " test)))
+ (substitute* "test/io.jl"
+ (("testset \\\"improved.*" all)
+ (string-append all "return\n")))
+ (substitute* "test/join.jl"
+ (("test (levels\\(outerjoin\\(B)" _ test)
+ (string-append "test_nowarn " test)))
+ #t)))))
+ (propagated-inputs
+ (list julia-dataapi
+ julia-invertedindices
+ julia-iteratorinterfaceextensions
+ julia-missings
+ julia-pooledarrays
+ julia-prettytables
+ julia-reexport
+ julia-sortingalgorithms
+ julia-tables
+ julia-tabletraits))
+ (native-inputs
+ (list julia-categoricalarrays
+ julia-combinatorics
+ julia-datastructures
+ julia-datavalues
+ julia-offsetarrays
+ julia-unitful))
+ (home-page "https://dataframes.juliadata.org/stable/")
+ (synopsis "In-memory tabular data")
+ (description "This package provides a set of tools for working with tabular
+data in Julia. Its design and functionality are similar to those of Pandas from
+Python or @code{data.frame}, @code{data.table} and @code{dplyr} from R, making
+it a great general purpose data science tool, especially for those coming to
+Julia from R or Python.")
+ (license license:expat)))
+
(define-public julia-datastructures
(package
(name "julia-datastructures")
(sha256
(base32 "0hdqp8ipsqdw5bqqkdvz4j6n67x80sj5azr9vzyxwjfsgkfbnk2l"))))
(propagated-inputs
- `(("julia-compat" ,julia-compat)
- ("julia-orderedcollections" ,julia-orderedcollections)))
+ (list julia-compat
+ julia-orderedcollections))
(build-system julia-build-system)
+ (arguments
+ `(#:phases
+ ,@(if (target-x86-32?)
+ '((modify-phases %standard-phases
+ (add-after 'unpack 'remove-failing-test-i686
+ (lambda _
+ ;; The evaluation returns the correct value,
+ ;; Evaluated: "Accumulator(1 => 3, 3 => 4)"
+ ;; but, for some reasons, is considered as failed.
+ (substitute* "test/test_accumulator.jl"
+ (("@test sprint\\(show,Accumulator\\(1 => 3, 3 => 4\\)\\)")
+ "@test_broken sprint(show, Accumulator(1 => 3, 3 => 4))"))))))
+ '(%standard-phases))))
(home-page "https://github.com/JuliaCollections/DataStructures.jl")
(synopsis "Julia module providing different data structures")
(description "This package implements a variety of data structures,
`(#:tests? #f ; Tests need upgrading with newer Julia version.
#:phases
(modify-phases %standard-phases
- (add-after 'unpack 'skip-known-failing-tests
+ (add-after 'link-depot 'skip-known-failing-tests
(lambda _
;; See upstream report:
;; https://github.com/queryverse/DataValues.jl/issues/83
((".*DataValue\\(method\\(f.*") ""))
#t)))))
(propagated-inputs
- `(("julia-datavalueinterfaces" ,julia-datavalueinterfaces)))
+ (list julia-datavalueinterfaces))
(home-page "https://github.com/queryverse/DataValues.jl")
(synopsis "Missing values for Julia")
(description "This package provides the type @code{DataValue} that is used
(base32 "1mm43hm8hd6sgmkkpqhbqhvap7mpkjwzmz5algxi6manp580gkr5"))))
(build-system julia-build-system)
(propagated-inputs
- `(("julia-indexing" ,julia-indexing)))
+ (list julia-indexing))
(home-page "https://github.com/andyferris/Dictionaries.jl")
(synopsis "Alternative interface for dictionaries in Julia")
(description "This package provides an alternative interface for
(arguments
`(#:phases
(modify-phases %standard-phases
- (add-after 'unpack 'skip-flakey-tests
+ (add-after 'link-depot 'skip-flakey-tests
(lambda _
;; Some combination of these tests fail nondeterministically
;; each of the times this package is built.
(("test dist\\(z, x") "test_nowarn dist(z, x")
(("test dist\\(z, y") "test_nowarn dist(z, y")))))))
(propagated-inputs
- `(("julia-statsapi" ,julia-statsapi)))
+ (list julia-statsapi))
(native-inputs
- `(("julia-offsetarrays" ,julia-offsetarrays)
- ("julia-unitful" ,julia-unitful)))
+ (list julia-offsetarrays
+ 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
(arguments
`(#:phases
(modify-phases %standard-phases
- (add-after 'unpack 'patch-source
+ (add-after 'link-depot 'patch-source
(lambda* (#:key inputs #:allow-other-keys)
(substitute* "src/Deps.jl"
(("pip install")
(string-append (assoc-ref inputs "python")
"/bin/pip install")))
#t))
- (add-after 'unpack 'remove-javascript-downloads
+ (add-after 'link-depot 'remove-javascript-downloads
(lambda _
(substitute* "src/Writers/HTMLWriter.jl"
(("cdnjs.cloudflare.com") "example.com"))
((".*Main\\.examples_html_mathjax3_doc.*") ""))
#t)))))
(propagated-inputs
- `(("julia-ansicoloredprinters" ,julia-ansicoloredprinters)
- ("julia-docstringextensions" ,julia-docstringextensions)
- ("julia-iocapture" ,julia-iocapture)
- ("julia-json" ,julia-json)))
+ (list julia-ansicoloredprinters julia-docstringextensions
+ julia-iocapture julia-json))
(inputs
`(("python" ,python-wrapper)))
(native-inputs
(inputs
;; We don't want to propagate the bootstrap version.
;; Cycle with Documenter.jl in later versions.
- `(("julia-documenter" ,julia-documenter-bootstrap)))
+ (list julia-documenter-bootstrap))
(home-page "https://github.com/JuliaDocs/DocumenterMarkdown.jl")
(synopsis "Documenter's Markdown")
(description "This package enables the Markdown / MkDocs backend of
;; Cycle with Documenter.jl in later versions.
`(("julia-documenter" ,julia-documenter-bootstrap)))
(propagated-inputs
- `(("julia-docstringextensions" ,julia-docstringextensions)
- ("julia-gumbo" ,julia-gumbo)
- ("julia-sass" ,julia-sass)))
+ (list julia-docstringextensions julia-gumbo julia-sass))
(native-inputs
- `(("julia-example" ,julia-example)))
+ (list julia-example))
(home-page "https://github.com/JuliaDocs/DocumenterTools.jl")
(synopsis "Extra tools for setting up Documenter.jl")
(description "This package contains utilities for setting up documentation
(file-name (git-file-name name version))
(sha256
(base32 "1w6p3yxajvclax5b9g7cr2jmbc7lvr5nk4gq0aljxdycdq1d2y3v"))))
- (propagated-inputs
- `(("julia-staticarrays" ,julia-staticarrays)))
(build-system julia-build-system)
+ (propagated-inputs
+ (list julia-staticarrays))
(home-page "https://github.com/JuliaDiff/DiffResults.jl")
(synopsis "In-place differentiation methods of primal values at multi-order")
(description "This package provides the @code{DiffResult} type, which can
(file-name (git-file-name name version))
(sha256
(base32 "0cwjvj4gma7924fm3yas0nf0jlnwwx4v7fi79ii3s290lkdldzfl"))))
- (propagated-inputs
- `(("julia-nanmath" ,julia-nanmath)
- ("julia-specialfunctions" ,julia-specialfunctions)))
(build-system julia-build-system)
+ (propagated-inputs
+ (list julia-nanmath
+ julia-specialfunctions))
(home-page "https://github.com/JuliaDiff/DiffRules.jl")
(synopsis "Primitive differentiation rules")
(description "This package provides primitive differentiation rules that
(arguments
`(#:phases
(modify-phases %standard-phases
- (add-after 'unpack 'adjust-test-suite
+ (add-after 'link-depot '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)))
+ (list julia-calculus
+ julia-nanmath
+ 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}
(arguments
`(#:phases
(modify-phases %standard-phases
- (add-after 'unpack 'adjust-test-suite
+ (add-after 'link-depot 'adjust-test-suite
(lambda _
(substitute* "test/runtests.jl"
;; Seems to not play nicely with Julia-1.6.
((".*basic.jl.*") "")))))))
(propagated-inputs
- `(("julia-arrayinterface" ,julia-arrayinterface)))
+ (list julia-arrayinterface))
(home-page "https://github.com/ChrisRackauckas/EllipsisNotation.jl")
(synopsis "Elipsis notation implementation")
(description "This implements the notation @code{..} for indexing arrays.
(description "This package provides various examples.")
(license license:expat))))
+;; ExproniconLite.jl is autogenerated from this package.
+(define-public julia-expronicon
+ (package
+ (name "julia-expronicon")
+ (version "0.6.10")
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/Roger-luo/Expronicon.jl")
+ (commit (string-append "v" version))))
+ (file-name (git-file-name name version))
+ (sha256
+ (base32 "0h8aaynqlxrkn8575k5vqmhzil4vvxchhf0bcxa6zwawp558gj2y"))))
+ (build-system julia-build-system)
+ (arguments
+ `(#:phases
+ (modify-phases %standard-phases
+ (add-after 'link-depot 'skip-network-tests
+ (lambda _
+ (substitute* "test/runtests.jl"
+ ;; This test tries to access the Julia package registry.
+ ((".*expand\\.jl.*") "")))))))
+ (propagated-inputs
+ (list julia-mlstyle))
+ (native-inputs
+ (list julia-documenter))
+ (home-page "https://expronicon.rogerluo.dev/dev/")
+ (synopsis "Collective tools for metaprogramming on Julia Expr")
+ (description "This package provides a collection of tools for
+metaprogramming on Julia Expr, the meta programming standard library for
+@code{MLStyle}.")
+ (license license:expat)))
+
(define-public julia-exprtools
(package
(name "julia-exprtools")
(base32 "1ldxbp0kq3ip67x7sp82dz56aq4p5i0chspbgx2zgskr6jcbjj1b"))))
(build-system julia-build-system)
(propagated-inputs
- `(("julia-ffmpeg-jll" ,julia-ffmpeg-jll)
- ("julia-x264-jll" ,julia-x264-jll)))
+ (list julia-ffmpeg-jll
+ julia-x264-jll))
(home-page "https://github.com/JuliaIO/FFMPEG.jl")
(synopsis "Julia Package for ffmpeg")
(description "This package is made to be included into packages that just
`(#:phases
(modify-phases %standard-phases
(delete 'reset-gzip-timestamps)
- (add-after 'unpack 'skip-network-tests
+ (add-after 'link-depot 'skip-network-tests
(lambda _
;; These tests try to download audio/video files.
(substitute* "test/query.jl"
(substitute* "test/runtests.jl"
((".*test_mimesave.*") "")))))))
(propagated-inputs
- `(("julia-requires" ,julia-requires)))
+ (list julia-requires))
(native-inputs
- `(("julia-colortypes" ,julia-colortypes)
- ("julia-filepathsbase" ,julia-filepathsbase)
- ("julia-http" ,julia-http)))
+ (list julia-colortypes
+ julia-filepathsbase
+ 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
(base32 "1sx96pzrgyh8k7x2w8vmyi6cazlmp7rg1n7wbl47qfzqjggka6kz"))))
(build-system julia-build-system)
(inputs ;required by tests
- `(("julia-staticarrays" ,julia-staticarrays)))
+ (list julia-staticarrays))
(home-page "https://github.com/JuliaArrays/FillArrays.jl")
(synopsis "Lazy matrix representation")
(description "This package lazily represents matrices filled with
(setenv "GROUP" "Core")
#t)))))
(propagated-inputs
- `(("julia-arrayinterface" ,julia-arrayinterface)
- ("julia-requires" ,julia-requires)
- ("julia-staticarrays" ,julia-staticarrays)))
+ (list julia-arrayinterface
+ julia-requires
+ julia-staticarrays))
(native-inputs
- `(("julia-bandedmatrices" ,julia-bandedmatrices)
- ("julia-blockbandedmatrices" ,julia-blockbandedmatrices)
- ("julia-safetestsets" ,julia-safetestsets)))
+ (list julia-bandedmatrices
+ julia-blockbandedmatrices
+ 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,
(sha256
(base32 "09nsf9cgk49yrvprflnhd9h5rrgs280rgj8sad3csghxdx6jqk5c"))))
(build-system julia-build-system)
+ (arguments
+ `(#:phases
+ ,@(if (target-x86-32?)
+ '((modify-phases %standard-phases
+ (add-after 'unpack 'remove-failing-test-i686
+ (lambda _
+ ;; Machine Precision incorrectly handled
+ (substitute* "test/methods.jl"
+ (("@test central_fdm\\(15, 5, adapt=2\\)\\(exp, 1.0\\)")
+ "@test_broken central_fdm(15, 5, adapt=2)(exp, 1.0)"))))))
+ '(%standard-phases))))
(inputs
- `(("julia-benchmarktools" ,julia-benchmarktools)))
+ (list julia-benchmarktools))
(propagated-inputs
- `(("julia-chainrulescore" ,julia-chainrulescore)
- ("julia-richardson" ,julia-richardson)
- ("julia-staticarrays" ,julia-staticarrays)))
+ (list julia-chainrulescore
+ julia-richardson
+ julia-staticarrays))
(home-page "https://github.com/JuliaDiff/FiniteDifferences.jl")
(synopsis "Estimates derivatives with finite differences")
(description "This package calculates approximate derivatives numerically
(arguments
`(#:phases
(modify-phases %standard-phases
- (add-after 'unpack 'disable-failing-test
+ (add-after 'link-depot 'disable-failing-test
(lambda* (#:key outputs #:allow-other-keys)
(substitute* "test/fixed.jl"
;; A deprecation warning is not thrown
(("@test_logs.*:warn" all) (string-append "# " all)))
#t)))))
- (propagated-inputs `(("julia-compat" ,julia-compat)))
+ (propagated-inputs
+ (list julia-compat))
(home-page "https://github.com/JuliaMath/FixedPointNumbers.jl")
(synopsis "Fixed point types for Julia")
(description "@code{FixedPointNumbers.jl} implements fixed-point number
(sha256
(base32 "1vb46x8mcn61g1l14qrk22c043khg2ml4q1ci7h4k2v34f2ak5fs"))))
(build-system julia-build-system)
+ (arguments
+ ;; XXXX: Unexpected and non-deterministic failures for i686, e.g.,
+ ;; Expression: dual_isapprox(FDNUM ^ PRIMAL, exp(PRIMAL * log(FDNUM)))
+ ;; ERROR: LoadError: LoadError: There was an error during testing
+ ;; Disable as stopgap.
+ `(#:tests? ,(not (target-x86-32?))))
(inputs ;required for tests
- `(("julia-calculus" ,julia-calculus)
- ("julia-difftests" ,julia-difftests)))
+ (list julia-calculus
+ julia-difftests))
(propagated-inputs
- `(("julia-commonsubexpressions" ,julia-commonsubexpressions)
- ("julia-diffresults" ,julia-diffresults)
- ("julia-diffrules" ,julia-diffrules)
- ("julia-nanmath" ,julia-nanmath)
- ("julia-specialfunctions" ,julia-specialfunctions)
- ("julia-staticarrays" ,julia-staticarrays)))
+ (list julia-commonsubexpressions
+ julia-diffresults
+ julia-diffrules
+ julia-nanmath
+ julia-specialfunctions
+ julia-staticarrays))
(home-page "https://github.com/JuliaDiff/ForwardDiff.jl")
(synopsis "Methods to take multidimensional derivatives")
(description "This package implements methods to take derivatives,
(arguments
`(#:phases
(modify-phases %standard-phases
- (add-after 'unpack 'adjust-tests
+ (add-after 'link-depot 'adjust-tests
(lambda _
(substitute* "test/runtests.jl"
(("testset \\\"Abstract.*" all)
arbitrary functions.")
(license license:expat)))
+(define-public julia-functors
+ (package
+ (name "julia-functors")
+ (version "0.2.7")
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/FluxML/Functors.jl")
+ (commit (string-append "v" version))))
+ (file-name (git-file-name name version))
+ (sha256
+ (base32 "03ry1wn1y2jssq65l29bi6q4ki041aa6gl1nd2w6cgl00k2mrxf3"))))
+ (build-system julia-build-system)
+ (home-page "https://fluxml.ai/Functors.jl/stable/")
+ (synopsis "Design pattern for structures as in machine learning")
+ (description "This package provides tools to express a design pattern for
+dealing with large/ nested structures, as in machine learning and
+optimisation. For large machine learning models it can be cumbersome or
+inefficient to work with parameters as one big, flat vector, and structs help
+in managing complexity; but it is also desirable to easily operate over all
+parameters at once, e.g. for changing precision or applying an optimiser
+update step.")
+ (license license:expat)))
+
(define-public julia-fuzzycompletions
(package
(name "julia-fuzzycompletions")
(arguments
`(#:phases
(modify-phases %standard-phases
- (add-after 'unpack 'skip-failing-test
+ (add-after 'link-depot 'skip-failing-test
(lambda _
(substitute* "test/runtests.jl"
((".*RPLE.*") "")))))))
(arguments
`(#:phases
(modify-phases %standard-phases
- (add-after 'unpack 'adjust-test-suite
+ (add-after 'link-depot 'adjust-test-suite
(lambda _
(substitute* "test/runtests.jl"
((".*lapack.*") "")))))))
(native-inputs
- `(("julia-quaternions" ,julia-quaternions)))
+ (list 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
(arguments
`(#:phases
(modify-phases %standard-phases
- (add-after 'unpack 'adjust-test-suite
+ (add-after 'link-depot 'adjust-test-suite
(lambda _
(substitute* "test/complex.jl"
;; expected Array{Int32,1}, got a value of type Array{Int64,1}
matrices the Schur form is often more useful.")
(license license:expat)))
+(define-public julia-geometrybasics
+ (package
+ (name "julia-geometrybasics")
+ (version "0.4.1")
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/JuliaGeometry/GeometryBasics.jl")
+ (commit (string-append "v" version))))
+ (file-name (git-file-name name version))
+ (sha256
+ (base32 "057j3hjpli3q5b98cqkpi4p10x2k9pyksrz62hjmv1kb5qzdvhsj"))))
+ (build-system julia-build-system)
+ (arguments
+ `(#:phases
+ (modify-phases %standard-phases
+ (add-after 'link-depot 'remove-earcut
+ (lambda _
+ (substitute* '("Project.toml"
+ "src/GeometryBasics.jl")
+ ((".*EarCut.*") ""))))
+ (add-after 'link-depot 'skip-incompatible-test
+ (lambda _
+ (substitute* "test/runtests.jl"
+ (("@testset.*MetaT and heterogeneous data.*" all)
+ (string-append all "return\n")))))
+ ,@(if (target-64bit?)
+ '()
+ '((add-after 'unpack 'fix-tests-int32-i686
+ (lambda _
+ (substitute* "test/runtests.jl"
+ (("Int64") "Int32")))))))))
+ (propagated-inputs
+ (list julia-itertools
+ julia-staticarrays
+ julia-structarrays
+ julia-tables))
+ (native-inputs
+ (list julia-offsetarrays))
+ (home-page "https://github.com/JuliaGeometry/GeometryBasics.jl")
+ (synopsis "Basic Geometry Types")
+ (description "This package aims to offer a standard set of Geometry types,
+which easily work with metadata, query frameworks on geometries and different
+memory layouts. The aim is to create a solid basis for Graphics/Plotting,
+finite elements analysis, Geo applications, and general geometry manipulations
+- while offering a Julian API, that still allows performant C-interop.")
+ (license license:expat)))
+
+(define-public julia-gr
+ (package
+ (name "julia-gr")
+ (version "0.58.1")
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/jheinen/GR.jl")
+ (commit (string-append "v" version))))
+ (file-name (git-file-name name version))
+ (sha256
+ (base32 "18zxa1w2wmrf44c5l10qbh99zjdp7h94gxlymh47cf5kj5fc4xmx"))))
+ (build-system julia-build-system)
+ (propagated-inputs
+ (list julia-gr-jll))
+ (home-page "https://github.com/jheinen/GR.jl")
+ (synopsis "Plotting for Julia based on GR")
+ (description "This module provides a Julia interface to GR, a framework for
+visualisation applications.")
+ (license license:expat)))
+
(define-public julia-graphics
(package
(name "julia-graphics")
(base32 "10h1s09v7qkvrjr6l678zamb1p248n8jv4rrwkf8g7d2bpfz9amn"))))
(build-system julia-build-system)
(propagated-inputs
- `(("julia-colors" ,julia-colors)
- ("julia-nanmath" ,julia-nanmath)))
+ (list julia-colors
+ julia-nanmath))
(home-page "https://github.com/JuliaGraphics/Graphics.jl")
(synopsis "Base graphics in Julia")
(description "@code{Graphics.jl} is an abstraction layer for graphical
(base32 "1g22dv3v7caakspv3pdahnqn937fzzsg9y87rj72hid9g8lxl1gm"))))
(build-system julia-build-system)
(propagated-inputs
- `(("julia-abstracttrees" ,julia-abstracttrees)
- ("julia-gumbo-jll" ,julia-gumbo-jll)))
+ (list julia-abstracttrees
+ julia-gumbo-jll))
(home-page "https://github.com/JuliaWeb/Gumbo.jl")
(synopsis "Julia wrapper around Google's gumbo C library for parsing HTML")
(description "@code{Gumbo.jl} is a Julia wrapper around Google's gumbo
(string-append all "return\n")))
#t)))))
(propagated-inputs
- `(("julia-inifile" ,julia-inifile)
- ("julia-mbedtls" ,julia-mbedtls)
- ("julia-uris" ,julia-uris)))
+ (list julia-inifile
+ julia-mbedtls
+ julia-uris))
;; required for tests
(inputs
- `(("julia-json" ,julia-json)
- ("julia-bufferedstreams" ,julia-bufferedstreams)))
+ (list julia-json
+ julia-bufferedstreams))
(home-page "https://juliaweb.github.io/HTTP.jl/")
(synopsis "HTTP support for Julia")
(description "@code{HTTP.jl} is a Julia library for HTTP Messages,
(base32 "0jvl4xn8f8k70sn473li5q62wbiycl5qi25b5k456h3a0j1lbiml"))))
(build-system julia-build-system)
(propagated-inputs
- `(("julia-offsetarrays" ,julia-offsetarrays)))
+ (list 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
(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)))
+ (list julia-axisarrays
+ julia-imagecore
+ julia-reexport
+ julia-simpletraits))
(native-inputs
- `(("julia-unitful" ,julia-unitful)))
+ (list 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
(arguments
`(#:tests? #f)) ; Cycle with ImageMagick.jl.
(propagated-inputs
- `(("julia-imagecore" ,julia-imagecore)
- ("julia-reexport" ,julia-reexport)))
+ (list julia-imagecore
+ julia-reexport))
;(native-inputs
; `(("julia-imagemagick" ,julia-imagemagick)
; ("julia-offsetarrays" ,julia-offsetarrays)
(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)))
+ (list julia-abstractffts
+ julia-colors
+ julia-colorvectorspace
+ julia-fixedpointnumbers
+ julia-graphics
+ julia-mappedarrays
+ julia-mosaicviews
+ julia-offsetarrays
+ julia-paddedviews
+ julia-reexport))
;(native-inputs
; `(("julia-aqua" ,julia-aqua)
; ("julia-colorvectorspace" ,julia-colorvectorspace)
(arguments
`(#:tests? #f)) ; Cycle with ReferenceTests.jl.
(propagated-inputs
- `(("julia-crayons" ,julia-crayons)
- ("julia-imagebase" ,julia-imagebase)
- ("julia-imagecore" ,julia-imagecore)
- ("julia-requires" ,julia-requires)))
+ (list julia-crayons
+ julia-imagebase
+ julia-imagecore
+ julia-requires))
;(native-inputs
; `(("julia-coordinatetransformations" ,julia-coordinatetransformations)
; ("julia-imagemagick" ,julia-imagemagick)
(arguments
`(#:phases
(modify-phases %standard-phases
- (add-after 'unpack 'skip-failing-test
+ (add-after 'link-depot 'skip-failing-test
(lambda _
;; These tests try to download from the imagemagick.org
(substitute* "test/runtests.jl"
(("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)))
+ (list julia-fileio
+ julia-imagecore
+ 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)))
+ (list julia-colors
+ julia-colorvectorspace
+ julia-imagemetadata
+ julia-imageshow
+ julia-imagetransformations
+ julia-indirectarrays
+ julia-offsetarrays
+ 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.
(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)))
+ (list julia-axisarrays
+ julia-imageaxes
+ julia-imagecore
+ julia-indirectarrays))
(native-inputs
- `(("julia-offsetarrays" ,julia-offsetarrays)
- ("julia-simpletraits" ,julia-simpletraits)
- ("julia-unitful" ,julia-unitful)))
+ (list julia-offsetarrays
+ julia-simpletraits
+ 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
(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)))
+ (list julia-fileio
+ julia-imagebase
+ julia-imagecore
+ julia-offsetarrays
+ julia-stackviews))
;(native-inputs
; `(("julia-imagedistances" ,julia-imagedistances)
; ("julia-imagemagick" ,julia-imagemagick)
(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)))
+ (list julia-axisalgorithms
+ julia-colorvectorspace
+ julia-coordinatetransformations
+ julia-identityranges
+ julia-imagecore
+ julia-interpolations
+ julia-offsetarrays
+ julia-rotations
+ julia-staticarrays))
;(native-inputs
; `(("julia-imagemagick" ,julia-imagemagick)
; ("julia-referencetests" ,julia-referencetests)
(base32 "0l0jq0jnr9z3k431ni82xycq7mqapgxrbrx4yyk6lycvi41ipm4s"))))
(build-system julia-build-system)
(native-inputs
- `(("julia-colors" ,julia-colors)
- ("julia-fixedpointnumbers" ,julia-fixedpointnumbers)
- ("julia-mappedarrays" ,julia-mappedarrays)))
+ (list julia-colors
+ julia-fixedpointnumbers
+ julia-mappedarrays))
(home-page "https://github.com/JuliaArrays/IndirectArrays.jl")
(synopsis "Julia implementation of indexed arrays")
(description "An @code{IndirectArray} is one that encodes data using a
indexed images, sometimes called \"colormap images\" or \"paletted images.\"")
(license license:expat)))
+(define-public julia-infinity
+ (package
+ (name "julia-infinity")
+ (version "0.2.4")
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/cjdoris/Infinity.jl")
+ (commit (string-append "v" version))))
+ (file-name (git-file-name name version))
+ (sha256
+ (base32 "1941lwvrdjnrynigzixxin3chpg1ba6xplvcwc89x0f6z658hwmm"))))
+ (build-system julia-build-system)
+ (arguments
+ `(#:phases
+ (modify-phases %standard-phases
+ (add-after 'link-depot 'remove-timezones.jl
+ (lambda _
+ (substitute* "test/runtests.jl"
+ (("using TimeZones.*") "")
+ ((".*infextendedtime.*") ""))
+ #t)))))
+ (propagated-inputs
+ (list julia-requires))
+ (native-inputs
+ (list julia-compat))
+ (home-page "https://docs.juliahub.com/Infinity/")
+ (synopsis "Representation of infinity in Julia")
+ (description "This package provides representations for infinity and
+negative infinity in Julia.")
+ (license license:expat)))
+
(define-public julia-inifile
(package
(name "julia-inifile")
(sha256
(base32 "1236c20k388qlh7k74mhf7hkbn0vf7ss8b1rgh1a6aj0234ayfnc"))))
(build-system julia-build-system)
+ (arguments
+ `(#:parallel-tests? #f
+ ;; XXXX: Unexpected failures for i686, e.g.,
+ ;; Got exception outside of a @test
+ ;; OverflowError: 96908232 * 106943408 overflowed for type Int32
+ ;; Disable as stopgap.
+ #:tests? ,(not (target-x86-32?))))
(propagated-inputs
- `(("julia-axisalgorithms" ,julia-axisalgorithms)
- ("julia-offsetarrays" ,julia-offsetarrays)
- ("julia-ratios" ,julia-ratios)
- ("julia-requires" ,julia-requires)
- ("julia-staticarrays" ,julia-staticarrays)
- ("julia-woodburymatrices" ,julia-woodburymatrices)))
+ (list julia-axisalgorithms
+ julia-offsetarrays
+ julia-ratios
+ julia-requires
+ julia-staticarrays
+ julia-woodburymatrices))
(native-inputs
- `(("julia-dualnumbers" ,julia-dualnumbers)
- ("julia-forwarddiff" ,julia-forwarddiff)
- ("julia-offsetarrays" ,julia-offsetarrays)
- ("julia-unitful" ,julia-unitful)
- ("julia-zygote" ,julia-zygote)))
+ (list julia-dualnumbers
+ julia-forwarddiff
+ julia-offsetarrays
+ julia-unitful julia-zygote))
(home-page "https://github.com/JuliaMath/Interpolations.jl")
(synopsis "Continuous interpolation of discrete datasets")
(description "This package implements a variety of interpolation schemes for
(sha256
(base32 "0gsz89cd3iygbl5qr389k9vwpg7w1nk0s90g25nsmk34y9hifxag"))))
(build-system julia-build-system)
+ (arguments
+ `(#:phases
+ ,@(if (target-x86-32?)
+ '((modify-phases %standard-phases
+ (add-after 'unpack 'remove-failing-test-i686
+ (lambda _
+ (substitute* "test/runtests.jl"
+ ;; For some reason, the output is correct but the test
+ ;; is considered as failed:
+ ;; Expression: duration(ClosedInterval(A, B)) ≡ 60
+ ;; Evaluated: 60 ≡ 60
+ (("@test duration\\(ClosedInterval")
+ "@test_broken duration(ClosedInterval"))))))
+ '(%standard-phases))))
(propagated-inputs
- `(("julia-ellipsisnotation" ,julia-ellipsisnotation)))
+ (list julia-ellipsisnotation))
(native-inputs
- `(("julia-offsetarrays" ,julia-offsetarrays)))
+ (list 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
(base32 "1179z20yxnkyziip7gn26wr1g3k3ssl1ci7pig3khc900f62di46"))))
(build-system julia-build-system)
(native-inputs
- `(("julia-offsetarrays" ,julia-offsetarrays)))
+ (list julia-offsetarrays))
(home-page "https://github.com/mbauman/InvertedIndices.jl")
(synopsis "Index type that allows for inverted selections")
(description "This package just exports one type: the @code{InvertedIndex},
(file-name (git-file-name name version))
(sha256
(base32 "11334fcg2slpwcj0raxf457brhf7pxglgxc6cy8q58ggrpxqfqql"))))
- (arguments
- '(#:tests? #f)) ;require Documenter, not packaged yet
(build-system julia-build-system)
(propagated-inputs
- `(("julia-macrotools" ,julia-macrotools)))
+ (list julia-macrotools))
+ (native-inputs
+ (list julia-documenter))
(home-page "https://github.com/FluxML/IRTools.jl")
(synopsis "Simple and flexible IR format")
(description "This package provides a simple and flexible IR format,
"Common functional iterator patterns (formerly @code{Iterators.jl}).")
(license license:expat)))
+(define-public julia-jive
+ (package
+ (name "julia-jive")
+ (version "0.2.20")
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/wookay/Jive.jl")
+ (commit (string-append "v" version))))
+ (file-name (git-file-name name version))
+ (sha256
+ (base32 "0khwsdh8472jxcfi9lqw14l49sqlbsixql1jb4irnyajxkdjrcsf"))))
+ (build-system julia-build-system)
+ (home-page "https://github.com/wookay/Jive.jl")
+ (synopsis "Julia package to help with writing tests")
+ (description "@code{Jive.jl} is a Julia package to help with writing tests.")
+ (license license:expat)))
+
(define-public julia-json
(package
(name "julia-json")
(base32 "1f9k613kbknmp4fgjxvjaw4d5sfbx8a5hmcszmp1w9rqfqngjx9m"))))
(build-system julia-build-system)
(propagated-inputs
- `(("julia-datastructures" ,julia-datastructures)
- ("julia-fixedpointnumbers" ,julia-fixedpointnumbers)
- ("julia-parsers" ,julia-parsers)
- ("julia-offsetarrays" ,julia-offsetarrays)))
+ (list julia-datastructures
+ julia-fixedpointnumbers
+ julia-parsers
+ julia-offsetarrays))
(home-page "https://github.com/JuliaIO/JSON.jl")
(synopsis "JSON parsing and printing library for Julia")
(description "@code{JSON.jl} is a pure Julia module which supports parsing
(base32 "11z5maz7v50wd99id8z7838higza0cllh2amkdkrlskbri3v2f17"))))
(build-system julia-build-system)
(propagated-inputs
- `(("julia-parsers" ,julia-parsers)
- ("julia-structtypes" ,julia-structtypes)))
+ (list julia-parsers
+ 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-latexstrings
+ (package
+ (name "julia-latexstrings")
+ (version "1.2.1")
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/stevengj/LaTeXStrings.jl")
+ (commit (string-append "v" version))))
+ (file-name (git-file-name name version))
+ (sha256
+ (base32 "117z27krcf8fydgp6mb0pgn75r4gng9qs7v90qb4bqzsry3faadp"))))
+ (build-system julia-build-system)
+ (native-inputs
+ (list julia-documenter))
+ (home-page "https://github.com/stevengj/LaTeXStrings.jl")
+ (synopsis "Input and display of LaTeX equation strings")
+ (description "This is a small package to make it easier to type LaTeX
+equations in string literals in the Julia language.")
+ (license license:expat)))
+
(define-public julia-lazyarrays
(package
(name "julia-lazyarrays")
(sha256
(base32 "17rhlrmgfvdw8w62pg32ikr9j4xy2ylr7mx7ar0hnpzryv929rp5"))))
(build-system julia-build-system)
+ (arguments
+ `(#:phases
+ ,@(if (target-64bit?)
+ '(%standard-phases)
+ '((modify-phases %standard-phases
+ (add-after 'unpack 'fix-tests-int32-i686
+ (lambda _
+ (substitute* "test/multests.jl"
+ (("Int64") "Int32")))))))))
(propagated-inputs
- `(("julia-arraylayouts" ,julia-arraylayouts)
- ("julia-fillarrays" ,julia-fillarrays)
- ("julia-macrotools" ,julia-macrotools)
- ("julia-matrixfactorizations" ,julia-matrixfactorizations)
- ("julia-staticarrays" ,julia-staticarrays)))
+ (list julia-arraylayouts
+ julia-fillarrays
+ julia-macrotools
+ julia-matrixfactorizations
+ julia-staticarrays))
(native-inputs
- `(("julia-tracker" ,julia-tracker)))
+ (list 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
(base32 "0rvms3mmq8a1viqlyzdgs2ccddcy6j0c677dlb8m5nk6hkiwr16n"))))
(build-system julia-build-system)
(propagated-inputs
- `(("julia-docstringextensions" ,julia-docstringextensions)))
+ (list julia-docstringextensions))
(native-inputs
- `(("julia-offsetarrays" ,julia-offsetarrays)))
+ (list 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
(sha256
(base32 "0l5adird8m1cmnsxwhzi5hcr7q9bm1rf7a6018zc7kcn2yxdshy3"))))
(build-system julia-build-system)
+ (arguments
+ `(#:phases
+ ,@(if (target-64bit?)
+ '(%standard-phases)
+ '((modify-phases %standard-phases
+ (add-after 'unpack 'fix-tests-int32-i686
+ (lambda _
+ (substitute* "test/runtests.jl"
+ (("Int64") "Int32")))))))))
(propagated-inputs
- `(("julia-fixedpointnumbers" ,julia-fixedpointnumbers)))
+ (list julia-fixedpointnumbers))
(native-inputs
- `(("julia-colortypes" ,julia-colortypes)
- ("julia-fixedpointnumbers" ,julia-fixedpointnumbers)
- ("julia-offsetarrays" ,julia-offsetarrays)))
+ (list julia-colortypes
+ julia-fixedpointnumbers
+ julia-offsetarrays))
(home-page "https://github.com/JuliaArrays/MappedArrays.jl")
(synopsis "Lazy in-place transformations of arrays")
(description "This package implements \"lazy\" in-place elementwise
(arguments
`(#:phases
(modify-phases %standard-phases
- (add-after 'unpack 'skip-failing-test
+ (add-after 'link-depot 'skip-failing-test
(lambda _
;; Tests with math functions are hard.
(substitute* "test/test_ul.jl"
(("test String") "test_nowarn String"))
#t)))))
(propagated-inputs
- `(("julia-arraylayouts" ,julia-arraylayouts)))
+ (list julia-arraylayouts))
(home-page "https://github.com/JuliaMatrices/MatrixFactorizations.jl")
(synopsis "Julia package to contain non-standard matrix factorizations")
(description "A Julia package to contain non-standard matrix factorizations.
(substitute* "test/runtests.jl"
(("testhost =") "return #"))
#t)))))
- (propagated-inputs `(("julia-mbedtls-jll" ,julia-mbedtls-jll)))
+ (propagated-inputs
+ (list julia-mbedtls-jll))
(home-page "https://github.com/JuliaLang/MbedTLS.jl")
(synopsis "Apache's mbed TLS library wrapper")
(description "@code{MbedTLS.jl} provides a wrapper around the @code{mbed
(base32 "05p3f0gr4sv4maq8cix5fi8ldq0zagswqsd43xn6fhy046f936mz"))))
(build-system julia-build-system)
(propagated-inputs
- `(("julia-calculus" ,julia-calculus)
- ("julia-recipesbase" ,julia-recipesbase)
- ("julia-requires" ,julia-requires)))
+ (list julia-calculus
+ julia-recipesbase
+ julia-requires))
(native-inputs
- `(("julia-quadgk" ,julia-quadgk)
- ("julia-specialfunctions" ,julia-specialfunctions)
- ("julia-unitful" ,julia-unitful)))
+ (list julia-quadgk
+ julia-specialfunctions
+ julia-unitful))
(home-page "https://juliaphysics.github.io/Measurements.jl/stable/")
(synopsis "Error propagation calculator and library")
(description "@code{Measurements.jl} is an error propagation calculator and
resolving them into absolute units.")
(license license:expat)))
+(define-public julia-media
+ (package
+ (name "julia-media")
+ (version "0.5.0")
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/JunoLab/Media.jl")
+ (commit (string-append "v" version))))
+ (file-name (git-file-name name version))
+ (sha256
+ (base32 "05jq9j3vs8yfj2lwz3sh1vk5rha06xdcikp9s2q3dn316vryy6di"))))
+ (build-system julia-build-system)
+ ;; Package without Project.toml
+ (arguments
+ '(#:julia-package-name "Media"
+ #:julia-package-uuid "e89f7d12-3494-54d1-8411-f7d8b9ae1f27"))
+ (propagated-inputs
+ (list julia-macrotools))
+ (home-page "https://github.com/JunoLab/Media.jl")
+ (synopsis "Unified measure and coordinates types")
+ (description "This package provides a display system which enables the
+user handle multiple input/output devices and decide what media types get
+displayed where.")
+ (license license:expat)))
+
+(define-public julia-millboard
+ (package
+ (name "julia-millboard")
+ (version "0.2.5")
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/wookay/Millboard.jl")
+ (commit (string-append "v" version))))
+ (file-name (git-file-name name version))
+ (sha256
+ (base32 "0k9jqgp285qhckldvvsmfk6s69dcr8s74m2fijgm2vxjj2gqjs1n"))))
+ (build-system julia-build-system)
+ (native-inputs
+ (list julia-jive))
+ (home-page "https://github.com/wookay/Millboard.jl")
+ (synopsis "Displaying data in tables for Julia")
+ (description
+ "@code{Millboard.jl} provides a library for getting data in a tablized
+format to arrange into rows and columns of cells.")
+ (license license:expat)))
+
(define-public julia-missings
(package
(name "julia-missings")
(base32 "1k481rm5lahmjyh34j177d4n10svgr0wm7ps5m3ar3xx6nr26ad5"))))
(build-system julia-build-system)
(propagated-inputs
- `(("julia-dataapi" ,julia-dataapi)))
+ (list julia-dataapi))
(home-page "https://github.com/JuliaData/Missings.jl")
(synopsis "Additional missing value support for Julia")
(description "This package provides additional functionality for working
(base32 "0h1cd7cr4c4cnpqyj3180113gdbvcc047lqphp8a8gq5smp3c059"))))
(build-system julia-build-system)
(native-inputs
- `(("julia-datastructures" ,julia-datastructures)))
+ (list julia-datastructures))
(home-page "https://thautwarm.github.io/MLStyle.jl/latest/")
(synopsis "Julia functional programming infrastructures")
(description "This package provides consistent and extensible functional
(base32 "1cg2is83bjmrchmmxcgx57k8c9b9vlamrw38v4fdhbb6d4six5cg"))))
(build-system julia-build-system)
(propagated-inputs
- `(("julia-compat" ,julia-compat)
- ("julia-exprtools" ,julia-exprtools)))
+ (list julia-compat
+ julia-exprtools))
(home-page "https://github.com/invenia/Mocking.jl")
(synopsis "Overload Julia function calls")
(description "The purpose of this package is to allow Julia function calls
(arguments
`(#:tests? #f)) ; Cycle with ImageCore.jl
(propagated-inputs
- `(("julia-mappedarrays" ,julia-mappedarrays)
- ("julia-paddedviews" ,julia-paddedviews)
- ("julia-stackviews" ,julia-stackviews)))
+ (list julia-mappedarrays
+ julia-paddedviews
+ julia-stackviews))
;(native-inputs
; `(("julia-colorvectorspace" ,julia-colorvectorspace)
; ("julia-imagecore" ,julia-imagecore)))
(sha256
(base32 "1isyj8h4nx96cr6892d154v8pw1nhr7mjyz5bd6ffr2mkzb2bq4f"))))
(build-system julia-build-system)
+ (arguments
+ `(#:phases
+ ,@(if (target-x86-32?)
+ '((modify-phases %standard-phases
+ (add-after 'unpack 'remove-failing-test-i686
+ (lambda _
+ (substitute* "test/utilities.jl"
+ ;; Non-deterministic returned value, e.g.,
+ ;; Expression: n == @allocated(f())
+ ;; Evaluated: 240 == 120
+ ;; and for some other values:
+ ;; Got correct result, please change to @test
+ ;; so @test_broken is not enough.
+ (("@test n == @allocated f\\(\\)")
+ " "))))))
+ '(%standard-phases))))
(propagated-inputs
- `(("julia-offsetarrays" ,julia-offsetarrays)))
+ (list 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:
(base32 "0n8qh5a2ghjx1j70zxn0hmh8gzpa46kmjg8di879y9974bfk0f98"))))
(build-system julia-build-system)
(propagated-inputs
- `(("julia-diffresults" ,julia-diffresults)
- ("julia-finitediff" ,julia-finitediff)
- ("julia-forwarddiff" ,julia-forwarddiff)))
+ (list julia-diffresults
+ julia-finitediff
+ julia-forwarddiff))
(native-inputs
- `(("julia-optimtestproblems" ,julia-optimtestproblems)
- ("julia-recursivearraytools" ,julia-recursivearraytools)))
+ (list julia-optimtestproblems
+ 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,
(arguments
`(#:phases
(modify-phases %standard-phases
- (add-after 'unpack 'skip-cuda-tests
+ (add-after 'link-depot 'skip-cuda-tests
(lambda _
(substitute* "test/runtests.jl"
(("using CUDA") "")
(("&& CUDA\\.functional\\(\\)") ""))
(setenv "NNLIB_TEST_CUDA" "false"))))))
(propagated-inputs
- `(("julia-adapt" ,julia-adapt)
- ("julia-chainrulescore" ,julia-chainrulescore)
- ("julia-requires" ,julia-requires)))
+ (list julia-adapt
+ julia-chainrulescore
+ julia-requires))
(native-inputs
- `(("julia-chainrulestestutils" ,julia-chainrulestestutils)
- ("julia-stablerngs" ,julia-stablerngs)
- ("julia-zygote" ,julia-zygote)))
+ (list julia-chainrulestestutils
+ julia-stablerngs
+ 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
(base32 "10h47x5ws42pkqjccimaz0yxfvz41w0yazq6inamfk4lg5g2g3d9"))))
(build-system julia-build-system)
(arguments
- `(#:julia-package-name "OptimTestProblems"))
+ `(#:julia-package-name "OptimTestProblems"
+ #:julia-package-uuid "cec144fc-5a64-5bc6-99fb-dde8f63e154c"))
(home-page "https://github.com/JuliaNLSolvers/OptimTestProblems.jl")
(synopsis "Collection of optimization test problems")
(description "The purpose of this package is to provide test problems for
(base32 "0j5a8ar8yc0j9h87gwfyrcqm23wpyv5yv5gn8vzilpg4vr0fiasc"))))
(build-system julia-build-system)
(propagated-inputs
- `(("julia-adapt" ,julia-adapt)))
+ (list julia-adapt))
;; CatIndices depends on OffsetArrays, introducing a recursive dependency
(arguments '(#:tests? #f))
(home-page "https://juliaarrays.github.io/OffsetArrays.jl/stable/")
(sha256
(base32 "0ran2vj6ahlzib0g77y7g0jhavy3k9s2mqq23ybpgp9z677wf26h"))))
(build-system julia-build-system)
- (arguments
- '(#:tests? #f)) ;require Documenter, not packaged yet
(propagated-inputs
- `(("julia-offsetarrays" ,julia-offsetarrays)))
+ (list julia-offsetarrays))
+ (native-inputs
+ (list julia-documenter))
(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,
(base32 "0b8lawi7kcws4axfsdf023gyxca15irl648ciyi1kw3wghz3pfi2"))))
(build-system julia-build-system)
(propagated-inputs
- `(("julia-orderedcollections" ,julia-orderedcollections)
- ("julia-unpack" ,julia-unpack)))
+ (list julia-orderedcollections
+ julia-unpack))
(home-page "https://github.com/mauro3/Parameters.jl")
(synopsis "Numerical-model parameter helpers")
(description "This package contains types with default field values, keyword
(base32 "1fd27w9z1vhz0d1bzrs5vcavpb5r5jviyh27d9c4ka37phz4xvmh"))))
(build-system julia-build-system)
(propagated-inputs
- `(("julia-plotutils" ,julia-plotutils)
- ("julia-requires" ,julia-requires)))
+ (list julia-plotutils
+ julia-requires))
(home-page "https://github.com/JuliaPlots/PlotThemes.jl")
(synopsis "Themes for the Julia plotting package Plots.jl")
(description
(base32 "12aw5gkkcfhpczv2w510k65w1j0hjnh825ihimi223v8plsi5105"))))
(build-system julia-build-system)
(propagated-inputs
- `(("julia-colors" ,julia-colors)
- ("julia-colorschemes" ,julia-colorschemes)
- ("julia-reexport" ,julia-reexport)))
+ (list julia-colors
+ julia-colorschemes
+ julia-reexport))
(native-inputs
- `(("julia-stablerngs" ,julia-stablerngs)))
+ (list julia-stablerngs))
(home-page "https://github.com/JuliaPlots/PlotUtils.jl")
(synopsis "Helper algorithms for building plotting components")
(description "This package contains generic helper algorithms for building
(base32 "0qdwvf1p5z6z0q4s4hn85ysd8wq47zy6hlzddc5ijvhk86ccqlrr"))))
(build-system julia-build-system)
(propagated-inputs
- `(("julia-dataapi" ,julia-dataapi)))
+ (list julia-dataapi))
(home-page "https://github.com/JuliaData/PooledArrays.jl")
(synopsis "Pooled representation of arrays in Julia")
(description "This package provides a pooled representation of arrays for
(base32 "1wxy6ak7f3hvibcgc8q88cgkf9zvi649mmjy1zlkx1qk80hgvz23"))))
(build-system julia-build-system)
(native-inputs
- `(("julia-forwarddiff" ,julia-forwarddiff)
- ("julia-reversediff" ,julia-reversediff)))
+ (list julia-forwarddiff
+ 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
(arguments
`(#:phases
(modify-phases %standard-phases
- (add-after 'unpack 'skip-color-tests
+ (add-after 'link-depot 'skip-color-tests
(lambda _
(substitute* "test/text_backend.jl"
((".*colors\\.jl.*") ""))
#t)))))
(propagated-inputs
- `(("julia-crayons" ,julia-crayons)
- ("julia-formatting" ,julia-formatting)
- ("julia-reexport" ,julia-reexport)
- ("julia-tables" ,julia-tables)))
+ (list julia-crayons
+ julia-formatting
+ julia-reexport
+ julia-tables))
(home-page "https://github.com/ronisbr/PrettyTables.jl")
(synopsis "Print data in formatted tables")
(description "This package has the purpose to print data in matrices in a
(define-public julia-pycall
(package
(name "julia-pycall")
- (version "1.92.3")
+ (version "1.92.5")
(source
(origin
(method git-fetch)
(file-name (git-file-name name version))
(sha256
(base32
- "07r99ni6nkxpyrp3wsb5qg4jxz7i2r08dyqbiffy2zm3g0bn88jq"))))
+ "1fj5d1ihnhnm0pl4hbx6hcd2bpdyhm8jiaqah2axsbd069j70saf"))))
(build-system julia-build-system)
(arguments
`(#:imported-modules ((guix build python-build-system)
((guix build python-build-system) #:prefix python:))
#:phases
(modify-phases %standard-phases
- (add-after 'unpack 'remove-conda
+ (add-after 'link-depot 'remove-conda
(lambda _
(substitute* "Project.toml"
((".*Conda.*") ""))
(substitute* "deps/depsutils.jl"
(("Conda.PYTHONDIR") "\"/\""))
#t))
- (add-after 'unpack 'set-python
+ (add-after 'link-depot 'set-python
(lambda* (#:key inputs outputs #:allow-other-keys)
(let ((python (assoc-ref inputs "python")))
(setenv "PYCALL_JL_RUNTIME_PYTHON"
(setenv "JULIA_PKGEVAL" "true")
#t)))))
(propagated-inputs
- `(("julia-macrotools" ,julia-macrotools)
- ("julia-versionparsing" ,julia-versionparsing)))
+ (list julia-macrotools
+ julia-versionparsing))
(inputs
- `(("python" ,python)))
+ (list python))
(native-inputs
- `(("python-numpy" ,python-numpy)))
+ (list python-numpy))
(home-page "https://github.com/JuliaPy/PyCall.jl")
(synopsis "Call Python functions from the Julia language")
(description "This package provides the ability to directly call and fully
share large data structures between Julia and Python without copying them.")
(license license:expat)))
+(define-public julia-pyplot
+ (package
+ (name "julia-pyplot")
+ (version "2.10.0")
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/JuliaPy/PyPlot.jl")
+ (commit (string-append "v" version))))
+ (file-name (git-file-name name version))
+ (sha256
+ (base32 "007zs0imfgs69f30pp2a3rc93kl0qiq7qjx6ig35z4wzkmps4skd"))))
+ (build-system julia-build-system)
+ (propagated-inputs
+ (list julia-colors
+ julia-latexstrings
+ julia-pycall
+ julia-versionparsing
+ ;; python-matplotlib is expected to be available at runtime.
+ python-matplotlib))
+ (home-page "https://github.com/JuliaPy/PyPlot.jl")
+ (synopsis "Plotting for Julia based on matplotlib.pyplot")
+ (description "This package provides a Julia interface to the Matplotlib
+plotting library from Python, and specifically to the @code{matplotlib.pyplot}
+module. PyPlot uses the Julia PyCall package to call Matplotlib directly from
+Julia with little or no overhead (arrays are passed without making a copy).")
+ (license license:expat)))
+
(define-public julia-quadgk
(package
(name "julia-quadgk")
(base32 "1hy0629yai6xflgxaflk9764lzr1lzhlghimxk1aqi212q9c6n33"))))
(build-system julia-build-system)
(propagated-inputs
- `(("julia-datastructures" ,julia-datastructures)))
+ (list julia-datastructures))
(home-page "https://github.com/JuliaMath/QuadGK.jl")
(synopsis "Adaptive 1d numerical Gauss–Kronrod integration")
(description "This package provides support for one-dimensional numerical
(arguments
`(#:phases
(modify-phases %standard-phases
- (add-after 'unpack 'hardcode-libmath-location
+ (add-after 'link-depot 'hardcode-libmath-location
(lambda* (#:key inputs #:allow-other-keys)
(let ((gcclib (assoc-ref inputs "gcc:lib")))
(substitute* "src/Quadmath.jl"
(("libquadmath.so.0" lib) (string-append gcclib "/lib/" lib)))
#t))))))
(propagated-inputs
- `(("julia-requires" ,julia-requires)))
+ (list julia-requires))
(inputs
`(("gcc:lib" ,gcc "lib")))
(native-inputs
- `(("julia-specialfunctions" ,julia-specialfunctions)))
+ (list julia-specialfunctions))
(home-page "https://github.com/JuliaMath/Quadmath.jl")
(synopsis "Float128 and libquadmath for the Julia language")
(description "This is a Julia interface to @code{libquadmath}, providing a
(base32 "1zhynyvchc50hywws2jznpkwydr3njh8cv84d2ylyabhcwwmil9s"))))
(build-system julia-build-system)
(propagated-inputs
- `(("julia-dualnumbers" ,julia-dualnumbers)))
+ (list 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
(base32 "06zm4cbn3x49lbpgshhdfvvmgz066qkc8q0d57igm5p8bcp6js22"))))
(build-system julia-build-system)
(propagated-inputs
- `(("julia-datastructures" ,julia-datastructures)
- ("julia-iteratorinterfaceextensions" ,julia-iteratorinterfaceextensions)
- ("julia-tableshowutils" ,julia-tableshowutils)))
+ (list julia-datastructures
+ julia-iteratorinterfaceextensions
+ julia-tableshowutils))
(home-page "https://github.com/queryverse/QueryOperators.jl")
(synopsis "Query operators for Julia")
(description "This package contains the underlying query operators that are
(arguments
`(#:tests? #f)) ; Cycle with Plots.jl.
(propagated-inputs
- `(("julia-nanmath" ,julia-nanmath)
- ("julia-plotutils" ,julia-plotutils)
- ("julia-recipesbase" ,julia-recipesbase)))
+ (list julia-nanmath
+ julia-plotutils
+ 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
(arguments
`(#:tests? #f)) ; Cycle with OrdinaryDiffEq.jl.
(propagated-inputs
- `(("julia-arrayinterface" ,julia-arrayinterface)
- ("julia-chainrulescore" ,julia-chainrulescore)
- ("julia-docstringextensions" ,julia-docstringextensions)
- ("julia-recipesbase" ,julia-recipesbase)
- ("julia-requires" ,julia-requires)
- ("julia-staticarrays" ,julia-staticarrays)
- ("julia-zygoterules" ,julia-zygoterules)))
+ (list julia-arrayinterface
+ julia-chainrulescore
+ julia-docstringextensions
+ julia-recipesbase
+ julia-requires
+ julia-staticarrays
+ julia-zygoterules))
;(native-inputs
; `(("julia-forwarddiff" ,julia-forwarddiff)
; ("julia-nlsolve" ,julia-nlsolve)
(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)))
+ (list julia-deepdiffs
+ julia-distances
+ julia-fileio
+ julia-imagecore
+ julia-imageinterminal))
;(native-inputs
; `(("julia-csvfiles" ,julia-csvfiles)
; ("julia-dataframes" ,julia-dataframes)
(sha256
(base32 "03hyfy7c0ma45b0y756j76awi3az2ii4bz4s8cxm3xw9yy1z7b01"))))
(build-system julia-build-system)
+ (arguments
+ `(#:parallel-tests? #f))
(inputs ;required for test
- `(("julia-example" ,julia-example)))
+ (list julia-example))
(propagated-inputs
- `(("julia-colors" ,julia-colors)))
+ (list julia-colors))
(home-page "https://github.com/JuliaPackaging/Requires.jl/")
(synopsis "Faster package loader")
(description "This package make loading packages faster, maybe. It
(sha256
(base32 "1wrr6sqj2xl9grkvdp88rw3manxy9vbx28zq2wssya5ns1xabsnl"))))
(build-system julia-build-system)
+ (arguments
+ ;; XXXX: Test suite failing for i686, e.g.,
+ ;; Expression: hash(tr_float, hash(1)) === hash(v_float, hash(1))
+ ;; MethodError: no method matching decompose(::ReverseDiff.TrackedReal{Float64, Float64, Nothing})
+ ;; Disable as stopgap.
+ `(#:tests? ,(not (target-x86-32?))))
(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)))
+ (list julia-diffresults
+ julia-diffrules
+ julia-forwarddiff
+ julia-functionwrappers
+ julia-macrotools
+ julia-nanmath
+ julia-specialfunctions
+ julia-staticarrays))
(native-inputs
- `(("julia-difftests" ,julia-difftests)
- ("julia-fillarrays" ,julia-fillarrays)))
+ (list julia-difftests
+ 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
(base32 "01wwqbdmj61yiz7rkmams4xg7gb9hbmg325173846ky4b9x1wb19"))))
(build-system julia-build-system)
(propagated-inputs
- `(("julia-staticarrays" ,julia-staticarrays)))
+ (list julia-staticarrays))
(native-inputs
- `(("julia-benchmarktools" ,julia-benchmarktools)
- ("julia-forwarddiff" ,julia-forwarddiff)
- ("julia-unitful" ,julia-unitful)))
+ (list julia-benchmarktools
+ julia-forwarddiff
+ 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
(base32 "1fb1dfdmiw2ggx60hf70954xlps0r48fcb3k3dvxynlz7ylphp96"))))
(build-system julia-build-system)
(arguments
- `(#:julia-package-name "SafeTestsets"))
+ `(#:julia-package-name "SafeTestsets"
+ #:julia-package-uuid "1bc83da4-3b8d-516f-aca4-4fe02f6d838f"))
(native-inputs
- `(("julia-staticarrays" ,julia-staticarrays)))
+ (list julia-staticarrays))
(home-page "https://github.com/YingboMa/SafeTestsets.jl")
(synopsis "Julia's testset in a module")
(description "This package contains the testset from Julia, packaged into
(base32 "0y7kkkj717h5cj659ssry89i5r64symr6pvhr6vv4qmaxrnjxj92"))))
(build-system julia-build-system)
(propagated-inputs
- `(("julia-libsass-jll" ,julia-libsass-jll)))
+ (list julia-libsass-jll))
(home-page "https://github.com/piever/Sass.jl")
(synopsis "Compile scss and sass file to css")
(description "This package provides a simple Julian API to use the
(base32 "1qvmkqcvhc2nilvkk36szccxdlcv9ls2i0ksxgl2yfjr3b3qlr05"))))
(build-system julia-build-system)
(propagated-inputs
- `(("julia-macrotools" ,julia-macrotools)))
+ (list 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.
types are fixed after creation.")
(license license:expat)))
+(define-public julia-softglobalscope
+ (package
+ (name "julia-softglobalscope")
+ (version "1.1.0")
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/stevengj/SoftGlobalScope.jl")
+ (commit (string-append "v" version))))
+ (file-name (git-file-name name version))
+ (sha256
+ (base32 "1n3l0al1vw5jpb4k9a29a71666cdb617nmiqg34wcmyfzrxpvv39"))))
+ (build-system julia-build-system)
+ (home-page "https://github.com/stevengj/SoftGlobalScope.jl")
+ (synopsis "Utilities for soft global scope in interactive Julia environments")
+ (description
+ "SoftGlobalScope is a package for the Julia language that simplifies the
+variable scoping rules for code in global scope. It is intended for interactive
+shells to make it easier to work interactively with Julia, especially for
+beginners.")
+ (license license:expat)))
+
(define-public julia-sortingalgorithms
(package
(name "julia-sortingalgorithms")
(arguments
`(#:tests? #f)) ; cycle with StatsBase.jl
(propagated-inputs
- `(("julia-datastructures" ,julia-datastructures)))
+ (list julia-datastructures))
;(native-inputs
; `(("julia-statsbase" ,julia-statsbase)))
(home-page "https://github.com/JuliaCollections/SortingAlgorithms.jl")
(base32 "0nfpnglx7zl9g20w2mgfkg17hcw9ri0shaq2rwplj0ij5pwz8yf0"))))
(build-system julia-build-system)
(inputs
- `(("julia-chainrulestestutils" ,julia-chainrulestestutils)))
+ (list julia-chainrulestestutils))
(propagated-inputs
- `(("julia-chainrulescore" ,julia-chainrulescore)
- ("julia-logexpfunctions" ,julia-logexpfunctions)
- ("julia-openspecfun-jll" ,julia-openspecfun-jll)))
+ (list julia-chainrulescore
+ julia-logexpfunctions
+ julia-openspecfun-jll))
(home-page "https://github.com/JuliaMath/SpecialFunctions.jl")
(synopsis "Special mathematical functions")
(description "This package provides special mathematical functions,
(base32 "1qzaqvk57b0s5krzn8bxkzmr5kz6hi9dm3jbf2sl7z4vznsgbn9x"))))
(build-system julia-build-system)
(propagated-inputs
- `(("julia-dictionaries" ,julia-dictionaries)
- ("julia-indexing" ,julia-indexing)))
+ (list julia-dictionaries
+ julia-indexing))
(home-page "https://github.com/JuliaData/SplitApplyCombine.jl")
(synopsis "Split-apply-combine strategies for Julia")
(description "@code{SplitApplyCombine.jl} provides high-level, generic tools
(base32 "1fwiaxdpx1z9dli3jr8kyraych0jbdiny3qklynf0r13px25r6i7"))))
(build-system julia-build-system)
(arguments
- `(#:tests? #f ; Documenter.jl not packaged yet
- #:phases
+ `(#:phases
(modify-phases %standard-phases
- (add-after 'unpack 'skip-doctest
+ (add-after 'link-depot '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)))
+ (list julia-offsetarrays))
+ (native-inputs
+ (list julia-aqua
+ julia-documenter))
(home-page "https://github.com/JuliaArrays/StackViews.jl")
(synopsis "No more catcat")
(description "StackViews provides only one array type: @code{StackView}.
(base32 "19k7h47zhz3zz28i0l4b3cc0r07pzp8kf35z0yammpy361b644l2"))))
(build-system julia-build-system)
(propagated-inputs
- `(("julia-ifelse" ,julia-ifelse)))
+ (list julia-ifelse))
(native-inputs
- `(("julia-aqua" ,julia-aqua)))
+ (list julia-aqua))
(home-page "https://github.com/SciML/Static.jl")
(synopsis "Static types useful for dispatch and generated functions")
(description "Static.jl defines a limited set of statically parameterized
(base32 "041mijzgzm8r61a3gwspr2wcxjikqksvj2rbnl4gmcy41alqmx79"))))
(build-system julia-build-system)
(inputs
- `(("julia-benchmarktools" ,julia-benchmarktools)))
+ (list julia-benchmarktools))
(home-page "https://github.com/JuliaArrays/StaticArrays.jl")
(synopsis "Statically sized arrays")
(description "This package provides a framework for implementing
(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)))
+ (list julia-dataapi
+ julia-datastructures
+ julia-missings
+ julia-sortingalgorithms
+ julia-statsapi))
(native-inputs
- `(("julia-stablerngs" ,julia-stablerngs)))
+ (list 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
(base32 "0n5707wplbibzhhv1xmshvc025d7xk6mnikclc3hvq5cdc0gy9f7"))))
(build-system julia-build-system)
(propagated-inputs
- `(("julia-distances" ,julia-distances)))
+ (list julia-distances))
(home-page "https://github.com/matthieugomez/StringDistances.jl")
(synopsis "String Distances in Julia")
(description "This package provides string distances in Julia. Distances
applied to any distance.")
(license license:expat)))
+(define-public julia-structarrays
+ (package
+ (name "julia-structarrays")
+ (version "0.6.3")
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/JuliaArrays/StructArrays.jl")
+ (commit (string-append "v" version))))
+ (file-name (git-file-name name version))
+ (sha256
+ (base32 "0rjcpyjwzg70n87q5r9c5i1qzigavncslxssm3rk5a3y549py56v"))))
+ (build-system julia-build-system)
+ (arguments
+ `(#:phases
+ ,@(if (target-64bit?)
+ '(%standard-phases)
+ '((modify-phases %standard-phases
+ (add-after 'unpack 'fix-tests-int32-i686
+ (lambda _
+ (substitute* '("src/utils.jl"
+ "test/runtests.jl")
+ (("Int64") "Int32")))))))))
+ (propagated-inputs
+ (list julia-dataapi
+ julia-staticarrays
+ julia-tables))
+ (native-inputs
+ (list julia-documenter
+ julia-offsetarrays
+ julia-pooledarrays
+ julia-typedtables
+ julia-weakrefstrings))
+ (home-page "https://github.com/JuliaArrays/StructArrays.jl")
+ (synopsis "Efficient implementation of struct arrays in Julia")
+ (description "This package introduces the type @code{StructArray} which is
+an @code{AbstractArray} whose elements are @code{struct} (for example
+@code{NamedTuples}, or @code{ComplexF64}, or a custom user defined
+@code{struct}). While a @code{StructArray} iterates @code{structs}, the layout
+is column based (meaning each field of the @code{struct} is stored in a separate
+@code{Array}).")
+ (license license:expat)))
+
(define-public julia-structtypes
(package
(name "julia-structtypes")
(base32 "1sqqagzqvav8b1rv5ywwbgy9ixvlmipq95fkwfwn0m8769i8jwzb"))))
(build-system julia-build-system)
(propagated-inputs
- `(("julia-dataapi" ,julia-dataapi)
- ("julia-datavalueinterfaces" ,julia-datavalueinterfaces)
- ("julia-iteratorinterfaceextensions" ,julia-iteratorinterfaceextensions)
- ("julia-tabletraits" ,julia-tabletraits)))
+ (list julia-dataapi
+ julia-datavalueinterfaces
+ julia-iteratorinterfaceextensions
+ julia-tabletraits))
(native-inputs
- `(("julia-datavalues" ,julia-datavalues)
- ("julia-queryoperators" ,julia-queryoperators)))
+ (list julia-datavalues
+ julia-queryoperators))
(home-page "https://github.com/JuliaData/Tables.jl")
(synopsis "Interface for tables in Julia")
(description "The @code{Tables.jl} package provides simple, yet powerful
(base32 "0gp3hpj3jvzfhkp9r345vfic2j2n2s60729wv38hwn75csp74cg5"))))
(build-system julia-build-system)
(propagated-inputs
- `(("julia-datavalues" ,julia-datavalues)
- ("julia-json" ,julia-json)))
+ (list julia-datavalues
+ julia-json))
(home-page "https://github.com/queryverse/TableShowUtils.jl")
(synopsis "Implement show for TableTraits.jl types")
(description "This package provides some common helper functions that make
(base32 "08ssb2630wm6j8f2qa985mn2vfibfm5kjcn4ayl2qkhfcyp8daw4"))))
(build-system julia-build-system)
(propagated-inputs
- `(("julia-iteratorinterfaceextensions" ,julia-iteratorinterfaceextensions)))
+ (list julia-iteratorinterfaceextensions))
(home-page "https://github.com/queryverse/TableTraits.jl")
(synopsis "Traits for Julia tables")
(description "TableTraits defines a generic interface for tabular data.")
(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)))
+ (list julia-axisarrays
+ julia-colortypes
+ julia-fileio
+ julia-offsetarrays
+ julia-stringdistances))
;(native-inputs
; `(("julia-colors" ,julia-colors)
; ("julia-fixedpointnumbers" ,julia-fixedpointnumbers)
(patches (search-patches "julia-tracker-16-compat.patch"))))
(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)))
+ (list julia-adapt
+ julia-diffrules
+ julia-forwarddiff
+ julia-macrotools
+ julia-nanmath
+ julia-nnlib
+ julia-requires
+ julia-specialfunctions))
(native-inputs
- `(("julia-pdmats" ,julia-pdmats)))
+ (list 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-transcodingstreams
+ (package
+ (name "julia-transcodingstreams")
+ (version "0.9.6")
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/JuliaIO/TranscodingStreams.jl")
+ (commit (string-append "v" version))))
+ (file-name (git-file-name name version))
+ (sha256
+ (base32 "1w3klii293caqiclfh28jggv7f53xclm9fr6xmw38brwrn1hjb48"))))
+ (build-system julia-build-system)
+ (arguments
+ `(#:tests? #f)) ; Circular dependency with various codecs.
+ (home-page "https://github.com/JuliaIO/TranscodingStreams.jl")
+ (synopsis "Fast I/O transcoding data streams")
+ (description "This package provides tools for transcoding data streams
+which are:
+@itemize
+@item fast: small overhead and specialized methods
+@item consistent: basic I/O operations work as expected
+@item generic: support any I/O objects like files, buffers, pipes, etc.
+@item extensible: easy definition for new codec to transcode data
+@end itemize")
+ (license license:expat)))
+
(define-public julia-typedtables
(package
(name "julia-typedtables")
(base32 "0nk6zhqvl2r8yhjdhb59kxq0srd3vy4ysg4d8rszj9a43dnn3w3i"))))
(build-system julia-build-system)
(propagated-inputs
- `(("julia-adapt" ,julia-adapt)
- ("julia-splitapplycombine" ,julia-splitapplycombine)
- ("julia-tables" ,julia-tables)))
+ (list julia-adapt
+ julia-splitapplycombine
+ julia-tables))
(home-page "https://github.com/JuliaData/TypedTables.jl")
(synopsis "Column-based storage for data analysis in Julia")
(description "@code{TypedTables.jl} provides two column-based storage
(build-system julia-build-system)
(arguments
'(#:julia-package-name "URIs" ;required to run tests
+ #:julia-package-uuid "5c2747f8-b7ea-4ff2-ba2e-563bfd36b1d4"
#:phases
(modify-phases %standard-phases
(add-before 'check 'change-dir
(lambda* (#:key source outputs #:allow-other-keys)
(let ((out (assoc-ref outputs "out")))
(chdir
- (string-append out "/share/julia/packages/URIs/test")))
+ (string-append out "/share/julia/loadpath/URIs/test")))
#t)))))
;; required for tests
- (inputs `(("julia-json" ,julia-json)))
+ (inputs (list julia-json))
(home-page "https://github.com/JuliaWeb/URIs.jl")
(synopsis "URI parsing in Julia")
(description "@code{URIs.jl} is a Julia package that allows parsing and
(sha256
(base32 "10qwscd15dnmvx116dwvg99m7kmwgmj5ahdkq7psiq48lcc554gq"))))
(build-system julia-build-system)
+ (arguments
+ `(#:parallel-tests? #f))
(propagated-inputs
- `(("julia-constructionbase" ,julia-constructionbase)))
+ (list julia-constructionbase))
(home-page "https://painterqubits.github.io/Unitful.jl/stable/")
(synopsis "Physical units in Julia")
(description "This package supports SI units and also many other unit
(base32 "14h1vdnc3rx87w6v2rr59lgb4kai2hd1wzqpxhmzsi8karg2z219"))))
(build-system julia-build-system)
(propagated-inputs
- `(("julia-dataapi" ,julia-dataapi)
- ("julia-parsers" ,julia-parsers)))
+ (list julia-dataapi
+ 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
(sha256
(base32 "04yykivi8zrbryxlmb0p5xa6lma8iq22r5s863117dnnqj5gaffd"))))
(build-system julia-build-system)
+ (arguments
+ `(#:phases
+ ,@(if (target-x86-32?)
+ '((modify-phases %standard-phases
+ (add-after 'unpack 'remove-failing-test-i686
+ (lambda _
+ (substitute* "test/woodbury.jl"
+ (("@test logdet\\(W\\)")
+ "@test_broken logdet(W)"))))))
+ '(%standard-phases))))
(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
"15bm3ki5mb9nvqs2byznrryq0bilnjcvsfy3k05hxhk9vapilw7k"))))
(build-system julia-build-system)
(propagated-inputs
- `(("julia-zlib-jll" ,julia-zlib-jll)))
+ (list julia-zlib-jll))
(home-page "https://github.com/fhs/ZipFile.jl")
(synopsis "Read/Write ZIP archives in Julia")
(description "This module provides support for reading and writing ZIP
(base32 "07i2mf6rr5b8i6l82qgwl5arsb5pwyyzyfasgnszhdqllk9501bs"))))
(build-system julia-build-system)
(propagated-inputs
- `(("julia-macrotools" ,julia-macrotools)))
+ (list julia-macrotools))
(home-page "https://github.com/FluxML/ZygoteRules.jl")
(synopsis "Add minimal custom gradients to Zygote")
(description "Minimal package which enables to add custom gradients to
(arguments
`(#:tests? #f)) ;require CUDA, not packaged yet
(propagated-inputs
- `(("julia-abstractffs" ,julia-abstractffts)
- ("julia-chainrules" ,julia-chainrules)
- ("julia-diffrules" ,julia-diffrules)
- ("julia-fillarrays" ,julia-fillarrays)
- ("julia-forwarddiff" ,julia-forwarddiff)
- ("julia-irtools" ,julia-irtools)
- ("julia-macrotools" ,julia-macrotools)
- ("julia-nanmath" ,julia-nanmath)
- ("julia-requires" ,julia-requires)
- ("julia-specialfunctions" ,julia-specialfunctions)
- ("julia-zygote-rules" ,julia-zygoterules)))
+ (list julia-abstractffts
+ julia-chainrules
+ julia-diffrules
+ julia-fillarrays
+ julia-forwarddiff
+ julia-irtools
+ julia-macrotools
+ julia-nanmath
+ julia-requires
+ julia-specialfunctions
+ julia-zygoterules))
(home-page "https://fluxml.ai/Zygote.jl")
(synopsis "Automatic differentiation in Julia")
(description "Zygote provides source-to-source automatic
HCoop / jackhill / guix / guix.git / blobdiff