2049 lines
79 KiB
Scheme
2049 lines
79 KiB
Scheme
;;; GNU Guix --- Functional package management for GNU
|
|
;;; Copyright © 2019 Nicolò Balzarotti <nicolo@nixo.xyz>
|
|
;;;
|
|
;;; This file is part of GNU Guix.
|
|
;;;
|
|
;;; GNU Guix is free software; you can redistribute it and/or modify it
|
|
;;; under the terms of the GNU General Public License as published by
|
|
;;; the Free Software Foundation; either version 3 of the License, or (at
|
|
;;; your option) any later version.
|
|
;;;
|
|
;;; GNU Guix is distributed in the hope that it will be useful, but
|
|
;;; WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
;;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
;;; GNU General Public License for more details.
|
|
;;;
|
|
;;; You should have received a copy of the GNU General Public License
|
|
;;; along with GNU Guix. If not, see <http://www.gnu.org/licenses/>.
|
|
|
|
(define-module (gnu packages julia-xyz)
|
|
#:use-module (guix build-system julia)
|
|
#:use-module (guix git-download)
|
|
#:use-module ((guix licenses) #:prefix license:)
|
|
#:use-module (guix packages)
|
|
#:use-module (gnu packages compression)
|
|
#:use-module (gnu packages graphics)
|
|
#:use-module (gnu packages maths)
|
|
#:use-module (gnu packages video)
|
|
#:use-module (gnu packages xml)
|
|
#:use-module (gnu packages tls))
|
|
|
|
(define-public julia-uriparser
|
|
(package
|
|
(name "julia-uriparser")
|
|
(version "0.4.0")
|
|
(source
|
|
(origin
|
|
(method git-fetch)
|
|
(uri (git-reference
|
|
(url "https://github.com/JuliaWeb/URIParser.jl")
|
|
(commit (string-append "v" version))))
|
|
(file-name "URIParser")
|
|
(sha256
|
|
(base32 "1i45wza6jh9k7x8jrqiil6k2yb81hdzm3s0zqhzy3y2sby66p44p"))))
|
|
(build-system julia-build-system)
|
|
(home-page "https://github.com/JuliaWeb/URIParser.jl")
|
|
(synopsis "Provides URI parsing according to RFC 3986")
|
|
(description "@code{URIParser} is a julia package that provides URI
|
|
parsing according to RFC 3986.")
|
|
(license license:expat)))
|
|
|
|
(define-public julia-inifile
|
|
(package
|
|
(name "julia-inifile")
|
|
(version "0.5.0")
|
|
(source
|
|
(origin
|
|
(method git-fetch)
|
|
(uri (git-reference
|
|
(url "https://github.com/JuliaIO/IniFile.jl")
|
|
(commit (string-append "v" version))))
|
|
(file-name "IniFile")
|
|
(sha256
|
|
(base32 "19cn41w04hikrqdzlxhrgf21rfqhkvj9x1zvwh3yz9hqbf350xs9"))))
|
|
(arguments
|
|
`(#:phases
|
|
(modify-phases %standard-phases
|
|
(add-before 'precompile 'fix-toml
|
|
(lambda* (#:key outputs source #:allow-other-keys)
|
|
(julia-create-package-toml
|
|
outputs source
|
|
"IniFile" "83e8ac13-25f8-5344-8a64-a9f2b223428f" "0.5.0"
|
|
'())
|
|
#t)))))
|
|
(build-system julia-build-system)
|
|
(home-page "https://github.com/JuliaIO/IniFile.jl")
|
|
(synopsis "Reading Windows-style INI files")
|
|
(description "@code{julia-inifile} is a julia package that defines an
|
|
Inifile type that allows to interface with @file{.ini} files.")
|
|
(license license:expat)))
|
|
|
|
(define-public julia-compat
|
|
(package
|
|
(name "julia-compat")
|
|
(version "2.2.0")
|
|
(source
|
|
(origin
|
|
(method git-fetch)
|
|
(uri (git-reference
|
|
(url "https://github.com/JuliaLang/Compat.jl")
|
|
(commit (string-append "v" version))))
|
|
(file-name "Compat")
|
|
(sha256
|
|
(base32 "024gqvhabranf398hwhb4m2w3a42kdg9zqj8s4pmjvaal14grw70"))))
|
|
(build-system julia-build-system)
|
|
(home-page "https://github.com/JuliaLang/Compat.jl")
|
|
(synopsis "Compatibility across Julia versions")
|
|
(description "The Compat package is designed to ease interoperability
|
|
between older and newer versions of the Julia language. The Compat package
|
|
provides a macro that lets you use the latest syntax in a backwards-compatible
|
|
way.")
|
|
(license license:expat)))
|
|
|
|
(define-public julia-sha
|
|
(package
|
|
(name "julia-sha")
|
|
(version "0.5.7")
|
|
(source
|
|
(origin
|
|
(method git-fetch)
|
|
(uri (git-reference
|
|
(url "https://github.com/staticfloat/SHA.jl")
|
|
(commit (string-append "v" version))))
|
|
(file-name "SHA")
|
|
(sha256
|
|
(base32 "10a09kg9z0m8rvwmlgsna6p342kyvizx2axdqc6pzyhraddr8jrp"))))
|
|
(propagated-inputs `(("julia-compat" ,julia-compat)))
|
|
(build-system julia-build-system)
|
|
(home-page "https://github.com/staticfloat/SHA.jl")
|
|
(synopsis "Performant, 100% native-julia SHA1, SHA2, and SHA3
|
|
implementation")
|
|
(description "Julia package implementing SHA algorithms. Each exported
|
|
function takes in either an Array{UInt8}, a ByteString or an IO object.")
|
|
(license license:expat)))
|
|
|
|
(define-public julia-binaryprovider
|
|
(package
|
|
(name "julia-binaryprovider")
|
|
(version "0.5.5")
|
|
(source
|
|
(origin
|
|
(method git-fetch)
|
|
(uri (git-reference
|
|
(url "https://github.com/JuliaPackaging/BinaryProvider.jl")
|
|
(commit (string-append "v" version))))
|
|
(file-name "BinaryProvider")
|
|
(sha256
|
|
(base32 "1papsz5ki5iwv1v3ac1ddybjxak93nydh7dqc3231zm0fzd918ys"))))
|
|
(propagated-inputs `(("julia-sha" ,julia-sha)))
|
|
(arguments
|
|
`(#:phases
|
|
;; wants to download things with curl/wget
|
|
(modify-phases %standard-phases (delete 'precompile))))
|
|
(build-system julia-build-system)
|
|
(home-page "https://github.com/JuliaPackaging/BinaryProvider.jl.git")
|
|
(synopsis "A reliable binary provider for Julia")
|
|
(description "Install binary packages with Julia.")
|
|
(license license:expat)))
|
|
|
|
(define-public julia-mbedtls
|
|
(package
|
|
(name "julia-mbedtls")
|
|
(version "0.7.0")
|
|
(source
|
|
(origin
|
|
(method git-fetch)
|
|
(uri (git-reference
|
|
(url "https://github.com/JuliaWeb/MbedTLS.jl")
|
|
(commit (string-append "v" version))))
|
|
(file-name "MbedTLS")
|
|
(sha256
|
|
(base32 "1a8snw9gi21lm6r3kh6ly7ngi99s9k5shqkfiizj3g9li20q23h2"))))
|
|
(propagated-inputs `(("julia-binaryprovider" ,julia-binaryprovider)
|
|
("mbedtls-apache" ,mbedtls-apache)))
|
|
(arguments
|
|
`(#:phases
|
|
(modify-phases %standard-phases
|
|
(add-before 'precompile 'build-deps
|
|
(lambda* (#:key outputs source inputs #:allow-other-keys)
|
|
(let ((f (open-file
|
|
(string-append
|
|
(assoc-ref outputs "out")
|
|
"/share/julia/packages/"
|
|
(string-append
|
|
(strip-store-file-name source) "/deps/deps.jl"))
|
|
"w")))
|
|
(display (string-append "const libmbedcrypto = \""
|
|
(assoc-ref inputs "mbedtls-apache")
|
|
"/lib/libmbedcrypto.so\"\n") f)
|
|
(display (string-append "const libmbedtls = \""
|
|
(assoc-ref inputs "mbedtls-apache")
|
|
"/lib/libmbedtls.so\"\n") f)
|
|
(display (string-append "const libmbedx509 = \""
|
|
(assoc-ref inputs "mbedtls-apache")
|
|
"/lib/libmbedx509.so\"\n") f)
|
|
(close-port f))
|
|
#t)))))
|
|
(build-system julia-build-system)
|
|
(home-page "https://github.com/JuliaWeb/MbedTLS.jl")
|
|
(synopsis "Wrapper around the mbed TLS and cryptography C libary")
|
|
(description "@code{julia-mbedtls} is a julia wrapper around mbed TLS.")
|
|
(license license:expat)))
|
|
|
|
(define-public julia-bindeps
|
|
(package
|
|
(name "julia-bindeps")
|
|
(version "0.8.10")
|
|
(source
|
|
(origin
|
|
(method git-fetch)
|
|
(uri (git-reference
|
|
(url "https://github.com/JuliaPackaging/BinDeps.jl")
|
|
(commit (string-append "v" version))))
|
|
(file-name "BinDeps")
|
|
(sha256
|
|
(base32 "1da7z4ii78gaqnjal7c4d1xvicyshiil4ls6xhi9id4q8plmfa2m"))))
|
|
(propagated-inputs `(("julia-uriparser" ,julia-uriparser)
|
|
("julia-sha" ,julia-sha)
|
|
("julia-compat" ,julia-compat)))
|
|
(build-system julia-build-system)
|
|
(home-page "https://github.com/JuliaPackaging/BinDeps.jl")
|
|
(synopsis "Easily build binary dependencies for Julia packages")
|
|
(description "@code{BinDeps} is a package that provides a collection of
|
|
tools to build binary dependencies for Julia packages.")
|
|
(license license:expat)))
|
|
|
|
(define-public julia-parsers
|
|
(package
|
|
(name "julia-parsers")
|
|
(version "0.3.7")
|
|
(source
|
|
(origin
|
|
(method git-fetch)
|
|
(uri (git-reference
|
|
(url "https://github.com/JuliaData/Parsers.jl")
|
|
(commit (string-append "v" version))))
|
|
(file-name "Parsers")
|
|
(sha256
|
|
(base32 "01j8cpnhxpxzybqzbvv3h5v0ksysqxmh5fmls6hpza2p3gjg4yrv"))))
|
|
(build-system julia-build-system)
|
|
(home-page "https://github.com/JuliaData/Parsers.jl")
|
|
(synopsis "Fast parsing machinery for basic types in Julia")
|
|
(description "@code{Parsers} is a collection of type parsers and utilities
|
|
for Julia")
|
|
(license license:expat)))
|
|
|
|
(define-public julia-json
|
|
(package
|
|
(name "julia-json")
|
|
(version "0.21.0")
|
|
(source
|
|
(origin
|
|
(method git-fetch)
|
|
(uri (git-reference
|
|
(url "https://github.com/JuliaIO/JSON.jl")
|
|
(commit (string-append "v" version))))
|
|
(file-name "JSON")
|
|
(sha256
|
|
(base32 "0knmfjhchd3ggy86dsfyb7l4v3fv5dcr207cgp54mj7rj96caqsm"))))
|
|
(propagated-inputs `(("julia-parsers" ,julia-parsers)))
|
|
(build-system julia-build-system)
|
|
(home-page "https://github.com/JuliaIO/JSON.jl")
|
|
(synopsis "JSON parsing and printing")
|
|
(description "Parsing and printing JSON in pure Julia.")
|
|
(license license:expat)))
|
|
|
|
(define-public julia-bufferedstreams
|
|
(package
|
|
(name "julia-bufferedstreams")
|
|
(version "1.0.0")
|
|
(source
|
|
(origin
|
|
(method git-fetch)
|
|
(uri (git-reference
|
|
(url "https://github.com/BioJulia/BufferedStreams.jl")
|
|
(commit (string-append "v" version))))
|
|
(file-name "BufferedStreams")
|
|
(sha256
|
|
(base32 "0sf4sxbq55mg2pwxyxf0c839z1lk0yxg8nmb7617bfbvw31cp88z"))))
|
|
(propagated-inputs `(("julia-compat" ,julia-compat)))
|
|
(build-system julia-build-system)
|
|
(home-page "https://github.com/BioJulia/BufferedStreams.jl")
|
|
(synopsis "Fast composable IO streams")
|
|
(description "@code{BufferedStreams} provides buffering for IO
|
|
operations. It can wrap any IO type automatically making incremental reading
|
|
and writing faster.")
|
|
(license license:expat)))
|
|
|
|
(define-public julia-transcodingstreams
|
|
(package
|
|
(name "julia-transcodingstreams")
|
|
(version "0.9.5")
|
|
(source
|
|
(origin
|
|
(method git-fetch)
|
|
(uri (git-reference
|
|
(url "https://github.com/bicycle1885/TranscodingStreams.jl")
|
|
(commit (string-append "v" version))))
|
|
(file-name "TranscodingStreams")
|
|
(sha256
|
|
(base32 "0zfr4g4yv08iy96vshn7zn4lh2z5rwd4k1ybvyinp3srl69hxlk9"))))
|
|
(propagated-inputs `(("julia-compat" ,julia-compat)))
|
|
(build-system julia-build-system)
|
|
(home-page "https://github.com/bicycle1885/TranscodingStreams.jl")
|
|
(synopsis "Simple, consistent interfaces for any codec")
|
|
(description " @code{TranscodingStreams.jl} is a package for transcoding
|
|
data streams, which is:
|
|
@enumerate
|
|
@item fast: small overhead and specialized
|
|
methods,
|
|
@item consistent: basic I/O operations you already know will work as
|
|
you expect,
|
|
@item generic: support any I/O objects like files, buffers, pipes,
|
|
@item extensible: you can define a new codec to transcode data
|
|
@end enumerate")
|
|
(license license:expat)))
|
|
|
|
(define-public julia-codeczlib
|
|
(package
|
|
(name "julia-codeczlib")
|
|
(version "0.6.0")
|
|
(source
|
|
(origin
|
|
(method git-fetch)
|
|
(uri (git-reference
|
|
(url "https://github.com/bicycle1885/CodecZlib.jl")
|
|
(commit (string-append "v" version))))
|
|
(file-name "CodecZlib")
|
|
(sha256
|
|
(base32 "18j5lhcsgln4ng5ik0y1s194q1a8h4828wwp4ws5vqc9i2spn8mb"))))
|
|
(propagated-inputs `(("julia-transcodingstreams" ,julia-transcodingstreams)
|
|
("julia-binaryprovider" ,julia-binaryprovider)
|
|
("zlib" ,zlib)))
|
|
(arguments
|
|
`(#:phases
|
|
(modify-phases %standard-phases
|
|
(delete 'reset-gzip-timestamps)
|
|
(add-before 'precompile 'build-deps
|
|
(lambda* (#:key outputs source inputs #:allow-other-keys)
|
|
(let ((f (open-file
|
|
(string-append
|
|
(assoc-ref outputs "out")
|
|
"/share/julia/packages/"
|
|
(string-append
|
|
(strip-store-file-name source) "/deps/deps.jl"))
|
|
"w")))
|
|
(display (string-append "const libz = \""
|
|
(assoc-ref inputs "zlib")
|
|
"/lib/libz.so\"\n") f)
|
|
(display "check_deps() = true\n" f)
|
|
(close-port f))
|
|
#t)))))
|
|
(build-system julia-build-system)
|
|
(home-page "https://github.com/bicycle1885/CodecZlib.jl")
|
|
(synopsis "@code{Zlib} codecs for @code{TranscodingStreams}")
|
|
(description "@code{CodecZlib} provides Zlib bindings for the
|
|
@code{TranscodingStreams} interface.")
|
|
(license license:expat)))
|
|
|
|
(define-public julia-http
|
|
(package
|
|
(name "julia-http")
|
|
(version "0.8.6")
|
|
(source
|
|
(origin
|
|
(method git-fetch)
|
|
(uri (git-reference
|
|
(url "https://github.com/JuliaWeb/HTTP.jl")
|
|
(commit (string-append "v" version))))
|
|
(file-name "HTTP")
|
|
(sha256
|
|
(base32 "01s9nszgdinpa3pyra646w2yi4qx0d6hcngsrxx291vr5gnhr7lj"))))
|
|
(propagated-inputs `(("julia-inifile" ,julia-inifile)
|
|
("julia-mbedtls" ,julia-mbedtls)
|
|
("julia-compat" ,julia-compat)))
|
|
(build-system julia-build-system)
|
|
(home-page "https://juliaweb.github.io/HTTP.jl/")
|
|
(synopsis "HTTP for Julia")
|
|
(description "HTTP client and server functionality for Julia.")
|
|
(license license:expat)))
|
|
|
|
(define-public julia-libexpat
|
|
(package
|
|
(name "julia-libexpat")
|
|
;; 0.6.0 requires julia 1.3+
|
|
(version "0.5.0")
|
|
(source
|
|
(origin
|
|
(method git-fetch)
|
|
(uri (git-reference
|
|
(url "https://github.com/JuliaIO/LibExpat.jl")
|
|
(commit (string-append "v" version))))
|
|
(file-name "LibExpat")
|
|
(sha256
|
|
(base32 "1iny18z76bkf3yi6cvpfia7z1j7kn789iy0nwigsj2sb9mfi5x8b"))))
|
|
(arguments
|
|
`(#:phases
|
|
(modify-phases %standard-phases
|
|
(add-before 'precompile 'build-deps
|
|
(lambda*
|
|
(#:key outputs source inputs #:allow-other-keys)
|
|
(substitute*
|
|
(string-append
|
|
(assoc-ref outputs "out") "/share/julia/packages/"
|
|
(strip-store-file-name source) "/src/LibExpat.jl")
|
|
(("const libexpat = \"libexpat\"")
|
|
(string-append "const libexpat = \""
|
|
(assoc-ref inputs "expat")
|
|
"/lib/libexpat.so\"")))
|
|
#t)))))
|
|
(propagated-inputs `(("julia-compat" ,julia-compat)
|
|
("expat" ,expat)))
|
|
(build-system julia-build-system)
|
|
(home-page "https://github.com/JuliaIO/LibExpat.jl")
|
|
(synopsis "Julia interface to the Expat XML parser library")
|
|
(description "Run XPath queries on fully parsed XML tree.")
|
|
(license license:expat)))
|
|
|
|
(define-public julia-iteratorinterfaceextensions
|
|
(package
|
|
(name "julia-iteratorinterfaceextensions")
|
|
(version "1.0.0")
|
|
(source
|
|
(origin
|
|
(method git-fetch)
|
|
(uri (git-reference
|
|
(url
|
|
"https://github.com/queryverse/IteratorInterfaceExtensions.jl")
|
|
(commit (string-append "v" version))))
|
|
(file-name "IteratorInterfaceExtensions")
|
|
(sha256
|
|
(base32 "1slpay1dhja8f9gy6z7b3psgvgcknn963dvfqqakvg1grk9ppa09"))))
|
|
(build-system julia-build-system)
|
|
(home-page "https://github.com/queryverse/IteratorInterfaceExtensions.jl")
|
|
(synopsis "@code{IteratorInterfaceExtensions} defines a small number of
|
|
extensions to the iterator interface")
|
|
(description "@code{IteratorInterfaceExtensions} is a Julia package that
|
|
adds @code{isiterable} and @code{getiterator} to the iterator interface.")
|
|
(license license:expat)))
|
|
|
|
(define-public julia-tabletraits
|
|
(package
|
|
(name "julia-tabletraits")
|
|
(version "1.0.0")
|
|
(source
|
|
(origin
|
|
(method git-fetch)
|
|
(uri (git-reference
|
|
(url "https://github.com/queryverse/TableTraits.jl")
|
|
(commit (string-append "v" version))))
|
|
(file-name "TableTraits")
|
|
(sha256
|
|
(base32 "0lzb9xqnhgjbvkscc4p9vw3pzajm3a5a6ayv6byqc53ws8fxqk2v"))))
|
|
(propagated-inputs `(("julia-iteratorinterfaceextensions"
|
|
,julia-iteratorinterfaceextensions)))
|
|
(build-system julia-build-system)
|
|
(home-page "https://github.com/queryverse/TableTraits.jl")
|
|
(synopsis "Traits for julia tables")
|
|
(description "@code{TableTraits} defines a generic interface for tabular
|
|
data.")
|
|
(license license:expat)))
|
|
|
|
(define-public julia-dataapi
|
|
(package
|
|
(name "julia-dataapi")
|
|
(version "1.1.0")
|
|
(source
|
|
(origin
|
|
(method git-fetch)
|
|
(uri (git-reference
|
|
(url "https://github.com/JuliaData/DataAPI.jl")
|
|
(commit (string-append "v" version))))
|
|
(file-name "DataAPI")
|
|
(sha256
|
|
(base32 "0zl9vwkwcd2zar7vn9mhdwysyzkkfmq4ls5cmfs2nqzlfv4bzwbx"))))
|
|
(build-system julia-build-system)
|
|
(home-page "https://github.com/JuliaData/DataAPI.jl")
|
|
(synopsis "Data-focused namespace for packages to share functions")
|
|
(description "This Julia package provides a namespace for data-related
|
|
generic function definitions to solve the optional dependency problem;
|
|
packages wishing to share and/or extend functions can avoid depending directly
|
|
on each other by moving the function definition to @code{DataAPI.jl} and each
|
|
package taking a dependency on it. As such, it is paramount for
|
|
@code{DataAPI.jl} to be as minimal as possible, defining only generic function
|
|
stubs and very little else.")
|
|
(license license:expat)))
|
|
|
|
(define-public julia-datavalues
|
|
(package
|
|
(name "julia-datavalues")
|
|
(version "0.4.12")
|
|
(source
|
|
(origin
|
|
(method git-fetch)
|
|
(uri (git-reference
|
|
(url "https://github.com/queryverse/DataValues.jl")
|
|
(commit (string-append "v" version))))
|
|
(file-name "DataValues")
|
|
(sha256
|
|
(base32 "1x0si392psc6drc1x9vnzln4ai4y483n639yd7wqkn5h1nsxaa1c"))))
|
|
(propagated-inputs `(("julia-datavalueinterfaces"
|
|
,julia-datavalueinterfaces)))
|
|
(build-system julia-build-system)
|
|
(home-page "https://github.com/queryverse/DataValues.jl")
|
|
(synopsis "Missing values for Julia")
|
|
(description "This package provides the type DataValue that is used to
|
|
represent missing data.")
|
|
(license license:expat)))
|
|
|
|
(define-public julia-datavalueinterfaces
|
|
(package
|
|
(name "julia-datavalueinterfaces")
|
|
(version "1.0.0")
|
|
(source
|
|
(origin
|
|
(method git-fetch)
|
|
(uri (git-reference
|
|
(url "https://github.com/queryverse/DataValueInterfaces.jl")
|
|
(commit (string-append "v" version))))
|
|
(file-name "DataValueInterfaces")
|
|
(sha256
|
|
(base32 "0g2wj6q7jj956nx6g7dk8x7w1c4l2xcmnr1kq5x8s8fild9kslg8"))))
|
|
(build-system julia-build-system)
|
|
(home-page "https://github.com/queryverse/DataValueInterfaces.jl")
|
|
(synopsis "Forward definitions for @code{Datavalues.jl}")
|
|
(description "This package allows a few forward definitions for the
|
|
@code{DataValues.jl} package that other packages can utilize for integration
|
|
without having to take direct dependencies.")
|
|
(license license:expat)))
|
|
|
|
(define-public julia-tables
|
|
(package
|
|
(name "julia-tables")
|
|
(version "0.2.11")
|
|
(source
|
|
(origin
|
|
(method git-fetch)
|
|
(uri (git-reference
|
|
(url "https://github.com/JuliaData/Tables.jl")
|
|
(commit (string-append "v" version))))
|
|
(file-name "Tables")
|
|
(sha256
|
|
(base32 "1ccvc0nicvy3yjmn7jnny2d357pzrs12qcf52qfxvb33k851zl8m"))))
|
|
(propagated-inputs
|
|
`(("julia-iteratorinterfaceextensions" ,julia-iteratorinterfaceextensions)
|
|
("julia-tabletraits" ,julia-tabletraits)
|
|
("julia-dataapi" ,julia-dataapi)
|
|
("julia-datavalueinterfaces" ,julia-datavalueinterfaces)))
|
|
(build-system julia-build-system)
|
|
(home-page "https://github.com/JuliaData/Tables.jl")
|
|
(synopsis " Interface for tables in Julia")
|
|
(description "The @code{Tables.jl} package provides simple, yet powerful
|
|
interface functions for working with all kinds tabular data through
|
|
predictable access patterns.")
|
|
(license license:expat)))
|
|
|
|
(define-public julia-missings
|
|
(package
|
|
(name "julia-missings")
|
|
(version "0.4.3")
|
|
(source
|
|
(origin
|
|
(method git-fetch)
|
|
(uri (git-reference
|
|
(url "https://github.com/JuliaData/Missings.jl")
|
|
(commit (string-append "v" version))))
|
|
(file-name "Missings")
|
|
(sha256
|
|
(base32 "1y77c9kml708hp3hq0w7yv6qfd2s53s1108bbpfb841y5nrwxnk8"))))
|
|
(propagated-inputs `(("julia-dataapi" ,julia-dataapi)))
|
|
(build-system julia-build-system)
|
|
(home-page "https://github.com/JuliaData/Missings.jl")
|
|
(synopsis "Missing value support for Julia")
|
|
(description "Convenience functions for working with missing values in
|
|
Julia.")
|
|
(license license:expat)))
|
|
|
|
(define-public julia-orderedcollections
|
|
(package
|
|
(name "julia-orderedcollections")
|
|
(version "1.1.0")
|
|
(source
|
|
(origin
|
|
(method git-fetch)
|
|
(uri (git-reference
|
|
(url "https://github.com/JuliaCollections/OrderedCollections.jl")
|
|
;; They added Package.toml after the 1.1.0 tag
|
|
(commit "7a789d72a40f4c446f59575f5d77a63df4391a24")))
|
|
(file-name "OrderedCollections")
|
|
(sha256
|
|
(base32 "09b3mlzkxcbc8wn0pji73591865li07q4kvvfzn9x4256mw47riq"))))
|
|
(build-system julia-build-system)
|
|
(home-page "https://github.com/JuliaCollections/OrderedCollections.jl")
|
|
(synopsis "Julia implementation of associative containers that preserve
|
|
insertion order")
|
|
(description "This package implements OrderedDicts and OrderedSets, which
|
|
are similar to containers in base Julia. However, during iteration the
|
|
Ordered* containers return items in the order in which they were added to the
|
|
collection.")
|
|
(license license:expat)))
|
|
|
|
(define-public julia-datastructures
|
|
(package
|
|
(name "julia-datastructures")
|
|
(version "0.17.2")
|
|
(source
|
|
(origin
|
|
(method git-fetch)
|
|
(uri (git-reference
|
|
(url "https://github.com/JuliaCollections/DataStructures.jl")
|
|
(commit (string-append "v" version))))
|
|
(file-name "DataStructures")
|
|
(sha256
|
|
(base32 "0l742ac5n2g2nnrbxvkqz1wkj739rmflzd8zyz934dc6a5pwnzrw"))))
|
|
(propagated-inputs
|
|
`(("julia-orderedcollections" ,julia-orderedcollections)))
|
|
(build-system julia-build-system)
|
|
(home-page "https://github.com/JuliaCollections/DataStructures.jl")
|
|
(synopsis "Julia implementation of Data structures")
|
|
(description "This package implements a variety of data structures,
|
|
including:
|
|
|
|
@enumerate
|
|
@item Deque (implemented with an unrolled linked list)
|
|
@item CircularBuffer
|
|
@item CircularDeque
|
|
@item Stack
|
|
@item Queue
|
|
@item Accumulators and Counters (i.e. Multisets / Bags)
|
|
@item Disjoint Sets
|
|
@item Binary Heap
|
|
@item Mutable Binary Heap
|
|
@item Ordered Dicts and Sets
|
|
@item Dictionaries with Defaults
|
|
@item Trie
|
|
@item Linked List and Mutable Linked List
|
|
@item Sorted Dict, Sorted Multi-Dict and Sorted Set
|
|
@item DataStructures.IntSet
|
|
@item Priority Queue
|
|
@item Fenwick Tree
|
|
@item SparseIntSet
|
|
@end enumerate")
|
|
(license license:expat)))
|
|
|
|
(define-public julia-sortingalgorithms
|
|
(package
|
|
(name "julia-sortingalgorithms")
|
|
(version "0.3.1")
|
|
(source
|
|
(origin
|
|
(method git-fetch)
|
|
(uri (git-reference
|
|
(url "https://github.com/JuliaCollections/SortingAlgorithms.jl")
|
|
(commit (string-append "v" version))))
|
|
(file-name "SortingAlgorithms")
|
|
(sha256
|
|
(base32 "1nz96sccgl6h6aknck59gmy1yrzx356kk9z68svj2g6yialprv1j"))))
|
|
(propagated-inputs `(("julia-datastructures" ,julia-datastructures)))
|
|
(arguments
|
|
`(#:phases
|
|
(modify-phases %standard-phases
|
|
(add-before 'precompile 'fix-toml
|
|
(lambda* (#:key outputs source #:allow-other-keys)
|
|
(julia-create-package-toml
|
|
outputs source
|
|
"SortingAlgorithms"
|
|
"a2af1166-a08f-5f64-846c-94a0d3cef48c"
|
|
"0.3.1"
|
|
'(("DataStructures" . "864edb3b-99cc-5e75-8d2d-829cb0a9cfe8")))
|
|
#t)))))
|
|
(build-system julia-build-system)
|
|
(home-page "https://github.com/JuliaCollections/SortingAlgorithms.jl")
|
|
(synopsis "Extra sorting algorithms extending Julia's sorting API")
|
|
(description "The SortingAlgorithms package provides three sorting
|
|
algorithms that can be used with Julia's standard sorting API:
|
|
@enumerate
|
|
@item HeapSort
|
|
@item TimSort
|
|
@item RadixSort
|
|
@end enumerate")
|
|
(license license:expat)))
|
|
|
|
(define-public julia-statsbase
|
|
(package
|
|
(name "julia-statsbase")
|
|
(version "0.32.0")
|
|
(source
|
|
(origin
|
|
(method git-fetch)
|
|
(uri (git-reference
|
|
(url "https://github.com/JuliaStats/StatsBase.jl")
|
|
(commit "b9454f979ff8bdbc3ecffe2490cc1331a824e798")))
|
|
(file-name "StatsBase")
|
|
(sha256
|
|
(base32 "1k6zcblpdrdq568lsgna83ld2kj47h2cxn5idp8g41fdm9scph5b"))))
|
|
(propagated-inputs `(("julia-datastructures" ,julia-datastructures)
|
|
("julia-sortingalgorithms" ,julia-sortingalgorithms)
|
|
("julia-missings" ,julia-missings)
|
|
("julia-dataapi" ,julia-dataapi)))
|
|
(build-system julia-build-system)
|
|
(home-page "https://github.com/JuliaStats/StatsBase.jl")
|
|
(synopsis "Basic statistics for Julia")
|
|
(description "@code{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-reexport
|
|
(package
|
|
(name "julia-reexport")
|
|
(version "0.2.0")
|
|
(source
|
|
(origin
|
|
(method git-fetch)
|
|
(uri (git-reference
|
|
(url "https://github.com/simonster/Reexport.jl")
|
|
(commit "258a4088bb77ee4821bf2da1c73fd6e4897fd43c")))
|
|
(file-name "Reexport")
|
|
(sha256
|
|
(base32 "0h8pfqwz0g0gywcsr5f7s3z6g7q0mmlb2ynki2nn16r8x4i074nx"))))
|
|
(build-system julia-build-system)
|
|
(home-page "https://github.com/simonster/Reexport.jl")
|
|
(synopsis "Julia macro for re-exporting one module from another")
|
|
(description "@code{Reexport.jl} re-exports symbols defined in another
|
|
module from your module, until this functionality is built into Julia.")
|
|
(license license:expat)))
|
|
|
|
(define-public julia-invertedindices
|
|
(package
|
|
(name "julia-invertedindices")
|
|
(version "1.0.0")
|
|
(source
|
|
(origin
|
|
(method git-fetch)
|
|
(uri (git-reference
|
|
(url "https://github.com/mbauman/InvertedIndices.jl")
|
|
(commit (string-append "v" version))))
|
|
(file-name "InvertedIndices")
|
|
(sha256
|
|
(base32 "1179z20yxnkyziip7gn26wr1g3k3ssl1ci7pig3khc900f62di46"))))
|
|
(build-system julia-build-system)
|
|
(home-page "https://github.com/mbauman/InvertedIndices.jl")
|
|
(synopsis "Simple index type that allows for inverted selections")
|
|
(description "This very small package just exports one type: the
|
|
InvertedIndex, or Not for short. It can wrap any supported index type and may
|
|
be used as an index into any AbstractArray subtype, including OffsetArrays.")
|
|
(license license:expat)))
|
|
|
|
(define-public julia-pooledarrays
|
|
(package
|
|
(name "julia-pooledarrays")
|
|
(version "0.5.2")
|
|
(source
|
|
(origin
|
|
(method git-fetch)
|
|
(uri (git-reference
|
|
(url "https://github.com/JuliaData/PooledArrays.jl")
|
|
(commit (string-append "v" version))))
|
|
(file-name "PooledArrays")
|
|
(sha256
|
|
(base32 "0sdn965bb93api43dj8dsd32lp3yyh53mp22xr0vfj115x3ym2wj"))))
|
|
(build-system julia-build-system)
|
|
(home-page "https://github.com/JuliaData/PooledArrays.jl")
|
|
(synopsis "Pooled representation of arrays for compression when few
|
|
elements are unique")
|
|
(description "This julia package provides a pooled representation of
|
|
arrays for purposes of compression when there are few unique elements.")
|
|
(license license:expat)))
|
|
|
|
(define-public julia-categoricalarrays
|
|
(package
|
|
(name "julia-categoricalarrays")
|
|
(version "0.7.1")
|
|
(source
|
|
(origin
|
|
(method git-fetch)
|
|
(uri (git-reference
|
|
(url "https://github.com/JuliaData/CategoricalArrays.jl")
|
|
(commit (string-append "v" version))))
|
|
(file-name "CategoricalArrays")
|
|
(sha256
|
|
(base32 "0g12q1gkzm9xc3d6hs8r155p8nnp2hdyghd68vzf9gmqysdn2851"))))
|
|
(propagated-inputs `(("julia-compat" ,julia-compat)
|
|
("julia-missings" ,julia-missings)
|
|
("julia-dataapi" ,julia-dataapi)
|
|
("julia-reexport" ,julia-reexport)
|
|
("julia-json" ,julia-json)))
|
|
(build-system julia-build-system)
|
|
(home-page "https://github.com/JuliaData/CategoricalArrays.jl")
|
|
(synopsis "Arrays for working with categorical data (both nominal and
|
|
ordinal)")
|
|
(description "This package provides tools for working with categorical
|
|
variables, both with unordered (nominal variables) and ordered
|
|
categories (ordinal variables), optionally with missing values.")
|
|
(license license:expat)))
|
|
|
|
(define-public julia-dataframes
|
|
(package
|
|
(name "julia-dataframes")
|
|
(version "0.19.4")
|
|
(source
|
|
(origin
|
|
(method git-fetch)
|
|
(uri (git-reference
|
|
(url "https://github.com/JuliaData/DataFrames.jl")
|
|
(commit (string-append "v" version))))
|
|
(file-name "DataFrames")
|
|
(sha256
|
|
(base32 "0400bhrxyz4z9xzqypayzra9xdk84frv76rz7s8p834i1v7ldmkk"))))
|
|
(propagated-inputs
|
|
`(("julia-tables" ,julia-tables)
|
|
("julia-iteratorinterfaceextensions" ,julia-iteratorinterfaceextensions)
|
|
("julia-tabletraits" ,julia-tabletraits)
|
|
("julia-missings" ,julia-missings)
|
|
("julia-categoricalarrays" ,julia-categoricalarrays)
|
|
("julia-invertedindices" ,julia-invertedindices)
|
|
("julia-compat" ,julia-compat)
|
|
("julia-pooledarrays" ,julia-pooledarrays)
|
|
("julia-sortingalgorithms" ,julia-sortingalgorithms)
|
|
("julia-reexport" ,julia-reexport)
|
|
("julia-dataapi" ,julia-dataapi)
|
|
("julia-parsers" ,julia-parsers)))
|
|
(build-system julia-build-system)
|
|
(home-page "https://github.com/JuliaData/DataFrames.jl")
|
|
(synopsis "In-memory tabular data in Julia")
|
|
(description "Tools for working with tabular data in Julia.")
|
|
(license license:expat)))
|
|
|
|
(define-public julia-fixedpointnumbers
|
|
(package
|
|
(name "julia-fixedpointnumbers")
|
|
(version "0.6.1")
|
|
(source
|
|
(origin
|
|
(method git-fetch)
|
|
(uri (git-reference
|
|
(url "https://github.com/JuliaMath/FixedPointNumbers.jl")
|
|
(commit (string-append "v" version))))
|
|
(file-name "FixedPointNumbers")
|
|
(sha256
|
|
(base32 "033s9gi94xs97kshy2mcx5mvdkigdf4aqgaa6qgq6kz4s6gbpa9r"))))
|
|
(propagated-inputs `(("julia-compat" ,julia-compat)))
|
|
(build-system julia-build-system)
|
|
(home-page "https://github.com/JuliaMath/FixedPointNumbers.jl")
|
|
(synopsis "Fixed point types for julia")
|
|
(description "This library implements fixed-point number types. A
|
|
fixed-point number represents a fractional, or non-integral, number. In
|
|
contrast with the more widely known floating-point numbers, with fixed-point
|
|
numbers the decimal point doesn't \"float\": fixed-point numbers are
|
|
effectively integers that are interpreted as being scaled by a constant
|
|
factor. Consequently, they have a fixed number of digits (bits) after the
|
|
decimal (radix) point.")
|
|
(license license:expat)))
|
|
|
|
(define-public julia-tokenize
|
|
(package
|
|
(name "julia-tokenize")
|
|
(version "0.5.6")
|
|
(source
|
|
(origin
|
|
(method git-fetch)
|
|
(uri (git-reference
|
|
(url "https://github.com/JuliaLang/Tokenize.jl")
|
|
(commit (string-append "v" version))))
|
|
(file-name "Tokenize")
|
|
(sha256
|
|
(base32 "1i05y9wvy5lii082bsn6qqs65nc9lvhw3mvl6jqmpdm5xqxw5mrg"))))
|
|
(build-system julia-build-system)
|
|
(home-page "https://github.com/JuliaLang/Tokenize.jl")
|
|
(synopsis "Tokenization for Julia source code")
|
|
(description "@code{Tokenize.jl} is a Julia package that serves a similar
|
|
purpose and API as the tokenize module in Python but for Julia. This is to
|
|
take a string or buffer containing Julia code, perform lexical analysis and
|
|
return a stream of tokens.
|
|
|
|
The goals of this package is to be:
|
|
@enumerate
|
|
@item Fast
|
|
@item Round trippable
|
|
@item Non error throwing
|
|
@end enumerate
|
|
")
|
|
(license license:expat)))
|
|
|
|
(define-public julia-cstparser
|
|
(package
|
|
(name "julia-cstparser")
|
|
(version "0.6.2")
|
|
(source
|
|
(origin
|
|
(method git-fetch)
|
|
(uri (git-reference
|
|
(url "https://github.com/julia-vscode/CSTParser.jl")
|
|
(commit (string-append "v" version))))
|
|
(file-name "CSTParser")
|
|
(sha256
|
|
(base32 "04g9k646zv5adps5491mkksa71lfzrnvmd8qi8j6gpl1cd4as3qi"))))
|
|
(propagated-inputs `(("julia-tokenize" ,julia-tokenize)))
|
|
(build-system julia-build-system)
|
|
(home-page "https://github.com/julia-vscode/CSTParser.jl")
|
|
(synopsis "Concrete syntax tree parser for Julia")
|
|
(description "Parser for Julia using Tokenize that aims to extend the
|
|
built-in parser by providing additional meta information along with the
|
|
resultant AST.")
|
|
(license license:expat)))
|
|
|
|
(define-public julia-macrotools
|
|
(package
|
|
(name "julia-macrotools")
|
|
(version "0.5.1")
|
|
(source
|
|
(origin
|
|
(method git-fetch)
|
|
(uri (git-reference
|
|
(url "https://github.com/MikeInnes/MacroTools.jl")
|
|
(commit (string-append "v" version))))
|
|
(file-name "MacroTools")
|
|
(sha256
|
|
(base32 "0sspp8na3cj7pni1b3dqzzpv2mkzln4f5w0n0wrh2jvn8rz1fjjx"))))
|
|
(propagated-inputs `(("julia-compat" ,julia-compat)
|
|
("julia-tokenize" ,julia-tokenize)
|
|
("julia-datastructures" ,julia-datastructures)
|
|
("julia-cstparser" ,julia-cstparser)))
|
|
(build-system julia-build-system)
|
|
(home-page "https://mikeinnes.github.io/MacroTools.jl/stable/")
|
|
(synopsis "MacroTools provides a library for working with Julia code and
|
|
expressions")
|
|
(description "MacroTools provides a library of tools for working with
|
|
Julia code and expressions. This includes a powerful template-matching system
|
|
and code-walking tools that let you do deep transformations of code in a few
|
|
lines.Julia code and expressions.")
|
|
(license license:expat)))
|
|
|
|
(define-public julia-lazy
|
|
(package
|
|
(name "julia-lazy")
|
|
(version "0.14.0")
|
|
(source
|
|
(origin
|
|
(method git-fetch)
|
|
(uri (git-reference
|
|
(url "https://github.com/MikeInnes/Lazy.jl")
|
|
(commit (string-append "v" version))))
|
|
(file-name "Lazy")
|
|
(sha256
|
|
(base32 "18ywj35yjcskrk7iy3w1aw7a8y1gqm20si9wdig6m7a6718479yr"))))
|
|
(propagated-inputs `(("julia-macrotools" ,julia-macrotools)
|
|
("julia-compat" ,julia-compat)))
|
|
(build-system julia-build-system)
|
|
(home-page "https://github.com/MikeInnes/Lazy.jl")
|
|
(synopsis "Lazy evaluated lists in Julia")
|
|
(description "@code{Lazy.jl} provides Julia with the cornerstones of
|
|
functional programming - lazily-evaluated lists and a large library of
|
|
functions for working with them.")
|
|
(license license:expat)))
|
|
|
|
(define-public julia-hiccup
|
|
(package
|
|
(name "julia-hiccup")
|
|
(version "0.2.2")
|
|
(source
|
|
(origin
|
|
(method git-fetch)
|
|
(uri
|
|
(git-reference
|
|
(url "https://github.com/JunoLab/Hiccup.jl")
|
|
(commit
|
|
(string-append "v" version))))
|
|
(file-name "Hiccup")
|
|
(sha256
|
|
(base32 "0m6my7d48658x4v0glv1006f0yvqd49f875b74q7kq3y6a9sxy5z"))))
|
|
(propagated-inputs
|
|
`(("julia-macrotools" ,julia-macrotools)
|
|
("julia-orderedcollections" ,julia-orderedcollections)
|
|
("julia-lazy" ,julia-lazy)))
|
|
(build-system julia-build-system)
|
|
(home-page "https://github.com/JunoLab/Hiccup.jl")
|
|
(synopsis "Super-simple library designed to make making HTML easy in
|
|
Julia")
|
|
(description "HTML Domain Specific Language for Julia, inspired by
|
|
Clojure's Hiccup DSL.")
|
|
(license license:expat)))
|
|
|
|
(define-public julia-requires
|
|
(package
|
|
(name "julia-requires")
|
|
(version "0.5.2")
|
|
(source
|
|
(origin
|
|
(method git-fetch)
|
|
(uri (git-reference
|
|
(url "https://github.com/MikeInnes/Requires.jl")
|
|
(commit "b2319cd875118c8da8ca099bcd733246ede13628")))
|
|
(file-name "Requires")
|
|
(sha256
|
|
(base32 "00ksdsdgn8pdr9v7263pdmnqmp14pmn6qpf0bvi8n0g59f2nibi9"))))
|
|
(propagated-inputs `(("julia-macrotools" ,julia-macrotools)))
|
|
(build-system julia-build-system)
|
|
(home-page "https://github.com/MikeInnes/Requires.jl")
|
|
(synopsis "Lazy code loading for Julia")
|
|
(description "Requires is a Julia package that will magically make loading
|
|
packages faster, maybe. It supports specifying glue code in packages which
|
|
will load automatically when a another package is loaded, so that explicit
|
|
dependencies (and long load times) can be avoided.")
|
|
(license license:expat)))
|
|
|
|
(define-public julia-websockets
|
|
(package
|
|
(name "julia-websockets")
|
|
(version "1.5.2")
|
|
(source
|
|
(origin
|
|
(method git-fetch)
|
|
(uri
|
|
(git-reference
|
|
(url "https://github.com/JuliaWeb/WebSockets.jl")
|
|
(commit
|
|
(string-append "v" version))))
|
|
(file-name "WebSockets")
|
|
(sha256
|
|
(base32 "1fpvskbax88x059lwnl211ps13j8s2jf97agwwr69sir11i0xh51"))))
|
|
(propagated-inputs
|
|
`(("julia-http" ,julia-http)
|
|
("julia-requires" ,julia-requires)))
|
|
(build-system julia-build-system)
|
|
(home-page "https://github.com/JuliaWeb/WebSockets.jl")
|
|
(synopsis "WebSockets library for Julia")
|
|
(description "Server and client side Websockets protocol in Julia.
|
|
WebSockets is a small overhead message protocol layered over TCP. It uses
|
|
HTTP(S) for establishing the connections.")
|
|
(license license:expat)))
|
|
|
|
(define-public julia-pidfile
|
|
(package
|
|
(name "julia-pidfile")
|
|
(version "1.1.0")
|
|
(source
|
|
(origin
|
|
(method git-fetch)
|
|
(uri
|
|
(git-reference
|
|
(url "https://github.com/vtjnash/Pidfile.jl")
|
|
;; Project.toml added after 1.1.0 release
|
|
(commit "b7c9060ad7fc57c9c1341d8a87392e25580b6b71")))
|
|
(file-name "Pidfile")
|
|
(sha256
|
|
(base32 "11pml7ls8dsipbcmngsqgdfwsdza9xjmy1974i5kiik7skhv860x"))))
|
|
(propagated-inputs
|
|
`(("julia-compat" ,julia-compat)))
|
|
(build-system julia-build-system)
|
|
(home-page "https://vtjnash.github.io/Pidfile.jl/")
|
|
(synopsis "Utility for creating advisory pidfiles (lock files)")
|
|
(description "Simple utility tool for creating advisory pidfiles (lock
|
|
files).")
|
|
(license license:expat)))
|
|
|
|
(define-public julia-assetregistry
|
|
(package
|
|
(name "julia-assetregistry")
|
|
(version "0.1.0")
|
|
(source
|
|
(origin
|
|
(method git-fetch)
|
|
(uri
|
|
(git-reference
|
|
(url "https://github.com/JuliaGizmos/AssetRegistry.jl")
|
|
(commit
|
|
(string-append "v" version))))
|
|
(file-name "AssetRegistry")
|
|
(sha256
|
|
(base32 "0xpldj08apvblgng6vndb9311gl6xxbk1f9jha8a661p2zfj0r4b"))))
|
|
(propagated-inputs
|
|
`(("julia-json" ,julia-json)
|
|
("julia-sha" ,julia-sha)
|
|
("julia-pidfile" ,julia-pidfile)))
|
|
(build-system julia-build-system)
|
|
(arguments
|
|
`(#:phases
|
|
(modify-phases %standard-phases
|
|
(add-before 'precompile 'fix-toml
|
|
(lambda*
|
|
(#:key outputs source #:allow-other-keys)
|
|
(julia-create-package-toml
|
|
outputs source
|
|
"AssetRegistry"
|
|
"bf4720bc-e11a-5d0c-854e-bdca1663c893"
|
|
"0.1.0"
|
|
'(("SHA" . "ea8e919c-243c-51af-8825-aaa63cd721ce")
|
|
("JSON" . "682c06a0-de6a-54ab-a142-c8b1cf79cde6")
|
|
("Pidfile" . "fa939f87-e72e-5be4-a000-7fc836dbe307")))
|
|
#t)))))
|
|
(home-page "https://github.com/JuliaGizmos/AssetRegistry.jl")
|
|
(synopsis "Serve arbitrary files and folders using a global registry")
|
|
(description "AssetRegistry allows you to serve arbitrary files and
|
|
folders, using a global registry. Now packages like Mux and IJulia can look up
|
|
this registry and serve these files while packages like WebIO and InteractBase
|
|
can register assets to be served to implement web-based UIs.")
|
|
(license license:expat)))
|
|
|
|
(define-public julia-mux
|
|
(package
|
|
(name "julia-mux")
|
|
(version "0.7.0")
|
|
(source
|
|
(origin
|
|
(method git-fetch)
|
|
(uri
|
|
(git-reference
|
|
(url "https://github.com/JuliaWeb/Mux.jl")
|
|
(commit
|
|
(string-append "v" version))))
|
|
(file-name "Mux")
|
|
(sha256
|
|
(base32 "1wmgh9iji0smx6vkn9y1kiylgci1ay0jrb968b61h6grwk9gxvlj"))))
|
|
(propagated-inputs
|
|
`(("julia-http" ,julia-http)
|
|
("julia-hiccup" ,julia-hiccup)
|
|
("julia-lazy" ,julia-lazy)
|
|
("julia-websockets" ,julia-websockets)
|
|
("julia-assetregistry" ,julia-assetregistry)
|
|
("julia-parsers" ,julia-parsers)
|
|
("julia-tokenize" ,julia-tokenize)
|
|
("julia-datastructures" ,julia-datastructures)
|
|
("julia-cstparser" ,julia-cstparser)))
|
|
(build-system julia-build-system)
|
|
(home-page "https://github.com/JuliaWeb/Mux.jl")
|
|
(synopsis "Middleware for Julia")
|
|
(description "@code{Mux.jl} gives your Julia web services some closure.
|
|
Mux allows you to define servers in terms of highly modular and composable
|
|
components called middleware, with the aim of making both simple and complex
|
|
servers as simple as possible to throw together.")
|
|
(license license:expat)))
|
|
|
|
(define-public julia-mustache
|
|
(package
|
|
(name "julia-mustache")
|
|
(version "0.5.13")
|
|
(source
|
|
(origin
|
|
(method git-fetch)
|
|
(uri (git-reference
|
|
(url "https://github.com/jverzani/Mustache.jl")
|
|
(commit (string-append "v" version))))
|
|
(file-name "Mustache")
|
|
(sha256
|
|
(base32 "02dnn8vjr9byzgs0x637053p6dkywq2jc3k5aanvrqs1pkhcrqyd"))))
|
|
(propagated-inputs `(("julia-tables" ,julia-tables)))
|
|
(build-system julia-build-system)
|
|
(home-page "https://github.com/jverzani/Mustache.jl")
|
|
(synopsis "Port of Mustache.js to Julia")
|
|
(description "Logic-less template syntax. It can be used for HTML,
|
|
config files, source code - anything. It works by expanding tags in a
|
|
template using values provided in a hash or object.")
|
|
(license license:expat)))
|
|
|
|
(define-public julia-nanmath
|
|
(package
|
|
(name "julia-nanmath")
|
|
(version "0.3.2")
|
|
(source
|
|
(origin
|
|
(method git-fetch)
|
|
(uri (git-reference
|
|
(url "https://github.com/mlubin/NaNMath.jl")
|
|
(commit (string-append "v" version))))
|
|
(file-name "NaNMath")
|
|
(sha256
|
|
(base32 "17cp9fnz8ydl684dkkqbsgi4c6xkd9skwrjyscawns9c1fhnzl2l"))))
|
|
(propagated-inputs `(("julia-compat" ,julia-compat)))
|
|
(build-system julia-build-system)
|
|
(arguments
|
|
`(#:phases
|
|
(modify-phases %standard-phases
|
|
(add-before 'precompile 'fix-toml
|
|
(lambda* (#:key outputs source #:allow-other-keys)
|
|
(julia-create-package-toml
|
|
outputs source
|
|
"NaNMath"
|
|
"77ba4419-2d1f-58cd-9bb1-8ffee604a2e3"
|
|
"0.3.2"
|
|
'(("Compat" . "34da2185-b29b-5c13-b0c7-acf172513d20")))
|
|
#t)))))
|
|
(home-page "https://github.com/mlubin/NaNMath.jl")
|
|
(synopsis "Julia math builtins which return NaN and accumulator functions
|
|
which ignore NaN")
|
|
(description "Implementations of basic math functions which return NaN
|
|
instead of throwing a DomainError.")
|
|
(license license:expat)))
|
|
|
|
(define-public julia-measures
|
|
(package
|
|
(name "julia-measures")
|
|
(version "0.3.0")
|
|
(source
|
|
(origin
|
|
(method git-fetch)
|
|
(uri (git-reference
|
|
(url "https://github.com/JuliaGraphics/Measures.jl")
|
|
(commit (string-append "v" version))))
|
|
(file-name "Measures")
|
|
(sha256
|
|
(base32 "020yf4a7wmm0jhkpzxgz4bif2l4l0zmrzagz0gc2hrvnz0kp9m3b"))))
|
|
(arguments
|
|
`(#:phases
|
|
(modify-phases %standard-phases
|
|
(add-before 'precompile 'fix-toml
|
|
(lambda* (#:key outputs source #:allow-other-keys)
|
|
(julia-create-package-toml
|
|
outputs source
|
|
"Measures"
|
|
"442fdcdd-2543-5da2-b0f3-8c86c306513e"
|
|
"0.3.0"
|
|
'())
|
|
#t)))))
|
|
(build-system julia-build-system)
|
|
(home-page "https://github.com/JuliaGraphics/Measures.jl")
|
|
(synopsis "Unified measure and coordinates types")
|
|
(description "This library generalizes and unifies the notion of measures
|
|
used in @code{Compose}, @code{Compose3D}, and @code{Escher}. It allows
|
|
building up and representing expressions involving differing types of units
|
|
that are then evaluated, resolving them into absolute units.")
|
|
(license license:expat)))
|
|
|
|
(define-public julia-colortypes
|
|
(package
|
|
(name "julia-colortypes")
|
|
(version "0.8.0")
|
|
(source
|
|
(origin
|
|
(method git-fetch)
|
|
(uri (git-reference
|
|
(url "https://github.com/JuliaGraphics/ColorTypes.jl")
|
|
(commit (string-append "v" version))))
|
|
(file-name "ColorTypes")
|
|
(sha256
|
|
(base32 "0yskbz6598aaa36502jzq59aqqy0daxcrcxcmhk6jnbb5a1psr95"))))
|
|
(propagated-inputs `(("julia-compat" ,julia-compat)
|
|
("julia-fixedpointnumbers" ,julia-fixedpointnumbers)))
|
|
(build-system julia-build-system)
|
|
(home-page "https://github.com/JuliaGraphics/ColorTypes.jl")
|
|
(synopsis "Basic color definitions and traits")
|
|
(description "This \"minimalistic\" package serves as the foundation for
|
|
working with colors in Julia. It defines basic color types and their
|
|
constructors, and sets up traits and show methods to make them easier to work
|
|
with.")
|
|
(license license:expat)))
|
|
|
|
(define-public julia-colors
|
|
(package
|
|
(name "julia-colors")
|
|
(version "0.9.6")
|
|
(source
|
|
(origin
|
|
(method git-fetch)
|
|
(uri (git-reference
|
|
(url "https://github.com/JuliaGraphics/Colors.jl")
|
|
(commit (string-append "v" version))))
|
|
(file-name "Colors")
|
|
(sha256
|
|
(base32 "1q2plh4iv3xqw7dd8xv4hshiv5xsg4d7dpd58y6zpip1fhpxpgrp"))))
|
|
(propagated-inputs `(("julia-fixedpointnumbers" ,julia-fixedpointnumbers)
|
|
("julia-colortypes" ,julia-colortypes)
|
|
("julia-reexport" ,julia-reexport)))
|
|
(build-system julia-build-system)
|
|
(home-page "https://github.com/JuliaGraphics/Colors.jl")
|
|
(synopsis "Color manipulation utilities for Julia")
|
|
(description "This library provides a wide array of functions for dealing
|
|
with color. This includes conversion between colorspaces, measuring distance
|
|
between colors, simulating color blindness, parsing colors, and generating
|
|
color scales for graphics.")
|
|
(license license:expat)))
|
|
|
|
(define-public julia-plotutils
|
|
(package
|
|
(name "julia-plotutils")
|
|
(version "0.6.0")
|
|
(source
|
|
(origin
|
|
(method git-fetch)
|
|
(uri (git-reference
|
|
(url "https://github.com/JuliaPlots/PlotUtils.jl")
|
|
(commit (string-append "v" version))))
|
|
(file-name "PlotUtils")
|
|
(sha256
|
|
(base32 "0g91ap8pw7ipp3fsy0xkh357czhmrvpdfi77hnj3lyjrrvbjc8sh"))))
|
|
(propagated-inputs `(("julia-colors" ,julia-colors)
|
|
("julia-reexport" ,julia-reexport)))
|
|
(build-system julia-build-system)
|
|
(home-page "https://github.com/JuliaPlots/PlotUtils.jl")
|
|
(synopsis "Generic helper algorithms for building plotting components")
|
|
(description "@code{PlotUtils.jl} is a julia package that provides helper
|
|
algorithms for building plotting components.")
|
|
(license license:expat)))
|
|
|
|
(define-public julia-contour
|
|
(package
|
|
(name "julia-contour")
|
|
(version "0.5.1")
|
|
(source
|
|
(origin
|
|
(method git-fetch)
|
|
(uri (git-reference
|
|
(url "https://github.com/JuliaGeometry/Contour.jl")
|
|
(commit (string-append "v" version))))
|
|
(file-name "Contour")
|
|
(sha256
|
|
(base32 "0l7zi2xshyv81xlp1szm47f6200lnhfylfdrsk7g0xiajr81acpd"))))
|
|
(propagated-inputs `(("julia-staticarrays" ,julia-staticarrays)))
|
|
(build-system julia-build-system)
|
|
(home-page "https://juliageometry.github.io/Contour.jl/stable/")
|
|
(synopsis "Calculating contour curves for 2D scalar fields in Julia")
|
|
(description "Generic implementation of the marching squares algorithm for
|
|
tracing contour curves on a scalar 2D field.")
|
|
(license license:expat)))
|
|
|
|
(define-public julia-staticarrays
|
|
(package
|
|
(name "julia-staticarrays")
|
|
(version "0.11.0")
|
|
(source
|
|
(origin
|
|
(method git-fetch)
|
|
(uri (git-reference
|
|
(url "https://github.com/JuliaArrays/StaticArrays.jl")
|
|
(commit (string-append "v" version))))
|
|
(file-name "StaticArrays")
|
|
(sha256
|
|
(base32 "0ni4rdq8qq4c7m49my885ispilqvhbza0id92j16rqzhdff8bghg"))))
|
|
(build-system julia-build-system)
|
|
(home-page "https://github.com/JuliaArrays/StaticArrays.jl")
|
|
(synopsis "Statically sized arrays for Julia")
|
|
(description "@code{StaticArrays} provides a framework for implementing
|
|
statically sized arrays in Julia, using the abstract type
|
|
@code{StaticArray{Size,T,N} <: AbstractArray{T,N}}. Subtypes of StaticArray
|
|
will provide fast implementations of common array and linear algebra
|
|
operations. Note that here \"statically sized\" means that the size can be
|
|
determined from the type, and \"static\" does not necessarily imply
|
|
immutable.")
|
|
(license license:expat)))
|
|
|
|
(define-public julia-itertools
|
|
(package
|
|
(name "julia-itertools")
|
|
(version "1.2.0")
|
|
(source
|
|
(origin
|
|
(method git-fetch)
|
|
(uri (git-reference
|
|
(url "https://github.com/JuliaCollections/IterTools.jl")
|
|
(commit (string-append "v" version))))
|
|
(file-name "IterTools")
|
|
(sha256
|
|
(base32 "1iq08xpj1gb2wz2hx7g177clxnxcwlma12dj240xnk7q0g623hbv"))))
|
|
(build-system julia-build-system)
|
|
(home-page "https://juliacollections.github.io/IterTools.jl/stable/")
|
|
(synopsis "Common functional iterator patterns")
|
|
(description "This Julia package provides common functional iterator
|
|
patterns like @code{nth}, @code{takenth}, @code{groupby}.")
|
|
(license license:expat)))
|
|
|
|
(define-public julia-geometrytypes
|
|
(package
|
|
(name "julia-geometrytypes")
|
|
(version "0.7.6")
|
|
(source
|
|
(origin
|
|
(method git-fetch)
|
|
(uri (git-reference
|
|
(url "https://github.com/JuliaGeometry/GeometryTypes.jl")
|
|
(commit "9294dcba10e7fbb4b6f504b6c56d3fcbc3bc5ca7")))
|
|
(file-name "GeometryTypes")
|
|
(sha256
|
|
(base32 "1skg4rx0a0ripm68ahj926xsqyd7zqkqlqij02l16n0x1k1cvbj4"))))
|
|
(propagated-inputs `(("julia-staticarrays" ,julia-staticarrays)
|
|
("julia-fixedpointnumbers" ,julia-fixedpointnumbers)
|
|
("julia-itertools" ,julia-itertools)
|
|
("julia-colortypes" ,julia-colortypes)))
|
|
(build-system julia-build-system)
|
|
(home-page "https://juliageometry.github.io/GeometryTypes.jl/stable/")
|
|
(synopsis "Geometry types for Julia")
|
|
(description "Geometry primitives and operations building up on
|
|
FixedSizeArrays.")
|
|
(license license:expat)))
|
|
|
|
(define-public julia-gr
|
|
(package
|
|
(name "julia-gr")
|
|
(version "0.41.0")
|
|
(source
|
|
(origin
|
|
(method git-fetch)
|
|
(uri (git-reference
|
|
(url "https://github.com/jheinen/GR.jl")
|
|
(commit (string-append "v" version))))
|
|
(file-name "GR")
|
|
(sha256
|
|
(base32 "0ciklxny3g3j87z00xf2hlshiy7h5zbdcf9fpwhb8xy6qci61rd1"))))
|
|
(propagated-inputs `(("gr" ,gr)))
|
|
(arguments
|
|
`(#:phases
|
|
(modify-phases %standard-phases
|
|
(add-before 'precompile 'build-deps
|
|
(lambda*
|
|
(#:key outputs source inputs #:allow-other-keys)
|
|
(substitute*
|
|
(string-append (assoc-ref outputs "out")
|
|
"/share/julia/packages/"
|
|
(strip-store-file-name source) "/src/GR.jl")
|
|
(("const libGR = \"libGR.so\"")
|
|
(string-append "const libGR = \""
|
|
(assoc-ref inputs "gr")
|
|
"/lib/libGR.so\""))
|
|
(("const libGR3 = \"libGR3.so\"")
|
|
(string-append "const libGR3 = \""
|
|
(assoc-ref inputs "gr")
|
|
"/lib/libGR3.so\""))
|
|
((" = grdir")
|
|
(string-append " = \""
|
|
(assoc-ref inputs "gr")
|
|
"\"")))
|
|
#t)))))
|
|
(build-system julia-build-system)
|
|
(home-page "https://github.com/jheinen/GR.jl")
|
|
(synopsis "Plotting for Julia based on GR, a framework for visualisation
|
|
applications")
|
|
(description "This Julia package provides an interface to the GR
|
|
visualization framework.")
|
|
(license license:expat)))
|
|
|
|
(define-public julia-plotthemes
|
|
(package
|
|
(name "julia-plotthemes")
|
|
(version "0.4.0")
|
|
(source
|
|
(origin
|
|
(method git-fetch)
|
|
(uri (git-reference
|
|
(url "https://github.com/JuliaPlots/PlotThemes.jl")
|
|
(commit (string-append "v" version))))
|
|
(file-name "PlotThemes")
|
|
(sha256
|
|
(base32 "0q6s3bwds1k1xcryj0y33l6lw0bl9kj6ljd0ph7rii445b7a9sk4"))))
|
|
(propagated-inputs `(("julia-plotutils" ,julia-plotutils)
|
|
("julia-requires" ,julia-requires)))
|
|
(build-system julia-build-system)
|
|
(home-page "https://github.com/JuliaPlots/PlotThemes.jl")
|
|
(synopsis "PlotThemes is a package to spice up the plots made with
|
|
@code{Plots.jl}")
|
|
(description "Custom plotting themes for @code{Plots.jl}, including both
|
|
light and dark themes.")
|
|
(license license:expat)))
|
|
|
|
(define-public julia-ffmpeg
|
|
(package
|
|
(name "julia-ffmpeg")
|
|
(version "0.2.3")
|
|
(source
|
|
(origin
|
|
(method git-fetch)
|
|
(uri (git-reference
|
|
(url "https://github.com/JuliaIO/FFMPEG.jl")
|
|
(commit (string-append "v" version))))
|
|
(file-name "FFMPEG")
|
|
(sha256
|
|
(base32 "1rnb7n5gzn7bsiz09fqapw4fcqc1p5bjcjw4ha3kxcs70w4by52x"))))
|
|
(arguments
|
|
`(#:phases
|
|
(modify-phases %standard-phases
|
|
(add-before 'precompile 'build-deps
|
|
(lambda* (#:key outputs source inputs #:allow-other-keys)
|
|
(let ((f (open-file
|
|
(string-append
|
|
(assoc-ref outputs "out")
|
|
"/share/julia/packages/"
|
|
(string-append
|
|
(strip-store-file-name source) "/deps/deps.jl"))
|
|
"w")))
|
|
(display (string-append "const libavcodec = \""
|
|
(assoc-ref inputs "ffmpeg")
|
|
"/lib/libavcodec.so\"\n") f)
|
|
(display (string-append "const libavformat = \""
|
|
(assoc-ref inputs "ffmpeg")
|
|
"/lib/libavformat.so\"\n") f)
|
|
(display (string-append "const libavcodec = \""
|
|
(assoc-ref inputs "ffmpeg")
|
|
"/lib/libavcodec.so\"\n") f)
|
|
(display (string-append "const libavutil = \""
|
|
(assoc-ref inputs "ffmpeg")
|
|
"/lib/libavutil.so\"\n") f)
|
|
(display (string-append "const libswscale = \""
|
|
(assoc-ref inputs "ffmpeg")
|
|
"/lib/libswscale.so\"\n") f)
|
|
(display (string-append "const libavdevice = \""
|
|
(assoc-ref inputs "ffmpeg")
|
|
"/lib/libavdevice.so\"\n") f)
|
|
(display (string-append "const libavfilter = \""
|
|
(assoc-ref inputs "ffmpeg")
|
|
"/lib/libavfilter.so\"\n") f)
|
|
(display (string-append "const ffmpeg = \""
|
|
(assoc-ref inputs "ffmpeg")
|
|
"/bin/ffmpeg\"\n") f)
|
|
(close-port f))
|
|
(substitute*
|
|
(string-append (assoc-ref
|
|
outputs "out") "/share/julia/packages/"
|
|
(string-append (strip-store-file-name
|
|
source) "/src/FFMPEG.jl"))
|
|
(("const libpath = joinpath(@__DIR__, \"..\", \"deps\", \"usr\", \"lib\")")
|
|
(string-append "const libpath = \""
|
|
(assoc-ref inputs "ffmpeg")
|
|
"/lib")))
|
|
#t)))))
|
|
(propagated-inputs `(("julia-binaryprovider" ,julia-binaryprovider)
|
|
("ffmpeg" ,ffmpeg)))
|
|
(build-system julia-build-system)
|
|
(home-page "https://github.com/JuliaIO/FFMPEG.jl")
|
|
(synopsis "Wrapper for the ffmpeg executable in Julia")
|
|
(description "Low level ffmpeg API used to get ffmpeg binaries and
|
|
executables.")
|
|
(license license:expat)))
|
|
|
|
(define-public julia-recipesbase
|
|
(package
|
|
(name "julia-recipesbase")
|
|
(version "0.7.0")
|
|
(source
|
|
(origin
|
|
(method git-fetch)
|
|
(uri (git-reference
|
|
(url "https://github.com/JuliaPlots/RecipesBase.jl")
|
|
(commit (string-append "v" version))))
|
|
(file-name "RecipesBase")
|
|
(sha256
|
|
(base32 "18dkzvnx6jcqvjaqx592bbxv5wgsl75japq56ij2s8p6gc868lvs"))))
|
|
(build-system julia-build-system)
|
|
(home-page "https://github.com/JuliaPlots/RecipesBase.jl")
|
|
(synopsis "Base package for defining transformation recipes on user types
|
|
for Plots.jl")
|
|
(description "This package implements handy macros @code{@@recipe} and
|
|
@code{@@series} which will define a custom transformation and attach attributes
|
|
for user types. Its design is an attempt to simplify and generalize the
|
|
summary and display of types and data from external packages. With no extra
|
|
dependencies and minimal code, package authors can describe visualization
|
|
routines that can be used as components in more complex visualizations.")
|
|
(license license:expat)))
|
|
|
|
(define-public julia-showoff
|
|
(package
|
|
(name "julia-showoff")
|
|
(version "0.2.1")
|
|
(source
|
|
(origin
|
|
(method git-fetch)
|
|
(uri (git-reference
|
|
(url "https://github.com/JuliaGraphics/Showoff.jl")
|
|
(commit "8502c2ec11f93c4f50c609ff4168aab31154b39d")))
|
|
(file-name "Showoff")
|
|
(sha256
|
|
(base32 "10iydva8vqlfv4i5jw31q9pc7877syd0bfz2djg93xdy90l4c617"))))
|
|
(propagated-inputs `(("julia-compat" ,julia-compat)))
|
|
(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 "Showoff provides an interface for consistently formatting an
|
|
array of n things, e.g. numbers, dates, unitful values.")
|
|
(license license:expat)))
|
|
|
|
(define-public julia-plots
|
|
(package
|
|
(name "julia-plots")
|
|
(version "0.27.0")
|
|
(source
|
|
(origin
|
|
(method git-fetch)
|
|
(uri (git-reference
|
|
(url "https://github.com/JuliaPlots/Plots.jl")
|
|
(commit (string-append "v" version))))
|
|
(file-name "Plots")
|
|
(sha256
|
|
(base32 "0cqg464g9wd2chgn4jjb7ylp0f6kk3hbvhzm2i2530qw2z9aaky6"))))
|
|
(propagated-inputs `(("julia-reexport" ,julia-reexport)
|
|
("julia-json" ,julia-json)
|
|
("julia-fixedpointnumbers" ,julia-fixedpointnumbers)
|
|
("julia-nanmath" ,julia-nanmath)
|
|
("julia-statsbase" ,julia-statsbase)
|
|
("julia-measures" ,julia-measures)
|
|
("julia-plotutils" ,julia-plotutils)
|
|
("julia-contour" ,julia-contour)
|
|
("julia-requires" ,julia-requires)
|
|
("julia-geometrytypes" ,julia-geometrytypes)
|
|
("julia-plotthemes" ,julia-plotthemes)
|
|
("julia-gr" ,julia-gr)
|
|
("julia-ffmpeg" ,julia-ffmpeg)
|
|
("julia-recipesbase" ,julia-recipesbase)
|
|
("julia-showoff" ,julia-showoff)))
|
|
(build-system julia-build-system)
|
|
(home-page "http://docs.juliaplots.org/latest/")
|
|
(synopsis "Powerful convenience for Julia visualizations and data analysis")
|
|
(description "Plots is a plotting API and toolset. My goals with the
|
|
package are:
|
|
@enumerate
|
|
@item @strong{Powerful}. Do more with less. Complex visualizations become easy
|
|
@item @strong{Intuitive}. Stop reading so much documentation
|
|
@item @strong{Concise}. Less code means fewer mistakes
|
|
@item @strong{Flexible}. Produce your favorite plots from your favorite package
|
|
@item @strong{Consistent}. Don't commit to one graphics package
|
|
@item @strong{Lightweight}. Very few dependencies
|
|
@item @strong{Smart}. Attempts to figure out what you want it to do
|
|
@end enumerate")
|
|
(license license:expat)))
|
|
|
|
(define-public julia-codetracking
|
|
(package
|
|
(name "julia-codetracking")
|
|
(version "0.5.8")
|
|
(source
|
|
(origin
|
|
(method git-fetch)
|
|
(uri (git-reference
|
|
(url "https://github.com/timholy/CodeTracking.jl")
|
|
(commit (string-append "v" version))))
|
|
(file-name "CodeTracking")
|
|
(sha256
|
|
(base32 "0w1kwhzmvn5snxj28l7syx1f3hzdd03zb6fni7xx29ghccp00zww"))))
|
|
(build-system julia-build-system)
|
|
(home-page "https://github.com/timholy/CodeTracking.jl")
|
|
(synopsis "It's editing-time, do you know where your methods are?")
|
|
(description "@code{CodeTracking} is a minimal package designed to work
|
|
with @code{Revise.jl}. Its main purpose is to support packages that need to
|
|
interact with code that might move around as it gets edited.")
|
|
(license license:expat)))
|
|
|
|
(define-public julia-juliainterpreter
|
|
(package
|
|
(name "julia-juliainterpreter")
|
|
(version "0.7.4")
|
|
(source
|
|
(origin
|
|
(method git-fetch)
|
|
(uri (git-reference
|
|
(url "https://github.com/JuliaDebug/JuliaInterpreter.jl")
|
|
(commit (string-append "v" version))))
|
|
(file-name "JuliaInterpreter")
|
|
(sha256
|
|
(base32 "0j4rp2wd5vqgz7ggnzyr0whvsqy8nmpngfwl1pfx2p22p2r4anbm"))))
|
|
(propagated-inputs `(("julia-codetracking" ,julia-codetracking)))
|
|
(build-system julia-build-system)
|
|
(home-page "https://juliadebug.github.io/JuliaInterpreter.jl/stable/")
|
|
(synopsis "Interpreter for Julia code")
|
|
(description "This package implements an interpreter for Julia
|
|
code. Normally, Julia compiles your code when you first execute it; using
|
|
JuliaInterpreter you can avoid compilation and execute the expressions that
|
|
define your code directly. Interpreters have a number of applications,
|
|
including support for stepping debuggers.")
|
|
(license license:expat)))
|
|
|
|
(define-public julia-loweredcodeutils
|
|
(package
|
|
(name "julia-loweredcodeutils")
|
|
(version "0.3.8")
|
|
(source
|
|
(origin
|
|
(method git-fetch)
|
|
(uri (git-reference
|
|
(url "https://github.com/JuliaDebug/LoweredCodeUtils.jl")
|
|
(commit (string-append "v" version))))
|
|
(file-name "LoweredCodeUtils")
|
|
(sha256
|
|
(base32 "00kyn5javyylkdpd8cmv9qifgh7yw0klskf5wvq4ab9jadfjq6za"))))
|
|
(propagated-inputs `(("julia-juliainterpreter" ,julia-juliainterpreter)))
|
|
(build-system julia-build-system)
|
|
(home-page "https://github.com/JuliaDebug/LoweredCodeUtils.jl")
|
|
(synopsis "Tools for manipulating Julia's lowered code")
|
|
(description "This package performs operations on Julia's lowered AST.")
|
|
(license license:expat)))
|
|
|
|
(define-public julia-revise
|
|
(package
|
|
(name "julia-revise")
|
|
(version "2.2.1")
|
|
(source
|
|
(origin
|
|
(method git-fetch)
|
|
(uri (git-reference
|
|
(url "https://github.com/timholy/Revise.jl")
|
|
(commit (string-append "v" version))))
|
|
(file-name "Revise")
|
|
(sha256
|
|
(base32 "1rs7d32iiv34x8zs08bn5a4bp11yy4q6hm0rsh3n85ga0rbk0xsr"))))
|
|
(propagated-inputs
|
|
`(("julia-codetracking" ,julia-codetracking)
|
|
("julia-loweredcodeutils" ,julia-loweredcodeutils)
|
|
("julia-juliainterpreter" ,julia-juliainterpreter)
|
|
("julia-orderedcollections" ,julia-orderedcollections)))
|
|
(build-system julia-build-system)
|
|
(home-page "https://timholy.github.io/Revise.jl/stable/")
|
|
(synopsis "Automatically update function definitions in a running Julia
|
|
session")
|
|
(description "@code{Revise.jl} allows you to modify code and use the changes
|
|
without restarting Julia. With Revise, you can be in the middle of a session
|
|
and then update packages, switch git branches, and/or edit the source code in
|
|
the editor of your choice; any changes will typically be incorporated into the
|
|
very next command you issue from the REPL. This can save you the overhead of
|
|
restarting Julia, loading packages, and waiting for code to JIT-compile.")
|
|
(license license:expat)))
|
|
|
|
(define-public julia-tabletraitsutils
|
|
(package
|
|
(name "julia-tabletraitsutils")
|
|
(version "1.0.0")
|
|
(source
|
|
(origin
|
|
(method git-fetch)
|
|
(uri (git-reference
|
|
(url "https://github.com/queryverse/TableTraitsUtils.jl")
|
|
(commit (string-append "v" version))))
|
|
(file-name "TableTraitsUtils")
|
|
(sha256
|
|
(base32 "0axmrznfmii7c909mcgr2zpzlddj62j1dhnss6d2gl9ar5mw5cl9"))))
|
|
(propagated-inputs `(("julia-datavalues" ,julia-datavalues)
|
|
("julia-tabletraits" ,julia-tabletraits)
|
|
("julia-missings" ,julia-missings)
|
|
("julia-iteratorinterfaceextensions"
|
|
,julia-iteratorinterfaceextensions)))
|
|
(build-system julia-build-system)
|
|
(home-page "https://github.com/queryverse/TableTraitsUtils.jl")
|
|
(synopsis "Utilities for implementing the @code{TableTraits.jl}
|
|
interfaces")
|
|
(description "@code{TableTraitsUtils.jl} provides default implementations
|
|
of the TableTraits.jl interface.")
|
|
(license license:expat)))
|
|
|
|
(define-public julia-iterabletables
|
|
(package
|
|
(name "julia-iterabletables")
|
|
(version "0.11.0")
|
|
(source
|
|
(origin
|
|
(method git-fetch)
|
|
(uri (git-reference
|
|
(url "https://github.com/queryverse/IterableTables.jl")
|
|
(commit "2683c006134613131c1f747c0f0fa40ec6e49bf0")))
|
|
(file-name "IterableTables")
|
|
(sha256
|
|
(base32 "1ifhlvrq16nki11pa6sqys9fna0v91659snp0x0y2sb1q2y2lv4g"))))
|
|
(propagated-inputs
|
|
`(("julia-datavalues" ,julia-datavalues)
|
|
("julia-requires" ,julia-requires)
|
|
("julia-tabletraits" ,julia-tabletraits)
|
|
("julia-tabletraitsutils" ,julia-tabletraitsutils)
|
|
("julia-iteratorinterfaceextensions"
|
|
,julia-iteratorinterfaceextensions)))
|
|
(build-system julia-build-system)
|
|
(home-page "https://github.com/queryverse/IterableTables.jl")
|
|
(synopsis "Implementations of the @code{TableTraits.jl} interface for
|
|
various packages")
|
|
(description "Iterable tables is a generic interface for tabular data. A
|
|
large number of packages are compatible with this interface.")
|
|
(license license:expat)))
|
|
|
|
(define-public julia-tableshowutils
|
|
(package
|
|
(name "julia-tableshowutils")
|
|
(version "0.2.5")
|
|
(source
|
|
(origin
|
|
(method git-fetch)
|
|
(uri (git-reference
|
|
(url "https://github.com/queryverse/TableShowUtils.jl")
|
|
(commit "0515a2cc615d55c2c5412e8d84740ea01fa4f7aa")))
|
|
(file-name "TableShowUtils")
|
|
(sha256
|
|
(base32 "1mbniba5llf4f0k57wwd2a0i5c77d1sry66xaz9h9w5b2lhx7cdy"))))
|
|
(propagated-inputs `(("julia-json" ,julia-json)
|
|
("julia-datavalues" ,julia-datavalues)))
|
|
(build-system julia-build-system)
|
|
(home-page "https://github.com/queryverse/TableShowUtils.jl")
|
|
(synopsis "Package that provides helpers for implementing show for
|
|
TableTraits.jl types")
|
|
(description "This package provides some common helper functions that make
|
|
it easier to implement various @code{Base.show} functions for types that
|
|
participate in the TableTraits.jl ecosystem. Most users will probably not
|
|
have any direct use for this package.")
|
|
(license license:expat)))
|
|
|
|
(define-public julia-queryoperators
|
|
(package
|
|
(name "julia-queryoperators")
|
|
(version "0.9.1")
|
|
(source
|
|
(origin
|
|
(method git-fetch)
|
|
(uri (git-reference
|
|
(url "https://github.com/queryverse/QueryOperators.jl")
|
|
(commit (string-append "v" version))))
|
|
(file-name "QueryOperators")
|
|
(sha256
|
|
(base32 "0phia28rwz49bdiyakpag3isnk9wiqmzigfcnyb42mymx65x8841"))))
|
|
(propagated-inputs `(("julia-datavalues" ,julia-datavalues)
|
|
("julia-datastructures" ,julia-datastructures)
|
|
("julia-tableshowutils" ,julia-tableshowutils)
|
|
("julia-iteratorinterfaceextensions"
|
|
,julia-iteratorinterfaceextensions)))
|
|
(build-system julia-build-system)
|
|
(home-page "https://github.com/queryverse/QueryOperators.jl")
|
|
(synopsis "This package contains the query operators that are exposed to
|
|
in Query.jl")
|
|
(description "This package contains the underlying query operators that
|
|
are exposed to users in @code{Query.jl}.")
|
|
(license license:expat)))
|
|
|
|
(define-public julia-query
|
|
(package
|
|
(name "julia-query")
|
|
(version "0.12.1")
|
|
(source
|
|
(origin
|
|
(method git-fetch)
|
|
(uri
|
|
(git-reference
|
|
(url "https://github.com/queryverse/Query.jl")
|
|
(commit
|
|
(string-append "v" version))))
|
|
(file-name "Query")
|
|
(sha256
|
|
(base32 "0pcc03f3vlx1i2llbv3jc8h0hc91jsf66lnrzaibz9ifm0lyda9r"))))
|
|
(propagated-inputs
|
|
`(("julia-macrotools" ,julia-macrotools)
|
|
("julia-queryoperators" ,julia-queryoperators)
|
|
("julia-iterabletables" ,julia-iterabletables)
|
|
("julia-datavalues" ,julia-datavalues)))
|
|
(build-system julia-build-system)
|
|
(home-page "https://github.com/queryverse/Query.jl")
|
|
(synopsis "Query almost anything in julia")
|
|
(description "Query is a package for querying julia data sources. It can
|
|
filter, project, join and group data from any iterable data source, including
|
|
all the sources supported in @code{IterableTables.jl}.")
|
|
(license license:expat)))
|
|
|
|
(define-public julia-fileio
|
|
(package
|
|
(name "julia-fileio")
|
|
(version "1.0.7")
|
|
(source
|
|
(origin
|
|
(method git-fetch)
|
|
(uri (git-reference
|
|
(url "https://github.com/JuliaIO/FileIO.jl")
|
|
(commit (string-append "v" version))))
|
|
(file-name "FileIO")
|
|
(sha256
|
|
(base32 "0dwsklxzc4nhsii9hhjp1h3cbf9n5abipj44jf3i0zncid06aanv"))))
|
|
(propagated-inputs `(("julia-compat" ,julia-compat)))
|
|
(build-system julia-build-system)
|
|
(home-page "https://github.com/JuliaIO/FileIO.jl")
|
|
(synopsis "Main Package for IO, loading all different kind of files")
|
|
(description "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
|
|
read and write). To avoid name conflicts, packages that provide support for
|
|
standard file formats through functions named load and save are encouraged to
|
|
extend the definitions here.")
|
|
(license license:expat)))
|
|
|
|
(define-public julia-nullables
|
|
(package
|
|
(name "julia-nullables")
|
|
(version "0.0.8")
|
|
(source
|
|
(origin
|
|
(method git-fetch)
|
|
(uri (git-reference
|
|
(url "https://github.com/JuliaAttic/Nullables.jl")
|
|
(commit (string-append "v" version))))
|
|
(file-name "Nullables")
|
|
(sha256
|
|
(base32 "00mdnk5hrl04wyw7g8dwybnxzn2wh0l52pa7398l3wggak2iqx1b"))))
|
|
(propagated-inputs `(("julia-compat" ,julia-compat)))
|
|
(build-system julia-build-system)
|
|
(arguments
|
|
`(#:phases
|
|
(modify-phases %standard-phases
|
|
(add-before 'precompile 'fix-toml
|
|
(lambda*
|
|
(#:key outputs source #:allow-other-keys)
|
|
(julia-create-package-toml
|
|
outputs source
|
|
"Nullables"
|
|
"4d1e1d77-625e-5b40-9113-a560ec7a8ecd"
|
|
"0.0.8"
|
|
'())
|
|
#t)))))
|
|
(home-page "https://github.com/JuliaAttic/Nullables.jl")
|
|
(synopsis "Nullable type for Julia")
|
|
(description "This package provides the Nullable type from Julia. It also
|
|
defines the unsafe_get and isnull functions, and all methods previously
|
|
implemented in Julia Base: @code{get}, @code{eltype}, @code{convert},
|
|
@code{promote}, @code{show}, @code{map}, @code{broadcast}, @code{filter},
|
|
@code{isequal}, @code{isless} and @code{hash}.")
|
|
(license license:expat)))
|
|
|
|
(define-public julia-specialfunctions
|
|
(package
|
|
(name "julia-specialfunctions")
|
|
(version "0.8.0")
|
|
(source
|
|
(origin
|
|
(method git-fetch)
|
|
(uri (git-reference
|
|
(url "https://github.com/JuliaMath/SpecialFunctions.jl")
|
|
(commit (string-append "v" version))))
|
|
(file-name "SpecialFunctions")
|
|
(sha256
|
|
(base32 "05kz4x06wcp785ivy8v6z69qcfxsjw86npf52xjic9a8rnnlcqj4"))))
|
|
(propagated-inputs `(("julia-bindeps" ,julia-bindeps)
|
|
("julia-binaryprovider" ,julia-binaryprovider)
|
|
("openspecfun" ,openspecfun)))
|
|
(arguments
|
|
`(#:phases
|
|
(modify-phases %standard-phases
|
|
(add-before 'precompile 'build-deps
|
|
(lambda* (#:key outputs source inputs #:allow-other-keys)
|
|
(let ((f (open-file
|
|
(string-append
|
|
(assoc-ref outputs "out")
|
|
"/share/julia/packages/"
|
|
(string-append
|
|
(strip-store-file-name source) "/deps/deps.jl"))
|
|
"w")))
|
|
(display (string-append "const openspecfun = \""
|
|
(assoc-ref inputs "openspecfun")
|
|
"/lib/libopenspecfun.so\"\n") f)
|
|
(display "check_deps() = true\n" f)
|
|
(close-port f))
|
|
#t)))))
|
|
(build-system julia-build-system)
|
|
(home-page "https://juliamath.github.io/SpecialFunctions.jl/stable/")
|
|
(synopsis "Special mathematical functions in Julia")
|
|
(description "Special mathematical functions in Julia, including Bessel,
|
|
Hankel, Airy, error, Dawson, sine and cosine integrals, eta, zeta, digamma,
|
|
inverse digamma, trigamma, and polygamma functions. Most of these functions
|
|
were formerly part of Base in early versions of Julia.")
|
|
(license license:expat)))
|
|
|
|
(define-public julia-quadmath
|
|
(package
|
|
(name "julia-quadmath")
|
|
(version "0.5.2")
|
|
(source
|
|
(origin
|
|
(method git-fetch)
|
|
(uri (git-reference
|
|
(url "https://github.com/JuliaMath/Quadmath.jl")
|
|
(commit (string-append "v" version))))
|
|
(file-name "Quadmath")
|
|
(sha256
|
|
(base32 "0gq0zxkqwv9z8w0635zcp86q7q67vgc91b6f4xrr3miq2fiy44q3"))))
|
|
(propagated-inputs `(("julia-requires" ,julia-requires)
|
|
("julia-specialfunctions" ,julia-specialfunctions)))
|
|
(build-system julia-build-system)
|
|
(home-page "https://github.com/JuliaMath/Quadmath.jl")
|
|
(synopsis "Float128 and libquadmath for the Julia language")
|
|
(description "This is a Julia interface to libquadmath, providing a
|
|
Float128 type corresponding to the IEEE754 binary128 floating point format.")
|
|
(license license:expat)))
|
|
|
|
(define-public julia-genericschur
|
|
(package
|
|
(name "julia-genericschur")
|
|
(version "0.3.0")
|
|
(source
|
|
(origin
|
|
(method git-fetch)
|
|
(uri (git-reference
|
|
(url "https://github.com/RalphAS/GenericSchur.jl")
|
|
(commit (string-append "v" version))))
|
|
(file-name "GenericSchur")
|
|
(sha256
|
|
(base32 "1hr8zkanbrysqzr61rwhbv1a306zfcfrjjw96whrxy7fm4qf9j6v"))))
|
|
(build-system julia-build-system)
|
|
(home-page "https://github.com/RalphAS/GenericSchur.jl")
|
|
(synopsis "Julia package for Schur decomposition of matrices with
|
|
generic element types")
|
|
(description "Schur decomposition for matrices of generic element types
|
|
in Julia. The Schur decomposition is the workhorse for eigensystem analysis
|
|
of dense non-symmetric matrices.")
|
|
(license license:expat)))
|
|
|
|
(define-public julia-genericsvd
|
|
(package
|
|
(name "julia-genericsvd")
|
|
(version "0.2.2")
|
|
(source
|
|
(origin
|
|
(method git-fetch)
|
|
(uri (git-reference
|
|
(url "https://github.com/JuliaLinearAlgebra/GenericSVD.jl")
|
|
(commit (string-append "v" version))))
|
|
(file-name "GenericSVD")
|
|
(sha256
|
|
(base32 "1qhyyls9m1k8hwf7fhkbd0ksn2r50n4l25f0v6gahjah5yqdz6bq"))))
|
|
(propagated-inputs `(("julia-compat" ,julia-compat)))
|
|
(build-system julia-build-system)
|
|
(home-page "https://github.com/JuliaLinearAlgebra/GenericSVD.jl")
|
|
(synopsis " Singular Value Decomposition for generic number types")
|
|
(description "Implements Singular Value Decomposition for generic
|
|
number types, such as BigFloat, Complex{BigFloat} or Quaternions. It
|
|
internally overloads several Base functions such that existing methods (svd,
|
|
svdfact and svdvals) should work directly.")
|
|
(license license:expat)))
|
|
|
|
(define-public julia-polynomials
|
|
(package
|
|
(name "julia-polynomials")
|
|
(version "0.5.3")
|
|
(source
|
|
(origin
|
|
(method git-fetch)
|
|
(uri (git-reference
|
|
(url "https://github.com/JuliaMath/Polynomials.jl")
|
|
(commit (string-append "v" version))))
|
|
(file-name "Polynomials")
|
|
(sha256
|
|
(base32 "1ax4q27fkl1w12by159wbzk7wvyb6c2jayg5kvhgpdq9g500pidw"))))
|
|
(propagated-inputs `(("julia-recipesbase" ,julia-recipesbase)))
|
|
(build-system julia-build-system)
|
|
(home-page "https://juliamath.github.io/Polynomials.jl/stable/")
|
|
(synopsis "Polynomial manipulations in Julia")
|
|
(description "Basic arithmetic, integration, differentiation, evaluation,
|
|
and root finding over dense univariate polynomials.")
|
|
(license license:expat)))
|
|
|
|
(define-public julia-doublefloats
|
|
(package
|
|
(name "julia-doublefloats")
|
|
(version "0.9.11")
|
|
(source
|
|
(origin
|
|
(method git-fetch)
|
|
(uri (git-reference
|
|
(url "https://github.com/JuliaMath/DoubleFloats.jl")
|
|
(commit (string-append "v" version))))
|
|
(file-name "DoubleFloats")
|
|
(sha256
|
|
(base32 "1gi3wlrn9v6xlprr09dszzi4x7vmafrw0w239w9zhm53sixdfxgg"))))
|
|
(propagated-inputs `(("julia-quadmath" ,julia-quadmath)
|
|
("julia-requires" ,julia-requires)
|
|
("julia-polynomials" ,julia-polynomials)
|
|
("julia-genericschur" ,julia-genericschur)
|
|
("julia-genericsvd" ,julia-genericsvd)))
|
|
(build-system julia-build-system)
|
|
(home-page "https://github.com/JuliaMath/DoubleFloats.jl")
|
|
(synopsis "Math with more good bits")
|
|
(description "Julia math with 85+ accurate bits. Extended precision float
|
|
and complex types.")
|
|
(license license:expat)))
|