Maxima Manual: Funktionen und Variablen der Integration

Next: Einführung in QUADPACK, Previous: Einführung in die Integration, Nach oben: Integration [Inhalt][Index]

#### 16.3.2 Funktionen und Variablen der Integration

Funktion: changevar (expr, f(x,y), y, x)

  Führt eine Substitution der Integrationsvariablen, die als f(x,y)=0 angegeben wird, für die Variable x in allen Integralen durch, die in expr enthalten sind. Die neue Variable ist y.

      (%i1) assume(a > 0)$

      (%i2) 'integrate (%e**sqrt(a*y), y, 0, 4);
                            4
                           /
                           [    sqrt(a) sqrt(y)
      (%o2)                I  %e                dy
                           ]
                           /
                            0

      (%i3) changevar (%, y-z^2/a, z, y);
                            0
                           /
                           [                abs(z)
                         2 I            z %e       dz
                           ]
                           /
                            - 2 sqrt(a)
      (%o3)            - ----------------------------
                                      a

  Ein Ausdruck mit einem Integral in einer Substantivform `'integrate` wie im obigen Beispiel kann mit der Funktion `ev` und dem Auswertungsschalter `nouns` ausgewertet werden. Das Beispiel von oben kann zum Beispiel mit `ev(%o3, nouns)` ausgewertet werden.

  Mit `changevar` können auch die Indizes einer Summe oder eines Produktes substituiert werden. Dabei muss beachtet werden, dass nur lineare Verschiebungen, wie zum Beispiel `i = j + ...`, eine korrekte Substitution für Summen und Produkte sind.

      (%i4) sum (a[i]*x^(i-2), i, 0, inf);
                               inf
                               ====
                               \         i - 2
      (%o4)                     >    a  x
                               /      i
                               ====
                               i = 0

      (%i5) changevar (%, i-2-n, n, i);
                              inf
                              ====
                              \               n
      (%o5)                    >      a      x
                              /        n + 2
                              ====
                              n = - 2

Funktion: dblint (f, r, s, a, b)

  Eine Routine, um ein bestimmtes doppeltes Integral mit der Simpsonschen Regel numerisch zu berechnen.

            b  s(x)
           /  /
           [  [
           I  I     f(x, y) dy dx
           ]  ]
           /  /
            a  r(x)

  Die Funktion f muss eine Funktion von zwei Variablen sein. r und s müssen Funktionen einer Variablen sein. a und b sind Gleitkommazahlen. Die Optionsvariablen `dblint_x` und `dblint_y` kontrollieren die Anzahl der Unterteilungen des Integrationsintervalls für den Simpsonschen Algorithmus. Der Standardwert ist jeweils 10.

  Das Kommando `demo(dblint)` zeigt ein Beispiel.

  Die numerischen Funktionen des Pakets `QUADPACK` sind gegenüber `dblint` zu bevorzugen.

Funktion: defint (expr, x, a, b)

  Sucht das bestimmte Integral eines Ausdrucks expr für die Integrationsvariable x in den Grenzen a und b. Diese Funktion wird ausgeführt, wenn ein bestimmtes Integral mit der Funktion `integrate` gesucht wird.

  `defint` gibt einen symbolischen Ausdruck als Ergebnis zurück. Ist das Integral divergent, generiert Maxima eine Fehlermeldung. Kann `defint` keine Lösung finden, wird eine Substantivform zurückgegeben.

Optionsvariable: erfflag

  Standardwert: `true`

  Hat `erfflag` den Wert `false`, wird von der Funktion `risch` die Fehlerfunktion `erf` nicht in die Lösung eingeführt.

