order: Add enum Order

Author: bluss

src/lib.rs

@@ -145,6 +145,7 @@ pub use crate::dimension::IxDynImpl;
 pub use crate::dimension::NdIndex;
 pub use crate::error::{ErrorKind, ShapeError};
 pub use crate::indexes::{indices, indices_of};
+pub use crate::order::Order;
 pub use crate::slice::{
     MultiSliceArg, NewAxis, Slice, SliceArg, SliceInfo, SliceInfoElem, SliceNextDim,
 };
@@ -202,6 +203,7 @@ mod linspace;
 mod logspace;
 mod math_cell;
 mod numeric_util;
+mod order;
 mod partial;
 mod shape_builder;
 #[macro_use]

src/order.rs

@@ -0,0 +1,83 @@
+
+/// 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:
+///
+/// ```text
+/// 1  2  3
+/// 4  5  6
+/// ```
+///
+/// If it is laid using column major ordering, it results in:
+///
+/// ```text
+/// 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.
+#[derive(Copy, Clone, Debug, PartialEq, Eq)]
+#[non_exhaustive]
+pub enum Order {
+    /// Row major or "C" order
+    RowMajor,
+    /// Column major or "F" order
+    ColumnMajor,
+}
+
+impl Order {
+    /// "C" is an alias for row major ordering
+    pub const C: Order = Order::RowMajor;
+
+    /// "F" (for Fortran) is an alias for column major ordering
+    pub const F: Order = Order::ColumnMajor;
+
+    /// Return true if input is Order::RowMajor, false otherwise
+    #[inline]
+    pub fn is_row_major(self) -> bool {
+        match self {
+            Order::RowMajor => true,
+            Order::ColumnMajor => false,
+        }
+    }
+
+    /// Return true if input is Order::ColumnMajor, false otherwise
+    #[inline]
+    pub fn is_column_major(self) -> bool {
+        !self.is_row_major()
+    }
+
+    /// Return Order::RowMajor if the input is true, Order::ColumnMajor otherwise
+    #[inline]
+    pub fn row_major(row_major: bool) -> Order {
+        if row_major { Order::RowMajor } else { Order::ColumnMajor }
+    }
+
+    /// Return Order::ColumnMajor if the input is true, Order::RowMajor otherwise
+    #[inline]
+    pub fn column_major(column_major: bool) -> Order {
+        Self::row_major(!column_major)
+    }
+
+    /// Return the transpose: row major becomes column major and vice versa.
+    #[inline]
+    pub fn transpose(self) -> Order {
+        match self {
+            Order::RowMajor => Order::ColumnMajor,
+            Order::ColumnMajor => Order::RowMajor,
+        }
+    }
+}