sicmutils.env — net.littleredcomputer/sicmutils 0.13.0

The purpose of these definitions is to let the import of sicmutils.env bring all the functions in the book into scope without qualification, so you can just start working with examples.

* clj/s≠

clj

(* & args)

cljs

+ clj/s≠

clj

(+ & args)

cljs

- clj/s≠

clj

(- & args)

cljs

->infix clj/s≠

clj

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

->local clj/s

/ clj/s≠

clj

(/ & args)

cljs

abs clj/s≠ multimethod

clj

generic abs

acos clj/s≠ multimethod

clj

generic acos

alternate-angles clj/s

angle clj/s≠

clj

(angle a)

cljs

asin clj/s≠ multimethod

clj

generic asin

atan clj/s≠ multimethod

clj

generic atan

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

clj

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

cljs

basis->oneform-basis clj/s≠

clj

(basis->oneform-basis b)

Extract the dual basis from the given basis object.

cljs

basis->vector-basis clj/s≠

clj

(basis->vector-basis b)

Extract the vector basis from the given basis object.

cljs

bootstrap-repl! clj macro

(bootstrap-repl!)

Bootstraps a repl or Clojure namespace by requiring all public vars from sicmutils.env. From (This will only work at a repl in Clojurescript.)

Cartan-transform clj/s≠

clj

(Cartan-transform cartan basis-prime)

cljs

chart clj/s≠

clj

(chart coordinate-system)

cljs

Christoffel->Cartan clj/s≠

clj

(Christoffel->Cartan Christoffel)

cljs

column-matrix clj/s

commutator clj/s≠

clj

(commutator o p)

cljs

compatible-shape clj/s≠

clj

(compatible-shape s)

Return an object compatible for multiplication with the given one, with the slots filled with gensyms.

cljs

complex clj/s≠

clj

(complex re)

(complex re im)

Construct a complex number from real, or real and imaginary, components.

cljs

component clj/s≠

clj

(component & indices)

Given an access chain (a sequence of indices), return a function of structures that will retrieve that corresponding element.

cljs

components->oneform-field clj/s≠

clj

(components->oneform-field components coordinate-system & [name])

cljs

components->vector-field clj/s≠

clj

(components->vector-field components coordinate-system & [name])

cljs

compose clj/s≠

clj

(compose & fns)

Compose is like Clojure's standard comp, but for this system we like to know the arity of our functions, so that we can calculate their derivatives with structure, etc. The arity of a composition is simply the arity of its rightmost (that is, first to be applied) function term.

cljs

compositional-canonical? clj/s≠

clj

(compositional-canonical? C H)

p.324

cljs

conjugate clj/s≠

clj

(conjugate a)

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.) Returns the q element, which is expected to be a mapping from time to a structure of coordinates

cljs

coordinate-system->basis clj/s≠

clj

(coordinate-system->basis coordinate-system)

Return the standard basis object for the coordinate system.

cljs

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

clj

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

cljs

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

clj

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

cljs

coordinate-tuple clj/s≠

clj

(coordinate-tuple & xs)

cljs

coordinatize clj/s≠

clj

(coordinatize v coordinate-system)

cljs

cos clj/s≠ multimethod

clj

generic cos

cot clj/s

covariant-derivative clj/s≠

clj

(covariant-derivative Cartan)

(covariant-derivative Cartan map)

cljs

cross-product clj/s≠ multimethod

clj

generic cross-product

csc clj/s

cube clj/s≠ multimethod

clj

generic cube

d clj/s

D clj/s≠

clj

Derivative operator. Produces 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.

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. (Clojure only for now.) Defaults to false.

: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

determinant clj/s≠ multimethod

clj

generic determinant

differential clj/s≠

clj

(differential mu:N->M)

FDG p.72

cljs

down clj/s≠

clj

(down & xs)

Construct a down (covariant) tuple from the arguments.

cljs

elliptic-f clj/s≠

clj

(elliptic-f phi k)

cljs

Euler-angles clj/s

Euler-Lagrange-operator clj/s≠

clj

(Euler-Lagrange-operator L)

cljs

evolution clj/s≠

clj

(evolution order)

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

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

exp clj/s≠ multimethod

clj

generic exp

expt clj/s≠ multimethod

clj

generic expt

F->C clj/s≠

clj

(F->C F)

cljs

F->CT clj/s≠

clj

(F->CT F)

A transformation of configuration coordinates F to a procedure implementing a transformation of phase-space coordinates (p. 320)

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

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

clj

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

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

Hamilton-equations clj/s≠

clj

(Hamilton-equations Hamiltonian)

cljs

Hamiltonian clj/s≠

clj

(Hamiltonian & n)

Return SICM-style function signature for a Hamiltonian with n degrees of freedom (or 1 if n is not given). Useful for constructing Hamiltonian literal functions.

cljs

Hamiltonian->state-derivative clj/s≠

clj

(Hamiltonian->state-derivative Hamiltonian)

cljs

imag-part clj/s≠

clj

(imag-part a)

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 V)

cljs

invert clj/s≠ multimethod

clj

generic invert

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)

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

cljs

Lagrange-equations clj/s≠

clj

(Lagrange-equations Lagrangian)

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)

cljs

Lagrangian->energy clj/s≠

clj

(Lagrangian->energy L)

