argamak/space

Types

An n-dimensional Space containing Axes of various sizes.

pub opaque type Space

An error returned when attempting to create an invalid Space.

pub type SpaceError {
  CannotMerge
  CannotInfer
  DuplicateName
  InvalidSize
  SpaceError(reason: SpaceError, axes: Axes)
}

Constructors

  • CannotMerge
  • CannotInfer
  • DuplicateName
  • InvalidSize
  • SpaceError(reason: SpaceError, axes: Axes)

A SpaceError list.

pub type SpaceErrors =
  List(SpaceError)

A Result alias type for spaces.

pub type SpaceResult =
  Result(Space, SpaceErrors)

Functions

pub fn axes(x: Space) -> List(Axis)

Returns the axes of a given Space.

Examples

> new() |> axes
[]

> import argamak/axis.{A, B, Infer}
> let assert Ok(space) = d1(Infer("A"))
> axes(space)
[Infer("A")]

> let assert Ok(space) = d3(A(2), B(2), Infer("C"))
> axes(space)
[A(2), B(2), Infer("C")]
pub fn d1(a: Axis) -> Result(Space, List(SpaceError))

Results in a one-dimensional Space on success, or SpaceErrors on failure.

Examples

> import argamak/axis.{Infer}
> let assert Ok(space) = d1(Infer("A"))
> axes(space)
[Infer("A")]
pub fn d2(a: Axis, b: Axis) -> Result(Space, List(SpaceError))

Results in a two-dimensional Space on success, or SpaceErrors on failure.

Examples

> import argamak/axis.{A, B}
> let assert Ok(space) = d2(A(2), B(2))
> axes(space)
[A(2), B(2)]
pub fn d3(
  a: Axis,
  b: Axis,
  c: Axis,
) -> Result(Space, List(SpaceError))

Results in a three-dimensional Space on success, or SpaceErrors on failure.

Examples

> import argamak/axis.{A, B, Infer}
> let assert Ok(space) = d3(A(2), B(2), Infer("C"))
> axes(space)
[A(2), B(2), Infer("C")]
pub fn d4(
  a: Axis,
  b: Axis,
  c: Axis,
  d: Axis,
) -> Result(Space, List(SpaceError))

Results in a four-dimensional Space on success, or SpaceErrors on failure.

Examples

> import argamak/axis.{A, B, D, Infer}
> let assert Ok(space) = d4(A(2), B(2), Infer("C"), D(1))
> axes(space)
[A(2), B(2), Infer("C"), D(1)]
pub fn d5(
  a: Axis,
  b: Axis,
  c: Axis,
  d: Axis,
  e: Axis,
) -> Result(Space, List(SpaceError))

Results in a five-dimensional Space on success, or SpaceErrors on failure.

Examples

> import argamak/axis.{A, B, C, D, E}
> let assert Ok(space) = d5(A(5), B(4), C(3), D(2), E(1))
> axes(space)
[A(5), B(4), C(3), D(2), E(1)]
pub fn d6(
  a: Axis,
  b: Axis,
  c: Axis,
  d: Axis,
  e: Axis,
  f: Axis,
) -> Result(Space, List(SpaceError))

Results in a six-dimensional Space on success, or SpaceErrors on failure.

Examples

> import argamak/axis.{A, B, C, D, E, F}
> let assert Ok(space) = d6(A(9), B(9), C(9), D(9), E(9), F(9))
> axes(space)
[A(9), B(9), C(9), D(9), E(9), F(9)]
pub fn degree(x: Space) -> Int

Returns the degree of a given Space.

Examples

> new() |> degree
0

> import argamak/axis.{A, B, Infer}
> let assert Ok(space) = d1(Infer("A"))
> degree(space)
1

> let assert Ok(space) = d3(A(2), B(2), Infer("C"))
> degree(space)
3
pub fn from_list(
  x: List(Axis),
) -> Result(Space, List(SpaceError))

Results in a Space created from a list of Axes on success, or SpaceErrors on failure.

Examples

> import argamak/axis.{A, B, C, D, E, F, Z}
> let assert Ok(space) = from_list([A(9), B(9), C(9), D(9), E(9), F(9), Z(9)])
> axes(space)
[A(9), B(9), C(9), D(9), E(9), F(9), Z(9)]
pub fn map(
  x: Space,
  with fun: fn(Axis) -> Axis,
) -> Result(Space, List(SpaceError))

Results in a new Space with the same number of dimensions as the given Space on success, or SpaceErrors on failure.

Applies the given function to each Axis of the Space.

Examples

> import argamak/axis.{B, C, Infer}
> let assert Ok(space) = map(new(), with: fn(_) { C(3) })
> axes(space)
[]

> let assert Ok(space) = d1(Infer("A"))
> let assert Ok(space) = map(space, with: fn(_) { C(3) })
> axes(space)
[C(3)]

> let assert Ok(space) = d3(Infer("A"), B(2), C(2))
> let assert Ok(space) = map(space, with: fn(axis) {
>   case axis {
>     Infer(_) -> axis.resize(axis, 4)
>     _else -> axis
>   }
> })
> axes(space)
[A(4), B(2), C(2)]
pub fn merge(
  a: Space,
  b: Space,
) -> Result(Space, List(SpaceError))

Results in a new Space that is the element-wise maximum of the given spaces on success, or SpaceErrors on failure.

Spaces are merged tail-first, and corresponding Axis names must match.

Examples

> import argamak/axis.{Axis, Infer, X, Y}
> let assert Ok(a) = d1(Infer("X"))
> merge(a, new()) |> result.map(with: axes)
Ok([Infer("X")])

> let assert Ok(b) = d2(Axis("Sparkle", 2), X(2))
> merge(a, b) |> result.map(with: axes)
Ok([Axis("Sparkle", 2), Infer("X")])

> let assert Ok(c) = d3(Infer("X"), Axis("Sparkle", 3), Y(3))
> merge(b, c)
Error([SpaceError(CannotMerge, [Y(3), X(2)])])
pub fn new() -> Space

Results in a dimensionless Space.

Examples

> new() |> axes
[]
pub fn shape(x: Space) -> List(Int)

Returns the shape of a given Space.

Examples

> new() |> shape
[]

> import argamak/axis.{A, B, Infer}
> let assert Ok(space) = d1(Infer("A"))
> shape(space)
[0]

> let assert Ok(space) = d3(A(2), B(2), Infer("C"))
> shape(space)
[2, 2, 0]
pub fn to_string(x: Space) -> String

Converts a Space into a String.

Examples

> new() |> to_string
"Space()"

> import argamak/axis.{A, B, Axis, Infer}
> let assert Ok(space) = d1(Axis("Sparkle", 2))
> to_string(space)
"Space(Axis(\"Sparkle\", 2))"

> let assert Ok(space) = d3(A(2), B(2), Infer("C"))
> to_string(space)
"Space(A(2), B(2), Infer(\"C\"))"
Search Document