This package exports following operations over bit vectors with extremely fast speed while keeping extra memory usage small:

• getindex(bv::IndexableBitVectors, i::Integer): i-th element of bv

• rank(b::Bool, bv::AbstractIndexableBitVector, i::Integer): the number of occurrences of bit b in bv[1:i]

• select(b::Bool, bv::AbstractIndexableBitVector, i::Integer): the index of i-th occurrence of b in bv.

and other shortcuts or types.

BenchmarkTools.jl makes performance tracking of Julia code easy by supplying a framework for writing and running groups of benchmarks as well as comparing benchmark results.

An IndirectArray is one that encodes data using a combination of an index and a value table. Each element is assigned its own index, which is used to retrieve the value from the value table. Among other uses, IndirectArrays can represent indexed images, sometimes called "colormap images" or "paletted images."

Millboard.jl provides a library for getting data in a tablized format to arrange into rows and columns of cells.

MutableArithmetics is a Julia package which allows:

• mutable types to implement mutable arithmetics

• algorithms that could exploit mutable arithmetics to exploit them while still being completely generic

Extents.jl is a small package that defines an Extent object that can be used by the different Julia spatial data packages. Extent is a wrapper for a NamedTuple of tuples holding the lower and upper bounds for each dimension of a object.

This package supports representing banded matrices by only the entries on the bands.

FuzzyCompletions provides fuzzy completions for a Julia runtime session.

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 generic helper algorithms for building plotting components.

IteratorInterfaceExtensions defines a small number of extensions to the iterator interface.

PlotThemes is a package to spice up the plots made with Plots.jl.

This package provides a macro-based implementation of traits. The main idea behind traits is to group types outside the type-hierarchy and to make dispatch work with that grouping. The difference to Union-types is that types can be added to a trait after the creation of the trait, whereas Union types are fixed after creation.

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.

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.

The package provides a light-weight dependency for defining sensitivities for functions without the need to depend on ChainRules itself.

This package provides a type stable and efficient wrapper of arbitrary functions.

This package provides a canonical set of default initial values and identity elements for Julia.

This package provides a lightweight string parsing and representation of angles.

This Julia package provides several utilities for working with tree-like data structures. Most importantly, it defines the children method that any package that contains such a data structure may import and extend in order to take advantage of any generic tree algorithm in this package.

This package provides support for image resizing, image rotation, and other spatial transformations of arrays.

A Julia package to contain non-standard matrix factorizations. At the moment it implements the QL, RQ, and UL factorizations, a combined Cholesky factorization with inverse, and polar decompositions. In the future it may include other factorizations such as the LQ factorization.

This package allows multiple FFT packages to co-exist with the same underlying fft(x) and plan_fft(x) interface. It is mainly not intended to be used directly. Instead, developers of packages that implement FFTs (such as FFTW.jl or FastTransforms.jl) extend the types/functions defined in AbstractFFTs.

This package provides an interface for readable and writable references to an element of an array or dictionary in Julia.