use alloc::string::String;
use core::fmt;
#[derive(Debug, Clone, PartialEq)]
pub enum StatsErrorEnum {
EmptyInput(String),
InsufficientSamples(String),
NegativeProbability(String),
DimensionMismatch(String),
NonPositiveScale(String),
RankDeficient(String),
NotConverged { iterations: usize, detail: String },
InvalidBinCount(String),
NonFiniteInput(String),
ConversionFailed(String),
}
#[derive(Debug, Clone, PartialEq)]
pub struct StatsError(pub StatsErrorEnum);
impl StatsError {
#[allow(non_snake_case)]
pub fn EmptyInput<S: Into<String>>(msg: S) -> Self {
Self(StatsErrorEnum::EmptyInput(msg.into()))
}
#[allow(non_snake_case)]
pub fn InsufficientSamples<S: Into<String>>(msg: S) -> Self {
Self(StatsErrorEnum::InsufficientSamples(msg.into()))
}
#[allow(non_snake_case)]
pub fn NegativeProbability<S: Into<String>>(msg: S) -> Self {
Self(StatsErrorEnum::NegativeProbability(msg.into()))
}
#[allow(non_snake_case)]
pub fn DimensionMismatch<S: Into<String>>(msg: S) -> Self {
Self(StatsErrorEnum::DimensionMismatch(msg.into()))
}
#[allow(non_snake_case)]
pub fn NonPositiveScale<S: Into<String>>(msg: S) -> Self {
Self(StatsErrorEnum::NonPositiveScale(msg.into()))
}
#[allow(non_snake_case)]
pub fn RankDeficient<S: Into<String>>(msg: S) -> Self {
Self(StatsErrorEnum::RankDeficient(msg.into()))
}
#[allow(non_snake_case)]
pub fn NotConverged<S: Into<String>>(iterations: usize, detail: S) -> Self {
Self(StatsErrorEnum::NotConverged {
iterations,
detail: detail.into(),
})
}
#[allow(non_snake_case)]
pub fn InvalidBinCount<S: Into<String>>(msg: S) -> Self {
Self(StatsErrorEnum::InvalidBinCount(msg.into()))
}
#[allow(non_snake_case)]
pub fn NonFiniteInput<S: Into<String>>(msg: S) -> Self {
Self(StatsErrorEnum::NonFiniteInput(msg.into()))
}
#[allow(non_snake_case)]
pub fn ConversionFailed<S: Into<String>>(msg: S) -> Self {
Self(StatsErrorEnum::ConversionFailed(msg.into()))
}
pub fn kind(&self) -> &StatsErrorEnum {
&self.0
}
}
impl fmt::Display for StatsError {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
match &self.0 {
StatsErrorEnum::EmptyInput(m) => write!(f, "Empty input: {m}"),
StatsErrorEnum::InsufficientSamples(m) => write!(f, "Insufficient samples: {m}"),
StatsErrorEnum::NegativeProbability(m) => write!(f, "Negative probability: {m}"),
StatsErrorEnum::DimensionMismatch(m) => write!(f, "Dimension mismatch: {m}"),
StatsErrorEnum::NonPositiveScale(m) => write!(f, "Non-positive scale: {m}"),
StatsErrorEnum::RankDeficient(m) => write!(f, "Rank deficient: {m}"),
StatsErrorEnum::NotConverged { iterations, detail } => {
write!(
f,
"Did not converge after {iterations} iterations: {detail}"
)
}
StatsErrorEnum::InvalidBinCount(m) => write!(f, "Invalid bin count: {m}"),
StatsErrorEnum::NonFiniteInput(m) => write!(f, "Non-finite input: {m}"),
StatsErrorEnum::ConversionFailed(m) => write!(f, "Conversion failed: {m}"),
}
}
}
impl core::error::Error for StatsError {}