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