Next: Einführung in Reihen, Previous: Summen Produkte und Reihen, Up: Summen Produkte und Reihen [Contents][Index]

### 15.1 Summen und Produkte

Funktion: bashindices (expr)

  Transformiert einen Ausdruck expr, der mehrere Summen oder Produkte enthält so, dass alle Summen und Produkte einen unterschiedlichen Index haben. Dies erleichtert zum Beispiel Substitutionen mit der Funktion `changevar`. Die neuen Indizes werden mit `jnummer` bezeichnet, wobei die Zahl nummer der Wert der Optionsvariablen `gensumnum` ist.

  Beispiel:

      (%i1) sum(1/k^2,k,0,inf)+sum(1/k,k,0,inf);
                             inf       inf
                             ====      ====
                             \     1   \     1
      (%o1)                   >    - +  >    --
                             /     k   /      2
                             ====      ====  k
                             k = 0     k = 0
      (%i2) bashindices(%);
                           inf         inf
                           ====        ====
                           \      1    \       1
      (%o2)                 >     -- +  >     ---
                           /      j2   /        2
                           ====        ====   j1
                           j2 = 0      j1 = 0

Optionsvariable: cauchysum

  Standardwert: `false`

  Werden zwei Reihen miteinander multipliziert und die Optionsvariablen `sumexpand` sowie `cauchysum` haben beide den Wert `true`, dann wird die Cauchy-Produktformel angewendet.

  Beispiele:

      (%i1) sumexpand: false$
      (%i2) cauchysum: false$
      (%i3) s: sum (f(i), i, 0, inf) * sum (g(j), j, 0, inf);
                            inf         inf
                            ====        ====
                            \           \
      (%o3)                ( >    f(i))  >    g(j)
                            /           /
                            ====        ====
                            i = 0       j = 0
      (%i4) sumexpand: true$
      (%i5) cauchysum: true$
      (%i6) ''s;
                       inf     i1
                       ====   ====
                       \      \
      (%o6)             >      >     g(i1 - i2) f(i2)
                       /      /
                       ====   ====
                       i1 = 0 i2 = 0

Optionsvariable: genindex

  Standardwert: `i`

  `genindex` enthält das Zeichen für den Präfix, der verwendet wird, um einen neuen Index für eine Summe oder ein Produkt zu generieren. Siehe auch `gensumnum`.

Optionsvariable: gensumnum

  Standardwert: 0

  `gensumnum` enthält die Nummer, die an den Präfix `genindex` angehängt wird, um den nächsten Index für eine Summe oder ein Produkt zu generieren. Hat `gensumnum` den Wert `false`, wird der Index nur aus dem Zeichen `genindex` gebildet. Siehe auch `genindex`.

Funktion: intosum (expr)

  Multipliziert Faktoren in eine Summe herein. Tritt der Index der Summe als ein Faktor außerhalb der Summe auf, wird von der Funktion `intosum` ein neuer Index gebildet. Summen haben die Eigenschaft `outative`, so dass Faktoren bei der Vereinfachung aus der Summe herausgezogen werden. Mit der Funktion `intosum` wird diese Vereinfachung rückgängig gemacht.

  Beispiel:

      (%i1) sum(2*x^2*n^k, k , 0, inf);
                                     inf
                                     ====
                                   2 \      k
      (%o1)                     2 x   >    n
                                     /
                                     ====
                                     k = 0

      (%i2) intosum(%);
                                inf
                                ====
                                \        k  2
      (%o2)                      >    2 n  x
                                /
                                ====
                                k = 0

Funktion: lsum (expr, i, L)

  Bildet die Summe für den Ausdruck expr zum Index i für alle Elemente der Liste L. Kann das Argument L nicht zu einer Liste ausgewertet werden, wird eine Substantivform zurückgegeben. Siehe auch `sum`.

  Beispiele:

      (%i1) lsum (x^i, i, [1, 2, 7]);
                                  7    2
      (%o1)                      x  + x  + x
      (%i2) lsum (i^2, i, rootsof (x^3 - 1, x));
                           ====
                           \      2
      (%o2)                 >    i
                           /
                           ====
                                         3
                           i in rootsof(x  - 1, x)

