matrax v0.2.2 Matrax View Source

Use :atomics as an M x N matrix.

Erlang atomics documentation

Examples

iex> matrax = Matrax.new(100, 100) # 100 x 100 matrix
iex> matrax |> Matrax.put({0, 0}, 10) # add 10 to position {0, 0}
iex> matrax |> Matrax.get({0, 0})
10
iex> matrax |> Matrax.add({0, 0}, 80)
iex> matrax |> Matrax.get({0, 0})
90

Enumerable protocol

Matrax implements the Enumerable protocol, so all Enum functions can be used:

iex> matrax = Matrax.new(10, 10)
iex> matrax |> Matrax.put({0, 0}, 8)
iex> matrax |> Enum.max()
8
iex> matrax |> Enum.member?(7)
false

Link to this section Summary

Functions

Adds incr to atomic at position.

Atomic addition and return of the result.

Applies the given fun function to all elements of matrax.

Returns position tuple of biggest value.

Converts given column index of %Matrax{} to list.

Atomically compares the value at position with expected , and if those are equal, sets value at position to desired.

Returns a %Matrax{} struct with a new atomics reference and positional values identical to the given matrax.

Returns count of values (rows * columns).

Only modifies the struct, it doesn't move or mutate data.

Atomically replaces value at position with value and returns the value it had before.

Returns position of the first occurence of the given value or nil if nothing was found.

Flip columns of matrix in the left-right direction (vertical axis).

Flip rows of matrix in the up-down direction (horizontal axis).

Returns value at position from the given matrax.

Create identity square matrix of given size.

Returns a position tuple for the given atomics index.

Returns largest integer in matrax.

Checks if value exists within matrax.

Returns smallest integer in matrax.

Returns a new %Matrax{} struct.

Returns atomics index corresponding to the position tuple in the given %Matrax{} struct.

Puts value into matrax at position.

Reshapes matrax to the given rows & cols.

Converts given row index of %Matrax{} to list.

Subtracts decr from atomic at position.

Atomic subtraction and return of the result.

Only modifies the struct, it doesn't move or mutate data.

Returns sum of integers in matrax.

Converts %Matrax{} to a flat list.

Converts %Matrax{} to list of lists.

Only modifies the struct, it doesn't move or mutate data.

Link to this section Types

Link to this type

position()

View Source
position() :: {row :: non_neg_integer(), col :: non_neg_integer()}
Link to this type

t()

View Source
t() :: %Matrax{
  atomics: reference(),
  changes: list(),
  columns: pos_integer(),
  max: pos_integer(),
  min: integer(),
  rows: pos_integer(),
  signed: boolean()
}

Link to this section Functions

Link to this function

add(matrax, position, incr)

View Source
add(t(), position(), integer()) :: :ok

Adds incr to atomic at position.

Examples

iex> matrax = Matrax.new(10, 10)
iex> matrax |> Matrax.add({0, 0}, 2)
:ok
iex> matrax |> Matrax.add({0, 0}, 2)
:ok
iex> matrax |> Matrax.get({0, 0})
4
Link to this function

add_get(matrax, position, incr)

View Source
add_get(t(), position(), integer()) :: integer()

Atomic addition and return of the result.

Adds incr to atomic at position and returns result.

Examples

iex> matrax = Matrax.new(10, 10)
iex> matrax |> Matrax.add_get({0, 0}, 2)
2
iex> matrax |> Matrax.add_get({0, 0}, 2)
4
Link to this function

apply(matrax, fun)

View Source
apply(t(), (integer() -> integer()) | (integer(), position() -> integer())) ::
  :ok

Applies the given fun function to all elements of matrax.

If arity of fun is 1 it receives the integer as single argument. If arity of fun is 2 it receives the integer as first and position tuple as the second argument.

Examples

iex> matrax = Matrax.new(10, 10)
iex> matrax |> Matrax.apply(fn int -> int + 2 end)
iex> matrax |> Matrax.get({0, 0})
2
iex> matrax = Matrax.new(10, 10)
iex> matrax |> Matrax.apply(fn _int, {row, col} -> row * col end)
iex> matrax |> Matrax.get({9, 9})
81
Link to this function

argmax(matrax)

View Source
argmax(t()) :: integer()

Returns position tuple of biggest value.

Examples

