This is machine translation

Translated by Microsoft
Mouseover text to see original. Click the button below to return to the English verison of the page.

Note: This page has been translated by MathWorks. Please click here
To view all translated materals including this page, select Japan from the country navigator on the bottom of this page.


Add patterns for definite and indefinite summation

MuPAD® notebooks are not recommended. Use MATLAB® live scripts instead.

MATLAB live scripts support most MuPAD functionality, though there are some differences. For more information, see Convert MuPAD Notebooks to MATLAB Live Scripts.


sum::addpattern(pat, k, res, <[var, …], <[cond, …]>>)
sum::addpattern(pat, k = a .. b, res, <[var, …], <[cond, …]>>)


sum::addpattern(pat, k, res) teaches sum to make use of .

sum::addpattern(pat, k=a..b, res) teaches sum that .

A part of a computer algebra system's summation abilities stems from mathematical pattern matching. The MuPAD® pattern matcher can be extended at runtime with sum::addpattern.

For definite summation, each bound is either an arithmetical expression which may contain pattern variables, or an identifier which can be used as a variable in the result and condition terms.

Users can include pattern variables and conditions on these by giving additional arguments. These conditions, as well as the result, are protected from premature evaluation, i.e., it is not necessary to write hold( _not @ iszero )(a^2-b), a simple not iszero(a^2-b) suffices.

The difference between not iszero(a^2-b) and a^2-b <> 0 when given as a condition is that the latter takes into account assumptions on the identifiers encountered, while the first does not. Cf. Example 4.

Patterns introduced by sum::addpattern are also used in recursive calls of sum and are automatically extended to include simple applications of summation by change of variables. Cf. Example 1.

Environment Interactions

Calling sum::addpattern changes the expressions returned by future calls to sum.


Example 1

Not surprisingly, MuPAD does not know how to do an indefinite summation with the function foo:

sum(foo(n), n)

We add a pattern for this function:

sum::addpattern(foo(k), k, bar(k))
sum(foo(n), n)

Note that this pattern is also used indirectly:


Example 2

Definite sums can be added similarly:

sum::addpattern(foo(k), k=1..infinity, bar(k))
sum(foo(k), k=1..infinity)

The above pattern will also match this definite sum with different bounds:

sum(foo(k), k=3..infinity)

Note that this pattern is also used indirectly:

sum(foo(k)+1/k^3, k=1..infinity)

The bounds may also be variables occurring in the pattern or the result:

sum::addpattern(foo(k,a), k=0..a, bar(a), [a])
sum(foo(k,7), k=0..7)

Example 3

The name of the summation variable used in the call to sum::addpattern does not restrict later calls to sum:

sum::addpattern(x^(2*i+1)/(2*i+1), i=0..infinity,
                piecewise([abs(x) < 1,
                           arccoth(x) + PI/2*sqrt(-1/x^2)*x]),

Example 4

Conditions are checked using is and therefore react to assumptions:

sum::addpattern(binomial(-1/2, k)*x^(2*k^2 + 1)/(2*k + 1),
                              k = 0..infinity, arcsinh(x),
                                     [x], [abs(x) < 1])
sum(binomial(-1/2, k)*x^(2*k^2 + 1)/(2*k + 1), 
    k = 0..infinity) assuming -1 < x < 1

sum(binomial(-1/2, k)*x^(2*k^2 + 1)/(2*k + 1), 
    k = 0..infinity) assuming x > 1

If MuPAD cannot decide whether the conditions are satisfied, a piecewise defined object is returned:

sum(binomial(-1/2, k) * x^(2*k^2+1)/(2*k+1), 
    k = 0..infinity)

If either the conditions are not satisfied or substituting the values into the result yields an error, the pattern is ignored. There is no need to include a condition to guard against an error, MuPAD simply computes the sum as usual:

sum::addpattern(c^k, k=0..n, (c^n-1)/(c-1), [c]);
sum(1^k, k=0..n)



The pattern to match: an arithmetical expression in k.


The summation index: an identifier.

a .. b

The boundaries for a definite summation: arithmetical expressions or identifiers.


The pattern for the result of the summation: an arithmetical expression

var, …

“pattern variables”: placeholders in pat and ret, i.e., identifiers or indexed identifiers. They do not represent themselves but almost arbitrary MuPAD expressions not containing k. You may restrict them by the conditions in the 5th parameter.

cond, …

Conditions on the pattern variables

Return Values

Object of type DOM_NULL

See Also

MuPAD Functions

Was this topic helpful?