Funktion: niceindices (expr)

  Gibt den Indizes von Summen und Produkten im Ausdruck expr einen neuen Namen. `niceindices` benennt die Indizes nacheinander mit den Namen, die in der Liste der Optionsvariablen `niceindicespref` enthalten sind. Die Standardnamen sind `[i, j, k, l, m, n]`. Sind nicht genügend Namen in der Liste vorhanden, werden weitere Indizes durch das Anhängen einer Nummer gebildet.

  `niceindices` wertet das Argument aus.

  Beispiele:

      (%i1) product (sum (f (foo + i*j*bar), foo, 1, inf), bar, 1, inf);
                       inf    inf
                      /===\   ====
                       ! !    \
      (%o1)            ! !     >      f(bar i j + foo)
                       ! !    /
                      bar = 1 ====
                              foo = 1

      (%i2) niceindices (%);
                           inf  inf
                          /===\ ====
                           ! !  \
      (%o2)                ! !   >    f(i j l + k)
                           ! !  /
                          l = 1 ====
                                k = 1

Optionsvariable: niceindicespref

  Standardwert: `[i, j, k, l, m, n]`

  `niceindicespref` ist die Liste mit den Namen, die die Funktion `niceindices` nutzt, um die Indizes von Summen und Produkte umzubenennen.

  Beispiele:

      (%i1) niceindicespref: [p, q, r, s, t, u]$
      (%i2) product (sum (f (foo + i*j*bar), foo, 1, inf), bar, 1, inf);
                       inf    inf
                      /===\   ====
                       ! !    \
      (%o2)            ! !     >      f(bar i j + foo)
                       ! !    /
                      bar = 1 ====
                              foo = 1
      (%i3) niceindices (%);
                           inf  inf
                          /===\ ====
                           ! !  \
      (%o3)                ! !   >    f(i j q + p)
                           ! !  /
                          q = 1 ====
                                p = 1

Funktion: nusum (expr, i, i_0, i_1)

  Wendet den Gosper-Algorithmus der unbestimmten Summation für den Ausdruck expr und dem Index i an. Der Index i läuft von i_0 bis i_1. Der Ausdruck expr und das Ergebnis der Summation müssen als Produkte von ganzzahligen Exponentiationen, Fakultäten, Binomialen und rationalen Funktionen darstellbar sein.

  Die Funktionen `nusum` und `unsum` wenden einige Regeln für die Vereinfachung von Summen und Differenzen von endlichen Produkten an. Siehe auch `unsum`.

  Beispiele:

      (%i1) nusum (n*n!, n, 0, n);

      Dependent equations eliminated:  (1)
      (%o1)                     (n + 1)! - 1
      (%i2) nusum (n^4*4^n/binomial(2*n,n), n, 0, n);
                           4        3       2              n
            2 (n + 1) (63 n  + 112 n  + 18 n  - 22 n + 3) 4      2
      (%o2) ------------------------------------------------ - ------
                          693 binomial(2 n, n)                 3 11 7
      (%i3) unsum (%, n);
                                    4  n
                                   n  4
      (%o3)                   ----------------
                              binomial(2 n, n)

      (%i4) unsum (prod (i^2, i, 1, n), n);
                          n - 1
                          /===\
                           ! !   2
      (%o4)              ( ! !  i ) (n - 1) (n + 1)
                           ! !
                          i = 1

      (%i5) nusum (%, n, 1, n);

      Dependent equations eliminated:  (2 3)
                                  n
                                /===\
                                 ! !   2
      (%o5)                      ! !  i  - 1
                                 ! !
                                i = 1

Funktion: product (expr, i, i_0, i_1)

  Bildet das Produkt des Ausdrucks expr zum Index i in den Grenzen i_0 bis i_1. `product` wertet expr sowie die untere Grenze i_0 und obere Grenze i_1 aus. Der Index i wird nicht ausgewertet.

  Ist die Differenz der oberen und unteren Grenze eine ganze Zahl, wird expr für jeden Wert des Index i ausgewertet. Das Ergebnis ist ein explizites Produkt. Andernfalls ist der Bereich des Index unbestimmt. Maxima wendet einige einfache Regeln an, um das Produkt zu vereinfachen. Hat die Optionsvariable `simpproduct` den Wert `true`, wendet Maxima weitere Regeln an, um Produkte zu vereinfachen.

  Siehe auch `nouns` und `evflag` für die Auswertung von Ausdrücken, die die Substantivform eines Produktes enthalten.

  Beispiele:

      (%i1) product (x + i*(i+1)/2, i, 1, 4);
      (%o1)           (x + 1) (x + 3) (x + 6) (x + 10)
      (%i2) product (i^2, i, 1, 7);
      (%o2)                       25401600
      (%i3) product (a[i], i, 1, 7);
      (%o3)                 a  a  a  a  a  a  a
                             1  2  3  4  5  6  7
      (%i4) product (a(i), i, 1, 7);
      (%o4)          a(1) a(2) a(3) a(4) a(5) a(6) a(7)
      (%i5) product (a(i), i, 1, n);

                                   n
                                 /===\
                                  ! !
      (%o5)                       ! !  a(i)
                                  ! !
                                 i = 1

      (%i6) product (k, k, 1, n);
                                     n
                                   /===\
                                    ! !
      (%o6)                         ! !  k
                                    ! !
                                   k = 1
      (%i7) product (k, k, 1, n), simpproduct;
      (%o7)                          n!
      (%i8) product (integrate (x^k, x, 0, 1), k, 1, n);
                                   n
                                 /===\
                                  ! !    1
      (%o8)                       ! !  -----
                                  ! !  k + 1
                                 k = 1
      (%i9) product (if k <= 5 then a^k else b^k, k, 1, 10);
                                    15  40
      (%o9)                        a   b

