auslander 0.9.0

Computational representation theory of finite-dimensional bound quiver algebras
Documentation
use crate::linalg::DenseMat;

use super::super::cochain::{as_usize, checked_add, checked_product, elimination_work};
use super::super::limits::{
    BarBudgetDiagnostics, BarCutReason, BarLimit, BarLimits, BarStage, HochschildError,
};

#[derive(Debug)]
pub(crate) struct Ledger {
    pub(crate) limits: BarLimits,
    pub(crate) requested_degree: usize,
    pub(crate) completed_degree_count: usize,
    pub(crate) work_units: u64,
    pub(crate) matrix_entries: usize,
    pub(crate) degrees: Vec<super::super::outcome::HochschildDegree>,
}

#[derive(Debug)]
pub(crate) struct Stop(pub(crate) BarBudgetDiagnostics);

pub(crate) type BuildResult<T> = Result<T, Stop>;

#[derive(Debug)]
pub(crate) enum BuildFailure {
    Stop(Stop),
    Defect(HochschildError),
}

pub(crate) type InnerResult<T> = Result<T, BuildFailure>;

from_variants!(BuildFailure { Stop => Stop });

impl Ledger {
    pub(crate) fn diagnostics(
        &self,
        reason: BarCutReason,
        stage: BarStage,
        degree: usize,
        used: u128,
        proposed: u128,
        ceiling: Option<u128>,
    ) -> Stop {
        Stop(BarBudgetDiagnostics {
            reason,
            stage,
            requested_degree: self.requested_degree,
            completed_degree_count: self.completed_degree_count,
            first_uncomputed_differential: degree,
            work_units: self.work_units,
            matrix_entries: self.matrix_entries,
            used,
            proposed,
            ceiling,
        })
    }

    pub(crate) fn overflow<T>(&self, degree: usize, stage: BarStage) -> BuildResult<T> {
        Err(self.diagnostics(BarCutReason::SizeOverflow, stage, degree, 0, 0, None))
    }

    pub(crate) fn checked_usize(
        &self,
        degree: usize,
        stage: BarStage,
        value: Option<usize>,
    ) -> BuildResult<usize> {
        value.ok_or_else(|| self.diagnostics(BarCutReason::SizeOverflow, stage, degree, 0, 0, None))
    }

    pub(crate) fn limit(
        &self,
        kind: BarLimit,
        stage: BarStage,
        degree: usize,
        used: u128,
        proposed: u128,
        ceiling: u128,
    ) -> BuildResult<()> {
        if proposed <= ceiling {
            Ok(())
        } else {
            Err(self.diagnostics(
                BarCutReason::Limit(kind),
                stage,
                degree,
                used,
                proposed,
                Some(ceiling),
            ))
        }
    }

    pub(crate) fn work(&mut self, degree: usize, stage: BarStage, units: u128) -> BuildResult<()> {
        let Some(units) = u64::try_from(units).ok() else {
            return self.overflow(degree, stage);
        };
        let Some(proposed) = self.work_units.checked_add(units) else {
            return self.overflow(degree, stage);
        };
        self.limit(
            BarLimit::WorkUnits,
            stage,
            degree,
            self.work_units.into(),
            proposed.into(),
            self.limits.max_work_units.into(),
        )?;
        self.work_units = proposed;
        Ok(())
    }

    fn per_degree(
        &self,
        degree: usize,
        stage: BarStage,
        kind: BarLimit,
        proposed: usize,
        ceiling: usize,
    ) -> BuildResult<()> {
        self.limit(kind, stage, degree, 0, proposed as u128, ceiling as u128)
    }

    pub(crate) fn shape(
        &self,
        degree: usize,
        tuples: usize,
        cochain_dim: usize,
    ) -> BuildResult<()> {
        self.per_degree(
            degree,
            BarStage::Shape,
            BarLimit::TensorTuples,
            tuples,
            self.limits.max_tensor_tuples,
        )?;
        self.per_degree(
            degree,
            BarStage::Shape,
            BarLimit::CochainDimension,
            cochain_dim,
            self.limits.max_cochain_dim,
        )
    }

    pub(crate) fn scratch(
        &self,
        degree: usize,
        stage: BarStage,
        entries: usize,
    ) -> BuildResult<()> {
        let Some(proposed) = self.matrix_entries.checked_add(entries) else {
            return self.overflow(degree, stage);
        };
        self.limit(
            BarLimit::MatrixEntries,
            stage,
            degree,
            self.matrix_entries as u128,
            proposed as u128,
            self.limits.max_matrix_entries as u128,
        )
    }

    pub(crate) fn work_elim(
        &mut self,
        degree: usize,
        stage: BarStage,
        rows: usize,
        cols: usize,
    ) -> BuildResult<()> {
        self.work(
            degree,
            stage,
            elimination_work(rows, cols, self, degree, stage)?,
        )
    }

    pub(crate) fn retain(
        &mut self,
        degree: usize,
        stage: BarStage,
        entries: usize,
    ) -> BuildResult<()> {
        self.scratch(degree, stage, entries)?;
        self.matrix_entries += entries;
        Ok(())
    }

    pub(crate) fn retain_matrix(
        &mut self,
        degree: usize,
        stage: BarStage,
        matrix: &DenseMat,
    ) -> BuildResult<()> {
        let budget = self.budget(degree, stage);
        let entries =
            budget.size(budget.product([matrix.rows() as u128, matrix.cols() as u128])?)?;
        self.retain(degree, stage, entries)
    }

    accessor_methods! {
        pub(crate) budget(degree: usize, stage: BarStage) -> Budget<'_> = |this| Budget {
            ledger: this,
            degree,
            stage,
        };
        pub(crate) scratch_u128(degree: usize, stage: BarStage, entries: u128) -> BuildResult<()> = |this|
            this.scratch(degree, stage, as_usize(this, degree, stage, entries)?);
    }
}

#[derive(Clone, Copy)]
pub(crate) struct Budget<'a> {
    ledger: &'a Ledger,
    degree: usize,
    stage: BarStage,
}

impl Budget<'_> {
    pub(crate) fn product<const N: usize>(&self, values: [u128; N]) -> BuildResult<u128> {
        checked_product(self.ledger, self.degree, self.stage, &values)
    }

    accessor_methods! {
        pub(crate) sum(left: u128, right: u128) -> BuildResult<u128> = |this|
            checked_add(this.ledger, this.degree, this.stage, left, right);
        pub(crate) size(value: u128) -> BuildResult<usize> = |this|
            as_usize(this.ledger, this.degree, this.stage, value);
    }
}