iex> matrax = Matrax.new(5, 5, seed_fun: fn _, {row, col} -> row * col end)
iex> matrax |> Matrax.argmax()
{4, 4}
Link to this function

column_to_list(matrax, col)

View Source
column_to_list(t(), non_neg_integer()) :: [integer()]

Converts given column index of %Matrax{} to list.

Examples

iex> matrax = Matrax.new(5, 5, seed_fun: fn _, {row, col} -> row * col end)
iex> matrax |> Matrax.column_to_list(2)
[0, 2, 4, 6, 8]
Link to this function

compare_exchange(matrax, position, expected, desired)

View Source
compare_exchange(t(), position(), integer(), integer()) :: :ok | integer()

Atomically compares the value at position with expected , and if those are equal, sets value at position to desired.

Returns :ok if desired was written. Returns the actual value at position if it does not equal to desired.

Examples

iex> matrax = Matrax.new(10, 10)
iex> matrax |> Matrax.compare_exchange({0, 0}, 0, -10)
:ok
iex> matrax |> Matrax.compare_exchange({0, 0}, 3, 10)
-10
Link to this function

copy(matrax)

View Source
copy(t()) :: t()

Returns a %Matrax{} struct with a new atomics reference and positional values identical to the given matrax.

The returned copy is always changes: [] so this can be used to finish the access-path only changes by the transpose/1, submatrix/3, reshape/3 functions.

Examples

iex> matrax = Matrax.new(10, 10)
iex> matrax |> Matrax.put({0, 0}, -9)
iex> matrax2 =  Matrax.copy(matrax)
iex> Matrax.get(matrax2, {0, 0})
-9

Returns count of values (rows * columns).

Examples

iex> matrax = Matrax.new(5, 5)
iex> Matrax.count(matrax)
25
Link to this function

diagonal(matrax)

View Source
diagonal(t()) :: t()

Only modifies the struct, it doesn't move or mutate data.

After diagonal/1 the access path to positions will be modified during execution in position_to_index/2.

If you want to get a new :atomics with mofified data use the copy/1 function which applies the :changes.

Examples

iex> matrax = Matrax.identity(5)
iex> matrax |> Matrax.diagonal() |> Matrax.to_list_of_lists
[[1, 1, 1, 1, 1]]
Link to this function

do_find(matrax, same, same, value)

View Source
Link to this function

exchange(matrax, position, value)

View Source
exchange(t(), position(), integer()) :: integer()

Atomically replaces value at position with value and returns the value it had before.

Examples

iex> matrax = Matrax.new(10, 10)
iex> matrax |> Matrax.exchange({0, 0}, -10)
0
iex> matrax |> Matrax.exchange({0, 0}, -15)
-10
Link to this function

find(matrax, value)

View Source
find(t(), integer()) :: position() | nil

Returns position of the first occurence of the given value or nil if nothing was found.

Examples

iex> Matrax.new(5, 5) |> Matrax.find(0)
{0, 0}
iex> matrax = Matrax.new(5, 5, seed_fun: fn _, {row, col} -> row * col end)
iex> matrax |> Matrax.find(16)
{4, 4}
iex> matrax |> Matrax.find(42)
nil
Link to this function

flip_lr(matrax)

View Source
flip_lr(t()) :: t()

Flip columns of matrix in the left-right direction (vertical axis).

After flip_lr/1 the access path to positions will be modified during execution in position_to_index/2.

If you want to get a new :atomics with mofified data use the copy/1 function which applies the :changes.

Examples

iex> matrax = Matrax.new(3, 4, seed_fun: fn _, {_row, col} -> col end)
iex> matrax |> Matrax.to_list_of_lists()
[
    [0, 1, 2, 3],
    [0, 1, 2, 3],
    [0, 1, 2, 3]
]
iex> matrax |> Matrax.flip_lr() |> Matrax.to_list_of_lists()
[
    [3, 2, 1, 0],
    [3, 2, 1, 0],
    [3, 2, 1, 0]
]
Link to this function

flip_ud(matrax)

View Source
flip_ud(t()) :: t()

Flip rows of matrix in the up-down direction (horizontal axis).

After flip_ud/1 the access path to positions will be modified during execution in position_to_index/2.

If you want to get a new :atomics with mofified data use the copy/1 function which applies the :changes.

Examples

