6 releases

0.3.2 Dec 18, 2023
0.3.1 Dec 12, 2023
0.3.0 Dec 8, 2022
0.2.1 Jun 18, 2019
0.1.0 Jun 10, 2019

#137 in Data structures

Download history 565/week @ 2024-01-27 538/week @ 2024-02-03 649/week @ 2024-02-10 680/week @ 2024-02-17 470/week @ 2024-02-24 625/week @ 2024-03-02 798/week @ 2024-03-09 763/week @ 2024-03-16 714/week @ 2024-03-23 828/week @ 2024-03-30 548/week @ 2024-04-06 723/week @ 2024-04-13 735/week @ 2024-04-20 969/week @ 2024-04-27 653/week @ 2024-05-04 551/week @ 2024-05-11

2,991 downloads per month
Used in 13 crates (9 directly)

MIT license

55KB
358 lines

array2d

Array2D provides a fixed sized two-dimensional array. It is more efficient and is easier to use than a vector of vectors, i.e. Vec<Vec<T>>.

This is beneficial when using a grid-like structure, which is common in image processing, game boards, and other situations. Array2D cannot be used when rows or columns might have different lengths⁠—all rows and columns must be the same length.

How to use Array2D

Creating an Array2D

An Array2D can be created in many different ways. These include:

Accessing data from an Array2D

Array2D supports several forms of indexing:

Array2D also supports several forms of iteration. You can iterate through:

Extracting all data from an Array2D

An Array2D can be converted back into a Vec through several methods. You can extract the data as:

Examples

use array2d::{Array2D, Error};

pub fn main() -> Result<(), Error> {
    // Create an array filled with the same element.
    let prefilled = Array2D::filled_with(42, 2, 3);
    assert_eq!(prefilled.num_rows(), 2);
    assert_eq!(prefilled.num_columns(), 3);
    assert_eq!(prefilled[(0, 0)], 42);

    // Create an array from the given rows. You can also use columns
    // with the `columns` function
    let rows = vec![vec![1, 2, 3], vec![4, 5, 6]];
    let from_rows = Array2D::from_rows(&rows)?;
    assert_eq!(from_rows.num_rows(), 2);
    assert_eq!(from_rows.num_columns(), 3);
    assert_eq!(from_rows[(1, 1)], 5);

    // Create an array from a flat Vec of elements in row major or
    // column major order.
    let column_major = vec![1, 4, 2, 5, 3, 6];
    let from_column_major =
        Array2D::from_column_major(&column_major, 2, 3)?;
    assert_eq!(from_column_major.num_rows(), 2);
    assert_eq!(from_column_major.num_columns(), 3);
    assert_eq!(from_column_major[(1, 1)], 5);

    // Implements `Eq` if the element type does.
    assert_eq!(from_rows, from_column_major);

    // Index into an array using a tuple of usize to access or alter
    // the array.
    let rows = vec![vec![1, 2, 3], vec![4, 5, 6]];
    let mut array = Array2D::from_rows(&rows)?;
    array[(1, 1)] = 100;

    // Convert the array back into a nested Vec using `as_rows` or
    // `as_columns`.
    let array_rows = array.as_rows();
    assert_eq!(array_rows, vec![vec![1, 2, 3], vec![4, 100, 6]]);

    // Convert the array back into a flat Vec using `as_row_major` or
    // `as_column_major`.
    let array_column_major = array.as_column_major();
    assert_eq!(array_column_major, vec![1, 4, 2, 100, 3, 6]);

    // Iterate over a single row or column
    println!("First column:");
    for element in array.column_iter(0)? {
        println!("{}", element);
    }

    // Iterate over all rows or columns.
    println!("All elements:");
    for row_iter in array.rows_iter() {
        for element in row_iter {
            print!("{} ", element);
        }
        println!();
    }

    Ok(())
}

License: MIT

Dependencies

~180KB