| 1 | ;;; GNU Guix --- Functional package management for GNU |
| 2 | ;;; Copyright © 2020, 2021 Nicolò Balzarotti <nicolo@nixo.xyz> |
| 3 | ;;; Copyright © 2021 Simon Tournier <zimon.toutoune@gmail.com> |
| 4 | ;;; |
| 5 | ;;; This file is part of GNU Guix. |
| 6 | ;;; |
| 7 | ;;; GNU Guix is free software; you can redistribute it and/or modify it |
| 8 | ;;; under the terms of the GNU General Public License as published by |
| 9 | ;;; the Free Software Foundation; either version 3 of the License, or (at |
| 10 | ;;; your option) any later version. |
| 11 | ;;; |
| 12 | ;;; GNU Guix is distributed in the hope that it will be useful, but |
| 13 | ;;; WITHOUT ANY WARRANTY; without even the implied warranty of |
| 14 | ;;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
| 15 | ;;; GNU General Public License for more details. |
| 16 | ;;; |
| 17 | ;;; You should have received a copy of the GNU General Public License |
| 18 | ;;; along with GNU Guix. If not, see <http://www.gnu.org/licenses/>. |
| 19 | |
| 20 | (define-module (gnu packages julia-xyz) |
| 21 | #:use-module ((guix licenses) #:prefix license:) |
| 22 | #:use-module (guix packages) |
| 23 | #:use-module (guix git-download) |
| 24 | #:use-module (guix build-system julia) |
| 25 | #:use-module (gnu packages gcc) |
| 26 | #:use-module (gnu packages maths) |
| 27 | #:use-module (gnu packages tls)) |
| 28 | |
| 29 | (define-public julia-abstractffts |
| 30 | (package |
| 31 | (name "julia-abstractffts") |
| 32 | (version "1.0.1") |
| 33 | (source |
| 34 | (origin |
| 35 | (method git-fetch) |
| 36 | (uri (git-reference |
| 37 | (url "https://github.com/JuliaMath/AbstractFFTS.jl") |
| 38 | (commit (string-append "v" version)))) |
| 39 | (file-name (git-file-name name version)) |
| 40 | (sha256 |
| 41 | (base32 "0083pwdyxjb04i330ir9pc8kmp4bwk59lx1jgc9qi05y8j7xzbp0")))) |
| 42 | (build-system julia-build-system) |
| 43 | (inputs ;required for tests |
| 44 | `(("julia-unitful" ,julia-unitful))) |
| 45 | (home-page "https://github.com/JuliaGPU/Adapt.jl") |
| 46 | (synopsis "General framework for fast Fourier transforms (FFTs)") |
| 47 | (description "This package allows multiple FFT packages to co-exist with |
| 48 | the same underlying @code{fft(x)} and @code{plan_fft(x)} interface. It is |
| 49 | mainly not intended to be used directly. Instead, developers of packages that |
| 50 | implement FFTs (such as @code{FFTW.jl} or @code{FastTransforms.jl}) extend the |
| 51 | types/functions defined in AbstractFFTs.") |
| 52 | (license license:expat))) |
| 53 | |
| 54 | (define-public julia-adapt |
| 55 | (package |
| 56 | (name "julia-adapt") |
| 57 | (version "3.1.1") |
| 58 | (source |
| 59 | (origin |
| 60 | (method git-fetch) |
| 61 | (uri (git-reference |
| 62 | (url "https://github.com/JuliaGPU/Adapt.jl") |
| 63 | (commit (string-append "v" version)))) |
| 64 | (file-name (git-file-name name version)) |
| 65 | (sha256 |
| 66 | (base32 "1lks6k3a1gvwlplld47nh6xfy3nnlpc0vhkzg6zg0qn33qdmavrg")))) |
| 67 | (build-system julia-build-system) |
| 68 | (home-page "https://github.com/JuliaGPU/Adapt.jl") |
| 69 | (synopsis "Package providing the @code{adapt} function, similar to @code{convert}") |
| 70 | (description "This Julia package provides the @code{adapt(T, x)} function |
| 71 | acts like @code{convert(T, x)}, but without the restriction of returning a |
| 72 | @code{T}. This allows you to \"convert\" wrapper types like @code{Adjoint} to |
| 73 | be GPU compatible without throwing away the wrapper.") |
| 74 | (license license:expat))) |
| 75 | |
| 76 | (define-public julia-benchmarktools |
| 77 | (package |
| 78 | (name "julia-benchmarktools") |
| 79 | (version "0.5.0") |
| 80 | (source |
| 81 | (origin |
| 82 | (method git-fetch) |
| 83 | (uri (git-reference |
| 84 | (url "https://github.com/JuliaCI/BenchmarkTools.jl") |
| 85 | (commit (string-append "v" version)))) |
| 86 | (file-name (git-file-name name version)) |
| 87 | (sha256 |
| 88 | (base32 "0nsx21m3i5h22lkgyrmfj6r085va6ag40khwssqs8y7l0wz98lvp")))) |
| 89 | (build-system julia-build-system) |
| 90 | (propagated-inputs `(("julia-json" ,julia-json))) |
| 91 | (home-page "https://github.com/JuliaCI/BenchmarkTools.jl") |
| 92 | (synopsis "Benchmarking framework for the Julia language") |
| 93 | (description "@code{BenchmarkTools.jl} makes performance tracking of Julia |
| 94 | code easy by supplying a framework for writing and running groups of |
| 95 | benchmarks as well as comparing benchmark results.") |
| 96 | (license license:expat))) |
| 97 | |
| 98 | (define-public julia-bufferedstreams |
| 99 | (package |
| 100 | (name "julia-bufferedstreams") |
| 101 | (version "1.0.0") |
| 102 | (source |
| 103 | (origin |
| 104 | (method git-fetch) |
| 105 | (uri (git-reference |
| 106 | (url "https://github.com/BioJulia/BufferedStreams.jl") |
| 107 | (commit (string-append "v" version)))) |
| 108 | (file-name (git-file-name name version)) |
| 109 | (sha256 |
| 110 | (base32 "0sf4sxbq55mg2pwxyxf0c839z1lk0yxg8nmb7617bfbvw31cp88z")))) |
| 111 | (build-system julia-build-system) |
| 112 | ;; The package is old and tests are using undefined functions. They also |
| 113 | ;; freeze, see |
| 114 | ;; https://travis-ci.org/BioJulia/BufferedStreams.jl/jobs/491050182 |
| 115 | (arguments |
| 116 | '(#:tests? #f |
| 117 | #:julia-package-name "BufferedStreams")) |
| 118 | (propagated-inputs `(("julia-compat" ,julia-compat))) |
| 119 | (home-page "https://github.com/BioJulia/BufferedStreams.jl") |
| 120 | (synopsis "Fast composable IO streams") |
| 121 | (description "@code{BufferedStreams.jl} provides buffering for IO |
| 122 | operations. It can wrap any @code{IO} type automatically making incremental |
| 123 | reading and writing faster.") |
| 124 | (license license:expat))) |
| 125 | |
| 126 | (define-public julia-calculus |
| 127 | (package |
| 128 | (name "julia-calculus") |
| 129 | (version "0.5.1") |
| 130 | (source |
| 131 | (origin |
| 132 | (method git-fetch) |
| 133 | (uri (git-reference |
| 134 | (url "https://github.com/JuliaMath/Calculus.jl") |
| 135 | (commit (string-append "v" version)))) |
| 136 | (file-name (git-file-name name version)) |
| 137 | (sha256 |
| 138 | (base32 "0xh0ak2ycsjw2h86ja24ch3kn2d18zx3frrds78aimwdnqb1gdc2")))) |
| 139 | (build-system julia-build-system) |
| 140 | (home-page "https://github.com/JuliaMath/Calculus.jl") |
| 141 | (synopsis "Common utilities for automatic differentiation") |
| 142 | (description "This package provides tools for working with the basic |
| 143 | calculus operations of differentiation and integration. The @code{Calculus} |
| 144 | package produces approximate derivatives by several forms of finite |
| 145 | differencing or produces exact derivative using symbolic differentiation. It |
| 146 | can also be used to compute definite integrals by different numerical |
| 147 | methods.") |
| 148 | (license license:expat))) |
| 149 | |
| 150 | (define-public julia-chainrules |
| 151 | (package |
| 152 | (name "julia-chainrules") |
| 153 | (version "0.7.54") |
| 154 | (source |
| 155 | (origin |
| 156 | (method git-fetch) |
| 157 | (uri (git-reference |
| 158 | (url "https://github.com/JuliaDiff/ChainRules.jl") |
| 159 | (commit (string-append "v" version)))) |
| 160 | (file-name (git-file-name name version)) |
| 161 | (sha256 |
| 162 | (base32 "1x4w71v8cw0vpba47h8f5xq4gyjfxbcvayzf7m41yg8gf49s9pkf")))) |
| 163 | (build-system julia-build-system) |
| 164 | (inputs ;required for test |
| 165 | `(("julia-chainrulestestutils" ,julia-chainrulestestutils) |
| 166 | ("julia-finitedifferences" ,julia-finitedifferences) |
| 167 | ("julia-nanmath" ,julia-nanmath) |
| 168 | ("julia-specialfunctions" ,julia-specialfunctions))) |
| 169 | (propagated-inputs |
| 170 | `(("julia-chainrulescore" ,julia-chainrulescore) |
| 171 | ("julia-compat" ,julia-compat) |
| 172 | ("julia-reexport" ,julia-reexport) |
| 173 | ("julia-requires" ,julia-requires))) |
| 174 | (home-page "https://github.com/JuliaDiff/ChainRules.jl") |
| 175 | (synopsis "Common utilities for automatic differentiation") |
| 176 | (description "The is package provides a variety of common utilities that |
| 177 | can be used by downstream automatic differentiation (AD) tools to define and |
| 178 | execute forward-, reverse-, and mixed-mode primitives.") |
| 179 | (license license:expat))) |
| 180 | |
| 181 | (define-public julia-chainrulescore |
| 182 | (package |
| 183 | (name "julia-chainrulescore") |
| 184 | (version "0.9.29") |
| 185 | (source |
| 186 | (origin |
| 187 | (method git-fetch) |
| 188 | (uri (git-reference |
| 189 | (url "https://github.com/JuliaDiff/ChainRulesCore.jl") |
| 190 | (commit (string-append "v" version)))) |
| 191 | (file-name (git-file-name name version)) |
| 192 | (sha256 |
| 193 | (base32 "1k0iayw39n1ikkkhvyi4498vsnzc94skqs41gnd15632gxjfvki4")))) |
| 194 | (build-system julia-build-system) |
| 195 | (inputs ;required for tests |
| 196 | `(("julia-benchmarktools" ,julia-benchmarktools) |
| 197 | ("julia-staticarrays" ,julia-staticarrays))) |
| 198 | (propagated-inputs |
| 199 | `(("julia-compat" ,julia-compat))) |
| 200 | (home-page "https://github.com/JuliaDiff/ChainRulesCore.jl") |
| 201 | (synopsis "Common utilities used by downstream automatic differentiation tools") |
| 202 | (description "The package provides a light-weight dependency for defining |
| 203 | sensitivities for functions without the need to depend on ChainRules itself.") |
| 204 | (license license:expat))) |
| 205 | |
| 206 | (define-public julia-chainrulestestutils |
| 207 | (package |
| 208 | (name "julia-chainrulestestutils") |
| 209 | (version "0.6.4") |
| 210 | (source |
| 211 | (origin |
| 212 | (method git-fetch) |
| 213 | (uri (git-reference |
| 214 | (url "https://github.com/JuliaDiff/ChainRulesTestUtils.jl") |
| 215 | (commit (string-append "v" version)))) |
| 216 | (file-name (git-file-name name version)) |
| 217 | (sha256 |
| 218 | (base32 "1pzs947adnb3cx1qd0cxp2fidk9szz0zsqbas90z1lhydykkvkil")))) |
| 219 | (build-system julia-build-system) |
| 220 | (propagated-inputs |
| 221 | `(("julia-chainrulescore" ,julia-chainrulescore) |
| 222 | ("julia-compat" ,julia-compat) |
| 223 | ("julia-finitedifference" ,julia-finitedifferences))) |
| 224 | (home-page "https://github.com/JuliaDiff/ChainRulesTestUtils.jl") |
| 225 | (synopsis "Common utilities used by downstream automatic differentiation tools") |
| 226 | (description "This package is designed to help in testing |
| 227 | @code{ChainRulesCore.frule} and @code{ChainRulesCore.rrule} methods. The main |
| 228 | entry points are @code{ChainRulesTestUtils.frule_test}, |
| 229 | @code{ChainRulesTestUtils.rrule_test}, and |
| 230 | @code{ChainRulesTestUtils.test_scalar}. Currently this is done via testing the |
| 231 | rules against numerical differentiation (using @code{FiniteDifferences.jl}). |
| 232 | |
| 233 | @code{ChainRulesTestUtils.jl} is separated from @code{ChainRulesCore.jl} so that it |
| 234 | can be a test-only dependency, allowing it to have potentially heavy |
| 235 | dependencies, while keeping @code{ChainRulesCore.jl} as light-weight as possible.") |
| 236 | (license license:expat))) |
| 237 | |
| 238 | (define-public julia-colors |
| 239 | (package |
| 240 | (name "julia-colors") |
| 241 | (version "0.12.6") |
| 242 | (source |
| 243 | (origin |
| 244 | (method git-fetch) |
| 245 | (uri (git-reference |
| 246 | (url "https://github.com/JuliaGraphics/Colors.jl") |
| 247 | (commit (string-append "v" version)))) |
| 248 | (file-name (git-file-name name version)) |
| 249 | (sha256 |
| 250 | (base32 "156zsszgwh6bmznsan0zyha6yvcxw3c5mvc5vr2qfsgxbyh36ln6")))) |
| 251 | (build-system julia-build-system) |
| 252 | (propagated-inputs |
| 253 | `(("julia-colortypes" ,julia-colortypes) |
| 254 | ("julia-fixedpointnumbers" ,julia-fixedpointnumbers) |
| 255 | ("julia-reexport" ,julia-reexport))) |
| 256 | (home-page "https://github.com/JuliaGraphics/Colors.jl") |
| 257 | (synopsis "Tools for dealing with color") |
| 258 | (description "This package provides a wide array of functions for dealing |
| 259 | with color. This includes conversion between colorspaces, measuring distance |
| 260 | between colors, simulating color blindness, parsing colors, and generating |
| 261 | color scales for graphics.") |
| 262 | (license license:expat))) |
| 263 | |
| 264 | (define-public julia-colortypes |
| 265 | (package |
| 266 | (name "julia-colortypes") |
| 267 | (version "0.10.12") |
| 268 | (source |
| 269 | (origin |
| 270 | (method git-fetch) |
| 271 | (uri (git-reference |
| 272 | (url "https://github.com/JuliaGraphics/ColorTypes.jl") |
| 273 | (commit (string-append "v" version)))) |
| 274 | (file-name (git-file-name name version)) |
| 275 | (sha256 |
| 276 | (base32 "176hr3qbz7lncmykks2qaj3cqisnzim7wi5jwsca9ld26wwyvyqq")))) |
| 277 | (arguments |
| 278 | '(#:tests? #f)) ;require Documenter, not packaged yet |
| 279 | (build-system julia-build-system) |
| 280 | (propagated-inputs |
| 281 | `(("julia-fixedpointnumbers" ,julia-fixedpointnumbers))) |
| 282 | (home-page "https://github.com/JuliaGraphics/ColorTypes.jl") |
| 283 | (synopsis "Basic color types and constructor") |
| 284 | (description "This minimalistic package serves as the foundation for |
| 285 | working with colors in Julia. It defines basic color types and their |
| 286 | constructors, and sets up traits and show methods to make them easier to work |
| 287 | with.") |
| 288 | (license license:expat))) |
| 289 | |
| 290 | (define-public julia-commonsubexpressions |
| 291 | (package |
| 292 | (name "julia-commonsubexpressions") |
| 293 | (version "0.3.0") |
| 294 | (source |
| 295 | (origin |
| 296 | (method git-fetch) |
| 297 | (uri (git-reference |
| 298 | (url "https://github.com/rdeits/CommonSubexpressions.jl") |
| 299 | (commit (string-append "v" version)))) |
| 300 | (file-name (git-file-name name version)) |
| 301 | (sha256 |
| 302 | (base32 "0mgy90kk8ksv3l720kkk04gnhn4aqhh2dj4sp3x8yy3limngfjay")))) |
| 303 | (build-system julia-build-system) |
| 304 | (propagated-inputs |
| 305 | `(("julia-macrotools" ,julia-macrotools))) |
| 306 | (home-page "https://github.com/rdeits/CommonSubexpressions.jl") |
| 307 | (synopsis "Macro @code{@cse}") |
| 308 | (description "This package provides the @code{@cse} macro, which performs |
| 309 | common subexpression elimination.") |
| 310 | (license license:expat))) |
| 311 | |
| 312 | (define-public julia-compat |
| 313 | (package |
| 314 | (name "julia-compat") |
| 315 | (version "3.25.0") |
| 316 | (source |
| 317 | (origin |
| 318 | (method git-fetch) |
| 319 | (uri (git-reference |
| 320 | (url "https://github.com/JuliaLang/Compat.jl") |
| 321 | (commit (string-append "v" version)))) |
| 322 | (file-name (git-file-name name version)) |
| 323 | (sha256 |
| 324 | (base32 "1m4r5i8mq29xjp3mllh6047n5a78sdyld57m15anrnsjgaapcgby")))) |
| 325 | (build-system julia-build-system) |
| 326 | (home-page "https://github.com/JuliaLang/Compat.jl") |
| 327 | (synopsis "Compatibility across Julia versions") |
| 328 | (description "The Compat package is designed to ease interoperability |
| 329 | between older and newer versions of the Julia language. The Compat package |
| 330 | provides a macro that lets you use the latest syntax in a backwards-compatible |
| 331 | way.") |
| 332 | (license license:expat))) |
| 333 | |
| 334 | ;;; TODO: Remove this autogenerated source package |
| 335 | ;;; and build it from realse source using <https://github.com/JuliaPackaging/Yggdrasil/> |
| 336 | (define-public julia-compilersupportlibraries-jll |
| 337 | (package |
| 338 | (name "julia-compilersupportlibraries-jll") |
| 339 | (version "0.4.0+1") |
| 340 | (source |
| 341 | (origin |
| 342 | (method git-fetch) |
| 343 | (uri (git-reference |
| 344 | (url "https://github.com/JuliaBinaryWrappers/CompilerSupportLibraries_jll.jl") |
| 345 | (commit (string-append "CompilerSupportLibraries-v" version)))) |
| 346 | (file-name (git-file-name name version)) |
| 347 | (sha256 |
| 348 | (base32 "03j6xdvps259mhdzpjqf41l65w2l9sahvxg4wrp34hcf69wkrzpy")))) |
| 349 | (build-system julia-build-system) |
| 350 | (arguments |
| 351 | `(#:tests? #f ; no runtests.jl |
| 352 | #:phases |
| 353 | (modify-phases %standard-phases |
| 354 | (add-after 'unpack 'override-binary-path |
| 355 | (lambda* (#:key inputs #:allow-other-keys) |
| 356 | (map |
| 357 | (lambda (wrapper) |
| 358 | (substitute* wrapper |
| 359 | (("generate_wrapper_header.*") |
| 360 | (string-append |
| 361 | "generate_wrapper_header(\"CompilerSupportLibraries\", \"" |
| 362 | (assoc-ref inputs "gfortran:lib") "\")\n")))) |
| 363 | ;; There's a Julia file for each platform, override them all |
| 364 | (find-files "src/wrappers/" "\\.jl$")) |
| 365 | #t))))) |
| 366 | (inputs ;required by artifacts |
| 367 | `(("gfortran:lib" ,gfortran "lib"))) |
| 368 | (propagated-inputs |
| 369 | `(("julia-jllwrappers" ,julia-jllwrappers))) |
| 370 | (home-page "https://github.com/JuliaBinaryWrappers/CompilerSupportLibraries_jll.jl") |
| 371 | (synopsis "Internal wrappers") |
| 372 | (description "This package provides compiler support for libraries. It is |
| 373 | an autogenerated source package constructed using @code{BinaryBuilder.jl}. The |
| 374 | originating @code{build_tarballs.jl} script can be found on the community |
| 375 | build tree Yggdrasil.") |
| 376 | (license license:expat))) |
| 377 | |
| 378 | (define-public julia-constructionbase |
| 379 | (let ((commit "de77e2865b554f9b078fd8c35b593cce0554ae02")) |
| 380 | (package |
| 381 | (name "julia-constructionbase") |
| 382 | (version "1.1.0") ;tag not created upstream |
| 383 | (source |
| 384 | (origin |
| 385 | (method git-fetch) |
| 386 | (uri (git-reference |
| 387 | (url "https://github.com/JuliaObjects/ConstructionBase.jl") |
| 388 | (commit commit))) |
| 389 | (file-name (git-file-name name version)) |
| 390 | (sha256 |
| 391 | (base32 "1y79sfj0rds1skl9j16p9161hwa9khm0xc2m4hgjcbh5zzvyr57v")))) |
| 392 | (build-system julia-build-system) |
| 393 | (home-page "https://juliaobjects.github.io/ConstructionBase.jl/dev/") |
| 394 | (synopsis "Primitive functions for construction of objects") |
| 395 | (description "This very lightweight package provides primitive functions |
| 396 | for construction of objects.") |
| 397 | (license license:expat)))) |
| 398 | |
| 399 | (define-public julia-datastructures |
| 400 | (package |
| 401 | (name "julia-datastructures") |
| 402 | (version "0.18.9") |
| 403 | (source |
| 404 | (origin |
| 405 | (method git-fetch) |
| 406 | (uri (git-reference |
| 407 | (url "https://github.com/JuliaCollections/DataStructures.jl") |
| 408 | (commit (string-append "v" version)))) |
| 409 | (file-name (git-file-name name version)) |
| 410 | (sha256 |
| 411 | (base32 "0hdqp8ipsqdw5bqqkdvz4j6n67x80sj5azr9vzyxwjfsgkfbnk2l")))) |
| 412 | (propagated-inputs |
| 413 | `(("julia-compat" ,julia-compat) |
| 414 | ("julia-orderedcollections" ,julia-orderedcollections))) |
| 415 | (build-system julia-build-system) |
| 416 | (home-page "https://github.com/JuliaCollections/DataStructures.jl") |
| 417 | (synopsis "Julia module providing different data structures") |
| 418 | (description "This package implements a variety of data structures, |
| 419 | including, @code{CircularBuffer}, @code{Queue}, @code{Stack}, |
| 420 | @code{Accumulators}, @code{LinkedLists}, @code{SortedDicts} and many others.") |
| 421 | (license license:expat))) |
| 422 | |
| 423 | (define-public julia-diffresults |
| 424 | (package |
| 425 | (name "julia-diffresults") |
| 426 | (version "1.0.3") |
| 427 | (source |
| 428 | (origin |
| 429 | (method git-fetch) |
| 430 | (uri (git-reference |
| 431 | (url "https://github.com/JuliaDiff/DiffResults.jl") |
| 432 | (commit (string-append "v" version)))) |
| 433 | (file-name (git-file-name name version)) |
| 434 | (sha256 |
| 435 | (base32 "1w6p3yxajvclax5b9g7cr2jmbc7lvr5nk4gq0aljxdycdq1d2y3v")))) |
| 436 | (propagated-inputs |
| 437 | `(("julia-staticarrays" ,julia-staticarrays))) |
| 438 | (build-system julia-build-system) |
| 439 | (home-page "https://github.com/JuliaDiff/DiffResults.jl") |
| 440 | (synopsis "In-place differentiation methods of primal values at multi-order") |
| 441 | (description "This package provides the @code{DiffResult} type, which can |
| 442 | be passed to in-place differentiation methods instead of an output buffer.") |
| 443 | (license license:expat))) |
| 444 | |
| 445 | (define-public julia-diffrules |
| 446 | (package |
| 447 | (name "julia-diffrules") |
| 448 | (version "1.0.2") |
| 449 | (source |
| 450 | (origin |
| 451 | (method git-fetch) |
| 452 | (uri (git-reference |
| 453 | (url "https://github.com/JuliaDiff/DiffRules.jl") |
| 454 | (commit (string-append "v" version)))) |
| 455 | (file-name (git-file-name name version)) |
| 456 | (sha256 |
| 457 | (base32 "0cwjvj4gma7924fm3yas0nf0jlnwwx4v7fi79ii3s290lkdldzfl")))) |
| 458 | (propagated-inputs |
| 459 | `(("julia-nanmath" ,julia-nanmath) |
| 460 | ("julia-specialfunctions" ,julia-specialfunctions))) |
| 461 | (build-system julia-build-system) |
| 462 | (home-page "https://github.com/JuliaDiff/DiffRules.jl") |
| 463 | (synopsis "Primitive differentiation rules") |
| 464 | (description "This package provides primitive differentiation rules that |
| 465 | can be composed via various formulations of the chain rule. Using |
| 466 | @code{DiffRules}, new differentiation rules can defined, query whether or not |
| 467 | a given rule exists, and symbolically apply rules to simple Julia expressions.") |
| 468 | (license license:expat))) |
| 469 | |
| 470 | (define-public julia-difftests |
| 471 | (package |
| 472 | (name "julia-difftests") |
| 473 | (version "0.1.1") |
| 474 | (source |
| 475 | (origin |
| 476 | (method git-fetch) |
| 477 | (uri (git-reference |
| 478 | (url "https://github.com/JuliaDiff/DiffTests.jl") |
| 479 | (commit (string-append "v" version)))) |
| 480 | (file-name (git-file-name name version)) |
| 481 | (sha256 |
| 482 | (base32 "1rxpnd5zi3pxgdd38l5jm2sxc3q6p7g57fqgll2dsiin07y3my57")))) |
| 483 | (build-system julia-build-system) |
| 484 | (home-page "https://github.com/JuliaDiff/DiffTests.jl") |
| 485 | (synopsis "Common test functions for differentiation tools") |
| 486 | (description "This package contains a common suite of test functions for |
| 487 | stressing the robustness of differentiation tools.") |
| 488 | (license license:expat))) |
| 489 | |
| 490 | (define-public julia-example |
| 491 | (let ((commit "f968c69dea24f851d0c7e686db23fa55826b5388")) |
| 492 | (package |
| 493 | (name "julia-example") |
| 494 | (version "0.5.4") ;tag not created upstream |
| 495 | (source |
| 496 | (origin |
| 497 | (method git-fetch) |
| 498 | (uri (git-reference |
| 499 | (url "https://github.com/JuliaLang/Example.jl") |
| 500 | (commit commit))) |
| 501 | (file-name (git-file-name name version)) |
| 502 | (sha256 |
| 503 | (base32 "1v3z0d6gh6wfbypffy9m9rhh36px6fm5wjzq0y6rbmc95r0qpqlx")))) |
| 504 | (build-system julia-build-system) |
| 505 | (home-page "https://github.com/JuliaLang/Example.jl") |
| 506 | (synopsis "Module providing examples") |
| 507 | (description "This package provides various examples.") |
| 508 | (license license:expat)))) |
| 509 | |
| 510 | (define-public julia-fillarrays |
| 511 | (package |
| 512 | (name "julia-fillarrays") |
| 513 | (version "0.11.7") |
| 514 | (source |
| 515 | (origin |
| 516 | (method git-fetch) |
| 517 | (uri (git-reference |
| 518 | (url "https://github.com/JuliaArrays/FillArrays.jl") |
| 519 | (commit (string-append "v" version)))) |
| 520 | (file-name (git-file-name name version)) |
| 521 | (sha256 |
| 522 | (base32 "1q1qn9pb5dmppddnmf8gggdqyvivqh3ffvbblhn37smcf9r5sy7d")))) |
| 523 | (build-system julia-build-system) |
| 524 | (inputs ;required by tests |
| 525 | `(("julia-staticarrays" ,julia-staticarrays))) |
| 526 | (home-page "https://github.com/JuliaArrays/FillArrays.jl") |
| 527 | (synopsis "Lazy matrix representation") |
| 528 | (description "This package allows to lazily represent matrices filled with |
| 529 | a single entry, as well as identity matrices. This package exports the |
| 530 | following types: @code{Eye}, @code{Fill}, @code{Ones}, @code{Zeros}, |
| 531 | @code{Trues} and @code{Falses}.") |
| 532 | (license license:expat))) |
| 533 | |
| 534 | (define-public julia-finitedifferences |
| 535 | (package |
| 536 | (name "julia-finitedifferences") |
| 537 | (version "0.12.2") |
| 538 | (source |
| 539 | (origin |
| 540 | (method git-fetch) |
| 541 | (uri (git-reference |
| 542 | (url "https://github.com/JuliaDiff/FiniteDifferences.jl") |
| 543 | (commit (string-append "v" version)))) |
| 544 | (file-name (git-file-name name version)) |
| 545 | (sha256 |
| 546 | (base32 "0dcx34026xdpfmbjls3mrknl8ww62kxxfr77kfihbazsfg2gp5b4")))) |
| 547 | (build-system julia-build-system) |
| 548 | (inputs |
| 549 | `(("julia-benchmarktools" ,julia-benchmarktools))) |
| 550 | (propagated-inputs |
| 551 | `(("julia-chainrulescore" ,julia-chainrulescore) |
| 552 | ("julia-richardson" ,julia-richardson) |
| 553 | ("julia-staticarrays" ,julia-staticarrays))) |
| 554 | (home-page "https://github.com/JuliaDiff/FiniteDifferences.jl") |
| 555 | (synopsis "Estimates derivatives with finite differences") |
| 556 | (description "This package calculates approximate derivatives numerically |
| 557 | using finite difference.") |
| 558 | (license license:expat))) |
| 559 | |
| 560 | (define-public julia-fixedpointnumbers |
| 561 | (package |
| 562 | (name "julia-fixedpointnumbers") |
| 563 | (version "0.8.4") |
| 564 | (source |
| 565 | (origin |
| 566 | (method git-fetch) |
| 567 | (uri (git-reference |
| 568 | (url "https://github.com/JuliaMath/FixedPointNumbers.jl") |
| 569 | (commit (string-append "v" version)))) |
| 570 | (file-name (git-file-name name version)) |
| 571 | (sha256 |
| 572 | (base32 "0j0n40n04q9sk68wh9jq90m6c67k4ws02k41djjzkrqmpzv4rcdi")))) |
| 573 | (build-system julia-build-system) |
| 574 | (arguments |
| 575 | `(#:phases |
| 576 | (modify-phases %standard-phases |
| 577 | (add-after 'unpack 'disable-failing-test |
| 578 | (lambda* (#:key outputs #:allow-other-keys) |
| 579 | (substitute* "test/fixed.jl" |
| 580 | ;; A deprecation warning is not thrown |
| 581 | (("@test_logs.*:warn" all) (string-append "# " all))) |
| 582 | #t))))) |
| 583 | (propagated-inputs `(("julia-compat" ,julia-compat))) |
| 584 | (home-page "https://github.com/JuliaMath/FixedPointNumbers.jl") |
| 585 | (synopsis "Fixed point types for Julia") |
| 586 | (description "@code{FixedPointNumbers.jl} implements fixed-point number |
| 587 | types for Julia. A fixed-point number represents a fractional, or |
| 588 | non-integral, number. In contrast with the more widely known floating-point |
| 589 | numbers, with fixed-point numbers the decimal point doesn't \"float\": |
| 590 | fixed-point numbers are effectively integers that are interpreted as being |
| 591 | scaled by a constant factor. Consequently, they have a fixed number of |
| 592 | digits (bits) after the decimal (radix) point.") |
| 593 | (license license:expat))) |
| 594 | |
| 595 | (define-public julia-http |
| 596 | (package |
| 597 | (name "julia-http") |
| 598 | (version "0.9.2") |
| 599 | (source |
| 600 | (origin |
| 601 | (method git-fetch) |
| 602 | (uri (git-reference |
| 603 | (url "https://github.com/JuliaWeb/HTTP.jl") |
| 604 | (commit (string-append "v" version)))) |
| 605 | (file-name (git-file-name name version)) |
| 606 | (sha256 |
| 607 | (base32 "0ij0yci13c46p92m4zywvcs02nn8pm0abyfffiyhxvva6hq48lyl")))) |
| 608 | (build-system julia-build-system) |
| 609 | (arguments |
| 610 | `(#:phases |
| 611 | (modify-phases %standard-phases |
| 612 | (add-before 'install 'disable-network-tests |
| 613 | (lambda _ |
| 614 | (substitute* "test/runtests.jl" |
| 615 | (("\"async.jl") "# \"async.jl") |
| 616 | (("\"client.jl") "# \"client.jl")) |
| 617 | (substitute* "test/aws4.jl" |
| 618 | (("@testset.*HTTP.request with AWS authentication.*" all) |
| 619 | (string-append all "return\n"))) |
| 620 | (substitute* "test/insert_layers.jl" |
| 621 | (("@testset.*Inserted final layer runs handler.*" all) |
| 622 | (string-append all "return\n"))) |
| 623 | (substitute* "test/multipart.jl" |
| 624 | (("@testset \"Setting of Content-Type.*" all) |
| 625 | (string-append all "return\n")) |
| 626 | (("@testset \"Deprecation of .*" all) |
| 627 | (string-append all "return\n"))) |
| 628 | (substitute* "test/websockets.jl" |
| 629 | (("@testset.*External Host.*" all) |
| 630 | (string-append all "return\n"))) |
| 631 | (substitute* "test/messages.jl" |
| 632 | (("@testset.*Read methods.*" all) |
| 633 | (string-append all "return\n")) |
| 634 | (("@testset.*Body - .*" all) |
| 635 | (string-append all "return\n")) |
| 636 | (("@testset.*Write to file.*" all) |
| 637 | (string-append all "return\n"))) |
| 638 | #t))))) |
| 639 | (propagated-inputs |
| 640 | `(("julia-inifile" ,julia-inifile) |
| 641 | ("julia-mbedtls" ,julia-mbedtls) |
| 642 | ("julia-uris" ,julia-uris))) |
| 643 | ;; required for tests |
| 644 | (inputs |
| 645 | `(("julia-json" ,julia-json) |
| 646 | ("julia-bufferedstreams" ,julia-bufferedstreams))) |
| 647 | (home-page "https://juliaweb.github.io/HTTP.jl/") |
| 648 | (synopsis "HTTP support for Julia") |
| 649 | (description "@code{HTTP.jl} is a Julia library for HTTP Messages, |
| 650 | implementing both a client and a server.") |
| 651 | (license license:expat))) |
| 652 | |
| 653 | (define-public julia-inifile |
| 654 | (package |
| 655 | (name "julia-inifile") |
| 656 | (version "0.5.0") |
| 657 | (source |
| 658 | (origin |
| 659 | (method git-fetch) |
| 660 | (uri (git-reference |
| 661 | (url "https://github.com/JuliaIO/IniFile.jl") |
| 662 | (commit "8ba59958495fa276d6489d2c3903e765d75e0bc0"))) |
| 663 | (file-name (git-file-name name version)) |
| 664 | (sha256 |
| 665 | (base32 "11h6f99jpbg729lplw841m68jprka7q3n8yw390bndlmcdsjabpd")))) |
| 666 | (build-system julia-build-system) |
| 667 | (home-page "https://github.com/JuliaIO/IniFile.jl") |
| 668 | (synopsis "Reading Windows-style INI files") |
| 669 | (description "This is a Julia package that defines an IniFile type that |
| 670 | allows to interface with @file{.ini} files.") |
| 671 | (license license:expat))) |
| 672 | |
| 673 | (define-public julia-irtools |
| 674 | (package |
| 675 | (name "julia-irtools") |
| 676 | (version "0.4.2") |
| 677 | (source |
| 678 | (origin |
| 679 | (method git-fetch) |
| 680 | (uri (git-reference |
| 681 | (url "https://github.com/FluxML/IRTools.jl") |
| 682 | (commit (string-append "v" version)))) |
| 683 | (file-name (git-file-name name version)) |
| 684 | (sha256 |
| 685 | (base32 "0wwzy77jcdnffnd5fr6xan7162g4wydz67igrq82wflwnrhlcx5y")))) |
| 686 | (arguments |
| 687 | '(#:tests? #f)) ;require Documenter, not packaged yet |
| 688 | (build-system julia-build-system) |
| 689 | (propagated-inputs |
| 690 | `(("julia-macrotools" ,julia-macrotools))) |
| 691 | (home-page "https://github.com/FluxML/IRTools.jl") |
| 692 | (synopsis "Simple and flexible IR format") |
| 693 | (description "This package provides a simple and flexible IR format, |
| 694 | expressive enough to work with both lowered and typed Julia code, as well as |
| 695 | external IRs. It can be used with Julia metaprogramming tools such as |
| 696 | Cassette.") |
| 697 | (license license:expat))) |
| 698 | |
| 699 | (define-public julia-jllwrappers |
| 700 | (package |
| 701 | (name "julia-jllwrappers") |
| 702 | (version "1.2.0") |
| 703 | (source |
| 704 | (origin |
| 705 | (method git-fetch) |
| 706 | (uri (git-reference |
| 707 | (url "https://github.com/JuliaPackaging/JLLWrappers.jl") |
| 708 | (commit (string-append "v" version)))) |
| 709 | (file-name (git-file-name name version)) |
| 710 | (sha256 |
| 711 | (base32 "1sj3mi2dcc13apqfpy401wic5n0pgbck1p98b2g3zw0mln9s83m4")))) |
| 712 | (arguments |
| 713 | ;; Wants to download stuff |
| 714 | '(#:tests? #f |
| 715 | #:phases |
| 716 | (modify-phases %standard-phases |
| 717 | (add-after 'unpack 'custom-override-path |
| 718 | (lambda* (#:key inputs #:allow-other-keys) |
| 719 | ;; Make @generate_wrapper_header take an optional argument that |
| 720 | ;; guix packagers can pass to override the default "override" |
| 721 | ;; binary path. This won't be needed when something like |
| 722 | ;; https://github.com/JuliaPackaging/JLLWrappers.jl/pull/27 |
| 723 | ;; will be merged. |
| 724 | (substitute* "src/wrapper_generators.jl" |
| 725 | (("generate_wrapper_header.*") |
| 726 | "generate_wrapper_header(src_name, override_path = nothing)\n") |
| 727 | (("pkg_dir = .*" all) |
| 728 | (string-append |
| 729 | all "\n" "override = something(override_path," |
| 730 | "joinpath(dirname(pkg_dir), \"override\"))\n")) |
| 731 | (("@static if isdir.*") "@static if isdir($override)\n") |
| 732 | (("return joinpath.*") "return $override\n")) |
| 733 | #t))))) |
| 734 | (build-system julia-build-system) |
| 735 | (home-page "https://github.com/JuliaPackaging/JLLWrappers.jl") |
| 736 | (synopsis "Julia macros used by JLL packages") |
| 737 | (description "This package contains Julia macros that enable JLL packages |
| 738 | to generate themselves. It is not intended to be used by users, but rather is |
| 739 | used in autogenerated packages via @code{BinaryBuilder.jl}.") |
| 740 | (license license:expat))) |
| 741 | |
| 742 | (define-public julia-json |
| 743 | (package |
| 744 | (name "julia-json") |
| 745 | (version "0.21.1") |
| 746 | (source |
| 747 | (origin |
| 748 | (method git-fetch) |
| 749 | (uri (git-reference |
| 750 | (url "https://github.com/JuliaIO/JSON.jl") |
| 751 | (commit (string-append "v" version)))) |
| 752 | (file-name (git-file-name name version)) |
| 753 | (sha256 |
| 754 | (base32 "1f9k613kbknmp4fgjxvjaw4d5sfbx8a5hmcszmp1w9rqfqngjx9m")))) |
| 755 | (build-system julia-build-system) |
| 756 | (propagated-inputs |
| 757 | `(("julia-datastructures" ,julia-datastructures) |
| 758 | ("julia-fixedpointnumbers" ,julia-fixedpointnumbers) |
| 759 | ("julia-parsers" ,julia-parsers) |
| 760 | ("julia-offsetarrays" ,julia-offsetarrays))) |
| 761 | (home-page "https://github.com/JuliaIO/JSON.jl") |
| 762 | (synopsis "JSON parsing and printing library for Julia") |
| 763 | (description "@code{JSON.jl} is a pure Julia module which supports parsing |
| 764 | and printing JSON documents.") |
| 765 | (license license:expat))) |
| 766 | |
| 767 | (define-public julia-macrotools |
| 768 | (package |
| 769 | (name "julia-macrotools") |
| 770 | (version "0.5.6") |
| 771 | (source |
| 772 | (origin |
| 773 | (method git-fetch) |
| 774 | (uri (git-reference |
| 775 | (url "https://github.com/FluxML/MacroTools.jl") |
| 776 | (commit (string-append "v" version)))) |
| 777 | (file-name (git-file-name name version)) |
| 778 | (sha256 |
| 779 | (base32 "0k4z2hyasd9cwxf4l61zk3w4ajs44k69wx6z1ghdn8f5p8xy217f")))) |
| 780 | (build-system julia-build-system) |
| 781 | (home-page "https://fluxml.ai/MacroTools.jl") |
| 782 | (synopsis "Tools for working with Julia code and expressions") |
| 783 | (description "This library provides tools for working with Julia code and |
| 784 | expressions. This includes a template-matching system and code-walking tools |
| 785 | that let you do deep transformations of code.") |
| 786 | (license license:expat))) |
| 787 | |
| 788 | (define-public julia-mbedtls |
| 789 | (package |
| 790 | (name "julia-mbedtls") |
| 791 | (version "1.0.3") |
| 792 | (source |
| 793 | (origin |
| 794 | (method git-fetch) |
| 795 | (uri (git-reference |
| 796 | (url "https://github.com/JuliaLang/MbedTLS.jl") |
| 797 | (commit (string-append "v" version)))) |
| 798 | (file-name (git-file-name name version)) |
| 799 | (sha256 |
| 800 | (base32 "0zjzf2r57l24n3k0gcqkvx3izwn5827iv9ak0lqix0aa5967wvfb")))) |
| 801 | (build-system julia-build-system) |
| 802 | (arguments |
| 803 | `(#:phases |
| 804 | (modify-phases %standard-phases |
| 805 | (add-before 'install 'disable-network-tests |
| 806 | ;; Tries to connect to httpbin.org |
| 807 | (lambda _ |
| 808 | (substitute* "test/runtests.jl" |
| 809 | (("testhost =") "return #")) |
| 810 | #t))))) |
| 811 | (propagated-inputs `(("julia-mbedtls-jll" ,julia-mbedtls-jll))) |
| 812 | (home-page "https://github.com/JuliaLang/MbedTLS.jl") |
| 813 | (synopsis "Apache's mbed TLS library wrapper") |
| 814 | (description "@code{MbedTLS.jl} provides a wrapper around the @code{mbed |
| 815 | TLS} and cryptography C libary for Julia.") |
| 816 | (license license:expat))) |
| 817 | |
| 818 | (define-public julia-mbedtls-jll |
| 819 | (package |
| 820 | (name "julia-mbedtls-jll") |
| 821 | ;; version 2.25.0+0 is not compatible with current mbedtls 2.23.0, |
| 822 | ;; upgrade this when mbedtls is updated in guix |
| 823 | (version "2.24.0+1") |
| 824 | (source |
| 825 | (origin |
| 826 | (method git-fetch) |
| 827 | (uri (git-reference |
| 828 | (url "https://github.com/JuliaBinaryWrappers/MbedTLS_jll.jl") |
| 829 | (commit (string-append "MbedTLS-v" version)))) |
| 830 | (file-name (git-file-name name version)) |
| 831 | (sha256 |
| 832 | (base32 "0kk9dlxdh7yms21npgrdfmjbj8q8ng6kdhrzw3jr2d7rp696kp99")))) |
| 833 | (build-system julia-build-system) |
| 834 | (arguments |
| 835 | '(#:tests? #f ; No runtests.jl |
| 836 | #:phases |
| 837 | (modify-phases %standard-phases |
| 838 | (add-after 'unpack 'override-binary-path |
| 839 | (lambda* (#:key inputs #:allow-other-keys) |
| 840 | (map |
| 841 | (lambda (wrapper) |
| 842 | (substitute* wrapper |
| 843 | (("generate_wrapper_header.*") |
| 844 | (string-append |
| 845 | "generate_wrapper_header(\"MbedTLS\", \"" |
| 846 | (assoc-ref inputs "mbedtls-apache") "\")\n")))) |
| 847 | ;; There's a Julia file for each platform, override them all |
| 848 | (find-files "src/wrappers/" "\\.jl$")) |
| 849 | #t))))) |
| 850 | (inputs `(("mbedtls-apache" ,mbedtls-apache))) |
| 851 | (propagated-inputs `(("julia-jllwrappers" ,julia-jllwrappers))) |
| 852 | (home-page "https://github.com/JuliaBinaryWrappers/MbedTLS_jll.jl") |
| 853 | (synopsis "Apache's mbed TLS binary wrappers") |
| 854 | (description "This Julia module provides @code{mbed TLS} libraries and |
| 855 | wrappers.") |
| 856 | (license license:expat))) |
| 857 | |
| 858 | (define-public julia-nanmath |
| 859 | (package |
| 860 | (name "julia-nanmath") |
| 861 | (version "0.3.5") |
| 862 | (source |
| 863 | (origin |
| 864 | (method git-fetch) |
| 865 | (uri (git-reference |
| 866 | (url "https://github.com/mlubin/NaNMath.jl") |
| 867 | (commit (string-append "v" version)))) |
| 868 | (file-name (git-file-name name version)) |
| 869 | (sha256 |
| 870 | (base32 "1hczhz00qj99w63vp627kwk02l2sr2qmzc2rkwwkdwvzy670p25q")))) |
| 871 | (build-system julia-build-system) |
| 872 | (home-page "https://github.com/mlubin/NaNMath.jl") |
| 873 | (synopsis "Implementations of basic math functions") |
| 874 | (description "Implementations of basic math functions which return |
| 875 | @code{NaN} instead of throwing a @code{DomainError}.") |
| 876 | (license license:expat))) |
| 877 | |
| 878 | (define-public julia-orderedcollections |
| 879 | (package |
| 880 | (name "julia-orderedcollections") |
| 881 | (version "1.3.2") |
| 882 | (source |
| 883 | (origin |
| 884 | (method git-fetch) |
| 885 | (uri (git-reference |
| 886 | (url "https://github.com/JuliaCollections/OrderedCollections.jl") |
| 887 | (commit (string-append "v" version)))) |
| 888 | (file-name (git-file-name name version)) |
| 889 | (sha256 |
| 890 | (base32 "0sfip1ixghsz91q2s7d62rgzw3gppg42fg6bccxlplqa3hfmbycf")))) |
| 891 | (build-system julia-build-system) |
| 892 | (home-page "https://github.com/JuliaCollections/OrderedCollections.jl") |
| 893 | (synopsis "Associative containers that preserve insertion order") |
| 894 | (description "This package implements @code{OrderedDicts} and |
| 895 | @code{OrderedSets}, which are similar to containers in base Julia. However, |
| 896 | during iteration the @code{Ordered*} containers return items in the order in |
| 897 | which they were added to the collection.") |
| 898 | (license license:expat))) |
| 899 | |
| 900 | (define-public julia-offsetarrays |
| 901 | (package |
| 902 | (name "julia-offsetarrays") |
| 903 | (version "1.5.2") |
| 904 | (source |
| 905 | (origin |
| 906 | (method git-fetch) |
| 907 | (uri (git-reference |
| 908 | (url "https://github.com/JuliaArrays/OffsetArrays.jl") |
| 909 | (commit (string-append "v" version)))) |
| 910 | (file-name (git-file-name name version)) |
| 911 | (sha256 |
| 912 | (base32 "1y3fnssw2hzyghrk6jfcxslab0f8sjkjszh482snfq4k6mkrhy77")))) |
| 913 | (build-system julia-build-system) |
| 914 | (propagated-inputs |
| 915 | `(("julia-adapt" ,julia-adapt))) |
| 916 | ;; CatIndices depends on OffsetArrays, introducing a recursive dependency |
| 917 | (arguments '(#:tests? #f)) |
| 918 | (home-page "https://juliaarrays.github.io/OffsetArrays.jl/stable/") |
| 919 | (synopsis "Fortran-like arrays with arbitrary, zero or negative indices") |
| 920 | (description "@code{OffsetArrays.jl} provides Julia users with arrays that |
| 921 | have arbitrary indices, similar to those found in some other programming |
| 922 | languages like Fortran.") |
| 923 | (license license:expat))) |
| 924 | |
| 925 | ;;; TODO: Remove this autogenerated source package |
| 926 | ;;; and build it from realse source using <https://github.com/JuliaPackaging/Yggdrasil/> |
| 927 | (define-public julia-openspecfun-jll |
| 928 | (let ((commit "6c505cce3bdcd9cd2b15b4f9362ec3a42c4da71c")) |
| 929 | (package |
| 930 | (name "julia-openspecfun-jll") |
| 931 | (version "0.5.3+4") ;tag not created upstream |
| 932 | (source |
| 933 | (origin |
| 934 | (method git-fetch) |
| 935 | (uri (git-reference |
| 936 | (url "https://github.com/JuliaBinaryWrappers/OpenSpecFun_jll.jl") |
| 937 | (commit commit))) |
| 938 | (file-name (git-file-name name version)) |
| 939 | (sha256 |
| 940 | (base32 "0bl2gcgndsbiwhwy8fl070cjm1fyf9kxj6gkikgirmzgjl29iakn")))) |
| 941 | (build-system julia-build-system) |
| 942 | (arguments |
| 943 | `(#:tests? #f ; no runtests.jl |
| 944 | #:phases |
| 945 | (modify-phases %standard-phases |
| 946 | (add-after 'unpack 'override-binary-path |
| 947 | (lambda* (#:key inputs #:allow-other-keys) |
| 948 | (map |
| 949 | (lambda (wrapper) |
| 950 | (substitute* wrapper |
| 951 | (("generate_wrapper_header.*") |
| 952 | (string-append |
| 953 | "generate_wrapper_header(\"OpenSpecFun\", \"" |
| 954 | (assoc-ref inputs "openspecfun") "\")\n")))) |
| 955 | ;; There's a Julia file for each platform, override them all |
| 956 | (find-files "src/wrappers/" "\\.jl$")) |
| 957 | #t))))) |
| 958 | (inputs |
| 959 | `(("openspecfun" ,openspecfun))) |
| 960 | (propagated-inputs |
| 961 | `(("julia-jllwrappers" ,julia-jllwrappers) |
| 962 | ("julia-compilersupportlibraries-jll" ,julia-compilersupportlibraries-jll))) |
| 963 | (home-page "https://github.com/JuliaBinaryWrappers/OpenSpecFun_jll.jl") |
| 964 | (synopsis "Internal wrappers") |
| 965 | (description "This package provides a wrapper for OpenSpecFun. It is an |
| 966 | autogenerated source package constructed using @code{BinaryBuilder.jl}. The |
| 967 | originating @code{build_tarballs.jl} script can be found on the community |
| 968 | build tree Yggdrasil.") |
| 969 | (license license:expat)))) |
| 970 | |
| 971 | (define-public julia-parsers |
| 972 | (package |
| 973 | (name "julia-parsers") |
| 974 | (version "1.0.15") |
| 975 | (source |
| 976 | (origin |
| 977 | (method git-fetch) |
| 978 | (uri (git-reference |
| 979 | (url "https://github.com/JuliaData/Parsers.jl") |
| 980 | (commit (string-append "v" version)))) |
| 981 | (file-name (git-file-name name version)) |
| 982 | (sha256 |
| 983 | (base32 "16iffl6l28kspgqch48mhi1s8qhspr3cpqcwsph3rqi72lbfqygx")))) |
| 984 | (build-system julia-build-system) |
| 985 | (home-page "https://github.com/JuliaData/Parsers.jl") |
| 986 | (synopsis "Fast parsing machinery for basic types in Julia") |
| 987 | (description "@code{Parsers.jl} is a collection of type parsers and |
| 988 | utilities for Julia.") |
| 989 | (license license:expat))) |
| 990 | |
| 991 | (define-public julia-reexport |
| 992 | (package |
| 993 | (name "julia-reexport") |
| 994 | (version "1.0.0") |
| 995 | (source |
| 996 | (origin |
| 997 | (method git-fetch) |
| 998 | (uri (git-reference |
| 999 | (url "https://github.com/simonster/Reexport.jl") |
| 1000 | (commit version))) |
| 1001 | (file-name (git-file-name name version)) |
| 1002 | (sha256 |
| 1003 | (base32 "1yhhja1zz6dy5f4fd19bdwd6jwgj7q4w3avzgyg1hjhmdl8jrh0s")))) |
| 1004 | (build-system julia-build-system) |
| 1005 | (home-page "https://github.com/simonster/Reexport.jl") |
| 1006 | (synopsis "Re-export modules and symbols") |
| 1007 | (description "This package provides tools to re-export modules and symbols.") |
| 1008 | (license license:expat))) |
| 1009 | |
| 1010 | (define-public julia-requires |
| 1011 | (package |
| 1012 | (name "julia-requires") |
| 1013 | (version "1.1.3") |
| 1014 | (source |
| 1015 | (origin |
| 1016 | (method git-fetch) |
| 1017 | (uri (git-reference |
| 1018 | (url "https://github.com/JuliaPackaging/Requires.jl/") |
| 1019 | (commit (string-append "v" version)))) |
| 1020 | (file-name (git-file-name name version)) |
| 1021 | (sha256 |
| 1022 | (base32 "03hyfy7c0ma45b0y756j76awi3az2ii4bz4s8cxm3xw9yy1z7b01")))) |
| 1023 | (build-system julia-build-system) |
| 1024 | (inputs ;required for test |
| 1025 | `(("julia-example" ,julia-example))) |
| 1026 | (propagated-inputs |
| 1027 | `(("julia-colors" ,julia-colors))) |
| 1028 | (home-page "https://github.com/JuliaPackaging/Requires.jl/") |
| 1029 | (synopsis "Faster package loader") |
| 1030 | (description "This package make loading packages faster, maybe. It |
| 1031 | supports specifying glue code in packages which will load automatically when |
| 1032 | another package is loaded, so that explicit dependencies (and long load times) |
| 1033 | can be avoided.") |
| 1034 | (license license:expat))) |
| 1035 | |
| 1036 | (define-public julia-richardson |
| 1037 | (package |
| 1038 | (name "julia-richardson") |
| 1039 | (version "1.4.0") |
| 1040 | (source |
| 1041 | (origin |
| 1042 | (method git-fetch) |
| 1043 | (uri (git-reference |
| 1044 | (url "https://github.com/JuliaMath/Richardson.jl") |
| 1045 | (commit (string-append "v" version)))) |
| 1046 | (file-name (git-file-name name version)) |
| 1047 | (sha256 |
| 1048 | (base32 "06v9ii3d7hh41fsrfklaa8ap55z5s017f888mrd1c18y4fx9i4nx")))) |
| 1049 | (build-system julia-build-system) |
| 1050 | (home-page "https://juliapackages.com/p/richardson") |
| 1051 | (synopsis "Extrapolate function using Richardson method") |
| 1052 | (description "This package provides a function extrapolate that |
| 1053 | extrapolates a given function @code{f(x)} to @code{f(x0)}, evaluating @code{f} |
| 1054 | only at a geometric sequence of points @code{> x0} (or optionally @code{< |
| 1055 | x0}). The key algorithm is Richardson extrapolation using a Neville–Aitken |
| 1056 | tableau, which adaptively increases the degree of an extrapolation polynomial |
| 1057 | until convergence is achieved to a desired tolerance (or convergence stalls |
| 1058 | due to e.g. floating-point errors). This allows one to obtain @code{f(x0)} to |
| 1059 | high-order accuracy, assuming that @code{f(x0+h)} has a Taylor series or some |
| 1060 | other power series in @code{h}.") |
| 1061 | (license license:expat))) |
| 1062 | |
| 1063 | (define-public julia-specialfunctions |
| 1064 | (package |
| 1065 | (name "julia-specialfunctions") |
| 1066 | (version "1.3.0") |
| 1067 | (source |
| 1068 | (origin |
| 1069 | (method git-fetch) |
| 1070 | (uri (git-reference |
| 1071 | (url "https://github.com/JuliaMath/SpecialFunctions.jl") |
| 1072 | (commit (string-append "v" version)))) |
| 1073 | (file-name (git-file-name name version)) |
| 1074 | (sha256 |
| 1075 | (base32 "1rfhrrkzi3ils7fklbn35ki1yp5x88fi71qknfwqyw4pk8cf8p80")))) |
| 1076 | (build-system julia-build-system) |
| 1077 | (inputs |
| 1078 | `(("julia-chainrulestestutils" ,julia-chainrulestestutils))) |
| 1079 | (propagated-inputs |
| 1080 | `(("julia-chainrulescore" ,julia-chainrulescore) |
| 1081 | ("julia-openspecfun-jll" ,julia-openspecfun-jll))) |
| 1082 | (home-page "https://github.com/JuliaMath/SpecialFunctions.jl") |
| 1083 | (synopsis "Special mathematical functions") |
| 1084 | (description "This package provides special mathematical functions, |
| 1085 | including Bessel, Hankel, Airy, error, Dawson, exponential (or sine and |
| 1086 | cosine) integrals, eta, zeta, digamma, inverse digamma, trigamma, and |
| 1087 | polygamma functions.") |
| 1088 | (license license:expat))) |
| 1089 | |
| 1090 | (define-public julia-staticarrays |
| 1091 | (package |
| 1092 | (name "julia-staticarrays") |
| 1093 | (version "1.0.1") |
| 1094 | (source |
| 1095 | (origin |
| 1096 | (method git-fetch) |
| 1097 | (uri (git-reference |
| 1098 | (url "https://github.com/JuliaArrays/StaticArrays.jl") |
| 1099 | (commit (string-append "v" version)))) |
| 1100 | (file-name (git-file-name name version)) |
| 1101 | (sha256 |
| 1102 | (base32 "01z8bcqwpfkp8p1h1r36pr5cc3798y76zkas7g3206pcsdhvlkz1")))) |
| 1103 | (build-system julia-build-system) |
| 1104 | (inputs |
| 1105 | `(("julia-benchmarktools" ,julia-benchmarktools))) |
| 1106 | (home-page "https://github.com/JuliaArrays/StaticArrays.jl") |
| 1107 | (synopsis "Statically sized arrays") |
| 1108 | (description "This package provides a framework for implementing |
| 1109 | statically sized arrays in Julia, using the abstract type |
| 1110 | @code{StaticArray{Size,T,N} <: AbstractArray{T,N}}. Subtypes of |
| 1111 | @code{StaticArray} will provide fast implementations of common array and |
| 1112 | linear algebra operations.") |
| 1113 | (license license:expat))) |
| 1114 | |
| 1115 | (define-public julia-uris |
| 1116 | (package |
| 1117 | (name "julia-uris") |
| 1118 | (version "1.2.0") |
| 1119 | (source |
| 1120 | (origin |
| 1121 | (method git-fetch) |
| 1122 | (uri (git-reference |
| 1123 | (url "https://github.com/JuliaWeb/URIs.jl") |
| 1124 | (commit (string-append "v" version)))) |
| 1125 | (file-name (git-file-name name version)) |
| 1126 | (sha256 |
| 1127 | (base32 "0fqyagsqks5za7m0czafr34m2xh5501f689k9cn5x3npajdnh2r3")))) |
| 1128 | (build-system julia-build-system) |
| 1129 | (arguments |
| 1130 | '(#:julia-package-name "URIs" ;required to run tests |
| 1131 | #:phases |
| 1132 | (modify-phases %standard-phases |
| 1133 | (add-before 'check 'change-dir |
| 1134 | ;; Tests must be run from the testdir |
| 1135 | (lambda* (#:key source outputs #:allow-other-keys) |
| 1136 | (let ((out (assoc-ref outputs "out"))) |
| 1137 | (chdir |
| 1138 | (string-append out "/share/julia/packages/URIs/test"))) |
| 1139 | #t))))) |
| 1140 | ;; required for tests |
| 1141 | (inputs `(("julia-json" ,julia-json))) |
| 1142 | (home-page "https://github.com/JuliaWeb/URIs.jl") |
| 1143 | (synopsis "URI parsing in Julia") |
| 1144 | (description "@code{URIs.jl} is a Julia package that allows parsing and |
| 1145 | working with @acronym{URIs,Uniform Resource Identifiers}, as defined in RFC |
| 1146 | 3986.") |
| 1147 | (license license:expat))) |
| 1148 | |
| 1149 | (define-public julia-unitful |
| 1150 | (package |
| 1151 | (name "julia-unitful") |
| 1152 | (version "1.6.0") |
| 1153 | (source |
| 1154 | (origin |
| 1155 | (method git-fetch) |
| 1156 | (uri (git-reference |
| 1157 | (url "https://github.com/PainterQubits/Unitful.jl") |
| 1158 | (commit (string-append "v" version)))) |
| 1159 | (file-name (git-file-name name version)) |
| 1160 | (sha256 |
| 1161 | (base32 "0g5bhlvay9yk11c5dqwbzmb3q7lzj0cq5zchyk39d59fkvvmxvq3")))) |
| 1162 | (build-system julia-build-system) |
| 1163 | (propagated-inputs |
| 1164 | `(("julia-constructionbase" ,julia-constructionbase))) |
| 1165 | (home-page "https://painterqubits.github.io/Unitful.jl/stable/") |
| 1166 | (synopsis "Physical units in Julia") |
| 1167 | (description "This package supports SI units and also many other unit |
| 1168 | system.") |
| 1169 | (license license:expat))) |