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])
Batteries-included namespace for the [SICMUtils](https://github.com/sicmutils/sicmutils/) library. The purpose of [[sicmutils.env]] is to bundle all of the functions used in [Structure and Interpretation of Classical Mechanics](https://tgvaughan.github.io/sicm/) and [Functional Differential Geometry](https://mitpress.mit.edu/books/functional-differential-geometry) into a single scope. The following form will import everything from [[sicmutils.env]] into your REPL: ```clojure (require '[sicmutils.env :as e]) (e/bootstrap-repl!) ``` Or, in Clojure: ```clojure (require '[sicmutils.env :as e :refer :all]) ```
(*)
(* 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"
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: ```clojure (* 2 #sicm/complex "3 + 1i") ;;=> #sicm/complex "6 + 2i" ```
(+)
(+ x)
(+ x y)
(+ x y & more)
Generic implementation of +
. Returns the sum of all supplied arguments. (+)
returns 0, the additive identity.
When applied between numbers, acts like clojure.core/+
. Dispatch is open,
however, making it possible to 'add' types wherever the behavior is
mathematically sound.
For example:
(+ [1 2 3] [2 3 4])
;;=> (up 3 5 7)
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: ```clojure (+ [1 2 3] [2 3 4]) ;;=> (up 3 5 7) ```
(-)
(- x)
(- x y)
(- x y & more)
Generic implementation of -
.
If one argument is supplied, returns the negation of a
. Else returns the
difference of the first argument a
and the sum of all remaining
arguments. (-)
returns 0.
When applied between numbers, acts like clojure.core/-
. Dispatch is open,
however, making it possible to 'subtract' types wherever the behavior is
mathematically sound.
For example:
(- [1 2 3] [2 3 4])
;;=> (up -1 -1 -1)
(- [1 10])
;;=> (up -1 -10)
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: ```clojure (- [1 2 3] [2 3 4]) ;;=> (up -1 -1 -1) (- [1 10]) ;;=> (up -1 -10) ```
Converts an S-expression to printable infix form. Numeric exponents are written as superscripts. Partial derivatives get subscripts.
Converts an S-expression to printable infix form. Numeric exponents are written as superscripts. Partial derivatives get subscripts.
(->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.
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.
The negation of the mathematical constant Pi.
The negation of the mathematical constant [Pi](https://en.wikipedia.org/wiki/Pi).
(/)
(/ x)
(/ x y)
(/ x y & more)
Generic implementation of /
.
If one argument is supplied, returns the multiplicative inverse of a
. Else
returns the result of dividing first argument a
by the product of all
remaining arguments. (/)
returns 1, the multiplicative identity.
When applied between numbers, acts like clojure.core//
. Dispatch is open,
however, making it possible to 'divide' types wherever the behavior is
mathematically sound.
For example:
(/ [2 4 6] 2)
;;=> (up 1 2 3)
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: ```clojure (/ [2 4 6] 2) ;;=> (up 1 2 3) ```
(acceleration local)
Returns the acceleration element of a local tuple (by convention, the fourth element).
See coordinate
for more detail.
Returns the acceleration element of a local tuple (by convention, the fourth element). See [[coordinate]] for more detail.
(acos a)
generic acos
generic acos
(acosh a)
generic acosh
generic acosh
(angle a)
generic angle
generic angle
(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
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. ```clojure ((arg-scale square 3) 4) ==> 144 ((arg-scale square 3 2 1) 4) ==> 144 ```
(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
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. ```clojure ((arg-shift square 3) 4) ==> 49 ((arg-shift square 3 2 1) 4) ==> 49 ```
(arity f)
Return the cached or obvious arity of f
if we know it. Otherwise
delegates to heavy duty reflection.
Return the cached or obvious arity of `f` if we know it. Otherwise delegates to heavy duty reflection.
(asin a)
generic asin
generic asin
(asinh a)
generic asinh
generic asinh
(atan a)
(atan a b)
generic atan
generic atan
(atanh a)
generic atanh
generic atanh
(basis->basis-over-map mu:N->M basis-on-M)
(basis->dimension b)
Extract the dimension from the given basis object b
.
Extract the dimension from the given basis object `b`.
(basis->oneform-basis b)
Extract the dual basis from the given basis object b
.
Extract the dual basis from the given basis object `b`.
(basis->vector-basis b)
Extract the vector basis from the given basis object b
.
Extract the vector basis from the given basis object `b`.
(basis? x)
Returns true if x
is a basis, false otherwise.
Returns true if `x` is a basis, false otherwise.
(bigint? x)
Returns true if the supplied x
is a BigInt
, false otherwise.
Returns true if the supplied `x` is a `BigInt`, false otherwise.
(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$$
Returns a [[PowerSeries]] instance representing a [Binomial series](https://en.wikipedia.org/wiki/Binomial_series), ie, the taylor series of the function $f$ given by ``` $$f(x) = (1 + x)^\alpha$$ ```
(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.
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 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.
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.
(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)
.
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](https://books.google.com/books?id=AITCAgAAQBAJ&q=Brent%E2%80%99s#v=onepage&q=Parabolic&f=false). 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)`.
(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.
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](https://cljdoc.org/d/sicmutils/sicmutils/CURRENT/doc/basics/generics) for more detail.
(chart coordinate-system)
Given an [[ICoordinateSystem]], returns a function from a point on the
coordinate system's manifold to the coordinate representation specified by the
supplied coordinate-system
.
Given an [[ICoordinateSystem]], returns a function from a point on the coordinate system's manifold to the coordinate representation specified by the supplied `coordinate-system`.
(chinese-remainder & modints)
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]
[Chinese Remainder Algorithm](https://en.wikipedia.org/wiki/Chinese_remainder_theorem). 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: ```clojure (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] ```
(column-matrix & xs)
Returns a column matrix populated by the supplied xs
. Variadic equivalent
to [[column*]].
Returns a column matrix populated by the supplied `xs`. Variadic equivalent to [[column*]].
(column-matrix->up m)
Returns the single column from the supplied column matrix as an up
. Errors if
some other type is supplied.
Returns the single column from the supplied column matrix as an `up`. Errors if some other type is supplied.
(column-matrix->vector m)
Returns the single column from the supplied column matrix as a vector. Errors if some other type is supplied.
Returns the single column from the supplied column matrix as a vector. Errors if some other type is supplied.
(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
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
(compatible-shape s)
Returns a structure compatible for multiplication with s
down to a scalar,
with the slots filled with gensyms.
Returns a structure compatible for multiplication with `s` down to a scalar, with the slots filled with gensyms.
(complex re)
(complex re im)
Returns a [[Complex]] number with the supplied real part re
and imaginary
part im
. im
defaults to 0.
Returns a [[Complex]] number with the supplied real part `re` and imaginary part `im`. `im` defaults to 0.
(complex? a)
Returns true if a
is an instance of [[Complex]], false otherwise.
Returns true if `a` is an instance of [[Complex]], false otherwise.
(component & selectors)
Given a sequence of selectors
, return a function that accepts some object x
and returns:
(apply ref x selectors)
Given a sequence of `selectors`, return a function that accepts some object `x` and returns: ```clojure (apply ref x selectors) ```
(components->oneform-field components coordinate-system & [name])
(components->vector-field components coordinate-system & [name])
(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
.
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`.
(compositional-canonical? C H)
p.324
p.324
(conjugate a)
generic conjugate
generic conjugate
(constant-manifold-function c)
Takes some constant c
and returns a manifold function that maps every input
manifold point
to c.
Takes some constant `c` and returns a manifold function that maps every input manifold `point` to `c.`
(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.
Returns a [[PowerSeries]] representing the supplied constant term. Optionally, pass `kind` of either `::series` or `::power-series` to specify the type of series returned.
(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.
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.
(coordinate-basis? x)
Returns true if x
is a coordinate basis, false otherwise.
Returns true if `x` is a coordinate basis, false otherwise.
(coordinate-system->basis coordinate-system)
Returns the standard basis object for coordinate-system
.
Returns the standard basis object for `coordinate-system`.
(coordinate-system->oneform-basis coordinate-system)
(coordinate-system->vector-basis coordinate-system)
(coordinate-system-at manifold coordinate-system-name patch-name)
Returns an [[ICoordinateSystem]] instance specialized to the patch named
patch-name
on manifold
.
Returns an [[ICoordinateSystem]] instance specialized to the patch named `patch-name` on `manifold`.
(coordinate-system-names patch)
Returns a set of names of all coordinate system constructors registered in the supplied patch.
Returns a set of names of all coordinate system constructors registered in the supplied patch.
(corresponding-velocities coords)
Takes a coordinate representation coords
of a manifold point with all
symbolic entries, and returns a structure of the same shape with v:
prepended to all symbols.
This structure is appropriate for representing the velocities associated with each coordinate.
Takes a coordinate representation `coords` of a manifold point with all symbolic entries, and returns a structure of the same shape with `v:` prepended to all symbols. This structure is appropriate for representing the velocities associated with each coordinate.
(cosh a)
generic cosh
generic cosh
(covariant-derivative Cartan)
(covariant-derivative Cartan map)
(cross-product a b)
generic cross-product
generic cross-product
(csch a)
generic csch
generic csch
(cube a)
generic cube
generic cube
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$.
Operator that takes a function `f` and returns a function that calculates the [Curl](https://en.wikipedia.org/wiki/Curl_(mathematics)) of `f` at its input point. `f` must be a function from $\mathbb{R}^3 \to \mathbb{R}^3$.
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.
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](https://en.wikipedia.org/wiki/Jacobian_matrix_and_determinant) 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 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.
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?
)
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.
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`: ```clojure {: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.
(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.
:method
: Specifies the integration method used. Must be
available-methods
:method
keyDefaults 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.
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.
(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.
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.
(determinant a)
generic determinant
generic determinant
(differential mu:N->M)
Defined on FDG p.72.
Defined on FDG p.72.
(dimension a)
generic dimension
generic dimension
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.
Operator that takes a function `f` and returns a function that calculates the [Divergence](https://en.wikipedia.org/wiki/Divergence) of `f` at its input point. The divergence is a one-level contraction of the gradient.
(dot-product a b)
generic dot-product
generic dot-product
(down & xs)
Construct a down (covariant) tuple from the arguments. Variadic version of [[down*]].
Construct a down (covariant) tuple from the arguments. Variadic version of [[down*]].
(down->row-matrix v)
Returns a row matrix with the contents of the supplied down
structure.
Errors if any other type is provided.
Returns a row matrix with the contents of the supplied `down` structure. Errors if any other type is provided.
(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.
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](http://phys.uri.edu/nigh/NumRec/bookfpdf/f6-11.pdf).
The mathematical constant e, sometimes known as Euler's Number.
The mathematical constant [e](https://en.wikipedia.org/wiki/E_(mathematical_constant)), sometimes known as Euler's Number.
(evolution order)
We can use the coordinatized vector field to build an evolution along an integral curve.
We can use the coordinatized vector field to build an evolution along an integral curve.
(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.
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.
(exact-divide a b)
generic exact-divide.
Similar to the binary case of /
, but throws if (v/exact? <result>)
returns false.
generic exact-divide. Similar to the binary case of [[/]], but throws if `(v/exact? <result>)` returns false.
(exp a)
generic exp.
Returns the base-e exponential of x
. Equivalent to (expt e x)
, given
some properly-defined e
symbol.
generic exp. Returns the base-e exponential of `x`. Equivalent to `(expt e x)`, given some properly-defined `e` symbol.
(exp10 a)
generic exp10.
Returns the base-10 exponential of x
. Equivalent to (expt 10 x)
.
generic exp10. Returns the base-10 exponential of `x`. Equivalent to `(expt 10 x)`.
(exp2 a)
generic exp2.
Returns the base-2 exponential of x
. Equivalent to (expt 2 x)
.
generic exp2. Returns the base-2 exponential of `x`. Equivalent to `(expt 2 x)`.
(expression-of expr)
If the supplied argument is a [[Literal]] (or a symbol, interpreted elsewhere as a numerical literal expression), returns the wrapped expression (or the symbol).
Else, returns expr
.
If the supplied argument is a [[Literal]] (or a symbol, interpreted elsewhere as a numerical literal expression), returns the wrapped expression (or the symbol). Else, returns `expr`.
(expt a b)
generic expt
generic expt
(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.
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.
(F->CT F)
A transformation of configuration coordinates F to a procedure implementing a transformation of phase-space coordinates (p. 320)
A transformation of configuration coordinates F to a procedure implementing a transformation of phase-space coordinates (p. 320)
(factorial n)
Returns the factorial of n
, ie, the product of 1 to n
(inclusive).
Returns the factorial of `n`, ie, the product of 1 to `n` (inclusive).
(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.
SICM p. 23. The optional parameter values is a callback which will report intermediate points of the minimization.
(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.
generic floor. Returns the largest integer less than or equal to `a`. Extensions beyond real numbers may behave differently; see the [Documentation site](https://cljdoc.org/d/sicmutils/sicmutils/CURRENT/doc/basics/generics) for more detail.
(form-field->form-field-over-map mu:N->M)
(fractional-part a)
generic fractional-part.
Returns the fractional part of the given value, defined as x - ⌊x⌋
.
For positive numbers, this is identical to (- a (integer-part a))
. For
negative a
, because floor
truncates toward negative infinity, you might
be surprised to find that fractional-part
returns the distance between a
and the next-lowest integer:
(= 0.6 (fractional-part -0.4))
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: ```clojure (= 0.6 (fractional-part -0.4)) ```
(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.
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.
(Gamma q)
(Gamma q n)
Gamma takes a path function (from time to coordinates) to a state function (from time to local tuple).
Gamma takes a path function (from time to coordinates) to a state function (from time to local tuple).
(gcd a b)
generic gcd.
Returns the greatest common
divisor of the two
inputs a
and b
.
generic gcd. Returns the [greatest common divisor](https://en.wikipedia.org/wiki/Greatest_common_divisor) of the two inputs `a` and `b`.
(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.
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.
(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.
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.
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.
Operator that takes a function `f` and returns a new function that calculates the [Gradient](https://en.wikipedia.org/wiki/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.
(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.
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 Hamiltonian)
Identity function. Returns its argument.
Identity function. Returns its argument.
(imag-part a)
generic imag-part
generic imag-part
(inner-product a b)
generic inner-product
generic inner-product
(integer-part a)
generic integer-part.
Returns the integer part of a
by removing any fractional digits.
generic integer-part. Returns the integer part of `a` by removing any fractional digits.
(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
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
(invert a)
generic invert.
Returns the multiplicative inverse of a
.
Equivalent to (/ 1 a)
.
generic invert. Returns the multiplicative inverse of `a`. Equivalent to `(/ 1 a)`.
(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.
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 to-basis from-basis)
Returns the Jacobian of transition from from-basis
to to-basis
.
The Jacobian is a structure of manifold functions. The outer index is the
from-basis index, so this structure can be multiplied by tuple of component
functions of a vector field relative to from-basis
to get component
functions for a vector field in to-basis
.
Returns the Jacobian of transition from `from-basis` to `to-basis`. The Jacobian is a structure of manifold functions. The outer index is the from-basis index, so this structure can be multiplied by tuple of component functions of a vector field relative to `from-basis` to get component functions for a vector field in `to-basis`.
(kind-predicate x)
Returns a predicate that returns true if its argument matches the supplied
kind-keyword k
, false otherwise.
Returns a predicate that returns true if its argument matches the supplied kind-keyword `k`, false otherwise.
(Lagrange-equations-first-order L)
(Lagrange-interpolation-function ys xs)
(Lagrangian->state-derivative L)
The state derivative of a Lagrangian is a function carrying a state tuple to its time derivative.
The state derivative of a Lagrangian is a function carrying a state tuple to its time derivative.
Operator that takes a function f
and returns a function that
calculates the Vector
Laplacian of
f
at its input point.
Operator that takes a function `f` and returns a function that calculates the [Vector Laplacian](https://en.wikipedia.org/wiki/Laplace_operator#Vector_Laplacian) of `f` at its input point.
(lcm a b)
generic lcm.
Returns the least common
multiple of the two
inputs a
and b
.
generic lcm. Returns the [least common multiple](https://en.wikipedia.org/wiki/Least_common_multiple) of the two inputs `a` and `b`.
(Lie-derivative a)
generic Lie-derivative
generic Lie-derivative
(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))
Generates a `down` structure of dimension `size` populated by symbolic entries, each prefixed by the supplied symbol `sym`. For example: ```clojure (= (literal-down 'x 3) (down 'x_0 'x_1 'x_2)) ```
(literal-function f)
(literal-function f sicm-signature)
(literal-function f domain range)
(literal-manifold-function sym coordinate-system)
Given a symbolic name sym
and an [[ICoordinateSystem]], returns a literal
function that maps coordinate-free manifold points to a scalar output.
Also aliased as literal-manifold-function
.
Given a symbolic name `sym` and an [[ICoordinateSystem]], returns a literal function that maps coordinate-free manifold points to a scalar output. Also aliased as [[literal-manifold-function]].
(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]))
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: ```clojure (= (literal-matrix 'x 2 2) (by-rows ['x_0↑0 'x_1↑0] ['x_0↑1 'x_1↑1])) ```
(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.
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 ```clojure (* 10 (literal-number 'x)) ``` is equivalent to ```clojure (* 10 'x) ``` If you pass an actual number, sicmutils will attempt to preserve exact values through various operations: ```clojure (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: ```clojure (g/+ 1 (g/cos (g/* 2 (literal-number 2.2)))) ;;=> 0.6926671300215806 ``` the system will go ahead and evaluate it.
(literal-oneform-field name coordinate-system)
(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))
Generates an `up` structure of dimension `size` populated by symbolic entries, each prefixed by the supplied symbol `sym`. For example: ```clojure (= (literal-up 'x 3) (up 'x↑0 'x↑1 'x↑2)) ```
(literal-vector-field name coordinate-system)
(log a)
generic log.
Returns the natural logarithm of x
.
generic log. Returns the natural logarithm of `x`.
(log10 a)
generic log10.
Returns the base-10 logarithm of x
, ie, $log_10(x)$.
generic log10. Returns the base-10 logarithm of `x`, ie, $log_10(x)$.
(log2 a)
generic log2.
Returns the base-2 logarithm of x
, ie, $log_2(x)$.
generic log2. Returns the base-2 logarithm of `x`, ie, $log_2(x)$.
(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.
Convert the matrix `m` into a structure `S`, guided by the requirement that `(* ls S rs)` should be a scalar.
(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 i
th row and j
-th column is (f i j)
.
Returns a matrix with `r` rows and `c` columns, whose entries are generated by the supplied function `f`. The entry in the `i`th row and `j`-th column is `(f i j)`.
(magnitude a)
generic magnitude
generic magnitude
(make-basis vector-basis dual-basis)
Make a basis object out of a vector and dual basis.
The dimensions of vector-basis
and dual-basis
must agree.
Make a basis object out of a vector and dual basis. The dimensions of `vector-basis` and `dual-basis` must agree.
(make-constant-vector-field basis m0)
(make-manifold family n)
(make-manifold family n embedding-dimension)
Returns a concrete manifold generated by specializing the supplied manifold
family
into a concrete manifold of dimension n
. n
must be a positive
integer.
Optionally takes an embedding-dimension
; this must be >= the value of n
.
Use this in cases like an n-sphere embedded in a euclidean space of dimension
n+1.
A manifold is a topological space that locally resembles Euclidean space near each point.
Returns a concrete manifold generated by specializing the supplied manifold `family` into a concrete manifold of dimension `n`. `n` must be a positive integer. Optionally takes an `embedding-dimension`; this must be >= the value of `n`. Use this in cases like an n-sphere embedded in a euclidean space of dimension n+1. A [manifold](https://en.wikipedia.org/wiki/Manifold) is a topological space that locally resembles Euclidean space near each point.
(make-polar a b)
generic make-polar
generic make-polar
(make-rectangular a b)
generic make-rectangular
generic make-rectangular
(manifold-point? p)
Returns true if p
is a manifold point, false otherwise.
Returns true if `p` is a manifold point, false otherwise.
(manifold-type manifold)
The supplied manifold m
locally resembles some vector space; this function
returns the field over which that vector space was specified.
The supplied manifold `m` locally resembles some vector space; this function returns the field over which that vector space was specified.
(mapr f & structures)
Return a structure with the same shape as s but with f applied to each primitive (that is, not structural) component.
Return a structure with the same shape as s but with f applied to each primitive (that is, not structural) component.
(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*]].
Returns a matrix whose columns consist of the supplied sequence of `cols`. These all must be the same length. Variadic equivalent to [[by-cols*]].
(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*]].
Returns a matrix whose rows consist of the supplied sequence of `rows`. These all must be the same length. Variadic equivalent to [[by-rows*]].
(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.
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.
(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
.
generic modulo. Returns the result of the mathematical [Modulo](https://en.wikipedia.org/wiki/Modulo_operation) operation between `a` and `b` (using the Knuth definition listed). The contract satisfied by [[modulo]] is: ```clojure (= 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`.
(momentum H-state)
See coordinate: this returns the momentum element of a Hammilton state tuple (by convention, the element at index 2).
See coordinate: this returns the momentum element of a Hammilton state tuple (by convention, the element at index 2).
(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.
Entrypoint for multidimensional minimization routines. See [[sicmutils.numerical.multimin.nelder-mead/nelder-mead]] for the only supported option.
(negate a)
generic negate.
Returns the negation of a
.
Equivalent to (- (v/zero-like a) a)
.
generic negate. Returns the negation of `a`. Equivalent to `(- (v/zero-like a) a)`.
(negative? a)
generic negative?.
Returns true if the argument a
is less than (v/zero-like a)
,
false otherwise. The default implementation depends on a proper Comparable
implementation on the type.`
generic negative?. Returns true if the argument `a` is less than `(v/zero-like a)`, false otherwise. The default implementation depends on a proper Comparable implementation on the type.`
(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.
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](https://github.com/scipy/scipy/blob/589c9afe41774ee96ec121f1867361146add8276/scipy/optimize/optimize.py#L556:5) which I have imitated here.
(one-manifold-function point)
Manifold function that maps every input manifold point
to the scalar value 1.
Manifold function that maps every input manifold `point` to the scalar value 1.
(orientation s)
Returns the orientation of s
, either ::up
or ::down
. Defaults to ::up
,
even for non-structures.
Returns the orientation of `s`, either `::up` or `::down`. Defaults to `::up`, even for non-structures.
(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.
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.
(outer-product a b)
generic outer-product
generic outer-product
(p->r [_ [r φ]])
SICM p. 47. Polar to rectangular coordinates of state.
SICM p. 47. Polar to rectangular coordinates of state.
(partial & selectors)
A shim. Dispatches to [[d/partial]] when all the arguments are integers; falls back to [[clojure.core/partial]] (partial function application) otherwise.
A shim. Dispatches to [[d/partial]] when all the arguments are integers; falls back to [[clojure.core/partial]] (partial function application) otherwise.
(partial-derivative a b)
generic partial-derivative
generic partial-derivative
(partial-sums s)
Returns a series (of the same type as the input) of partial sums of the terms
in the supplied series s
.
Returns a series (of the same type as the input) of partial sums of the terms in the supplied series `s`.
(patch-names manifold)
Returns a set of patch names registered in the supplied manifold.
Returns a set of patch names registered in the supplied manifold.
The mathematical constant 𝜑, also known as the Golden Ratio.
The mathematical constant [𝜑](https://en.wikipedia.org/wiki/Golden_ratio), also known as the Golden Ratio.
The mathematical constant Pi.
The mathematical constant [Pi](https://en.wikipedia.org/wiki/Pi).
(point coordinate-system)
Given an [[ICoordinateSystem]], returns a function from coordinates in
coordinate-system
's repesentation to the matching point on the manifold
associated with coordinate-system
.
Given an [[ICoordinateSystem]], returns a function from coordinates in `coordinate-system`'s repesentation to the matching point on the manifold associated with `coordinate-system`.
(polar-canonical alpha)
p.327
p.327
(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*]].
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*]].
(pushforward-vector mu:N->M mu-inverse:M->N)
(quotient a b)
generic quotient
generic quotient
(real-part a)
generic real-part
generic real-part
(ref a)
(ref a & ks)
A shim so that ref can act like nth in SICM contexts, as clojure core ref elsewhere.
A shim so that ref can act like nth in SICM contexts, as clojure core ref elsewhere.
(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
.
generic remainder. Returns the remainder of dividing the dividend `a` by divisor `b`. The contract satisfied by [[remainder]] is: ```clojure (= 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`.
(row-matrix & xs)
Returns a row matrix populated by the supplied xs
. Variadic equivalent
to [[row*]].
Returns a row matrix populated by the supplied `xs`. Variadic equivalent to [[row*]].
(row-matrix->down m)
Returns the single row from the supplied row matrix as a down
. Errors if some
other type is supplied.
Returns the single row from the supplied row matrix as a `down`. Errors if some other type is supplied.
(row-matrix->vector m)
Returns the single row from the supplied row matrix as a vector. Errors if some other type is supplied.
Returns the single row from the supplied row matrix as a vector. Errors if some other type is supplied.
(Rx α)
Returns a function which rotates a vector α radians about the x axis.
Returns a function which rotates a vector α radians about the x axis.
(Ry α)
Returns a function which rotates a vector α radians about the y axis.
Returns a function which rotates a vector α radians about the y axis.
(Rz α)
Returns a function which rotates a vector α radians about the z axis.
Returns a function which rotates a vector α radians about the z axis.
(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.
Convert the structure `ms`, which would be a scalar if the (compatible) multiplication`(* ls ms rs)` were performed, to a matrix.
Similar to the S2-spherical
coordinate system, with the north
pole rotated 90 degrees and lying along the positive y axis.
Similar to the [[S2-spherical]] coordinate system, with the north pole rotated 90 degrees and lying along the positive y axis.
(s:generate dimension orientation f)
Generate a structure with the given orientation
whose elements are
(f i)
where i ranges from [0..dimension)
.
Generate a structure with the given `orientation` whose elements are (f i) where i ranges from `[0..dimension)`.
(sech a)
generic sech
generic sech
(seq:pprint n xs)
Realizes, simplifies and pretty-prints n
elements from the supplied sequence
xs
.
Realizes, simplifies and pretty-prints `n` elements from the supplied sequence `xs`.
(seq:print n xs)
Realizes, simplifies and prints n
elements from the supplied sequence xs
.
Realizes, simplifies and prints `n` elements from the supplied sequence `xs`.
(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*]].
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*]].
(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.
Returns the sum of all elements in the input series `s` up to order `n` (inclusive). For example: ```clojure (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.
(simplify a)
generic simplify
generic simplify
(sinh a)
generic sinh
generic sinh
(solve-linear a b)
generic solve-linear.
For a given a
and b
, returns x
such that a*x = b
.
Seesolve-linear-right
for a similar function that solves for a = x*b
.
generic solve-linear. For a given `a` and `b`, returns `x` such that `a*x = b`. See[[solve-linear-right]] for a similar function that solves for `a = x*b`.
(solve-linear-left a b)
Alias for solve-linear
; present for compatibility with the original
scmutils
codebase.
NOTE: In scmutils
, solve-linear-left
and solve-linear
act identically in
all cases except matrices. solve-linear-left
only accepted a column
matrix (or up structure) in the b
position, while solve-linear
accepted
either a column or row (up or down structure).
In SICMUtils, both functions accept either type.
Alias for [[solve-linear]]; present for compatibility with the original `scmutils` codebase. NOTE: In `scmutils`, `solve-linear-left` and `solve-linear` act identically in all cases except matrices. `solve-linear-left` only accepted a column matrix (or up structure) in the `b` position, while `solve-linear` accepted either a column or row (up or down structure). In SICMUtils, both functions accept either type.
(solve-linear-right a b)
generic solve-linear-right.
For a given a
and b
, returns x
such that a = x*b
.
Seesolve-linear
for a similar function that solves for a*x = b
.
generic solve-linear-right. For a given `a` and `b`, returns `x` such that `a = x*b`. See[[solve-linear]] for a similar function that solves for `a*x = b`.
(sqrt a)
generic sqrt
generic sqrt
(square a)
generic square
generic square
(state->t s)
Extract the time slot from a state tuple.
See coordinate
for more detail.
Extract the time slot from a state tuple. See [[coordinate]] for more detail.
(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:
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.
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.
(structure->vector s)
Return the structure s
in unoriented vector form.
Return the structure `s` in unoriented vector form.
(structure? s)
Returns true
if s
is a structure, false otherwise. (Vectors are treated as
up structures.)
Returns `true` if `s` is a structure, false otherwise. (Vectors are treated as up structures.)
(submatrix m lowrow hirow lowcol hicol)
Returns the submatrix of m
generated by taking
lowrow
-> hirow
,lowcol
-> hicol
Returns the submatrix of `m` generated by taking - rows from `lowrow` -> `hirow`, - columns from `lowcol` -> `hicol`
(sum xs)
(sum f low high)
Sums either:
xs
of numbers, orf
to (range low high)
Using Kahan's summation trick behind the scenes to keep floating point errors under control.
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.
(sumr f & structures)
Given some function f
and any number of isomorphic structures
,
returns the sum of the results of applying f
to each associated set of
entries in each structure
.
Given some function `f` and any number of isomorphic `structures`, returns the sum of the results of applying `f` to each associated set of entries in each `structure`.
(symplectic-transform? C)
p. 334
p. 334
(symplectic-unit n)
p. 334 (used, but not defined there)
p. 334 (used, but not defined there)
(tanh a)
generic tanh
generic tanh
(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)))
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: ```clojure (fn [x] (* (s/up ('dx x) ('dy x)) ((D f) x))) ``` `constantly` delays the interpretation of `dx` one step: ```clojure (fn [x] (* (s/up 'dx 'dy) ((D f) x))) ```
(tex$ expr)
Returns a string containing a LaTeX representation of expr
, wrapped in single
$
to mark the string as an inline LaTeX form.
Returns a string containing a LaTeX representation of `expr`, wrapped in single `$` to mark the string as an inline LaTeX form.
(tex$$ expr)
Returns a string containing a LaTeX representation of expr
, wrapped in double
$$
to mark the string as a block LaTeX form.
Returns a string containing a LaTeX representation of `expr`, wrapped in double `$$` to mark the string as a block LaTeX form.
(time-independent-canonical? C)
p.326
p.326
(trace a)
generic trace
generic trace
(transfer-point embedded embedding)
Returns a function that takes a single manifold point
embedded in the
manifold embedded
and transfers the point to the supplied embedding
manifold.
The embedding dimension must be the same for both manifolds.
Returns a function that takes a single manifold `point` embedded in the manifold `embedded` and transfers the point to the supplied `embedding` manifold. The embedding dimension must be the same for both manifolds.
(transpose a)
generic transpose
generic transpose
(typical-coords coordinate-system)
Given an [[ICoordinateSystem]], returns a structure that matches
the [[coordinate-prototype]] of coordinate-system
, with all unique,
gensym-ed entries.
Use typical-coords
if you require a unique symbolic coordinate
representation compatible with coordinate-system
.
See typical-point
for a coordinate-free version of this function.
Given an [[ICoordinateSystem]], returns a structure that matches the [[coordinate-prototype]] of `coordinate-system`, with all unique, gensym-ed entries. Use [[typical-coords]] if you require a unique symbolic coordinate representation compatible with `coordinate-system`. See [[typical-point]] for a coordinate-free version of this function.
(typical-point coordinate-system)
Given an [[ICoordinateSystem]], returns a unique, symbolically-represented
point on the manifold associated with coordinate-system
.
See typical-coords
for a coordinate-based version of this function.
Given an [[ICoordinateSystem]], returns a unique, symbolically-represented point on the manifold associated with `coordinate-system`. See [[typical-coords]] for a coordinate-based version of this function.
(up & xs)
Construct an up (contravariant) tuple from the arguments.
Variadic version of [[up*]].
Construct an up (contravariant) tuple from the arguments. Variadic version of [[up*]].
(up->column-matrix v)
Returns a column matrix with the contents of the supplied up
structure.
Errors if any other type is provided.
Returns a column matrix with the contents of the supplied `up` structure. Errors if any other type is provided.
(up? s)
Returns true
if s
is an up structure, false otherwise.
Returns `true` if `s` is an up structure, false otherwise.
(v:make-basis-unit i)
(v:make-basis-unit n i)
Returns a basis sequence of n
0s, with 1
in the i
th position.
If n
is not supplied returns an infinite sequence.
Returns a basis sequence of `n` 0s, with `1` in the `i`th position. If `n` is not supplied returns an infinite sequence.
(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.
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.
(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.
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.
(vector-basis->dual vector-basis coordinate-system)
(vector-field->components vf coordinate-system)
(vector-field->vector-field-over-map mu:N->M)
Defined on FDG p.72.
Defined on FDG p.72.
(vector:generate n f)
Generates a new vector of length n
by applying the function f
to integers
in the range $[0,n)$.
Generates a new vector of length `n` by applying the function `f` to integers in the range $[0,n)$.
(velocity local)
Returns the velocity element of a local tuple (by convention, the third element).
See coordinate
for more detail.
Returns the velocity element of a local tuple (by convention, the third element). See [[coordinate]] for more detail.
(zero-manifold-function point)
Manifold function that maps every input manifold point
to the scalar value 0.
Manifold function that maps every input manifold `point` to the scalar value 0.
cljdoc is a website building & hosting documentation for Clojure/Script libraries
× close