use super::{GoalContext, same_index_set};
use indicatrix_cut_core::{ConstraintTier, Design};
pub const MAST_FLOOR: f64 = 0.05;
const ZERO_ANGLE_EPSILON: f64 = 1e-9;
const GIRDLE_MIN_ANGLE_DEG: f64 = 90.0 - 1e-6;
#[must_use]
pub fn mast_within(actual: f64, wanted: f64, rel_tol: f64) -> bool {
(actual - wanted).abs() <= rel_tol * wanted.abs().max(MAST_FLOOR)
}
pub(super) fn blank_equals_zero(angle_deg: f64) -> bool {
angle_deg.abs() < ZERO_ANGLE_EPSILON || angle_deg.abs() >= GIRDLE_MIN_ANGLE_DEG
}
fn blank_as_zero(indices: &[f64]) -> Vec<f64> {
if indices.is_empty() {
vec![0.0]
} else {
indices.to_vec()
}
}
fn same_indices(angle_deg: f64, user: &[f64], wanted: &[f64], gear: f64) -> bool {
if blank_equals_zero(angle_deg) {
same_index_set(&blank_as_zero(user), &blank_as_zero(wanted), gear)
} else if wanted.is_empty() {
user.is_empty()
} else {
same_index_set(user, wanted, gear)
}
}
fn same_zero_side(a: f64, b: f64) -> bool {
if a.abs() < ZERO_ANGLE_EPSILON && b.abs() < ZERO_ANGLE_EPSILON {
a.is_sign_negative() == b.is_sign_negative()
} else {
true
}
}
fn same_cut(user: &ConstraintTier, wanted: &ConstraintTier, gear: f64, angle_tol_deg: f64) -> bool {
user.name.trim().eq_ignore_ascii_case(wanted.name.trim())
&& (user.angle_deg - wanted.angle_deg).abs() <= angle_tol_deg
&& same_zero_side(user.angle_deg, wanted.angle_deg)
&& same_indices(wanted.angle_deg, &user.indices, &wanted.indices, gear)
}
fn pair_cuts(
user: &[ConstraintTier],
target: &[ConstraintTier],
gear: f64,
angle_tol_deg: f64,
) -> Option<Vec<usize>> {
if user.len() != target.len() {
return None;
}
let mut used = vec![false; user.len()];
let mut pairs = Vec::with_capacity(target.len());
for wanted in target {
let found = user
.iter()
.enumerate()
.find(|(index, tier)| !used[*index] && same_cut(tier, wanted, gear, angle_tol_deg))?
.0;
used[found] = true;
pairs.push(found);
}
Some(pairs)
}
pub(super) fn problem(
target: &Design,
angle_tol_deg: f64,
mast_rel_tol: f64,
target_masts: &[f64],
) -> Option<String> {
if !angle_tol_deg.is_finite() || angle_tol_deg < 0.0 {
Some("the angle tolerance is not a number".into())
} else if !mast_rel_tol.is_finite() || mast_rel_tol < 0.0 {
Some("the depth tolerance is not a number".into())
} else if target.tiers.is_empty() {
Some("the target design has no tiers".into())
} else if !target_masts.is_empty() && target_masts.len() != target.tiers.len() {
Some("target_masts must have one entry per target tier".into())
} else if target_masts.iter().any(|mast| !mast.is_finite()) {
Some("a target mast is not a number".into())
} else {
None
}
}
pub(super) fn met(
ctx: &GoalContext<'_>,
target: &Design,
angle_tol_deg: f64,
mast_rel_tol: f64,
target_masts: &[f64],
) -> bool {
let design = ctx.design;
if design.meta.gear_teeth_abs() != target.meta.gear_teeth_abs()
|| design.meta.symmetry_order != target.meta.symmetry_order
|| design.meta.mirror != target.meta.mirror
{
return false;
}
let gear = f64::from(design.meta.gear_teeth_abs());
let Some(pairs) = pair_cuts(&design.tiers, &target.tiers, gear, angle_tol_deg) else {
return false;
};
if target_masts.is_empty() {
return true;
}
if !ctx.solved_closed {
return false;
}
let Some(masts) = ctx.solved_masts else {
return false;
};
masts.len() == design.tiers.len()
&& pairs
.iter()
.zip(target_masts)
.all(|(&user, &wanted)| mast_within(masts[user], wanted, mast_rel_tol))
}