use super::core::CatalogAtlas;
#[derive(Clone, Debug, PartialEq, Eq)]
pub enum AtlasScoreError {
MultiplicityLength { expected: usize, got: usize },
DegreeRange { first: usize, last: usize },
DegreeOutsideAtlas { degree: usize, max_degree: usize },
ProductOverflow {
degree: usize,
source: usize,
target: usize,
},
SumOverflow { degree: usize },
}
display_error! { error AtlasScoreError {
Self::MultiplicityLength { expected, got } => "multiplicity vector has {got} entries, expected {expected}";
Self::DegreeRange { first, last } => "self-Ext degree range {first} through {last} is empty";
Self::DegreeOutsideAtlas { degree, max_degree } => "self-Ext degree {degree} exceeds atlas bound {max_degree}";
Self::ProductOverflow { degree, source, target } => "self-Ext score overflows at degree {degree}, pair ({source}, {target})";
Self::SumOverflow { degree } => "self-Ext score overflows while summing degree {degree}";
} }
impl CatalogAtlas {
pub fn self_ext_scores(
&self,
multiplicities: &[usize],
first: usize,
last: usize,
) -> Result<Vec<usize>, AtlasScoreError> {
self.ext_scores(multiplicities, multiplicities, first, last)
}
pub fn ext_scores(
&self,
left: &[usize],
right: &[usize],
first: usize,
last: usize,
) -> Result<Vec<usize>, AtlasScoreError> {
self.validate_score_input(left, first, last)?;
self.validate_score_input(right, first, last)?;
(first..=last)
.map(|degree| self.score_degree(left, right, degree))
.collect()
}
pub fn ext_vanishes(
&self,
left: &[usize],
right: &[usize],
first: usize,
last: usize,
) -> Result<bool, AtlasScoreError> {
self.validate_score_input(left, first, last)?;
self.validate_score_input(right, first, last)?;
Ok((first..=last).all(|degree| self.vanishes_at_degree(left, right, degree)))
}
pub fn self_ext_vanishes(
&self,
multiplicities: &[usize],
first: usize,
last: usize,
) -> Result<bool, AtlasScoreError> {
self.ext_vanishes(multiplicities, multiplicities, first, last)
}
fn validate_score_input(
&self,
multiplicities: &[usize],
first: usize,
last: usize,
) -> Result<(), AtlasScoreError> {
if multiplicities.len() != self.catalog().len() {
return Err(AtlasScoreError::MultiplicityLength {
expected: self.catalog().len(),
got: multiplicities.len(),
});
}
if first > last {
return Err(AtlasScoreError::DegreeRange { first, last });
}
if last > self.max_degree() {
return Err(AtlasScoreError::DegreeOutsideAtlas {
degree: last,
max_degree: self.max_degree(),
});
}
Ok(())
}
fn score_degree(
&self,
lefts: &[usize],
rights: &[usize],
degree: usize,
) -> Result<usize, AtlasScoreError> {
let mut score = 0usize;
for (source, &left) in lefts.iter().enumerate() {
if left == 0 {
continue;
}
for (target, &right) in rights.iter().enumerate() {
if right == 0 {
continue;
}
let term = self.score_contribution(left, right, degree, source, target)?;
score = score
.checked_add(term)
.ok_or(AtlasScoreError::SumOverflow { degree })?;
}
}
Ok(score)
}
fn vanishes_at_degree(&self, left: &[usize], right: &[usize], degree: usize) -> bool {
for (source, &left_value) in left.iter().enumerate() {
if left_value == 0 {
continue;
}
for (target, &right_value) in right.iter().enumerate() {
if right_value > 0 && self.ext_dim(source, target, degree).unwrap() > 0 {
return false;
}
}
}
true
}
fn score_contribution(
&self,
left: usize,
right: usize,
degree: usize,
source: usize,
target: usize,
) -> Result<usize, AtlasScoreError> {
let dimension = self
.ext_dim(source, target, degree)
.expect("validated degree and catalog indices");
let term = left
.checked_mul(dimension)
.and_then(|value| value.checked_mul(right))
.ok_or(AtlasScoreError::ProductOverflow {
degree,
source,
target,
})?;
Ok(term)
}
}