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

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 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 provides a wide array of functions for dealing with color. This includes conversion between colorspaces, measuring distance between colors, simulating color blindness, parsing colors, and generating color scales for graphics.

This package provides a convenient function form of the conditional ifelse. It is similar to Core.ifelse but it is extendable.

This package provides these irrational constants:

• twoπ = 2π

• fourπ = 4π

• halfπ = π / 2

• quartπ = π / 4

• invπ = 1 / π

• twoinvπ = 2 / π

• fourinvπ = 4 / π

• inv2π = 1 / (2π)

• inv4π = 1 / (4π)

• sqrt2 = √2

• sqrt3 = √3

• sqrtπ = √π

• sqrt2π = √2π

• sqrt4π = √4π

• sqrthalfπ = √(π / 2)

• invsqrt2 = 1 / √2

• invsqrtπ = 1 / √π

• invsqrt2π = 1 / √2π

• loghalf = log(1 / 2)

• logtwo = log(2)

• logten = log(10)

• logπ = log(π)

• log2π = log(2π)

• log4π = log(4π)

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.

This package provides consistent and extensible functional programming infrastructures, and metaprogramming facilities.

This package aims to offer a standard set of Geometry types, which easily work with metadata, query frameworks on geometries and different memory layouts. The aim is to create a solid basis for Graphics/Plotting, finite elements analysis, Geo applications, and general geometry manipulations - while offering a Julian API, that still allows performant C-interop.

This package implements real and complex polylogarithms, including the real and complex dilogarithm and trilogarithm in Julia.

SoftGlobalScope is a package for the Julia language that simplifies the variable scoping rules for code in global scope. It is intended for interactive shells to make it easier to work interactively with Julia, especially for beginners.

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

ExprTools provides tooling for working with Julia expressions during metaprogramming. This package aims to provide light-weight performant tooling without requiring additional package dependencies.

TypedTables.jl provides two column-based storage containers: Table and FlexTable, both of which represent an array of NamedTuples. This package is designed to be lightweight, easy-to-use and fast, and presents a very minimal new interface to learn.

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

This package provides tools to express a design pattern for dealing with large/ nested structures, as in machine learning and optimisation. For large machine learning models it can be cumbersome or inefficient to work with parameters as one big, flat vector, and structs help in managing complexity; but it is also desirable to easily operate over all parameters at once, e.g. for changing precision or applying an optimiser update step.

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 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.

TableTraits defines a generic interface for tabular data.

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 provides a C-compatible enum for Julia.

This package allows you to query the availability of specific CPU features with low run-time cost.

FileIO aims to provide a common framework for detecting file formats and dispatching to appropriate readers/writers. The two core functions in this package are called load and save, and offer high-level support for formatted files (in contrast with Julia's low-level read and write).

This package provides a pooled representation of arrays for purposes of compression when there are few unique elements.