Optionsvariable: simpproduct

  Standardwert: `false`

  Hat `simpproduct` den Wert `true`, versucht Maxima ein Produkt weiter zu vereinfachen. Die Vereinfachung kann eine geschlossene Form liefern. Hat `simpproduct` den Wert `false` oder wird das Produkt als Substantivform `'product` definiert, werden nur einige einfache Regeln von Maxima für die Vereinfachung angewendet. `simpproduct` ist auch ein Auswertungsschalter. Siehe `evflag`.

  Siehe auch `product` für ein Beispiel.

Optionsvariable: simpsum

  Standardwert: `false`

  Hat `simpsum` den Wert `true`, versucht Maxima eine Summe oder Reihe weiter zu vereinfachen. Die Vereinfachung kann eine geschlossene Form liefern. Hat `simpsum` den Wert `false` oder die Summe oder Reihe liegt als Substantivform `'sum` vor, werden nur einige einfache Regeln von Maxima für die Vereinfachung angewendet. `simpsum` ist auch ein Auswertungsschalter. Siehe `evflag`.

  Siehe auch `sum` für ein Beispiel.

Funktion: sum (expr, i, i_0, i_1)

  Bildet die Summe des Ausdrucks expr zum Index i in den Grenzen i_0 bis i_1. Die Funktion `sum` wertet expr sowie die untere Grenze i_0 und obere Grenze i_1 aus. Der Index i wird nicht ausgewertet.

  Ist die Differenz der oberen und unteren Grenze eine ganze Zahl, wird expr für jeden Wert des Index i ausgewertet. Das Ergebnis ist eine explizite Summe. Andernfalls ist der Bereich des Index unbestimmt. Maxima wendet einige einfache Regeln an, um die Summe zu vereinfachen. Hat die Optionsvariable `simpsum` den Wert `true`, wendet Maxima weitere Regeln an, um Summen zu vereinfachen.

  Werden zwei unendliche Reihen miteinander multipliziert und die Optionsvariablen `sumexpand` sowie `cauchysum` haben beide den Wert `true`, dann wird die Cauchy-Produktformel angewendet.

  Die Optionsvariable `genindex` enthält das Zeichen, das der Präfix eines automatisch generierten Index ist. `gensumnum` enthält eine ganze Zahl, die an den Präfix `genindex` angehängt wird, um einen automatischen Index zu generieren. `gensumnum` wird von Maxima automatisch erhöht. Hat `gensumnum` den Wert `false`, wird keine Zahl an den Präfix angehängt.

  Das Paket `simplify_sum` enthält die Funktion `simplify_sum`, mit der Summen zu einer geschlossenen Form vereinfacht werden können.

  Siehe auch `sumcontract`, `sumexpand`, `intosum`, `bashindices`, `niceindices`, `cauchysum` und `zeilberger`.

  Beispiele:

      (%i1) sum (i^2, i, 1, 7);
      (%o1)                          140
      (%i2) sum (a[i], i, 1, 7);
      (%o2)           a  + a  + a  + a  + a  + a  + a
                       7    6    5    4    3    2    1
      (%i3) sum (a(i), i, 1, 7);
      (%o3)    a(7) + a(6) + a(5) + a(4) + a(3) + a(2) + a(1)
      (%i4) sum (a(i), i, 1, n);
                                  n
                                 ====
                                 \
      (%o4)                       >    a(i)
                                 /
                                 ====
                                 i = 1

      (%i5) sum (2^i + i^2, i, 0, n);
                                n
                               ====
                               \       i    2
      (%o5)                     >    (2  + i )
                               /
                               ====
                               i = 0

      (%i6) sum (2^i + i^2, i, 0, n), simpsum;
                                    3      2
                         n + 1   2 n  + 3 n  + n
      (%o6)             2      + --------------- - 1
                                        6

      (%i7) sum (1/3^i, i, 1, inf);
                                  inf
                                  ====
                                  \     1
      (%o7)                        >    --
                                  /      i
                                  ====  3
                                  i = 1

      (%i8) sum (1/3^i, i, 1, inf), simpsum;
                                      1
      (%o8)                           -
                                      2
      (%i9) sum (i^2, i, 1, 4) * sum (1/i^2, i, 1, inf);
                                    inf
                                    ====
                                    \     1
      (%o9)                      30  >    --
                                    /      2
                                    ====  i
                                    i = 1
      (%i10) sum (i^2, i, 1, 4) * sum (1/i^2, i, 1, inf), simpsum;
                                        2
      (%o10)                       5 %pi
      (%i11) sum (integrate (x^k, x, 0, 1), k, 1, n);
                                  n
                                 ====
                                 \       1
      (%o11)                      >    -----
                                 /     k + 1
                                 ====
                                 k = 1
      (%i12) sum (if k <= 5 then a^k else b^k, k, 1, 10);
                10    9    8    7    6    5    4    3    2
      (%o12)   b   + b  + b  + b  + b  + a  + a  + a  + a  + a

