1948 lines
70 KiB
Scheme
1948 lines
70 KiB
Scheme
;;; GNU Guix --- Functional package management for GNU
|
|
;;; Copyright © 2015, 2016 Ricardo Wurmus <rekado@elephly.net>
|
|
;;; Copyright © 2015 Vicente Vera Parra <vicentemvp@gmail.com>
|
|
;;;
|
|
;;; This file is part of GNU Guix.
|
|
;;;
|
|
;;; GNU Guix is free software; you can redistribute it and/or modify it
|
|
;;; under the terms of the GNU General Public License as published by
|
|
;;; the Free Software Foundation; either version 3 of the License, or (at
|
|
;;; your option) any later version.
|
|
;;;
|
|
;;; GNU Guix is distributed in the hope that it will be useful, but
|
|
;;; WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
;;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
;;; GNU General Public License for more details.
|
|
;;;
|
|
;;; You should have received a copy of the GNU General Public License
|
|
;;; along with GNU Guix. If not, see <http://www.gnu.org/licenses/>.
|
|
|
|
(define-module (gnu packages statistics)
|
|
#:use-module ((guix licenses) #:prefix license:)
|
|
#:use-module (guix packages)
|
|
#:use-module (guix download)
|
|
#:use-module (guix utils)
|
|
#:use-module (guix build-system gnu)
|
|
#:use-module (guix build-system r)
|
|
#:use-module (guix build-system python)
|
|
#:use-module (gnu packages)
|
|
#:use-module (gnu packages compression)
|
|
#:use-module (gnu packages curl)
|
|
#:use-module (gnu packages gcc)
|
|
#:use-module (gnu packages gtk)
|
|
#:use-module (gnu packages haskell)
|
|
#:use-module (gnu packages icu4c)
|
|
#:use-module (gnu packages image)
|
|
#:use-module (gnu packages java)
|
|
#:use-module (gnu packages maths)
|
|
#:use-module (gnu packages pcre)
|
|
#:use-module (gnu packages perl)
|
|
#:use-module (gnu packages pkg-config)
|
|
#:use-module (gnu packages python)
|
|
#:use-module (gnu packages readline)
|
|
#:use-module (gnu packages ssh)
|
|
#:use-module (gnu packages texlive)
|
|
#:use-module (gnu packages texinfo)
|
|
#:use-module (gnu packages tls)
|
|
#:use-module (gnu packages base)
|
|
#:use-module (gnu packages web)
|
|
#:use-module (gnu packages xml)
|
|
#:use-module (gnu packages xorg)
|
|
#:use-module (gnu packages zip)
|
|
#:use-module (srfi srfi-1))
|
|
|
|
(define-public r
|
|
(package
|
|
(name "r")
|
|
(version "3.2.3")
|
|
(source (origin
|
|
(method url-fetch)
|
|
(uri (string-append "mirror://cran/src/base/R-"
|
|
(version-prefix version 1) "/R-"
|
|
version ".tar.gz"))
|
|
(sha256
|
|
(base32
|
|
"1hdnv77ralzcx5k5b88jq1r8l6zqnywpq00g2qs949rqh63psfxr"))))
|
|
(build-system gnu-build-system)
|
|
(arguments
|
|
`(#:make-flags
|
|
(list (string-append "LDFLAGS=-Wl,-rpath="
|
|
(assoc-ref %outputs "out")
|
|
"/lib/R/lib"))
|
|
#:phases
|
|
(modify-phases %standard-phases
|
|
(add-before
|
|
'configure 'set-default-pager
|
|
;; Set default pager to "cat", because otherwise it is "false",
|
|
;; making "help()" print nothing at all.
|
|
(lambda _ (setenv "PAGER" "cat") #t))
|
|
(add-before
|
|
'check 'set-timezone
|
|
;; Some tests require the timezone to be set.
|
|
(lambda _ (setenv "TZ" "UTC") #t))
|
|
(add-after 'build 'make-info
|
|
(lambda _ (zero? (system* "make" "info"))))
|
|
(add-after 'build 'install-info
|
|
(lambda _ (zero? (system* "make" "install-info")))))
|
|
#:configure-flags
|
|
'("--with-blas=openblas"
|
|
"--with-lapack"
|
|
"--with-cairo"
|
|
"--with-libpng"
|
|
"--with-jpeglib"
|
|
"--with-libtiff"
|
|
"--with-ICU"
|
|
"--enable-R-shlib"
|
|
"--enable-BLAS-shlib"
|
|
"--with-system-zlib"
|
|
"--with-system-bzlib"
|
|
"--with-system-pcre"
|
|
"--with-system-tre"
|
|
"--with-system-xz")))
|
|
;; R has some support for Java. When the JDK is available at configure
|
|
;; time environment variables pointing to the JDK will be recorded under
|
|
;; $R_HOME/etc and ./tools/getsp.java will be compiled which is used by "R
|
|
;; CMD javareconf". "R CMD javareconf" appears to only be used to update
|
|
;; the recorded environment variables in $R_HOME/etc. Refer to
|
|
;; https://cran.r-project.org/doc/manuals/r-release/R-admin.html#Java-support
|
|
;; for additional information.
|
|
|
|
;; As the JDK is a rather large input with only very limited effects on R,
|
|
;; we decided to drop it.
|
|
(native-inputs
|
|
`(("bzip2" ,bzip2)
|
|
("perl" ,perl)
|
|
("pkg-config" ,pkg-config)
|
|
("texinfo" ,texinfo) ; for building HTML manuals
|
|
("which" ,which) ; for tests/Examples/base-Ex.R
|
|
("xz" ,xz)))
|
|
(inputs
|
|
`(("openblas" ,openblas)
|
|
("cairo" ,cairo)
|
|
("gfortran" ,gfortran)
|
|
("icu4c" ,icu4c)
|
|
("lapack" ,lapack)
|
|
("libjpeg" ,libjpeg)
|
|
("libpng" ,libpng)
|
|
("libtiff" ,libtiff)
|
|
("libxt" ,libxt)
|
|
("pcre" ,pcre)
|
|
("readline" ,readline)
|
|
("zlib" ,zlib)))
|
|
(native-search-paths
|
|
(list (search-path-specification
|
|
(variable "R_LIBS_SITE")
|
|
(files (list "site-library/")))))
|
|
(home-page "http://www.r-project.org/")
|
|
(synopsis "Environment for statistical computing and graphics")
|
|
(description
|
|
"R is a language and environment for statistical computing and graphics.
|
|
It provides a variety of statistical techniques, such as linear and nonlinear
|
|
modeling, classical statistical tests, time-series analysis, classification
|
|
and clustering. It also provides robust support for producing
|
|
publication-quality data plots. A large amount of 3rd-party packages are
|
|
available, greatly increasing its breadth and scope.")
|
|
(license license:gpl3+)))
|
|
|
|
(define-public r-colorspace
|
|
(package
|
|
(name "r-colorspace")
|
|
(version "1.2-6")
|
|
(source
|
|
(origin
|
|
(method url-fetch)
|
|
(uri (cran-uri "colorspace" version))
|
|
(sha256
|
|
(base32 "0y8n4ljwhbdvkysdwgqzcnpv107pb3px1jip3k6svv86p72nacds"))))
|
|
(build-system r-build-system)
|
|
(home-page "http://cran.r-project.org/web/packages/colorspace")
|
|
(synopsis "Color space manipulation")
|
|
(description
|
|
"This package carries out a mapping between assorted color spaces
|
|
including RGB, HSV, HLS, CIEXYZ, CIELUV, HCL (polar CIELUV), CIELAB and polar
|
|
CIELAB. Qualitative, sequential, and diverging color palettes based on HCL
|
|
colors are provided.")
|
|
(license license:bsd-3)))
|
|
|
|
(define-public r-dichromat
|
|
(package
|
|
(name "r-dichromat")
|
|
(version "2.0-0")
|
|
(source
|
|
(origin
|
|
(method url-fetch)
|
|
(uri (cran-uri "dichromat" version))
|
|
(sha256
|
|
(base32 "1l8db1nk29ccqg3mkbafvfiw0775iq4gapysf88xq2zp6spiw59i"))))
|
|
(build-system r-build-system)
|
|
(home-page "http://cran.r-project.org/web/packages/dichromat")
|
|
(synopsis "Color schemes for dichromats")
|
|
(description
|
|
"Dichromat collapses red-green or green-blue distinctions to simulate the
|
|
effects of different types of color-blindness.")
|
|
(license license:gpl2+)))
|
|
|
|
(define-public r-digest
|
|
(package
|
|
(name "r-digest")
|
|
(version "0.6.8")
|
|
(source
|
|
(origin
|
|
(method url-fetch)
|
|
(uri (cran-uri "digest" version))
|
|
(sha256
|
|
(base32 "0m9grqv67hhf51lz10whymhw0g0d98466ka694kya5x95hn44qih"))))
|
|
(build-system r-build-system)
|
|
(home-page "http://dirk.eddelbuettel.com/code/digest.html")
|
|
(synopsis "Create cryptographic hash digests of R objects")
|
|
(description
|
|
"This package contains an implementation of a function 'digest()' for the
|
|
creation of hash digests of arbitrary R objects (using the md5, sha-1,
|
|
sha-256, crc32, xxhash and murmurhash algorithms) permitting easy comparison
|
|
of R language objects, as well as a function 'hmac()' to create hash-based
|
|
message authentication code.
|
|
|
|
Please note that this package is not meant to be deployed for cryptographic
|
|
purposes for which more comprehensive (and widely tested) libraries such as
|
|
OpenSSL should be used.")
|
|
(license license:gpl2+)))
|
|
|
|
(define-public r-gtable
|
|
(package
|
|
(name "r-gtable")
|
|
(version "0.1.2")
|
|
(source
|
|
(origin
|
|
(method url-fetch)
|
|
(uri (cran-uri "gtable" version))
|
|
(sha256
|
|
(base32 "0k9hfj6r5y238gqh92s3cbdn34biczx3zfh79ix5xq0c5vkai2xh"))))
|
|
(build-system r-build-system)
|
|
(home-page "https://cran.r-project.org/web/packages/gtable")
|
|
(synopsis "R library to arrange grobs in tables")
|
|
(description
|
|
"Gtable is a collection of tools to make it easier to work with
|
|
\"tables\" of grobs.")
|
|
(license license:gpl2+)))
|
|
|
|
(define-public r-labeling
|
|
(package
|
|
(name "r-labeling")
|
|
(version "0.3")
|
|
(source
|
|
(origin
|
|
(method url-fetch)
|
|
(uri (cran-uri "labeling" version))
|
|
(sha256
|
|
(base32 "13sk7zrrrzry6ky1bp8mmnzcl9jhvkig8j4id9nny7z993mnk00d"))))
|
|
(build-system r-build-system)
|
|
(home-page "http://cran.r-project.org/web/packages/labeling")
|
|
(synopsis "Axis labeling algorithms")
|
|
(description "The labeling package provides a range of axis labeling
|
|
algorithms.")
|
|
(license license:expat)))
|
|
|
|
(define-public r-magrittr
|
|
(package
|
|
(name "r-magrittr")
|
|
(version "1.5")
|
|
(source
|
|
(origin
|
|
(method url-fetch)
|
|
(uri (cran-uri "magrittr" version))
|
|
(sha256
|
|
(base32 "1s1ar6rag8m277qcqmdp02gn4awn9bdj9ax0r8s32i59mm1mki05"))))
|
|
(build-system r-build-system)
|
|
(home-page "http://cran.r-project.org/web/packages/magrittr/index.html")
|
|
(synopsis "A forward-pipe operator for R")
|
|
(description
|
|
"Magrittr provides a mechanism for chaining commands with a new
|
|
forward-pipe operator, %>%. This operator will forward a value, or the result
|
|
of an expression, into the next function call/expression. There is flexible
|
|
support for the type of right-hand side expressions. For more information,
|
|
see package vignette. To quote Rene Magritte, \"Ceci n'est pas un pipe.\"")
|
|
(license license:expat)))
|
|
|
|
(define-public r-munsell
|
|
(package
|
|
(name "r-munsell")
|
|
(version "0.4.2")
|
|
(source
|
|
(origin
|
|
(method url-fetch)
|
|
(uri (cran-uri "munsell" version))
|
|
(sha256
|
|
(base32 "1bi5yi0i80778bbzx2rm4f0glpc34kvh24pwwfhm4v32izsqgrw4"))))
|
|
(build-system r-build-system)
|
|
(propagated-inputs
|
|
`(("r-colorspace" ,r-colorspace)))
|
|
(home-page "http://cran.r-project.org/web/packages/munsell")
|
|
(synopsis "Munsell colour system")
|
|
(description
|
|
"The Munsell package contains Functions for exploring and using the
|
|
Munsell colour system.")
|
|
(license license:expat)))
|
|
|
|
(define-public r-rcpp
|
|
(package
|
|
(name "r-rcpp")
|
|
(version "0.12.0")
|
|
(source
|
|
(origin
|
|
(method url-fetch)
|
|
(uri (cran-uri "Rcpp" version))
|
|
(sha256
|
|
(base32 "182109z0yc1snqgd833ssl2cix6cbq83bcxmy5344b15ym820y38"))))
|
|
(build-system r-build-system)
|
|
(home-page "http://www.rcpp.org")
|
|
(synopsis "Seamless R and C++ Integration")
|
|
(description
|
|
"The Rcpp package provides R functions as well as C++ classes which offer
|
|
a seamless integration of R and C++. Many R data types and objects can be
|
|
mapped back and forth to C++ equivalents which facilitates both writing of new
|
|
code as well as easier integration of third-party libraries. Documentation
|
|
about Rcpp is provided by several vignettes included in this package, via the
|
|
'Rcpp Gallery' site at <http://gallery.rcpp.org>, the paper by Eddelbuettel
|
|
and Francois (2011, JSS), and the book by Eddelbuettel (2013, Springer); see
|
|
'citation(\"Rcpp\")' for details on these last two.")
|
|
(license license:gpl2+)))
|
|
|
|
(define-public r-plyr
|
|
(package
|
|
(name "r-plyr")
|
|
(version "1.8.3")
|
|
(source
|
|
(origin
|
|
(method url-fetch)
|
|
(uri (cran-uri "plyr" version))
|
|
(sha256
|
|
(base32 "06v4zxawpjz37rp2q2ii5q43g664z9s29j4ydn0cz3crn7lzl6pk"))))
|
|
(build-system r-build-system)
|
|
(native-inputs `(("r-rcpp" ,r-rcpp)))
|
|
(home-page "http://had.co.nz/plyr")
|
|
(synopsis "Tools for Splitting, Applying and Combining Data")
|
|
(description
|
|
"Plyr is a set of tools that solves a common set of problems: you need to
|
|
break a big problem down into manageable pieces, operate on each piece and
|
|
then put all the pieces back together. For example, you might want to fit a
|
|
model to each spatial location or time point in your study, summarise data by
|
|
panels or collapse high-dimensional arrays to simpler summary statistics.")
|
|
(license license:expat)))
|
|
|
|
(define-public r-proto
|
|
(package
|
|
(name "r-proto")
|
|
(version "0.3-10")
|
|
(source
|
|
(origin
|
|
(method url-fetch)
|
|
(uri (cran-uri "proto" version))
|
|
(sha256
|
|
(base32 "03mvzi529y6kjcp9bkpk7zlgpcakb3iz73hca6rpjy14pyzl3nfh"))))
|
|
(build-system r-build-system)
|
|
(home-page "http://r-proto.googlecode.com")
|
|
(synopsis "Prototype object-based programming")
|
|
(description
|
|
"Proto is an object oriented system using object-based, also called
|
|
prototype-based, rather than class-based object oriented ideas.")
|
|
(license license:gpl2+)))
|
|
|
|
(define-public r-rcolorbrewer
|
|
(package
|
|
(name "r-rcolorbrewer")
|
|
(version "1.1-2")
|
|
(source
|
|
(origin
|
|
(method url-fetch)
|
|
(uri (cran-uri "RColorBrewer" version))
|
|
(sha256
|
|
(base32 "1pfcl8z1pnsssfaaz9dvdckyfnnc6rcq56dhislbf571hhg7isgk"))))
|
|
(build-system r-build-system)
|
|
(home-page "http://cran.r-project.org/web/packages/RColorBrewer")
|
|
(synopsis "ColorBrewer palettes")
|
|
(description
|
|
"This package provides color schemes for maps (and other graphics)
|
|
designed by Cynthia Brewer as described at http://colorbrewer2.org")
|
|
;; Includes code licensed under bsd-4
|
|
(license license:asl2.0)))
|
|
|
|
(define-public r-stringi
|
|
(package
|
|
(name "r-stringi")
|
|
(version "0.5-5")
|
|
(source
|
|
(origin
|
|
(method url-fetch)
|
|
(uri (cran-uri "stringi" version))
|
|
(sha256
|
|
(base32
|
|
"183wrrjhpgl1wbnn9lhghyvhz7l2mc64mpcmzplckal7y9j7pmhw"))))
|
|
(build-system r-build-system)
|
|
(inputs `(("icu4c" ,icu4c)))
|
|
(native-inputs `(("pkg-config" ,pkg-config)))
|
|
(home-page "http://stringi.rexamine.com/")
|
|
(synopsis "Character string processing facilities")
|
|
(description
|
|
"This package allows for fast, correct, consistent, portable, as well as
|
|
convenient character string/text processing in every locale and any native
|
|
encoding. Owing to the use of the ICU library, the package provides R users
|
|
with platform-independent functions known to Java, Perl, Python, PHP, and Ruby
|
|
programmers. Among available features there are: pattern searching
|
|
(e.g. via regular expressions), random string generation, string collation,
|
|
transliteration, concatenation, date-time formatting and parsing, etc.")
|
|
(license license:bsd-3)))
|
|
|
|
(define-public r-stringr
|
|
(package
|
|
(name "r-stringr")
|
|
(version "1.0.0")
|
|
(source
|
|
(origin
|
|
(method url-fetch)
|
|
(uri (cran-uri "stringr" version))
|
|
(sha256
|
|
(base32 "0jnz6r9yqyf7dschr2fnn1slg4wn6b4ik5q00j4zrh43bfw7s9pq"))))
|
|
(build-system r-build-system)
|
|
(propagated-inputs
|
|
`(("r-magrittr" ,r-magrittr)
|
|
("r-stringi" ,r-stringi)))
|
|
(home-page "https://github.com/hadley/stringr")
|
|
(synopsis "Simple, consistent wrappers for common string operations")
|
|
(description
|
|
"Stringr is a consistent, simple and easy to use set of wrappers around
|
|
the fantastic 'stringi' package. All function and argument names (and
|
|
positions) are consistent, all functions deal with \"NA\"'s and zero length
|
|
vectors in the same way, and the output from one function is easy to feed into
|
|
the input of another.")
|
|
(license license:gpl2+)))
|
|
|
|
(define-public r-reshape2
|
|
(package
|
|
(name "r-reshape2")
|
|
(version "1.4.1")
|
|
(source
|
|
(origin
|
|
(method url-fetch)
|
|
(uri (cran-uri "reshape2" version))
|
|
(sha256
|
|
(base32 "0hl082dyk3pk07nqprpn5dvnrkqhnf6zjnjig1ijddxhlmsrzm7v"))))
|
|
(build-system r-build-system)
|
|
(propagated-inputs
|
|
`(("r-plyr" ,r-plyr)
|
|
("r-rcpp" ,r-rcpp)
|
|
("r-stringr" ,r-stringr)))
|
|
(home-page "https://github.com/hadley/reshape")
|
|
(synopsis "Flexibly reshape data: a reboot of the \"reshape\" package")
|
|
(description
|
|
"Reshape2 is an R library to flexibly restructure and aggregate data
|
|
using just two functions: melt and dcast (or acast).")
|
|
(license license:expat)))
|
|
|
|
(define-public r-scales
|
|
(package
|
|
(name "r-scales")
|
|
(version "0.3.0")
|
|
(source
|
|
(origin
|
|
(method url-fetch)
|
|
(uri (cran-uri "scales" version))
|
|
(sha256
|
|
(base32 "1kkgpqzb0a6lnpblhcprr4qzyfk5lhicdv4639xs5cq16n7bkqgl"))))
|
|
(build-system r-build-system)
|
|
(propagated-inputs
|
|
`(("r-dichromat" ,r-dichromat)
|
|
("r-labeling" ,r-labeling)
|
|
("r-munsell" ,r-munsell)
|
|
("r-plyr" ,r-plyr)
|
|
("r-rcolorbrewer" ,r-rcolorbrewer)
|
|
("r-rcpp" ,r-rcpp)))
|
|
(home-page "https://github.com/hadley/scales")
|
|
(synopsis "Scale functions for visualization")
|
|
(description
|
|
"This package provides graphical scales that map data to aesthetics, and
|
|
provides methods for automatically determining breaks and labels for axes and
|
|
legends.")
|
|
(license license:expat)))
|
|
|
|
(define-public r-ggplot2
|
|
(package
|
|
(name "r-ggplot2")
|
|
(version "1.0.1")
|
|
(source
|
|
(origin
|
|
(method url-fetch)
|
|
(uri (cran-uri "ggplot2" version))
|
|
(sha256
|
|
(base32 "0794kjqi3lrxb33lr1mykd58959hlgkhdn259vj8fxrh65mqw920"))))
|
|
(build-system r-build-system)
|
|
(propagated-inputs
|
|
`(("r-digest" ,r-digest)
|
|
("r-gtable" ,r-gtable)
|
|
("r-plyr" ,r-plyr)
|
|
("r-proto" ,r-proto)
|
|
("r-reshape2" ,r-reshape2)
|
|
("r-scales" ,r-scales)))
|
|
(home-page "http://ggplot2.org")
|
|
(synopsis "An implementation of the grammar of graphics")
|
|
(description
|
|
"Ggplot2 is an implementation of the grammar of graphics in R. It
|
|
combines the advantages of both base and lattice graphics: conditioning and
|
|
shared axes are handled automatically, and you can still build up a plot step
|
|
by step from multiple data sources. It also implements a sophisticated
|
|
multidimensional conditioning system and a consistent interface to map data to
|
|
aesthetic attributes.")
|
|
(license license:gpl2+)))
|
|
|
|
(define-public r-assertthat
|
|
(package
|
|
(name "r-assertthat")
|
|
(version "0.1")
|
|
(source (origin
|
|
(method url-fetch)
|
|
(uri (cran-uri "assertthat" version))
|
|
(sha256
|
|
(base32
|
|
"0dwsqajyglfscqilj843qfqn1ndbqpswa7b4l1d633qjk9d68qqk"))))
|
|
(build-system r-build-system)
|
|
(home-page "https://github.com/hadley/assertthat")
|
|
(synopsis "Easy pre and post assertions")
|
|
(description
|
|
"Assertthat is an extension to stopifnot() that makes it easy to declare
|
|
the pre and post conditions that your code should satisfy, while also
|
|
producing friendly error messages so that your users know what they've done
|
|
wrong.")
|
|
(license license:gpl3+)))
|
|
|
|
(define-public r-lazyeval
|
|
(package
|
|
(name "r-lazyeval")
|
|
(version "0.1.10")
|
|
(source (origin
|
|
(method url-fetch)
|
|
(uri (cran-uri "lazyeval" version))
|
|
(sha256
|
|
(base32
|
|
"02qfpn2fmy78vx4jxr7g7rhqzcm1kcivfwai7lbh0vvpawia0qwh"))))
|
|
(build-system r-build-system)
|
|
(home-page "https://github.com/hadley/lazyeval")
|
|
(synopsis "Lazy (non-standard) evaluation in R")
|
|
(description
|
|
"This package provides the tools necessary to do non-standard
|
|
evaluation (NSE) in R.")
|
|
(license license:gpl3+)))
|
|
|
|
(define-public r-dbi
|
|
(package
|
|
(name "r-dbi")
|
|
(version "0.3.1")
|
|
(source (origin
|
|
(method url-fetch)
|
|
(uri (cran-uri "DBI" version))
|
|
(sha256
|
|
(base32
|
|
"0xj5baxwnhl23rd5nskhjvranrwrc68f3xlyrklglipi41bm69hw"))))
|
|
(build-system r-build-system)
|
|
(home-page "https://github.com/rstats-db/DBI")
|
|
(synopsis "R database interface")
|
|
(description
|
|
"The DBI package provides a database interface (DBI) definition for
|
|
communication between R and relational database management systems. All
|
|
classes in this package are virtual and need to be extended by the various
|
|
R/DBMS implementations.")
|
|
(license license:lgpl2.0+)))
|
|
|
|
(define-public r-bh
|
|
(package
|
|
(name "r-bh")
|
|
(version "1.58.0-1")
|
|
(source (origin
|
|
(method url-fetch)
|
|
(uri (cran-uri "BH" version))
|
|
(sha256
|
|
(base32
|
|
"17rnwyw9ib2pvm60iixzkbz7ff4fslpifp1nlx4czp42hy67kqpf"))))
|
|
(build-system r-build-system)
|
|
(home-page "https://github.com/eddelbuettel/bh")
|
|
(synopsis "R package providing subset of Boost headers")
|
|
(description
|
|
"This package aims to provide the most useful subset of Boost libraries
|
|
for template use among CRAN packages.")
|
|
(license license:boost1.0)))
|
|
|
|
(define-public r-evaluate
|
|
(package
|
|
(name "r-evaluate")
|
|
(version "0.8")
|
|
(source (origin
|
|
(method url-fetch)
|
|
(uri (cran-uri "evaluate" version))
|
|
(sha256
|
|
(base32
|
|
"137gc35jlizhqnx19mxim3llrkm403abj8ghb2b7v5ls9rvd40pq"))))
|
|
(build-system r-build-system)
|
|
(propagated-inputs
|
|
`(("r-stringr" ,r-stringr)))
|
|
(home-page "https://github.com/hadley/evaluate")
|
|
(synopsis "Parsing and evaluation tools for R")
|
|
(description
|
|
"This package provides tools that allow you to recreate the parsing,
|
|
evaluation and display of R code, with enough information that you can
|
|
accurately recreate what happens at the command line. The tools can easily be
|
|
adapted for other output formats, such as HTML or LaTeX.")
|
|
(license license:gpl3+)))
|
|
|
|
(define-public r-formatr
|
|
(package
|
|
(name "r-formatr")
|
|
(version "1.2.1")
|
|
(source (origin
|
|
(method url-fetch)
|
|
(uri (cran-uri "formatR" version))
|
|
(sha256
|
|
(base32
|
|
"0f4cv2zv5wayyqx99ybfyl0p83kgjvnsv8dhcwa4s49kw6jsx1lr"))))
|
|
(build-system r-build-system)
|
|
(home-page "http://yihui.name/formatR")
|
|
(synopsis "Format R code automatically")
|
|
(description
|
|
"This package provides a function to format R source code. Spaces and
|
|
indent will be added to the code automatically, and comments will be preserved
|
|
under certain conditions, so that R code will be more human-readable and tidy.
|
|
There is also a Shiny app as a user interface in this package.")
|
|
(license license:gpl3+)))
|
|
|
|
(define-public r-highr
|
|
(package
|
|
(name "r-highr")
|
|
(version "0.5.1")
|
|
(source (origin
|
|
(method url-fetch)
|
|
(uri (cran-uri "highr" version))
|
|
(sha256
|
|
(base32
|
|
"11hyawzhaw3ph5y5xphi7alx6df1d0i6wh0a2n5m4sxxhdrzswnb"))))
|
|
(build-system r-build-system)
|
|
(home-page "https://github.com/yihui/highr")
|
|
(synopsis "Syntax highlighting for R source code")
|
|
(description
|
|
"This package provides syntax highlighting for R source code. Currently
|
|
it supports LaTeX and HTML output. Source code of other languages is
|
|
supported via Andre Simon's highlight package.")
|
|
(license license:gpl3+)))
|
|
|
|
(define-public r-mime
|
|
(package
|
|
(name "r-mime")
|
|
(version "0.4")
|
|
(source (origin
|
|
(method url-fetch)
|
|
(uri (cran-uri "mime" version))
|
|
(sha256
|
|
(base32
|
|
"145cdcg252w2zsq67dmvmsqka60msfp7agymlxs3gl3ihgiwg46p"))))
|
|
(build-system r-build-system)
|
|
(home-page "https://github.com/yihui/mime")
|
|
(synopsis "R package to map filenames to MIME types")
|
|
(description
|
|
"This package guesses the MIME type from a filename extension using the
|
|
data derived from /etc/mime.types in UNIX-type systems.")
|
|
(license license:gpl2)))
|
|
|
|
(define-public r-markdown
|
|
(package
|
|
(name "r-markdown")
|
|
(version "0.7.7")
|
|
(source (origin
|
|
(method url-fetch)
|
|
(uri (cran-uri "markdown" version))
|
|
(sha256
|
|
(base32
|
|
"00j1hlib3il50azs2vlcyhi0bjpx1r50mxr9w9dl5g1bwjjc71hb"))))
|
|
(build-system r-build-system)
|
|
;; Skip check phase because the tests require the r-knitr package to be
|
|
;; installed. This prevents installation failures. Knitr normally
|
|
;; shouldn't be available since r-markdown is a dependency of the r-knitr
|
|
;; package.
|
|
(arguments `(#:tests? #f))
|
|
(propagated-inputs
|
|
`(("r-mime" ,r-mime)))
|
|
(home-page "https://github.com/rstudio/markdown")
|
|
(synopsis "Markdown rendering for R")
|
|
(description
|
|
"This package provides R bindings to the Sundown Markdown rendering
|
|
library (https://github.com/vmg/sundown). Markdown is a plain-text formatting
|
|
syntax that can be converted to XHTML or other formats.")
|
|
(license license:gpl2)))
|
|
|
|
(define-public r-yaml
|
|
(package
|
|
(name "r-yaml")
|
|
(version "2.1.13")
|
|
(source (origin
|
|
(method url-fetch)
|
|
(uri (cran-uri "yaml" version))
|
|
(sha256
|
|
(base32
|
|
"18kz5mfn7qpif5pn91w4vbrc5bkycsj85vwm5wxwzjlb02i9mxi6"))))
|
|
(build-system r-build-system)
|
|
(home-page "https://cran.r-project.org/web/packages/yaml/")
|
|
(synopsis "Methods to convert R data to YAML and back")
|
|
(description
|
|
"This package implements the libyaml YAML 1.1 parser and
|
|
emitter (http://pyyaml.org/wiki/LibYAML) for R.")
|
|
(license license:bsd-3)))
|
|
|
|
(define-public r-knitr
|
|
(package
|
|
(name "r-knitr")
|
|
(version "1.11")
|
|
(source (origin
|
|
(method url-fetch)
|
|
(uri (cran-uri "knitr" version))
|
|
(sha256
|
|
(base32
|
|
"1ikjla0hnpjfkdbydqhhqypc0aiizbi4nyn8c694sdk9ca4jasdd"))))
|
|
(build-system r-build-system)
|
|
(propagated-inputs
|
|
`(("r-evaluate" ,r-evaluate)
|
|
("r-digest" ,r-digest)
|
|
("r-formatr" ,r-formatr)
|
|
("r-highr" ,r-highr)
|
|
("r-markdown" ,r-markdown)
|
|
("r-stringr" ,r-stringr)
|
|
("r-yaml" ,r-yaml)))
|
|
(home-page "http://yihui.name/knitr/")
|
|
(synopsis "General-purpose package for dynamic report generation in R")
|
|
(description
|
|
"This package provides a general-purpose tool for dynamic report
|
|
generation in R using Literate Programming techniques.")
|
|
;; The code is released under any version of the GPL. As it is used by
|
|
;; r-markdown which is available under GPLv2 only, we have chosen GPLv2+
|
|
;; here.
|
|
(license license:gpl2+)))
|
|
|
|
(define-public r-microbenchmark
|
|
(package
|
|
(name "r-microbenchmark")
|
|
(version "1.4-2")
|
|
(source (origin
|
|
(method url-fetch)
|
|
(uri (cran-uri "microbenchmark" version))
|
|
(sha256
|
|
(base32
|
|
"05yxvdnkxr2ll94h6f2m5sn3gg7vrlm9nbdxgmj2g8cp8gfxpfkg"))))
|
|
(build-system r-build-system)
|
|
(propagated-inputs
|
|
`(("r-ggplot2" ,r-ggplot2)))
|
|
(home-page "https://cran.r-project.org/web/packages/microbenchmark/")
|
|
(synopsis "Accurate timing functions for R")
|
|
(description
|
|
"This package provides infrastructure to accurately measure and compare
|
|
the execution time of R expressions.")
|
|
(license license:bsd-2)))
|
|
|
|
(define-public r-codetools
|
|
(package
|
|
(name "r-codetools")
|
|
(version "0.2-14")
|
|
(source (origin
|
|
(method url-fetch)
|
|
(uri (cran-uri "codetools" version))
|
|
(sha256
|
|
(base32
|
|
"0y9r4m2b8xgavr89sc179knzwpz54xljbc1dinpq2q07i4xn0397"))))
|
|
(build-system r-build-system)
|
|
(home-page "https://cran.r-project.org/web/packages/codetools/index.html")
|
|
(synopsis "Code analysis tools for R")
|
|
(description "This package provides code analysis tools for R.")
|
|
(license license:gpl3+)))
|
|
|
|
(define-public r-pryr
|
|
(package
|
|
(name "r-pryr")
|
|
(version "0.1.2")
|
|
(source (origin
|
|
(method url-fetch)
|
|
(uri (cran-uri "pryr" version))
|
|
(sha256
|
|
(base32
|
|
"1in350a8hxwf580afavasvn3jc7x2p1b7nlwmj1scakfz74vghk5"))))
|
|
(build-system r-build-system)
|
|
(propagated-inputs
|
|
`(("r-stringr" ,r-stringr)
|
|
("r-codetools" ,r-codetools)))
|
|
(native-inputs
|
|
`(("r-rcpp" ,r-rcpp)))
|
|
(home-page "https://github.com/hadley/pryr")
|
|
(synopsis "Tools for computing on the R language")
|
|
(description
|
|
"This package provides useful tools to pry back the covers of R and
|
|
understand the language at a deeper level.")
|
|
(license license:gpl2)))
|
|
|
|
(define-public r-memoise
|
|
(package
|
|
(name "r-memoise")
|
|
(version "0.2.1")
|
|
(source (origin
|
|
(method url-fetch)
|
|
(uri (cran-uri "memoise" version))
|
|
(sha256
|
|
(base32
|
|
"19wm4b3kq6xva43kga3xydnl7ybl5mq7b4y2fczgzzjz63jd75y4"))))
|
|
(build-system r-build-system)
|
|
(propagated-inputs
|
|
`(("r-digest" ,r-digest)))
|
|
(home-page "http://github.com/hadley/memoise")
|
|
(synopsis "Memoise functions for R")
|
|
(description
|
|
"This R package allows to cache the results of a function so that when
|
|
you call it again with the same arguments it returns the pre-computed value.")
|
|
(license license:expat)))
|
|
|
|
(define-public r-crayon
|
|
(package
|
|
(name "r-crayon")
|
|
(version "1.3.1")
|
|
(source (origin
|
|
(method url-fetch)
|
|
(uri (cran-uri "crayon" version))
|
|
(sha256
|
|
(base32
|
|
"0d38fm06h272a8iqlc0d45m2rh36giwqw7mwq4z8hkp4vs975fmm"))))
|
|
(build-system r-build-system)
|
|
(propagated-inputs
|
|
`(("r-memoise" ,r-memoise)))
|
|
(home-page "https://github.com/gaborcsardi/crayon")
|
|
(synopsis "Colored terminal output for R")
|
|
(description
|
|
"Colored terminal output on terminals that support ANSI color and
|
|
highlight codes. It also works in Emacs ESS. ANSI color support is
|
|
automatically detected. Colors and highlighting can be combined and nested.
|
|
New styles can also be created easily. This package was inspired by the
|
|
\"chalk\" JavaScript project.")
|
|
(license license:expat)))
|
|
|
|
(define-public r-testthat
|
|
(package
|
|
(name "r-testthat")
|
|
(version "0.10.0")
|
|
(source (origin
|
|
(method url-fetch)
|
|
(uri (cran-uri "testthat" version))
|
|
(sha256
|
|
(base32
|
|
"0b3akwcx5mv9dmi8vssbk91hr3yrrdxd2fm6zhr31fnyz8kjx4pw"))))
|
|
(build-system r-build-system)
|
|
(propagated-inputs
|
|
`(("r-digest" ,r-digest)
|
|
("r-crayon" ,r-crayon)))
|
|
(home-page "https://github.com/hadley/testthat")
|
|
(synopsis "Unit testing for R")
|
|
(description
|
|
"This package provides a unit testing system for R designed to be fun,
|
|
flexible and easy to set up.")
|
|
(license license:expat)))
|
|
|
|
(define-public r-r6
|
|
(package
|
|
(name "r-r6")
|
|
(version "2.1.1")
|
|
(source (origin
|
|
(method url-fetch)
|
|
(uri (cran-uri "R6" version))
|
|
(sha256
|
|
(base32
|
|
"16qq35bgxgswf989yvsqkb6fv7srpf8n8dv2s2c0z9n6zgmwq66m"))))
|
|
(build-system r-build-system)
|
|
(propagated-inputs
|
|
`(("r-knitr" ,r-knitr)
|
|
("r-microbenchmark" ,r-microbenchmark)
|
|
("r-pryr" ,r-pryr)
|
|
("r-testthat" ,r-testthat)
|
|
("r-ggplot2" ,r-ggplot2)
|
|
("r-scales" ,r-scales)))
|
|
(home-page "https://github.com/wch/R6/")
|
|
(synopsis "Classes with reference semantics in R")
|
|
(description
|
|
"The R6 package allows the creation of classes with reference semantics,
|
|
similar to R's built-in reference classes. Compared to reference classes, R6
|
|
classes are simpler and lighter-weight, and they are not built on S4 classes
|
|
so they do not require the methods package. These classes allow public and
|
|
private members, and they support inheritance, even when the classes are
|
|
defined in different packages.")
|
|
(license license:expat)))
|
|
|
|
(define-public r-dplyr
|
|
(package
|
|
(name "r-dplyr")
|
|
(version "0.4.3")
|
|
(source (origin
|
|
(method url-fetch)
|
|
(uri (cran-uri "dplyr" version))
|
|
(sha256
|
|
(base32
|
|
"1p8rbn4p4yrx2840dapwiahf9iqa8gnvd35nyc200wfhmrxlqdlc"))))
|
|
(build-system r-build-system)
|
|
(propagated-inputs
|
|
`(("r-assertthat" ,r-assertthat)
|
|
("r-r6" ,r-r6)
|
|
("r-magrittr" ,r-magrittr)
|
|
("r-lazyeval" ,r-lazyeval)
|
|
("r-dbi" ,r-dbi)))
|
|
(native-inputs
|
|
`(("r-rcpp" ,r-rcpp)
|
|
("r-bh" ,r-bh)))
|
|
(home-page "https://github.com/hadley/dplyr")
|
|
(synopsis "Tools for working with data frames in R")
|
|
(description
|
|
"dplyr is the next iteration of plyr. It is focussed on tools for
|
|
working with data frames. It has three main goals: 1) identify the most
|
|
important data manipulation tools needed for data analysis and make them easy
|
|
to use in R; 2) provide fast performance for in-memory data by writing key
|
|
pieces of code in C++; 3) use the same code interface to work with data no
|
|
matter where it is stored, whether in a data frame, a data table or
|
|
database.")
|
|
(license license:expat)))
|
|
|
|
(define-public r-chron
|
|
(package
|
|
(name "r-chron")
|
|
(version "2.3-47")
|
|
(source (origin
|
|
(method url-fetch)
|
|
(uri (cran-uri "chron" version))
|
|
(sha256
|
|
(base32
|
|
"1xj50kk8b8mbjpszp8i0wbripb5a4b36jcscwlbyap8n4487g34s"))))
|
|
(build-system r-build-system)
|
|
(home-page "http://cran.r-project.org/web/packages/chron")
|
|
(synopsis "Chronological R objects which can handle dates and times")
|
|
(description
|
|
"This package provides chronological R objects which can handle dates and
|
|
times.")
|
|
(license license:gpl2)))
|
|
|
|
(define-public r-data-table
|
|
(package
|
|
(name "r-data-table")
|
|
(version "1.9.6")
|
|
(source (origin
|
|
(method url-fetch)
|
|
(uri (cran-uri "data.table" version))
|
|
(sha256
|
|
(base32
|
|
"0vi3zplpxqbg78z9ifjfs1kl2i8qhkqxr7l9ysp2663kq54w6x3g"))))
|
|
(build-system r-build-system)
|
|
(propagated-inputs
|
|
`(("r-chron" ,r-chron)))
|
|
(home-page "https://github.com/Rdatatable/data.table/wiki")
|
|
(synopsis "Enhanced version of data.frame R object")
|
|
(description
|
|
"The R package @code{data.table} is an extension of @code{data.frame}
|
|
providing functions for fast aggregation of large data (e.g. 100GB in RAM),
|
|
fast ordered joins, fast add/modify/delete of columns by group, column listing
|
|
and fast file reading.")
|
|
(license license:gpl3+)))
|
|
|
|
(define-public python-patsy
|
|
(package
|
|
(name "python-patsy")
|
|
(version "0.4.0")
|
|
(source (origin
|
|
(method url-fetch)
|
|
(uri (string-append "https://pypi.python.org/packages/source/"
|
|
"p/patsy/patsy-" version ".zip"))
|
|
(sha256
|
|
(base32
|
|
"1kbs996xc2haxalmhd19rr1wh5fa4gbbxf81czkf5w4kam7h7wz4"))))
|
|
(build-system python-build-system)
|
|
(arguments
|
|
`(#:phases
|
|
(modify-phases %standard-phases
|
|
(replace 'check (lambda _ (zero? (system* "nosetests" "-v"))))
|
|
(add-after 'unpack 'prevent-generation-of-egg-archive
|
|
(lambda _
|
|
(substitute* "setup.py"
|
|
(("from setuptools import setup")
|
|
"from distutils.core import setup"))
|
|
#t)))))
|
|
(propagated-inputs
|
|
`(("python-numpy" ,python-numpy)
|
|
("python-scipy" ,python-scipy)
|
|
("python-six" ,python-six)))
|
|
(native-inputs
|
|
`(("python-nose" ,python-nose)
|
|
("unzip" ,unzip)))
|
|
(home-page "https://github.com/pydata/patsy")
|
|
(synopsis "Describe statistical models and build design matrices")
|
|
(description
|
|
"Patsy is a Python package for describing statistical models and for
|
|
building design matrices.")
|
|
;; The majority of the code is distributed under BSD-2. The module
|
|
;; patsy.compat contains code derived from the Python standard library,
|
|
;; and is covered by the PSFL.
|
|
(license (list license:bsd-2 license:psfl))))
|
|
|
|
(define-public python2-patsy
|
|
(let ((patsy (package-with-python2 python-patsy)))
|
|
(package (inherit patsy)
|
|
(native-inputs
|
|
`(("python2-setuptools" ,python2-setuptools)
|
|
,@(package-native-inputs patsy)))
|
|
(propagated-inputs
|
|
`(("python2-numpy" ,python2-numpy)
|
|
("python2-scipy" ,python2-scipy)
|
|
,@(alist-delete "python-numpy"
|
|
(alist-delete "python-scipy"
|
|
(package-propagated-inputs patsy))))))))
|
|
|
|
(define-public python-statsmodels
|
|
(package
|
|
(name "python-statsmodels")
|
|
(version "0.6.1")
|
|
(source
|
|
(origin
|
|
(method url-fetch)
|
|
(uri (string-append "https://pypi.python.org/packages/source/"
|
|
"s/statsmodels/statsmodels-" version ".tar.gz"))
|
|
(sha256
|
|
(base32
|
|
"0xn67sqr0cc1lmlhzm71352hrb4hw7g318p5ff5q97pc98vl8kmy"))))
|
|
(build-system python-build-system)
|
|
(arguments
|
|
`(#:phases
|
|
(modify-phases %standard-phases
|
|
;; tests must be run after installation
|
|
(delete 'check)
|
|
(add-after 'unpack 'set-matplotlib-backend-to-agg
|
|
(lambda _
|
|
;; Set the matplotlib backend to Agg to avoid problems using the
|
|
;; GTK backend without a display.
|
|
(substitute* (find-files "statsmodels/graphics/tests" "\\.py")
|
|
(("import matplotlib\\.pyplot as plt" line)
|
|
(string-append "import matplotlib;matplotlib.use('Agg');"
|
|
line)))
|
|
#t))
|
|
(add-after 'install 'check
|
|
(lambda _
|
|
(with-directory-excursion "/tmp"
|
|
(zero? (system* "nosetests"
|
|
"--stop"
|
|
"-v" "statsmodels"))))))))
|
|
(propagated-inputs
|
|
`(("python-numpy" ,python-numpy)
|
|
("python-scipy" ,python-scipy)
|
|
("python-pandas" ,python-pandas)
|
|
("python-patsy" ,python-patsy)
|
|
("python-matplotlib" ,python-matplotlib)))
|
|
(native-inputs
|
|
`(("python-cython" ,python-cython)
|
|
("python-nose" ,python-nose)
|
|
("python-sphinx" ,python-sphinx)))
|
|
(home-page "http://statsmodels.sourceforge.net/")
|
|
(synopsis "Statistical modeling and econometrics in Python")
|
|
(description
|
|
"Statsmodels is a Python package that provides a complement to scipy for
|
|
statistical computations including descriptive statistics and estimation and
|
|
inference for statistical models.")
|
|
(license license:bsd-3)))
|
|
|
|
(define-public python2-statsmodels
|
|
(let ((stats (package-with-python2 python-statsmodels)))
|
|
(package (inherit stats)
|
|
(propagated-inputs
|
|
`(("python2-numpy" ,python2-numpy)
|
|
("python2-scipy" ,python2-scipy)
|
|
("python2-pandas" ,python2-pandas)
|
|
("python2-patsy" ,python2-patsy)
|
|
("python2-matplotlib" ,python2-matplotlib)))
|
|
(native-inputs
|
|
`(("python2-setuptools" ,python2-setuptools)
|
|
,@(package-native-inputs stats))))))
|
|
|
|
(define-public r-xml2
|
|
(package
|
|
(name "r-xml2")
|
|
(version "0.1.2")
|
|
(source
|
|
(origin
|
|
(method url-fetch)
|
|
(uri (cran-uri "xml2" version))
|
|
(sha256
|
|
(base32
|
|
"0jjilz36h7vbdbkpvjnja1vgjf6d1imql3z4glqn2m2b74w5qm4c"))))
|
|
(build-system r-build-system)
|
|
(inputs
|
|
`(("libxml2" ,libxml2)))
|
|
(propagated-inputs
|
|
`(("r-rcpp" ,r-rcpp)
|
|
("r-bh" ,r-bh)))
|
|
(home-page "https://github.com/hadley/xml2")
|
|
(synopsis "Parse XML with R")
|
|
(description
|
|
"This package provides a simple, consistent interface to working with XML
|
|
files in R. It is built on top of the libxml2 C library.")
|
|
(license license:gpl2+)))
|
|
|
|
(define-public r-rversions
|
|
(package
|
|
(name "r-rversions")
|
|
(version "1.0.2")
|
|
(source (origin
|
|
(method url-fetch)
|
|
(uri (cran-uri "rversions" version))
|
|
(sha256
|
|
(base32
|
|
"0xmi461g1rf5ngb7r1sri798jn6icld1xq25wj9jii2ca8j8xv68"))))
|
|
(build-system r-build-system)
|
|
(propagated-inputs
|
|
`(("r-curl" ,r-curl)
|
|
("r-xml2" ,r-xml2)))
|
|
(home-page "https://github.com/metacran/rversions")
|
|
(synopsis "Query R versions, including 'r-release' and 'r-oldrel'")
|
|
(description
|
|
"This package provides functions to query the main R repository to find
|
|
the versions that @code{r-release} and @code{r-oldrel} refer to, and also all
|
|
previous R versions and their release dates.")
|
|
(license license:expat)))
|
|
|
|
(define-public r-whisker
|
|
(package
|
|
(name "r-whisker")
|
|
(version "0.3-2")
|
|
(source (origin
|
|
(method url-fetch)
|
|
(uri (cran-uri "whisker" version))
|
|
(sha256
|
|
(base32
|
|
"0z4cn115gxcl086d6bnqr8afi67b6a7xqg6ivmk3l4ng1x8kcj28"))))
|
|
(build-system r-build-system)
|
|
(home-page "http://github.com/edwindj/whisker")
|
|
(synopsis "Logicless mustache templating for R")
|
|
(description
|
|
"This package provides logicless templating, with a syntax that is not
|
|
limited to R.")
|
|
(license license:gpl3+)))
|
|
|
|
(define-public r-brew
|
|
(package
|
|
(name "r-brew")
|
|
(version "1.0-6")
|
|
(source (origin
|
|
(method url-fetch)
|
|
(uri (cran-uri "brew" version))
|
|
(sha256
|
|
(base32
|
|
"1vghazbcha8gvkwwcdagjvzx6yl8zm7kgr0i9wxr4jng06d1l3fp"))))
|
|
(build-system r-build-system)
|
|
(home-page "http://cran.r-project.org/web/packages/brew")
|
|
(synopsis "Templating framework for report generation")
|
|
(description
|
|
"The brew package implements a templating framework for mixing text and R
|
|
code for report generation. The template syntax is similar to PHP, Ruby's erb
|
|
module, Java Server Pages, and Python's psp module.")
|
|
(license license:gpl2+)))
|
|
|
|
(define-public r-roxygen2
|
|
(package
|
|
(name "r-roxygen2")
|
|
(version "5.0.0")
|
|
(source (origin
|
|
(method url-fetch)
|
|
(uri (cran-uri "roxygen2" version))
|
|
(sha256
|
|
(base32
|
|
"0xjdphjs7l1v71lylmqgp76cbcxzvm9z1a40jgkdwvz072nn08vr"))))
|
|
(build-system r-build-system)
|
|
(propagated-inputs
|
|
`(("r-brew" ,r-brew)
|
|
("r-digest" ,r-digest)
|
|
("r-rcpp" ,r-rcpp)
|
|
("r-stringi" ,r-stringi)
|
|
("r-stringr" ,r-stringr)))
|
|
(home-page "https://github.com/klutometis/roxygen")
|
|
(synopsis "In-source documentation system for R")
|
|
(description
|
|
"Roxygen2 is a Doxygen-like in-source documentation system for Rd,
|
|
collation, and NAMESPACE files.")
|
|
(license license:gpl2+)))
|
|
|
|
(define-public r-httr
|
|
(package
|
|
(name "r-httr")
|
|
(version "1.0.0")
|
|
(source (origin
|
|
(method url-fetch)
|
|
(uri (cran-uri "httr" version))
|
|
(sha256
|
|
(base32
|
|
"1yprw8p4g8026jhravgg1hdwj1g51cpdgycyr5a58jwm4i5f79cq"))))
|
|
(build-system r-build-system)
|
|
(propagated-inputs
|
|
`(("r-curl" ,r-curl)
|
|
("r-digest" ,r-digest)
|
|
("r-jsonlite" ,r-jsonlite)
|
|
("r-mime" ,r-mime)
|
|
("r-r6" ,r-r6)
|
|
("r-stringr" ,r-stringr)))
|
|
(home-page "https://github.com/hadley/httr")
|
|
(synopsis "Tools for working with URLs and HTTP")
|
|
(description
|
|
"The aim of httr is to provide a wrapper for RCurl customised to the
|
|
demands of modern web APIs. It provides useful tools for working with HTTP
|
|
organised by HTTP verbs (@code{GET()}, @code{POST()}, etc). Configuration
|
|
functions make it easy to control additional request components.")
|
|
(license license:expat)))
|
|
|
|
(define-public r-git2r
|
|
(package
|
|
(name "r-git2r")
|
|
(version "0.11.0")
|
|
(source (origin
|
|
(method url-fetch)
|
|
(uri (cran-uri "git2r" version))
|
|
(sha256
|
|
(base32
|
|
"1h5ag8sm512jsn2sp4yhiqspc7hjq5y8z0kqz24sdznxa3b7rpn9"))))
|
|
(build-system r-build-system)
|
|
;; This R package contains modified sources of libgit2. This modified
|
|
;; version of libgit2 is built as the package is built. Hence libgit2 is
|
|
;; not among the inputs of this package.
|
|
(inputs
|
|
`(("libssh2" ,libssh2)
|
|
("openssl" ,openssl)
|
|
("zlib" ,zlib)))
|
|
(home-page "https://github.com/ropensci/git2r")
|
|
(synopsis "Access Git repositories with R")
|
|
(description
|
|
"This package provides an R interface to the libgit2 library, which is a
|
|
pure C implementation of the Git core methods.")
|
|
;; GPLv2 only with linking exception.
|
|
(license license:gpl2)))
|
|
|
|
(define-public r-rstudioapi
|
|
(package
|
|
(name "r-rstudioapi")
|
|
(version "0.3.1")
|
|
(source (origin
|
|
(method url-fetch)
|
|
(uri (cran-uri "rstudioapi" version))
|
|
(sha256
|
|
(base32
|
|
"0q7671d924nzqsqhs8d9p7l907bcam56wjwm7vvz44xgj0saj8bs"))))
|
|
(build-system r-build-system)
|
|
(home-page "http://cran.r-project.org/web/packages/rstudioapi")
|
|
(synopsis "Safely access the RStudio API")
|
|
(description
|
|
"This package provides functions to access the RStudio API and provide
|
|
informative error messages when it's not available.")
|
|
(license license:expat)))
|
|
|
|
(define-public r-devtools
|
|
(package
|
|
(name "r-devtools")
|
|
(version "1.9.1")
|
|
(source (origin
|
|
(method url-fetch)
|
|
(uri (cran-uri "devtools" version))
|
|
(sha256
|
|
(base32
|
|
"10ycx3kkiz5x8nmgw31d9wa5hhlx2fhda2nqzxfrczqpz1jik6ci"))))
|
|
(build-system r-build-system)
|
|
(propagated-inputs
|
|
`(("r-curl" ,r-curl)
|
|
("r-digest" ,r-digest)
|
|
("r-evaluate" ,r-evaluate)
|
|
("r-git2r" ,r-git2r)
|
|
("r-httr" ,r-httr)
|
|
("r-jsonlite" ,r-jsonlite)
|
|
("r-memoise" ,r-memoise)
|
|
("r-roxygen2" ,r-roxygen2)
|
|
("r-rstudioapi" ,r-rstudioapi)
|
|
("r-rversions" ,r-rversions)
|
|
("r-whisker" ,r-whisker)))
|
|
(home-page "https://github.com/hadley/devtools")
|
|
(synopsis "Tools to make developing R packages easier")
|
|
(description "The devtools package is a collection of package development
|
|
tools to simplify the devolpment of R packages.")
|
|
(license license:gpl2+)))
|
|
|
|
(define-public r-readr
|
|
(package
|
|
(name "r-readr")
|
|
(version "0.2.2")
|
|
(source (origin
|
|
(method url-fetch)
|
|
(uri (cran-uri "readr" version))
|
|
(sha256
|
|
(base32
|
|
"156422xwvskynna5kjc8h1qqnn50kxgjrihl2h2b7vm9sxxdyr2m"))))
|
|
(build-system r-build-system)
|
|
(propagated-inputs
|
|
`(("r-curl" ,r-curl)
|
|
("r-rcpp" ,r-rcpp)
|
|
("r-bh" ,r-bh)))
|
|
(home-page "https://github.com/hadley/readr")
|
|
(synopsis "Read tabular data")
|
|
(description
|
|
"This package provides functions to read flat or tabular text files from
|
|
disk (or a connection).")
|
|
(license license:gpl2+)))
|
|
|
|
(define-public r-plotrix
|
|
(package
|
|
(name "r-plotrix")
|
|
(version "3.6")
|
|
(source (origin
|
|
(method url-fetch)
|
|
(uri (cran-uri "plotrix" version))
|
|
(sha256
|
|
(base32
|
|
"0zn6k8azh40v0lg7q9yd4sy30a26bcc0fjvndn4z7k36avlw4i25"))))
|
|
(build-system r-build-system)
|
|
(home-page "http://cran.r-project.org/web/packages/plotrix")
|
|
(synopsis "Various plotting functions")
|
|
(description
|
|
"This package provides lots of plotting, various labeling, axis and color
|
|
scaling functions for R.")
|
|
(license license:gpl2+)))
|
|
|
|
(define-public r-gridbase
|
|
(package
|
|
(name "r-gridbase")
|
|
(version "0.4-7")
|
|
(source (origin
|
|
(method url-fetch)
|
|
(uri (cran-uri "gridBase" version))
|
|
(sha256
|
|
(base32
|
|
"09jzw4rzwf2y5lcz7b16mb68pn0fqigv34ff7lr6w3yi9k91i1xy"))))
|
|
(build-system r-build-system)
|
|
(home-page "http://cran.r-project.org/web/packages/gridBase")
|
|
(synopsis "Integration of base and grid graphics")
|
|
(description
|
|
"This package provides an integration of base and grid graphics for R.")
|
|
(license license:gpl2+)))
|
|
|
|
(define-public r-lattice
|
|
(package
|
|
(name "r-lattice")
|
|
(version "0.20-33")
|
|
(source (origin
|
|
(method url-fetch)
|
|
(uri (cran-uri "lattice" version))
|
|
(sha256
|
|
(base32
|
|
"0car12x5vl9k180i9pc86lq3cvwqakdpqn3lgdf98k9n2h52cilg"))))
|
|
(build-system r-build-system)
|
|
(home-page "http://lattice.r-forge.r-project.org/")
|
|
(synopsis "High-level data visualization system")
|
|
(description
|
|
"The lattice package provides a powerful and elegant high-level data
|
|
visualization system inspired by Trellis graphics, with an emphasis on
|
|
multivariate data. Lattice is sufficient for typical graphics needs, and is
|
|
also flexible enough to handle most nonstandard requirements.")
|
|
(license license:gpl2+)))
|
|
|
|
(define-public r-rcpparmadillo
|
|
(package
|
|
(name "r-rcpparmadillo")
|
|
(version "0.6.200.2.0")
|
|
(source (origin
|
|
(method url-fetch)
|
|
(uri (cran-uri "RcppArmadillo" version))
|
|
(sha256
|
|
(base32
|
|
"137wqqga776yj6synx5awhrzgkz7mmqnvgmggh9l4k6d99vwp9gj"))
|
|
(modules '((guix build utils)))
|
|
;; Remove bundled armadillo sources
|
|
(snippet
|
|
'(begin
|
|
(delete-file-recursively "inst/include/armadillo_bits")
|
|
(delete-file "inst/include/armadillo")))))
|
|
(properties `((upstream-name . "RcppArmadillo")))
|
|
(build-system r-build-system)
|
|
(arguments
|
|
`(#:phases
|
|
(modify-phases %standard-phases
|
|
(add-after 'unpack 'link-against-armadillo
|
|
(lambda _
|
|
(substitute* "src/Makevars"
|
|
(("PKG_LIBS=" prefix)
|
|
(string-append prefix "-larmadillo"))))))))
|
|
(propagated-inputs
|
|
`(("r-rcpp" ,r-rcpp)
|
|
("armadillo" ,armadillo-for-rcpparmadillo)))
|
|
(home-page "https://github.com/RcppCore/RcppArmadillo")
|
|
(synopsis "Rcpp integration for the Armadillo linear algebra library")
|
|
(description
|
|
"Armadillo is a templated C++ linear algebra library that aims towards a
|
|
good balance between speed and ease of use. Integer, floating point and
|
|
complex numbers are supported, as well as a subset of trigonometric and
|
|
statistics functions. Various matrix decompositions are provided through
|
|
optional integration with LAPACK and ATLAS libraries. This package includes
|
|
the header files from the templated Armadillo library.")
|
|
;; Armadillo is licensed under the MPL 2.0, while RcppArmadillo (the Rcpp
|
|
;; bindings to Armadillo) is licensed under the GNU GPL version 2 or
|
|
;; later, as is the rest of 'Rcpp'.
|
|
(license license:gpl2+)))
|
|
|
|
(define-public r-bitops
|
|
(package
|
|
(name "r-bitops")
|
|
(version "1.0-6")
|
|
(source (origin
|
|
(method url-fetch)
|
|
(uri (cran-uri "bitops" version))
|
|
(sha256
|
|
(base32
|
|
"176nr5wpnkavn5z0yy9f7d47l37ndnn2w3gv854xav8nnybi6wwv"))))
|
|
(build-system r-build-system)
|
|
(home-page "http://cran.r-project.org/web/packages/bitops")
|
|
(synopsis "Bitwise operations")
|
|
(description
|
|
"This package provides functions for bitwise operations on integer
|
|
vectors.")
|
|
(license license:gpl2+)))
|
|
|
|
(define-public r-catools
|
|
(package
|
|
(name "r-catools")
|
|
(version "1.17.1")
|
|
(source (origin
|
|
(method url-fetch)
|
|
(uri (cran-uri "caTools" version))
|
|
(sha256
|
|
(base32
|
|
"1x4szsn2qmbzpyjfdaiz2q7jwhap2gky9wq0riah74q0pzz76ank"))))
|
|
(properties `((upstream-name . "caTools")))
|
|
(build-system r-build-system)
|
|
(propagated-inputs
|
|
`(("r-bitops" ,r-bitops)))
|
|
(home-page "http://cran.r-project.org/web/packages/caTools")
|
|
(synopsis "Various tools including functions for moving window statistics")
|
|
(description
|
|
"This package contains several basic utility functions including:
|
|
moving (rolling, running) window statistic functions, read/write for GIF and
|
|
ENVI binary files, fast calculation of AUC, LogitBoost classifier, base64
|
|
encoder/decoder, round-off-error-free sum and cumsum, etc.")
|
|
(license license:gpl3+)))
|
|
|
|
(define-public r-rmarkdown
|
|
(package
|
|
(name "r-rmarkdown")
|
|
(version "0.8.1")
|
|
(source
|
|
(origin
|
|
(method url-fetch)
|
|
(uri (cran-uri "rmarkdown" version))
|
|
(sha256
|
|
(base32
|
|
"07q5g9dvac5j3vnf4sjc60mnkij1k6y7vnzjz6anf499rwdwbxza"))))
|
|
(properties `((upstream-name . "rmarkdown")))
|
|
(build-system r-build-system)
|
|
(propagated-inputs
|
|
`(("r-catools" ,r-catools)
|
|
("r-htmltools" ,r-htmltools)
|
|
("r-knitr" ,r-knitr)
|
|
("r-yaml" ,r-yaml)
|
|
("ghc-pandoc" ,ghc-pandoc)))
|
|
(home-page "http://rmarkdown.rstudio.com")
|
|
(synopsis "Convert R Markdown documents into a variety of formats")
|
|
(description
|
|
"This package provides tools to convert R Markdown documents into a
|
|
variety of formats.")
|
|
(license license:gpl3+)))
|
|
|
|
(define-public r-gtable
|
|
(package
|
|
(name "r-gtable")
|
|
(version "0.1.2")
|
|
(source (origin
|
|
(method url-fetch)
|
|
(uri (cran-uri "gtable" version))
|
|
(sha256
|
|
(base32
|
|
"0k9hfj6r5y238gqh92s3cbdn34biczx3zfh79ix5xq0c5vkai2xh"))))
|
|
(properties `((upstream-name . "gtable")))
|
|
(build-system r-build-system)
|
|
(home-page "http://cran.r-project.org/web/packages/gtable")
|
|
(synopsis "Arrange grobs in tables")
|
|
(description
|
|
"This package provides tools to make it easier to work with tables of
|
|
grobs.")
|
|
(license license:gpl2+)))
|
|
|
|
(define-public r-gridextra
|
|
(package
|
|
(name "r-gridextra")
|
|
(version "2.0.0")
|
|
(source (origin
|
|
(method url-fetch)
|
|
(uri (cran-uri "gridExtra" version))
|
|
(sha256
|
|
(base32
|
|
"19yyrfd37c5hxlavb9lca9l26wjhc80rlqhgmfj9k3xhbvvpdp17"))))
|
|
(properties `((upstream-name . "gridExtra")))
|
|
(build-system r-build-system)
|
|
(propagated-inputs
|
|
`(("r-gtable" ,r-gtable)))
|
|
(native-inputs
|
|
`(("r-knitr" ,r-knitr))) ;for building vignettes
|
|
(home-page "https://github.com/baptiste/gridextra")
|
|
(synopsis "Miscellaneous functions for \"Grid\" graphics")
|
|
(description
|
|
"This package provides a number of user-level functions to work with
|
|
@code{grid} graphics, notably to arrange multiple grid-based plots on a page,
|
|
and draw tables.")
|
|
(license license:gpl2+)))
|
|
|
|
(define-public r-rsqlite
|
|
(package
|
|
(name "r-rsqlite")
|
|
(version "1.0.0")
|
|
(source (origin
|
|
(method url-fetch)
|
|
(uri (cran-uri "RSQLite" version))
|
|
(sha256
|
|
(base32
|
|
"08b1syv8z887gxiw8i09dpqh0zisfb6ihq6qqr01zipvkahzq34f"))))
|
|
(properties `((upstream-name . "RSQLite")))
|
|
(build-system r-build-system)
|
|
(propagated-inputs
|
|
`(("r-dbi" ,r-dbi)))
|
|
(home-page "https://github.com/rstats-db/RSQLite")
|
|
(synopsis "SQLite interface for R")
|
|
(description
|
|
"This package embeds the SQLite database engine in R and provides an
|
|
interface compliant with the DBI package. The source for the SQLite
|
|
engine (version 3.8.6) is included.")
|
|
(license license:lgpl2.0+)))
|
|
|
|
(define-public r-rcurl
|
|
(package
|
|
(name "r-rcurl")
|
|
(version "1.95-0.1.2")
|
|
(source (origin
|
|
(method url-fetch)
|
|
(uri (string-append "http://www.bioconductor.org/packages/"
|
|
"release/extra/src/"
|
|
"contrib/RCurl_" version ".tar.gz"))
|
|
(sha256
|
|
(base32
|
|
"0l7qi45jxlf898n0jazabnam1yyczvqfdknd00bdirhhiplpd1sc"))))
|
|
(properties `((upstream-name . "RCurl")))
|
|
(build-system r-build-system)
|
|
(inputs
|
|
`(("libcurl" ,curl)))
|
|
(propagated-inputs
|
|
`(("r-bitops" ,r-bitops)))
|
|
(home-page "http://www.omegahat.org/RCurl")
|
|
(synopsis "General network client interface for R")
|
|
(description
|
|
"The package allows one to compose general HTTP requests and provides
|
|
convenient functions to fetch URIs, GET and POST forms, etc. and process the
|
|
results returned by the Web server. This provides a great deal of control
|
|
over the HTTP/FTP/... connection and the form of the request while providing a
|
|
higher-level interface than is available just using R socket connections.
|
|
Additionally, the underlying implementation is robust and extensive,
|
|
supporting FTP/FTPS/TFTP (uploads and downloads), SSL/HTTPS, telnet, dict,
|
|
ldap, and also supports cookies, redirects, authentication, etc.")
|
|
(license license:bsd-3)))
|
|
|
|
(define-public r-xml
|
|
(package
|
|
(name "r-xml")
|
|
(version "3.98-1.3")
|
|
(source (origin
|
|
(method url-fetch)
|
|
(uri (cran-uri "XML" version))
|
|
(sha256
|
|
(base32
|
|
"0j9ayp8a35g0227a4zd8nbmvnbfnj5w687jal6qvj4lbhi3va7sy"))))
|
|
(properties
|
|
`((upstream-name . "XML")))
|
|
(build-system r-build-system)
|
|
(inputs
|
|
`(("libxml2" ,libxml2)))
|
|
(propagated-inputs
|
|
`(("r-rcurl" ,r-rcurl)))
|
|
(home-page "http://www.omegahat.org/RSXML")
|
|
(synopsis "Tools for parsing and generating XML within R")
|
|
(description
|
|
"Many approaches for both reading and creating XML (and HTML)
|
|
documents (including DTDs), both local and accessible via HTTP or FTP. Also
|
|
offers access to an XPath \"interpreter\".")
|
|
(license license:bsd-2)))
|
|
|
|
(define-public r-lambda-r
|
|
(package
|
|
(name "r-lambda-r")
|
|
(version "1.1.7")
|
|
(source (origin
|
|
(method url-fetch)
|
|
(uri (cran-uri "lambda.r" version))
|
|
(sha256
|
|
(base32
|
|
"1lxzrwyminc3dfb07pbn1rmj45kplxgsb17b06pzflj728knbqwa"))))
|
|
(properties `((upstream-name . "lambda.r")))
|
|
(build-system r-build-system)
|
|
(home-page "http://cran.r-project.org/web/packages/lambda.r")
|
|
(synopsis "Functional programming extension for R")
|
|
(description
|
|
"This package provides a language extension to efficiently write
|
|
functional programs in R. Syntax extensions include multi-part function
|
|
definitions, pattern matching, guard statements, built-in (optional) type
|
|
safety.")
|
|
(license license:lgpl3+)))
|
|
|
|
(define-public r-futile-options
|
|
(package
|
|
(name "r-futile-options")
|
|
(version "1.0.0")
|
|
(source (origin
|
|
(method url-fetch)
|
|
(uri (cran-uri "futile.options" version))
|
|
(sha256
|
|
(base32
|
|
"1hp82h6xqq5cck67h7lpf22n3j7mg3v1mla5y5ivnzrrb7iyr17f"))))
|
|
(properties
|
|
`((upstream-name . "futile.options")))
|
|
(build-system r-build-system)
|
|
(home-page "http://cran.r-project.org/web/packages/futile.options")
|
|
(synopsis "Options management framework")
|
|
(description
|
|
"The futile.options subsystem provides an easy user-defined options
|
|
management system that is properly scoped. This means that options created
|
|
via @code{futile.options} are fully self-contained and will not collide with
|
|
options defined in other packages.")
|
|
(license license:lgpl3+)))
|
|
|
|
(define-public r-futile-logger
|
|
(package
|
|
(name "r-futile-logger")
|
|
(version "1.4.1")
|
|
(source (origin
|
|
(method url-fetch)
|
|
(uri (cran-uri "futile.logger" version))
|
|
(sha256
|
|
(base32
|
|
"1plld1icxrcay7llplbd4i8inpg97crpnczk58mbk26j8glqbr51"))))
|
|
(properties `((upstream-name . "futile.logger")))
|
|
(build-system r-build-system)
|
|
(propagated-inputs
|
|
`(("r-futile-options" ,r-futile-options)
|
|
("r-lambda-r" ,r-lambda-r)))
|
|
(home-page "http://cran.r-project.org/web/packages/futile.logger")
|
|
(synopsis "Logging utility for R")
|
|
(description
|
|
"This package provides a simple yet powerful logging utility. Based
|
|
loosely on log4j, futile.logger takes advantage of R idioms to make logging a
|
|
convenient and easy to use replacement for @code{cat} and @code{print}
|
|
statements.")
|
|
(license license:lgpl3+)))
|
|
|
|
(define-public r-snow
|
|
(package
|
|
(name "r-snow")
|
|
(version "0.4-1")
|
|
(source (origin
|
|
(method url-fetch)
|
|
(uri (cran-uri "snow" version))
|
|
(sha256
|
|
(base32
|
|
"19r2yq8aqw99vwyx81p6ay4afsfqffal1wzvizk3dj882s2n4j8w"))))
|
|
(build-system r-build-system)
|
|
(home-page "http://cran.r-project.org/web/packages/snow")
|
|
(synopsis "Support for simple parallel computing in R")
|
|
(description
|
|
"The snow package provides support for simple parallel computing on a
|
|
network of workstations using R. A master R process calls @code{makeCluster}
|
|
to start a cluster of worker processes; the master process then uses functions
|
|
such as @code{clusterCall} and @code{clusterApply} to execute R code on the
|
|
worker processes and collect and return the results on the master.")
|
|
(license (list license:gpl2+ license:gpl3+))))
|
|
|
|
(define-public r-sparsem
|
|
(package
|
|
(name "r-sparsem")
|
|
(version "1.7")
|
|
(source (origin
|
|
(method url-fetch)
|
|
(uri (cran-uri "SparseM" version))
|
|
(sha256
|
|
(base32
|
|
"0s9kab5khk7daqf6nfp1wm1qnhkssnnwnymisfwyk3kz4q5maqfz"))))
|
|
(properties
|
|
`((upstream-name . "SparseM")))
|
|
(inputs
|
|
`(("gfortran" ,gfortran)))
|
|
(build-system r-build-system)
|
|
(home-page "http://www.econ.uiuc.edu/~roger/research/sparse/sparse.html")
|
|
(synopsis "Sparse linear algebra")
|
|
(description
|
|
"This package provides some basic linear algebra functionality for sparse
|
|
matrices. It includes Cholesky decomposition and backsolving as well as
|
|
standard R subsetting and Kronecker products.")
|
|
(license license:gpl2+)))
|
|
|
|
(define-public r-dt
|
|
(package
|
|
(name "r-dt")
|
|
(version "0.1")
|
|
(source (origin
|
|
(method url-fetch)
|
|
(uri (cran-uri "DT" version))
|
|
(sha256
|
|
(base32
|
|
"0mj7iiy1gglw7kixybmb7kr1bcl5r006zcb3klkw7p6vvvzdm6qj"))))
|
|
(properties
|
|
`((upstream-name . "DT")))
|
|
(build-system r-build-system)
|
|
(propagated-inputs
|
|
`(("r-htmltools" ,r-htmltools)
|
|
("r-htmlwidgets" ,r-htmlwidgets)
|
|
("r-magrittr" ,r-magrittr)))
|
|
(home-page "http://rstudio.github.io/DT")
|
|
(synopsis "R wrapper of the DataTables JavaScript library")
|
|
(description
|
|
"This package allows for data objects in R to be rendered as HTML tables
|
|
using the JavaScript library 'DataTables' (typically via R Markdown or Shiny).
|
|
The 'DataTables' library has been included in this R package.")
|
|
;; The DT package as a whole is distributed under GPLv3. The DT package
|
|
;; inludes other software components under different licenses:
|
|
;;
|
|
;; * Expat: jQuery, jquery.highlight.js, DataTables
|
|
;; * ASL2.0: selectize.js
|
|
;; * WTFPL: noUiSlider
|
|
(license (list license:gpl3
|
|
license:expat
|
|
license:asl2.0
|
|
(license:non-copyleft "http://www.wtfpl.net/txt/copying/")))))
|
|
|
|
(define-public r-base64enc
|
|
(package
|
|
(name "r-base64enc")
|
|
(version "0.1-3")
|
|
(source (origin
|
|
(method url-fetch)
|
|
(uri (cran-uri "base64enc" version))
|
|
(sha256
|
|
(base32
|
|
"13b89fhg1nx7zds82a0biz847ixphg9byf5zl2cw9kab6s56v1bd"))))
|
|
(build-system r-build-system)
|
|
(home-page "http://www.rforge.net/base64enc")
|
|
(synopsis "Tools for Base64 encoding")
|
|
(description
|
|
"This package provides tools for handling Base64 encoding. It is more
|
|
flexible than the orphaned \"base64\" package.")
|
|
(license license:gpl2+)))
|
|
|
|
(define-public r-r-methodss3
|
|
(package
|
|
(name "r-r-methodss3")
|
|
(version "1.7.0")
|
|
(source (origin
|
|
(method url-fetch)
|
|
(uri (cran-uri "R.methodsS3" version))
|
|
(sha256
|
|
(base32
|
|
"1dg4bbrwr8jcsqisjrrwxs942mrjq72zw8yvl2br4djdm0md8zz5"))))
|
|
(properties `((upstream-name . "R.methodsS3")))
|
|
(build-system r-build-system)
|
|
(home-page "http://cran.r-project.org/web/packages/R.methodsS3")
|
|
(synopsis "S3 methods simplified")
|
|
(description
|
|
"This package provides methods that simplify the setup of S3 generic
|
|
functions and S3 methods. Major effort has been made in making definition of
|
|
methods as simple as possible with a minimum of maintenance for package
|
|
developers. For example, generic functions are created automatically, if
|
|
missing, and naming conflict are automatically solved, if possible. The
|
|
method @code{setMethodS3()} is a good start for those who in the future may
|
|
want to migrate to S4.")
|
|
(license license:lgpl2.1+)))
|
|
|
|
(define-public r-r-oo
|
|
(package
|
|
(name "r-r-oo")
|
|
(version "1.19.0")
|
|
(source (origin
|
|
(method url-fetch)
|
|
(uri (cran-uri "R.oo" version))
|
|
(sha256
|
|
(base32
|
|
"15rm1qb9a212bqazhcpk7m48hcp7jq8rh4yhd9c6zfyvdqszfmsb"))))
|
|
(properties `((upstream-name . "R.oo")))
|
|
(build-system r-build-system)
|
|
(propagated-inputs
|
|
`(("r-r-methodss3" ,r-r-methodss3)))
|
|
(home-page "https://github.com/HenrikBengtsson/R.oo")
|
|
(synopsis "R object-oriented programming with or without references")
|
|
(description
|
|
"This package provides methods and classes for object-oriented
|
|
programming in R with or without references. Large effort has been made on
|
|
making definition of methods as simple as possible with a minimum of
|
|
maintenance for package developers.")
|
|
(license license:lgpl2.1+)))
|
|
|
|
(define-public r-r-utils
|
|
(package
|
|
(name "r-r-utils")
|
|
(version "2.1.0")
|
|
(source (origin
|
|
(method url-fetch)
|
|
(uri (cran-uri "R.utils" version))
|
|
(sha256
|
|
(base32
|
|
"03pi6pkcsq65fv7cn4x74cj050dc8x5d4xyg930p6f7flk788xaz"))))
|
|
(properties `((upstream-name . "R.utils")))
|
|
(build-system r-build-system)
|
|
(propagated-inputs
|
|
`(("r-r-methodss3" ,r-r-methodss3)
|
|
("r-r-oo" ,r-r-oo)))
|
|
(home-page "https://github.com/HenrikBengtsson/R.utils")
|
|
(synopsis "Various programming utilities")
|
|
(description
|
|
"This package provides utility functions useful when programming and
|
|
developing R packages.")
|
|
(license license:lgpl2.1+)))
|
|
|
|
(define-public r-r-cache
|
|
(package
|
|
(name "r-r-cache")
|
|
(version "0.12.0")
|
|
(source (origin
|
|
(method url-fetch)
|
|
(uri (cran-uri "R.cache" version))
|
|
(sha256
|
|
(base32
|
|
"006x52w9r8phw5hgqmyp0bz8z42vn8p5yibibnzi1sfa1xlw8iyx"))))
|
|
(properties `((upstream-name . "R.cache")))
|
|
(build-system r-build-system)
|
|
(propagated-inputs
|
|
`(("r-digest" ,r-digest)
|
|
("r-r-methodss3" ,r-r-methodss3)
|
|
("r-r-oo" ,r-r-oo)
|
|
("r-r-utils" ,r-r-utils)))
|
|
(home-page "https://github.com/HenrikBengtsson/R.cache")
|
|
(synopsis "Light-weight caching of objects and results")
|
|
(description
|
|
"This package provides methods for caching or memoization of objects and
|
|
results. With this package, any R object can be cached in a key-value storage
|
|
where the key can be an arbitrary set of R objects. The cache memory is
|
|
persistent (on the file system).")
|
|
(license license:lgpl2.1+)))
|
|
|
|
(define-public r-r-rsp
|
|
(package
|
|
(name "r-r-rsp")
|
|
(version "0.20.0")
|
|
(source (origin
|
|
(method url-fetch)
|
|
(uri (cran-uri "R.rsp" version))
|
|
(sha256
|
|
(base32
|
|
"06vq9qq5hdz3hqc99q82622mab6ix7jwap20h4za6ap6gnwqs0fv"))))
|
|
(properties `((upstream-name . "R.rsp")))
|
|
(build-system r-build-system)
|
|
(propagated-inputs
|
|
`(("r-r-cache" ,r-r-cache)
|
|
("r-r-methodss3" ,r-r-methodss3)
|
|
("r-r-oo" ,r-r-oo)
|
|
("r-r-utils" ,r-r-utils)))
|
|
(home-page "https://github.com/HenrikBengtsson/R.rsp")
|
|
(synopsis "Dynamic generation of scientific reports")
|
|
(description
|
|
"The RSP markup language provides a powerful markup for controlling the
|
|
content and output of LaTeX, HTML, Markdown, AsciiDoc, Sweave and knitr
|
|
documents (and more), e.g. @code{Today's date is <%=Sys.Date()%>}. Contrary
|
|
to many other literate programming languages, with RSP it is straightforward
|
|
to loop over mixtures of code and text sections, e.g. in month-by-month
|
|
summaries. RSP has also several preprocessing directives for incorporating
|
|
static and dynamic contents of external files (local or online) among other
|
|
things. RSP is ideal for self-contained scientific reports and R package
|
|
vignettes.")
|
|
(license license:lgpl2.1+)))
|
|
|
|
(define-public r-matrixstats
|
|
(package
|
|
(name "r-matrixstats")
|
|
(version "0.15.0")
|
|
(source (origin
|
|
(method url-fetch)
|
|
(uri (cran-uri "matrixStats" version))
|
|
(sha256
|
|
(base32
|
|
"1068k85s6rlwfzlszw790c2rndydvrsw7rpck6k6z17896m8drfa"))))
|
|
(properties `((upstream-name . "matrixStats")))
|
|
(build-system r-build-system)
|
|
(native-inputs
|
|
`(("r-r-rsp" ,r-r-rsp))) ;used to build vignettes
|
|
(home-page "https://github.com/HenrikBengtsson/matrixStats")
|
|
(synopsis "Methods applying to vectors and matrix rows and columns")
|
|
(description
|
|
"This package provides methods operating on rows and columns of matrices,
|
|
e.g. @code{rowMedians()}, @code{rowRanks()}, and @code{rowSds()}. There are
|
|
also some vector-based methods, e.g. @code{binMeans()}, @code{madDiff()} and
|
|
@code{weightedMedians()}. All methods have been optimized for speed and
|
|
memory usage.")
|
|
(license license:artistic2.0)))
|
|
|
|
(define-public r-viridis
|
|
(package
|
|
(name "r-viridis")
|
|
(version "0.3.1")
|
|
(source (origin
|
|
(method url-fetch)
|
|
(uri (cran-uri "viridis" version))
|
|
(sha256
|
|
(base32
|
|
"0zz9i874s1fwhl9bcbiprlzaz7zsy1rj6c729zn3k525d63qbnj7"))))
|
|
(build-system r-build-system)
|
|
(propagated-inputs
|
|
`(("r-ggplot2" ,r-ggplot2)
|
|
("r-gridextra" ,r-gridextra)))
|
|
(home-page "https://github.com/sjmgarnier/viridis")
|
|
(synopsis "Matplotlib default color map")
|
|
(description
|
|
"This package is a port of the new @url{matplotlib,
|
|
http://matplotlib.org/} color maps (@code{viridis}--the default--,
|
|
@code{magma}, @code{plasma}, and @code{inferno}) to R. These color maps are
|
|
designed in such a way that they will analytically be perfectly
|
|
perceptually-uniform, both in regular form and also when converted to
|
|
black-and-white. They are also designed to be perceived by readers with the
|
|
most common form of color blindness.")
|
|
(license license:x11)))
|
|
|
|
(define-public r-plotly
|
|
(package
|
|
(name "r-plotly")
|
|
(version "2.0.3")
|
|
(source (origin
|
|
(method url-fetch)
|
|
(uri (cran-uri "plotly" version))
|
|
(sha256
|
|
(base32
|
|
"16pqycns8qf0y1j21n009qf242lv0izwyidlx40zv88izxhg1vs0"))))
|
|
(build-system r-build-system)
|
|
(propagated-inputs
|
|
`(("r-base64enc" ,r-base64enc)
|
|
("r-digest" ,r-digest)
|
|
("r-ggplot2" ,r-ggplot2)
|
|
("r-htmlwidgets" ,r-htmlwidgets)
|
|
("r-httr" ,r-httr)
|
|
("r-jsonlite" ,r-jsonlite)
|
|
("r-magrittr" ,r-magrittr)
|
|
("r-plyr" ,r-plyr)
|
|
("r-viridis" ,r-viridis)))
|
|
(home-page "https://plot.ly/r")
|
|
(synopsis "Create interactive web graphics")
|
|
(description
|
|
"This package enables the translation of ggplot2 graphs to an interactive
|
|
web-based version and/or the creation of custom web-based visualizations
|
|
directly from R. Once uploaded to a plotly account, plotly graphs (and the
|
|
data behind them) can be viewed and modified in a web browser.")
|
|
(license license:x11)))
|
|
|