This package provides macros for defining the required behaviours of Julia interfaces, and stating that an object implements them.

Optimisers.jl defines many standard gradient-based optimisation rules, and tools for applying them to deeply nested models.

This package provides a collection of tools for metaprogramming on Julia Expr, the meta programming standard library for MLStyle.

Run a julia REPL inside a terminal in Emacs. In contrast to ESS, use the Julia REPL facilities for interactive features, such readline, help, debugging.

This package supports lazy analogues of array operations like vcat, hcat, and multiplication. This helps with the implementation of matrix-free methods for iterative solvers.

This library provides tools for working with Julia code and expressions. This includes a template-matching system and code-walking tools that let you do deep transformations of code.

The is package provides a variety of common utilities that can be used by downstream automatic differentiation (AD) tools to define and execute forward-, reverse-, and mixed-mode primitives.

This package defines the Bijection data type. A Bijection data structure behaves similar to a Dict, however it prevents assigning the same value to two different keys.

This package provides a convenient Julia interface for loading standard named test images and example images for the internal usage in JuliaImages. This can be used in conjunction with the Images package.

This package lazily represents matrices filled with a single entry, as well as identity matrices. This package exports the following types: Eye, Fill, Ones, Zeros, Trues and Falses.

This package is for calculating derivatives, gradients, Jacobians, Hessians, etc. numerically. This library is for maximizing speed while giving a usable interface to end users in a way that specializes on array types and sparsity.

This minimalistic package serves as the foundation for working with colors in Julia. It defines basic color types and their constructors, and sets up traits and show methods to make them easier to work with.

ItemGraphs is a simple wrapper around LightGraphs that enables most common use case for graph-like data structures: with collection of items that are in relations between each other providing the shortest path between two items.

This package is intended as a lightweight foundation for tensor operations across the Julia ecosystem. Currently it exports three operations: hadamard, tensor, and boxdot.

This package contains types with default field values, keyword constructors and (un-)pack macros. Keyword functions can be slow in Julia, however, the normal positional constructor is also provided and could be used in performance critical code.

StackViews provides only one array type: StackView. There are multiple ways to understand StackView:

• inverse of eachslice

• cat variant

• view object

• lazy version of repeat special case

This package intends to provide a simple RNG with stable streams, suitable for tests in packages which need reproducible streams of random numbers across Julia versions. Indeed, the Julia RNGs provided by default are documented to have non-stable streams (which for example enables some performance improvements).

Allows to import functions and whole packages from Julia in R. Imported Julia functions can directly be called as R functions. Data structures can be translated between Julia and R. More details can also be found in the corresponding article <doi:10.18637/jss.v101.i06>.

This package provides a minor mode for interacting with a Julia REPL running inside Emacs. The julia process is started in an ANSI terminal (term), which allows text formatting and colors, and interaction with the help system and the debugger. It is recommended that you use this minor mode with the package emacs-julia-mode.

This package provides a set of tools for working with tabular data in Julia. Its design and functionality are similar to those of Pandas from Python or data.frame, data.table and dplyr from R, making it a great general purpose data science tool, especially for those coming to Julia from R or Python.

This package for the Julia language provides an array type (the AxisArray) that knows about its dimension names and axis values. This allows for indexing by name without incurring any runtime overhead. This permits one to implement algorithms that are oblivious to the storage order of the underlying arrays. AxisArrays can also be indexed by the values along their axes, allowing column names or interval selections.

This package provides a function extrapolate that extrapolates a given function f(x) to f(x0), evaluating f only at a geometric sequence of points > x0 (or optionally < x0). The key algorithm is Richardson extrapolation using a Neville–Aitken tableau, which adaptively increases the degree of an extrapolation polynomial until convergence is achieved to a desired tolerance (or convergence stalls due to e.g. floating-point errors). This allows one to obtain f(x0) to high-order accuracy, assuming that f(x0+h) has a Taylor series or some other power series in h.

Documentation at https://melpa.org/#/julia-snail

Documentation at https://melpa.org/#/julia-shell