use std::{convert::Infallible, error::Error, fmt};
#[derive(Debug)]
pub struct BackendError(Box<dyn Error>);
impl BackendError {
pub fn new<E: Error + 'static>(source: E) -> Self {
Self(Box::new(source))
}
pub fn as_error(&self) -> &(dyn Error + 'static) {
self.0.as_ref()
}
}
impl fmt::Display for BackendError {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
self.0.fmt(f)
}
}
impl Error for BackendError {
fn source(&self) -> Option<&(dyn Error + 'static)> {
Some(self.as_error())
}
}
#[derive(Debug)]
pub enum FitError<E = Infallible> {
InvalidInput {
message: String,
},
UnsupportedCombination {
solver: &'static str,
reason: String,
suggestion: &'static str,
},
NumericalFailure {
operation: &'static str,
iteration: usize,
},
Backend {
operation: &'static str,
source: E,
},
LineSearchFailure {
iteration: usize,
step: f64,
},
}
impl<E: fmt::Display> fmt::Display for FitError<E> {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
match self {
Self::InvalidInput { message } => write!(f, "invalid fit input: {message}"),
Self::UnsupportedCombination {
solver,
reason,
suggestion,
} => write!(
f,
"unsupported fit combination for {solver}: {reason}; {suggestion}"
),
Self::NumericalFailure {
operation,
iteration,
} => write!(
f,
"nonfinite arithmetic while {operation} at iteration {iteration}"
),
Self::Backend { operation, source } => {
write!(f, "backend failed while {operation}: {source}")
}
Self::LineSearchFailure { iteration, step } => write!(
f,
"line search failed at iteration {iteration} with step {step}; increase max_backtracks or check scaling and solver settings"
),
}
}
}
impl<E> FitError<E> {
pub(crate) fn erase_backend(self) -> FitError<BackendError>
where
E: Error + 'static,
{
match self {
Self::InvalidInput { message } => FitError::InvalidInput { message },
Self::UnsupportedCombination {
solver,
reason,
suggestion,
} => FitError::UnsupportedCombination {
solver,
reason,
suggestion,
},
Self::NumericalFailure {
operation,
iteration,
} => FitError::NumericalFailure {
operation,
iteration,
},
Self::Backend { operation, source } => FitError::Backend {
operation,
source: BackendError::new(source),
},
Self::LineSearchFailure { iteration, step } => {
FitError::LineSearchFailure { iteration, step }
}
}
}
pub(crate) fn from_component(error: FitError, iteration: usize) -> Self {
match error {
FitError::InvalidInput { message } => Self::InvalidInput { message },
FitError::UnsupportedCombination {
solver,
reason,
suggestion,
} => Self::UnsupportedCombination {
solver,
reason,
suggestion,
},
FitError::NumericalFailure { operation, .. } => Self::NumericalFailure {
operation,
iteration,
},
FitError::LineSearchFailure { iteration, step } => {
Self::LineSearchFailure { iteration, step }
}
FitError::Backend { source, .. } => match source {},
}
}
}
impl<E: Error + 'static> Error for FitError<E> {
fn source(&self) -> Option<&(dyn Error + 'static)> {
match self {
Self::Backend { source, .. } => Some(source),
_ => None,
}
}
}
impl<E> From<NumericalFailure> for FitError<E> {
fn from(error: NumericalFailure) -> Self {
Self::NumericalFailure {
operation: error.operation,
iteration: error.iteration,
}
}
}
pub(crate) fn invalid<E>(message: impl Into<String>) -> FitError<E> {
FitError::InvalidInput {
message: message.into(),
}
}
pub(crate) fn unsupported<E>(
solver: &'static str,
reason: impl Into<String>,
suggestion: &'static str,
) -> FitError<E> {
FitError::UnsupportedCombination {
solver,
reason: reason.into(),
suggestion,
}
}
#[derive(Debug)]
pub(crate) struct NumericalFailure {
pub operation: &'static str,
pub iteration: usize,
}
pub(crate) fn finite(
value: f64,
operation: &'static str,
iteration: usize,
) -> Result<f64, NumericalFailure> {
if value.is_finite() {
Ok(value)
} else {
Err(NumericalFailure {
operation,
iteration,
})
}
}