glat - v0.1.0

glat

Types

Rational

</> 
pub type Rational {
  Rational(num: Int, den: Int)
}

Constructors 

  • Rational(num: Int, den: Int)

    ⚠⚠ It is unsafe to raw construct this from unknown input, as these functions assume the rational they take in do not have a 0 or negative denominator. You should use new.

Constants

one

</> 
pub const one: Rational

1/1

zero

</> 
pub const zero: Rational

0/1

Functions

absolute_value

</> 
pub fn absolute_value(rat: Rational) -> Rational

|num| / den

add

</> 
pub fn add(lhs: Rational, rhs: Rational) -> Rational

ceiling

</> 
pub fn ceiling(rat: Rational) -> Rational

Rounds the rational upwards.

clamp

</> 
pub fn clamp(
  rat: Rational,
  min min_bound: Rational,
  max max_bound: Rational,
) -> Rational

Restricts a rational between a lower and upper bound.

compare

</> 
pub fn compare(lhs: Rational, rhs: Rational) -> Order

digits

</> 
pub fn digits(
  rat: Rational,
  base: Int,
) -> Result(#(List(Int), List(Int)), Nil)

Splits the numerator and denominator into their digit representations in the specified base. Returns an error if the base is less than 2.

divide

</> 
pub fn divide(lhs: Rational, rhs: Rational) -> Rational

Also a new for rationals.

Returns zero if the second rational’s numerator is 0 because you are dividing the first rational by zero.

divide_check

</> 
pub fn divide_check(
  lhs: Rational,
  rhs: Rational,
) -> Result(Rational, Nil)

Also a new for rationals.

Returns Error if the second rational’s numerator is 0, because you are dividing the first rational by zero.

flip

</> 
pub fn flip(rat: Rational) -> Rational

Swap the numerator and denominator.

Returns zero if the numerator is 0.

flip_check

</> 
pub fn flip_check(rat: Rational) -> Result(Rational, Nil)

Swap the numerator and denominator.

Returns an Error if the numerator is 0.

floor

</> 
pub fn floor(rat: Rational) -> Rational

Rounds the rational upwards.

fraction

</> 
pub fn fraction(rat: Rational) -> Rational

Get the fractional part of a mixed fraction. Uses truncated division.

fraction_floor

</> 
pub fn fraction_floor(rat: Rational) -> Rational

Get the fractional part of a mixed fraction. Uses floored division.

from_float

</> 
pub fn from_float(f: Float) -> Rational

Returns zero if the float is 0.0.

from_float_check

</> 
pub fn from_float_check(f: Float) -> Result(Rational, Nil)

Returns Error if the float is 0.0.

from_int

</> 
pub fn from_int(num: Int) -> Rational

num / 1.

int_power

</> 
pub fn int_power(base: Int, of exponent: Int) -> Rational

Returns zero if the numerator is 0 and the exponent is negative, because the negative exponent makes it 1/0.

int_power_check

</> 
pub fn int_power_check(
  base: Int,
  of exponent: Int,
) -> Result(Rational, Nil)

Returns Error if the numerator is 0 and the exponent is negative, because the negative exponent makes it 1/0.

is_negative

</> 
pub fn is_negative(rat: Rational) -> Bool

is_positive

</> 
pub fn is_positive(rat: Rational) -> Bool

map_both

</> 
pub fn map_both(rat: Rational, fun: fn(Int) -> Int) -> Rational

map_both_check

</> 
pub fn map_both_check(
  rat: Rational,
  fun: fn(Int) -> Int,
) -> Result(Rational, Nil)

map_den

</> 
pub fn map_den(rat: Rational, fun: fn(Int) -> Int) -> Rational

map_den_check

</> 
pub fn map_den_check(
  rat: Rational,
  fun: fn(Int) -> Int,
) -> Result(Rational, Nil)

map_num

</> 
pub fn map_num(rat: Rational, fun: fn(Int) -> Int) -> Rational

map_seperate

</> 
pub fn map_seperate(
  rat: Rational,
  fun1: fn(Int) -> Int,
  fun2: fn(Int) -> Int,
) -> Rational

map_seperate_check

</> 
pub fn map_seperate_check(
  rat: Rational,
  fun1: fn(Int) -> Int,
  fun2: fn(Int) -> Int,
) -> Result(Rational, Nil)

max

</> 
pub fn max(rat1: Rational, rat2: Rational) -> Rational

Returns the largest of two rationals.

min

</> 
pub fn min(rat1: Rational, rat2: Rational) -> Rational

Returns the smallest of two rationals.

modulo

</> 
pub fn modulo(rat: Rational) -> Int

This uses floor division. See remainder for truncated division.

multiply

</> 
pub fn multiply(lhs: Rational, rhs: Rational) -> Rational

negate

</> 
pub fn negate(rat: Rational) -> Rational

new

</> 
pub fn new(num: Int, over den: Int) -> Rational

Returns zero if the denominator is 0.

new_check

</> 
pub fn new_check(
  num: Int,
  over den: Int,
) -> Result(Rational, Nil)

Returns Error if the denominator is 0.

parse

</> 
pub fn parse(str: String) -> Result(Rational, Nil)

Only parses {num}/{den}.

Returns Error if the parsing fails.
Returns zero if the denominator is 0.

parse_check

</> 
pub fn parse_check(str: String) -> Result(Rational, Nil)

Only parses {num}/{den}.

Returns Error if the parsing fails, or the denominator is 0.

power

</> 
pub fn power(rat: Rational, of exponent: Int) -> Rational

Returns zero if the numerator is 0 and the exponent is negative, because the negative exponent makes it 1/0.

power_check

</> 
pub fn power_check(
  rat: Rational,
  of exponent: Int,
) -> Result(Rational, Nil)

Returns Error if the numerator is 0 and the exponent is negative, because the negative exponent makes it 1/0.

product

</> 
pub fn product(rats: List(Rational)) -> Rational

Multiplies a list of rationals and returns the product.

random

</> 
pub fn random(over den: Int) -> Rational

This returns (0..=den)/den.
A negative denominator will negate the result.

Returns zero if den is 0.

random_check

</> 
pub fn random_check(over den: Int) -> Result(Rational, Nil)

This returns (0..=den)/den.
A negative denominator will negate the result.

Returns Error if the integer is 0.

reduce

</> 
pub fn reduce(rat: Rational) -> Rational

Simplify the rational.

remainder

</> 
pub fn remainder(rat: Rational) -> Int

This uses truncated division like the % operator does. See modulo for floor division.

round

</> 
pub fn round(rat: Rational) -> Rational

floor if it is less than 1/2, ceiling otherwise.

square_root

</> 
pub fn square_root(rat: Rational) -> Rational

TODO: make this function (or a new function) not have a float limitation.

Panics if the numerator and denominator are not in the bounds of a float.
Returns zero if the rational is negative.

square_root_check

</> 
pub fn square_root_check(rat: Rational) -> Result(Rational, Nil)

TODO: make this function (or a new function) not have a float limitation.

Panics if the numerator and denominator are not in the bounds of a float.
Returns Error if the rational is negative.

subtract

</> 
pub fn subtract(lhs: Rational, rhs: Rational) -> Rational

sum

</> 
pub fn sum(rats: List(Rational)) -> Rational

Sums a list of rationals.

to_float

</> 
pub fn to_float(rat: Rational) -> Float

Panics if the numerator or denominator are not in range of a Float.

to_int

</> 
pub fn to_int(rat: Rational) -> Int

Result of num / den. Also getting the whole part of a mixed fraction.

to_int_floor

</> 
pub fn to_int_floor(rat: Rational) -> Int

Result of int.floor_divide(num, den). Also getting the whole part of a mixed fraction.

to_string

</> 
pub fn to_string(rat: Rational) -> String

Join the numerator and denominator with a “/”.

undigits

</> 
pub fn undigits(
  tup: #(List(Int), List(Int)),
  base: Int,
) -> Result(Rational, Nil)

Joins two lists of digits into a rational.

Returns an error if the base is less than 2, or the list contains a digit greater than or equal to the specified base.
Returns zero if the second list of digits equal zero.

undigits_check

</> 
pub fn undigits_check(
  tup: #(List(Int), List(Int)),
  base: Int,
) -> Result(Rational, Nil)

Joins two lists of digits into a rational.

Returns Error if the base is less than 2, the list contains a digit greater than or equal to the specified base, or the second list of digits equal zero.

unwrap

</> 
pub fn unwrap(res: Result(Rational, Nil)) -> Rational

Replace error with zero.

✨ Search Document