mirror of
https://github.com/sigmasternchen/gleam-community-maths
synced 2025-03-15 07:59:01 +00:00
Fix typos
This commit is contained in:
parent
861c067f12
commit
83a671fe2b
5 changed files with 73 additions and 65 deletions
|
@ -146,7 +146,7 @@ pub fn ceiling(x: Float, digits: option.Option(Int)) -> Result(Float, String) {
|
|||
/// </a>
|
||||
/// </div>
|
||||
///
|
||||
/// The floor function rounds input $$x \in \mathbb{R}$$ to the nearest integer value (at the specified digit) that is less than or equal to the input $$x$$
|
||||
/// The floor function rounds input $$x \in \mathbb{R}$$ to the nearest integer value (at the specified digit) that is less than or equal to the input $$x$$.
|
||||
///
|
||||
/// Note: The floor function is used as an alias for the rounding function [`round`](#round) with rounding mode `RoundDown`.
|
||||
///
|
||||
|
@ -361,7 +361,7 @@ pub fn truncate(x: Float, digits: option.Option(Int)) -> Result(Float, String) {
|
|||
/// |> should.equal(Ok(12.07))
|
||||
///
|
||||
/// floatx.round(12.0654, option.Some(2), option.Some(floatx.RoundTiesUp))
|
||||
/// |> should.equal(Ok(12.07)
|
||||
/// |> should.equal(Ok(12.07))
|
||||
///
|
||||
/// floatx.round(12.0654, option.Some(2), option.Some(floatx.RoundToZero))
|
||||
/// |> should.equal(Ok(12.06))
|
||||
|
@ -714,7 +714,7 @@ if javascript {
|
|||
///
|
||||
/// pub fn example() {
|
||||
/// floatx.asin(0.0)
|
||||
/// |> should.equal(0.0)
|
||||
/// |> should.equal(Ok(0.0))
|
||||
///
|
||||
/// floatx.asin(1.1)
|
||||
/// |> should.be_error()
|
||||
|
@ -1108,20 +1108,19 @@ if javascript {
|
|||
"../../maths.mjs" "exponential"
|
||||
}
|
||||
|
||||
// TODO: Update description here below
|
||||
/// <div style="text-align: right;">
|
||||
/// <a href="https://github.com/gleam-community/maths/issues">
|
||||
/// <small>Spot a typo? Open an issue!</small>
|
||||
/// </a>
|
||||
/// </div>
|
||||
///
|
||||
/// The natural logarithm function:
|
||||
/// The base $$b$$ logarithm function (computed through the "change of base" formula):
|
||||
///
|
||||
/// \\[
|
||||
/// \forall x \in \(0, \infty\), \\; \log_{e}{(x)} = y \in \(-\infty, +\infty\)
|
||||
/// \forall x \in \(0, \infty\) \textnormal{ and } b > 1, \\; \log_{b}{(x)} = y \in \(-\infty, +\infty\)
|
||||
/// \\]
|
||||
///
|
||||
/// The function takes a number $$x$$ in its domain $$\(0, \infty\)$$ as input and returns
|
||||
/// The function takes a number $$x$$ in its domain $$\(0, \infty\)$$ and a base $$b > 1$$ as input and returns
|
||||
/// a numeric value $$y$$ that lies in the range $$\(-\infty, \infty\)$$.
|
||||
/// If the input value is outside the domain of the function an error is returned.
|
||||
///
|
||||
|
@ -1137,7 +1136,7 @@ if javascript {
|
|||
/// |> should.equal(Ok(0.0))
|
||||
///
|
||||
/// floatx.logarithm(floatx.e(), option.Some(floatx.e()))
|
||||
/// |> should.equal(1.0)
|
||||
/// |> should.equal(Ok(1.0))
|
||||
///
|
||||
/// floatx.logarithm(-1.0, option.Some(2.0))
|
||||
/// |> should.be_error()
|
||||
|
@ -1205,7 +1204,7 @@ pub fn logarithm(x: Float, base: option.Option(Float)) -> Result(Float, String)
|
|||
/// |> should.equal(Ok(0.0))
|
||||
///
|
||||
/// floatx.natural_logarithm(floatx.e())
|
||||
/// |> should.equal(1.0)
|
||||
/// |> should.equal(Ok(1.0))
|
||||
///
|
||||
/// floatx.natural_logarithm(-1.0)
|
||||
/// |> should.be_error()
|
||||
|
@ -1546,7 +1545,7 @@ pub fn cube_root(x: Float) -> Result(Float, String) {
|
|||
/// </a>
|
||||
/// </div>
|
||||
///
|
||||
/// The nth root function: $$y = \sqrt[3]{x} = x^{\frac{1}{n}}$$.
|
||||
/// The $$n$$'th root function: $$y = \sqrt[n]{x} = x^{\frac{1}{n}}$$.
|
||||
///
|
||||
/// Note that the function is not defined if:
|
||||
/// 1. The input is negative ($$x < 0$$). An error will be returned
|
||||
|
@ -1607,7 +1606,7 @@ pub fn nth_root(x: Float, n: Int) -> Result(Float, String) {
|
|||
/// </a>
|
||||
/// </div>
|
||||
///
|
||||
/// A function to compute the hypotenuse of a right-angled triangle: $$\sqrt[2](x^2 + y^2)$$.
|
||||
/// A function to compute the hypotenuse of a right-angled triangle: $$\sqrt[2]{x^2 + y^2}$$.
|
||||
/// The function can also be used to calculate the Euclidean distance in 2 dimensions.
|
||||
///
|
||||
/// <details>
|
||||
|
@ -1617,7 +1616,14 @@ pub fn nth_root(x: Float, n: Int) -> Result(Float, String) {
|
|||
/// import gleam_community/maths/float as floatx
|
||||
///
|
||||
/// pub fn example() {
|
||||
/// floatx.hypotenuse(0.0, 0.0)
|
||||
/// |> should.equal(0.0)
|
||||
///
|
||||
/// floatx.hypotenuse(1.0, 0.0)
|
||||
/// |> should.equal(1.0)
|
||||
///
|
||||
/// floatx.hypotenuse(0.0, 1.0)
|
||||
/// |> should.equal(1.0)
|
||||
/// }
|
||||
/// </details>
|
||||
///
|
||||
|
@ -1853,7 +1859,7 @@ if javascript {
|
|||
/// floatx.to_degree(0.0)
|
||||
/// |> should.equal(0.0)
|
||||
///
|
||||
/// floatx.to_degree(2. *. pi())
|
||||
/// floatx.to_degree(2. *. floatx.pi())
|
||||
/// |> should.equal(360.)
|
||||
/// }
|
||||
/// </details>
|
||||
|
@ -1885,7 +1891,7 @@ pub fn to_degree(x: Float) -> Float {
|
|||
///
|
||||
/// pub fn example() {
|
||||
/// floatx.to_radian(360.)
|
||||
/// |> should.equal(2. *. pi())
|
||||
/// |> should.equal(2. *. floatx.pi())
|
||||
/// }
|
||||
/// </details>
|
||||
///
|
||||
|
|
|
@ -125,7 +125,7 @@ pub fn norm(arr: List(Float), p: Float) -> Float {
|
|||
/// Calculcate the Minkowski distance between two lists (representing vectors):
|
||||
///
|
||||
/// \\[
|
||||
/// \left( \sum_{i=1}^n \left|x_i - x_j \right|^{p} \right)^{\frac{1}{p}}
|
||||
/// \left( \sum_{i=1}^n \left|x_i - y_i \right|^{p} \right)^{\frac{1}{p}}
|
||||
/// \\]
|
||||
///
|
||||
/// In the formula, $$p >= 1$$ is the order, $$n$$ is the length of the two lists and $$x_i, y_i$$ are the values in the respective input lists indexed by $$i, j$$.
|
||||
|
@ -203,7 +203,7 @@ pub fn minkowski_distance(
|
|||
/// Calculcate the Euclidean distance between two lists (representing vectors):
|
||||
///
|
||||
/// \\[
|
||||
/// \left( \sum_{i=1}^n \left|x_i - x_j \right|^{2} \right)^{\frac{1}{2}}
|
||||
/// \left( \sum_{i=1}^n \left|x_i - y_i \right|^{2} \right)^{\frac{1}{2}}
|
||||
/// \\]
|
||||
///
|
||||
/// In the formula, $$n$$ is the length of the two lists and $$x_i, y_i$$ are the values in the respective input lists indexed by $$i, j$$.
|
||||
|
@ -219,11 +219,11 @@ pub fn minkowski_distance(
|
|||
/// assert Ok(tol) = floatx.power(-10.0, -6.0)
|
||||
///
|
||||
/// // Empty lists returns 0.0
|
||||
/// float_list.euclidean_distance([], [], 1.0)
|
||||
/// float_list.euclidean_distance([], [])
|
||||
/// |> should.equal(Ok(0.0))
|
||||
///
|
||||
/// // Differing lengths returns error
|
||||
/// float_list.euclidean_distance([], [1.0], 1.0)
|
||||
/// float_list.euclidean_distance([], [1.0])
|
||||
/// |> should.be_error()
|
||||
///
|
||||
/// assert Ok(result) = float_list.euclidean_distance([0.0, 0.0], [1.0, 2.0])
|
||||
|
@ -255,7 +255,7 @@ pub fn euclidean_distance(
|
|||
/// Calculcate the Manhatten distance between two lists (representing vectors):
|
||||
///
|
||||
/// \\[
|
||||
/// \sum_{i=1}^n \left|x_i - x_j \right|
|
||||
/// \sum_{i=1}^n \left|x_i - y_i \right|
|
||||
/// \\]
|
||||
///
|
||||
/// In the formula, $$n$$ is the length of the two lists and $$x_i, y_i$$ are the values in the respective input lists indexed by $$i, j$$.
|
||||
|
@ -390,7 +390,7 @@ pub fn linear_space(
|
|||
///
|
||||
/// pub fn example () {
|
||||
/// assert Ok(tol) = floatx.power(-10.0, -6.0)
|
||||
/// assert Ok(logspace) = float_list.logarithmic_space(1.0, 3.0, 3, True)
|
||||
/// assert Ok(logspace) = float_list.logarithmic_space(1.0, 3.0, 3, True, 10.0)
|
||||
/// assert Ok(result) =
|
||||
/// float_list.all_close(logspace, [10.0, 100.0, 1000.0], 0.0, tol)
|
||||
/// result
|
||||
|
@ -398,7 +398,7 @@ pub fn linear_space(
|
|||
/// |> should.be_true()
|
||||
///
|
||||
/// // A negative number of points (-3) does not work
|
||||
/// float_list.logarithmic_space(1.0, 3.0, -3, False)
|
||||
/// float_list.logarithmic_space(1.0, 3.0, -3, False, 10.0)
|
||||
/// |> should.be_error()
|
||||
/// }
|
||||
/// </details>
|
||||
|
@ -438,7 +438,7 @@ pub fn logarithmic_space(
|
|||
/// </a>
|
||||
/// </div>
|
||||
///
|
||||
/// The function returns a list of numbers spaced evenly on a log scale (a geometric progression). Each output point in the list is a constant multiple of the previous.
|
||||
/// The function returns a list of numbers spaced evenly on a log scale (a geometric progression). Each point in the list is a constant multiple of the previous.
|
||||
/// The function is similar to the [`logarithmic_space`](#logarithmic_space) function, but with endpoints specified directly.
|
||||
///
|
||||
/// <details>
|
||||
|
@ -661,11 +661,12 @@ pub fn product(arr: List(Float)) -> Float {
|
|||
/// Calculcate the cumulative sum of the elements in a list:
|
||||
///
|
||||
/// \\[
|
||||
/// v_j = \sum_{i=1}^j x_i, \forall j \leq n
|
||||
/// v_j = \sum_{i=1}^j x_i \\;\\; \forall j = 1,\dots, n
|
||||
/// \\]
|
||||
///
|
||||
/// In the formula, $$n$$ is the length of the list and $$x_i$$ is the value in the input list indexed by $$i$$.
|
||||
/// Furthermore, $$v_j$$ is the $$j$$th element in the cumulative sum.
|
||||
/// In the formula, $$v_j$$ is the $$j$$'th element in the cumulative sum of $$n$$ elements.
|
||||
/// That is, $$n$$ is the length of the list and $$x_i$$ is the value in the input list indexed by $$i$$.
|
||||
/// The value $$v_j$$ is thus the sum of the $$1$$ to $$j$$ first elements in the given list.
|
||||
///
|
||||
/// <details>
|
||||
/// <summary>Example:</summary>
|
||||
|
@ -709,11 +710,12 @@ pub fn cumulative_sum(arr: List(Float)) -> List(Float) {
|
|||
/// Calculcate the cumulative product of the elements in a list:
|
||||
///
|
||||
/// \\[
|
||||
/// v_j = \prod_{i=1}^j x_i, \forall j \leq n
|
||||
/// v_j = \prod_{i=1}^j x_i \\;\\; \forall j = 1,\dots, n
|
||||
/// \\]
|
||||
///
|
||||
/// In the formula, $$n$$ is the length of the list and $$x_i$$ is the value in the input list indexed by $$i$$.
|
||||
/// Furthermore, $$v_j$$ is the $$j$$th element in the cumulative product.
|
||||
/// In the formula, $$v_j$$ is the $$j$$'th element in the cumulative product of $$n$$ elements.
|
||||
/// That is, $$n$$ is the length of the list and $$x_i$$ is the value in the input list indexed by $$i$$.
|
||||
/// The value $$v_j$$ is thus the sum of the $$1$$ to $$j$$ first elements in the given list.
|
||||
///
|
||||
/// <details>
|
||||
/// <summary>Example:</summary>
|
||||
|
@ -985,7 +987,7 @@ pub fn arg_minimum(arr: List(Float)) -> Result(List(Int), String) {
|
|||
/// </a>
|
||||
/// </div>
|
||||
///
|
||||
/// Returns the minimum value of a list.
|
||||
/// Returns a tuple consisting of the minimum and maximum value of a list.
|
||||
///
|
||||
/// <details>
|
||||
/// <summary>Example:</summary>
|
||||
|
@ -1045,8 +1047,7 @@ pub fn extrema(arr: List(Float)) -> Result(#(Float, Float), String) {
|
|||
/// </a>
|
||||
/// </div>
|
||||
///
|
||||
/// Determine if a list of values are close to or equivalent to a
|
||||
/// another list of reference values.
|
||||
/// Determine if a list of values are close to or equivalent to a another list of reference values.
|
||||
///
|
||||
/// <details>
|
||||
/// <summary>Example:</summary>
|
||||
|
|
|
@ -469,11 +469,11 @@ pub fn permutation(n: Int, k: Int) -> Result(Int, String) {
|
|||
/// import gleam_community/maths/int as intx
|
||||
///
|
||||
/// pub fn example() {
|
||||
/// intx.absolute_difference(-10.0, 10.0)
|
||||
/// |> should.equal(20.0)
|
||||
/// intx.absolute_difference(-10, 10)
|
||||
/// |> should.equal(20)
|
||||
///
|
||||
/// intx.absolute_difference(0.0, -2.0)
|
||||
/// |> should.equal(2.0)
|
||||
/// intx.absolute_difference(0, -2)
|
||||
/// |> should.equal(2)
|
||||
/// }
|
||||
/// </details>
|
||||
///
|
||||
|
@ -601,7 +601,6 @@ fn do_sum(arr: List(Int)) -> Int {
|
|||
///
|
||||
/// intx.proper_divisors(13)
|
||||
/// |> should.equal([1])
|
||||
///
|
||||
/// }
|
||||
/// </details>
|
||||
///
|
||||
|
@ -831,7 +830,7 @@ pub fn is_even(x: Int) -> Bool {
|
|||
/// </a>
|
||||
/// </div>
|
||||
///
|
||||
/// A function that produces a number of type `Float` and from an `Int`.
|
||||
/// A function that produces a number of type `Float` from an `Int`.
|
||||
///
|
||||
/// Note: The function is equivalent to the similar function in the Gleam stdlib.
|
||||
///
|
||||
|
@ -845,7 +844,7 @@ pub fn is_even(x: Int) -> Bool {
|
|||
/// intx.to_float(-1)
|
||||
/// |> should.equal(-1.0)
|
||||
///
|
||||
/// intx.is_even(1)
|
||||
/// intx.to_float(1)
|
||||
/// |> should.equal(1.0)
|
||||
/// }
|
||||
/// </details>
|
||||
|
|
|
@ -51,7 +51,7 @@ import gleam_community/maths/int as intx
|
|||
/// Calculcate the Manhatten distance between two lists (representing vectors):
|
||||
///
|
||||
/// \\[
|
||||
/// \sum_{i=1}^n \left|x_i - x_j \right|
|
||||
/// \sum_{i=1}^n \left|x_i - y_i \right|
|
||||
/// \\]
|
||||
///
|
||||
/// In the formula, $$n$$ is the length of the two lists and $$x_i, y_i$$ are the values in the respective input lists indexed by $$i, j$$.
|
||||
|
@ -60,16 +60,15 @@ import gleam_community/maths/int as intx
|
|||
/// <summary>Example:</summary>
|
||||
///
|
||||
/// import gleeunit/should
|
||||
/// import gleam_community/maths/float as floatx
|
||||
/// import gleam_community/maths/float_list
|
||||
/// import gleam_community/maths/int_list
|
||||
///
|
||||
/// pub fn example () {
|
||||
/// // Empty lists returns 0
|
||||
/// float_list.manhatten_distance([], [])
|
||||
/// |> should.equal(Ok(0.0))
|
||||
/// int_list.manhatten_distance([], [])
|
||||
/// |> should.equal(Ok(0))
|
||||
///
|
||||
/// // Differing lengths returns error
|
||||
/// float_list.manhatten_distance([], [1])
|
||||
/// int_list.manhatten_distance([], [1])
|
||||
/// |> should.be_error()
|
||||
///
|
||||
/// assert Ok(result) = int_list.manhatten_distance([0, 0], [1, 2])
|
||||
|
@ -122,17 +121,17 @@ pub fn manhatten_distance(
|
|||
/// <summary>Example:</summary>
|
||||
///
|
||||
/// import gleeunit/should
|
||||
/// import gleam_community/maths/float_list
|
||||
/// import gleam_community/maths/int_list
|
||||
///
|
||||
/// pub fn example () {
|
||||
/// // An empty list returns 0
|
||||
/// []
|
||||
/// |> float_list.sum()
|
||||
/// |> int_list.sum()
|
||||
/// |> should.equal(0)
|
||||
///
|
||||
/// // Valid input returns a result
|
||||
/// [1, 2, 3]
|
||||
/// |> float_list.sum()
|
||||
/// |> int_list.sum()
|
||||
/// |> should.equal(6)
|
||||
/// }
|
||||
/// </details>
|
||||
|
@ -170,18 +169,18 @@ pub fn sum(arr: List(Int)) -> Int {
|
|||
/// <summary>Example:</summary>
|
||||
///
|
||||
/// import gleeunit/should
|
||||
/// import gleam_community/maths/float_list
|
||||
/// import gleam_community/maths/int_list
|
||||
///
|
||||
/// pub fn example () {
|
||||
/// // An empty list returns an error
|
||||
/// // An empty list returns 0
|
||||
/// []
|
||||
/// |> float_list.sum()
|
||||
/// |> should.equal(0.)
|
||||
/// |> int_list.product()
|
||||
/// |> should.equal(0)
|
||||
///
|
||||
/// // Valid input returns a result
|
||||
/// [1., 2., 3.]
|
||||
/// |> float_list.product()
|
||||
/// |> should.equal(6.)
|
||||
/// [1, 2, 3]
|
||||
/// |> int_list.product()
|
||||
/// |> should.equal(6)
|
||||
/// }
|
||||
/// </details>
|
||||
///
|
||||
|
@ -209,11 +208,12 @@ pub fn product(arr: List(Int)) -> Int {
|
|||
/// Calculcate the cumulative sum of the elements in a list:
|
||||
///
|
||||
/// \\[
|
||||
/// v_j = \sum_{i=1}^j x_i, \forall j \leq n
|
||||
/// v_j = \sum_{i=1}^j x_i \\;\\; \forall j = 1,\dots, n
|
||||
/// \\]
|
||||
///
|
||||
/// In the formula, $$n$$ is the length of the list and $$x_i$$ is the value in the input list indexed by $$i$$.
|
||||
/// Furthermore, $$v_j$$ is the $$j$$th element in the cumulative sum.
|
||||
/// In the formula, $$v_j$$ is the $$j$$'th element in the cumulative sum of $$n$$ elements.
|
||||
/// That is, $$n$$ is the length of the list and $$x_i$$ is the value in the input list indexed by $$i$$.
|
||||
/// The value $$v_j$$ is thus the sum of the $$1$$ to $$j$$ first elements in the given list.
|
||||
///
|
||||
/// <details>
|
||||
/// <summary>Example:</summary>
|
||||
|
@ -257,11 +257,12 @@ pub fn cumulative_sum(arr: List(Int)) -> List(Int) {
|
|||
/// Calculcate the cumulative product of the elements in a list:
|
||||
///
|
||||
/// \\[
|
||||
/// v_j = \prod_{i=1}^j x_i, \forall j \leq n
|
||||
/// v_j = \prod_{i=1}^j x_i \\;\\; \forall j = 1,\dots, n
|
||||
/// \\]
|
||||
///
|
||||
/// In the formula, $$n$$ is the length of the list and $$x_i$$ is the value in the input list indexed by $$i$$.
|
||||
/// Furthermore, $$v_j$$ is the $$j$$th element in the cumulative product.
|
||||
/// In the formula, $$v_j$$ is the $$j$$'th element in the cumulative product of $$n$$ elements.
|
||||
/// That is, $$n$$ is the length of the list and $$x_i$$ is the value in the input list indexed by $$i$$.
|
||||
/// The value $$v_j$$ is thus the product of the $$1$$ to $$j$$ first elements in the given list.
|
||||
///
|
||||
/// <details>
|
||||
/// <summary>Example:</summary>
|
||||
|
@ -288,7 +289,7 @@ pub fn cumulative_sum(arr: List(Int)) -> List(Int) {
|
|||
/// </a>
|
||||
/// </div>
|
||||
///
|
||||
pub fn cumumlative_product(arr: List(Int)) -> List(Int) {
|
||||
pub fn cumulative_product(arr: List(Int)) -> List(Int) {
|
||||
case arr {
|
||||
[] -> []
|
||||
_ ->
|
||||
|
@ -319,7 +320,7 @@ pub fn cumumlative_product(arr: List(Int)) -> List(Int) {
|
|||
///
|
||||
/// // Valid input returns a result
|
||||
/// [4, 4, 3, 2, 1]
|
||||
/// |> stats.arg_minimum()
|
||||
/// |> int_list.arg_minimum()
|
||||
/// |> should.equal(Ok([4]))
|
||||
/// }
|
||||
/// </details>
|
||||
|
@ -533,6 +534,7 @@ pub fn minimum(arr: List(Int)) -> Result(Int, String) {
|
|||
/// </a>
|
||||
/// </div>
|
||||
///
|
||||
/// Returns a tuple consisting of the minimum and maximum value of a list.
|
||||
///
|
||||
/// <details>
|
||||
/// <summary>Example:</summary>
|
||||
|
|
|
@ -120,16 +120,16 @@ pub fn int_list_product_test() {
|
|||
pub fn int_list_cumulative_product_test() {
|
||||
// An empty lists returns an empty list
|
||||
[]
|
||||
|> int_list.cumumlative_product()
|
||||
|> int_list.cumulative_product()
|
||||
|> should.equal([])
|
||||
|
||||
// Valid input returns a result
|
||||
[1, 2, 3]
|
||||
|> int_list.cumumlative_product()
|
||||
|> int_list.cumulative_product()
|
||||
|> should.equal([1, 2, 6])
|
||||
|
||||
[-2, 4, 6]
|
||||
|> int_list.cumumlative_product()
|
||||
|> int_list.cumulative_product()
|
||||
|> should.equal([-2, -8, -48])
|
||||
}
|
||||
|
||||
|
|
Loading…
Reference in a new issue