Funktion: sumcontract (expr)

  Fasst alle Summen in dem Ausdruck expr zusammen, die sich in ihrem oberen und unterem Index nur um eine Konstante voneinander unterscheiden. Das Ergebnis ist eine Ausdruck mit einer Summe, für die Summen, die zusammengefasst werden können und weiteren Termen, die hinzu addiert werden müssen, um einen äquivalenten Ausdruck zu erhalten.

  Es kann notwendig sein zunächst das Kommando `intosum(expr)` auszuführen. Siehe `intosum`.

  Beispiel:

      (%i1) 'sum(1/l,l,1,n)+'sum(k,k,1,n+2);

                               n        n + 2
                              ====      ====
                              \     1   \
      (%o1)                    >    - +  >    k
                              /     l   /
                              ====      ====
                              l = 1     k = 1

      (%i2) sumcontract(%);

                                  n
                                 ====
                                 \          1
      (%o2)                2 n +  >    (l + -) + 3
                                 /          l
                                 ====
                                 l = 1

Optionsvariable: sumexpand

  Standardwert: `false`

  Hat die Optionsvariable `sumexpand` den Wert `true`, werden Produkte von Summen und Potenzen von Summen zu verschachtelten Summen vereinfacht. Siehe auch `cauchysum`.

  Beispiele:

      (%i1) sumexpand: true$
      (%i2) sum (f (i), i, 0, m) * sum (g (j), j, 0, n);
                           m      n
                          ====   ====
                          \      \
      (%o2)                >      >     f(i1) g(i2)
                          /      /
                          ====   ====
                          i1 = 0 i2 = 0
      (%i3) sum (f (i), i, 0, m)^2;
                           m      m
                          ====   ====
                          \      \
      (%o3)                >      >     f(i3) f(i4)
                          /      /
                          ====   ====
                          i3 = 0 i4 = 0

Funktion: unsum (f, n)

  Gibt die erste Rückwärtsdifferenz `f(n) - f(n-1)` zurück. Siehe auch `nusum`.

  Beispiele:

      (%i1) g(p) := p*4^n/binomial(2*n,n);

                                           n
                                        p 4
      (%o1)               g(p) := ----------------
                                  binomial(2 n, n)

      (%i2) g(n^4);
                                    4  n
                                   n  4
      (%o2)                   ----------------
                              binomial(2 n, n)

      (%i3) nusum (%, n, 0, n);
                           4        3       2              n
            2 (n + 1) (63 n  + 112 n  + 18 n  - 22 n + 3) 4      2
      (%o3) ------------------------------------------------ - ------
                          693 binomial(2 n, n)                 3 11 7
      (%i4) unsum (%, n);
                                    4  n
                                   n  4
      (%o4)                   ----------------
                              binomial(2 n, n)

Next: Einführung in Reihen, Previous: Summen Produkte und Reihen, Up: Summen Produkte und Reihen [Contents][Index]