boreholeio 0.1.0

use super::{utils::slice_view1, Base, ChannelAxis, Error, Numeric, NumericAxis, OrderedNumeric};
use ndarray::{Array1, SliceInfoElem};
use serde::{Deserialize, Serialize};

#[derive(Clone, Debug, Deserialize, Serialize)]
pub struct LinearAxis {
    pub extents: [f64; 2],
    pub size: usize,
    pub name: String,
    pub units: Option<String>,
    pub period: Option<f64>,
}

impl Base for LinearAxis {
    fn size(&self) -> Result<usize, Error> {
        Ok(self.size)
    }

    fn slice(&self, slice_info: &SliceInfoElem) -> Result<ChannelAxis, Error> {
        if matches!(slice_info, SliceInfoElem::NewAxis) {
            return Err("SliceInfoElem::NewAxis variant is not supported".into());
        }

        let coordinates = self.coordinates()?;
        let slice = slice_view1(coordinates.view(), slice_info)?;

        if slice.is_empty() {
            return Err("LinearAxis cannot be empty".into());
        }

        Ok(Self {
            extents: [*slice.first().unwrap(), *slice.last().unwrap()],
            size: slice.len(),
            name: self.name.clone(),
            units: self.units.clone(),
            period: self.period,
        }
        .into())
    }
}

impl Numeric for LinearAxis {
    fn name(&self) -> &str {
        &self.name
    }

    fn units(&self) -> &Option<String> {
        &self.units
    }

    fn coordinates(&self) -> Result<Array1<f64>, Error> {
        Ok(Array1::linspace(
            self.extents[0],
            self.extents[1],
            self.size,
        ))
    }

    fn make_monotonic(&self) -> Result<Vec<NumericAxis>, Error> {
        todo!()
    }
}

impl OrderedNumeric for LinearAxis {
    fn extents(&self) -> [f64; 2] {
        self.extents
    }
}