fastapprox

https://docs.rs/fastapprox/0.3.1/fastapprox/
Admin
fastapprox is a Rust library providing fast approximate versions of mathematical functions commonly...
Tokens:9,911
Snippets:128
Trust Score:9.1
Update:5 months ago
Show doc for...
Tokens:
Raw
### Benchmark Results for FastApprox Functions

Source: https://docs.rs/fastapprox

These results, obtained by running `cargo bench`, show the average time per iteration (ns/iter) for different approximation functions. They highlight the performance gains of 'fast' and 'faster' approximations compared to standard library functions, with varying degrees of error.

```text
test cos_fast            ... bench:       3,674 ns/iter (+/- 778)
test cos_faster          ... bench:       1,559 ns/iter (+/- 206)
test cos_std             ... bench:       7,329 ns/iter (+/- 104)
test cosfull_fast        ... bench:       6,880 ns/iter (+/- 1,021)
test cosfull_faster      ... bench:       4,238 ns/iter (+/- 183)
test cosh_fast           ... bench:       8,270 ns/iter (+/- 4,190)
test cosh_faster         ... bench:       2,451 ns/iter (+/- 175)
test cosh_std            ... bench:       4,407 ns/iter (+/- 798)
test digamma_fast        ... bench:       4,644 ns/iter (+/- 1,126)
test digamma_faster      ... bench:       3,770 ns/iter (+/- 417)
test digamma_special     ... bench:      16,260 ns/iter (+/- 1,374)
test digamma_statrs      ... bench:      14,401 ns/iter (+/- 3,198)
test erf_fast            ... bench:      54,401 ns/iter (+/- 20,448)
test erf_faster          ... bench:       2,359 ns/iter (+/- 426)
test erf_inv_fast        ... bench:       5,958 ns/iter (+/- 2,794)
test erf_inv_faster      ... bench:       2,113 ns/iter (+/- 153)
test erf_inv_statrs      ... bench:         769 ns/iter (+/- 83)
test erf_special         ... bench:       4,948 ns/iter (+/- 1,443)
test erf_statrs          ... bench:       6,287 ns/iter (+/- 246)
test erfc_fast           ... bench:      54,201 ns/iter (+/- 6,307)
test erfc_faster         ... bench:       2,052 ns/iter (+/- 112)
test erfc_special        ... bench:       4,887 ns/iter (+/- 362)
test exp_fast            ... bench:       3,774 ns/iter (+/- 235)
test exp_faster          ... bench:       1,400 ns/iter (+/- 260)
test exp_std             ... bench:       2,760 ns/iter (+/- 202)
test lambertw_fast       ... bench:      21,040 ns/iter (+/- 2,523)
test lambertw_faster     ... bench:      24,840 ns/iter (+/- 8,939)
test lambertwexpx_fast   ... bench:      13,240 ns/iter (+/- 858)
test lambertwexpx_faster ... bench:       8,857 ns/iter (+/- 1,439)
test ln_fast             ... bench:       2,087 ns/iter (+/- 528)
test ln_faster           ... bench:       1,214 ns/iter (+/- 447)
test ln_gamma_fast       ... bench:       6,193 ns/iter (+/- 901)
test ln_gamma_faster     ... bench:       2,952 ns/iter (+/- 211)
test ln_gamma_special    ... bench:      36,726 ns/iter (+/- 846)
test ln_gamma_statrs     ... bench:      56,295 ns/iter (+/- 973)
test ln_std              ... bench:       5,175 ns/iter (+/- 321)
test log2_fast           ... bench:       1,998 ns/iter (+/- 335)
test log2_faster         ... bench:       1,206 ns/iter (+/- 188)
test log2_std            ... bench:       5,087 ns/iter (+/- 1,736)
test pow2_fast           ... bench:       3,472 ns/iter (+/- 192)
test pow2_faster         ... bench:       1,069 ns/iter (+/- 356)
test pow2_std            ... bench:       2,942 ns/iter (+/- 172)
test pow_fast            ... bench:       6,769 ns/iter (+/- 1,460)
test pow_faster          ... bench:       2,365 ns/iter (+/- 293)
test pow_std             ... bench:      13,147 ns/iter (+/- 1,000)
test sigmoid_fast        ... bench:       4,818 ns/iter (+/- 428)
test sigmoid_faster      ... bench:       1,869 ns/iter (+/- 56)
test sigmoid_std         ... bench:       3,312 ns/iter (+/- 131)
test sin_fast            ... bench:       3,038 ns/iter (+/- 685)
test sin_faster          ... bench:       1,875 ns/iter (+/- 481)
test sin_std             ... bench:       7,215 ns/iter (+/- 39)
test sinfull_fast        ... bench:       6,483 ns/iter (+/- 405)
test sinfull_faster      ... bench:       3,973 ns/iter (+/- 874)
test sinh_fast           ... bench:       8,394 ns/iter (+/- 618)
test sinh_faster         ... bench:       2,588 ns/iter (+/- 286)
test sinh_std            ... bench:       4,434 ns/iter (+/- 329)
test tan_fast            ... bench:       5,165 ns/iter (+/- 174)
test tan_faster          ... bench:       3,423 ns/iter (+/- 1,083)
test tan_std             ... bench:       7,695 ns/iter (+/- 453)
test tanfull_fast        ... bench:      10,299 ns/iter (+/- 1,761)
test tanfull_faster      ... bench:       6,214 ns/iter (+/- 524)
test tanh_fast           ... bench:       5,598 ns/iter (+/- 709)
test tanh_faster         ... bench:       1,921 ns/iter (+/- 445)
test tanh_std            ... bench:       4,056 ns/iter (+/- 306)
```

