Next: Wurzel- Exponential- und Logarithmusfunktion, Previous: Funktionen für komplexe Zahlen, Up: Mathematische Funktionen [Contents][Index]

### 10.3 Funktionen der Kombinatorik

Operator: !!

  Ist der Operator der doppelten Fakultät.

  Für eine positive ganze Zahl `n`, wird `n!!` zu dem Produkt `n (n-2) (n-4) (n-6) ... (n - 2 (k-1))` vereinfacht, wobei `k` gleich `floor(n/2)` ist und `floor` die größte ganze Zahl als Ergebnis hat, die kleiner oder gleich `n/2` ist.

  Für ein Argument `n`, das keine ganze positive Zahl ist, gibt `n!!` die Substantivform `genfact(n, n/2,2)` zurück. Siehe die Funktion `genfact`.

  Die Verallgemeinerung der doppelten Fakultät für reelle und komplexe Zahlen ist als die Funktion `double_factorial` implementiert.

  Beispiele:

      (%i1) [0!!, 1!!, 2!!, 3!!, 4!!, 5!!, 6!!, 7!!, 8!!];
      (%o1)           [1, 1, 2, 3, 8, 15, 48, 105, 384]
      (%i2) 1.5!!;
      (%o2)                  genfact(1.5, 0, 2)
      (%i3) x!!;
                                         x
      (%o3)                   genfact(x, -, 2)
                                         2

Funktion: binomial (x, y)

  Ist der Binominialkoeffizient, der definiert ist als

                                        x!
                   binomial(x, y) = -----------
                                    (x - y)! y!

  Die Funktion `binomial` ist für das numerische und symbolische Rechnen geeignet.

  Sind die Argumente x oder y ganze Zahlen, wird der Binominialkoeffizient zu einer ganzen Zahl vereinfacht. Sind die Argumente x und y reelle oder komplexe Gleitkommazahlen, wird der Binominialkoeffizient mit der entsprechenden verallgemeinerten Fakultät berechnet. Siehe auch `factorial` und `gamma`.

  Ist das Argument y oder die Differenz x-y eine ganz Zahl, wird der Binominialkoeffizient zu einem Polynom vereinfacht.

  Mit den Funktionen `makefact` oder `makegamma` werden Binominialkoeffizienten in einem Ausdruck durch äquivalente Ausdrücke mit der Fakultät oder der Gammafunktion ersetzt.

  Maxima kennt die Ableitung des Binominialkoeffizienten nach den Argumenten x und y.

  Beispiele:

      (%i1) binomial(11, 7);
      (%o1)                          330
      (%i2) binomial(%i, 1.5);
      (%o2)       .3693753994635863 %i - .7573400496142132
      (%i3) binomial(x, 3);
                              (x - 2) (x - 1) x
      (%o3)                   -----------------
                                      6
      (%i4) binomial(x+3, 3);
                           (x + 1) (x + 2) (x + 3)
      (%o4)                -----------------------
                                      6
      (%i5) makefact(binomial(x,y));
                                     x!
      (%o5)                      -----------
                                 (x - y)! y!

      (%i6) diff(binomial(x,y), y);
      (%o6)  - binomial(x, y) (psi (y + 1) - psi (- y + x + 1))
                                  0             0

