sicmutils.env — sicmutils 0.16.0

Batteries-included namespace for the SICMUtils library.

The purpose of sicmutils.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 sicmutils.env into your REPL:

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

Or, in Clojure:

(require '[sicmutils.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 #sicm/complex "3 + 1i")
;;=> #sicm/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])
;;=> ([[structure/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])
;;=> ([[structure/up]] -1 -1 -1)

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

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

->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)
([[structure/up]] 1 2 3)

cljs

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

cljs

acosh clj/s≠ multimethod

clj

(acosh a)

generic acosh

cljs

alternate-angles clj/s

angle clj/s≠ multimethod

clj

(angle a)

generic angle

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

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

asin clj/s≠ multimethod

clj

(asin a)

generic asin

cljs

asinh clj/s≠ multimethod

clj

(asinh a)

generic asinh

cljs

atan clj/s≠ multimethod

clj

(atan a)

(atan a b)

generic atan

cljs

atanh clj/s≠ multimethod

clj

(atanh a)

generic atanh

cljs

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

cljs

basis->vector-basis clj/s≠

clj

(basis->vector-basis b)

Extract the vector basis from the given basis object b.

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.

(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

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)

cljs

chinese-remainder clj/s≠

clj

(chinese-remainder & modints)

Chinese Remainder Algorithm.

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

For example:

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

cljs

Christoffel->Cartan clj/s≠

clj

(Christoffel->Cartan Christoffel)

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

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

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

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

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

clj

(coordinate-system->basis coordinate-system)

Returns the standard basis object for 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

coordinatize clj/s≠

clj

(coordinatize v coordinate-system)

cljs

cos clj/s≠ multimethod

clj

(cos a)

generic cos

cljs

cosh clj/s≠ multimethod

clj

(cosh a)

generic cosh

cljs

cot clj/s≠ multimethod

clj

(cot a)

generic cot

cljs

covariant-derivative clj/s≠

clj

(covariant-derivative Cartan)

(covariant-derivative Cartan map)

cljs

cross-product clj/s≠ multimethod

clj

(cross-product a b)

generic cross-product

cljs

csc clj/s≠ multimethod

clj

(csc a)

generic csc

cljs

csch clj/s≠ multimethod

clj

(csch a)

generic csch

cljs

cube clj/s≠ multimethod

clj

(cube a)

generic cube

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

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

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

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

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

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

clj

(exact-divide a b)

generic exact-divide.

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

cljs

exact? clj/s≠

clj

(exact? this)

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

expt clj/s≠ multimethod

clj

(expt a b)

generic expt

cljs

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

(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

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

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 (g/fractional-part -0.4))

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

(gcd a b)

generic gcd.

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

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.

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

I clj/s≠

clj

Identity function. Returns its argument.

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

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

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.

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

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.

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

clj

(Lie-derivative a)

generic Lie-derivative

cljs

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

(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, ie, $log_10(x)$.

cljs

log2 clj/s≠ multimethod

clj

(log2 a)

generic log2.

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

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 r c f)

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

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

clj

(make-Christoffel symbols basis)

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

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

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)

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

cljs

momentum-tuple clj/s

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

(negate a)

generic negate.

Returns the negation of a.

Equivalent to ([[-]] ([[value/zero-like]] a) a).

cljs

negative? clj/s≠ multimethod

clj

(negative? a)

generic negative?.

Returns true if the argument a is less than ([[value/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

numerical? clj/s≠

clj

(numerical? _)

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

(outer-product a b)

generic outer-product

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

pi clj/s

The mathematical constant Pi.

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≠

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

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≠

clj

(qp-submatrix m)

cljs

quotient clj/s≠ multimethod

clj

(quotient a b)

generic quotient

cljs

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

(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

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

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

cljs

sech clj/s≠ multimethod

clj

(sech a)

generic sech

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

sicmutils-repl-init clj

(sicmutils-repl-init)

simplify clj/s≠ multimethod

clj

(simplify a)

generic simplify

cljs

sin clj/s≠ multimethod

clj

(sin a)

generic sin

cljs

sinh clj/s≠ multimethod

clj

(sinh a)

generic sinh

cljs

SO3 clj/s

sqrt clj/s≠ multimethod

clj

(sqrt a)

generic sqrt

cljs

square clj/s≠ multimethod

clj

(square a)

generic square

cljs

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.

See coordinate for more detail.

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

(tan a)

generic tan

cljs

tanh clj/s≠ multimethod

clj

(tanh a)

generic tanh

cljs

taylor-series clj/s≠

clj

(taylor-series f x dx)

Returns a sicmutils.series/Series of the coefficients of the taylor series of the function f evaluated at x, with incremental quantity dx.

NOTE: The (constantly dx) term is what allows this to work with arbitrary structures of x and dx. Without this wrapper, ((g/* dx D) f) with dx == (up 'dx 'dy) would expand to this:

(fn [x] (* (s/up ('dx x) ('dy x))
           ((D f) x)))

constantly delays the interpretation of dx one step:

(fn [x] (* (s/up 'dx 'dy)
           ((D f) x)))

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.

time-independent-canonical? clj/s≠

clj

(time-independent-canonical? C)

p.326

cljs

trace clj/s≠ multimethod

clj

(trace a)

generic trace

cljs

transpose clj/s≠ multimethod

clj

(transpose a)

generic transpose

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

Defined on 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)

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

See coordinate for more detail.

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

Γ-bar clj/s