sicmutils.env — sicmutils 0.14.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

-pi clj/s

/ clj/s≠

clj

(/ & args)

cljs

abs clj/s≠ multimethod

clj

generic abs

acos clj/s≠ multimethod

clj

generic acos

acosh clj/s≠ multimethod

clj

generic acosh

alternate-angles clj/s

angle clj/s≠ multimethod

clj

generic angle

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

arity clj/s≠

clj

(arity f)

Return the cached or obvious arity of the object if we know it. Otherwise delegate to the heavy duty reflection, if we have to.

cljs

asin clj/s≠ multimethod

clj

generic asin

asinh clj/s≠ multimethod

clj

generic asinh

atan clj/s≠ multimethod

clj

generic atan

atanh clj/s≠ multimethod

clj

generic atanh

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

binomial-series clj/s≠

clj

(binomial-series alpha)

Returns a PowerSeries instance representing a Binomial series, ie, the taylor series of the function $f$ given by

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

cljs

bootstrap-repl! clj/s 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.)

TODO add support for refer-macros 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-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

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

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

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 that accepts a structure and returns the element at the specified access chain.

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≠ multimethod

clj

generic conjugate

constant-series clj/s

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

cosh clj/s≠ multimethod

clj

generic cosh

cot clj/s≠ multimethod

clj

generic cot

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≠ multimethod

clj

generic csc

csch clj/s≠ multimethod

clj

generic csch

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.

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

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

derivative clj/s≠

clj

(derivative f)

cljs

determinant clj/s≠ multimethod

clj

generic determinant

differential clj/s≠

clj

(differential mu:N->M)

FDG p.72

cljs

dimension clj/s≠ multimethod

clj

generic dimension

dot-product clj/s≠ multimethod

clj

generic dot-product

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

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

exact? clj/s≠

clj

(exact? this)

cljs

exp clj/s≠ multimethod

clj

generic exp.

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

exp10 clj/s≠ multimethod

clj

generic exp10.

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

exp2 clj/s≠ multimethod

clj

generic exp2.

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

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

factorial clj/s≠

clj

(factorial n)

Returns the factorial of n, ie, the product of 1 to n inclusive.

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

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

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

generic gcd

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

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

identity-like clj/s≠

clj

(identity-like this)

cljs

identity? clj/s≠

clj

(identity? this)

cljs

imag-part clj/s≠ multimethod

clj

generic imag-part

inner-product clj/s≠ multimethod

clj

generic inner-product

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

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

lcm clj/s≠ multimethod

clj

generic lcm

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

clj

(literal-matrix sym nrows ncols)

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

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

clj

(literal-number x)

Returns its argument, wrapped in a marker type that responds to the generic operations registered in sicmutils.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, sicmutils 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)

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 name coordinate-system)

cljs

log clj/s≠ multimethod

clj

generic log.

Returns the natural logarithm of x.

log10 clj/s≠ multimethod

clj

generic log10.

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

log2 clj/s≠ multimethod

clj

generic log2.

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

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

magnitude clj/s≠ multimethod

clj

generic magnitude

make-Christoffel clj/s≠

clj

(make-Christoffel symbols basis)

cljs

make-polar clj/s≠ multimethod

clj

generic make-polar

make-rectangular clj/s≠ multimethod

clj

generic make-rectangular

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

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

multidimensional-minimize clj/s≠

clj

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

Entrypoint for multidimensional minimization routines.

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

cljs

negate clj/s≠ multimethod

clj

generic negate

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

numerical? clj/s≠

clj

(numerical? this)

cljs

one-like clj/s≠

clj

(one-like this)

cljs

one? clj/s≠

clj

(one? this)

cljs

orientation clj/s≠

clj

(orientation s)

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

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

generic outer-product

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.

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

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≠ multimethod

clj

generic real-part

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.

row-matrix clj/s

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

s:generate clj/s

sec clj/s≠ multimethod

clj

generic sec

sech clj/s≠ multimethod

clj

generic sech

seq:pprint clj/s

seq:print 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

sinh clj/s≠ multimethod

clj

generic sinh

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)

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

cljs

submatrix clj/s≠

clj

(submatrix m lowrow hirow lowcol hicol)

Returns the submatrix of m generated by taking

• rows from lowrow -> hirow,
• columns from lowcol -> hicol

cljs

sum clj/s≠

clj

(sum xs)

(sum f low high)

Sums either:

• a series xs of numbers, or
• the result of mapping function f to (range low high)

Using Kahan's summation trick behind the scenes to keep floating point errors under control.

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

tanh clj/s≠ multimethod

clj

generic tanh

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.

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

v:make-basis-unit clj/s

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

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)

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

clj

(zero-like this)

cljs

zero? clj/s≠

clj

(zero? this)

cljs

Γ clj/s