Implementation of a [[literal-function]] constructor. Literal functions can be
applied to structures and numeric inputs, and differentiated.

The namespace also contains an implementation of a small language for
declaring the input and output types of [[literal-function]] instances.

Symbolic expressions in Emmy are created through the [[literal-number]]
constructor, or implicitly by performing arithmetic between symbols and
numbers.

This namespace implements the [[literal-number]] constructor and installs the
underlying type into the generic arithmetic system.

Namespace implementing various aggregation functions using the `fold`
abstraction and combinators for generating new folds from fold primitives.

Contains a number of algorithms for [compensated
summation](https://en.wikipedia.org/wiki/Kahan_summation_algorithm) of
floating-point numbers.

This namespace implements a number of differential operators like [[D]], and
the machinery to apply [[D]] to various structures.

This namespace implements a form field operator and a number of functions for
creating and working with form fields.

A form-field of rank n is an operator that takes n vector fields to a
real-valued function on the manifold. A one-form field takes a single vector
field.

The namespace also contains two definitions of the [[wedge]]
product ([[alt-wedge]] is the second), plus the [[exterior-derivative]].

This namespace implements minimal support for indexed objects and typed
functions.

This namespace defines a functional API for:

- differentiable manifolds (both manifold families like [[Rn]] and manifolds
  specialized to a concrete dimension)
- manifold points
- coordinate patches

As well as a whole bunch of defined manifolds and coordinate systems for
exploration and fun!

Various definitions and utilities for working with maps between manifolds.

This namespace contains vector calculus operators, in versions built on top
of [[derivative/D]] _and_ in Functional Differential Geometry style.

The former transform functions of scalars or vectors, while the latter take a
metric and basis.

This namespace implements a vector field operator and a number of functions for
creating and working with vector fields.

A vector field is an operator that takes a smooth real-valued function of a
manifold and produces a new function on the manifold which computes the
directional derivative of the given function at each point of the manifold.

This namespace contains implementations of various Emmy protocols for
native Clojure collections.

This namespace provides a number of functions and constructors for working
with [[Complex]] numbers in Clojure and ClojureScript, and
installs [[Complex]] into the Emmy generic arithmetic system.

For other numeric extensions, see [[emmy.ratio]]
and [[emmy.numbers]].

This namespace contains an implementation of [[Differential]], a generalized
dual number type that forms the basis for the forward-mode automatic
differentiation implementation in emmy.

See [[emmy.calculus.derivative]] for a fleshed-out derivative
implementation using [[Differential]].

(require '[emmy.env :as e])
(e/bootstrap-repl!)

(require '[emmy.env :as e :refer :all])

Batteries-included namespace for the [Emmy](https://github.com/mentat-collective/emmy/) library.

The purpose of [[emmy.env]] is to bundle all of the functions used
in [Structure and Interpretation of Classical
Mechanics](https://tgvaughan.github.io/sicm/) and [Functional Differential
Geometry](https://mitpress.mit.edu/books/functional-differential-geometry)
into a single scope. The following form will import everything
from [[emmy.env]] into your REPL:

```clojure
(require '[emmy.env :as e])
(e/bootstrap-repl!)
```

Or, in Clojure:

```clojure
(require '[emmy.env :as e :refer :all])
```

Implementations of various [greatest common
divisor](https://en.wikipedia.org/wiki/Greatest_common_divisor) algorithms.

This namespace contains a number of functions and utilities for manipulating
and comparing raw symbolic expression trees.

Also included is an implementation of a [[Literal]] type that forms the basis
for [[emmy.abstract.number/literal-number]].

This namespace defines an API for working with 'expression analyzers' and
the [[ICanonicalize]] protocol.

Expression analyzers find canonical forms of inputs over limited vocabularies
of operations. For example, a polynomial analyzer will expose operations like
addition, subtraction, multiplication, and exponentiation by positive
integers (but not division).

An expression containing only these operations and symbols can then be
converted to and from a polynomial canonical form, which in this example would
have the effect of grouping like terms; a rational function backend would
include the division operation and be capable of cancellation. Canonicalizing
an expression with respect to an analyzer is therefore effected by a
round-trip to and from the canonical form.

This namespace contains tools for compiling functions implemented with the
numeric operations defined in [[emmy.generic]] down to fast, native
functions.

This namespace implements subexpression extraction and "elimination", the
process we use to avoid redundant computation inside of a simplified function
body.

Functions and utilities for rendering symbolic expressions to various backends
like LaTeX, infix or Javascript.

Procedures that act on Clojure's function and multimethod types, along with
extensions of the Emmy generic operations to functions.

See [the `Function`
cljdocs](https://cljdoc.org/d/org.mentat/emmy/CURRENT/doc/data-types/function)
for a discussion of generic function arithmetic.

The home of most of the Emmy extensible generic operations. The bulk of
the others live in [[emmy.value]].

See [the `Generics`
cljdocs](https://cljdoc.org/d/org.mentat/emmy/CURRENT/doc/basics/generics)
for a detailed discussion of how to use and extend the generic operations
defined in [[emmy.generic]] and [[emmy.value]].

This namespace contains an implementation of a [[Matrix]] datatype and various
operations for creating and working with [[Matrix]] instances.

[[emmy.matrix]] also extends many Emmy generic operations
to the [[Matrix]] datatype.

This namespace contains an implementation of a [[ModInt]] datatype and various
operations for creating and working with [[ModInt]] instances. See ["Modular
Arithmetic"](https://en.wikipedia.org/wiki/Modular_arithmetic) on Wikipedia
for more details about modular arithmetic.

[[emmy.modint]] also extends many Emmy generic operations
to the [[ModInt]] datatype.

This namespace extends of all appropriate Emmy generic operations
from [[emmy.generic]] and [[emmy.value]] to the Clojure(script)
numeric tower.

For other numeric extensions, see [[emmy.ratio]]
and [[emmy.complex]].

This namespace contains implementations of various approaches to [numerical
differentiation](https://en.wikipedia.org/wiki/Numerical_differentiation).

Each of these methods uses [Richardson
extrapolation](https://en.wikipedia.org/wiki/Richardson_extrapolation) to
accelerate convergence, and roundoff error estimation to bail out of the
computation when roundoff error threatens to overwhelm the calculation.

For an implementation of [forward-mode automatic
differentiation](https://en.wikipedia.org/wiki/Automatic_differentiation),
see [[emmy.differential]] (for the backing implementation)
and [[emmy.calculus.derivative]] (for the [[emmy.operator/Operator]]
instances that make it pleasant to use this method.)

Entrypoint for univariate and multivariate minimization routines.

ODE solvers for working with initial value problems.

Implements utilities shared by all integrators, for example:

- code to wrap a sequence of progressively better estimates in a common `integrator` interface
- data structures implementing various integration intervals.

### U Substitution and Variable Changes

This namespace provides implementations of functions that accept an
`integrator` and perform a variable change to address some singularity, like
an infinite endpoint, in the definite integral.

The strategies currently implemented were each described by Press, et al. in
section 4.4 of ['Numerical
Recipes'](http://phys.uri.edu/nigh/NumRec/bookfpdf/f4-4.pdf).

Trapezoid method.

This namespace contains implementations of a number of methods for root-finding
on real-valued functions of one argument.

NOTE: This namespace is not yet stable: Expect these functions to change as
new root-finding methods are added. 

This namespace contains an implementation of Brent's method for finding the
minimum of a real-valued function.

Implementations of the generic operations for numeric types that have
optimizations available, and for the general symbolic case.

Code for defining and compiling 'consequence' functions, i.e., functions from a
binding map generated by a [[[emmy.pattern.match]]] to some successful
transformation (or a failure!).

See [[emmy.pattern.rule]] for a detailed treatment.

Implementation of a emmy.pattern.matching system inspired by [Gerald Jay Sussman's
lecture notes for MIT
6.945](http://groups.csail.mit.edu/mac/users/gjs/6.945/).
See [[emmy.pattern.rule]] for a higher-level API.

[[emmy.pattern.match]] and [[emmy.pattern.rule]] are spiritually similar to Alexey
Radul's [Rules](https://github.com/axch/rules) library for Scheme, and the
emmy.pattern.matching system described in GJS and Hanson's [Software Design for
Flexibility](https://mitpress.mit.edu/books/software-design-flexibility).

This namespace provides an API for building rules out of the matchers and
matcher combinators declared in [[emmy.pattern.match]], along with a series of
combinators for building advanced term-rewriting systems.

The syntax namespace defines the default syntax for patterns corresponding to
the matcher combinators defined in [[emmy.pattern.match]].

This namespace contains functions for factoring polynomials and symbolic
expressions.

This namespace contains a discussion of polynomial interpolation, and different
methods for fitting a polynomial of degree `N-1` to `N` points and evaluating
that polynomial at some different `x`.

Richardson interpolation is a special case of polynomial interpolation; knowing
the ratios of successive `x` coordinates in the point sequence allows a more
efficient calculation.

This namespace provides a number of functions and constructors for working
with [[Quaternion]] instances in Clojure and ClojureScript, and
installs [[Quaternion]] into the Emmy generic arithmetic system.

For other numeric extensions, see [[emmy.ratio]], [[emmy.complex]]
and [[emmy.numbers]].

This namespace provides a number of functions and constructors for working
with ratios in Clojure and ClojureScript.

[[clojure.lang.Ratio]] is native in Clojure. The ClojureScript implementation
uses [Fraction.js](https://github.com/infusion/Fraction.js/).

For other numeric extensions, see [[emmy.numbers]]
and [[emmy.complex]].

This namespace contains a discussion of rational function interpolation, and
different methods for fitting rational functions to `N` points and evaluating
them at some value `x`.

This namespace contains reimplementations of various macros from emmy,
defined in the form required by SCI.

$$[a b c d ...] == $a + bx + cx^2 + dx^3 + ...$$

This namespace contains an implementation of two data types:

- [[Series]], which represents a generic infinite series of arbitrary values, and
- [[PowerSeries]], a series that represents a power series in a single
variable; in other words, a series where the nth entry is interpreted as
the coefficient of $x^n$:

```
$$[a b c d ...] == $a + bx + cx^2 + dx^3 + ...$$
```

Many of the functions below draw on the [[emmy.series.impl]] namespace,
which implements many of these operations on bare Clojure sequences.

The implementation follows Doug McIlroy's beautiful paper, ["Power Series,
Power
Serious"](http://citeseerx.ist.psu.edu/viewdoc/download?doi=10.1.1.333.3156&rep=rep1&type=pdf).

Doug also has a 10-line version in Haskell on [his
website](https://www.cs.dartmouth.edu/~doug/powser.html).

This namespace contains many sets of algebraic simplification rules you can use
to build simplifiers for algebraic structures.

[[rules]] currently holds a mix of:

- rulesets ported from the scmutils library
- more fine-grained, tuneable rulesets like [[associative]]
  and [[constant-elimination]] designed to help you build lightweight custom
  term-rewriting simplifiers.

NOTE: Expect this namespace to be broken out into more fine-grained
namespaces. There are TODO entries throughout the docstrings left as tips for
how to proceed here.

This namespace contains function to compute various [elliptic
integrals](https://en.wikipedia.org/wiki/Elliptic_integral) in [Carlson
symmetric form](https://en.wikipedia.org/wiki/Carlson_symmetric_form), as well
as the [Jacobi elliptic
functions](https://en.wikipedia.org/wiki/Jacobi_elliptic_functions).

Namespace holding implementations of variations on the factorial function.

Shared utilities between clojure and clojurescript.

Namespace with algorithms for aggregating sequences in various ways.

Logic utilities!

Utilities for generating permutations of sequences.

This namespace contains various standard sequences, as well as utilities for
working with strict and lazy sequences.

Contains an implementation and API for an 'ordered set' data structure backed
by a persistent vector.

The home of most of the protocol-based extensible generic operations offered by
Emmy. The bulk of the others live in [[emmy.generic]].

See [the `Generics`
cljdocs](https://cljdoc.org/d/org.mentat/emmy/CURRENT/doc/basics/generics)
for a detailed discussion of how to use and extend the generic operations
defined in [[emmy.generic]] and [[emmy.value]].