sicmutils.numerical.quadrature.riemann

Liking cljdoc? Tell your friends :D

All platforms.

geometric-estimate-seq
incrementalize
left-integral
left-sequence
left-sequence**
lower-integral
lower-sequence
midpoint-sum
right-integral
right-sequence
Sn->S2n
upper-integral
upper-sequence
windowed-sum

geometric-estimate-seq^clj/s

(geometric-estimate-seq S-fn next-S-fn factor n0)

Accepts:

S-fn: a function of n that generates a numerical integral estimate from n slices of some region, and
next-S-fn: a function of (previous estimate, previous n) => new estimate
factor: the factor by which n increases for successive estimates
n0: the initial n to pass to S-fn

The new estimate returned b next-S-fn should be of factor * n slices.

Accepts:

- `S-fn`: a function of `n` that generates a numerical integral estimate from
`n` slices of some region, and
- `next-S-fn`: a function of (previous estimate, previous `n`) => new estimate
- `factor`: the factor by which `n` increases for successive estimates
- `n0`: the initial `n` to pass to `S-fn`

The new estimate returned b `next-S-fn` should be of `factor * n` slices.

source raw docstring

incrementalize^clj/s

(incrementalize S-fn next-S-fn factor n)

Function that generalizes the ability to create successively-refined estimates of an integral, given:

S-fn: a function of n that generates a numerical integral estimate from n slices of some region, and
next-S-fn: a function of (previous estimate, previous n) => new estimate
factor: the factor by which next-S-fn increases n in its returned estimate
n: EITHER a number, or a monotonically increasing sequence of n slices to use.

If n is a sequence, returns a (lazy) sequence of estimates generated for each entry in n.

If n is a number, returns a lazy sequence of estimates generated for each entry in a geometrically increasing series of inputs $n, n(factor), n(factor^2), ....$

Internally decides whether or not to use S-fn or next-S-fn to generate successive estimates.

Function that generalizes the ability to create successively-refined estimates
of an integral, given:

- `S-fn`: a function of `n` that generates a numerical integral estimate from
`n` slices of some region, and
- `next-S-fn`: a function of (previous estimate, previous `n`) => new estimate
- `factor`: the factor by which `next-S-fn` increases `n` in its returned estimate
- `n`: EITHER a number, or a monotonically increasing sequence of `n` slices to use.

If `n` is a sequence, returns a (lazy) sequence of estimates generated for
each entry in `n`.

If `n` is a number, returns a lazy sequence of estimates generated for each
entry in a geometrically increasing series of inputs $n, n(factor),
n(factor^2), ....$

Internally decides whether or not to use `S-fn` or `next-S-fn` to generate
successive estimates.

source raw docstring

left-integral^clj/s

(left-integral f a b)

(left-integral f a b opts)

Returns an estimate of the integral of f across the closed-open interval $a, b$ using a left-Riemann sum with $1, 2, 4 ... 2^n$ windows for each estimate.

Optionally accepts opts, a dict of optional arguments. All of these get passed on to us/seq-limit to configure convergence checking.

See left-sequence for information on the optional args in opts that customize this function's behavior.

Returns an estimate of the integral of `f` across the closed-open interval $a,
b$ using a left-Riemann sum with $1, 2, 4 ... 2^n$ windows for each estimate.

Optionally accepts `opts`, a dict of optional arguments. All of these get
passed on to `us/seq-limit` to configure convergence checking.

See `left-sequence` for information on the optional args in `opts` that
customize this function's behavior.

source raw docstring

left-sequence^clj/s

(left-sequence f a b)

(left-sequence f a b opts)

Returns a (lazy) sequence of successively refined estimates of the integral of f over the closed-open interval $a, b$ by taking left-Riemann sums.

Optional Arguments

:n: If n is a number, returns estimates with $n, 2n, 4n, ...$ slices, geometrically increasing by a factor of 2 with each estimate.

If n is a sequence, the resulting sequence will hold an estimate for each integer number of slices in that sequence.

:accelerate?: if supplied (and n is a number), attempts to accelerate convergence using Richardson extrapolation. If n is a sequence this option is ignored.

Returns a (lazy) sequence of successively refined estimates of the integral of
`f` over the closed-open interval $a, b$ by taking left-Riemann sums.

## Optional Arguments

`:n`: If `n` is a number, returns estimates with $n, 2n, 4n, ...$ slices,
geometrically increasing by a factor of 2 with each estimate.