iex> matrax = Matrax.new(3, 4, seed_fun: fn _, {row, _col} -> row end)
iex> matrax |> Matrax.to_list_of_lists()
[
    [0, 0, 0, 0],
    [1, 1, 1, 1],
    [2, 2, 2, 2]
]
iex> matrax |> Matrax.flip_ud() |> Matrax.to_list_of_lists()
[
    [2, 2, 2, 2],
    [1, 1, 1, 1],
    [0, 0, 0, 0]
]
Link to this function

get(matrax, position)

View Source
get(t(), position()) :: integer()

Returns value at position from the given matrax.

Examples

iex> matrax = Matrax.new(10, 10, seed_fun: fn _ -> 3 end)
iex> matrax |> Matrax.get({0, 5})
3

Create identity square matrix of given size.

Examples

iex> Matrax.identity(5) |> Matrax.to_list_of_lists
[
    [1, 0, 0, 0, 0],
    [0, 1, 0, 0, 0],
    [0, 0, 1, 0, 0],
    [0, 0, 0, 1, 0],
    [0, 0, 0, 0, 1]
]
Link to this function

index_to_position(matrax, index)

View Source
index_to_position(t(), pos_integer()) :: position()

Returns a position tuple for the given atomics index.

Examples

iex> matrax = Matrax.new(10, 10)
iex> Matrax.index_to_position(matrax, 10)
{0, 9}

Returns largest integer in matrax.

Examples

iex> matrax = Matrax.new(10, 10, seed_fun: fn _, {row, col} -> row * col end)
iex> matrax |> Matrax.max()
81
iex> Matrax.new(5, 5) |> Matrax.max()
0
Link to this function

member?(matrax, value)

View Source
member?(t(), integer()) :: boolean()

Checks if value exists within matrax.

Examples

iex> matrax = Matrax.new(5, 5, seed_fun: fn _, {row, col} -> row * col end)
iex> matrax |> Matrax.member?(6)
true
iex> matrax |> Matrax.member?(100)
false

Returns smallest integer in matrax.

Examples

iex> matrax = Matrax.new(10, 10, seed_fun: fn _ -> 7 end)
iex> matrax |> Matrax.min()
7
Link to this function

new(rows, columns, options \\ [])

View Source
new(pos_integer(), pos_integer(), list()) :: t()

Returns a new %Matrax{} struct.

Options

  • :seed_fun - a function to seed all positions. See apply/2 for further information.
  • :signed - whether to have signed or unsigned 64bit integers

Examples

 Matrax.new(10, 5) # 10 x 5 matrix
 Matrax.new(10, 5, signed: false) # unsigned integers
 Matrax.new(10, 5, seed_fun: fn _, {row, col} -> row * col end) # seed values
Link to this function

position_to_index(matrax, arg)

View Source
position_to_index(t(), position()) :: pos_integer()

Returns atomics index corresponding to the position tuple in the given %Matrax{} struct.

Examples

iex> matrax = Matrax.new(10, 10)
iex> matrax |> Matrax.position_to_index({1, 1})
12
iex> matrax |> Matrax.position_to_index({0, 4})
5
Link to this function

put(matrax, position, value)

View Source
put(t(), position(), integer()) :: :ok

Puts value into matrax at position.

Returns :ok

Examples

iex> matrax = Matrax.new(10, 10)
iex> matrax |> Matrax.put({1, 3}, 5)
:ok
Link to this function

reshape(matrax, desired_rows, desired_columns)

View Source
reshape(t(), pos_integer(), pos_integer()) :: t()

Reshapes matrax to the given rows & cols.

After reshape/3 the access path to positions will be modified during execution in position_to_index/2.

If you want to get a new :atomics with mofified data use the copy/1 function which applies the :changes.

Examples

iex> matrax = Matrax.new(4, 3, seed_fun: fn _, {_row, col} -> col end)
iex> matrax |> Matrax.to_list_of_lists()
[
    [0, 1, 2],
    [0, 1, 2],
    [0, 1, 2],
    [0, 1, 2]
]
iex> matrax |> Matrax.reshape(2, 6) |> Matrax.to_list_of_lists()
[
    [0, 1, 2, 0, 1, 2],
    [0, 1, 2, 0, 1, 2]
]
Link to this function

row_to_list(matrax, row)

View Source
row_to_list(t(), non_neg_integer()) :: [integer()]

Converts given row index of %Matrax{} to list.