--------------------------------

### Calculate Cosine using fastapprox::fast::cos

Source: https://docs.rs/fastapprox/0.3.1/fastapprox/fast/fn.cos.html

Compares the result of f32::cos with fastapprox::fast::cos for a given input. Use fastapprox::fast::cos for potentially faster, approximate cosine calculations.

```rust
assert_eq!(f32::cos(1.0), 0.5403023);
assert_eq!(fastapprox::fast::cos(1.0), 0.5402951);
```

--------------------------------

### Compare f32::cos and fastapprox::faster::cos

Source: https://docs.rs/fastapprox/0.3.1/fastapprox/faster/fn.cos.html

Compares the output of the standard library's f32::cos with the fastapprox::faster::cos function. Use fastapprox::faster::cos for performance-critical applications where a slight approximation is acceptable.

```rust
assert_eq!(f32::cos(1.0), 0.5403023);
assert_eq!(fastapprox::faster::cos(1.0), 0.5357177);
```

--------------------------------

### lambertwexpx

Source: https://docs.rs/fastapprox/0.3.1/fastapprox/fast/fn.lambertwexpx.html

Calculates the exponent of the Lambert W function for a given f32 input.

```APIDOC
## lambertwexpx

### Description
Exponent of Lambert W function.

### Signature
```rust
pub fn lambertwexpx(x: f32) -> f32
```

### Parameters
* `x` (f32) - The input value.

### Returns
* `f32` - The result of the Lambert W function exponent calculation.
```

--------------------------------

### Fast Implementations

Source: https://docs.rs/fastapprox/0.3.1/fastapprox/all.html

Optimized mathematical functions for faster computation.

```APIDOC
## fast::cos

### Description
Computes the cosine.

### Function Signature
`fn cos(x: f64) -> f64`

## fast::cosfull

### Description
Computes the full cosine.

### Function Signature
`fn cosfull(x: f64) -> f64`

## fast::cosh

### Description
Computes the hyperbolic cosine.

### Function Signature
`fn cosh(x: f64) -> f64`

## fast::digamma

### Description
Computes the digamma function.

### Function Signature
`fn digamma(x: f64) -> f64`

## fast::erf

### Description
Computes the error function.

### Function Signature
`fn erf(x: f64) -> f64`

## fast::erf_inv

### Description
Computes the inverse error function.

### Function Signature
`fn erf_inv(x: f64) -> f64`

## fast::erfc

### Description
Computes the complementary error function.

### Function Signature
`fn erfc(x: f64) -> f64`

## fast::exp

### Description
Computes the exponential function.

### Function Signature
`fn exp(x: f64) -> f64`

## fast::lambertw

### Description
Computes the Lambert W function.

### Function Signature
`fn lambertw(x: f64) -> f64`

## fast::lambertwexpx

### Description
Computes the Lambert W function multiplied by its argument's exponent.

### Function Signature
`fn lambertwexpx(x: f64) -> f64`

## fast::ln

### Description
Computes the natural logarithm.

### Function Signature
`fn ln(x: f64) -> f64`

## fast::ln_gamma

### Description
Computes the natural logarithm of the gamma function.

### Function Signature
`fn ln_gamma(x: f64) -> f64`

## fast::log2

### Description
Computes the base-2 logarithm.

### Function Signature
`fn log2(x: f64) -> f64`

## fast::pow

### Description
Computes the power function (x^y).

### Function Signature
`fn pow(x: f64, y: f64) -> f64`

## fast::pow2

### Description
Computes 2 raised to the power of x.

### Function Signature
`fn pow2(x: f64) -> f64`

## fast::sigmoid

### Description
Computes the sigmoid function.

### Function Signature
`fn sigmoid(x: f64) -> f64`

## fast::sin

### Description
Computes the sine.

### Function Signature
`fn sin(x: f64) -> f64`

## fast::sinfull

### Description
Computes the full sine.

### Function Signature
`fn sinfull(x: f64) -> f64`

## fast::sinh

### Description
Computes the hyperbolic sine.

### Function Signature
`fn sinh(x: f64) -> f64`

## fast::tan

### Description
Computes the tangent.

### Function Signature
`fn tan(x: f64) -> f64`

## fast::tanfull

### Description
Computes the full tangent.

### Function Signature
`fn tanfull(x: f64) -> f64`

## fast::tanh

### Description
Computes the hyperbolic tangent.

### Function Signature
`fn tanh(x: f64) -> f64`
```

