nixo
/
guix-devel
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity
guix-devel/gnu/packages/julia-xyz.scm

2152 lines
83 KiB
Scheme
Raw Blame History

;;; 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)))
(define-public julia-weakrefstrings
(package
(name "julia-weakrefstrings")
(version "0.6.1")
(source
(origin
(method git-fetch)
(uri (git-reference
(url "https://github.com/JuliaData/WeakRefStrings.jl")
(commit (string-append "v" version))))
(file-name "WeakRefStrings")
(sha256
(base32 "00sfqhw2niarfmpn8i3dmv5dfhyj3bylvwp4yrq77b560g997khh"))))
(build-system julia-build-system)
(home-page "https://github.com/JuliaData/WeakRefStrings.jl")
(synopsis "String type for Julia that allows efficient string
representation and transfer")
(description "Minimal String type for Julia that allows for efficient
string representation and transfer.")
(license license:expat)))
(define-public julia-textparse
(package
(name "julia-textparse")
(version "0.9.1")
(source
(origin
(method git-fetch)
(uri (git-reference
(url "https://github.com/JuliaComputing/TextParse.jl")
(commit (string-append "v" version))))
(file-name "TextParse")
(sha256
(base32 "1vzmn4gfhicif5vhzz0h3mv1qgpsmjfq4rz7rhbmkdqbwjfphfw2"))))
(propagated-inputs `(("julia-nullables" ,julia-nullables)
("julia-codeczlib" ,julia-codeczlib)
("julia-doublefloats" ,julia-doublefloats)
("julia-weakrefstrings" ,julia-weakrefstrings)
("julia-pooledarrays" ,julia-pooledarrays)
("julia-datastructures" ,julia-datastructures)))
(build-system julia-build-system)
(home-page "https://github.com/JuliaComputing/TextParse.jl")
(synopsis "Fast text parsing tools")
(description "TextParse uses Julia's generated functions to generate
efficient specialized parsers for text files. Parsing packages can use
TextParse as a framework for implementing parsers for other formats.")
(license license:expat)))
(define-public julia-csvfiles
(package
(name "julia-csvfiles")
(version "0.16.0")
(source
(origin
(method git-fetch)
(uri (git-reference
(url "https://github.com/queryverse/CSVFiles.jl")
(commit (string-append "v" version))))
(file-name "CSVFiles")
(sha256
(base32 "09g045lfc1cszp5lc6l5p12y9qlhrx894s5vd88wy5cmic4250jl"))))
(propagated-inputs
`(("julia-codeczlib" ,julia-codeczlib)
("julia-iterabletables" ,julia-iterabletables)
("julia-fileio" ,julia-fileio)
("julia-textparse" ,julia-textparse)
("julia-datavalues" ,julia-datavalues)
("julia-tabletraitsutils" ,julia-tabletraitsutils)
("julia-tabletraits" ,julia-tabletraits)
("julia-tableshowutils" ,julia-tableshowutils)
("julia-iteratorinterfaceextensions" ,julia-iteratorinterfaceextensions)
("julia-http" ,julia-http)))
(build-system julia-build-system)
(home-page "https://github.com/queryverse/CSVFiles.jl")
(synopsis "FileIO.jl integration for CSV files")
(description "This package provides load and save support for CSV Files
under the @code{FileIO.jl} package.")
(license license:expat)))
(define-public julia-abstracttrees
(package
(name "julia-abstracttrees")
(version "0.2.1")
(source
(origin
(method git-fetch)
(uri (git-reference
(url "https://github.com/Keno/AbstractTrees.jl")
(commit (string-append "v" version))))
(file-name "AbstractTrees")
(sha256
(base32 "0w05zar1hlyqqx7zlzh05h78mjs9vsgaifn5z390crrhb1bgw4bj"))))
(propagated-inputs `(("julia-compat" ,julia-compat)))
(build-system julia-build-system)
(home-page "https://github.com/Keno/AbstractTrees.jl")
(synopsis "Abstract julia interfaces for working with trees")
(description "This package provides several utilities for working with
tree-like data structures. Most importantly, it defines the children method
that any package that contains such a datastructure may import and extend in
order to take advantage of any generic tree algorithm in this package (or
other packages compatible with this package).")
(license license:expat)))
Reference in New Issue View Git Blame Copy Permalink