mirror of
https://github.com/storytold/gridcraft.git
synced 2026-11-16 23:33:28 +00:00
SUMIF/AVERAGEIF size the sum range like the criteria range
Excel adds up the range that starts at sum_range's top-left cell and has the criteria range's height and width, whatever size sum_range has. With A1:B3 = a,1 / b,2 / a,3, =SUMIF(A1:A3,"a",B1) is 4; GridCraft gave 1, because if_numbers only saw sum_range's values (one cell) and read them at the criteria positions. Its comment promised the resizing, but by then the argument was a plain value. The evaluator has the references, so it now does the resizing, as it does for OFFSET and INDEX: for SUMIF and AVERAGEIF with three arguments, a single-area sum range reference becomes resized_sum_range(sum, criteria height, criteria width), cut off at the sheet's edge. It works across sheets and through names. The dependency graph records the resized range, so editing a cell inside it recalculates; when the criteria range isn't a plain reference the formula is recalculated every time instead. SUMIFS and AVERAGEIFS keep requiring same-size ranges (#VALUE! otherwise). Tests: a single-cell, shorter, wider, longer and horizontal sum range, whole-column criteria, editing a cell of the resized range, the sheet edge, another sheet and a defined name, and SUMIFS/AVERAGEIFS size mismatches. They fail before the fix (1 instead of 4). Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
This commit is contained in:
1 parent
51b531be3e
commit
8fe3276cb8
3 files changed
+158
-20
No files matched your search
+64
-18
@@ -696,8 +696,20 @@ impl<'h> Evaluator<'h> {
|
||||
return err(CellError::Value);
|
||||
}
|
||||
let mut evaluated = Vec::with_capacity(args.len());
|
||||
for a in args {
|
||||
let ev = self.eval(a);
|
||||
// SUMIF/AVERAGEIF: the size of the criteria range (argument 1), which the sum range takes.
|
||||
let mut criteria_shape = None;
|
||||
for (i, a) in args.iter().enumerate() {
|
||||
let mut ev = self.eval(a);
|
||||
if resizes_sum_range(name, args.len()) {
|
||||
if i == 0 {
|
||||
criteria_shape = ev_shape(&ev);
|
||||
} else if i == 2
|
||||
&& let (Some((h, w)), Ev::R(areas)) = (criteria_shape, &ev)
|
||||
&& let [area] = areas.as_slice()
|
||||
{
|
||||
ev = Ev::R(vec![Area { sheet: area.sheet, range: resized_sum_range(area.range, h, w) }]);
|
||||
}
|
||||
}
|
||||
let from_ref = matches!(ev, Ev::R(_));
|
||||
let value = match ev {
|
||||
Ev::R(areas) if areas.len() > 1 => {
|
||||
@@ -1306,30 +1318,64 @@ fn binary_scalar(op: BinOp, a: &Value, b: &Value) -> Value {
|
||||
}
|
||||
}
|
||||
|
||||
/// SUMIF and AVERAGEIF with a sum range: Excel sizes the sum range like the criteria range.
|
||||
fn resizes_sum_range(name: &str, args: usize) -> bool {
|
||||
args == 3 && matches!(name, "SUMIF" | "AVERAGEIF")
|
||||
}
|
||||
|
||||
/// Height and width of a single-area reference or an array argument.
|
||||
fn ev_shape(ev: &Ev) -> Option<(u32, u32)> {
|
||||
match ev {
|
||||
Ev::R(areas) => match areas.as_slice() {
|
||||
[a] => Some((a.range.height(), a.range.width())),
|
||||
_ => None,
|
||||
},
|
||||
Ev::V(Value::Array(a)) => Some((u32::try_from(a.rows).unwrap_or(u32::MAX), u32::try_from(a.cols).unwrap_or(u32::MAX))),
|
||||
Ev::V(_) => Some((1, 1)),
|
||||
Ev::L(_) => None,
|
||||
}
|
||||
}
|
||||
|
||||
/// The range SUMIF/AVERAGEIF add up: from the sum range's top-left cell, as many rows and columns
|
||||
/// as the criteria range (`height` × `width`), cut off at the sheet's edge.
|
||||
pub fn resized_sum_range(sum: RangeRef, height: u32, width: u32) -> RangeRef {
|
||||
let row = sum.start.row.saturating_add(height.saturating_sub(1)).min(MAX_ROWS - 1);
|
||||
let col = sum.start.col.saturating_add(width.saturating_sub(1)).min(MAX_COLS - 1);
|
||||
RangeRef::new(sum.start, CellRef::new(row, col))
|
||||
}
|
||||
|
||||
/// Collects the static references of an expression with their sheets resolved; `dynamic` is
|
||||
/// set when the formula uses INDIRECT/OFFSET/names/tables whose targets can change.
|
||||
pub fn precedents(wb: &Workbook, sheet: usize, e: &Expr) -> (Vec<Area>, bool) {
|
||||
let mut out = Vec::new();
|
||||
let mut dynamic = false;
|
||||
e.walk(&mut |x| match x {
|
||||
Expr::Ref(r) => {
|
||||
let range = r.range();
|
||||
match &r.sheet {
|
||||
SheetSel::Current => out.push(Area { sheet, range }),
|
||||
SheetSel::Named(n) => {
|
||||
if let Some(i) = wb.sheet_index(n) {
|
||||
out.push(Area { sheet: i, range });
|
||||
}
|
||||
}
|
||||
SheetSel::Span(a, b) => {
|
||||
if let (Some(i), Some(j)) = (wb.sheet_index(a), wb.sheet_index(b)) {
|
||||
for s in i.min(j)..=i.max(j) {
|
||||
out.push(Area { sheet: s, range });
|
||||
}
|
||||
}
|
||||
let push = |out: &mut Vec<Area>, r: &Reference, range: RangeRef| match &r.sheet {
|
||||
SheetSel::Current => out.push(Area { sheet, range }),
|
||||
SheetSel::Named(n) => {
|
||||
if let Some(i) = wb.sheet_index(n) {
|
||||
out.push(Area { sheet: i, range });
|
||||
}
|
||||
}
|
||||
SheetSel::Span(a, b) => {
|
||||
if let (Some(i), Some(j)) = (wb.sheet_index(a), wb.sheet_index(b)) {
|
||||
for s in i.min(j)..=i.max(j) {
|
||||
out.push(Area { sheet: s, range });
|
||||
}
|
||||
}
|
||||
}
|
||||
};
|
||||
e.walk(&mut |x| match x {
|
||||
Expr::Ref(r) => push(&mut out, r, r.range()),
|
||||
// The cells SUMIF/AVERAGEIF really read from the sum range (see `resized_sum_range`); when
|
||||
// the criteria range's size isn't known statically, recalculate the formula every time.
|
||||
Expr::Call(n, args) if resizes_sum_range(n, args.len()) => match (args.first(), args.get(2)) {
|
||||
(Some(Expr::Ref(c)), Some(Expr::Ref(s))) => {
|
||||
let (crit, sum) = (c.range(), s.range());
|
||||
push(&mut out, s, resized_sum_range(sum, crit.height(), crit.width()));
|
||||
}
|
||||
(_, Some(Expr::Number(_) | Expr::Text(_) | Expr::Bool(_) | Expr::Error(_) | Expr::Array(_) | Expr::Missing)) => {}
|
||||
_ => dynamic = true,
|
||||
},
|
||||
Expr::Call(n, _)
|
||||
if matches!(n.as_str(), "INDIRECT" | "OFFSET" | "NOW" | "TODAY" | "RAND" | "RANDBETWEEN" | "RANDARRAY" | "CELL" | "INFO") =>
|
||||
{
|
||||
|
||||
@@ -215,3 +215,94 @@ fn recalc_all_after_load() {
|
||||
t.calc.recalc_all(&mut t.wb);
|
||||
assert_eq!(t.num("A3"), 12.0);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn sumif_sum_range_takes_the_criteria_size() {
|
||||
// Excel adds up the range that starts at sum_range's top-left cell with the criteria range's
|
||||
// height and width, whatever size sum_range has.
|
||||
let mut t = T::new();
|
||||
for (r, (k, v)) in [("a", 1), ("b", 2), ("a", 3)].iter().enumerate() {
|
||||
t.set(&format!("A{}", r + 1), k);
|
||||
t.set(&format!("B{}", r + 1), &v.to_string());
|
||||
}
|
||||
t.set("D1", "=SUMIF(A1:A3,\"a\",B1)");
|
||||
assert_eq!(t.num("D1"), 4.0);
|
||||
t.set("D2", "=AVERAGEIF(A1:A3,\"a\",B1)");
|
||||
assert_eq!(t.num("D2"), 2.0);
|
||||
t.set("D3", "=SUMIF(A1:A3,\"a\",B1:B2)");
|
||||
assert_eq!(t.num("D3"), 4.0);
|
||||
t.set("D4", "=SUMIF(A1:A3,\"a\",B1:F1)");
|
||||
assert_eq!(t.num("D4"), 4.0);
|
||||
t.set("D5", "=SUMIF(A1:A3,\"a\",B1:B99)");
|
||||
assert_eq!(t.num("D5"), 4.0);
|
||||
t.set("D6", "=SUMIF(A:A,\"a\",B1)");
|
||||
assert_eq!(t.num("D6"), 4.0);
|
||||
t.set("D7", "=SUMIF(A1:A3,\"a\",$B$2)");
|
||||
assert_eq!(t.num("D7"), 2.0); // B2:B4: rows 1 and 3 match → B2 + B4 (empty)
|
||||
t.set("D8", "=SUMIF(A1:A3,\"a\")");
|
||||
assert_eq!(t.num("D8"), 0.0);
|
||||
// A horizontal criteria range resizes across.
|
||||
t.set("H1", "1");
|
||||
t.set("I1", "0");
|
||||
t.set("J1", "1");
|
||||
t.set("H2", "10");
|
||||
t.set("I2", "20");
|
||||
t.set("J2", "30");
|
||||
t.set("D9", "=SUMIF(H1:J1,1,H2)");
|
||||
assert_eq!(t.num("D9"), 40.0);
|
||||
// The resized cells are precedents: editing one recalculates.
|
||||
t.set("B3", "5");
|
||||
assert_eq!(t.num("D1"), 6.0);
|
||||
assert_eq!(t.num("D2"), 3.0);
|
||||
assert_eq!(t.num("D3"), 6.0);
|
||||
assert_eq!(t.num("D4"), 6.0);
|
||||
assert_eq!(t.num("D6"), 6.0);
|
||||
// SUMIFS and AVERAGEIFS don't resize: different sizes are #VALUE!.
|
||||
t.set("D11", "=SUMIFS(B1,A1:A3,\"a\")");
|
||||
assert_eq!(t.get("D11"), Value::Error(CellError::Value));
|
||||
t.set("D12", "=AVERAGEIFS(B1:B2,A1:A3,\"a\")");
|
||||
assert_eq!(t.get("D12"), Value::Error(CellError::Value));
|
||||
t.set("D13", "=SUMIFS(B1:B3,A1:A3,\"a\")");
|
||||
assert_eq!(t.num("D13"), 6.0);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn sumif_resized_sum_range_stops_at_the_sheet_edge() {
|
||||
let mut t = T::new();
|
||||
t.set("A1", "a");
|
||||
t.set("A2", "a");
|
||||
t.set("B1048575", "5");
|
||||
t.set("B1048576", "7");
|
||||
t.set("C1", "=SUMIF(A1:A2,\"a\",B1048576)");
|
||||
assert_eq!(t.num("C1"), 7.0);
|
||||
t.set("C2", "=SUMIF(A1:A2,\"a\",B1048575)");
|
||||
assert_eq!(t.num("C2"), 12.0);
|
||||
t.set("C3", "=SUMIF(A1:B1,\"a\",XFD1)");
|
||||
assert_eq!(t.num("C3"), 0.0);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn sumif_resized_sum_range_on_another_sheet_and_through_a_name() {
|
||||
let mut t = T::new();
|
||||
t.wb.sheets.push(std::sync::Arc::new(gridcraft_model::Sheet::new("Data")));
|
||||
t.wb.names.push(gridcraft_model::DefinedName {
|
||||
name: "Amounts".into(),
|
||||
scope: None,
|
||||
formula: "Data!$B$1".into(),
|
||||
comment: String::new(),
|
||||
hidden: false,
|
||||
});
|
||||
for (r, k) in ["a", "b", "a"].iter().enumerate() {
|
||||
t.set(&format!("A{}", r + 1), k);
|
||||
t.wb.sheet_mut(1).unwrap().set_value(CellRef::new(r as u32, 1), Value::Number((r + 1) as f64));
|
||||
}
|
||||
t.calc.rebuild(&t.wb);
|
||||
t.set("C1", "=SUMIF(A1:A3,\"a\",Data!B1)");
|
||||
assert_eq!(t.num("C1"), 4.0);
|
||||
t.set("C2", "=AVERAGEIF(A1:A3,\"a\",Amounts)");
|
||||
assert_eq!(t.num("C2"), 2.0);
|
||||
t.wb.sheet_mut(1).unwrap().set_value(c("B3"), Value::Number(9.0));
|
||||
t.calc.cells_changed(&mut t.wb, &[(1, c("B3"))]);
|
||||
assert_eq!(t.num("C1"), 10.0);
|
||||
assert_eq!(t.num("C2"), 5.0);
|
||||
}
|
||||
@@ -1006,8 +1006,9 @@ fn countif(a: &[Arg], _c: &mut dyn Ctx) -> R<Value> {
|
||||
num_val(range.iter().filter(|v| c.matches(v)).count() as f64)
|
||||
}
|
||||
|
||||
/// SUMIF / AVERAGEIF: matched numbers from the sum range, which takes the criteria range's
|
||||
/// shape anchored at its own top-left.
|
||||
/// SUMIF / AVERAGEIF: matched numbers from the sum range, read at the criteria range's positions.
|
||||
/// Excel sizes a sum range reference like the criteria range, anchored at its own top-left cell;
|
||||
/// the evaluator does that resizing (it has the references), so cells line up one to one here.
|
||||
fn if_numbers(a: &[Arg]) -> R<Vec<f64>> {
|
||||
let range = as_array(&crate::util::arg(a, 0)?.value);
|
||||
let c = Criterion::parse(&crate::util::arg(a, 1)?.value.scalar());
|
||||
|
||||
Reference in new issue
Block a user