Funktion: double_factorial (z)

  Ist die doppelte Fakultät, die allgemein definiert ist als

                     2  1/4 (1 - cos(z %pi))  z/2       z
                   (---)                     2    gamma(- + 1)
                    %pi                                 2

  Die Funktion `double_factorial` ist für das numerische und symbolische Rechnen geeignet. Ist das Argument z eine ganze Zahl, eine Gleitkommazahl, eine große Gleitkommazahl oder eine komplexe Gleitkommazahl, dann wird ein numerisches Ergebnis berechnet. Für eine positive ganze Zahl ist das Ergebnis gleich dem Ergebnis des Operators der doppelten Fakultät `!!`. Für rationale Zahlen ist das Ergebnis eine Substantivform.

  Für negative gerade ganze Zahlen ist die Funktion `double_factorial` nicht definiert.

  Hat die Optionsvariable `factorial_expand` den Wert `true`, vereinfacht Maxima `double_factorial` für das Argument `n-1` und für Argumente `n+2*k`, wobei `k` eine ganze Zahl ist.

  Maxima kennt die Ableitung der Funktion `double_factorial`.

  `double_factorial` wird automatisch auf die Elemente von Listen und Matrizen sowie auf die beiden Seiten von Gleichungen angewendet. Siehe `distribute_over`.

  Beispiele:

  Numerische Ergebnisse für ganze Zahlen, Gleitkommazahlen und komplexen Gleitkommazahlen.

      (%i1) double_factorial([-3, -1, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]);
      (%o1) [- 1, 1, 1, 1, 2, 3, 8, 15, 48, 105, 384, 945, 3840]

      (%i2) double_factorial([1.5, 1.5b0, 0.5+%i, 0.5b0+%i]);
      (%o2) [1.380662681753386, 1.380662681753387b0,
      .4186422526242637 - .7218816624466643 %i,
      4.186422526242633b-1 - 7.218816624466641b-1 %i]

  Vereinfachungen, wenn die Optionsvariable `factorial_expand` den Wert `true` hat.

      (%i3) factorial_expand:true;
      (%o3)                         true
      (%i4) double_factorial(n-1);
                                     n!
      (%o4)                  -------------------
                             double_factorial(n)
      (%i5) double_factorial(n+4);
      (%o5)          (n + 2) (n + 4) double_factorial(n)
      (%i6) double_factorial(n-4);

                             double_factorial(n)
      (%o6)                  -------------------
                                  (n - 2) n

  Die Ableitung der Funktion `double_factorial`.

      (%i7) diff(double_factorial(x), x);
                                           2
                                  %pi log(---) sin(%pi x)
                                          %pi                    x
      (%o7) (double_factorial(x) (----------------------- + psi (- + 1)
                                             2                 0 2
                                                           + log(2)))/2

Funktion: factcomb (expr)

  Fasst Faktoren mit Fakultäten im Ausdruck expr zusammen. Zum Beispiel wird `(n+1)*n!` zu `(n+1)!` zusammengefasst.

  Hat die Optionsvariable `sumsplitfact` den Wert `false`, wird nach der Vereinfachung mit `factcomb` die Funktion `minfactorial` auf den Ausdruck expr angewendet.

  Beispiele:

      (%i1) expr: ((n+1)*n!)/(n+2)!;
                                 (n + 1) n!
      (%o1)                      ----------
                                  (n + 2)!
      (%i2) factcomb(expr);

                                  (n + 1)!
      (%o2)                       --------
                                  (n + 2)!

      (%i3) factcomb(expr), sumsplitfact:false;
                                      1
      (%o3)                         -----
                                    n + 2

Funktion: factorial (z)
Operator: !

  Die Funktion `factorial` ist für das numerische und symbolische Rechnen der Fakultät geeignet. Der Operator der Fakultät `!`, ist identisch mit der Funktion `factorial`.

  Für eine ganze Zahl `n`, vereinfacht `n!` zum Produkt der ganzen Zahlen von 1 bis einschließlich `n`. `0!` vereinfacht zu 1. Für reelle und komplexe Gleitkommazahlen wird `z!` mit der Verallgemeinerung `gamma(z+1)` berechnet. Siehe die Funktion `gamma`. Für eine halbzahlige rationale Zahl `n/2`, vereinfacht `(n/2)!` zu einem rationalen Faktor multipliziert mit `sqrt(%pi)`.

  Die Optionsvariable `factlim` enthält die größte Zahl, für die die Fakultät einer ganzen Zahl numerisch berechnet wird. Ist das Argument der Fakultät eine rationale Zahl, wird von Maxima die Funktion `gamma` für die numerische Berechnung aufgerufen. In diesem Fall ist `gammalim - 1` der größte Nenner, für den die Fakultät vereinfacht wird. Siehe `gammalim`.

  Hat die Optionsvariable `factorial_expand` den Wert `true`, wird die Fakultät von Argumenten der Form `(n+k)!` oder `(n-k)!` vereinfacht, wobei `k` eine ganze Zahl ist.

  Mit den Funktionen `minfactorial` und `factcomb` können Fakultäten in Ausdrücken vereinfacht werden.

  Die Funktion `makegamma` ersetzt Fakultäten in einem Ausdruck durch die Gammafunktion `gamma`. Umgekehrt ersetzt die Funktion `makefact` Binomialkoeffizienten und die Gammafunktion in einem Ausdruck durch Fakultäten.

  Maxima kennt die Ableitung der Fakultät und die Grenzwerte der Fakultät für spezielle Werte wie negative ganze Zahlen.

  Siehe auch die Gammfunktion `gamma` und den Binomialkoeffizienten `binomial`.

  Beispiele:

  Die Fakultät einer ganzen Zahl wird zu einer exakten Zahl vereinfacht, wenn das Argument nicht größer als `factlim` ist. Die Fakultät für reelle und komplexe Zahlen wird als Gleitkommazahl berechnet.

      (%i1) factlim:10;
      (%o1)                          10
      (%i2) [0!, (7/2)!, 8!, 20!];
                           105 sqrt(%pi)
      (%o2)            [1, -------------, 40320, 20!]
                                16
      (%i3) [4.77!, (1.0+%i)!];
      (%o3) [81.44668037931197, .3430658398165451 %i
                                                   + .6529654964201663]
      (%i4) [2.86b0!, (1.0b0+%i)!];
      (%o4) [5.046635586910012b0, 3.430658398165454b-1 %i
                                                + 6.529654964201667b-1]

  Die Fakultät von numerischen Konstanten oder eines konstanten Ausdrucks wird numerisch berechnet, wenn die Konstante oder der Ausdruck zu einer Zahl ausgewertet werden kann.

      (%i1) [(%i + 1)!, %pi!, %e!, (cos(1) + sin(1))!];
      (%o1)      [(%i + 1)!, %pi!, %e!, (sin(1) + cos(1))!]
      (%i2) ev (%, numer, %enumer);
      (%o2) [.3430658398165451 %i + .6529654964201663,
               7.188082728976031, 4.260820476357003, 1.227580202486819]

  Fakultäten werden vereinfacht und nicht ausgewertet. Daher wird die Fakultät auch dann berechnet, wenn die Auswertung mit dem Quote-Operator `'` unterdrückt ist.

      (%i1) '([0!, (7/2)!, 4.77!, 8!, 20!]);
                  105 sqrt(%pi)
      (%o1)   [1, -------------, 81.44668037931197, 40320, 20!]
                       16

  Maxima kennt die Ableitung der Fakultät.

      (%i1) diff(x!, x);
      (%o1)                    x! psi (x + 1)
                                     0

  Die Optionsvariable `factorial_expand` kontrolliert die Expansion und Vereinfachung von Ausdrücken, die die Fakultät enthalten.

      (%i1) (n+1)!/n!,factorial_expand:true;
      (%o1)                         n + 1