--------------------------------

### Faster Implementations

Source: https://docs.rs/fastapprox/0.3.1/fastapprox/all.html

Alternative optimized mathematical functions, potentially with different trade-offs.

```APIDOC
## faster::cos

### Description
Computes the cosine.

### Function Signature
`fn cos(x: f64) -> f64`

## faster::cosfull

### Description
Computes the full cosine.

### Function Signature
`fn cosfull(x: f64) -> f64`

## faster::cosh

### Description
Computes the hyperbolic cosine.

### Function Signature
`fn cosh(x: f64) -> f64`

## faster::digamma

### Description
Computes the digamma function.

### Function Signature
`fn digamma(x: f64) -> f64`

## faster::erf

### Description
Computes the error function.

### Function Signature
`fn erf(x: f64) -> f64`

## faster::erf_inv

### Description
Computes the inverse error function.

### Function Signature
`fn erf_inv(x: f64) -> f64`

## faster::erfc

### Description
Computes the complementary error function.

### Function Signature
`fn erfc(x: f64) -> f64`

## faster::exp

### Description
Computes the exponential function.

### Function Signature
`fn exp(x: f64) -> f64`

## faster::lambertw

### Description
Computes the Lambert W function.

### Function Signature
`fn lambertw(x: f64) -> f64`

## faster::lambertwexpx

### Description
Computes the Lambert W function multiplied by its argument's exponent.

### Function Signature
`fn lambertwexpx(x: f64) -> f64`

## faster::ln

### Description
Computes the natural logarithm.

### Function Signature
`fn ln(x: f64) -> f64`

## faster::ln_gamma

### Description
Computes the natural logarithm of the gamma function.

### Function Signature
`fn ln_gamma(x: f64) -> f64`

## faster::log2

### Description
Computes the base-2 logarithm.

### Function Signature
`fn log2(x: f64) -> f64`

## faster::pow

### Description
Computes the power function (x^y).

### Function Signature
`fn pow(x: f64, y: f64) -> f64`

## faster::pow2

### Description
Computes 2 raised to the power of x.

### Function Signature
`fn pow2(x: f64) -> f64`

## faster::sigmoid

### Description
Computes the sigmoid function.

### Function Signature
`fn sigmoid(x: f64) -> f64`

## faster::sin

### Description
Computes the sine.

### Function Signature
`fn sin(x: f64) -> f64`

## faster::sinfull

### Description
Computes the full sine.

### Function Signature
`fn sinfull(x: f64) -> f64`

## faster::sinh

### Description
Computes the hyperbolic sine.

### Function Signature
`fn sinh(x: f64) -> f64`

## faster::tan

### Description
Computes the tangent.

### Function Signature
`fn tan(x: f64) -> f64`

## faster::tanfull

### Description
Computes the full tangent.

### Function Signature
`fn tanfull(x: f64) -> f64`

## faster::tanh

### Description
Computes the hyperbolic tangent.

### Function Signature
`fn tanh(x: f64) -> f64`
```

--------------------------------

### Logarithm Functions

Source: https://docs.rs/fastapprox/0.3.1/fastapprox/fast/index.html

Provides functions for natural logarithm and base 2 logarithm.

```APIDOC
## ln

### Description
Natural logarithm.

### Function Signature
`fn ln(x: f64) -> f64`

## ln_gamma

### Description
Natural logarithm of the Gamma function.

### Function Signature
`fn ln_gamma(x: f64) -> f64`

## log2

### Description
Base 2 logarithm.

### Function Signature
`fn log2(x: f64) -> f64`
```

--------------------------------

### from_bits

Source: https://docs.rs/fastapprox/0.3.1/fastapprox/bits/index.html

Performs a raw transmutation from a u32 value.

```APIDOC
## Function: from_bits

### Description
Raw transmutation from `u32`.

### Signature
```rust
fn from_bits(bits: u32) -> Self
```

### Parameters
* **bits** (u32) - The u32 value to transmute.
```

--------------------------------

### Logarithm Functions

Source: https://docs.rs/fastapprox/0.3.1/fastapprox/faster/index.html

