Enum Order

#[non_exhaustive]
pub enum Order {
    RowMajor,
    ColumnMajor,
}

Array order

Order refers to indexing order, or how a linear sequence is translated into a two-dimensional or multi-dimensional array.

• RowMajor means that the index along the row is the most rapidly changing
• ColumnMajor means that the index along the column is the most rapidly changing

Given a sequence like: 1, 2, 3, 4, 5, 6

If it is laid it out in a 2 x 3 matrix using row major ordering, it results in:

1  2  3
4  5  6

If it is laid using column major ordering, it results in:

1  3  5
2  4  6

It can be seen as filling in “rows first” or “columns first”.

Order can be used both to refer to logical ordering as well as memory ordering or memory layout. The orderings have common short names, also seen in other environments, where row major is called “C” order (after the C programming language) and column major is called “F” or “Fortran” order.

Variants (Non-exhaustive)

Non-exhaustive enums could have additional variants added in future. Therefore, when matching against variants of non-exhaustive enums, an extra wildcard arm must be added to account for any future variants.

RowMajor

Row major or “C” order

ColumnMajor

Column major or “F” order

Implementations

impl Order

pub const C: Order = Order::RowMajor

“C” is an alias for row major ordering

pub const F: Order = Order::ColumnMajor

“F” (for Fortran) is an alias for column major ordering

pub fn is_row_major(self) -> bool

Return true if input is Order::RowMajor, false otherwise

pub fn is_column_major(self) -> bool

Return true if input is Order::ColumnMajor, false otherwise

pub fn row_major(row_major: bool) -> Order

Return Order::RowMajor if the input is true, Order::ColumnMajor otherwise

pub fn column_major(column_major: bool) -> Order

Return Order::ColumnMajor if the input is true, Order::RowMajor otherwise

pub fn transpose(self) -> Order

Return the transpose: row major becomes column major and vice versa.

Trait Implementations

impl Clone for Order

fn clone(&self) -> Order

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Order

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Formats the value using the given formatter.

impl PartialEq for Order

fn eq(&self, other: &Order) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Copy for Order

impl Eq for Order

impl StructuralPartialEq for Order