fn round_family(args : Array[Thunk], mode : Int) -> Value {
  let vals = eager(args)
  if first_error(vals) is Some(e) {
    return Value::Err(e)
  }
  let d = match arg_number(vals, 0) {
    Ok(x) => x
    Err(e) => return Value::Err(e)
  }
  let digits_d = match arg_number(vals, 1) {
    Ok(x) => x
    Err(e) => return Value::Err(e)
  }
  if !digits_d.is_finite() {
    return Value::Err(XlError::Num)
  }
  let mut digits = digits_d.trunc().to_int()
  if digits > 400 {
    digits = 400
  }
  if digits < -400 {
    digits = -400
  }
  Value::Num(round_excel(d, digits, mode))
}

fn fn_round(_ctx : Ctx, args : Array[Thunk]) -> Value {
  round_family(args, 0)
}

fn fn_roundup(_ctx : Ctx, args : Array[Thunk]) -> Value {
  round_family(args, 1)
}

fn fn_rounddown(_ctx : Ctx, args : Array[Thunk]) -> Value {
  round_family(args, 2)
}

fn fn_abs(_ctx : Ctx, args : Array[Thunk]) -> Value {
  match to_number(scalarize(args[0]())) {
    Err(e) => Value::Err(e)
    Ok(d) => Value::Num(d.abs())
  }
}

fn fn_int(_ctx : Ctx, args : Array[Thunk]) -> Value {
  match to_number(scalarize(args[0]())) {
    Err(e) => Value::Err(e)
    Ok(d) => {
      let f = d.floor()
      if f.is_finite() { Value::Num(f) } else { Value::Err(XlError::Num) }
    }
  }
}

fn fn_mod(_ctx : Ctx, args : Array[Thunk]) -> Value {
  let vals = eager(args)
  if first_error(vals) is Some(e) {
    return Value::Err(e)
  }
  let a = match arg_number(vals, 0) {
    Ok(x) => x
    Err(e) => return Value::Err(e)
  }
  let b = match arg_number(vals, 1) {
    Ok(x) => x
    Err(e) => return Value::Err(e)
  }
  if b == 0.0 {
    return Value::Err(XlError::Div0)
  }
  // Excel MOD: result sign follows the divisor.
  let r = a - b * (a / b).floor()
  if r.is_finite() { Value::Num(r) } else { Value::Err(XlError::Num) }
}

fn fn_power(_ctx : Ctx, args : Array[Thunk]) -> Value {
  let vals = eager(args)
  if first_error(vals) is Some(e) {
    return Value::Err(e)
  }
  let a = match arg_number(vals, 0) {
    Ok(x) => x
    Err(e) => return Value::Err(e)
  }
  let b = match arg_number(vals, 1) {
    Ok(x) => x
    Err(e) => return Value::Err(e)
  }
  pow_excel(a, b)
}

fn fn_sqrt(_ctx : Ctx, args : Array[Thunk]) -> Value {
  match to_number(scalarize(args[0]())) {
    Err(e) => Value::Err(e)
    Ok(d) =>
      if d < 0.0 {
        Value::Err(XlError::Num)
      } else {
        Value::Num(d.sqrt())
      }
  }
}

fn fn_sum(_ctx : Ctx, args : Array[Thunk]) -> Value {
  let vals = eager(args)
  match collect_numbers(vals, false) {
    Err(e) => Value::Err(e)
    Ok(nums) => {
      let mut total = 0.0
      for d in nums {
        total += d
      }
      Value::Num(total)
    }
  }
}

fn fn_sumif(_ctx : Ctx, args : Array[Thunk]) -> Value {
  let vals = eager(args)
  // Range errors never match; an error criterion matches error cells of the
  // same value, and sum-range errors propagate per matched cell below.
  let range = as_range(vals[0])
  let crit = parse_criteria(vals[1])
  let sum_range = if vals.length() == 3 { Some(as_range(vals[2])) } else { None }
  let mut total = 0.0
  for i in 0.. range.cells[i]
        Some(sr) => if i < sr.cells.length() { sr.cells[i] } else { Value::Blank }
      }
      match sv {
        Num(d) => total += d
        Err(e) => return Value::Err(e)
        _ => ()
      }
    }
  }
  Value::Num(total)
}

fn fn_sumproduct(_ctx : Ctx, args : Array[Thunk]) -> Value {
  let vals = eager(args)
  if first_error(vals) is Some(e) {
    return Value::Err(e)
  }
  let ranges : Array[RangeValue] = []
  for v in vals {
    match v {
      Range(r) => ranges.push(r)
      _ => return Value::Err(XlError::Value)
    }
  }
  let rows = ranges[0].rows
  let cols = ranges[0].cols
  for r in ranges {
    if r.rows != rows || r.cols != cols {
      return Value::Err(XlError::Value)
    }
  }
  let mut total = 0.0
  for i in 0..<(rows * cols) {
    let mut prod = 1.0
    for r in ranges {
      match r.cells[i] {
        Num(d) => prod *= d
        Err(e) => return Value::Err(e)
        _ => prod = 0.0
      }
    }
    total += prod
  }
  Value::Num(total)
}