Examples

iex> matrax = Matrax.new(5, 5, seed_fun: fn _, {row, col} -> row * col end)
iex> matrax |> Matrax.row_to_list(2)
[0, 2, 4, 6, 8]
Link to this function

sub(matrax, position, decr)

View Source
sub(t(), position(), integer()) :: :ok

Subtracts decr from atomic at position.

Examples

iex> matrax = Matrax.new(10, 10)
iex> matrax |> Matrax.sub({0, 0}, 1)
:ok
iex> matrax |> Matrax.sub({0, 0}, 1)
:ok
iex> matrax |> Matrax.get({0, 0})
-2
Link to this function

sub_get(matrax, position, decr)

View Source
sub_get(t(), position(), integer()) :: integer()

Atomic subtraction and return of the result.

Subtracts decr from atomic at position and returns result.

Examples

iex> matrax = Matrax.new(10, 10)
iex> matrax |> Matrax.sub_get({0, 0}, 2)
-2
iex> matrax |> Matrax.sub_get({0, 0}, 2)
-4
Link to this function

submatrix(matrax, row_range, col_range)

View Source
submatrix(t(), Range.t(), Range.t()) :: t()

Only modifies the struct, it doesn't move or mutate data.

Ranges are inclusive.

After submatrix/3 the access path to positions will be modified during execution in position_to_index/2.

If you want to get a new :atomics with mofified data use the copy/1 function which applies the :changes.

Examples

iex> matrax = Matrax.new(7, 4, seed_fun: fn _, {row, col} -> row + col end)
iex> matrax |> Matrax.to_list_of_lists()
[
    [0, 1, 2, 3],
    [1, 2, 3, 4],
    [2, 3, 4, 5],
    [3, 4, 5, 6],
    [4, 5, 6, 7],
    [5, 6, 7, 8],
    [6, 7, 8, 9]
]
iex> matrax |> Matrax.submatrix(5..6, 1..3) |> Matrax.to_list_of_lists()
[
    [6, 7, 8],
    [7, 8, 9]
]

Returns sum of integers in matrax.

Examples

iex> matrax = Matrax.new(10, 10, seed_fun: fn _, {row, col} -> row * col end)
iex> matrax |> Matrax.sum()
2025
iex> Matrax.new(5, 5, seed_fun: fn _ -> 1 end) |> Matrax.sum()
25
Link to this function

to_list(matrax)

View Source
to_list(t()) :: [integer()]

Converts %Matrax{} to a flat list.

Examples

iex> matrax = Matrax.new(3, 3, seed_fun: fn _, {row, col} -> row * col end)
iex> Matrax.to_list(matrax)
[0, 0, 0, 0, 1, 2, 0, 2, 4]
Link to this function

to_list_of_lists(matrax)

View Source
to_list_of_lists(t()) :: [[integer()]]

Converts %Matrax{} to list of lists.

Examples

iex> matrax = Matrax.new(5, 5, seed_fun: fn _, {row, col} -> row * col end)
iex> Matrax.to_list_of_lists(matrax)
[
  [0, 0, 0, 0, 0],
  [0, 1, 2, 3, 4],
  [0, 2, 4, 6, 8],
  [0, 3, 6, 9, 12],
  [0, 4, 8, 12, 16]
]
Link to this function

transpose(matrax)

View Source
transpose(t()) :: t()

Only modifies the struct, it doesn't move or mutate data.

After transpose/1 the access path to positions will be modified during execution in position_to_index/2.

If you want to get a new :atomics with mofified data use the copy/1 function which applies the :changes.

Examples

iex> matrax = Matrax.new(7, 4, seed_fun: fn _, {row, col} -> row + col end)
iex> matrax |> Matrax.to_list_of_lists()
[
    [0, 1, 2, 3],
    [1, 2, 3, 4],
    [2, 3, 4, 5],
    [3, 4, 5, 6],
    [4, 5, 6, 7],
    [5, 6, 7, 8],
    [6, 7, 8, 9]
]
iex> matrax |> Matrax.transpose() |> Matrax.to_list_of_lists()
[
    [0, 1, 2, 3, 4, 5, 6],
    [1, 2, 3, 4, 5, 6, 7],
    [2, 3, 4, 5, 6, 7, 8],
    [3, 4, 5, 6, 7, 8, 9]
]