use super::Estimator;
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
pub struct Capabilities {
sample_weights: bool,
artifact: bool,
multiclass: bool,
decision_function: bool,
probability: bool,
}
impl Capabilities {
pub const NONE: Self = Self {
sample_weights: false,
artifact: false,
multiclass: false,
decision_function: false,
probability: false,
};
#[must_use]
pub const fn with_sample_weights(mut self, supported: bool) -> Self {
self.sample_weights = supported;
self
}
#[must_use]
pub const fn with_artifact(mut self, supported: bool) -> Self {
self.artifact = supported;
self
}
#[must_use]
pub const fn with_multiclass(mut self, supported: bool) -> Self {
self.multiclass = supported;
self
}
#[must_use]
pub const fn with_decision_function(mut self, supported: bool) -> Self {
self.decision_function = supported;
self
}
#[must_use]
pub const fn with_probability(mut self, supported: bool) -> Self {
self.probability = supported;
self
}
#[must_use]
pub const fn sample_weights(self) -> bool {
self.sample_weights
}
#[must_use]
pub const fn artifact(self) -> bool {
self.artifact
}
#[must_use]
pub const fn multiclass(self) -> bool {
self.multiclass
}
#[must_use]
pub const fn decision_function(self) -> bool {
self.decision_function
}
#[must_use]
pub const fn probability(self) -> bool {
self.probability
}
#[must_use]
pub const fn intersection(self, other: Self) -> Self {
Self {
sample_weights: self.sample_weights && other.sample_weights,
artifact: self.artifact && other.artifact,
multiclass: self.multiclass && other.multiclass,
decision_function: self.decision_function && other.decision_function,
probability: self.probability && other.probability,
}
}
}
pub trait HasCapabilities: Estimator {
const CAPABILITIES: Capabilities = Capabilities::NONE;
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn the_conservative_descriptor_declares_nothing() {
assert!(!Capabilities::NONE.sample_weights());
assert!(!Capabilities::NONE.artifact());
assert!(!Capabilities::NONE.multiclass());
assert!(!Capabilities::NONE.decision_function());
assert!(!Capabilities::NONE.probability());
}
#[test]
fn declarations_are_independent_and_const_evaluable() {
const WEIGHTS: Capabilities = Capabilities::NONE.with_sample_weights(true);
const ARTIFACT: Capabilities = Capabilities::NONE.with_artifact(true);
const MULTICLASS: Capabilities = Capabilities::NONE.with_multiclass(true);
const DECISION: Capabilities = Capabilities::NONE.with_decision_function(true);
const PROBABILITY: Capabilities = Capabilities::NONE.with_probability(true);
const BOTH: Capabilities = WEIGHTS.with_artifact(true);
assert!(WEIGHTS.sample_weights() && !WEIGHTS.artifact() && !WEIGHTS.multiclass());
assert!(!ARTIFACT.sample_weights() && ARTIFACT.artifact() && !ARTIFACT.multiclass());
assert!(!MULTICLASS.sample_weights() && !MULTICLASS.artifact() && MULTICLASS.multiclass());
assert!(BOTH.sample_weights() && BOTH.artifact() && !BOTH.multiclass());
assert!(DECISION.decision_function() && !DECISION.multiclass() && !DECISION.artifact());
assert!(!WEIGHTS.decision_function() && !BOTH.decision_function());
assert_eq!(BOTH.with_sample_weights(false), ARTIFACT);
assert_eq!(MULTICLASS.with_multiclass(false), Capabilities::NONE);
assert_eq!(DECISION.with_decision_function(false), Capabilities::NONE);
assert!(PROBABILITY.probability() && !PROBABILITY.decision_function());
assert!(!DECISION.probability() && !BOTH.probability());
assert_eq!(PROBABILITY.with_probability(false), Capabilities::NONE);
}
#[test]
fn intersection_keeps_only_what_both_sides_declare() {
const WEIGHTS: Capabilities = Capabilities::NONE.with_sample_weights(true);
const BOTH: Capabilities = WEIGHTS.with_artifact(true);
assert_eq!(BOTH.intersection(BOTH), BOTH);
assert_eq!(BOTH.intersection(WEIGHTS), WEIGHTS);
assert_eq!(
BOTH.with_multiclass(true).intersection(BOTH),
BOTH,
"a capability only one side declares is not promised"
);
assert_eq!(
BOTH.with_decision_function(true).intersection(BOTH),
BOTH,
"a decision function only one side has is not promised"
);
assert_eq!(
BOTH.with_probability(true).intersection(BOTH),
BOTH,
"probabilities only one side produces are not promised"
);
assert_eq!(BOTH.intersection(Capabilities::NONE), Capabilities::NONE);
assert_eq!(WEIGHTS.intersection(BOTH), BOTH.intersection(WEIGHTS));
}
#[test]
fn an_undeclared_estimator_defaults_to_declaring_nothing() {
struct Undeclared;
impl Estimator for Undeclared {
fn n_features_in(&self) -> usize {
1
}
}
impl HasCapabilities for Undeclared {}
assert_eq!(Undeclared::CAPABILITIES, Capabilities::NONE);
}
}