SERIESSUM

What it does

SERIESSUM(x, n, m, coefficients)

SERIESSUM(x,n,m,coefficients) adds terms a_i*x^(n+i*m), starting with coefficient index i=0. N is the initial exponent and m the exponent step; the coefficient count determines the number of terms.

Try it

=SERIESSUM(2,0,1,{1,3,2}) returns 15:

Changing m to two uses exponents zero, two and four: =SERIESSUM(2,0,2,{1,3,2}) returns 45. The exponent step belongs to the powers, rather than changing the coefficient values.

Quirks

Microsoft documents #VALUE! for nonnumeric arguments. The current first-three-argument reader rejects logical values. Its coefficient grid accepts numeric cells, propagates a worksheet error and returns #VALUE! for other coefficient kinds; blank or text coefficients are not skipped as they can be in some aggregates.

The current graph evaluates a power before multiplying by its coefficient. A zero coefficient therefore does not erase an invalid power: the current route for SERIESSUM(-1,0.5,1,{0}) reaches #NUM!. Negative bases and fractional exponents need the real power-domain policy. Overflow and underflow of terms can matter even when the mathematical sum would be finite.

How to implement

1. Read numeric x,n,m, then the coefficient grid. Traverse coefficient cells in row order, retaining their positions.
2. For zero-based coefficient index i, form exponent e=n+i*m with a binary64 multiplication followed by an addition.
3. Obtain the internal runtime power crt_pow(x,e). This is the current code’s leaf, not the public worksheet POWER wrapper.
4. Multiply by coefficient a_i, then add the term to a binary64 accumulator initialized to zero. Preserve the term and sum order and apply worksheet result publication afterward.

For the first example, the accumulator visits one, seven, then fifteen. With a two-row coefficient array {1,3;2,4}, the same row traversal at x=2, n=0, m=1 gives 1+6+8+32=47.

Horner evaluation can avoid repeated powers for an ordinary polynomial. It can also change rounding, overflow and invalid-power behaviour. Treat it as a separate numerical implementation choice until compared; the series definition alone does not identify Excel’s internal power algorithm or all its storage stages.

Rust code

45 seriessum "SERIESSUM" (4, 4) [V "x", V "n", V "m", R "coefficients"] |s, a, sv| {
    let x = super::kit::num_without_logical(s, a, 0)?;
    let n = super::kit::num_without_logical(s, a, 1)?;
    let m = super::kit::num_without_logical(s, a, 2)?;
    let coefficients = grid(s, a, 3, sv)?;
    let mut sum = 0.0;
    for (i, cell) in coefficients.cells.iter().enumerate() {
        let c = match cell.core_ref() {
            CoreRef::Number(c) => c,
            CoreRef::Error(code) => return fail(code),
            _ => return fail(WorksheetErrorCode::Value),
        };
        sum += c * crt_pow(x, n + (i as f64) * m);
    }
    s.number(sum)
}

No implementation has been published with a Handbook test suite for this function.

Version differences

No same-input comparison between named Excel builds is recorded for this function here. The documented behaviour below is not a measurement of every Excel release.

Alternatives

SUMPRODUCT can combine explicit powers and coefficients; POWER evaluates one term’s power. Horner evaluation is a mathematical alternative for polynomial series.

Named variants

No named variants are recorded yet.