sicmutils.env — net.littleredcomputer/sicmutils 0.12.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

(* & args)

+ clj

(+ & args)

- clj

(- & args)

->infix clj

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

->local clj

/ clj

(/ & args)

abs clj multimethod

generic abs

acos clj multimethod

generic acos

alternate-angles clj

angle clj

(angle a)

asin clj multimethod

generic asin

atan clj multimethod

generic atan

basis->basis-over-map clj

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

basis->oneform-basis clj

(basis->oneform-basis b)

Extract the dual basis from the given basis object.

basis->vector-basis clj

(basis->vector-basis b)

Extract the vector basis from the given basis object.

Cartan-transform clj

(Cartan-transform cartan basis-prime)

chart clj

(chart coordinate-system)

Christoffel->Cartan clj

(Christoffel->Cartan Christoffel)

column-matrix clj

commutator clj

(commutator o p)

compatible-shape clj

(compatible-shape s)

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

complex clj

(complex re)

(complex re im)

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

component clj

(component & indices)

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

components->oneform-field clj

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

components->vector-field clj

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

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

compositional-canonical? clj

(compositional-canonical? C H)

p.324

conjugate clj

(conjugate a)

coordinate 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

coordinate-system->basis clj

(coordinate-system->basis coordinate-system)

Return the standard basis object for the coordinate system.

coordinate-system->oneform-basis clj

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

coordinate-system->vector-basis clj

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

coordinate-tuple clj

(coordinate-tuple & xs)

coordinatize clj

(coordinatize v coordinate-system)

cos clj multimethod

generic cos

cot clj

covariant-derivative clj

(covariant-derivative Cartan)

(covariant-derivative Cartan map)

cross-product clj multimethod

generic cross-product

csc clj

cube clj multimethod

generic cube

d clj

D 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

(definite-integral f
                   a
                   b
                   &
                   {:keys [compile method max-evaluations relative-accuracy
                           absolute-accuracy min-iterations max-iterations
                           points]
                    :or {compile false
                         method :romberg
                         max-evaluations 32768
                         relative-accuracy 1.0E-6
                         absolute-accuracy 1.0E-15
                         min-iterations 3
                         max-iterations 32
                         points 16}})

determinant clj multimethod

generic determinant

differential clj

(differential mu:N->M)

FDG p.72

down clj

(down & xs)

Construct a down (covariant) tuple from the arguments.

elliptic-f clj

(elliptic-f phi k)

Euler-angles clj

Euler-Lagrange-operator clj

(Euler-Lagrange-operator L)

evolution clj

(evolution order)

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

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

exp clj multimethod

generic exp

expt clj multimethod

generic expt

F->C clj

(F->C F)

F->CT clj

(F->CT F)

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

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

form-field->form-field-over-map clj

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

Gamma clj

(Gamma q)

(Gamma q n)

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

Gamma-bar clj

(Gamma-bar f)

Hamilton-equations clj

(Hamilton-equations Hamiltonian)

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

Hamiltonian->state-derivative clj

(Hamiltonian->state-derivative Hamiltonian)

imag-part clj

(imag-part a)

integrate-state-derivative 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

interior-product clj

(interior-product V)

invert clj multimethod

generic invert

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

Jacobian clj

(Jacobian to-basis from-basis)

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

Lagrange-equations clj

(Lagrange-equations Lagrangian)

Lagrange-equations-first-order clj

(Lagrange-equations-first-order L)

Lagrange-interpolation-function clj

(Lagrange-interpolation-function ys xs)

Lagrangian->energy clj

(Lagrangian->energy L)

Lagrangian->Hamiltonian clj

Lagrangian->state-derivative clj

(Lagrangian->state-derivative L)

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

Lagrangian-action clj

(Lagrangian-action L q t1 t2)

Legendre-transform clj

let-coordinates clj macro

(let-coordinates bindings & body)

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

Lie-derivative clj multimethod

generic Lie-derivative

Lie-transform clj

(Lie-transform H t)

p. 428

linear-interpolants clj

(linear-interpolants x0 x1 n)

literal-function clj macro

(literal-function f)

(literal-function f sicm-signature)

(literal-function f domain range)

literal-manifold-function clj

(literal-manifold-function name coordinate-system)

literal-manifold-map clj

(literal-manifold-map name source target)

literal-oneform-field clj

(literal-oneform-field name coordinate-system)

literal-vector-field clj

(literal-vector-field name coordinate-system)

log clj multimethod

generic log

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

m:dimension clj

m:transpose clj

magnitude clj multimethod

generic magnitude

make-Christoffel clj

(make-Christoffel symbols basis)

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

matrix-by-rows clj

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

momentum clj

(momentum H-state)

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

momentum-tuple clj

(momentum-tuple & ps)

negate clj multimethod

generic negate

orientation clj

(orientation s)

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

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

p->r clj

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

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

partial clj

(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

point clj

(point coordinate-system)

Poisson-bracket clj

(Poisson-bracket f g)

polar-canonical clj

(polar-canonical alpha)

p.327

principal-value clj

print-expression clj

pullback clj

(pullback mu:N->M)

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

pushforward-vector clj

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

qp-submatrix clj

R1-rect clj

R2-polar clj

R2-rect clj

R3-cyl clj

R3-rect clj

real-part clj

(real-part a)

ref clj

(ref a & as)

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

Rx clj

(Rx α)

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

Ry clj

(Ry α)

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

Rz clj

(Rz α)

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

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

s->r clj

(s->r [_ [r θ φ] _])

SICM p. 83

S2-Riemann clj

S2-spherical clj

S2-stereographic clj

sec clj

series clj

series:sum clj

sicmutils-repl-init clj

(sicmutils-repl-init)

simplify clj multimethod

sin clj multimethod

generic sin

SO3 clj

sqrt clj multimethod

generic sqrt

square clj multimethod

generic square

standard-map clj

(standard-map K)

state-advancer 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 the initial state, target time, and error tolerance as arguments. The final state is returned. 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.

structure->vector clj

(structure->vector s)

Return the structure in unoriented vector form.

structure? clj

(structure? s)

True if s is a structure.

symplectic-transform? clj

(symplectic-transform? C)

p. 334

symplectic-unit clj

(symplectic-unit n)

p. 334 (used, but not defined there)

tan clj multimethod

generic tan

tex$ clj

(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

(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

(time-independent-canonical? C)

p.326

transpose clj multimethod

generic transpose

up clj

(up & xs)

Construct an up (contravariant) tuple from the arguments.

up? clj

(up? s)

True if s in an up structure.

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

(vector->down v)

Form a down-tuple from a vector.

vector->up clj

(vector->up v)

Form an up-tuple from a vector.

vector-basis->dual clj

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

vector-field->components clj

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

vector-field->vector-field-over-map clj

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

FDG p.72

velocity clj

(velocity local)

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

velocity-tuple clj

wedge clj

(wedge & fs)

with-literal-functions clj macro

(with-literal-functions & args)

zero? clj

Γ clj

∂ clj

(∂ & selectors)

Partial differentiation of a function at the (zero-based) slot index provided.