emmy.generic

Liking cljdoc? Tell your friends :D

All platforms.

The home of most of the Emmy extensible generic operations. The bulk of the others live in emmy.value.

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

The home of most of the Emmy extensible generic operations. The bulk of
the others live in [[emmy.value]].

See [the `Generics`
cljdocs](https://cljdoc.org/d/org.mentat/emmy/CURRENT/doc/basics/generics)
for a detailed discussion of how to use and extend the generic operations
defined in [[emmy.generic]] and [[emmy.value]].

raw docstring

*^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 #emmy/complex "3 + 1i")
;;=> #emmy/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 #emmy/complex "3 + 1i")
;;=> #emmy/complex "6 + 2i"
```

source raw docstring

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

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

source raw docstring

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

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

source raw docstring

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

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

source raw docstring

abs^clj/smultimethod

(abs a)

generic abs

generic abs

source raw docstring

acos^clj/smultimethod

(acos a)

generic acos.

Computes the inverse cosine of the supplied argument a.

Defaults to atan(sqrt(1-x^2)/x).

generic acos.

Computes the inverse cosine of the supplied argument `a`.

Defaults to `atan(sqrt(1-x^2)/x)`.

source raw docstring

acosh^clj/smultimethod

(acosh a)

generic acosh.

Computes the inverse hyperbolic cosine of the supplied argument a.

defaults to 2 ln(sqrt((x+1)/2) + sqrt((x-1)/2)).

generic acosh.

Computes the [inverse hyperbolic
 cosine](https://mathworld.wolfram.com/InverseHyperbolicCosine.html) of the supplied
 argument `a`.

defaults to `2 ln(sqrt((x+1)/2) + sqrt((x-1)/2))`.

source raw docstring

acot^clj/smultimethod

(acot a)

generic acot.

Computes the inverse cotangent of the supplied argument a.

defaults to pi/2 - atan(x).

generic acot.

Computes the [inverse
 cotangent](https://mathworld.wolfram.com/InverseCotangent.html) of the supplied
 argument `a`.

defaults to `pi/2 - atan(x)`.

source raw docstring

acoth^clj/smultimethod

(acoth a)

generic acoth.

Computes the inverse hyperbolic cotangent of the supplied argument a.

defaults to 1/2 ln((x+1)/(x-1)).

generic acoth.

Computes the [inverse hyperbolic
 cotangent](https://mathworld.wolfram.com/InverseHyperbolicCotangent.html) of
 the supplied argument `a`.

defaults to `1/2 ln((x+1)/(x-1))`.

source raw docstring

acsc^clj/smultimethod

(acsc a)

generic acsc.

Computes the inverse cosecant of the supplied argument a.

defaults to atan(1 / sqrt(x^2 - 1)).

generic acsc.

Computes the [inverse
 cosecant](https://mathworld.wolfram.com/InverseCosecant.html) of the supplied
 argument `a`.

defaults to `atan(1 / sqrt(x^2 - 1))`.

source raw docstring

acsch^clj/smultimethod

(acsch a)

generic acsch.

Computes the inverse hyperbolic cosecant of the supplied argument a.

defaults to ln((1 + sqrt(1+x^2)) / x).

generic acsch.

Computes the [inverse hyperbolic
 cosecant](https://mathworld.wolfram.com/InverseHyperbolicCosecant.html) of the
 supplied argument `a`.

defaults to `ln((1 + sqrt(1+x^2)) / x)`.

source raw docstring

almost-integral?^clj/s

(almost-integral? x)

Returns true if x is either:

[[integral?]],
a floating point number either < [[absolute-integer-tolerance]] (if near zero) or within [[relative-integer-tolerance]] of the closest integer,

false otherwise.

Returns true if `x` is either:

- [[integral?]],
- a floating point number either < [[absolute-integer-tolerance]] (if near
  zero) or within [[relative-integer-tolerance]] of the closest integer,

false otherwise.

source raw docstring

angle^clj/smultimethod

(angle a)

generic angle

generic angle

source raw docstring

asec^clj/smultimethod

(asec a)

generic asec.

Computes the inverse secant of the supplied argument a.

defaults to atan(sqrt(x^2 - 1)).

generic asec.

Computes the [inverse
 secant](https://mathworld.wolfram.com/InverseSecant.html) of the supplied
 argument `a`.

defaults to `atan(sqrt(x^2 - 1))`.

source raw docstring

asech^clj/smultimethod

(asech a)

generic asech.

Computes the inverse hyperbolic secant of the supplied argument a.

defaults to ln((1 + sqrt(1-x^2)) / x).

generic asech.

Computes the [inverse hyperbolic
 secant](https://mathworld.wolfram.com/InverseHyperbolicSecant.html) of the
 supplied argument `a`.

defaults to `ln((1 + sqrt(1-x^2)) / x)`.

source raw docstring

asin^clj/smultimethod

(asin a)

generic asin.

Computes the inverse sine of the supplied argument a.

Defaults to atan(x/sqrt(1-x^2)).

generic asin.

Computes the inverse sine of the supplied argument `a`.

Defaults to `atan(x/sqrt(1-x^2))`.

source raw docstring

asinh^clj/smultimethod

(asinh a)

generic asinh.

Computes the inverse hyperbolic sine of the supplied argument a.

defaults to ln(x + sqrt(1 + x^2)).

generic asinh.

Computes the [inverse hyperbolic
 sine](https://mathworld.wolfram.com/InverseHyperbolicSine.html) of the
 supplied argument `a`.

defaults to `ln(x + sqrt(1 + x^2))`.

source raw docstring

atan^clj/smultimethod

(atan a)

(atan a b)

generic atan.

Computes the inverse tangent of the supplied argument a. Given two arguments a and b, returns the inverse tangent of the angle formed by the point (b, a) in a 2-dimensional euclidean plane.

The two-argument version is sometimes called Atan2.

generic atan.

Computes the inverse tangent of the supplied argument `a`. Given two
  arguments `a` and `b`, returns the inverse tangent of the angle formed by the
  point `(b, a)` in a 2-dimensional euclidean plane.

  The two-argument version is sometimes
  called [Atan2](https://en.wikipedia.org/wiki/Atan2).

source raw docstring

atanh^clj/smultimethod

(atanh a)

generic atanh.

Computes the inverse hyperbolic tangent of the supplied argument a.

defaults to 1/2 ln((1+x)/(1-x)).

generic atanh.

Computes the [inverse hyperbolic
 tangent](https://mathworld.wolfram.com/InverseHyperbolicTangent.html) of the
 supplied argument `a`.

defaults to `1/2 ln((1+x)/(1-x))`.

source raw docstring

ceiling^clj/smultimethod

(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/org.mentat/emmy/CURRENT/doc/basics/generics)
  for more detail.

source raw docstring

conjugate^clj/smultimethod

(conjugate a)

generic conjugate

generic conjugate

source raw docstring

cos^clj/smultimethod

(cos a)

generic cos.

Returns the cosine of the supplied argument a.

generic cos.

Returns the [cosine](https://en.wikipedia.org/wiki/Sine_and_cosine) of the
  supplied argument `a`.

source raw docstring

cosh^clj/smultimethod

(cosh a)

generic cosh.

Computes the hyperbolic cosine of the supplied argument a.

defaults to (e^x + e^{-x}) / 2.

generic cosh.

Computes the [hyperbolic
 cosine](https://mathworld.wolfram.com/HyperbolicCosine.html) of the supplied
 argument `a`.

defaults to `(e^x + e^{-x}) / 2`.

source raw docstring

cot^clj/smultimethod

(cot a)

generic cot.

Computes the trigonometric cotangent function of the supplied argument a.

Equivalent to (invert (tan a)), or (/ (cos a) (sin a)).

generic cot.

Computes the trigonometric cotangent function of the supplied argument `a`.

Equivalent to `(invert (tan a))`, or `(/ (cos a) (sin a))`.

source raw docstring

coth^clj/smultimethod

(coth a)

generic coth.

Computes the hyperbolic cotangent of the supplied argument a.

defaults to cosh(x) / sinh(x).

generic coth.

Computes the [hyperbolic
 cotangent](https://mathworld.wolfram.com/HyperbolicCotangent.html) of the supplied
 argument `a`.

defaults to `cosh(x) / sinh(x)`.

source raw docstring

cross-product^clj/smultimethod

(cross-product a b)

generic cross-product

generic cross-product

source raw docstring

csc^clj/smultimethod

(csc a)

generic csc.

Computes the cosecant of the supplied argument a.

Equivalent to (invert (sin a)).

generic csc.

Computes the cosecant of the supplied argument `a`.

Equivalent to `(invert (sin a))`.

source raw docstring

csch^clj/smultimethod

(csch a)

generic csch.

Computes the hyperbolic cosecant of the supplied argument a.

defaults to 1 / sinh(x).

generic csch.

Computes the [hyperbolic
 cosecant](https://mathworld.wolfram.com/HyperbolicCosecant.html) of the supplied
 argument `a`.

defaults to `1 / sinh(x)`.

source raw docstring

cube^clj/smultimethod

(cube a)

generic cube

generic cube

source raw docstring

determinant^clj/smultimethod

(determinant a)

generic determinant

generic determinant

source raw docstring

dimension^clj/smultimethod

(dimension a)

generic dimension

generic dimension

source raw docstring

div^clj/smultimethod

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

generic div.

Returns the result of dividing `a` and `b`.

  Equivalent to `(* a (negate b))`.

  See [[/]] for a variadic version of [[div]].

source raw docstring

divide^clj/s

Alias for /.

Alias for [[/]].

source raw docstring

dot-product^clj/smultimethod

(dot-product a b)

generic dot-product

generic dot-product

source raw docstring

exact-divide^clj/smultimethod

(exact-divide a b)

generic exact-divide.

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

generic exact-divide.

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

source raw docstring

exact-zero?^clj/s

(exact-zero? n)

Returns true if the supplied argument is an exact numerical zero, false otherwise.

Returns true if the supplied argument is an exact numerical zero, false
otherwise.

source raw docstring

exact?^clj/smultimethod

(exact? a)

generic exact?.

Entries that are exact are available for gcd, among other operations.

generic exact?.

Entries that are exact are available for `gcd`, among other operations.

source raw docstring

exp^clj/smultimethod

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

source raw docstring

exp10^clj/smultimethod

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

source raw docstring

exp2^clj/smultimethod

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

source raw docstring

expt^clj/smultimethod

(expt a b)

generic expt

generic expt

source raw docstring

floor^clj/smultimethod

(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/org.mentat/emmy/CURRENT/doc/basics/generics)
  for more detail.

source raw docstring

fractional-part^clj/smultimethod

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

source raw docstring

freeze^clj/smultimethod

(freeze a)

generic freeze.

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.

generic freeze.

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.

source raw docstring

gcd^clj/smultimethod

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

source raw docstring

identity-like^clj/smultimethod

(identity-like a)

generic identity-like.

Like one-like but works for square matrices.

generic identity-like.

Like `one-like` but works for square matrices.

source raw docstring

identity?^clj/smultimethod

(identity? a)

generic identity?.

Like one?, but this is true of square identity matrices as well. No matrix is considered one? because its function as a multiplicative identity depends on the shape of the other multiplicand.

generic identity?.

Like `one?`, but this is true of square identity matrices as well.
  No matrix is considered `one?` because its function as a multiplicative
  identity depends on the shape of the other multiplicand.

source raw docstring

imag-part^clj/smultimethod

(imag-part a)

generic imag-part

generic imag-part

source raw docstring

infinite?^clj/smultimethod

(infinite? a)

generic infinite?.

Returns true if a is either numerically infinite (i.e., equal to ##Inf) or a compound number (complex or quaterion, for example) with some infinite component.

generic infinite?.

Returns true if `a` is either numerically infinite (i.e., equal to `##Inf`) or
  a compound number (complex or quaterion, for example) with some infinite
  component.

source raw docstring

inner-product^clj/smultimethod

(inner-product a b)

generic inner-product

generic inner-product

source raw docstring

integer-part^clj/smultimethod

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

source raw docstring

invert^clj/smultimethod

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

source raw docstring

lcm^clj/smultimethod

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

source raw docstring

Lie-derivative^clj/smultimethod

(Lie-derivative a)

generic Lie-derivative

generic Lie-derivative

source raw docstring

log^clj/smultimethod

(log a)

generic log.

Returns the natural logarithm of x.

generic log.

Returns the natural logarithm of `x`.

source raw docstring

log10^clj/smultimethod

(log10 a)

generic log10.

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

generic log10.

Returns the base-10 logarithm of `x`, i.e., $log_10(x)$.

source raw docstring

log2^clj/smultimethod

(log2 a)

generic log2.

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

generic log2.

Returns the base-2 logarithm of `x`, i.e., $log_2(x)$.

source raw docstring

magnitude^clj/smultimethod

(magnitude a)

generic magnitude

generic magnitude

source raw docstring

make-polar^clj/smultimethod

(make-polar a b)

generic make-polar

generic make-polar

source raw docstring

make-rectangular^clj/smultimethod

(make-rectangular a b)

generic make-rectangular

generic make-rectangular

source raw docstring

modulo^clj/smultimethod

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

source raw docstring

negate^clj/smultimethod

(negate a)

generic negate.

Returns the negation of a.

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

generic negate.

Returns the negation of `a`.

  Equivalent to `(- (g/zero-like a) a)`.

source raw docstring

negative?^clj/smultimethod

(negative? a)

generic negative?.

Returns true if the argument a is less than (g/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 `(g/zero-like a)`,
  false otherwise. The default implementation depends on a proper Comparable
  implementation on the type.`

source raw docstring

numeric-zero?^clj/s

(numeric-zero? x)

Returns true if x is both a [[number?]] and zero?, false otherwise.

Returns `true` if `x` is both a [[number?]] and [[zero?]], false otherwise.

source raw docstring

one-like^clj/smultimethod

(one-like a)

generic one-like.

In general, this procedure returns the multiplicative identity of the type of its argument, if it exists. For numbers this is 1.

generic one-like.

In general, this procedure returns the multiplicative identity of the type of
  its argument, if it exists. For numbers this is 1.

source raw docstring

one?^clj/smultimethod

(one? a)

generic one?.

Is true if x is a multiplicative identity.

generic one?.

Is true if `x` is a multiplicative identity.

source raw docstring

outer-product^clj/smultimethod

(outer-product a b)

generic outer-product

generic outer-product

source raw docstring

partial-derivative^clj/smultimethod

(partial-derivative a b)

generic partial-derivative

generic partial-derivative

source raw docstring

quotient^clj/smultimethod

(quotient a b)

generic quotient

generic quotient

source raw docstring

real-part^clj/smultimethod

(real-part a)

generic real-part

generic real-part

source raw docstring

remainder^clj/smultimethod

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

source raw docstring

sec^clj/smultimethod

(sec a)

generic sec.

Computes the secant of the supplied argument a.

Equivalent to (invert (cos a)).

generic sec.

Computes the secant of the supplied argument `a`.

Equivalent to `(invert (cos a))`.

source raw docstring

sech^clj/smultimethod

(sech a)

generic sech.

Computes the hyperbolic secant of the supplied argument a.

defaults to 1 / cosh(x).

generic sech.

Computes the [hyperbolic
 secant](https://mathworld.wolfram.com/HyperbolicSecant.html) of the supplied
 argument `a`.

defaults to `1 / cosh(x)`.

source raw docstring

simplify^clj/smultimethod

(simplify a)

generic simplify

generic simplify

source raw docstring

sin^clj/smultimethod

(sin a)

generic sin.

Returns the sine of the supplied argument a.

generic sin.

Returns the [sine](https://en.wikipedia.org/wiki/Sine_and_cosine) of the
  supplied argument `a`.

source raw docstring

sinc^clj/smultimethod

(sinc a)

generic sinc.

The unnormalized sinc function, equivalent to $\frac{\sin x}{x}$ but defined to be equal to 1 at $x = 0$.

References

Wikipedia page
Mathworld page on Sinc
[Boost notes on sinc and [[sinch]]](https://www.boost.org/doc/libs/1_65_0/libs/math/doc/html/math_toolkit/sinc/sinc_overview.html)

generic sinc.

The unnormalized [sinc
  function](https://en.wikipedia.org/wiki/Sinc_function), equivalent to
  $\frac{\sin x}{x}$ but defined to be equal to 1 at $x = 0$.

  ### References

   - [Wikipedia page](https://en.wikipedia.org/wiki/Sinc_function)
   - [Mathworld page on Sinc](https://mathworld.wolfram.com/SincFunction.html)
   - [Boost notes on [[sinc]]
     and [[sinch]]](https://www.boost.org/doc/libs/1_65_0/libs/math/doc/html/math_toolkit/sinc/sinc_overview.html)

source raw docstring

sinh^clj/smultimethod

(sinh a)

generic sinh.

Computes the hyperbolic sine of the supplied argument a.

defaults to (e^x - e^{-x}) / 2.

generic sinh.

Computes the [hyperbolic
 sine](https://mathworld.wolfram.com/HyperbolicSine.html) of the supplied
 argument `a`.

defaults to `(e^x - e^{-x}) / 2`.

source raw docstring

sinhc^clj/smultimethod

(sinhc a)

generic sinhc.

The sinhc function, equivalent to $\frac{\sinh x}{x}$ but defined to be equal to 1 at $x = 0$.

References

generic sinhc.

The [sinhc function](https://en.wikipedia.org/wiki/Sinhc_function),
  equivalent to $\frac{\sinh x}{x}$ but defined to be equal to 1 at $x = 0$.

  ### References

   - [Wikipedia page](https://en.wikipedia.org/wiki/Sinhc_function)
   - [Mathworld page on Sinhc](https://mathworld.wolfram.com/SinhcFunction.html)

source raw docstring

solve-linear^clj/smultimethod

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

source raw docstring

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 Emmy, 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 Emmy, both functions accept either type.

source raw docstring

solve-linear-right^clj/smultimethod

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

source raw docstring

sqrt^clj/smultimethod

(sqrt a)

generic sqrt

generic sqrt

source raw docstring

square^clj/smultimethod

(square a)

generic square

generic square

source raw docstring

tan^clj/smultimethod

(tan a)

generic tan.

Computes the trigonometric tangent function of the supplied argument a.

Equivalent to (/ (sin a) (cos a)).

generic tan.

Computes the trigonometric tangent function of the supplied argument `a`.

Equivalent to `(/ (sin a) (cos a))`.

source raw docstring

tanc^clj/smultimethod

(tanc a)

generic tanc.

tanc is defined, by analogy with sinc, to be equal to $\frac{\tan x}{x}$ for nonzero $x$ and equal to 1 at $x = 0$.

References

generic tanc.

`tanc` is defined, by analogy with [[sinc]], to be equal to $\frac{\tan
  x}{x}$ for nonzero $x$ and equal to 1 at $x = 0$.

  ### References

   - [Wikipedia page](https://en.wikipedia.org/wiki/Tanc_function)
   - [Mathworld page on Sinc](https://mathworld.wolfram.com/TancFunction.html)

source raw docstring

tanh^clj/smultimethod

(tanh a)

generic tanh.

Computes the hyperbolic tangent of the supplied argument a.

defaults to sinh(x) / cosh(x).

generic tanh.

Computes the [hyperbolic
 tangent](https://mathworld.wolfram.com/HyperbolicTangent.html) of the supplied
 argument `a`.

defaults to `sinh(x) / cosh(x)`.

source raw docstring

tanhc^clj/smultimethod

(tanhc a)

generic tanhc.

The tanhc function, equivalent to $\frac{\tanh x}{x}$ but defined to be equal to 1 at $x = 0$.

References

generic tanhc.

The [tanhc function](https://en.wikipedia.org/wiki/Tanhc_function),
  equivalent to $\frac{\tanh x}{x}$ but defined to be equal to 1 at $x = 0$.

  ### References

   - [Wikipedia page](https://en.wikipedia.org/wiki/Tanhc_function)
   - [Mathworld page on Tanhc](https://mathworld.wolfram.com/TanhcFunction.html)

source raw docstring

trace^clj/smultimethod

(trace a)

generic trace

generic trace

source raw docstring

transpose^clj/smultimethod

(transpose a)

generic transpose

generic transpose

source raw docstring

zero-like^clj/smultimethod

(zero-like a)

generic zero-like.

In general, this procedure returns the additive identity of the type of its argument, if it exists. For numbers this is 0.

generic zero-like.

In general, this procedure returns the additive identity of the type of its
  argument, if it exists. For numbers this is 0.

source raw docstring

zero?^clj/smultimethod

(zero? a)

generic zero?.

Is true if x is an additive identity.

generic zero?.

Is true if `x` is an additive identity.

source raw docstring

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

Keyboard shortcuts Report a problem cljdoc on GitHub

× close

emmy.generic

*clj/s

+clj/s

-clj/s

/clj/s

absclj/smultimethod

acosclj/smultimethod

acoshclj/smultimethod

acotclj/smultimethod

acothclj/smultimethod

acscclj/smultimethod

acschclj/smultimethod

almost-integral?clj/s

angleclj/smultimethod

asecclj/smultimethod

asechclj/smultimethod

asinclj/smultimethod

asinhclj/smultimethod

atanclj/smultimethod

atanhclj/smultimethod

ceilingclj/smultimethod

conjugateclj/smultimethod

cosclj/smultimethod

coshclj/smultimethod

cotclj/smultimethod

cothclj/smultimethod

cross-productclj/smultimethod

cscclj/smultimethod

cschclj/smultimethod

cubeclj/smultimethod

determinantclj/smultimethod

dimensionclj/smultimethod

divclj/smultimethod

divideclj/s

dot-productclj/smultimethod

exact-divideclj/smultimethod

exact-zero?clj/s

exact?clj/smultimethod

expclj/smultimethod

exp10clj/smultimethod

exp2clj/smultimethod

exptclj/smultimethod

floorclj/smultimethod

fractional-partclj/smultimethod

freezeclj/smultimethod

gcdclj/smultimethod

identity-likeclj/smultimethod

identity?clj/smultimethod

imag-partclj/smultimethod

infinite?clj/smultimethod

inner-productclj/smultimethod

integer-partclj/smultimethod

invertclj/smultimethod

lcmclj/smultimethod

Lie-derivativeclj/smultimethod

logclj/smultimethod

log10clj/smultimethod

log2clj/smultimethod

magnitudeclj/smultimethod

make-polarclj/smultimethod

make-rectangularclj/smultimethod

moduloclj/smultimethod

negateclj/smultimethod

negative?clj/smultimethod

numeric-zero?clj/s

one-likeclj/smultimethod

one?clj/smultimethod

outer-productclj/smultimethod

partial-derivativeclj/smultimethod

quotientclj/smultimethod

real-partclj/smultimethod

remainderclj/smultimethod

secclj/smultimethod

sechclj/smultimethod

simplifyclj/smultimethod

sinclj/smultimethod

sincclj/smultimethod

References

sinhclj/smultimethod

sinhcclj/smultimethod

*^clj/s

+^clj/s

-^clj/s

/^clj/s

abs^clj/smultimethod

acos^clj/smultimethod

acosh^clj/smultimethod

acot^clj/smultimethod

acoth^clj/smultimethod

acsc^clj/smultimethod

acsch^clj/smultimethod

almost-integral?^clj/s

angle^clj/smultimethod

asec^clj/smultimethod

asech^clj/smultimethod

asin^clj/smultimethod

asinh^clj/smultimethod

atan^clj/smultimethod

atanh^clj/smultimethod

ceiling^clj/smultimethod

conjugate^clj/smultimethod

cos^clj/smultimethod

cosh^clj/smultimethod

cot^clj/smultimethod

coth^clj/smultimethod

cross-product^clj/smultimethod

csc^clj/smultimethod

csch^clj/smultimethod

cube^clj/smultimethod

determinant^clj/smultimethod

dimension^clj/smultimethod

div^clj/smultimethod

divide^clj/s

dot-product^clj/smultimethod

exact-divide^clj/smultimethod

exact-zero?^clj/s

exact?^clj/smultimethod

exp^clj/smultimethod

exp10^clj/smultimethod

exp2^clj/smultimethod

expt^clj/smultimethod

floor^clj/smultimethod

fractional-part^clj/smultimethod

freeze^clj/smultimethod

gcd^clj/smultimethod

identity-like^clj/smultimethod

identity?^clj/smultimethod

imag-part^clj/smultimethod

infinite?^clj/smultimethod

inner-product^clj/smultimethod

integer-part^clj/smultimethod

invert^clj/smultimethod

lcm^clj/smultimethod

Lie-derivative^clj/smultimethod

log^clj/smultimethod

log10^clj/smultimethod

log2^clj/smultimethod

magnitude^clj/smultimethod

make-polar^clj/smultimethod

make-rectangular^clj/smultimethod

modulo^clj/smultimethod

negate^clj/smultimethod

negative?^clj/smultimethod

numeric-zero?^clj/s

one-like^clj/smultimethod

one?^clj/smultimethod

outer-product^clj/smultimethod

partial-derivative^clj/smultimethod

quotient^clj/smultimethod

real-part^clj/smultimethod

remainder^clj/smultimethod

sec^clj/smultimethod

sech^clj/smultimethod

simplify^clj/smultimethod

sin^clj/smultimethod

sinc^clj/smultimethod

sinh^clj/smultimethod

sinhc^clj/smultimethod

solve-linear^clj/smultimethod

solve-linear-left^clj/s