Provides natural logarithm, base 2 logarithm, and natural logarithm of the Gamma function.

```APIDOC
## ln

### Description
Calculates the natural logarithm.

### Function Signature
`fn ln(x: f64) -> f64`

## ln_gamma

### Description
Calculates the natural logarithm of the Gamma function.

### Function Signature
`fn ln_gamma(x: f64) -> f64`

## log2

### Description
Calculates the base 2 logarithm.

### Function Signature
`fn log2(x: f64) -> f64`
```

--------------------------------

### Compare cosfull with f32::cos

Source: https://docs.rs/fastapprox/0.3.1/fastapprox/faster/fn.cosfull.html

Compares the output of fastapprox::faster::cosfull with the standard library's f32::cos for a given input. The range reduction technique used by cosfull may lead to slight inaccuracies for large inputs.

```rust
assert_eq!(f32::cos(10.0), -0.8390715);
assert_eq!(fastapprox::faster::cosfull(10.0), -0.8394889);
```

--------------------------------

### cosfull vs f32::cos Comparison

Source: https://docs.rs/fastapprox/0.3.1/fastapprox/fast/fn.cosfull.html

Compares the output of fastapprox::fast::cosfull with the standard f32::cos for a given input. Note that cosfull has accuracy limitations for large inputs.

```rust
assert_eq!(f32::cos(10.0), -0.8390715);
assert_eq!(fastapprox::fast::cosfull(10.0), -0.83907986);
```

--------------------------------

### pow2

Source: https://docs.rs/fastapprox/0.3.1/fastapprox/fast/fn.pow2.html

Raises 2 to a floating point power.

```APIDOC
## pow2

### Description
Raises 2 to a floating point power.

### Signature
```rust
pub fn pow2(p: f32) -> f32
```

### Parameters
* **p** (f32) - The exponent to raise 2 to.
```

--------------------------------

### ln

Source: https://docs.rs/fastapprox/0.3.1/fastapprox/faster/fn.ln.html

Calculates the natural logarithm of a given f32 value.

```APIDOC
## ln

### Description
Calculates the natural logarithm of a given f32 value.

### Function Signature
```rust
pub fn ln(x: f32) -> f32
```

### Parameters
* **x** (f32) - The input value for which to calculate the natural logarithm.

### Returns
* (f32) - The natural logarithm of the input value.
```

--------------------------------

### to_bits

Source: https://docs.rs/fastapprox/0.3.1/fastapprox/bits/index.html

Performs a raw transmutation to a u32 value.

```APIDOC
## Function: to_bits

### Description
Raw transmutation to `u32`.

### Signature
```rust
fn to_bits(self) -> u32
```

### Parameters
* **self** - The value to transmute.
```

--------------------------------

### lambertw

Source: https://docs.rs/fastapprox/0.3.1/fastapprox/fast/fn.lambertw.html

Computes the Lambert W function for a given f32 input.

```APIDOC
## lambertw

### Description
Computes the Lambert W function.

### Signature
```rust
pub fn lambertw(x: f32) -> f32
```

### Parameters
* **x** (f32) - The input value for the Lambert W function.

### Returns
* (f32) - The result of the Lambert W function.
```

--------------------------------

### to_bits

Source: https://docs.rs/fastapprox/0.3.1/fastapprox/bits/fn.to_bits.html

Converts an f32 to its raw u32 memory representation. This is a low-level operation similar to f32::to_bits but described as even more raw.

```APIDOC
## to_bits

### Description
Transmutes the given `f32` into its raw memory representation. Similar to `f32::to_bits` but even more raw.

### Signature
```rust
pub fn to_bits(x: f32) -> u32
```

### Parameters
* **x** (f32) - The floating-point number to transmute.

### Returns
* (u32) - The raw memory representation of the input f32.
```

--------------------------------

### log2

Source: https://docs.rs/fastapprox/0.3.1/fastapprox/fast/fn.log2.html

Computes the base 2 logarithm of a 32-bit floating-point number.

```APIDOC
## log2

### Description
Base 2 logarithm.

### Signature
```rust
pub fn log2(x: f32) -> f32
```

### Parameters
* `x` (f32) - The input number for which to calculate the base 2 logarithm.

### Returns
* `f32` - The base 2 logarithm of `x`.
```

--------------------------------

### Sine Functions

Source: https://docs.rs/fastapprox/0.3.1/fastapprox/fast/index.html

Provides functions for calculating the sine of a number.

```APIDOC
## sin

### Description
Sine of a number in [-π, π], in radians.

### Function Signature
`fn sin(x: f64) -> f64`

## sinfull

### Description
Sine in radians.

### Function Signature
`fn sinfull(x: f64) -> f64`
```

--------------------------------