cljs

Lagrangian->Hamiltonian clj/s

Lagrangian->state-derivative clj/s≠

clj

(Lagrangian->state-derivative L)

The state derivative of a Lagrangian is a function carrying a state tuple to its time derivative.

cljs

Lagrangian-action clj/s≠

clj

(Lagrangian-action L q t1 t2)

cljs

Legendre-transform clj/s

let-coordinates clj macro

(let-coordinates bindings & body)

Example: (let-coordinates [[x y] R2-rect [r theta] R2-polar] body...)

Lie-derivative clj/s≠ multimethod

clj

generic Lie-derivative

Lie-transform clj/s≠

clj

(Lie-transform H t)

p. 428

cljs

linear-interpolants clj/s≠

clj

(linear-interpolants x0 x1 n)

cljs

literal-function clj/s macro

(literal-function f)

(literal-function f sicm-signature)

(literal-function f domain range)

literal-manifold-function clj/s≠

clj

(literal-manifold-function name coordinate-system)

cljs

literal-manifold-map clj/s≠

clj

(literal-manifold-map name source target)

cljs

literal-oneform-field clj/s≠

clj

(literal-oneform-field name coordinate-system)

cljs

literal-vector-field clj/s≠

clj

(literal-vector-field name coordinate-system)

cljs

log clj/s≠ multimethod

clj

generic log

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:dimension clj/s

m:transpose clj/s

magnitude clj/s≠ multimethod

clj

generic magnitude

make-Christoffel clj/s≠

clj

(make-Christoffel symbols basis)

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-rows clj/s

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 observe is supplied, will be invoked with the iteration count and the values of x and f(x) at each search step.

cljs

momentum clj/s≠

clj

(momentum H-state)

See coordinate: this returns the momentum element of a Hammilton state tuple (by convention, the element at index 2).

cljs

momentum-tuple clj/s≠

clj

(momentum-tuple & ps)

cljs

negate clj/s≠ multimethod

clj

generic negate

orientation clj/s≠

clj

(orientation s)

Return the orientation of s, either ::up or ::down.

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

p->r clj/s≠

clj

(p->r [_ [r φ]])

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

cljs

partial clj/s

(partial & selectors)

A shim. Dispatches to partial differentiation when all the arguments are integers; falls back to the core meaning (partial function application) otherwise.

pi clj/s

point clj/s≠

clj

(point 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

principal-value clj/s

print-expression clj/s

pullback clj/s≠

clj

(pullback mu:N->M)

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

cljs

pushforward-vector clj/s≠

clj

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

cljs

qp-submatrix clj/s

R1-rect clj/s

R2-polar clj/s

R2-rect clj/s

R3-cyl clj/s

R3-rect clj/s

real-part clj/s≠

clj

(real-part a)

cljs

ref clj/s

(ref a & as)

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

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 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 [_ [r θ φ] _])

SICM p. 83

cljs

S2-Riemann clj/s

S2-spherical clj/s

S2-stereographic clj/s

sec clj/s

series clj/s

series:sum clj/s

sicmutils-repl-init clj

(sicmutils-repl-init)

simplify clj/s multimethod

sin clj/s≠ multimethod

clj

generic sin

SO3 clj/s

sqrt clj/s≠ multimethod

clj

generic sqrt

square clj/s≠ multimethod

clj

generic square

standard-map clj/s≠

clj

(standard-map K)

cljs

state->t clj/s≠

clj

(state->t s)

Extract the time slot from a state tuple

cljs

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->vector clj/s≠

clj

(structure->vector s)

Return the structure in unoriented vector form.

cljs

structure? clj/s≠

clj

(structure? s)

True if s is a structure.

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

generic tan

tex$ clj/s

(tex$ expr)

Render expression in a form convenient for rendering with clojupyter. In this case, we want the TeX material wrapped with dollar signs.

tex$$ clj/s

(tex$$ expr)

Render expression in a form convenient for rendering with clojupyter. In this case, we want the TeX material wrapped with dollar signs.

time-independent-canonical? clj/s≠

clj

(time-independent-canonical? C)

p.326

cljs

transpose clj/s≠ multimethod

clj

generic transpose

up clj/s≠

clj

(up & xs)

Construct an up (contravariant) tuple from the arguments.

cljs

up? clj/s≠

clj

(up? s)

True if s in an up structure.

cljs

using-coordinates clj macro

(using-coordinates coordinate-prototype coordinate-system & body)

Example: (using-coordinates (up x y) R2-rect body...)

Note: this is just a macro wrapping let-coordinates, the use of which is preferred.

vector->down clj/s≠

clj

(vector->down v)

Form a down-tuple from a vector.

cljs

vector->up clj/s≠

clj

(vector->up v)

Form an up-tuple from a vector.

cljs

vector-basis->dual clj/s≠

clj

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

cljs

vector-field->components clj/s≠

clj

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

cljs

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

clj

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

FDG p.72

cljs

velocity clj/s≠

clj

(velocity local)

See coordinate: this returns the velocity element of a local tuple (by convention, the 2nd element).

cljs

velocity-tuple clj/s

wedge clj/s≠

clj

(wedge & fs)

cljs

with-literal-functions clj/s macro

(with-literal-functions & args)

zero? clj/s

Γ clj/s