gleam_community_maths - v1.0.0

gleam_community/maths/sequences

Sequences: A module containing functions for generating various types of sequences, ranges and intervals.

Functions

arange

</> 
pub fn arange(start: Float, stop: Float, step: Float) -> List(
  Float,
)

The function returns a list with evenly spaced values within a given interval based on a start, stop value and a given increment (step-length) between consecutive values. The list returned includes the given start value but excludes the stop value.

Example: 
 import gleeunit/should
 import gleam_community/maths/sequences

 pub fn example () {
   sequences.arange(1.0, 5.0, 1.0)
   |> should.equal([1.0, 2.0, 3.0, 4.0])
   
   // No points returned since
   // start smaller than stop and positive step
   sequences.arange(5.0, 1.0, 1.0)
   |> should.equal([])
   
   // Points returned since
   // start smaller than stop but negative step
   sequences.arange(5.0, 1.0, -1.0)
   |> should.equal([5.0, 4.0, 3.0, 2.0])
 }

geometric_space

</> 
pub fn geometric_space(start: Float, stop: Float, num: Int, endpoint: Bool) -> Result(
  List(Float),
  String,
)

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 function, but with endpoints specified directly.

Example: 
 import gleeunit/should
 import gleam_community/maths/elementary
 import gleam_community/maths/sequences
 import gleam_community/maths/predicates

 pub fn example () {
   let assert Ok(tol) = elementary.power(-10.0, -6.0)
   let assert Ok(logspace) = sequences.geometric_space(10.0, 1000.0, 3, True)
   let assert Ok(result) =
     predicates.all_close(logspace, [10.0, 100.0, 1000.0], 0.0, tol)
   result
   |> list.all(fn(x) { x == True })
   |> should.be_true()

   // Input (start and stop can't be equal to 0.0)
   sequences.geometric_space(0.0, 1000.0, 3, False)
   |> should.be_error()
 
   sequences.geometric_space(-1000.0, 0.0, 3, False)
   |> should.be_error()

   // A negative number of points (-3) does not work
   sequences.geometric_space(10.0, 1000.0, -3, False)
   |> should.be_error()
 }

linear_space

</> 
pub fn linear_space(start: Float, stop: Float, num: Int, endpoint: Bool) -> Result(
  List(Float),
  String,
)

Generate a linearly spaced list of points over a specified interval. The endpoint of the interval can optionally be included/excluded.

Example: 
 import gleeunit/should
 import gleam_community/maths/elementary
 import gleam_community/maths/sequences
 import gleam_community/maths/predicates

 pub fn example () {
   let assert Ok(tol) = elementary.power(-10.0, -6.0)
   let assert Ok(linspace) = sequences.linear_space(10.0, 50.0, 5, True)
   let assert Ok(result) =
     predicates.all_close(linspace, [10.0, 20.0, 30.0, 40.0, 50.0], 0.0, tol)
   result
   |> list.all(fn(x) { x == True })
   |> should.be_true()

   // A negative number of points (-5) does not work
   sequences.linear_space(10.0, 50.0, -5, True)
   |> should.be_error()
 }

logarithmic_space

</> 
pub fn logarithmic_space(start: Float, stop: Float, num: Int, endpoint: Bool, base: Float) -> Result(
  List(Float),
  String,
)

Generate a logarithmically spaced list of points over a specified interval. The endpoint of the interval can optionally be included/excluded.

Example: 
 import gleeunit/should
 import gleam_community/maths/elementary
 import gleam_community/maths/sequences
 import gleam_community/maths/predicates

 pub fn example () {
   let assert Ok(tol) = elementary.power(-10.0, -6.0)
   let assert Ok(logspace) = sequences.logarithmic_space(1.0, 3.0, 3, True, 10.0)
   let assert Ok(result) =
     predicates.all_close(logspace, [10.0, 100.0, 1000.0], 0.0, tol)
   result
   |> list.all(fn(x) { x == True })
   |> should.be_true()

   // A negative number of points (-3) does not work
   sequences.logarithmic_space(1.0, 3.0, -3, False, 10.0)
   |> should.be_error()
 }
✨ Search Document