Funktion: ilt (expr, s, t)

  Berechnet die Inverse Laplace-Transformation des Ausdrucks expr für die Variable s und den Parameter t. expr muss eine rationale Funktion sein, in deren Nenner nur lineare und quadratische Faktoren auftreten. Mit den Funktionen `laplace` und `ilt` sowie den Funktionen `solve` oder `linsolve` können lineare Differentialgleichungen oder Systeme von linearen Differentialgleichungen gelöst werden.

      (%i1) 'integrate (sinh(a*x)*f(t-x), x, 0, t) + b*f(t) = t**2;
                    t
                   /
                   [                                    2
      (%o1)        I  f(t - x) sinh(a x) dx + b f(t) = t
                   ]
                   /
                    0

      (%i2) laplace (%, t, s);
                                     a laplace(f(t), t, s)   2
      (%o2)  b laplace(f(t), t, s) + --------------------- = --
                                             2    2           3
                                            s  - a           s

      (%i3) linsolve ([%], ['laplace(f(t), t, s)]);
                                              2      2
                                           2 s  - 2 a
      (%o3)     [laplace(f(t), t, s) = --------------------]
                                          5         2     3
                                       b s  + (a - a  b) s

      (%i4) ilt (rhs (first (%)), s, t);
      Is  a b (a b - 1)  positive, negative, or zero?

      pos;
                     sqrt(a b (a b - 1)) t
              2 cosh(---------------------)       2
                               b               a t
      (%o4) - ----------------------------- + -------
                    3  2      2               a b - 1
                   a  b  - 2 a  b + a

                                                             2
                                                   + ------------------
                                                      3  2      2
                                                     a  b  - 2 a  b + a

Optionsvariable: intanalysis

  Standardwert: `true`

  Hat `intanalysis` den Wert `true`, sucht Maxima nach Polen in einem Integranden. Existieren solche, wird der Cauchysche Hauptwert des Integrals bestimmt. Hat `intanalysis` den Wert `false`, wird die Integration unter der Annahme ausgeführt, dass das Integral keine Pole im Integrationsbereich hat.

  Siehe auch `ldefint`.

  Beispiele:

  Maxima kann das folgende Integral lösen, wenn `intanalysis` den Wert `false` hat.

      (%i1) integrate(1/(sqrt(x)+1),x,0,1);

                                      1
                                     /
                                     [       1
      (%o1)                          I  ----------- dx
                                     ]  sqrt(x) + 1
                                     /
                                      0

      (%i2) integrate(1/(sqrt(x)+1),x,0,1),intanalysis:false;
      (%o2)                            2 - 2 log(2)

      (%i3) integrate(cos(a)/sqrt((tan(a))^2 +1),a,-%pi/2,%pi/2);
      The number 1 isn't in the domain of atanh
       -- an error. To debug this try: debugmode(true);

      (%i4) intanalysis:false$
      (%i5) integrate(cos(a)/sqrt((tan(a))^2+1),a,-%pi/2,%pi/2);
                                            %pi
      (%o5)                                 ---
                                             2

Funktion: integrate (expr, x)
Funktion: integrate (expr, x, a, b)

  Sucht die symbolische Lösung des Integrals für den Ausdruck expr und der Integrationsvariablen x. `integrate(expr, x)` löst das unbestimmte Integral.

  `integrate(expr, x, a, b)` sucht die Lösung des bestimmten Integrals in den Integrationsgrenzen a und b. Die Integrationsgrenzen dürfen die Integrationsvariable x nicht enthalten. Für die Integrationsgrenzen muss nicht gelten a < b. Sind die Integrationsgrenzen gleich, dann ist das Ergebnis der Integration Null.

  Für die numerische Lösung von Integralen siehe die Funktion `quad_qag` und verwandte Funktionen. Residuen eines Integranden können mit der Funktion `residue` berechnet werden. Einen alternativen Algorithmus für das Lösen von Integralen, die im Integranden eine unbekannte Funktion und deren Ableitung enthalten, bieten die Funktionen `antid` und `antidiff`.

  Findet `integrate` keine Lösung wird eine Substantivform oder ein Ausdruck mit einer oder mehreren Substantivformen zurückgegeben.

  Soll das Integral nicht sofort berechnet werden, kann die Substantivform des Integrals angegeben werden, zum Beispiel `'integrate(expr, x)`. Die Berechnung des Integrals ist dann mit Funktion `ev` und dem Auswertungsschalter `nouns` möglich.

  Die Abhängigkeit der Funktionen im Integranden von Variablen muss explizit zum Beispiel mit `f(x)` angegeben werden. `integrate` beachtet keine Abhängigkeit die mit der Funktion `depends` definiert werden.

  Benötigt `integrate` Informationen zu einem Parameter, die nicht aus dem aktuellen Kontext abgeleitet werden können, wird der Nutzer nach den fehlenden Informationen gefragt.

  `integrate` ist standardmäßig nicht als linear deklariert. Siehe `declare` und `linear`.

  Nur in einigen speziellen Fällen wendet `integrate` die Methode der partiellen Integration an.

  Beispiele:

  Elementare unbestimmte und bestimme Integrale.

      (%i1) integrate (sin(x)^3, x);
                                 3
                              cos (x)
      (%o1)                   ------- - cos(x)
                                 3

      (%i2) integrate (x/ sqrt (b^2 - x^2), x);
                                       2    2
      (%o2)                    - sqrt(b  - x )

      (%i3) integrate (cos(x)^2 * exp(x), x, 0, %pi);
                                     %pi
                                 3 %e      3
      (%o3)                      ------- - -
                                    5      5

      (%i4) integrate (x^2 * exp(-x^2), x, minf, inf);
                                  sqrt(%pi)
      (%o4)                       ---------
                                      2

  Gebrauch von `assume` und interaktive Fragen.

      (%i1) assume (a > 1)$

      (%i2) integrate (x**a/(x+1)**(5/2), x, 0, inf);
          2 a + 2
      Is  -------  an integer?
             5

      no;
      Is  2 a - 3  positive, negative, or zero?

      neg;
                                         3
      (%o2)                  beta(a + 1, - - a)
                                         2

  Substitution der Integrationsvariablen. In diesem Beispiel werden zwei verschiedene Substitutionen vorgenommen. Zuerst wird eine Ableitung der Funktion mit der Funktion `gradef` definiert. Die andere nutzt die Ableitung `diff(r(x))` einer unbekannten Funktion `r(x)`.

      (%i3) gradef (q(x), sin(x^2));
      (%o3)                         q(x)

      (%i4) diff (log (q (r (x))), x);
                            d               2
                           (-- (r(x))) sin(r (x))
                            dx
      (%o4)                ----------------------
                                  q(r(x))

      (%i5) integrate (%, x);
      (%o5)                     log(q(r(x)))

  Die Lösung enthält eine Substantivform für das Integral einer rationalen Funktion. Siehe auch `integrate_use_rootsof` für Informationen zu Integralen von rationalen Funktionen.

      (%i1) expand ((x-4) * (x^3+2*x+1));
                          4      3      2
      (%o1)              x  - 4 x  + 2 x  - 7 x - 4

      (%i2) integrate (1/%, x);
                                    /  2
                                    [ x  + 4 x + 18
                                    I ------------- dx
                                    ]  3
                       log(x - 4)   / x  + 2 x + 1
      (%o2)            ---------- - ------------------
                           73               73

  Definition einer Funktion als ein Integral. Die rechte Seite einer Funktionsdefinition wird nicht ausgewertet. Daher enthält die Funktionsdefinition das Integral in einer Substantivform. Der `Quote-Quote-Operator` `''` erzwingt die Auswertung der Substantivform.

      (%i1) f_1(a) := integrate (x^3, x, 1, a);
                                           3
      (%o1)           f_1(a) := integrate(x , x, 1, a)

      (%i2) ev(f_1 (7), nouns);
      (%o2)                          600

      (%i3) /* Note parentheses around integrate(...) here */
            f_2(a) := ''(integrate (x^3, x, 1, a));
                                         4
                                        a    1
      (%o3)                   f_2(a) := -- - -
                                        4    4

      (%i4) f_2(7);
      (%o4)                          600

Optionsvariable: integration_constant

  Standardwert: `%c`

  Wird eine symbolische Integrationskonstante für die Lösung eines Integrals benötigt, erzeugt Maxima diese durch Verkettung des Symbols `integration_constant` mit einer laufenden Nummer, die der Wert der Optionsvariablen `integration_constant_counter` ist.

  Der Optionsvariablen `integration_constant` kann ein beliebiges Symbol zugewiesen werden.

  Beispiele:

      (%i1) integrate (x^2 = 1, x);
                                 3
                                x
      (%o1)                     -- = x + %c1
                                3

      (%i2) integration_constant : 'k;
      (%o2)                           k

      (%i3) integrate (x^2 = 1, x);
                                  3
                                 x
      (%o3)                      -- = x + k2
                                 3

Systemvariable: integration_constant_counter

  Standardwert: 0

  Wird eine symbolische Integrationskonstante für die Lösung eines Integrals benötigt, erzeugt Maxima diese durch Verkettung des Symbols `integration_constant` mit einer laufenden Nummer, die der Wert der Optionsvariablen `integration_constant_counter` ist.

  Der Wert der Systemvariablen `integration_constant_counter` wird vor der Erzeugung der Integrationskonstanten erhöht.

  Beispiele:

      (%i1) integrate (x^2 = 1, x);
                                 3
                                x
      (%o1)                     -- = x + %c1
                                3

      (%i2) integrate (x^2 = 1, x);
                                 3
                                x
      (%o2)                     -- = x + %c2
                                3

      (%i3) reset (integration_constant_counter);
      (%o3)            [integration_constant_counter]

      (%i4) integrate (x^2 = 1, x);
                                 3
                                x
      (%o4)                     -- = x + %c1
                                3

Optionsvariable: integrate_use_rootsof

  Standardwert: `false`

  Hat `integrate_use_rootsof` den Wert `true` und der Nenner einer rationalen Funktion kann nicht faktorisiert werden, dann gibt `integrate` ein Integral zurück, das eine Summe über die unbekannten Wurzeln des Nenners enthält.

  Hat zum Beispiel `integrate_use_rootsof` den Wert `false`, gibt `integrate` im Folgenden ein Lösung zurück, die eine Substantivform enthält.

      (%i1) integrate_use_rootsof: false$

      (%i2) integrate (1/(1+x+x^5), x);
              /  2
              [ x  - 4 x + 5
              I ------------ dx                            2 x + 1
              ]  3    2                2            5 atan(-------)
              / x  - x  + 1       log(x  + x + 1)          sqrt(3)
      (%o2)   ----------------- - --------------- + ---------------
                      7                 14             7 sqrt(3)

  Mit dem Wert `true` für die Optionsvariable `integrate_use_rootsof` wird das ungelöste Integral als eine Summe über die Wurzeln des Nenners der rationalen Funktion zurückgegeben.

      (%i3) integrate_use_rootsof: true$

      (%i4) integrate (1/(1+x+x^5), x);
            ====        2
            \       (%r4  - 4 %r4 + 5) log(x - %r4)
             >      -------------------------------
            /                    2
            ====            3 %r4  - 2 %r4
                            3    2
            %r4 in rootsof(x  - x  + 1)
      (%o4) ----------------------------------------------------------
                     7

                                                            2 x + 1
                                        2            5 atan(-------)
                                   log(x  + x + 1)          sqrt(3)
                                 - --------------- + ---------------
                                         14             7 sqrt(3)

  Alternativ kann der Nutzer die Wurzeln des Nenners separat berechnen und den Integranden mit Hilfe der Wurzeln ausdrücken. Zum Beispiel als `1/((x - a)*(x - b)*(x - c))` oder `1/((x^2-(a+b)*x + a*b)*(x - c))` für ein kubisches Polynom mit drei Nullstellen im Nenner. Auf diese Weise kann Maxima in einigen Fällen eine Lösung für ein Integral finden.

Funktion: laplace (expr, t, s)

  Sucht die Laplace-Transformation des Ausdrucks expr für die Integrationsvariable x und den Parameter s.

  `laplace` findet die Laplace-Transformation für Ausdrücke, die die Funktionen `delta`, `exp`, `log`, `sin`, `cos`, `sinh`, `cosh` und `erf` sowie Ausdrücke mit `derivative`, `integrate`, `sum` und `ilt` enthalten.

  Kann `laplace` die Laplace-Transformation nicht finden, wird die Funktion `specint` aufgerufen. `specint` kann die Laplace-Transformation für eine Vielzahl von speziellen Funktionen im Integranden berechnen. Findet auch `specint` keine Lösung ist das Ergebnis eine Substantivform.

  `laplace` erkennt die Faltung von Funktionen der Form `integrate (f(x) * g(t - x), x, 0, t)`. Andere Faltungen werden nicht erkannt.

  Funktionale Abhängigkeiten von Variablen müssen explizit angegeben werden. `laplace` erkennt keine Abhängigkeiten, die mit der Funktion `depends` definiert wurden. Eine Funktion die von den Variablen x abhängt, muss als `f(x)` im Ausdruck expr auftreten.

  Siehe auch `ilt` für die Inverse Laplace-Transformation.

  Beispiele:

      (%i1) laplace (exp (2*t + a) * sin(t) * t, t, s);
                                  a
                                %e  (2 s - 4)
      (%o1)                    ---------------
                                 2           2
                               (s  - 4 s + 5)
      (%i2) laplace ('diff (f (x), x), x, s);
      (%o2)             s laplace(f(x), x, s) - f(0)
      (%i3) diff (diff (delta (t), t), t);
                                2
                               d
      (%o3)                    --- (delta(t))
                                 2
                               dt
      (%i4) laplace (%, t, s);
                                  !
                     d            !         2
      (%o4)        - -- (delta(t))!      + s  - delta(0) s
                     dt           !
                                  !t = 0
      (%i5) assume(a>0)$
      (%i6) laplace(gamma_incomplete(a,t),t,s),gamma_expand:true;
                                                    - a - 1
                               gamma(a)   gamma(a) s
      (%o6)                    -------- - -----------------
                                  s            1     a
                                              (- + 1)
                                               s
      (%i7) factor(laplace(gamma_incomplete(1/2,t),t,s));

                                                    s + 1
                            sqrt(%pi) (sqrt(s) sqrt(-----) - 1)
                                                      s
      (%o7)                 -----------------------------------
                                      3/2      s + 1
                                     s    sqrt(-----)
                                                 s

      (%i8) assume(exp(%pi*s)>1)$
      (%i9) laplace(sum((-1)^n*unit_step(t-n*%pi)*sin(t),n,0,inf),t,s)
              ,simpsum;

                               %i                         %i
                    ------------------------ - ------------------------
                                    - %pi s                    - %pi s
                    (s + %i) (1 - %e       )   (s - %i) (1 - %e       )
      (%o9)         ---------------------------------------------------
                                             2

      (%i9) factor(%);
                                            %pi s
                                          %e
      (%o9)                   -------------------------------
                                                   %pi s
                              (s - %i) (s + %i) (%e      - 1)

Funktion: ldefint (expr, x, a, b)

  Sucht die Lösung des bestimmten Integrals für den Integranden expr. `ldefint` bestimmt die Stammfunktion und sucht die Grenzwerte mit der Funktion `limit` an den Integrationsgrenzen a und b. Kann ein Grenzwert nicht ermittelt werden, enthält das Ergebnis die Substantivform des Grenzwertes.

  `ldefint` wird nicht von der Funktion `integrate` aufgerufen. Daher kann `ldefint` ein von `integrate` verschiedenes Ergebnis haben. `ldefint` verwendet immer denselben Algorithmus, um eine Lösung zu finden. Dagegen wendet `integrate` verschiedene Algorithmen an, um nach einer Lösung zu suchen.

Funktion: residue (expr, z, z_0)

  Berechnet das Residuum für den Ausdruck expr, wenn die Variable z gegen den Wert z_0 geht.

  Beispiele:

      (%i1) residue (s/(s**2+a**2), s, a*%i);
                                      1
      (%o1)                           -
                                      2

      (%i2) residue (sin(a*x)/x**4, x, 0);
                                       3
                                      a
      (%o2)                         - --
                                      6

Funktion: risch (expr, x)

  Nutzt den transzendenten Risch-Algorithmus für die Integration des Ausdruck expr und der Integrationsvariable x. Der algebraische Risch-Algorithmus ist nicht implementiert. Der transzendente Risch-Algorithmus behandelt Integranden mit Exponential- und Logarithmusfunktionen. Der Risch-Algorithmus wird von `integrate` aufgerufen, wenn `integrate` keine Stammfunktion finden kann.

  Hat `erfflag` den Wert `false`, werden von der Funktion `risch` keine Fehlerfunktionen `erf` in die Lösung eingeführt.

  Beispiele:

      (%i1) risch (x^2*erf(x), x);
                                                              2
                   3                      2                - x
              %pi x  erf(x) + (sqrt(%pi) x  + sqrt(%pi)) %e
      (%o1)   -------------------------------------------------
                                    3 %pi

      (%i2) diff(%, x), ratsimp;
                                   2
      (%o2)                       x  erf(x)

Funktion: tldefint (expr, x, a, b)

  Entspricht der Funktion `ldefint` mit dem Wert `true` für die Optionsvariable `tlimswitch`.

Next: Einführung in QUADPACK, Previous: Einführung in die Integration, Nach oben: Integration [Inhalt][Index]