### exp

Source: https://docs.rs/fastapprox/0.3.1/fastapprox/fast/fn.exp.html

Calculates the exponential of a given floating-point number.

```APIDOC
## exp

### Description
Exponential function.

### Function Signature
```rust
pub fn exp(p: f32) -> f32
```

### Parameters
* **p** (f32) - The input value for which to calculate the exponential.

### Returns
* (f32) - The result of the exponential function e^p.
```

--------------------------------

### pow

Source: https://docs.rs/fastapprox/0.3.1/fastapprox/fast/fn.pow.html

Raises a number to a floating point power.

```APIDOC
## pow

### Description
Raises a number to a floating point power.

### Function Signature
```rust
pub fn pow(x: f32, p: f32) -> f32
```

### Parameters
* **x** (f32) - The base number.
* **p** (f32) - The exponent.

### Returns
* (f32) - The result of x raised to the power of p.
```

--------------------------------

### Power Functions

Source: https://docs.rs/fastapprox/0.3.1/fastapprox/fast/index.html

Provides functions for raising numbers to a power.

```APIDOC
## pow

### Description
Raises a number to a floating point power.

### Function Signature
`fn pow(base: f64, exp: f64) -> f64`

## pow2

### Description
Raises 2 to a floating point power.

### Function Signature
`fn pow2(exp: f64) -> f64`
```

--------------------------------

### Cosine Functions

Source: https://docs.rs/fastapprox/0.3.1/fastapprox/fast/index.html

Provides functions for calculating the cosine of a number.

```APIDOC
## cos

### Description
Cosine of a number in [-π, π], in radians.

### Function Signature
`fn cos(x: f64) -> f64`

## cosfull

### Description
Cosine in radians.

### Function Signature
`fn cosfull(x: f64) -> f64`
```

--------------------------------

### from_bits

Source: https://docs.rs/fastapprox/0.3.1/fastapprox/bits/fn.from_bits.html

Converts the given u32 containing the float’s raw memory representation into the f32 type. Similar to f32::from_bits but even more raw.

```APIDOC
## from_bits

### Description
Converts the given `u32` containing the float’s raw memory representation into the `f32` type. Similar to `f32::from_bits` but even more raw.

### Signature
```rust
pub fn from_bits(x: u32) -> f32
```

### Parameters
#### Path Parameters
- **x** (u32) - Description: The u32 value representing the raw memory of an f32.

### Returns
- **f32** - The f32 value represented by the input u32.
```

--------------------------------

### Lambert W Function

Source: https://docs.rs/fastapprox/0.3.1/fastapprox/fast/index.html

Provides functions related to the Lambert W function.

```APIDOC
## lambertw

### Description
Lambert W function.

### Function Signature
`fn lambertw(x: f64) -> f64`

## lambertwexpx

### Description
Exponent of Lambert W function.

### Function Signature
`fn lambertwexpx(x: f64) -> f64`
```

--------------------------------

### Hyperbolic Sine

Source: https://docs.rs/fastapprox/0.3.1/fastapprox/fast/index.html

Calculates the hyperbolic sine of a number.

```APIDOC
## sinh

### Description
Hyperbolic sine function.

### Function Signature
`fn sinh(x: f64) -> f64`
```

--------------------------------

### Sine Calculation in Radians

Source: https://docs.rs/fastapprox/0.3.1/fastapprox/fast/fn.sinfull.html

Calculates the sine of a floating-point number in radians. Be aware that the range reduction technique used can lead to inaccuracies for input values significantly larger than 1000.

```rust
pub fn sinfull(x: f32) -> f32
```

--------------------------------

### sin Function

Source: https://docs.rs/fastapprox/0.3.1/fastapprox/fast/fn.sin.html

Calculates the sine of a number. The input `x` should be in radians and within the range of [-π, π].

```APIDOC
## sin

### Description
Sine of a number in [-π, π], in radians.

### Signature
```rust
pub fn sin(x: f32) -> f32
```

### Parameters
* **x** (f32) - The input number in radians, expected to be in the range [-π, π].

### Returns
* (f32) - The sine of the input number.
```

--------------------------------

### Tangent Functions

Source: https://docs.rs/fastapprox/0.3.1/fastapprox/fast/index.html

Provides functions for calculating the tangent of a number.

```APIDOC
## tan

### Description
Tangent of a number in [-π/2, π/2], in radians.

### Function Signature
`fn tan(x: f64) -> f64`

## tanfull

### Description
Tangent in radians.

### Function Signature
`fn tanfull(x: f64) -> f64`
```

--------------------------------

### Bit Manipulation Functions

Source: https://docs.rs/fastapprox/0.3.1/fastapprox/all.html

Functions for converting between bit representations.

