Skip to main content

qualia_core_db/sensing/acquisition/
lineage.rs

1use super::*;
2#[derive(Clone, Copy, Debug, PartialEq, Eq)]
3pub enum Loss {
4    /// Explicit claim of no observational loss, not a reversibility proof.
5    NoneDeclared,
6    Quantization,
7    Resampling,
8    PhaseDiscarded,
9    ChannelReduction,
10    EventAggregation,
11    Clipping,
12    Windowing,
13    BandSelection,
14    Registered(ArtifactLink),
15}
16/// Source/parameter/output identities and declared losses for an existing derivative.
17/// This declaration neither executes nor qualifies an algorithm.
18#[derive(Clone, Copy, Debug)]
19pub struct Derivation<'a> {
20    output: Original<'a>,
21    inputs: &'a [Original<'a>],
22    algorithm: ArtifactLink,
23    parameters: ArtifactLink,
24    losses: &'a [Loss],
25}
26impl<'a> Derivation<'a> {
27    pub fn admit(
28        output: Original<'a>,
29        inputs: &'a [Original<'a>],
30        algorithm: ArtifactLink,
31        parameters: ArtifactLink,
32        losses: &'a [Loss],
33        max_links: usize,
34    ) -> Result<Self, Error> {
35        if inputs.is_empty() || losses.is_empty() {
36            return Err(Error::LossDeclaration);
37        }
38        if inputs
39            .len()
40            .checked_add(losses.len())
41            .ok_or(Error::Overflow)?
42            > max_links
43        {
44            return Err(Error::Budget);
45        }
46        algorithm.validate()?;
47        parameters.validate()?;
48        if losses.len() > 1 && losses.contains(&Loss::NoneDeclared) {
49            return Err(Error::LossDeclaration);
50        }
51        for loss in losses {
52            if let Loss::Registered(r) = loss {
53                r.validate()?;
54            }
55        }
56        Ok(Self {
57            output,
58            inputs,
59            algorithm,
60            parameters,
61            losses,
62        })
63    }
64    pub fn output(self) -> Original<'a> {
65        self.output
66    }
67    pub fn inputs(self) -> &'a [Original<'a>] {
68        self.inputs
69    }
70    pub fn algorithm(self) -> ArtifactLink {
71        self.algorithm
72    }
73    pub fn parameters(self) -> ArtifactLink {
74        self.parameters
75    }
76    pub fn losses(self) -> &'a [Loss] {
77        self.losses
78    }
79}