Liking cljdoc? Tell your friends :D

emmy.generic

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"
```
sourceraw 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)
```
sourceraw 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)
```
sourceraw 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)
```
sourceraw docstring

absclj/smultimethod

(abs a)

generic abs

generic abs
sourceraw docstring

acosclj/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)`.
sourceraw docstring

acoshclj/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))`.
sourceraw docstring

acotclj/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)`.
sourceraw docstring

acothclj/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))`.
sourceraw docstring

acscclj/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))`.
sourceraw docstring

acschclj/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)`.
sourceraw docstring

angleclj/smultimethod

(angle a)

generic angle

generic angle
sourceraw docstring

asecclj/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))`.
sourceraw docstring

asechclj/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)`.
sourceraw docstring

asinclj/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))`.
sourceraw docstring

asinhclj/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))`.
sourceraw docstring

atanclj/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).
sourceraw docstring

atanhclj/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))`.
sourceraw docstring

ceilingclj/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.
sourceraw docstring

conjugateclj/smultimethod

(conjugate a)

generic conjugate

generic conjugate
sourceraw docstring

cosclj/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`.
sourceraw docstring

coshclj/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`.
sourceraw docstring

cotclj/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))`.
sourceraw docstring

cothclj/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)`.
sourceraw docstring

cross-productclj/smultimethod

(cross-product a b)

generic cross-product

generic cross-product
sourceraw docstring

cscclj/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))`.
sourceraw docstring

cschclj/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)`.
sourceraw docstring

cubeclj/smultimethod

(cube a)

generic cube

generic cube
sourceraw docstring

determinantclj/smultimethod

(determinant a)

generic determinant

generic determinant
sourceraw docstring

dimensionclj/smultimethod

(dimension a)

generic dimension

generic dimension
sourceraw docstring

divclj/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]].
sourceraw docstring

divideclj/s

Alias for /.

Alias for [[/]].
sourceraw docstring

dot-productclj/smultimethod

(dot-product a b)

generic dot-product

generic dot-product
sourceraw docstring

exact-divideclj/smultimethod

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

expclj/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.
sourceraw docstring

exp10clj/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)`.
sourceraw docstring

exp2clj/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)`.
sourceraw docstring

exptclj/smultimethod

(expt a b)

generic expt

generic expt
sourceraw docstring

floorclj/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.
sourceraw docstring

fractional-partclj/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))
```
sourceraw docstring

gcdclj/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`.
sourceraw docstring

imag-partclj/smultimethod

(imag-part a)

generic imag-part

generic imag-part
sourceraw 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.
sourceraw docstring

inner-productclj/smultimethod

(inner-product a b)

generic inner-product

generic inner-product
sourceraw docstring

integer-partclj/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.
sourceraw docstring

invertclj/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)`.
sourceraw docstring

lcmclj/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`.
sourceraw docstring

Lie-derivativeclj/smultimethod

(Lie-derivative a)

generic Lie-derivative

generic Lie-derivative
sourceraw docstring

logclj/smultimethod

(log a)

generic log.

Returns the natural logarithm of x.

generic log.

Returns the natural logarithm of `x`.
sourceraw docstring

log10clj/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)$.
sourceraw docstring

log2clj/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)$.
sourceraw docstring

magnitudeclj/smultimethod

(magnitude a)

generic magnitude

generic magnitude
sourceraw docstring

make-polarclj/smultimethod

(make-polar a b)

generic make-polar

generic make-polar
sourceraw docstring

make-rectangularclj/smultimethod

(make-rectangular a b)

generic make-rectangular

generic make-rectangular
sourceraw docstring

moduloclj/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`.
sourceraw docstring

negateclj/smultimethod

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

negative?clj/smultimethod

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

outer-productclj/smultimethod

(outer-product a b)

generic outer-product

generic outer-product
sourceraw docstring

partial-derivativeclj/smultimethod

(partial-derivative a b)

generic partial-derivative

generic partial-derivative
sourceraw docstring

quotientclj/smultimethod

(quotient a b)

generic quotient

generic quotient
sourceraw docstring

real-partclj/smultimethod

(real-part a)

generic real-part

generic real-part
sourceraw docstring

remainderclj/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`.
sourceraw docstring

secclj/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))`.
sourceraw docstring

sechclj/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)`.
sourceraw docstring

simplifyclj/smultimethod

(simplify a)

generic simplify

generic simplify
sourceraw docstring

sinclj/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`.
sourceraw docstring

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

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

sinhclj/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`.
sourceraw docstring

sinhcclj/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)
sourceraw docstring

solve-linearclj/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`.
sourceraw docstring

solve-linear-leftclj/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.
sourceraw docstring

solve-linear-rightclj/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`.
sourceraw docstring

sqrtclj/smultimethod

(sqrt a)

generic sqrt

generic sqrt
sourceraw docstring

squareclj/smultimethod

(square a)

generic square

generic square
sourceraw docstring

tanclj/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))`.
sourceraw docstring

tancclj/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)
sourceraw docstring

tanhclj/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)`.
sourceraw docstring

tanhcclj/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)
sourceraw docstring

traceclj/smultimethod

(trace a)

generic trace

generic trace
sourceraw docstring

transposeclj/smultimethod

(transpose a)

generic transpose

generic transpose
sourceraw docstring

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

× close