If `n` is a sequence, the resulting sequence will hold an estimate for each
integer number of slices in that sequence.

`:accelerate?`: if supplied (and `n` is a number), attempts to accelerate
convergence using Richardson extrapolation. If `n` is a sequence this option
is ignored.

source raw docstring

left-sequence**^clj/s

(left-sequence** f a b)

(left-sequence** f a b n0)

Returns a (lazy) sequence of successively refined estimates of the integral of f over the closed-open interval $a, b$ by taking left-Riemann sums with

n0, 2n0, 4n0, ...

slices.

Returns a (lazy) sequence of successively refined estimates of the integral of
`f` over the closed-open interval $a, b$ by taking left-Riemann sums with

n0, 2n0, 4n0, ...

slices.

source raw docstring

lower-integral^clj/s

(lower-integral f a b)

(lower-integral f a b opts)

Returns an estimate of the integral of f across the closed-open interval $a, b$ using a lower-Riemann sum with $1, 2, 4 ... 2^n$ windows for each estimate.

Optionally accepts opts, a dict of optional arguments. All of these get passed on to us/seq-limit to configure convergence checking.

See lower-sequence for information on the optional args in opts that customize this function's behavior.

Returns an estimate of the integral of `f` across the closed-open interval $a,
b$ using a lower-Riemann sum with $1, 2, 4 ... 2^n$ windows for each estimate.

Optionally accepts `opts`, a dict of optional arguments. All of these get
passed on to `us/seq-limit` to configure convergence checking.

See `lower-sequence` for information on the optional args in `opts` that
customize this function's behavior.

source raw docstring

lower-sequence^clj/s

(lower-sequence f a b)

(lower-sequence f a b {:keys [n] :or {n 1} :as opts})

Returns a (lazy) sequence of successively refined estimates of the integral of f over the closed interval $(a, b)$ by taking lower-Riemann sums.

Optional Arguments

:n: If n is a number, returns estimates with $n, 2n, 4n, ...$ slices, geometrically increasing by a factor of 2 with each estimate.

If n is a sequence, the resulting sequence will hold an estimate for each integer number of slices in that sequence.

:accelerate?: if supplied (and n is a number), attempts to accelerate convergence using Richardson extrapolation. If n is a sequence this option is ignored.

Returns a (lazy) sequence of successively refined estimates of the integral of
`f` over the closed interval $(a, b)$ by taking lower-Riemann sums.

## Optional Arguments

`:n`: If `n` is a number, returns estimates with $n, 2n, 4n, ...$ slices,
geometrically increasing by a factor of 2 with each estimate.

If `n` is a sequence, the resulting sequence will hold an estimate for each
integer number of slices in that sequence.

`:accelerate?`: if supplied (and `n` is a number), attempts to accelerate
convergence using Richardson extrapolation. If `n` is a sequence this option
is ignored.

source raw docstring

midpoint-sum^clj/s

(midpoint-sum f a b)

Returns a function of n, some number of slices of the total integration range, that returns an estimate for the definite integral of $f$ over the range $(a, b)$ using midpoint estimates.

Returns a function of `n`, some number of slices of the total integration
range, that returns an estimate for the definite integral of $f$ over the
range $(a, b)$ using midpoint estimates.

source raw docstring

right-integral^clj/s

(right-integral f a b)

(right-integral f a b opts)

Returns an estimate of the integral of f across the closed-open interval $a, b$ using a right-Riemann sum with $1, 2, 4 ... 2^n$ windows for each estimate.

Optionally accepts opts, a dict of optional arguments. All of these get passed on to us/seq-limit to configure convergence checking.

See right-sequence for information on the optional args in opts that customize this function's behavior.

Returns an estimate of the integral of `f` across the closed-open interval $a,
b$ using a right-Riemann sum with $1, 2, 4 ... 2^n$ windows for each estimate.

Optionally accepts `opts`, a dict of optional arguments. All of these get
passed on to `us/seq-limit` to configure convergence checking.

See `right-sequence` for information on the optional args in `opts` that
customize this function's behavior.

source raw docstring

right-sequence^clj/s

(right-sequence f a b)

(right-sequence f a b opts)

Returns a (lazy) sequence of successively refined estimates of the integral of f over the closed-open interval $a, b$ by taking right-Riemann sums.

Optional Arguments

