use super::selection::validate_selection;
use super::{DataError, SelectionError};
use std::slice::ChunksExact;
fn validated_matrix_len(rows: usize, columns: usize, actual: usize) -> Result<usize, DataError> {
if rows == 0 {
return Err(DataError::ZeroRows);
}
if columns == 0 {
return Err(DataError::ZeroColumns);
}
let expected = rows
.checked_mul(columns)
.ok_or(DataError::DimensionOverflow { rows, columns })?;
if actual != expected {
return Err(DataError::LengthMismatch { expected, actual });
}
Ok(expected)
}
fn validate_finite(values: &[f32]) -> Result<(), DataError> {
if let Some(index) = values.iter().position(|value| !value.is_finite()) {
return Err(DataError::NonFiniteValue { index });
}
Ok(())
}
#[derive(Clone, Copy, Debug, PartialEq)]
pub struct MatrixView<'a> {
values: &'a [f32],
rows: usize,
columns: usize,
}
impl<'a> MatrixView<'a> {
pub fn new(values: &'a [f32], rows: usize, columns: usize) -> Result<Self, DataError> {
validated_matrix_len(rows, columns, values.len())?;
validate_finite(values)?;
Ok(Self {
values,
rows,
columns,
})
}
pub(crate) fn from_validated_parts(values: &'a [f32], rows: usize, columns: usize) -> Self {
assert!(rows != 0 && columns != 0, "validated matrix shape is empty");
assert_eq!(
values.len(),
rows.saturating_mul(columns),
"validated matrix shape does not describe its buffer"
);
debug_assert!(values.iter().all(|value| value.is_finite()));
Self {
values,
rows,
columns,
}
}
pub(crate) fn to_dense(self) -> DenseMatrix {
DenseMatrix::from_validated_parts(self.values.to_vec(), self.rows, self.columns)
}
#[inline]
pub const fn rows(&self) -> usize {
self.rows
}
#[inline]
pub const fn columns(&self) -> usize {
self.columns
}
#[inline]
pub const fn as_slice(&self) -> &'a [f32] {
self.values
}
#[inline]
pub fn row(&self, index: usize) -> Option<&'a [f32]> {
let start = index.checked_mul(self.columns)?;
let end = start.checked_add(self.columns)?;
self.values.get(start..end)
}
#[inline]
pub fn get(&self, row: usize, column: usize) -> Option<f32> {
if column >= self.columns {
return None;
}
let index = row.checked_mul(self.columns)?.checked_add(column)?;
self.values.get(index).copied()
}
#[inline]
pub fn iter_rows(&self) -> ChunksExact<'a, f32> {
self.values.chunks_exact(self.columns)
}
}
#[derive(Clone, Debug, PartialEq)]
pub struct DenseMatrix {
values: Vec<f32>,
rows: usize,
columns: usize,
}
impl DenseMatrix {
pub fn new(values: Vec<f32>, rows: usize, columns: usize) -> Result<Self, DataError> {
validated_matrix_len(rows, columns, values.len())?;
validate_finite(&values)?;
Ok(Self {
values,
rows,
columns,
})
}
pub(crate) fn from_validated_parts(values: Vec<f32>, rows: usize, columns: usize) -> Self {
assert!(rows != 0 && columns != 0, "validated matrix shape is empty");
assert_eq!(
values.len(),
rows.saturating_mul(columns),
"validated matrix shape does not describe its buffer"
);
debug_assert!(values.iter().all(|value| value.is_finite()));
Self {
values,
rows,
columns,
}
}
#[inline]
pub const fn rows(&self) -> usize {
self.rows
}
#[inline]
pub const fn columns(&self) -> usize {
self.columns
}
#[inline]
pub fn as_view(&self) -> MatrixView<'_> {
MatrixView {
values: &self.values,
rows: self.rows,
columns: self.columns,
}
}
#[inline]
pub fn as_slice(&self) -> &[f32] {
&self.values
}
#[inline]
pub fn row(&self, index: usize) -> Option<&[f32]> {
self.as_view().row(index)
}
#[inline]
pub fn get(&self, row: usize, column: usize) -> Option<f32> {
self.as_view().get(row, column)
}
#[inline]
pub fn iter_rows(&self) -> ChunksExact<'_, f32> {
self.values.chunks_exact(self.columns)
}
#[inline]
pub fn into_values(self) -> Vec<f32> {
self.values
}
pub fn select_rows(&self, indices: &[usize]) -> Result<Self, SelectionError> {
validate_selection(indices, self.rows)?;
let output_len =
indices
.len()
.checked_mul(self.columns)
.ok_or(SelectionError::OutputShapeOverflow {
rows: indices.len(),
columns: self.columns,
})?;
let mut values = Vec::with_capacity(output_len);
for &index in indices {
values.extend_from_slice(self.row(index).expect("selection index was validated"));
}
Ok(Self {
values,
rows: indices.len(),
columns: self.columns,
})
}
}