sicmutils.generic — sicmutils 0.19.0

The home of most of the SICMUtils extensible generic operations. The bulk of the others live in sicmutils.value.

See the Generics cljdocs for a detailed discussion of how to use and extend the generic operations defined in sicmutils.generic and sicmutils.value.

* clj/s

(*)

(* 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"

+ clj/s

(+)

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

- clj/s

(-)

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

/ clj/s

(/)

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

abs clj/s multimethod

(abs a)

generic abs

acos clj/s multimethod

(acos a)

generic acos

acosh clj/s multimethod

(acosh a)

generic acosh

angle clj/s multimethod

(angle a)

generic angle

asin clj/s multimethod

(asin a)

generic asin

asinh clj/s multimethod

(asinh a)

generic asinh

atan clj/s multimethod

(atan a)

(atan a b)

generic atan

atanh clj/s multimethod

(atanh a)

generic atanh

ceiling clj/s multimethod

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

conjugate clj/s multimethod

(conjugate a)

generic conjugate

cos clj/s multimethod

(cos a)

generic cos

cosh clj/s multimethod

(cosh a)

generic cosh

cot clj/s multimethod

(cot a)

generic cot

cross-product clj/s multimethod

(cross-product a b)

generic cross-product

csc clj/s multimethod

(csc a)

generic csc

csch clj/s multimethod

(csch a)

generic csch

cube clj/s multimethod

(cube a)

generic cube

determinant clj/s multimethod

(determinant a)

generic determinant

dimension clj/s multimethod

(dimension a)

generic dimension

div clj/s multimethod

(div a b)

generic div.

Returns the result of dividing a and b.

Equivalent to (* a (negate b)).

See / for a variadic version of div.

divide clj/s

Alias for /.

dot-product clj/s multimethod

(dot-product a b)

generic dot-product

exact-divide clj/s multimethod

(exact-divide a b)

generic exact-divide.

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

exp clj/s multimethod

(exp a)

generic exp.

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

exp10 clj/s multimethod

(exp10 a)

generic exp10.

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

exp2 clj/s multimethod

(exp2 a)

generic exp2.

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

expt clj/s multimethod

(expt a b)

generic expt

factorial clj/s

(factorial n)

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

floor clj/s multimethod

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

fractional-part clj/s multimethod

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

gcd clj/s multimethod

(gcd a b)

generic gcd.

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

imag-part clj/s multimethod

(imag-part a)

generic imag-part

inner-product clj/s multimethod

(inner-product a b)

generic inner-product

integer-part clj/s multimethod

(integer-part a)

generic integer-part.

Returns the integer part of a by removing any fractional digits.

invert clj/s multimethod

(invert a)

generic invert.

Returns the multiplicative inverse of a.

Equivalent to (/ 1 a).

lcm clj/s multimethod

(lcm a b)

generic lcm.

Returns the least common multiple of the two inputs a and b.

Lie-derivative clj/s multimethod

(Lie-derivative a)

generic Lie-derivative

log clj/s multimethod

(log a)

generic log.

Returns the natural logarithm of x.

log10 clj/s multimethod

(log10 a)

generic log10.

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

log2 clj/s multimethod

(log2 a)

generic log2.

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

magnitude clj/s multimethod

(magnitude a)

generic magnitude

make-polar clj/s multimethod

(make-polar a b)

generic make-polar

make-rectangular clj/s multimethod

(make-rectangular a b)

generic make-rectangular

modulo clj/s multimethod

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

negate clj/s multimethod

(negate a)

generic negate.

Returns the negation of a.

Equivalent to (- (v/zero-like a) a).

negative? clj/s multimethod

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

outer-product clj/s multimethod

(outer-product a b)

generic outer-product

partial-derivative clj/s multimethod

(partial-derivative a b)

generic partial-derivative

quotient clj/s multimethod

(quotient a b)

generic quotient

real-part clj/s multimethod

(real-part a)

generic real-part

remainder clj/s multimethod

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

sec clj/s multimethod

(sec a)

generic sec

sech clj/s multimethod

(sech a)

generic sech

simplify clj/s multimethod

(simplify a)

generic simplify

sin clj/s multimethod

(sin a)

generic sin

sinh clj/s multimethod

(sinh a)

generic sinh

solve-linear clj/s multimethod

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

solve-linear-left clj/s

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

solve-linear-right clj/s multimethod

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

sqrt clj/s multimethod

(sqrt a)

generic sqrt

square clj/s multimethod

(square a)

generic square

tan clj/s multimethod

(tan a)

generic tan

tanh clj/s multimethod

(tanh a)

generic tanh

trace clj/s multimethod

(trace a)

generic trace

transpose clj/s multimethod

(transpose a)

generic transpose