:n: If n is a number, returns estimates with $n, 2n, 4n, ...$ slices, geometrically increasing by a factor of 2 with each estimate.

If n is a sequence, the resulting sequence will hold an estimate for each integer number of slices in that sequence.

:accelerate?: if supplied (and n is a number), attempts to accelerate convergence using Richardson extrapolation. If n is a sequence this option is ignored.

Returns a (lazy) sequence of successively refined estimates of the integral of
`f` over the closed-open interval $a, b$ by taking right-Riemann sums.

## Optional Arguments

`:n`: If `n` is a number, returns estimates with $n, 2n, 4n, ...$ slices,
geometrically increasing by a factor of 2 with each estimate.

If `n` is a sequence, the resulting sequence will hold an estimate for each
integer number of slices in that sequence.

`:accelerate?`: if supplied (and `n` is a number), attempts to accelerate
convergence using Richardson extrapolation. If `n` is a sequence this option
is ignored.

source raw docstring

Sn->S2n^clj/s

(Sn->S2n f a b)

Returns a function of:

Sn: a sum estimate for n partitions, and
n: the number of partitions

And returns a new estimate for $S_{2n}$ by sampling the midpoints of each slice. This incremental update rule is valid for left and right Riemann sums, as well as the midpoint method.

Returns a function of:

- `Sn`: a sum estimate for `n` partitions, and
- `n`: the number of partitions

And returns a new estimate for $S_{2n}$ by sampling the midpoints of each
slice. This incremental update rule is valid for left and right Riemann sums,
as well as the midpoint method.

source raw docstring

upper-integral^clj/s

(upper-integral f a b)

(upper-integral f a b opts)

Returns an estimate of the integral of f across the closed-open interval $a, b$ using an upper-Riemann sum with $1, 2, 4 ... 2^n$ windows for each estimate.

Optionally accepts opts, a dict of optional arguments. All of these get passed on to us/seq-limit to configure convergence checking.

See upper-sequence for information on the optional args in opts that customize this function's behavior.

Returns an estimate of the integral of `f` across the closed-open interval $a,
b$ using an upper-Riemann sum with $1, 2, 4 ... 2^n$ windows for each estimate.

Optionally accepts `opts`, a dict of optional arguments. All of these get
passed on to `us/seq-limit` to configure convergence checking.

See `upper-sequence` for information on the optional args in `opts` that
customize this function's behavior.

source raw docstring

upper-sequence^clj/s

(upper-sequence f a b)

(upper-sequence f a b {:keys [n] :or {n 1} :as opts})

Returns a (lazy) sequence of successively refined estimates of the integral of f over the closed interval $(a, b)$ by taking upper-Riemann sums.

Optional Arguments

:n: If n is a number, returns estimates with $n, 2n, 4n, ...$ slices, geometrically increasing by a factor of 2 with each estimate.

If n is a sequence, the resulting sequence will hold an estimate for each integer number of slices in that sequence.

:accelerate?: if supplied (and n is a number), attempts to accelerate convergence using Richardson extrapolation. If n is a sequence this option is ignored.

Returns a (lazy) sequence of successively refined estimates of the integral of
`f` over the closed interval $(a, b)$ by taking upper-Riemann sums.

## Optional Arguments

`:n`: If `n` is a number, returns estimates with $n, 2n, 4n, ...$ slices,
geometrically increasing by a factor of 2 with each estimate.

If `n` is a sequence, the resulting sequence will hold an estimate for each
integer number of slices in that sequence.

`:accelerate?`: if supplied (and `n` is a number), attempts to accelerate
convergence using Richardson extrapolation. If `n` is a sequence this option
is ignored.

source raw docstring

windowed-sum^clj/s

(windowed-sum area-fn a b)

Takes:

area-fn, a function of the left and right endpoints of some integration slice
definite integration bounds a and b

and returns a function of n, the number of slices to use for an integration estimate.

area-fn should return an estimate of the area under some curve between the l and r bounds it receives.

Takes:

- `area-fn`, a function of the left and right endpoints of some integration
slice
- definite integration bounds `a` and `b`

and returns a function of `n`, the number of slices to use for an integration
estimate.

`area-fn` should return an estimate of the area under some curve between the
`l` and `r` bounds it receives.

source raw docstring

cljdoc is a website building & hosting documentation for Clojure/Script libraries

Keyboard shortcuts Report a problem cljdoc on GitHub

× close