Optionsvariable: factlim

  Standardwert: 100000

  Die Optionsvariable `factlim` spezifiziert die größte ganze Zahl, für die die Fakultät einer ganzen Zahl numerisch berechnet wird. Hat `factlim` den Wert -1, wird die Fakultät für jede ganze Zahl berechnet. Siehe die Funktion `factorial`.

Optionsvariable: factorial_expand

  Standardwert: `false`

  Die Optionsvariable `factorial_expand` kontrolliert die Vereinfachung von Ausdrücken wie `(n+k)!` oder `(n-k)!`, wobei `k` eine ganze Zahl ist. Siehe `factorial` für ein Beispiel.

  Siehe auch die Funktionen `minfactorial` und `factcomb` für die Vereinfachung von Ausdrücken mit der Fakultät.

Funktion: genfact (x, y, z)

  Gibt die verallgemeinerte Fakultät zurück, die als `x (x-z) (x - 2 z) ... (x - (y - 1) z)` definiert ist. Ist x eine ganze Zahl, dann entspricht `genfact(x, x, 1)` der Fakultät `x!` und `genfact(x, x/2, 2)` der doppelten Fakultät `x!!`. Siehe auch die Funktionen `factorial` und `double_factorial` sowie die Operatoren `!` und `!!`.

Funktion: minfactorial (expr)

  Die Funktion `minfactorial` vereinfacht Fakultäten `factorial` in dem Ausdruck epxr, die sich um eine ganze Zahl voneinander unterscheiden. Siehe auch die Funktion `factcomb`, um Fakultäten zusammenzufassen, sowie die Optionsvariable `factorial_expand`.

      (%i1) n!/(n+2)!;
                                     n!
      (%o1)                       --------
                                  (n + 2)!
      (%i2) minfactorial (%);
                                      1
      (%o2)                    ---------------
                               (n + 1) (n + 2)

Optionsvariable: sumsplitfact

  Standardwert: `true`

  Hat die Optionsvariable `sumsplitfact` den Wert `false`, wird von der Funktion `factcomb` nach der Zusammenfassung von Fakultäten die Funktion `minfactorial` angewendet. Siehe die Funktion `factcomb` für ein Beispiel.

Next: Wurzel- Exponential- und Logarithmusfunktion, Previous: Funktionen für komplexe Zahlen, Up: Mathematische Funktionen [Contents][Index]