```APIDOC
## bits::from_bits

### Description
Converts from a bit representation.

### Function Signature
`fn from_bits(value: u64) -> f64`

## bits::to_bits

### Description
Converts to a bit representation.

### Function Signature
`fn to_bits(value: f64) -> u64`
```

--------------------------------

### sinfull Function Signature

Source: https://docs.rs/fastapprox/0.3.1/fastapprox/faster/fn.sinfull.html

Calculates the sine of a number in radians. Note that the range reduction technique used may be inaccurate for |x| >> 1000.

```APIDOC
## sinfull

### Description
Sine in radians.

### Signature
```rust
pub fn sinfull(x: f32) -> f32
```

### Parameters
* **x** (f32) - The input angle in radians.

### Returns
* (f32) - The sine of the input angle.

### Notes
The range reduction technique used here will be hopelessly inaccurate for |x| >> 1000.
```

--------------------------------

### tanfull

Source: https://docs.rs/fastapprox/0.3.1/fastapprox/fast/fn.tanfull.html

Calculates the tangent of an angle in radians. Note that the range reduction technique used can lead to inaccuracies for large input values (|x| >> 1000).

```APIDOC
## tanfull

### Description
Tangent in radians. The range reduction technique used here will be hopelessly inaccurate for |x| >> 1000.

### Signature
```rust
pub fn tanfull(x: f32) -> f32
```

### Parameters
* **x** (f32) - The angle in radians.

### Returns
* (f32) - The tangent of the angle.
```

--------------------------------

### Hyperbolic Tangent Function (tanh)

Source: https://docs.rs/fastapprox/0.3.1/fastapprox/faster/fn.tanh.html

Calculates the hyperbolic tangent of a single f32 value. This function is part of the fastapprox crate for efficient approximations.

```rust
pub fn tanh(p: f32) -> f32
```

--------------------------------

### ln Function

Source: https://docs.rs/fastapprox/0.3.1/fastapprox/fast/fn.ln.html

Calculates the natural logarithm of a single-precision floating-point number.

```APIDOC
## ln Function

### Description
Natural logarithm.

### Signature
```rust
pub fn ln(x: f32) -> f32
```

### Parameters
* **x** (f32) - The input value for which to calculate the natural logarithm.
```

--------------------------------

### Hyperbolic Cosine

Source: https://docs.rs/fastapprox/0.3.1/fastapprox/fast/index.html

Calculates the hyperbolic cosine of a number.

```APIDOC
## cosh

### Description
Hyperbolic cosine function.

### Function Signature
`fn cosh(x: f64) -> f64`
```

--------------------------------

### sinfull Function Signature

Source: https://docs.rs/fastapprox/0.3.1/fastapprox/fast/fn.sinfull.html

Calculates the sine of a number in radians. Note that the range reduction technique used can lead to inaccuracies for large input values (|x| >> 1000).

```APIDOC
## Function sinfull

### Description
Sine in radians.

### Signature
```rust
pub fn sinfull(x: f32) -> f32
```

### Details
The range reduction technique used here will be hopelessly inaccurate for |x| >> 1000.
```

--------------------------------

### Sigmoid Function

Source: https://docs.rs/fastapprox/0.3.1/fastapprox/fast/index.html

Computes the sigmoid function.

```APIDOC
## sigmoid

### Description
Sigmoid function.

### Function Signature
`fn sigmoid(x: f64) -> f64`
```

--------------------------------

### sigmoid

Source: https://docs.rs/fastapprox/0.3.1/fastapprox/fast/fn.sigmoid.html

Calculates the sigmoid of a given f32 value.

```APIDOC
## sigmoid

### Description
Sigmoid function.

### Signature
```rust
pub fn sigmoid(x: f32) -> f32
```

### Parameters
* `x` (f32) - The input value.

### Returns
* `f32` - The sigmoid of the input value.
```

--------------------------------

### tanfull Function Signature

Source: https://docs.rs/fastapprox/0.3.1/fastapprox/faster/fn.tanfull.html

Calculates the tangent of a number in radians. The range reduction technique used here will be hopelessly inaccurate for |x| >> 1000.

```APIDOC
## tanfull

### Description
Tangent in radians.

### Signature
```rust
pub fn tanfull(x: f32) -> f32
```

### Remarks
The range reduction technique used here will be hopelessly inaccurate for |x| >> 1000.
```

--------------------------------

### tanfull Function Signature

Source: https://docs.rs/fastapprox/0.3.1/fastapprox/fast/fn.tanfull.html

Calculates the tangent of a number in radians. The range reduction technique used is inaccurate for |x| >> 1000.

```rust
pub fn tanfull(x: f32) -> f32
```

--------------------------------

### Exponential Function

Source: https://docs.rs/fastapprox/0.3.1/fastapprox/fast/index.html

