emmy.env — org.mentat/emmy 0.31.0

Batteries-included namespace for the Emmy library.

The purpose of emmy.env is to bundle all of the functions used in Structure and Interpretation of Classical Mechanics and Functional Differential Geometry into a single scope. The following form will import everything from emmy.env into your REPL:

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

Or, in Clojure:

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

* clj/s≠

clj

(*)

(* x)

(* x y)

(* x y & more)

Generic implementation of *. Returns the product of all supplied arguments. (*) returns 1, the multiplicative identity.

When applied between numbers, acts like clojure.core/*. Dispatch is open, however, making it possible to 'multiply' types wherever the behavior is mathematically sound.

For example:

(* 2 #emmy/complex "3 + 1i")
;;=> #emmy/complex "6 + 2i"

cljs

+ clj/s≠

clj

(+)

(+ x)

(+ x y)

(+ x y & more)

Generic implementation of +. Returns the sum of all supplied arguments. (+) returns 0, the additive identity.

When applied between numbers, acts like clojure.core/+. Dispatch is open, however, making it possible to 'add' types wherever the behavior is mathematically sound.

For example:

(+ [1 2 3] [2 3 4])
;;=> (up 3 5 7)

cljs

- clj/s≠

clj

(-)

(- x)

(- x y)

(- x y & more)

Generic implementation of -.

If one argument is supplied, returns the negation of a. Else returns the difference of the first argument a and the sum of all remaining arguments. (-) returns 0.

When applied between numbers, acts like clojure.core/-. Dispatch is open, however, making it possible to 'subtract' types wherever the behavior is mathematically sound.

For example:

(- [1 2 3] [2 3 4])
;;=> (up -1 -1 -1)

(- [1 10])
;;=> (up -1 -10)

cljs

->H-state clj/s≠

clj

(->H-state t q p)

Given a time t, coordinate tuple (or scalar) q and momentum tuple (or scalar) p, returns a 'Hamiltonian state tuple', i.e., the state expected by a Hamiltonian.

cljs

->infix clj/s≠

clj

Converts an S-expression to printable infix form. Numeric exponents are written as superscripts. Partial derivatives get subscripts.

->JavaScript clj/s≠

clj

Converts an S-expression to JavaScript.

->L-state clj/s≠

clj

(->L-state t q qdot & derivs)

Given a time t, coordinate tuple (or scalar) q, velocity tuple (or scalar) qdot and any number of additional higher-order derivative tuples (or scalars), returns a 'Local tuple', i.e., the state expected by a Lagrangian.

cljs

->local clj/s≠

clj

Alias for ->L-state.

->state clj/s≠

clj

Alias for ->L-state.

->TeX clj/s≠

clj

(->TeX expr & {:keys [equation]})

Convert the given expression to TeX format, as a string.

If you set the :equation keyword argument to a truthy value, the result will be wrapped in an equation environment. :equation <string> will insert a \label{<string>} entry inside the equation environment.

For example:

(let [expr (+ 'x 'xy)]
  (println
    (->TeX expr :equation "label!")))

\begin{equation}
\label{label!}
x + y
\end{equation}

cljs

->tex-equation clj/s

(->tex-equation expr & {:keys [label]})

Returns a string containing a LaTeX representation of expr, wrapped in an equation environment.

Optionally supply a :label keyword argument to set a custom label.

-pi clj/s

The negation of the mathematical constant Pi.

/ clj/s≠

clj

(/)

(/ x)

(/ x y)

(/ x y & more)

Generic implementation of /.

If one argument is supplied, returns the multiplicative inverse of a. Else returns the result of dividing first argument a by the product of all remaining arguments. (/) returns 1, the multiplicative identity.

When applied between numbers, acts like clojure.core//. Dispatch is open, however, making it possible to 'divide' types wherever the behavior is mathematically sound.

For example:

(/ [2 4 6] 2)
;;=> (up 1 2 3)

cljs

= clj/s multimethod

abs clj/s≠ multimethod

clj

(abs a)

generic abs

cljs

acceleration clj/s≠

clj

(acceleration local)

Returns the acceleration element of a local tuple (by convention, the fourth element).

See coordinate for more detail.

cljs

acceleration-tuple clj/s

acos clj/s≠ multimethod

clj

(acos a)

generic acos.

Computes the inverse cosine of the supplied argument a.

Defaults to atan(sqrt(1-x^2)/x).

cljs

acosh clj/s≠ multimethod

clj

(acosh a)

generic acosh.

Computes the inverse hyperbolic cosine of the supplied argument a.

defaults to 2 ln(sqrt((x+1)/2) + sqrt((x-1)/2)).

cljs

acot clj/s≠ multimethod

clj

(acot a)

generic acot.

Computes the inverse cotangent of the supplied argument a.

defaults to pi/2 - atan(x).

cljs

acoth clj/s≠ multimethod

clj

(acoth a)

generic acoth.

Computes the inverse hyperbolic cotangent of the supplied argument a.

defaults to 1/2 ln((x+1)/(x-1)).

cljs

acsc clj/s≠ multimethod

clj

(acsc a)

generic acsc.

Computes the inverse cosecant of the supplied argument a.

defaults to atan(1 / sqrt(x^2 - 1)).

cljs

acsch clj/s≠ multimethod

clj

(acsch a)

generic acsch.

Computes the inverse hyperbolic cosecant of the supplied argument a.

defaults to ln((1 + sqrt(1+x^2)) / x).

cljs

add-v:cs clj/s≠

clj

(add-v:cs v1:c v2:c)

cljs

add-velocities clj/s≠

clj

(add-velocities v1 v2)

velocities must be in meters/second, since we don't yet have units support.

cljs

Alt clj/s≠

clj

(Alt form)

Returns the alternation of the supplied differential form.

cljs

alt-wedge clj/s≠

clj

(alt-wedge & args)

Alternative definition of wedge in terms of alternation.

cljs

alternate-angles clj/s

ancestor-frame clj/s≠

clj

(ancestor-frame _)

Returns the ancestor [[IFrame]] instance of this frame, or nil if there is no ancestor.

cljs

angle clj/s≠ multimethod

clj

(angle a)

generic angle

cljs

angle-axis->rotation-matrix clj/s≠

clj

(angle-axis->rotation-matrix theta [x y z])

cljs

anticommutator clj/s≠

clj

(anticommutator o p)

cljs

arg-scale clj/s≠

clj

(arg-scale f & factors)

Takes a function f and a sequence of factors, and returns a new function that multiplies each factor by the corresponding argument of f. Too many or two few factors are ignored.

((arg-scale square 3) 4) ==> 144
((arg-scale square 3 2 1) 4) ==> 144

cljs

arg-shift clj/s≠

clj

(arg-shift f & shifts)

Takes a function f and a sequence of shifts, and returns a new function that adds each shift to the corresponding argument of f. Too many or two few shifts are ignored.

((arg-shift square 3) 4) ==> 49
((arg-shift square 3 2 1) 4) ==> 49

cljs

argument-types clj/s≠

clj

(argument-types f)

Given an operator or function f, returns its registered vector of argument types, or [] if none exist.

argument types are, for example,

[::ff/oneform-field ::vf/vector-field ::vf/vector-field]

for a Christoffel-2, which takes one oneform field and two vector fields.

cljs

arity clj/s≠

clj

(arity f)

Return the cached or obvious arity of f if we know it. Otherwise delegates to heavy duty reflection.

cljs

asec clj/s≠ multimethod

clj

(asec a)

generic asec.

Computes the inverse secant of the supplied argument a.

defaults to atan(sqrt(x^2 - 1)).

cljs

asech clj/s≠ multimethod

clj

(asech a)

generic asech.

Computes the inverse hyperbolic secant of the supplied argument a.

defaults to ln((1 + sqrt(1-x^2)) / x).

cljs

asin clj/s≠ multimethod

clj

(asin a)

generic asin.

Computes the inverse sine of the supplied argument a.

Defaults to atan(x/sqrt(1-x^2)).

cljs

asinh clj/s≠ multimethod

clj

(asinh a)

generic asinh.

Computes the inverse hyperbolic sine of the supplied argument a.

defaults to ln(x + sqrt(1 + x^2)).

cljs

atan clj/s≠ multimethod

clj

(atan a)

(atan a b)

generic atan.

Computes the inverse tangent of the supplied argument a. Given two arguments a and b, returns the inverse tangent of the angle formed by the point (b, a) in a 2-dimensional euclidean plane.

The two-argument version is sometimes called Atan2.

cljs

atanh clj/s≠ multimethod

clj

(atanh a)

generic atanh.

Computes the inverse hyperbolic tangent of the supplied argument a.

defaults to 1/2 ln((1+x)/(1-x)).

cljs

base-frame-maker clj/s

basis->basis-over-map clj/s≠

clj

(basis->basis-over-map mu:N->M basis-on-M)

cljs

basis->coordinate-system clj/s≠

clj

(basis->coordinate-system b)

cljs

basis->dimension clj/s≠

clj

(basis->dimension b)

Extract the dimension from the given basis object b.

cljs

basis->oneform-basis clj/s≠

clj

(basis->oneform-basis b)

Extract the dual basis from the given basis object b.

cljs

basis->vector-basis clj/s≠

clj

(basis->vector-basis b)

Extract the vector basis from the given basis object b.

cljs

basis-components->oneform-field clj/s≠

clj

(basis-components->oneform-field components oneform-basis)

Given a structure of components functions defined on manifold points and and a matching oneform-basis (of identical structure),

Returns a new one-form field that

• passes its vector-field argument to oneform-basis, returning a new equivalent structure with each slot populated by functions from a manifold point to the directional derivative (using the vector field) in that coordinate direction

• contracts the result of that operation with the result of applying each component in components to the manifold point.

NOTE:

• This is for any basis, not just a coordinate basis
• The components are evaluated at a manifold point, not its coordinates
• Given a dual basis, you can retrieve the original components with oneform-field->basis-components

cljs

basis-components->vector-field clj/s≠

clj

(basis-components->vector-field components vector-basis)

Given a structure of components and and a matching vector-basis (of identical structure with orientations flipped), returns a new vector field generated contracting by these two structures together.

The returned vector field passes its input function to the operator generated by this contraction.

For example:

(let-coordinates [[x y] R2-rect]
  (basis-components->vector-field
   (up x y)
   (coordinate-system->vector-basis R2-rect)))
;; => (+ (* x d:dx) (* y d:dy))

NOTE:

• This is for any basis, not just a coordinate basis
• The components are evaluated at a manifold point, not its coordinates
• Given a dual basis, you can retrieve the original components with vector-field->basis-components

cljs

basis? clj/s≠

clj

(basis? x)

Returns true if x is a basis, false otherwise.

cljs

bigint cljs

bigint? clj/s≠

clj

(bigint? x)

Returns true if the supplied x is a BigInt, false otherwise.

cljs

binomial-series clj/s≠

clj

(binomial-series alpha)

Returns a [[PowerSeries]] instance representing a Binomial series, i.e., the taylor series of the function $f$ given by

$$f(x) = (1 + x)^\alpha$$

cljs

boost-direction clj/s≠

clj

(boost-direction frame)

cljs

bootstrap-repl! clj/s macro

(bootstrap-repl!)

Bootstraps a repl or Clojure namespace by requiring all public vars from emmy.env.

(This will only work at a repl in ClojureScript.)

TODO add :rename, :exclude support.

brent-max clj/s≠

clj

(brent-max f a b opts)

For convenience, we also provide the sister-procedure for finding the maximum of a unimodal function using Brent's method.

Negate the function, minimize, negate the result.

cljs

brent-min clj/s≠

clj

(brent-min f a b)

(brent-min f
           a
           b
           {:keys [relative-threshold absolute-threshold maxiter maxfun
                   callback]
            :or {relative-threshold (g/sqrt v/machine-epsilon)
                 absolute-threshold 1.0E-11
                 maxiter 1000
                 callback (constantly nil)}})

Find the minimum of the function f: R -> R in the interval [a,b] using Brent's Method, described by Richard Brent in Algorithms for Minimization without Derivatives.

Brent's method is a combination of a golden section search with a parabolic interpolation step. Parabolic interpolation can go wild if the candidate point is close to colinear with the search bounds, or of the points are too close together.

Brent's method prevents this by applying an internal test that forces a golden section step every so often. (If you want the details, see parabola-valid? above.)

Supports the following optional keyword arguments:

:callback if supplied, the supplied fn will be invoked at each intermediate point with the iteration count and the values of x and f(x) at each search step.

:relative-threshold defaults to around 1.49e8, the sqrt of the machine tolerance. You won't gain any benefit attempting to set the value less than the default.

:absolute-threshold a smaller absolute threshold that applies when the candidate minimum point is close to 0.

:maxiter Maximum number of iterations allowed for the minimizer. Defaults to 1000.

:maxfun Maximum number of times the function can be evaluated before exiting. Defaults to (inc maxiter).

cljs

Cartan->basis clj/s≠

clj

(Cartan->basis C)

cljs

Cartan->Cartan-over-map clj/s≠

clj

(Cartan->Cartan-over-map Cartan map)

cljs

Cartan->Christoffel clj/s≠

clj

(Cartan->Christoffel Cartan)

cljs

Cartan->forms clj/s≠

clj

(Cartan->forms C)

cljs

Cartan-transform clj/s≠

clj

(Cartan-transform cartan basis-prime)

cljs

Cartan? clj/s≠

clj

(Cartan? x)

cljs

ceiling clj/s≠ multimethod

clj

(ceiling a)

generic ceiling.

Returns the result of rounding a up to the next largest integer.

Extensions beyond real numbers may behave differently; see the Documentation site for more detail.

cljs

chart clj/s≠

clj

(chart coordinate-system)

Given an [[ICoordinateSystem]], returns a function from a point on the coordinate system's manifold to the coordinate representation specified by the supplied coordinate-system.

cljs

chinese-remainder clj/s≠

clj

(chinese-remainder & modints)

Chinese Remainder Algorithm.

Accepts a sequence of [[ModInt]] instances (where the modulus of all [[ModInt]] instances are relatively prime), and returns a [[ModInt]] x such that (residue input) == (mod x (modulus input)).

For example:

(let [a1 (m/make 2 5)
      a2 (m/make 3 13)]
  [(= 42 (chinese-remainder a1 a2))
   (= (residue a1) (mod cr (modulus a1)))
   (= (residue a2) (mod cr (modulus a2)))])
;;=> [true true true]

cljs

Christoffel->basis clj/s≠

clj

(Christoffel->basis C)

cljs

Christoffel->Cartan clj/s≠

clj

(Christoffel->Cartan Christoffel)

cljs

Christoffel->symbols clj/s≠

clj

(Christoffel->symbols C)

cljs

Christoffel? clj/s≠

clj

(Christoffel? x)

cljs

claim clj/s≠

clj

(claim coords owner)

Marks (via metadata) the supplied set of coords as being owned by owner. If coords already has an owner (that is not equal to owner), throws.

cljs

column-matrix clj/s≠

clj

(column-matrix & xs)

Returns a column matrix populated by the supplied xs. Variadic equivalent to [[column*]].

cljs

column-matrix->up clj/s≠

clj

(column-matrix->up m)

Returns the single column from the supplied column matrix as an up. Errors if some other type is supplied.

cljs

column-matrix->vector clj/s≠

clj

(column-matrix->vector m)

Returns the single column from the supplied column matrix as a vector. Errors if some other type is supplied.

cljs

commutator clj/s≠

clj

(commutator o p)

cljs

compare clj/s≠

clj

(compare x y)

Comparator. Returns a negative number, zero, or a positive number when x is logically 'less than', 'equal to', or 'greater than' y. Same as Java x.compareTo(y) except it also works for nil, and compares numbers and collections in a type-independent manner. x must implement Comparable

cljs

compatible-shape clj/s≠

clj

(compatible-shape s)

Returns a structure compatible for multiplication with s down to a scalar, with the slots filled with gensyms.

cljs

compatible-zero clj/s≠

clj

(compatible-zero s)

Returns a structure compatible for multiplication with s down to 0.

cljs

complex clj/s≠

clj

(complex re)

(complex re im)

Returns a [[Complex]] number with the supplied real part re and imaginary part im. im defaults to 0.

cljs

complex? clj/s≠

clj

(complex? a)

Returns true if a is an instance of [[Complex]], false otherwise.

cljs

component clj/s

(component & selectors)

Given a sequence of selectors, return a function that accepts some object x and returns:

(apply ref x selectors)

components->metric clj/s≠

clj

(components->metric components basis)

cljs

components->oneform-field clj/s≠

clj

(components->oneform-field components coordinate-system)

(components->oneform-field components coordinate-system name)

Takes:

• a down tuple of components of the one-form field relative to coordinate-system
• the coordinate-system

And returns a full one-form field.

A one-field field is an operator that takes a vector field to a real-valued function on the manifold.

cljs

components->vector-field clj/s≠

clj

(components->vector-field components coordinate-system)

(components->vector-field components coordinate-system name)

Takes:

• an up tuple of the functions that each return the corresponding component of the vector field relative coordinate-system
• the coordinate-system
• optionally, a symbolic name for the vector field operator

And returns a vector field.

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

cljs

compose clj/s≠

clj

(compose & fns)

Arity-preserving version of clojure.core/comp.

The arity of a composition is the arity of the rightmost (that is, first to be applied) function term in fns.

cljs

compositional-canonical? clj/s≠

clj

(compositional-canonical? C H)

p.324

cljs

conjugate clj/s≠ multimethod

clj

(conjugate a)

generic conjugate

cljs

constant-manifold-function clj/s≠

clj

(constant-manifold-function c)

Takes some constant c and returns a manifold function that maps every input manifold point to c.

cljs

constant-series clj/s≠

clj

(constant-series c)

(constant-series c kind)

Returns a [[PowerSeries]] representing the supplied constant term.

Optionally, pass kind of either ::series or ::power-series to specify the type of series returned.

cljs

contract clj/s≠

clj

(contract f basis)

cljs

coordinate clj/s≠

clj

(coordinate local)

A convenience function on local tuples. A local tuple describes the state of a system at a particular time:

[t, q, D q, D^2 q]

representing time, position, velocity (and optionally acceleration etc.)

coordinate returns the q element, which is expected to be a mapping from time to a structure of coordinates.

cljs

coordinate-basis-oneform-field clj/s≠

clj

(coordinate-basis-oneform-field coordinate-system name & indices)

Given some coordinate-system, a symbolic name and a sequence of indices into the structure of the coordinate system's representation, returns a one-form field.

The returned one-form field at each structural spot takes a vector field and returns a function that takes the directional derivative in that coordinate's direction using the vector field.

cljs

coordinate-basis-vector-field clj/s≠

clj

(coordinate-basis-vector-field coordinate-system name & indices)

Given some coordinate-system, a symbolic name and a sequence of indices into the structure of the coordinate system's representation,

returns a vector field that takes a function and returns a new function that computes the partial derivative of that function with respect to the supplied indices into coordinate-system.

To compute the full Jacobian, pass no indices.

cljs

coordinate-basis? clj/s≠

clj

(coordinate-basis? x)

Returns true if x is a coordinate basis, false otherwise.

cljs

coordinate-origin clj/s≠

clj

(coordinate-origin frame)

cljs

coordinate-system->basis clj/s≠

clj

(coordinate-system->basis coordinate-system)

Returns the standard basis object for coordinate-system.

cljs

coordinate-system->inverse-metric clj/s≠

clj

(coordinate-system->inverse-metric coordinate-system)

cljs

coordinate-system->metric clj/s≠

clj

(coordinate-system->metric coordinate-system)

cljs

coordinate-system->metric-components clj/s≠

clj

(coordinate-system->metric-components coordsys)

cljs

coordinate-system->oneform-basis clj/s≠

clj

(coordinate-system->oneform-basis coordinate-system)

Given some coordinate-system, returns a structure of coordinate-basis-oneform-field instances.

The one-form field at each structural spot takes a vector field and returns a function that takes the directional derivative in that coordinate's direction using the vector field.

When applied as a function, the structure behaves equivalently to

(coordinate-basis-oneform-field <coordinate-system> 'ignored-name)

With no indices supplied.

cljs

coordinate-system->vector-basis clj/s≠

clj

(coordinate-system->vector-basis coordinate-system)

Given some coordinate-system, returns a structure of coordinate-basis-vector-field instances. The vector field at each structural spot takes a function and computes its directional derivative with respect to that coordinate.

When applied as a function, the structure behaves equivalently to

(coordinate-basis-vector-field <coordinate-system> 'ignored-name)

With no indices supplied.

cljs

coordinate-system-at clj/s≠

clj

(coordinate-system-at manifold coordinate-system-name patch-name)

Returns an [[ICoordinateSystem]] instance specialized to the patch named patch-name on manifold.

cljs

coordinate-system-names clj/s≠

clj

(coordinate-system-names patch)

Returns a set of names of all coordinate system constructors registered in the supplied patch.

cljs

coordinate-system? clj/s≠

clj

(coordinate-system? x)

Returns true if x implements [[ICoordinateSystem]], false otherwise.

cljs

coordinate-tuple clj/s

coordinatize clj/s≠

clj

(coordinatize vf coordinate-system)

Returns an operator that acts as a coordinate version of the supplied vector field vf with respect to coordinate-system.

The returned operator takes a function and returns a new function that takes directional derivatives of coordinate representations of manifold points, with respect to coordinate-system.

cljs

coords->event clj/s≠

clj

(coords->event this coords)

Accepts a coordinate representation coords of some event and returns a coordinate-free representation of the event.

coords must be owned this this reference frame; coords->event will throw if not.

cljs

corresponding-velocities clj/s≠

clj

(corresponding-velocities coords)

Takes a coordinate representation coords of a manifold point with all symbolic entries, and returns a structure of the same shape with v: prepended to all symbols.

This structure is appropriate for representing the velocities associated with each coordinate.

cljs

cos clj/s≠ multimethod

clj

(cos a)

generic cos.

Returns the cosine of the supplied argument a.

cljs

cosh clj/s≠ multimethod

clj

(cosh a)

generic cosh.

Computes the hyperbolic cosine of the supplied argument a.

defaults to (e^x + e^{-x}) / 2.

cljs

cot clj/s≠ multimethod

clj

(cot a)

generic cot.

Computes the trigonometric cotangent function of the supplied argument a.

Equivalent to (invert (tan a)), or (/ (cos a) (sin a)).

cljs

coth clj/s≠ multimethod

clj

(coth a)

generic coth.

Computes the hyperbolic cotangent of the supplied argument a.

defaults to cosh(x) / sinh(x).

cljs

covariant-derivative clj/s≠

clj

(covariant-derivative Cartan)

(covariant-derivative Cartan map)

cljs

covariant-differential clj/s≠

clj

(covariant-differential Cartan)

cljs

cross-product clj/s≠ multimethod

clj

(cross-product a b)

generic cross-product

cljs

csc clj/s≠ multimethod

clj

(csc a)

generic csc.

Computes the cosecant of the supplied argument a.

Equivalent to (invert (sin a)).

cljs

csch clj/s≠ multimethod

clj

(csch a)

generic csch.

Computes the hyperbolic cosecant of the supplied argument a.

defaults to 1 / sinh(x).

cljs

cube clj/s≠ multimethod

clj

(cube a)

generic cube

cljs

curl clj/s≠

clj

(curl metric orthonormal-basis)

curl implements equation (10.7) of Functional Differential Geometry, defined on page 155.

cljs

Curl clj/s≠

clj

Operator that takes a function f and returns a function that calculates the Curl of f at its input point.

f must be a function from $\mathbb{R}^3 \to \mathbb{R}^3$.

curvature-components clj/s≠

clj

(curvature-components nabla coord-sys)

cljs

d clj/s

D clj/s≠

clj

Derivative operator. Takes some function f and returns a function whose value at some point can multiply an increment in the arguments, to produce the best linear estimate of the increment in the function value.

For univariate functions, D computes a derivative. For vector-valued functions, D computes the Jacobian of f.

The related Grad returns a function that produces a structure of the opposite orientation as D. Both of these functions use forward-mode automatic differentiation.

D-as-matrix clj/s≠

clj

(D-as-matrix F)

cljs

D-numeric clj/s≠

clj

(D-numeric f)

(D-numeric f opts)

Takes a function f: R => R (function of a single real variable), and returns a new function of x that approximates the derivative $Df(x)$ (or $D^2f(x)$ if you pass :method :central-d2).

Returns the estimated value of the derivative at x. If you pass :info? true, the fn returns a dictionary of the results of us/seq-limit:

{:converged? <boolean>
 :terms-checked <int>
 :result <derivative estimate>}

Make sure to visit emmy.calculus.derivative/D if you want symbolic or automatic differentiation.

Roundoff Estimate

The returned function will attempt to estimate how many times it can halve the step size used to estimate the derivative before roundoff error swamps the calculation, and force the function to return (with :converged? false, if you pass :info?)

Optional Arguments

D-numeric takes optional args as its second param. Any of these can be overridden by passing a second argument to the function returned by D-numeric; helpful for setting defaults and then overriding them later.

The returned function passes through these and any other options to us/seq-limit, where they control the sequence of richardson extrapolation-accelerated estimates.

Options:

• :method: one of :central, :central-d2, :forward or :backward. :central-d2 forces a second derivative estimate; the other methods configure a first derivative estimator.

• :info? if false (default), returns the estimated value of x. If true, returns a dictionary with more information (see D-numeric's docstring for more info.)

• :initial-h: the initial h to use for derivative estimates before $h o 0$. Defaults to 0.1 * abs(x).

• :tolerance: see us/stream-limit for a discussion of how this value handles relative vs absolute tolerance. $\sqrt(\epsilon)$ by default, where $\epsilon$ = machine tolerance.

• :maxterms: the maximum number of terms to consider when hunting for a derivative estimate. This defaults to an estimate generated internally, designed to prevent roundoff error from swamping the result. If you want to disable this feature, set :maxterms to something moderately large, like :maxterms 100. But do so carefully! See the surrounding namespace for a larger discussion.

cljs

define-coordinates clj/s macro

(define-coordinates & args)

definite-integral clj/s≠

clj

(definite-integral f a b)

(definite-integral f
                   a
                   b
                   {:keys [method compile? info?]
                    :or {method :open compile? false info? false}
                    :as opts})

Evaluates the definite integral of integrand f across the interval $a, b$. Optionally accepts a dictionary opts of customizing options; All opts will be passed through to the supplied integrate functions.

If you'd like more control, or to retrieve the integration function directly without looking it up via :method each time, see get-integrator.

All supplied options are passed through to the underlying integrator; see the specific integrator for information on what options are available.

Keyword arguments:

:method: Specifies the integration method used. Must be

• a keyword naming one of the available methods in available-methods
• a function with the proper integrator signature
• a dictionary of integrator options with a :method key

Defaults to :open, which specifies an adaptive bulirsch-stoer quadrature method.

:compile? If true, the generic function will be simplified and compiled before execution.

:info? If true, definite-integral will return a map of integration information returned by the underlying integrator. Else, returns an estimate of the definite integral.

cljs

denominator clj/s≠

clj

(denominator _)

cljs

derivative clj/s≠

clj

(derivative f)

Returns a single-argument function of that, when called with an argument x, returns the derivative of f at x using forward-mode automatic differentiation.

For numerical differentiation, see emmy.numerical.derivative/D-numeric.

f must be built out of generic operations that know how to handle [[d/Differential]] inputs in addition to any types that a normal (f x) call would present. This restriction does not apply to operations like putting x into a container or destructuring; just primitive function calls.

cljs

determinant clj/s≠ multimethod

clj

(determinant a)

generic determinant

cljs

differential clj/s≠

clj

Alias for differential-of-map.

differential-of-map clj/s≠

clj

(differential-of-map mu:N->M)

Defined on FDG p.72.

cljs

dimension clj/s≠ multimethod

clj

(dimension a)

generic dimension

cljs

Div clj/s≠

clj

Operator that takes a function f and returns a function that calculates the Divergence of f at its input point.

The divergence is a one-level contraction of the gradient.

divergence clj/s≠

clj

(divergence Cartan)

(divergence metric orthonormal-basis)

Both arities of divergence are defined on page 156 of Functional Differential Geometry.

cljs

divide clj/s≠

clj

Alias for /.

dot-product clj/s≠ multimethod

clj

(dot-product a b)

generic dot-product

cljs

down clj/s≠

clj

(down & xs)

Construct a down (covariant) tuple from the arguments. Variadic version of [[down*]].

cljs

down->row-matrix clj/s≠

clj

(down->row-matrix v)

Returns a row matrix with the contents of the supplied down structure. Errors if any other type is provided.

cljs

drop1 clj/s≠

clj

Alias for lower.

drop2 clj/s≠

clj

(drop2 metric-tensor basis)

For making a (2,0) tensor into a (0,2) tensor.

cljs

Dt clj/s

dual-zero clj/s≠

clj

Alias for compatible-zero.

elliptic-f clj/s≠

clj

(elliptic-f phi k)

Legendre elliptic integral of the first kind F(φ, k). See W.H. Press, Numerical Recipes in C++, 2ed. eq. 6.11.19

See page 260.

cljs

euler clj/s

The mathematical constant e, sometimes known as Euler's Number.

Euler->M clj/s≠

clj

(Euler->M [theta phi psi])

Compute the rotation matrix from a 3-vector of Euler angles.

Our Euler Angle convention:

M(theta, phi, psi) = R_z(phi)*R_x(theta)*R_z(psi)

cljs

Euler-angles clj/s

euler-gamma clj/s

The mathematical constant known as the Euler–Mascheroni constant and sometimes as Euler's constant.

Euler-Lagrange-operator clj/s≠

clj

(Euler-Lagrange-operator L)

cljs

event->coords clj/s≠

clj

(event->coords this event)

Accepts a reference frame and an event, and returns this reference frame's coordinate representation of the supplied event.

cljs

event? clj/s≠

clj

(event? e)

Returns true if e is an event, false otherwise.

Make new events with make-event.

cljs

evolution clj/s≠

clj

(evolution order)

We can use the coordinatized vector field to build an evolution along an integral curve.

NOTE: I don't see how this has anything to do with coordinatize!

cljs

evolve clj/s≠

clj

(evolve state-derivative & state-derivative-args)

evolve takes a state derivative function constructor and its arguments, and returns an integrator via make-integrator.

In particular, the returned function accepts a callback function which will be invoked at intermediate grid points of the integration.

cljs

exact-divide clj/s≠ multimethod

clj

(exact-divide a b)

generic exact-divide.

Similar to the binary case of /, but throws if (v/exact? <result>) returns false.

cljs

exact? clj/s≠

clj

(exact? this)

Entries that are exact are available for gcd, among other operations.

cljs

exp clj/s≠ multimethod

clj

(exp a)

generic exp.

Returns the base-e exponential of x. Equivalent to (expt e x), given some properly-defined e symbol.

cljs

exp10 clj/s≠ multimethod

clj

(exp10 a)

generic exp10.

Returns the base-10 exponential of x. Equivalent to (expt 10 x).

cljs

exp2 clj/s≠ multimethod

clj

(exp2 a)

generic exp2.

Returns the base-2 exponential of x. Equivalent to (expt 2 x).

cljs

expression->stream clj/s≠

clj

(expression->stream expr stream)

(expression->stream expr stream options)

Renders an expression through the simplifier and onto the stream.

cljs

expression->string clj/s≠

clj

(expression->string expr)

Returns a string representation of a frozen, simplified version of the supplied expression expr.

cljs

expression-of clj/s≠

clj

(expression-of expr)

If the supplied argument is a [[Literal]] (or a symbol, interpreted elsewhere as a numerical literal expression), returns the wrapped expression (or the symbol).

Else, returns expr.

cljs

expt clj/s≠ multimethod

clj

(expt a b)

generic expt

cljs

extended-rotation clj/s≠

clj

(extended-rotation R)

cljs

exterior-derivative clj/s

F->C clj/s≠

clj

(F->C F)

Accepts a coordinate transformation F from a local tuple to a new coordinate structure, and returns a function from local -> local that applies the transformation directly.

F->C handles local tuples of arbitrary length.

cljs

F->CT clj/s≠

clj

Alias for [[F->CH]].

factor clj/s≠

clj

(factor expr)

Accepts a single symbolic expression and returns a factored version of that expression.

Differs from [[factor-expression]] in that it can handle any expression, not just expressions limited to polynomial operations.

cljs

factorial clj/s≠

clj

(factorial n)

Returns the factorial of n, i.e., the product of 1 to n (inclusive).

factorial will return a platform-specific emmy.util/bigint given some n that causes integer overflow.

cljs

ff:zero clj/s≠

clj

(ff:zero _)

Returns a form field that returns, for any supplied vector field vf, a manifold function [[manifold/zero-manifold-function]] that maps every input manifold point to the scalar value 0.

cljs

find-path clj/s≠

clj

(find-path Lagrangian t0 q0 t1 q1 n & {:keys [observe]})

SICM p. 23. The optional parameter values is a callback which will report intermediate points of the minimization.

cljs

floor clj/s≠ multimethod

clj

(floor a)

generic floor.

Returns the largest integer less than or equal to a.

Extensions beyond real numbers may behave differently; see the Documentation site for more detail.

cljs

form-field->form-field-over-map clj/s≠

clj

(form-field->form-field-over-map mu:N->M)

cljs

form-field? clj/s≠

clj

(form-field? ff)

Returns true if the supplied f is a form field operator, false otherwise.

cljs

four-tuple->ct clj/s≠

clj

(four-tuple->ct [ct])

cljs

four-tuple->space clj/s≠

clj

(four-tuple->space [_ x y z])

cljs

fractional-part clj/s≠ multimethod

clj

(fractional-part a)

generic fractional-part.

Returns the fractional part of the given value, defined as x - ⌊x⌋.

For positive numbers, this is identical to (- a (integer-part a)). For negative a, because floor truncates toward negative infinity, you might be surprised to find that fractional-part returns the distance between a and the next-lowest integer:

(= 0.6 (fractional-part -0.4))

cljs

frame-maker clj/s≠

clj

(frame-maker c->e e->c)

Takes:

• c->e, a function mapping coordinates to events
• e->c, a function mapping events to coordinates

and returns a function that takes:

• a symbolic name
• an ancestor frame
• a dictionary of params

and returns instance of [[IFrame]].

Both c->e and e->c must accept three arguments:

• ancestor-frame
• the [[IFrame]] instance
• a map of parameters supplied to the returned function (possibly empty!).

cljs

frame-name clj/s≠

clj

(frame-name _)

Returns the symbolic name of the suppplied frame.

cljs

frame-owner clj/s≠

clj

(frame-owner coords)

Returns the owning [[IFrame]] instance of the supplied coordinates coords, nil if there's no owner otherwise.

cljs

frame-params clj/s≠

clj

(frame-params _)

Returns the parameters registered with the supplied frame.

cljs

frame? clj/s≠

clj

(frame? x)

Returns true if x implements [[IFrame]], false otherwise.

cljs

freeze clj/s≠

clj

(freeze this)

Freezing an expression means removing wrappers and other metadata from subexpressions, so that the result is basically a pure S-expression with the same structure as the input. Doing this will rob an expression of useful information for further computation; so this is intended to be done just before simplification and printing, to simplify those processes.

cljs

function->oneform-field clj/s≠

clj

(function->oneform-field f)

One of the two incompatible definitions of differential.

This differential is a special case of exterior derivative. The other one lives at [[map/differential]].

cljs

Gamma clj/s≠

clj

(Gamma q)

(Gamma q n)

Gamma takes a path function (from time to coordinates) to a state function (from time to local tuple).

cljs

Gamma-bar clj/s≠

clj

(Gamma-bar f)

cljs

gcd clj/s≠ multimethod

clj

(gcd a b)

generic gcd.

Returns the greatest common divisor of the two inputs a and b.

cljs

general-boost clj/s≠

clj

(general-boost beta)

cljs

general-boost2 clj/s≠

clj

(general-boost2 direction v:c)

Takes a unit 3-vector direction (representing a direction) and a velocity v:c normalized by C.

cljs

generalized-LE clj/s≠

clj

(generalized-LE Lagrangian)

cljs

geodesic-equation clj/s≠

clj

(geodesic-equation source-coordsys target-coordsys Cartan-on-target)

cljs

golden-section-max clj/s≠

clj

(golden-section-max f xa xb)

(golden-section-max f xa xb opts)

For convenience, we also provide the sister-procedure for finding the maximum of a unimodal function using the golden section method.

Negate the function, minimize, negate the result.

cljs

golden-section-min clj/s≠

clj

(golden-section-min f xa xb)

(golden-section-min f
                    xa
                    xb
                    {:keys [choose callback]
                     :or {choose best-of callback (constantly nil)}
                     :as opts})

Golden Section search attempts to locate the minimum of the supplied function f by evaluating points located at golden-ratioed intervals between the two starting endpoints a and b. This method is slow, steady and reliable.

Supports the following optional keyword arguments:

:converged? is an optional predicate accepting five arguments:

• [a fa]
• [l fl]
• [r fr]
• [b fb]
• current-iteration

If the supplied fn returns true, it will signal convergence and the optimizer will return. Returning false will continue.

:choose is called at the final step of optimization with all 4 points and their fn values (see the first four arguments to :converged?), and returns the final choice.

:callback receives all 5 arguments on every iteration.

:maxiter Maximum number of iterations allowed for the minimizer. Defaults to 1000.

:maxfun Maximum number of times the function can be evaluated before exiting. Defaults to 1000.

:fn-tolerance check that the minimal value of any of the checked points is within the maximum of f(a) or f(b).

:arg-tolerance check that a and b are within this supplied absolute distance.

cljs

Grad clj/s≠

clj

Operator that takes a function f and returns a new function that calculates the Gradient of f.

The related D operator returns a function that produces a structure of the opposite orientation as Grad. Both of these functions use forward-mode automatic differentiation.

gradient clj/s≠

clj

(gradient metric basis)

gradient implements equation (10.3) in Functional Differential Geometry, defined on page 154.

cljs

Gram-Schmidt clj/s≠

clj

(Gram-Schmidt vector-basis metric)

cljs

Hamilton-equations clj/s≠

clj

(Hamilton-equations Hamiltonian)

cljs

Hamiltonian clj/s≠

clj

(Hamiltonian n)

Returns function signature for a Hamiltonian with n degrees of freedom (or an unrestricted number if n is not given).

Useful for constructing Hamiltonian literal functions.

cljs

Hamiltonian->state-derivative clj/s≠

clj

(Hamiltonian->state-derivative H)

cljs

Hodge-star clj/s≠

clj

(Hodge-star metric spec & {:keys [orthonormalize?] :or {orthonormalize? false}})

Takes a metric and a spec and returns the Hodge star operator (actually just a function, but I suspect this should be a proper operator!)

spec may be:

• a coordinate system with an orthonormal basis
• an orthonormal basis
• a basis

if the spec is a basis that needs to be orthonormalized, the optional :orthonormalize? keyword argument must be a coordinate system.

cljs

I clj/s≠

clj

Identity function. Returns its argument.

i:contract clj/s≠

clj

(i:contract T u d n)

cljs

i:outer-product clj/s≠

clj

(i:outer-product T1 T2)

cljs

identity-like clj/s≠

clj

(identity-like this)

cljs

identity? clj/s≠

clj

(identity? this)

cljs

imag-part clj/s≠ multimethod

clj

(imag-part a)

generic imag-part

cljs

index-types clj/s≠

clj

(index-types f)

Given an operator or function f, returns its registered vector of index types, or [] if none exist.

index types are, for example,

['up 'down 'down]

for a Christoffel-2, which takes one oneform field and two vector fields.

cljs

indexed->typed clj/s≠

clj

(indexed->typed indexed basis)

cljs

infinite? clj/s≠ multimethod

clj

(infinite? a)

generic infinite?.

Returns true if a is either numerically infinite (i.e., equal to ##Inf) or a compound number (complex or quaterion, for example) with some infinite component.

cljs

inner-product clj/s≠ multimethod

clj

(inner-product a b)

generic inner-product

cljs

integer-part clj/s≠ multimethod

clj

(integer-part a)

generic integer-part.

Returns the integer part of a by removing any fractional digits.

cljs

integrate-state-derivative clj/s≠

clj

(integrate-state-derivative state-derivative
                            state-derivative-args
                            initial-state
                            t1
                            dt)

A wrapper for evolve, which is more convenient when you just want a vector of (time, state) pairs over the integration interval instead of having to deal with a callback. Integrates the supplied state derivative (and its argument package) from [0 to t1] in steps of size dt

cljs

interior-product clj/s≠

clj

(interior-product X)

cljs

invert clj/s≠ multimethod

clj

(invert a)

generic invert.

Returns the multiplicative inverse of a.

Equivalent to (/ 1 a).

cljs

iterated-map clj/s≠

clj

(iterated-map f n)

f is a function of (x y continue fail), which calls continue with the values of x' y' that follow x y in the mapping.

Returns a map of the same shape that iterates the iterated map n times before invoking the continuation, or invokes the fail continuation if the inner map fails.

cljs

Jacobian clj/s≠

clj

(Jacobian to-basis from-basis)

Returns the Jacobian of transition from from-basis to to-basis.

The Jacobian is a structure of manifold functions. The outer index is the from-basis index, so this structure can be multiplied by tuple of component functions of a vector field relative to from-basis to get component functions for a vector field in to-basis.

cljs

kind clj/s≠

clj

(kind this)

cljs

kind-predicate clj/s≠

clj

(kind-predicate x)

Returns a predicate that returns true if its argument matches the supplied kind-keyword k, false otherwise.

cljs

Lagrange-equations clj/s≠

clj

(Lagrange-equations L)

(Lagrange-equations L dissipation-fn)

cljs

Lagrange-equations-first-order clj/s≠

clj

(Lagrange-equations-first-order L)

cljs

Lagrange-interpolation-function clj/s≠

clj

(Lagrange-interpolation-function ys xs)

Given ys (a sequence of function values) and xs (an equal-length sequence of function inputs), returns a [[emmy.polynomial/Polynomial]] instance guaranteed to pass through all supplied xs and ys.

The contract for inputs is that (map vector xs ys) should return a sequence of pairs of points.

cljs

Lagrangian->energy clj/s≠

clj

(Lagrangian->energy L)

cljs

Lagrangian->Hamiltonian clj/s

Lagrangian->power-loss clj/s≠

clj

(Lagrangian->power-loss L)

cljs

Lagrangian->state-derivative clj/s≠

clj

(Lagrangian->state-derivative L)

(Lagrangian->state-derivative L dissipation-fn)

Optionally takes a dissipation function.

cljs

Lagrangian-action clj/s≠

clj

(Lagrangian-action L q t1 t2)

(Lagrangian-action L q t1 t2 integration-opts)

cljs

Lap clj/s≠

clj

Operator that takes a function f and returns a function that calculates the Vector Laplacian of f at its input point.

Laplacian clj/s≠

clj

(Laplacian metric orthonormal-basis)

cljs

lcm clj/s≠ multimethod

clj

(lcm a b)

generic lcm.

Returns the least common multiple of the two inputs a and b.

cljs

Legendre-transform clj/s

let-coordinates clj/s macro

(let-coordinates & args)

Lie-D clj/s≠

clj

(Lie-D R)

Takes a system derivative R and returns a operator that takes a function F of coordinatized state and performs the operation described below, from ODE.scm in scmutils:

Let (sigma t) be the state of a system at time t. Let the (first-order) system of differential equations governing the evolution of this state be:

((D sigma) t) = (R (sigma t))

(D sigma) = (compose R sigma)

i.e. R is a system derivative.

Let F be any function of state, then a differential equation for the evolution of F, as it is dragged along the integral curve sigma is:

(D (compose F sigma)) = (* (compose (D F) sigma) (D sigma))
= (compose (* (D F) R) sigma)

Let's call this operation Lie-D (the Lie derivative for coordinates).

cljs

Lie-derivative clj/s≠ multimethod

clj

(Lie-derivative a)

generic Lie-derivative

cljs

Lie-transform clj/s≠

clj

(Lie-transform H t)

p. 428, the Lie transform is just the time-advance operator using the Lie derivative (see Hamiltonian.scm).

cljs

linear-interpolants clj/s≠

clj

(linear-interpolants x0 x1 n)

cljs

literal-Cartan clj/s≠

clj

(literal-Cartan name coordsys)

cljs

literal-Christoffel-1 clj/s≠

clj

(literal-Christoffel-1 name coordsys)

cljs

literal-Christoffel-2 clj/s≠

clj

(literal-Christoffel-2 name coordsys)

cljs

literal-down clj/s≠

clj

(literal-down sym size)

Generates a down structure of dimension size populated by symbolic entries, each prefixed by the supplied symbol sym.

For example:

(= (literal-down 'x 3)
   (down 'x_0 'x_1 'x_2))

cljs

literal-function clj/s macro

(literal-function f)

(literal-function f sicm-signature)

(literal-function f domain range)

literal-Lagrangian-state clj/s≠

clj

(literal-Lagrangian-state n-dof)

cljs

literal-manifold-function clj/s≠

clj

(literal-manifold-function sym coordinate-system)

Given a symbolic name sym and an [[ICoordinateSystem]], returns a literal function that maps coordinate-free manifold points to a scalar output.

Also aliased as literal-manifold-function.

cljs

literal-manifold-map clj/s≠

clj

(literal-manifold-map name source target)

cljs

literal-matrix clj/s≠

clj

(literal-matrix sym nrows)

(literal-matrix sym nrows ncols)

Generates a nrows x ncols matrix of symbolic entries, each prefixed by the supplied symbol sym.

If ncols (the third argument) is not supplied, returns a square matrix of size nrows x nrows.

NOTE: The symbols in the returned matrix record their Einstein-notation path into the structure that this matrix represents; a down of up columns. This means that the returned indices embedded in the symbols look flipped, ji vs ij.

For example:

(= (literal-matrix 'x 2 2)
   (by-rows ['x_0↑0 'x_1↑0]
            ['x_0↑1 'x_1↑1]))

cljs

literal-metric clj/s≠

clj

(literal-metric name coordinate-system)

Flat coordinate systems here only.

cljs

literal-number clj/s≠

clj

(literal-number x)

Returns its argument, wrapped in a marker type that responds to the generic operations registered in emmy.numsymb.

Symbols are automatically treated as literal-number instances, so

(* 10 (literal-number 'x))

is equivalent to

(* 10 'x)

If you pass an actual number, emmy will attempt to preserve exact values through various operations:

(g/+ 1 (g/cos (g/* 2 (literal-number 4))))
;;=> (+ 1 (cos 8))

Notice that the (g/* 2 ...) is evaluated, but cos evaluation is deferred, since the result is inexact. On the other hand, if the number is inexact to begin with:

(g/+ 1 (g/cos (g/* 2 (literal-number 2.2))))
;;=> 0.6926671300215806

the system will go ahead and evaluate it.

cljs

literal-oneform-field clj/s≠

clj

(literal-oneform-field name coordinate-system)

Given a symbolic name sym and a coordinate-system, returns a one-form field consisting of literal real-valued functions from the coordinate system's dimension for each coordinate component.

These functions are passed to components->oneform-field, along with the supplied coordinate-system and symbolic name sym.

For coordinate systems of dimension 1, literal-form-field's component functions will accept a single non-structural argument.

cljs

literal-up clj/s≠

clj

(literal-up sym size)

Generates an up structure of dimension size populated by symbolic entries, each prefixed by the supplied symbol sym.

For example:

(= (literal-up 'x 3)
   (up 'x↑0 'x↑1 'x↑2))

cljs

literal-vector-field clj/s≠

clj

(literal-vector-field sym coordinate-system)

Given a symbolic name sym and a coordinate-system, returns a vector field consisting of literal real-valued functions from the coordinate system's dimension for each coordinate component.

These functions are passed to components->vector-field, along with the supplied coordinate-system and symbolic name sym.

For coordinate systems of dimension 1, literal-vector-field's component functions will accept a single non-structural argument.

cljs

log clj/s≠ multimethod

clj

(log a)

generic log.

Returns the natural logarithm of x.

cljs

log10 clj/s≠ multimethod

clj

(log10 a)

generic log10.

Returns the base-10 logarithm of x, i.e., $log_10(x)$.

cljs

log2 clj/s≠ multimethod

clj

(log2 a)

generic log2.

Returns the base-2 logarithm of x, i.e., $log_2(x)$.

cljs

lower clj/s≠

clj

(lower metric)

To make a vector field into a one-form field, i.e., a (1,0) tensor into a (0,1) tensor.

cljs

m->s clj/s≠

clj

(m->s ls m rs)

Convert the matrix m into a structure S, guided by the requirement that (* ls S rs) should be a scalar.

cljs

m:generate clj/s≠

clj

(m:generate n f)

(m:generate r c f)

Returns a matrix with r rows and c columns, whose entries are generated by the supplied function f.

If you only supply one dimension n the returned matrix will be square.

The entry in the ith row and j-th column is (f i j).

cljs

magnitude clj/s≠ multimethod

clj

(magnitude a)

generic magnitude

cljs

make-basis clj/s≠

clj

(make-basis vector-basis dual-basis)

Make a basis object out of a vector and dual basis.

The dimensions of vector-basis and dual-basis must agree.

cljs

make-Cartan clj/s≠

clj

(make-Cartan forms basis)

cljs

make-Christoffel clj/s≠

clj

(make-Christoffel symbols basis)

Returns a data structure representing Christoffel symbols of the second kind.

cljs

make-Christoffel-1 clj/s≠

clj

(make-Christoffel-1 symbols basis)

Returns a data structure representing Christoffel symbols of the first kind.

cljs

make-constant-vector-field clj/s≠

clj

(make-constant-vector-field basis m0)

cljs

make-event clj/s≠

clj

(make-event e)

Marks the input event e as an event via its metadata. The return value will return true when passed to event?.

cljs

make-four-tuple clj/s≠

clj

(make-four-tuple ct [x y z])

cljs

make-manifold clj/s≠

clj

(make-manifold family n)

(make-manifold family n embedding-dimension)

Returns a concrete manifold generated by specializing the supplied manifold family into a concrete manifold of dimension n. n must be a positive integer.

Optionally takes an embedding-dimension; this must be >= the value of n. Use this in cases like an n-sphere embedded in a euclidean space of dimension n+1.

A manifold is a topological space that locally resembles Euclidean space near each point.

cljs

make-polar clj/s≠ multimethod

clj

(make-polar a b)

generic make-polar

cljs

make-rectangular clj/s≠ multimethod

clj

(make-rectangular a b)

generic make-rectangular

cljs

make-SR-coordinates clj/s≠

clj

(make-SR-coordinates frame four-tuple)

cljs

make-SR-frame clj/s≠

clj

(make-SR-frame name ancestor-frame boost-direction v-over-c origin)

cljs

manifold-family? clj/s≠

clj

(manifold-family? m)

Returns true if m is a dictionary representing a manifold family, false otherwise.

cljs

manifold-point? clj/s≠

clj

(manifold-point? p)

Returns true if p is a manifold point, false otherwise.

cljs

manifold-type clj/s≠

clj

(manifold-type manifold)

The supplied manifold m locally resembles some vector space; this function returns the field over which that vector space was specified.

cljs

manifold? clj/s≠

clj

(manifold? m)

Returns true if m is a dictionary representing a manifold, false otherwise.

cljs

mapr clj/s≠

clj

(mapr f & structures)

Return a structure with the same shape as s but with f applied to each primitive (that is, not structural) component.

cljs

matrix-by-cols clj/s≠

clj

(matrix-by-cols & cols)

Returns a matrix whose columns consist of the supplied sequence of cols. These all must be the same length.

Variadic equivalent to [[by-cols*]].

cljs

matrix-by-rows clj/s≠

clj

(matrix-by-rows & rows)

Returns a matrix whose rows consist of the supplied sequence of rows. These all must be the same length.

Variadic equivalent to [[by-rows*]].

cljs

metric->Christoffel-1 clj/s≠

clj

(metric->Christoffel-1 metric basis)

cljs

metric->Christoffel-2 clj/s≠

clj

(metric->Christoffel-2 metric basis)

cljs

metric->components clj/s≠

clj

(metric->components metric basis)

cljs

metric->connection-1 clj/s≠

clj

(metric->connection-1 metric basis)

cljs

metric->connection-2 clj/s≠

clj

(metric->connection-2 metric basis)

cljs

metric->inverse-components clj/s≠

clj

(metric->inverse-components metric basis)

Given a metric and a basis, computes the inverse metric.

cljs

metric-over-map clj/s≠

clj

(metric-over-map mu:N->M g-on-M)

cljs

metric:invert clj/s≠

clj

(metric:invert metric basis)

cljs

minimize clj/s≠

clj

(minimize f a b)

(minimize f a b observe)

Find the minimum of the function f: R -> R in the interval [a, b].

If an observe function is supplied, it will be invoked with the iteration count and the values of x and f(x) at each search step.

cljs

modulo clj/s≠ multimethod

clj

(modulo a b)

generic modulo.

Returns the result of the mathematical Modulo operation between a and b (using the Knuth definition listed).

The contract satisfied by modulo is:

(= a (+ (* b (floor (/ a b)))
        (modulo a b)))

For numbers, this differs from the contract offered by remainder because (floor (/ a b)) rounds toward negative infinity, while the quotient operation in the contract for remainder rounds toward 0.

The result will be either 0 or of the same sign as the divisor b.

cljs

momentum clj/s≠

clj

(momentum H-state)

Returns the momentum element of a local Hamiltonian state tuple (by convention, the third element).

cljs

momentum-tuple clj/s

multidimensional-minimize clj/s≠

clj

(multidimensional-minimize func x0 & {:keys [info?] :as opts})

Entrypoint for multidimensional minimization routines.

See emmy.numerical.multimin.nelder-mead/nelder-mead for the only supported option.

cljs

negate clj/s≠ multimethod

clj

(negate a)

generic negate.

Returns the negation of a.

Equivalent to (- (v/zero-like a) a).

cljs

negative? clj/s≠ multimethod

clj

(negative? a)

generic negative?.

Returns true if the argument a is less than (v/zero-like a), false otherwise. The default implementation depends on a proper Comparable implementation on the type.`

cljs

nelder-mead clj/s≠

clj

(nelder-mead func x0 {:keys [callback] :as opts})

Find the minimum of the function f: R^n -> R, given an initial point q ∈ R^n. Supports the following optional keyword arguments:

:callback if supplied, the supplied fn will be invoked with iteration count, the values of X and the value of f(X) at each intermediate point of evaluation.

:info? if true, wraps the result with evaluation information.

:adaptive? if true, the Nelder-Mead parameters for contraction, expansion, reflection and shrinking will be set adaptively, as functions of the number of dimensions. If false they stay constant.

:alpha sets the reflection coefficient used for each step of Nelder-Mead.

:beta sets the expansion coefficient used for each step of Nelder-Mead.

:gamma sets the contraction coefficient used for each step of Nelder-Mead.

:sigma sets the shrink coefficient used for each step of Nelder-Mead.

:maxiter Maximum number of iterations allowed for the minimizer. Defaults to 200*dimension.

:maxfun Maximum number of times the function can be evaluated before exiting. Defaults to 200*dimension.

:simplex-tolerance When the absolute value of the max difference between the best point and any point in the simplex falls below this tolerance, the minimizer stops. Defaults to 1e-4.

:fn-tolerance When the absolute value of the max difference between the best point's function value and the fn value of any point in the simplex falls below this tolerance, the minimizer stops. Defaults to 1e-4.

:zero-delta controls the value to which 0 entries in the initial vector are set during initial simplex generation. Defaults to 0.00025.

:nonzero-delta factor by which entries in the initial vector are perturbed to generate the initial simplex. Defaults to 0.05.

See Gao, F. and Han, L. Implementing the Nelder-Mead simplex algorithm with adaptive parameters. 2012. Computational Optimization and Applications. 51:1, pp. 259-277 I gratefully acknowledge the Python implementation in SciPy which I have imitated here.

cljs

nform-field? clj/s≠

clj

(nform-field? f n)

Returns true if the supplied f is an form field of rank n, false otherwise.

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

cljs

numerator clj/s≠

clj

(numerator _)

cljs

numerical? clj/s≠

clj

(numerical? _)

cljs

one-like clj/s≠

clj

(one-like this)

cljs

one-manifold-function clj/s≠

clj

(one-manifold-function point)

Manifold function that maps every input manifold point to the scalar value 1.

cljs

one? clj/s≠

clj

(one? this)

cljs

oneform-field->basis-components clj/s≠

clj

(oneform-field->basis-components w vector-basis)

Given a structure w of and a vector field basis vector-basis, returns a new structure generated by applying the full vector basis to each element of w.

Here's an example of how to use this function to round trip a structure of basis components:

(let [vb    (vf/coordinate-system->vector-basis coordsys)
      basis (coordinate-system->oneform-basis coordsys)
      components (down d:dx d:dy)]
  (= components
     (-> components
         (basis-components->oneform-field basis)
         (oneform-field->basis-components vb))))

cljs

oneform-field->components clj/s≠

clj

(oneform-field->components form coordinate-system)

Given a one-form field form and a coordinate-system, returns a function from the coordinate representation of a manifold point to a coordinate representation of the coordinatized components of the form field at that point.

For example:

(let-coordinates [[x y] R2-rect]
  (let [f (literal-oneform-field 'f R2-rect)]
    ((oneform-field->components f R2-rect)
     (up 'x0 'y0))))

;;=> (down (f_0 (up x0 y0))
;;         (f_1 (up x0 y0)))

cljs

oneform-field->vector-field clj/s≠

clj

Alias for raise.

oneform-field? clj/s≠

clj

(oneform-field? f)

Returns true if the supplied f is a One-form, false otherwise.

A One-form takes a single vector field to a real-valued function on the manifold.

cljs

orientation clj/s≠

clj

(orientation s)

Returns the orientation of s, either ::up or ::down. Defaults to ::up, even for non-structures.

cljs

orthonormalize clj/s≠

clj

(orthonormalize basis metric coordinate-system)

cljs

osculating-path clj/s≠

clj

(osculating-path state0)

Given a state tuple (of finite length), reconstitutes the initial segment of the Taylor series corresponding to the state tuple data as a function of t.

Time is measured beginning at the point of time specified in the input state tuple.

cljs

outer-product clj/s≠ multimethod

clj

(outer-product a b)

generic outer-product

cljs

p->r clj/s≠

clj

(p->r tqv)

SICM p. 47. Polar to rectangular coordinates of state.

cljs

parallel-transport-equation clj/s≠

clj

(parallel-transport-equation source-coordsys target-coordsys Cartan-on-target)

cljs

partial clj/s

(partial & selectors)

A shim. Dispatches to [[d/partial]] when all the arguments are integers; falls back to [[clojure.core/partial]] (partial function application) otherwise.

partial-derivative clj/s≠ multimethod

clj

(partial-derivative a b)

generic partial-derivative

cljs

partial-sums clj/s≠

clj

(partial-sums s)

Returns a series (of the same type as the input) of partial sums of the terms in the supplied series s.

cljs

patch-names clj/s≠

clj

(patch-names manifold)

Returns a set of patch names registered in the supplied manifold.

cljs

pe clj/s

phase-space-derivative clj/s≠

clj

Alias for Hamiltonian->state-derivative, for compatibility with 1st edition of SICM.

phi clj/s

The mathematical constant 𝜑, also known as the Golden Ratio.

pi clj/s

The mathematical constant Pi.

point clj/s≠

clj

(point coordinate-system)

Given an [[ICoordinateSystem]], returns a function from coordinates in coordinate-system's repesentation to the matching point on the manifold associated with coordinate-system.

cljs

Poisson-bracket clj/s≠

clj

(Poisson-bracket f g)

cljs

polar-canonical clj/s≠

clj

(polar-canonical alpha)

p.327

cljs

power-series clj/s≠

clj

(power-series & prefix)

Return a [[PowerSeries]] starting with the supplied values. The remainder of the series will be filled with the zero-value corresponding to the first of the given values.

If you have a sequence already, prefer [[power-series*]].

cljs

principal-value clj/s≠

clj

(principal-value cuthigh)

cljs

print-expression clj/s≠

clj

(print-expression expr)

cljs

proper-space-interval clj/s≠

clj

(proper-space-interval four-tuple)

cljs

proper-time-interval clj/s≠

clj

(proper-time-interval four-tuple)

cljs

pullback clj/s≠

clj

(pullback mu:N->M)

(pullback mu:N->M mu-inverse:M->N)

cljs

pullback-form clj/s≠

clj

(pullback-form mu:N->M)

Returns a function which will pull a form back across a map (without needing its inverse)

cljs

pullback-function clj/s≠

clj

(pullback-function mu:N->M)

cljs

pullback-vector-field clj/s≠

clj

(pullback-vector-field mu:N->M mu-inverse:M->N)

cljs

pushforward-function clj/s≠

clj

(pushforward-function mu-inverse:M->N)

cljs

pushforward-vector clj/s≠

clj

(pushforward-vector mu:N->M mu-inverse:M->N)

cljs

qp-submatrix clj/s≠

clj

(qp-submatrix m)

cljs

quotient clj/s≠ multimethod

clj

(quotient a b)

generic quotient

cljs

r->p clj/s≠

clj

(r->p tqv)

cljs

r->s clj/s≠

clj

(r->s local)

cljs

R1 clj/s

R1-rect clj/s

R2 clj/s

R2-polar clj/s

R2-rect clj/s

R3 clj/s

R3-cyl clj/s

R3-rect clj/s

R3-spherical clj/s

R4 clj/s

R4-cyl clj/s

R4-rect clj/s

raise clj/s≠

clj

(raise metric basis)

To make a one-form field into a vector field, i.e., a (0,1) tensor into a (1,0) tensor.

cljs

raise1 clj/s≠

clj

Alias for raise.

raise2 clj/s≠

clj

(raise2 metric-tensor basis)

For making a (0,2) tensor into a (2,0) tensor.

cljs

ratio? cljs

rationalize cljs

real-part clj/s≠ multimethod

clj

(real-part a)

generic real-part

cljs

ref clj/s

(ref a)

(ref a & ks)

A shim so that ref can act like nth in SICM contexts, as clojure core ref elsewhere.

remainder clj/s≠ multimethod

clj

(remainder a b)

generic remainder.

Returns the remainder of dividing the dividend a by divisor b.

The contract satisfied by remainder is:

(= a (+ (* b (quotient a b))
        (remainder a b)))

For numbers, this differs from the contract offered by modulo because quotient rounds toward 0, while (floor (/ a b)) rounds toward negative infinity.

The result will be either 0 or of the same sign as the dividend a.

cljs

Ricci clj/s≠

clj

(Ricci nabla basis)

cljs

Riemann clj/s≠

clj

(Riemann nabla)

cljs

Riemann-curvature clj/s≠

clj

(Riemann-curvature nabla)

cljs

Rn clj/s

rotate-x clj/s

rotate-x-matrix clj/s≠

clj

(rotate-x-matrix α)

Produce the matrix of a rotation of α radians about the x axis.

cljs

rotate-x-tuple clj/s≠

clj

(rotate-x-tuple α)

cljs

rotate-y clj/s

rotate-y-matrix clj/s≠

clj

(rotate-y-matrix α)

Produce the matrix of a rotation of α radians about the y axis.

cljs

rotate-y-tuple clj/s≠

clj

(rotate-y-tuple α)

cljs

rotate-z clj/s

rotate-z-matrix clj/s≠

clj

(rotate-z-matrix α)

Produce the matrix of a rotation of α radians about the z axis.

cljs

rotate-z-tuple clj/s≠

clj

(rotate-z-tuple α)

cljs

row-matrix clj/s≠

clj

(row-matrix & xs)

Returns a row matrix populated by the supplied xs. Variadic equivalent to [[row*]].

cljs

row-matrix->down clj/s≠

clj

(row-matrix->down m)

Returns the single row from the supplied row matrix as a down. Errors if some other type is supplied.

cljs

row-matrix->vector clj/s≠

clj

(row-matrix->vector m)

Returns the single row from the supplied row matrix as a vector. Errors if some other type is supplied.

cljs

Rx clj/s≠

clj

(Rx α)

Returns a function which rotates a vector α radians about the x axis.

cljs

Ry clj/s≠

clj

(Ry α)

Returns a function which rotates a vector α radians about the y axis.

cljs

Rz clj/s≠

clj

(Rz α)

Returns a function which rotates a vector α radians about the z axis.

cljs

s->m clj/s≠

clj

(s->m ms rs)

(s->m ls ms rs)

Convert the structure ms, which would be a scalar if the (compatible) multiplication (* ls ms rs) were performed, to a matrix.

cljs

s->r clj/s≠

clj

(s->r local)

SICM p. 83

cljs

S1 clj/s

S1-circular clj/s

S1-gnomonic clj/s

S1-slope clj/s

S1-tilted clj/s

S2 clj/s

S2-gnomonic clj/s

S2-metric clj/s

S2-Riemann clj/s

S2-spherical clj/s

S2-stereographic clj/s

S2-tilted clj/s≠

clj

Similar to the S2-spherical coordinate system, with the north pole rotated 90 degrees and lying along the positive y axis.

S2-type clj/s

S2p clj/s

S2p-gnomonic clj/s

S2p-Riemann clj/s

S2p-spherical clj/s

S2p-stereographic clj/s

S2p-tilted clj/s

S3 clj/s

S3-gnomonic clj/s

S3-spherical clj/s

S3-stereographic clj/s

S3-tilted clj/s

s:generate clj/s≠

clj

(s:generate dimension orientation f)

Generate a structure with the given orientation whose elements are

(f i)

where i ranges from [0..dimension).

cljs

sec clj/s≠ multimethod

clj

(sec a)

generic sec.

Computes the secant of the supplied argument a.

Equivalent to (invert (cos a)).

cljs

sech clj/s≠ multimethod

clj

(sech a)

generic sech.

Computes the hyperbolic secant of the supplied argument a.

defaults to 1 / cosh(x).

cljs

seq:pprint clj/s≠

clj

(seq:pprint n xs)

Realizes, simplifies and pretty-prints n elements from the supplied sequence xs.

cljs

seq:print clj/s≠

clj

(seq:print n xs)

Realizes, simplifies and prints n elements from the supplied sequence xs.

cljs

series clj/s≠

clj

(series & prefix)

Return a [[Series]] starting with the supplied values. The remainder of the series will be filled with the zero-value corresponding to the first of the given values.

If you have a sequence already, prefer [[series*]].

cljs

series:sum clj/s≠

clj

(series:sum s n)

Returns the sum of all elements in the input series s up to order n (inclusive). For example:

(sum (series 1 1 1 1 1 1 1) 3)
;; => 4

NOTE that sum sums the first n + 1 terms, since a series starts with an order 0 term.

cljs

sharpen clj/s≠

clj

(sharpen metric basis m)

cljs

simplify clj/s≠ multimethod

clj

(simplify a)

generic simplify

cljs

sin clj/s≠ multimethod

clj

(sin a)

generic sin.

Returns the sine of the supplied argument a.

cljs

sinc clj/s≠ multimethod

clj

(sinc a)

generic sinc.

The unnormalized sinc function, equivalent to $\frac{\sin x}{x}$ but defined to be equal to 1 at $x = 0$.

References

• Wikipedia page
• Mathworld page on Sinc
• [Boost notes on sinc and [[sinch]]](https://www.boost.org/doc/libs/1_65_0/libs/math/doc/html/math_toolkit/sinc/sinc_overview.html)

cljs

sinh clj/s≠ multimethod

clj

(sinh a)

generic sinh.

Computes the hyperbolic sine of the supplied argument a.

defaults to (e^x - e^{-x}) / 2.

cljs

sinhc clj/s≠ multimethod

clj

(sinhc a)

generic sinhc.

The sinhc function, equivalent to $\frac{\sinh x}{x}$ but defined to be equal to 1 at $x = 0$.

References

• Wikipedia page
• Mathworld page on Sinhc

cljs

Sn clj/s

SO3 clj/s

SO3-type clj/s

solve-linear clj/s≠ multimethod

clj

(solve-linear a b)

generic solve-linear.

For a given a and b, returns x such that a*x = b.

Seesolve-linear-right for a similar function that solves for a = x*b.

cljs

solve-linear-left clj/s≠

clj

(solve-linear-left a b)

Alias for solve-linear; present for compatibility with the original scmutils codebase.

NOTE: In scmutils, solve-linear-left and solve-linear act identically in all cases except matrices. solve-linear-left only accepted a column matrix (or up structure) in the b position, while solve-linear accepted either a column or row (up or down structure).

In Emmy, both functions accept either type.

cljs

solve-linear-right clj/s≠ multimethod

clj

(solve-linear-right a b)

generic solve-linear-right.

For a given a and b, returns x such that a = x*b.

Seesolve-linear for a similar function that solves for a*x = b.

cljs

spacetime clj/s

spacetime-rect clj/s

spacetime-sphere clj/s

sqrt clj/s≠ multimethod

clj

(sqrt a)

generic sqrt

cljs

square clj/s≠ multimethod

clj

(square a)

generic square

cljs

SR-coordinates? clj/s≠

clj

(SR-coordinates? coords)

cljs

SR-name clj/s≠

clj

(SR-name coords)

cljs

standard-map clj/s≠

clj

(standard-map K)

cljs

state->t clj/s≠

clj

Alias for [[time]].

state-advancer clj/s≠

clj

(state-advancer state-derivative & state-derivative-args)

state-advancer takes a state derivative function constructor followed by the arguments to construct it with. The state derivative function is constructed and an integrator is produced which takes:

• initial state
• target time

as arguments. Optionally, supply an options map with these optional fields:

:compile?: If true, the ODE solver will compile your state function.

:epsilon: The maximum error tolerance allowed by the ODE solver, both relative and absolute.

Returns the final state.

The state derivative is expected to map a structure to a structure of the same shape, and is required to have the time parameter as the first element.

cljs

structure->typed clj/s≠

clj

(structure->typed coeff-functions basis)

cljs

structure->vector clj/s≠

clj

(structure->vector s)

Return the structure s in unoriented vector form.

cljs

structure-constant clj/s≠

clj

(structure-constant e_i e_j e_k basis metric)

cljs

structure? clj/s≠

clj

(structure? s)

Returns true if s is a structure, false otherwise. (Vectors are treated as up structures.)

cljs

submatrix clj/s≠

clj

(submatrix x lowrow hirow lowcol hicol)

Returns the submatrix of the matrix (or matrix-like structure) s generated by taking

• rows from lowrow -> hirow (inclusive)
• columns from lowcol -> hicol (inclusive)

cljs

sum clj/s≠

clj

(sum xs)

(sum f low high)

Takes either:

• a series xs of numbers
• A transformation function f, an inclusive-lower bound low and exclusive-upper bound upper

And returns the result of aggregating either xs or (map f (range low high)) using the fold dynamically bound to [[fold]].

Use binding to substitute in a different fold:

(require '[emmy.algebra.fold :as af])

(binding [*fold* (af/join af/kahan af/min af/max)]
  (sum inc 0 10))
;;=> [55.0 1 10]

cljs

sumr clj/s≠

clj

(sumr f & structures)

Given some function f and any number of isomorphic structures, returns the sum of the results of applying f to each associated set of entries in each structure.

cljs

symmetrize-Cartan clj/s≠

clj

(symmetrize-Cartan Cartan)

cljs

symmetrize-Christoffel clj/s≠

clj

(symmetrize-Christoffel G)

cljs

symplectic-transform? clj/s≠

clj

(symplectic-transform? C)

p. 334

cljs

symplectic-unit clj/s≠

clj

(symplectic-unit n)

p. 334 (used, but not defined there)

cljs

tan clj/s≠ multimethod

clj

(tan a)

generic tan.

Computes the trigonometric tangent function of the supplied argument a.

Equivalent to (/ (sin a) (cos a)).

cljs

tanc clj/s≠ multimethod

clj

(tanc a)

generic tanc.

tanc is defined, by analogy with sinc, to be equal to $\frac{\tan x}{x}$ for nonzero $x$ and equal to 1 at $x = 0$.

References

• Wikipedia page
• Mathworld page on Sinc

cljs

tanh clj/s≠ multimethod

clj

(tanh a)

generic tanh.

Computes the hyperbolic tangent of the supplied argument a.

defaults to sinh(x) / cosh(x).

cljs

tanhc clj/s≠ multimethod

clj

(tanhc a)

generic tanhc.

The tanhc function, equivalent to $\frac{\tanh x}{x}$ but defined to be equal to 1 at $x = 0$.

References

• Wikipedia page
• Mathworld page on Tanhc

cljs

taylor-series clj/s≠

clj

(taylor-series f)

(taylor-series f & xs)

Given a differentiable function f and any number of arguments xs, returns a [[emmy.series/PowerSeries]] representing the Taylor series of the function f expanded at xs.

Calling taylor-series with no arguments will return the Maclaurin series of f, i.e., the Taylor series expansion at (= x 0).

Calling the returned power series with incremental argument dx will produce a [[emmy.series/Series]] representing the terms of the Taylor series of f expanded at x and evaluated at x+dx.

NOTE: Just like the D operator, functions f of multiple-arguments are treated as a function of a single structural argument. If you pass multiple arguments xs, you'll have to manually wrap your multiple-argument dx in a emmy.structure/up or a vector before passing it to the returned power series.

NOTE: The typical definition of a Taylor series of f expanded around some point x is

$$T(p) = f(x) + \frac{f'(x)}{1!}(p-x) + \frac{f''(x)}{2!} (p-x)^2 + \ldots,$$

where p is the evaluation point. When (= p x), all derivatives of the Taylor series expansion of f will exactly match the derivatives of f itself.

The Taylor series returned here (call it $T'$) is actually a function of dx, where

$$T'(dx) = T(x+dx) = f(x) + \frac{f'(x)}{1!}(dx) + \frac{f''(x)}{2!} (dx)^2 + \ldots.$$

cljs

tex$ clj/s

(tex$ expr)

Returns a string containing a LaTeX representation of expr, wrapped in single $ to mark the string as an inline LaTeX form.

tex$$ clj/s

(tex$$ expr)

Returns a string containing a LaTeX representation of expr, wrapped in double $$ to mark the string as a block LaTeX form.

the-ether clj/s

the-real-line clj/s

time-independent-canonical? clj/s≠

clj

(time-independent-canonical? C)

p.326

cljs

torsion clj/s≠

clj

(torsion nabla)

cljs

torsion-vector clj/s≠

clj

(torsion-vector nabla)

cljs

trace clj/s≠ multimethod

clj

(trace a)

generic trace

cljs

trace2down clj/s≠

clj

(trace2down metric-tensor basis)

Computes the trace of a (0,2) tensor.

cljs

trace2up clj/s≠

clj

(trace2up metric-tensor basis)

Computes the trace of a (2,0) tensor

cljs

transfer-point clj/s≠

clj

(transfer-point embedded embedding)

Returns a function that takes a single manifold point embedded in the manifold embedded and transfers the point to the supplied embedding manifold.

The embedding dimension must be the same for both manifolds.

NOTE that embedded and embedding can be either manifolds, or instances of [[ICoordinateSystem]]. In the latter case embedded and embedding will bind to the manifold associated with the supplied [[ICoordinateSystem]].

cljs

transpose clj/s≠ multimethod

clj

(transpose a)

generic transpose

cljs

typed->indexed clj/s≠

clj

(typed->indexed f basis)

cljs

typed->structure clj/s≠

clj

(typed->structure T basis)

cljs

typical-coords clj/s≠

clj

(typical-coords coordinate-system)

Given an [[ICoordinateSystem]], returns a structure that matches the [[coordinate-prototype]] of coordinate-system, with all unique, gensym-ed entries.

Use typical-coords if you require a unique symbolic coordinate representation compatible with coordinate-system.

See typical-point for a coordinate-free version of this function.

cljs

typical-point clj/s≠

clj

(typical-point coordinate-system)

Given an [[ICoordinateSystem]], returns a unique, symbolically-represented point on the manifold associated with coordinate-system.

See typical-coords for a coordinate-based version of this function.

cljs

up clj/s≠

clj

(up & xs)

Construct an up (contravariant) tuple from the arguments.

Variadic version of [[up*]].

cljs

up->column-matrix clj/s≠

clj

(up->column-matrix v)

Returns a column matrix with the contents of the supplied up structure. Errors if any other type is provided.

cljs

up? clj/s≠

clj

(up? s)

Returns true if s is an up structure, false otherwise.

cljs

using-coordinates clj/s macro

(using-coordinates & args)

v:c clj/s≠

clj

(v:c frame)

cljs

v:make-basis-unit clj/s≠

clj

(v:make-basis-unit i)

(v:make-basis-unit n i)

Returns a basis sequence of n 0s, with 1 in the ith position.

If n is not supplied returns an infinite sequence.

cljs

vector->down clj/s≠

clj

(vector->down v)

Form a down-tuple from a vector.

NOTE that this is an alias of [[down*]] that is more restrictive, in that it only accepts a vector. Use [[down*]] if you'd like to pass an arbitrary sequence. (If you pass a vector to [[down*]]) it will be just as efficient.

cljs

vector->up clj/s≠

clj

(vector->up v)

Form an up-tuple from a vector.

NOTE that this is an alias of [[up*]] that is more restrictive, in that it only accepts a vector. Use [[up*]] if you'd like to pass an arbitrary sequence. (If you pass a vector to [[up*]]) it will be just as efficient.

cljs

vector-basis->dual clj/s≠

clj

(vector-basis->dual vector-basis coordinate-system)

cljs

vector-field->basis-components clj/s≠

clj

(vector-field->basis-components vf dual-basis)

Given a vector field vf generated from basis-components->vector-field and a dual basis, returns the original basis components.

NOTE: You can generate a dual basis with [[basis/vector-basis->dual-basis]].

Here's an example of how to use this function to round trip a structure of basis components:

(let [basis (coordinate-system->vector-basis coordsys)
      dual  (basis/vector-basis->dual basis coordsys)]
  (= basis-components
     (-> basis-components
         (basis-components->vector-field basis)
         (vector-field->basis-components dual))))

cljs

vector-field->components clj/s≠

clj

(vector-field->components vf coordinate-system)

Given a vector field vf and a coordinate-system, returns a function from the coordinate representation of a manifold point to a coordinate representation of the coordinatized components of the vector field at that point.

For example:

(let-coordinates [[x y] R2-rect]
  (let [f (literal-vector-field 'f R2-rect)]
      ((vector-field->components f R2-rect)
       (up 'x0 'y0))))

;;=> (up (f↑0 (up x0 y0))
;;       (f↑1 (up x0 y0)))

cljs

vector-field->oneform-field clj/s≠

clj

Alias for lower.

vector-field->vector-field-over-map clj/s≠

clj

(vector-field->vector-field-over-map mu:N->M)

Defined on FDG p.72.

cljs

vector-field? clj/s≠

clj

(vector-field? vf)

Returns true if the supplied argument vf is a vector field operator, false otherwise.

cljs

vector:generate clj/s≠

clj

(vector:generate n f)

Generates a new vector of length n by applying the function f to integers in the range $[0,n)$.

cljs

velocity clj/s≠

clj

(velocity local)

Returns the velocity element of a local tuple (by convention, the third element).

See coordinate for more detail.

cljs

velocity-tuple clj/s

vf:zero clj/s≠

clj

(vf:zero _)

Returns a vector field that returns, for any supplied function f, a manifold function [[manifold/zero-manifold-function]] that maps every input manifold point to the scalar value 0.

cljs

wcross->w clj/s≠

clj

(wcross->w A)

cljs

wedge clj/s≠

clj

(wedge)

(wedge f)

(wedge f & fs)

Computes the wedge product of the sequence fs of one-forms.

Higher rank forms can be constructed from one-forms by wedging them together. This antisymmetric tensor product is computed as a determinant. The purpose of this is to allow us to use the construction dx^dy to compute the area described by the vectors that are given to it.

See Spivak p275 v1 of 'Differential Geometry' to see the correct definition. The key is that the wedge of the coordinate basis forms had better be the volume element.

cljs

with-argument-types clj/s≠

clj

(with-argument-types f types)

Given some operator or function f, returns a copy of f with the supplied argument types types registered in its metadata (if a function) or context (if an operator).

Retrieve these types with argument-types.

cljs

with-index-types clj/s≠

clj

(with-index-types f types)

Given some operator or function f, returns a copy of f with the supplied index types types registered in its metadata (if a function) or context (if an operator).

Retrieve these types with index-types.

cljs

with-literal-functions clj/s macro

(with-literal-functions & args)

zero-like clj/s≠

clj

(zero-like this)

cljs

zero-manifold-function clj/s≠

clj

(zero-manifold-function point)

Manifold function that maps every input manifold point to the scalar value 0.

cljs

zero? clj/s≠

clj

(zero? this)

cljs