VDB

25 vdb_fn "VDB" (5, 7) [V "cost", V "salvage", V "life", V "start_period", V "end_period", V "factor", V "no_switch"] |s, a, sv| {
    // W111 typed and padding controls read the required arguments, then factor,
    // then no_switch. An explicit empty factor slot coerces to zero; only an
    // absent trailing factor takes the default of two.
    let (cost, salvage, life, start, end) =
        (num(s, a, 0)?, num(s, a, 1)?, num(s, a, 2)?, num(s, a, 3)?, num(s, a, 4)?);
    let factor = if a.len() > 5 { num(s, a, 5)? } else { 2.0 };
    let no_switch = if given(a, 6) && !a[6].is_empty() { flag(s, a, 6)? } else { false };
    out(s, dep::vdb_kernel(cost, salvage, life, start, end, factor, no_switch))
}

fn declining_interval_depreciation(
    cost: f64,
    salvage: f64,
    life: f64,
    start_period: f64,
    end_period: f64,
    factor: f64,
    no_switch: bool,
) -> Result<f64, WorksheetErrorCode> {
    validate_finite(&[cost, salvage, life, start_period, end_period, factor])?;
    if cost < 0.0 || salvage < 0.0 || life <= 0.0 || factor < 0.0 {
        return Err(WorksheetErrorCode::Num);
    }
    if start_period < 0.0 || end_period < start_period || end_period > life {
        return Err(WorksheetErrorCode::Num);
    }
    if no_switch {
        if start_period == end_period {
            return Ok(0.0);
        }
        let mut year = start_period.floor();
        let mut total = 0.0;
        while year < end_period {
            let dep = ddb_period_depreciation(cost, salvage, life, year + 1.0, factor)?;
            // Excel rounds these partial products separately, even when both
            // bounds lie in the same year. The final fraction is formed by
            // subtracting the unused tail from one; end-year loses observed
            // cancellation, including tiny negative intervals. The final year uses the same
            // annual amount, without rescaling it by the remaining year length.
            let final_fraction = 1.0 - ((year + 1.0) - end_period).max(0.0);
            // Both products pass through an extended-precision store. Their
            // separate rounding is visible when adjacent endpoints cancel.
            let final_part =
                publish_depreciation(crate::ported::excel_numeric::excel_x87_mul(dep, final_fraction))?;
            let initial_part = publish_depreciation(crate::ported::excel_numeric::excel_x87_mul(
                dep,
                (start_period - year).max(0.0),
            ))?;
            total += final_part - initial_part;
            if dep == 0.0 {
                break;
            }
            year += 1.0;
        }
        // The partial products publish subnormals as zero, but subtraction
        // of two normal products may return a nonzero subnormal Value2.
        return if total.is_finite() {
            Ok(total)
        } else {
            Err(WorksheetErrorCode::Num)
        };
    }
    switched_interval_depreciation(cost, salvage, life, start_period, end_period, factor)
}

fn switched_interval_depreciation(
    cost: f64,
    salvage: f64,
    life: f64,
    start_period: f64,
    end_period: f64,
    factor: f64,
) -> Result<f64, WorksheetErrorCode> {
    use crate::ported::excel_numeric::{
        excel_x87_add as add, excel_x87_div as div, excel_x87_mul as mul, excel_x87_sub as sub,
    };
    if start_period == end_period {
        return Ok(0.0);
    }
    // Exact neighboring probes pin an inclusive absolute 2^-1026 boundary.
    // This is a VDB switch rule, not a general numeric comparison policy.
    let switch_exceeds = |straight: f64, declining: f64| {
        straight > declining && straight - declining >= f64::MIN_POSITIVE / 16.0
    };
    let rate = publish_depreciation(div(factor, life))?;
    let initial_declining = publish_depreciation(mul(cost, rate))?;
    let initial_straight = publish_depreciation(div(cost - salvage, life))?;
    if cost >= salvage && switch_exceeds(initial_straight, initial_declining.min(cost - salvage)) {
        return publish_depreciation(mul(initial_straight, end_period - start_period));
    }
    let fraction = start_period - start_period.floor();
    let initial_amount = initial_declining.min(cost - salvage).max(0.0);
    let initial_part = publish_depreciation(mul(initial_amount, fraction))?;
    let mut book = sub(cost, initial_part);
    let mut remaining_life = life - fraction;
    let mut straight_line = None;
    let mut accumulate = |duration: f64, requested: bool| -> Result<f64, WorksheetErrorCode> {
        let mut total = 0.0;
        let mut cursor = start_period;
        let mut year = 0.0;
        loop {
            if if requested {
                cursor >= end_period
            } else {
                year >= duration
            } {
                break;
            }
            let declining = publish_depreciation(mul(book, rate))?;
            let available = book - salvage;
            let denominator = if declining > available {
                remaining_life.max(1.0)
            } else {
                remaining_life
            };
            let straight = match straight_line {
                Some(value) => value,
                None => publish_depreciation(div(available, denominator))?,
            };
            // Even clipping does not hide overflow of this remaining-life
            // division. A fixed straight-line amount does not waive it either.
            publish_depreciation(div(available, remaining_life))?;
            let amount = if straight_line.is_none() && declining > available {
                available
            } else if switch_exceeds(straight, declining.min(available)) {
                straight_line = Some(straight);
                straight
            } else {
                declining.min(available)
            };
            let remaining = if requested {
                end_period - cursor
            } else {
                duration - year
            };
            let take = if straight_line.is_some() {
                remaining
            } else {
                remaining.min(1.0)
            };
            // A whole clipped year preserves a subnormal amount. Fractional
            // products publish separately, so a blanket final flush is wrong.
            let part = if take == 1.0 {
                amount
            } else {
                publish_depreciation(mul(amount, take))?
            };
            total = add(total, part);
            book = if requested {
                book - part
            } else {
                sub(book, part)
            };
            remaining_life -= take;
            // Use the already stored remaining length: cursor+1 can round
            // below end even when this subtraction has rounded to exactly one.
            if requested && remaining <= 1.0 {
                break;
            }
            cursor += 1.0;
            if straight_line.is_some() {
                break;
            }
            year += 1.0;
        }
        if !total.is_finite() {
            Err(WorksheetErrorCode::Num)
        } else {
            Ok(if total == 0.0 { 0.0 } else { total })
        }
    };
    accumulate(start_period.floor(), false)?;
    accumulate(end_period - start_period, true)
}

pub fn vdb_kernel(
    cost: f64,
    salvage: f64,
    life: f64,
    start_period: f64,
    end_period: f64,
    factor: f64,
    no_switch: bool,
) -> Result<f64, WorksheetErrorCode> {
    declining_interval_depreciation(
        cost,
        salvage,
        life,
        start_period,
        end_period,
        factor,
        no_switch,
    )
}