Calculates the exponential of a number.

```APIDOC
## exp

### Description
Exponential function.

### Function Signature
`fn exp(x: f64) -> f64`
```

--------------------------------

### cosh

Source: https://docs.rs/fastapprox/0.3.1/fastapprox/fast/fn.cosh.html

Calculates the hyperbolic cosine of a given floating-point number.

```APIDOC
## cosh

### Description
Hyperbolic cosine function.

### Signature
```rust
pub fn cosh(p: f32) -> f32
```

### Parameters
* **p** (f32) - The input value for which to calculate the hyperbolic cosine.
```

--------------------------------

### Digamma Function

Source: https://docs.rs/fastapprox/0.3.1/fastapprox/fast/index.html

Computes the digamma function.

```APIDOC
## digamma

### Description
Digamma function.

### Function Signature
`fn digamma(x: f64) -> f64`
```

--------------------------------

### Hyperbolic Tangent

Source: https://docs.rs/fastapprox/0.3.1/fastapprox/fast/index.html

Calculates the hyperbolic tangent of a number.

```APIDOC
## tanh

### Description
Hyperbolic tangent function.

### Function Signature
`fn tanh(x: f64) -> f64`
```

--------------------------------

### cosfull

Source: https://docs.rs/fastapprox/0.3.1/fastapprox/faster/fn.cosfull.html

Calculates the cosine of a number in radians. The range reduction technique used is inaccurate for |x| >> 1000.

```APIDOC
## cosfull

### Description
Calculates the cosine of a number in radians. The range reduction technique used is inaccurate for |x| >> 1000.

### Signature
```
pub fn cosfull(x: f32) -> f32
```

### Parameters
* **x** (f32) - The input value in radians.

### Returns
* (f32) - The cosine of the input value.

### Examples
```rust
assert_eq!(fastapprox::faster::cosfull(10.0), -0.8394889);
```
```

--------------------------------

### sinh

Source: https://docs.rs/fastapprox/0.3.1/fastapprox/fast/fn.sinh.html

Calculates the hyperbolic sine of a given f32 number.

```APIDOC
## sinh

### Description
Hyperbolic sine function.

### Function Signature
```
pub fn sinh(p: f32) -> f32
```

### Parameters
* **p** (f32) - The input value for which to calculate the hyperbolic sine.
```

--------------------------------

### tanh

Source: https://docs.rs/fastapprox/0.3.1/fastapprox/faster/fn.tanh.html

Computes the hyperbolic tangent of a given f32 value.

```APIDOC
## tanh

### Description
Hyperbolic tangent function.

### Signature
```rust
pub fn tanh(p: f32) -> f32
```

### Parameters
#### Path Parameters
- **p** (f32) - The input value for which to compute the hyperbolic tangent.
```

--------------------------------

### erf

Source: https://docs.rs/fastapprox/0.3.1/fastapprox/fast/fn.erf.html

Calculates the error function for a given f32 input.

```APIDOC
## erf

### Description
Error function.

### Signature
```rust
pub fn erf(x: f32) -> f32
```

### Parameters
* `x` (f32) - The input value for the error function.

### Returns
* `f32` - The result of the error function.
```

--------------------------------

### ln_gamma Function

Source: https://docs.rs/fastapprox/0.3.1/fastapprox/fast/fn.ln_gamma.html

Calculates the natural logarithm of the Gamma function. This function is only valid for positive input values.

```APIDOC
## ln_gamma

### Description
Calculates the natural logarithm of the Gamma function. Only works for positive values.

### Signature
```rust
pub fn ln_gamma(x: f32) -> f32
```

### Parameters
* **x** (f32) - The input value for which to calculate the natural logarithm of the Gamma function. Must be positive.

### Returns
* (f32) - The natural logarithm of the Gamma function of x.
```

--------------------------------

### tan

Source: https://docs.rs/fastapprox/0.3.1/fastapprox/fast/fn.tan.html

Calculates the tangent of a number in radians. The input is expected to be within the range of [-π/2, π/2].

```APIDOC
## tan

### Description
Tangent of a number in [-π/2, π/2], in radians.

### Signature
```rust
pub fn tan(x: f32) -> f32
```

### Parameters
* **x** (f32) - The input number in radians.
```

--------------------------------

### cosfull Function

Source: https://docs.rs/fastapprox/0.3.1/fastapprox/fast/fn.cosfull.html

Calculates the cosine of an angle in radians. Note that the range reduction technique used can lead to inaccuracies for very large input values.

```APIDOC
## cosfull

### Description
Cosine in radians. The range reduction technique used here will be hopelessly inaccurate for |x| >> 1000.

### Signature
```rust
pub fn cosfull(x: f32) -> f32
```

### Examples
```rust
assert_eq!(fastapprox::fast::cosfull(10.0), -0.83907986);
```
```

--------------------------------

### digamma

Source: https://docs.rs/fastapprox/0.3.1/fastapprox/fast/fn.digamma.html

Calculates the digamma function. This function is only valid for positive input values.

```APIDOC
## digamma

### Description
Calculates the digamma function. This function only works for positive values.

### Signature
```rust
pub fn digamma(x: f32) -> f32
```

### Parameters
* **x** (f32) - The input value for the digamma function. Must be positive.

### Returns
* (f32) - The result of the digamma function.
```

--------------------------------

### erfc Function Signature

Source: https://docs.rs/fastapprox/0.3.1/fastapprox/fast/fn.erfc.html

The erfc function takes a single f32 argument and returns an f32.

```APIDOC
## erfc

### Description
Complementary error function.

### Signature
```rust
pub fn erfc(x: f32) -> f32
```

### Parameters
* **x** (f32) - The input value.

### Returns
* (f32) - The complementary error function of x.
```

--------------------------------

### Error Functions

Source: https://docs.rs/fastapprox/0.3.1/fastapprox/faster/index.html

Provides functions related to the error function.

```APIDOC
## erf

### Description
Calculates the error function.

### Function Signature
`fn erf(x: f64) -> f64`

## erf_inv

### Description
Calculates the inverse error function.

### Function Signature
`fn erf_inv(x: f64) -> f64`

## erfc

### Description
Calculates the complementary error function.

### Function Signature
`fn erfc(x: f64) -> f64`
```

--------------------------------

### erfc

Source: https://docs.rs/fastapprox/0.3.1/fastapprox/faster/fn.erfc.html

Calculates the complementary error function.

```APIDOC
## erfc

### Description
Complementary error function.

### Signature
```rust
pub fn erfc(x: f32) -> f32
```

### Parameters
* **x** (f32) - The input value for which to calculate the complementary error function.
```

--------------------------------

### erf Function Signature

Source: https://docs.rs/fastapprox/0.3.1/fastapprox/faster/fn.erf.html

The erf function takes a 32-bit floating-point number as input and returns a 32-bit floating-point number representing the error function.

```APIDOC
## erf

### Description
Error function.

### Signature
```rust
pub fn erf(x: f32) -> f32
```

### Parameters
* **x** (f32) - The input value for which to calculate the error function.

### Returns
* (f32) - The result of the error function calculation.
```

--------------------------------

### tanh Function

Source: https://docs.rs/fastapprox/0.3.1/fastapprox/fast/fn.tanh.html

Computes the hyperbolic tangent of a 32-bit floating-point number.

```APIDOC
## tanh

### Description
Hyperbolic tangent function.

### Signature
```rust
pub fn tanh(p: f32) -> f32
```

### Parameters
* `p` (f32) - The input value for which to compute the hyperbolic tangent.
```

--------------------------------

### erf_inv

Source: https://docs.rs/fastapprox/0.3.1/fastapprox/fast/fn.erf_inv.html

Calculates the inverse error function. It takes a single f32 argument and returns an f32.

```APIDOC
## Function erf_inv

### Description
Inverse error function.

### Signature
```rust
pub fn erf_inv(x: f32) -> f32
```

### Parameters
* **x** (f32) - The input value for which to calculate the inverse error function.
```

--------------------------------

### erf Function Signature

Source: https://docs.rs/fastapprox/0.3.1/fastapprox/fast/fn.erf.html

This is the function signature for the error function (erf). It takes a 32-bit floating-point number and returns a 32-bit floating-point number.

```rust
pub fn erf(x: f32) -> f32
```

--------------------------------

### cos Function

Source: https://docs.rs/fastapprox/0.3.1/fastapprox/fast/fn.cos.html

Calculates the cosine of a number in radians. The input is expected to be within the range of [-π, π].

```APIDOC
## Function cos

### Description
Cosine of a number in [-π, π], in radians.

### Signature
```rust
pub fn cos(x: f32) -> f32
```

### Examples
```rust
assert_eq!(f32::cos(1.0), 0.5403023);
assert_eq!(fastapprox::fast::cos(1.0), 0.5402951);
```
```

--------------------------------

### Error Function

Source: https://docs.rs/fastapprox/0.3.1/fastapprox/fast/index.html

Provides functions related to the error function.

```APIDOC
## erf

### Description
Error function.

### Function Signature
`fn erf(x: f64) -> f64`

## erf_inv

### Description
Inverse error function.

### Function Signature
`fn erf_inv(x: f64) -> f64`

## erfc

### Description
Complementary error function.

### Function Signature
`fn erfc(x: f64) -> f64`
```
Tokens:
Raw