[ < ] | [ > ] |  | [ << ] | [ Up ] | [ >> ] |  |  |  |  | [Top] | [Contents] | [Index] | [ ? ]

# 16. Analysis

[ < ] | [ > ] |  | [ << ] | [ Up ] | [ >> ] |  |  |  |  | [Top] | [Contents] | [Index] | [ ? ]

## 16.1 Funktionen und Variablen für Grenzwerte

Optionsvariable: lhospitallim

  Standardwert: 4

  Die Optionsvariable `lhospitallim` enthält die maximale Zahl an Iterationen, für die die L'Hospitalsche Regel von der Funktion `limit` angewendet wird. Damit wird verhindert, dass die Funktion `limit` in eine unendliche Schleife gerät.

Funktion: limit (expr, x, val, dir)
Funktion: limit (expr, x, val)
Funktion: limit (expr)

  Berechnet den Grenzwert des Ausdrucks expr, wenn die reelle Variable x gegen den Wert val in Richtung dir geht. Die Richtung dir kann die Werte plus für einen Grenzwert von oben und minus für einen Grenzwert von unten haben. Für einen zweiseitigen Grenzwert wird die Richtung dir nicht angegeben.

  Maxima verwendet die folgenden Symbole für unendliche und infinitesimale Größen sowie undefinierte und unbestimmte Größen, die als Ergebnis eines Grenzwertes oder als Wert für die Bestimmung eines Grenzwertes auftreten können:

  `inf`

    positiv unendlich

  `minf`

    negativ unendlich

  `infinity`

    komplex unendlich

  `zeroa`

    positiv unendlich klein

  `zerob`

    negativ unendlich klein

  `und`

    ein nicht definiertes Ergebnis

  `ind`

    ein unbestimmtes Ergebnis

  Die Optionsvariable `lhospitallim` enthält die maximale Zahl an Iterationen, für die die L'Hospitalsche Regel von der Funktion `limit` angewendet wird.

  Hat `tlimswitch` den Wert `true`, nutzt die Funktion `limit` eine Taylor-Reihenentwicklung, wenn der Grenzwert nicht mit anderen Methoden bestimmt werden kann.

  Hat die Optionsvariable `limsubst` den Wert `false`, wird die Ersetzung von `limit(f(g(x)),x,x0)` durch `f(limit(g(x),x,x0))` für eine unbekannte Funktion `f` verhindert. Siehe auch `limsubst`.

  `limit` kann mit einem Argument aufgerufen werden, um Ausdrücke zu vereinfachen, die unendliche oder infinitesimale Größen enthalten. Zum Beispiel wird `limit(inf-1)` zu `inf` vereinfacht.

  Der Algorithmus ist in der folgenden Arbeit beschrieben: Wang, P., "Evaluation of Definite Integrals by Symbolic Manipulation", Ph.D. thesis, MAC TR-92, October 1971.

  Beispiele:

      (%i1) limit(x*log(x),x,0,plus)
      (%o1)                           0
      (%i2) limit((x+1)^(1/x),x,0)
      (%o2)                          %e
      (%i3) limit(%e^x/x,x,inf)
      (%o3)                          inf
      (%i4) limit(sin(1/x),x,0)
      (%o4)                          ind

Optionsvariable: limsubst

  Standardwert: `false`

  Ist eine Funktion `f` teil eines Ausdrucks für den Maxima den Grenzwert sucht, dann wird folgende Ersetzung ausgeführt:

         limit   f(g(x)) = f(limit   g(x))
         x -> x0             x -> x0

  Hat die Optionsvariable `limsubst` den Wert `false`, führt `limit` die oben gezeigte Ersetzung nicht für unbekannte Funktionen `f` aus. Dies vermeidet Fehler wie zum Beispiel ein Ergebnis von 1 für den Grenzwert `limit (f(n)/f(n+1), n, inf)`. Hat `limsubst` den Wert `true`, führt Maxima die oben gezeigte Ersetzung auch für unbekannte Funktionen `f` aus.

  Beispiele:

  Die Funktion `f` ist nicht definiert. Maxima gibt im ersten Fall eine Substantivform zurück. Im zweiten Fall nimmt Maxima den Grenzwert für die unbekannte Funktion als `f(10)` an.

      (%i1) limit(f(x),x,10),limsubst:false;
      (%o1)                     limit   f(x)
                                x -> 10
      (%i2) limit(f(x),x,10),limsubst:true;
      (%o2)                         f(10)

Funktion: tlimit (expr, x, val, dir)
Funktion: tlimit (expr, x, val)
Funktion: tlimit (expr)

  Bestimmt den Grenzwert mit Hilfe der Taylor-Reihenwicklung des Ausdrucks `expr`, wenn die Variable x gegen den Wert `val` aus der Richtung dir geht. Diese Methode wird von `limit` angewendet, wenn die Optionsvariable `tlimswitch` den Wert `true` ist. Das ist der Standardwert.

Optionsvariable: tlimswitch

  Standardwert: `true`

  Hat `tlimswitch` den Wert `true`, nutzt die Funktion `limit` eine Taylor-Reihenentwicklung, wenn der Grenzwert nicht mit anderen Methoden bestimmt werden kann.

[ < ] | [ > ] |  | [ << ] | [ Up ] | [ >> ] |  |  |  |  | [Top] | [Contents] | [Index] | [ ? ]

## 16.2 Funktionen und Variablen der Differentiation

Funktion: at (expr, [eqn_1, …, eqn_n])
Funktion: at (expr, eqn)

  Wertet den Ausdruck expr aus, wobei dessen Variablen die Werte annehmen, die in der Liste der Gleichungen `[eqn_1, ..., eqn_n]` oder in der einzelnen Gleichung eqn angegeben sind.

  Wenn ein Teilausdruck von einer Variablen abhängt, für die ein Wert angegeben ist, aber kein `atvalue`, und er auch sonst nicht ausgewertet werden kann, dann wird von `at` eine Substantivform zurückgegeben.

  `at` führt mehrfache Ersetzungen parallel aus.

  Siehe auch `atvalue`. Für andere Funktionen, die Ersetzungen ausführen, siehe weiterhin `subst` und `ev`.

  Beispiele:

      (%i1) atvalue (f(x,y), [x = 0, y = 1], a^2);
                                      2
      (%o1)                          a
      (%i2) atvalue ('diff (f(x,y), x), x = 0, 1 + y);
      (%o2)                        @2 + 1
      (%i3) printprops (all, atvalue);
                                      !
                        d             !
                       --- (f(@1, @2))!       = @2 + 1
                       d@1            !
                                      !@1 = 0

                                           2
                                f(0, 1) = a

      (%o3)                         done
      (%i4) diff (4*f(x, y)^2 - u(x, y)^2, x);
                        d                          d
      (%o4)  8 f(x, y) (-- (f(x, y))) - 2 u(x, y) (-- (u(x, y)))
                        dx                         dx
      (%i5) at (%, [x = 0, y = 1]);
                                               !
                    2              d           !
      (%o5)     16 a  - 2 u(0, 1) (-- (u(x, y))!            )
                                   dx          !
                                               !x = 0, y = 1

Funktion: antid (expr, x, u(x))

  Gibt eine Liste mit zwei Elementen zurück aus denen die Stammfunktion des Ausdrucks expr mit der Variablen x konstruiert werden kann. Der Ausdruck expr kann eine unbekannte Funktion u und deren Ableitungen enthalten. Ist L das Ergebnis der Funktion `antid`, dann ist der Ausdruck `L[1]+ 'integrate(L[2], x)` die gesuchte Stammfunktion des Ausdrucks expr mit der Variablen x.

  Kann `antid` die Stammfunktion vollständig bestimmen, ist das zweite Element der Liste Null. Hat `antid` keinerlei Erfolg, ist das erste Element der Liste Null. In anderen Fällen enthält das erste Elemente den integrierbaren Anteil des Ausdrucks expr und das zweite Element den nicht integrierbaren Anteil des Ausdrucks.

  Mit dem Kommando `load(antid)` wird die Funktion geladen.

  `antid` steht in folgender Beziehung zur Funktion `antidiff`. Ist L die Liste mit den Ergebnissen der Funktion `antid`, dann hat die Funktion `antidiff` das Ergebnis `L[1] + 'integrate(L[2], x)` mit x als der Variablen des Ausdrucks expr.

  Beispiele:

      (%i1) load ("antid")$
      (%i2) expr: exp (z(x)) * diff (z(x), x) * y(x);
                                  z(x)  d
      (%o2)                y(x) %e     (-- (z(x)))
                                        dx
      (%i3) a1: antid (expr, x, z(x));
                             z(x)      z(x)  d
      (%o3)          [y(x) %e    , - %e     (-- (y(x)))]
                                             dx
      (%i4) a2: antidiff (expr, x, z(x));
                                  /
                           z(x)   [   z(x)  d
      (%o4)         y(x) %e     - I %e     (-- (y(x))) dx
                                  ]         dx
                                  /
      (%i5) a2 - (first (a1) + 'integrate (second (a1), x));
      (%o5)                           0
      (%i6) antid (expr, x, y(x));
                                   z(x)  d
      (%o6)             [0, y(x) %e     (-- (z(x)))]
                                         dx
      (%i7) antidiff (expr, x, y(x));
                        /
                        [        z(x)  d
      (%o7)             I y(x) %e     (-- (z(x))) dx
                        ]              dx
                        /

Funktion: antidiff (expr, x, u(x))

  Gibt die Stammfunktion des Ausdrucks expr mit der Variablen x zurück. Der Ausdruck expr kann eine unbekannte Funktion u und deren Ableitungen enthalten.

  Kann `antidiff` die Stammfunktion nicht oder nur teilweise bestimmen, enthält das Ergebnis das Integral des nicht bestimmbaren Anteils.

  Mit dem Kommando `load(antid)` wird die Funktion geladen.

  `antidiff` steht in folgender Beziehung zur Funktion `antid`. Ist L die Liste mit den Ergebnissen der Funktion `antid`, dann hat die Funktion `antidiff` das Ergebnis `L[1] + 'integrate(L[2], x)` mit x als der Variablen des Ausdrucks expr.

  Für Beispiele und weitere Ausführungen siehe die Funktion `antid`.

Eigenschaft: atomgrad

  Wird für ein Symbol eine Ableitung mit der Funktion `gradef` definiert, dann erhält das Symbol die Eigenschaft `atomgrad`.

Funktion: atvalue (expr, [x_1 = a_1, …, x_m = a_m], c)
Funktion: atvalue (expr, x_1 = a_1, c)

  Dem Ausdruck expr wird der Wert c am Punkt `x = a` zugewiesen. Typischerweise werden Randwerte mit der Funktion `atvalue` definiert.

  Der Ausdruck expr ist entweder eine Funktion `f(x_1, ..., x_m)` oder die Ableitung einer Funktion `diff(f(x_1, ..., x_m), x_1, n_1, ..., x_n, n_m)`. Die Argumente müssen explizit auftreten. n_i ist die Ordnung der Ableitung bezüglich der Variablen x_i.

  Die Randwerte werden durch die Liste `[x_1 = a_1, ..., x_m = a_m]` definiert. Eine einzelne Gleichung muss nicht als Liste angegeben werden.

  `printprops([f_1, f_2, ...], atvalue)` zeigt die Randwerte der Funktionen `f_1, f_2, ...` wie sie mit der Funktion `atvalue` definiert wurden. `printprops (f, atvalue)` zeigt nur die Randwerte für die Funktion f. `printprops (all, atvalue)` zeigt die Randwerte aller Funktionen.

  Die Symbole `@1`, `@2`, … repräsentieren die Variablen x_1, x_2, …, wenn die Randwerte angezeigt werden.

  `atvalue` wertet die Argumente aus. `atvalue` gibt den Randwert c zurück.

  Beispiele:

      (%i1) atvalue (f(x,y), [x = 0, y = 1], a^2);
                                      2
      (%o1)                          a
      (%i2) atvalue ('diff (f(x,y), x), x = 0, 1 + y);
      (%o2)                        @2 + 1
      (%i3) printprops (all, atvalue);
                                      !
                        d             !
                       --- (f(@1, @2))!       = @2 + 1
                       d@1            !
                                      !@1 = 0

                                           2
                                f(0, 1) = a

      (%o3)                         done
      (%i4) diff (4*f(x,y)^2 - u(x,y)^2, x);
                        d                          d
      (%o4)  8 f(x, y) (-- (f(x, y))) - 2 u(x, y) (-- (u(x, y)))
                        dx                         dx
      (%i5) at (%, [x = 0, y = 1]);
                                               !
                    2              d           !
      (%o5)     16 a  - 2 u(0, 1) (-- (u(x, y))!            )
                                   dx          !
                                               !x = 0, y = 1

Paket: cartan

  The exterior calculus of differential forms is a basic tool of differential geometry developed by Elie Cartan and has important applications in the theory of partial differential equations. The `cartan` package implements the functions `ext_diff` and `lie_diff`, along with the operators `~` (wedge product) and `|` (contraction of a form with a vector.) Type `demo (tensor)` to see a brief description of these commands along with examples.

  `cartan` was implemented by F.B. Estabrook and H.D. Wahlquist.

Funktion: del (x)

  `del(x)` repräsentiert das Differential der Variablen x.

  `diff` gibt Ausdrücke zurück, die Differentiale enthalten, wenn keine Variablen angegeben sind, nach denen abgeleitet werden soll. In diesem Fall gibt `diff` das totale Differential zurück.

  Beispiele:

      (%i1) diff (log (x));
                                   del(x)
      (%o1)                        ------
                                     x
      (%i2) diff (exp (x*y));
                           x y              x y
      (%o2)            x %e    del(y) + y %e    del(x)
      (%i3) diff (x*y*z);
      (%o3)         x y del(z) + x z del(y) + y z del(x)

Funktion: delta (t)

  Die Diracsche Delta-Funktion.

  Maxima kennt die Delta-Funktion nur im Zusammenhang mit Laplace-Transformationen. Siehe `laplace`.

  Beispiel:

      (%i1) laplace (delta (t - a) * sin(b*t), t, s);
      Is  a  positive, negative, or zero?

      p;
                                         - a s
      (%o1)                   sin(a b) %e

Systemvariable: dependencies

  Standardwert: `[]`

  `dependencies` ist eine Liste der Symbole, für die eine Abhängigkeit mit den Funktionen `depends` oder `gradef` definiert wurde. Siehe `depends` und `gradef`.

Funktion: depends (f_1, x_1, …, f_n, x_n)

  Definiert die Abhängigkeit einer Funktion f von einer Variablen x. Ist keine Abhängigkeit definiert, dann hat die Ableitung `diff(f, x)` das Ergebnis Null. Wird mit dem Kommando `depends(f, x)` definiert, dass die Funktion f von der Variablen x abhängt, dann ist das Ergebnis der Ableitung die Substantivform `'diff(f,x,1)`.

  Jedes Argument f_1, x_1, … kann der Name einer Variablen, eines Arrays oder eine Liste mit Namen sein. Jedes Symbol f_i hängt ab von den Symbolen der Liste x_i. Ist eines der Symbole f_i der Name eines Arrays, dann hängen alle Elemente des Arrays von x_i ab.

  `diff` erkennt indirekte Abhängigkeiten und wendet für diesen Fall die Kettenregel an.

  `remove(f, dependency)` entfernt alle Abhängigkeiten, die für f definiert wurden.

  `depends` gibt eine Liste der Abhängigkeiten zurück. Die Abhängigkeiten werden in die Informationsliste `dependencies` eingetragen. `depends` wertet die Argumente aus.

  Die Funktion `diff` ist die einzige Maxima-Funktion, die Abhängigkeiten erkennt, die mit `depends` definiert wurden. Andere Funktionen wie `integrate` oder `laplace` erkennen keine Abhängigkeiten, die mit der `depends` definiert wurden. Für diese Funktionen müssen die Abhängigkeiten explizit angegeben werden, zum Beispiel als `integrate(f(x), x)`.

  Beispiele:

      (%i1) depends ([f, g], x);
      (%o1)                     [f(x), g(x)]
      (%i2) depends ([r, s], [u, v, w]);
      (%o2)               [r(u, v, w), s(u, v, w)]
      (%i3) depends (u, t);
      (%o3)                        [u(t)]
      (%i4) dependencies;
      (%o4)      [f(x), g(x), r(u, v, w), s(u, v, w), u(t)]
      (%i5) diff (r.s, u);
                               dr           ds
      (%o5)                    -- . s + r . --
                               du           du

      (%i6) diff (r.s, t);
                            dr du           ds du
      (%o6)                 -- -- . s + r . -- --
                            du dt           du dt

      (%i7) remove (r, dependency);
      (%o7)                         done
      (%i8) diff (r.s, t);
                                      ds du
      (%o8)                       r . -- --
                                      du dt

Optionsvariable: derivabbrev

  Standardwert: `false`

  Hat `derivabbrev` den Wert `true`, werden symbolische Ableitungen mit einem tiefgestellten Index angezeigt. Ansonsten werden Ableitungen als `dy/dx` angezeigt.

  Beispiel:

      (%i1) derivabbrev:false$

      (%i2) 'diff(y,x);
                                     dy
      (%o2)                          --
                                     dx
      (%i3) derivabbrev:true$

      (%i4) 'diff(y,x);
      (%o4)                          y
                                      x

Funktion: derivdegree (expr, y, x)

  Gibt die höchste Ableitung des Arguments y in Bezug auf die Variable x zurück, die in dem Ausdruck expr enthalten ist.

  Beispiel:

      (%i1) 'diff (y, x, 2) + 'diff (y, z, 3) + 'diff (y, x) * x^2;
                               3     2
                              d y   d y    2 dy
      (%o1)                   --- + --- + x  --
                                3     2      dx
                              dz    dx
      (%i2) derivdegree (%, y, x);
      (%o2)                           2

Auswertungsschalter: derivlist (var_1, …, var_k)

  `derivlist` ist ein Auswertungsschalter für die Funktion `ev`. `ev` führt nur die Ableitungen in Bezug auf die angegebenen Variablen var_1, …, var_k aus. Siehe auch `ev`.

Optionsvariable: derivsubst

  Standardwert: `false`

  Hat `derivsubst` den Wert `true`, werden Substitutionen auch in Ausdrücke mit Ableitungen ausgeführt. Zum Beispiel hat dann `subst(x, 'diff(y, t), 'diff(y, t, 2))` das Ergebnis `'diff(x, t)`.

Funktion: diff (expr, x_1, n_1, …, x_m, n_m)
Funktion: diff (expr, x, n)
Funktion: diff (expr, x)
Funktion: diff (expr)
Auswertungsschalter: diff

  Gibt die Ableitungen oder Differentiale des Ausdrucks expr in Bezug auf alle oder einige der Variablen des Ausdrucks zurück.

  `diff(expr, x, n)` gibt die n-te Ableitung des Ausdrucks expr in Bezug auf die Variable x zurück.

  `diff(expr, x_1, n_1, ..., x_m, n_m)` gibt die partielle Ableitung des Ausdrucks expr in Bezug auf die Variablen x_1, ..., x_m zurück. Dies ist äquivalent zu `diff(... (diff(expr, x_m, n_m) ...), x_1, n_1)`.

  `diff(expr, x)` gibt die erste Ableitung des Ausdrucks expr in Bezug auf die Variable x zurück.

  `diff(expr)` gibt das totale Differential des Ausdrucks expr zurück. Siehe auch `del`.

  Wenn die Ableitungen nicht ausgeführt werden sollen, kann der `Quote-Operator` `'` verwendet werden, um eine Substantivform der Ableitung zu erhalten.

  Hat `derivabbrev` den Wert `true`, werden symbolische Ableitungen mit einem tiefgestelltem Index angezeigt. Ansonsten werden Ableitungen als `dy/dy` angezeigt.

  `diff` ist auch ein Auswertungsschalter für die Funktion `ev`. Das Kommando `ev(expr), diff` bewirkt, dass alle Ableitungen ausgeführt werden, die im Ausdruck expr enthalten sind. Siehe auch die Funktion `ev`.

  `derivative` ist ein Alias-Name der Funktion `diff`.

  Beispiele:

      (%i1) diff (exp (f(x)), x, 2);
                           2
                    f(x)  d               f(x)  d         2
      (%o1)       %e     (--- (f(x))) + %e     (-- (f(x)))
                            2                   dx
                          dx
      (%i2) derivabbrev: true$
      (%i3) 'integrate (f(x, y), y, g(x), h(x));
                               h(x)
                              /
                              [
      (%o3)                   I     f(x, y) dy
                              ]
                              /
                               g(x)
      (%i4) diff (%, x);
             h(x)
            /
            [
      (%o4) I     f(x, y)  dy + f(x, h(x)) h(x)  - f(x, g(x)) g(x)
            ]            x                     x                  x
            /
             g(x)

  For the tensor package, the following modifications have been incorporated:

  1. The derivatives of any indexed objects in expr will have the variables x_i appended as additional arguments. Then all the derivative indices will be sorted.
  2. The x_i may be integers from 1 up to the value of the variable `dimension` [default value: 4]. This will cause the differentiation to be carried out with respect to the x_i'th member of the list `coordinates` which should be set to a list of the names of the coordinates, e.g., `[x, y, z, t]`. If `coordinates` is bound to an atomic variable, then that variable subscripted by x_i will be used for the variable of differentiation. This permits an array of coordinate names or subscripted names like `X[1]`, `X[2]`, … to be used. If `coordinates` has not been assigned a value, then the variables will be treated as in (1) above.

Funktion: gradef (f(x_1, …, x_n), g_1, …, g_m)
Funktion: gradef (a, x, expr)

  Definiert eine partielle Ableitung der Funktion f oder Variablen a.

  Das Kommando `gradef(f(x_1, ..., x_n), g_1, ..., g_m)` definiert die partielle Ableitung `df/dx_i` als g_i. g_i ist ein Ausdruck. g_i kann ein Funktionsaufruf sein, aber nicht der Name einer Funktion. Die Anzahl der partiellen Ableitungen m kann kleiner als die Anzahl der Argumente n sein.

  `gradef(a, x, expr)` definiert die Ableitung der Variablen a in Bezug auf die Variable x als expr. Wie mit der Funktion `depends` wird a als abhängig von x deklariert. Die Abhängigkeit wird in die Liste `dependencies` eingetragen. Siehe auch `depends`.

  Bis auf das erste Argument werden die Argumente der Funktion `gradef` ausgewertet. `gradef` gibt die Funktion oder Variable zurück, für die eine partielle Ableitung definiert wurde.

  `gradef` kann die Ableitungen von vorhandenen Maxima-Funktionen neu definieren. Zum Beispiel definiert `gradef(sin(x), sqrt (1 - sin(x)^2))` eine neue Ableitung der Sinusfunktion.

  `gradef` kann keine partiellen Ableitungen für indizierte Funktionen definieren.

  `printprops([f_1, ..., f_n], gradef)` zeigt die mit `gradef` definierten partiellen Ableitungen der Funktionen f_1, …, f_n an und `printprops([a_n, ..., a_n], atomgrad)` zeigt die mit `gradef` definierten partiellen Ableitungen der Variablen a_n, …, a_n an. Siehe `printprops`.

  `gradefs` ist eine Informationsliste, die die Funktionen enthält, für die mit `gradef` eine Ableitung definierte wurde. Die Liste enthält keine Variablen, für die Ableitungen definiert wurden.

Systemvariable: gradefs

  Standardwert: `[]`

  `gradefs` ist eine Liste der Funktionen, für die eine Ableitung mit der Funktion `gradef` definiert wurde.

[ < ] | [ > ] |  | [ << ] | [ Up ] | [ >> ] |  |  |  |  | [Top] | [Contents] | [Index] | [ ? ]

## 16.3 Integration

[ < ] | [ > ] |  | [ << ] | [ Up ] | [ >> ] |  |  |  |  | [Top] | [Contents] | [Index] | [ ? ]

### 16.3.1 Einführung in die Integration

Maxima hat verschiedene Algorithmen, um Integrale zu behandeln. Die Funktion `integrate` nutzt diese. Maxima hat ein Paket `antid`, welches Integrale mit einer unbekannten Funktion, deren Ableitung bekannt ist, integrieren kann. Für die numerische Berechnung von Integralen hat Maxima das Paket `QUADPACK` mit Funktionen wie `quad_qag` oder `quad_qags`. Die Funktionen `laplace` und `specint` finden die Laplacetransformation. Wird das Paket `abs_integrate` geladen, kann Maxima weitere Integrale lösen. Dazu gehören insbesondere Integrale mit der Betragsfunktion `abs` und der Signum-Funktion `signum`. Siehe auch abs_integrate.

[ < ] | [ > ] |  | [ << ] | [ Up ] | [ >> ] |  |  |  |  | [Top] | [Contents] | [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`.

[ < ] | [ > ] |  | [ << ] | [ Up ] | [ >> ] |  |  |  |  | [Top] | [Contents] | [Index] | [ ? ]

### 16.3.3 Einführung in QUADPACK

QUADPACK ist eine Sammlung von Funktionen für die numerische Berechnung von eindimensionalen bestimmten Integralen. QUADPACK hat den Ursprung in einem Projekt von R. Piessens (1), E. de Doncker (2), C. Ueberhuber (3), und D. Kahaner (4).

Die QUADPACK-Bibliothek, die in Maxima enthalten ist, ist eine automatische Übersetzung des Fortran Quellcodes mit dem Programm `f2cl` wie er in der SLATEC Common Mathematical Library, Version 4.1 (5) vorliegt. Die SLATEC Bibliothek datiert auf Juli 1993. Die QUADPACK Funktionen wurden bereits einige Jahre früher programmiert. Es gibt eine weitere Version von QUADPACK bei Netlib (6). Es ist jedoch unklar worin sich diese von der SLATEC Version unterscheidet.

Alle QUADPACK-Funktionen versuchen automatisch, ein bestimmtes Integral numerisch innerhalb eine spezifizierten Genauigkeit zu berechnen. Die Übersetzung nach Lisp enthält einige weitere nicht-automatische Funktionen, die jedoch nicht als Maxima Funktionen zur Verfügung stehen.

Weitere Informationen über das QUADPACK-Paket sind in dem QUADPACK-Buch (7) enthalten.

#### Übersicht über die Integrationsroutinen

`quad_qag`

  Integration einer allgemeinen Funktion über ein endliches Intervall. `quad_qag` implementiert einen globalen adaptiven Integrator auf Grundlage der Strategie von Aind (Piessens, 1973). Es kann aus 6 verschiedenen Paaren von Gauß-Kronrad-Quadraturformeln ausgewählt werden. Die Formeln höheren Grades sind für stark oszillierende Integranden geeignet.

`quad_qags`

  Integration einer allgemeinen Funktion über ein endliches Intervall. Die Funktion `quad_qags` implementiert die Strategie einer globalen adaptiven Unterteilung des Integrationsintervalls mit Extrapolation (de Doncker, 1978). Zusätzlich wird versucht, die Konvergenz der Integralapproximation mit Hilfe des Epsilon-Algorithmus (Wynn, 1956) zu beschleunigen. Dies führt zum Beispiel bei Integranden mit Singularitäten, deren Lage und Typ unbekannt sind, zu einer Effizienzsteigerung.

`quad_qagi`

  Die Funktion `quad_qagi` führt die Integration einer allgemeinen Funktion über ein unendliches oder halb-unendliches Intervall aus. Das Intervall wird auf ein endliches Intervall transformiert. Das transformierte Integrationsproblem wird dann mit einer geringfügig modifizierten Algorithmus wie in `quad_qags` gelöst.

`quad_qawo`

  Berechnung von Integralen mit den trigonometrischen Gewichtsfunktionen cos(omega x) f(x) oder sin(omega x) f(x) über ein endliches Intervall, wobei omega eine Konstante ist. Der Algorithmus der Funktion `quad_qawo` zur basiert auf eine modifizierte Clenshaw-Curtis-Technik. `quad_qawo` wendet eine adaptive Unterteilung des Integrationsintervalls mit Extrapolation an, die vergleichbar mit dem Algorithmus von `quad_qags` ist. Zusätzlich wird versucht, die Konvergenz der Integralapproximation mit Hilfe des Epsilon-Algorithmus (Wynn, 1956) zu beschleunigen.

`quad_qawf`

  Die Funktion `quad_qawf` berechnet die Sinus- oder Kosinus-Fouriertransformation über ein halb-unendliches Intervall. Dabei wird die global adaptive Routine `quad_qawo` sukzessive auf endliche Teilintervalle angewendet. Zur Konvergenzbeschleunigung der resultierenden alternierenden Reihe wird der Epsilon-Algorithmus (Wynn, 1956) verwendet.

`quad_qaws`

  Integration von w(x) f(x) über ein endliches Intervall [a, b], wobei w eine Funktion der Form (x - a)^alpha (b - x)^beta v(x) ist und v(x) ist 1 oder log(x - a) oder log(b - x) oder log(x - a) log(b - x), und alpha > -1 und beta > -1. `quad_qaws` ist speziell für die effiziente Berechnung von Integralen über endliche Intervalle mit algebraischen oder algebraisch-logarithmischen Endpunktsingularitäten konzipiert. Eine globale adaptive Strategie mit Unterteilung des Integrationsintervalls wird angewendet. Auf Teilintervalle die keinen Endpunkt des Integrationsintervalls enthalten, kommt ein Gauß-Kronrod-Formelpaar und auf Randintervallen kommen modifizierte Clenshaw-Curtis-Formeln zur Anwendung.

`quad_qawc`

  Die Funktion `quad_qawc` berechnet den Cauchyschen Hauptwert von f(x)(x - c) über ein endliches Intervall (a, b) und dem Wert c. Es wird eine modifizierte Clenshaw-Curtis-Formel angewendet, wenn c im Teilbereich enthalten ist. Andernfalls wird eine globale adaptive Strategie mit einem Gauß-Kronrod-Formelpaar angewendet.

`quad_qagp`

  Basically the same as `quad_qags` but points of singularity or discontinuity of the integrand must be supplied. This makes it easier for the integrator to produce a good solution.

[ < ] | [ > ] |  | [ << ] | [ Up ] | [ >> ] |  |  |  |  | [Top] | [Contents] | [Index] | [ ? ]

### 16.3.4 Funktionen und Variablen für QUADPACK

Funktion: quad_qag (f(x), x, a, b, key, [epsrel, epsabs, limit])
Funktion: quad_qag (f, x, a, b, key, [epsrel, epsabs, limit])

  Die Funktion `quad_qag` berechnet das folgende Integral über ein endliches Intervall.

                 b
                /
                [
                I  f(x) dx
                ]
                /
                 a

  `quad_qag` implementiert einen globalen adaptiven Integrator auf Grundlage der Strategie von Aind (Piessens, 1973). Es kann aus 6 verschiedenen Paaren von Gauß-Kronrad-Quadraturformeln ausgewählt werden. Die Formeln höheren Grades sind für stark oszillierende Integranden geeignet.

  Die Funktion f(x) mit der abhängigen Variablen x wird im Integrationsintervall a und b integriert. key wählt den Grad der Gauß-Kronrod-Quadraturformel aus und kann Werte von 1 bis 6 annehmen. Ein größerer Grad ist geeignet für stark oszillierende Integranden.

  Der Integrand kann eine Maxima-Funktion, eine Lisp-Funktion, ein Operator, ein Maxima-Lambda-Ausdruck oder ein allgemeiner Maxima-Ausdruck sein.

  Die numerische Integration wird adaptiv ausgeführt. Der Integrationsbereich wird solange geteilt, bis die gewünschte Genauigkeit erreicht wird.

  Die Schlüsselwortargumente sind optional und können in beliebiger Reihenfolge angegeben werden. Sie haben die Form `key=val`. Die Schlüsselwortargumente sind:

  `epsrel`

    Gewünschter relativer Fehler der Approximation. Der Standardwert ist `1.0e-8`.

  `epsabs`

    Gewünschter absoluter Fehler der Approximation. Der Standardwert ist `0`.

  `limit`

    Die maximale Zahl an Teilintervallen des adaptiven Algorithmus. Der Standardwert ist `200`.

  `quad_qag` gibt eine Liste mit vier Elementen zurück:

  - eine numerische Näherung des Integrals,
  - geschätzer absoluter Fehler der Näherung,
  - Anzahl der Auswertungen des Integranden,
  - ein Fehlercode.

  Der Fehlercode kann die folgenden Werte annehmen:

  Beispiele:

      (%i1) quad_qag (x^(1/2)*log(1/x), x, 0, 1, 3, 'epsrel=5d-8);
      (%o1)    [.4444444444492108, 3.1700968502883E-9, 961, 0]
      (%i2) integrate (x^(1/2)*log(1/x), x, 0, 1);
                                      4
      (%o2)                           -
                                      9

Funktion: quad_qags (f(x), x, a, b, [epsrel, epsabs, limit])
Funktion: quad_qags (f, x, a, b, [epsrel, epsabs, limit])

  Die Funktion `quad_qags` berechnet das folgende Integral über ein endliches Intervall.

                 b
                /
                [
                I  f(x) dx
                ]
                /
                 a

  `quad_qags` implementiert die Strategie einer globalen adaptiven Unterteilung des Integrationsintervalls mit Extrapolation (de Doncker, 1978). Zusätzlich wird versucht, die Konvergenz der Integralapproximation mit Hilfe des Epsilon-Algorithmus (Wynn, 1956) zu beschleunigen. Dies führt zum Beispiel bei Integranden mit Singularitäten, deren Lage und Typ unbekannt sind, zu einer Effizienzsteigerung.

  Die Funktion f(x) mit der abhängigen Variablen x wird im Integrationsintervall a und b integriert.

  Der Integrand kann eine Maxima-Funktion, eine Lisp-Funktion, ein Operator, ein Maxima-Lambda-Ausdruck oder ein allgemeiner Maxima-Ausdruck sein.

  Die Schlüsselwortargumente sind optional und können in beliebiger Reihenfolge angegeben werden. Sie haben die Form `key=val`. Die Schlüsselwortargumente sind:

  `epsrel`

    Gewünschter relativer Fehler der Approximation. Der Standardwert ist `1.0e-8`.

  `epsabs`

    Gewünschter absoluter Fehler der Approximation. Der Standardwert ist `0`.

  `limit`

    Die maximale Zahl an Teilintervallen des adaptiven Algorithmus. Der Standardwert ist `200`.

  `quad_qag` gibt eine Liste mit vier Elementen zurück:

  - eine numerische Näherung des Integrals,
  - geschätzer absoluter Fehler der Näherung,
  - Anzahl der Auswertungen des Integranden,
  - ein Fehlercode.

  Der Fehlercode kann die folgenden Werte annehmen:

  Beispiele:

  `quad_qags` ist genauer und effizienter als `quad_qag` für das folgende Beispiel.

      (%i1) quad_qags (x^(1/2)*log(1/x), x, 0, 1, 'epsrel=1d-10);
      (%o1)   [.4444444444444448, 1.11022302462516E-15, 315, 0]

Funktion: quad_qagi (f(x), x, a, b, [epsrel, epsabs, limit])
Funktion: quad_qagi (f, x, a, b, [epsrel, epsabs, limit])

  Die Funktion `quad_qagi` berechnet die folgenden Integrale über ein unendliches oder halb-unendliches Intervall.

                 inf
                /
                [
                I    f(x) dx
                ]
                /
                 a

                 a
                /
                [
                I     f(x) dx
                ]
                /
                 minf

                 inf
                /
                [
                I     f(x) dx
                ]
                /
                 minf

  Das Intervall wird auf ein endliches Intervall transformiert. Das transformierte Integrationsproblem wird dann mit einem geringfügig modifizierten Algorithmus wie in `quad_qags` gelöst.

  Die Funktion f(x) mit der abhängigen Variablen x wird über einen unendlichen Bereich integriert.

  Der Integrand kann eine Maxima-Funktion, eine Lisp-Funktion, ein Operator, ein Maxima-Lambda-Ausdruck oder ein allgemeiner Maxima-Ausdruck sein.

  Eine der Grenzen des Integrationsbereiches kann unendlich sein. Ist dies nicht der Fall gibt `quad_qagi` eine Substantivform zurück.

  Die Schlüsselwortargumente sind optional und können in beliebiger Reihenfolge angegeben werden. Sie haben die Form `key=val`. Die Schlüsselwortargumente sind:

  `epsrel`

    Gewünschter relativer Fehler der Approximation. Der Standardwert ist `1.0e-8`.

  `epsabs`

    Gewünschter absoluter Fehler der Approximation. Der Standardwert ist `0`.

  `limit`

    Die maximale Zahl an Teilintervallen des adaptiven Algorithmus. Der Standardwert ist `200`.

  `quad_qag` gibt eine Liste mit vier Elementen zurück:

  - eine numerische Näherung des Integrals,
  - geschätzer absoluter Fehler der Näherung,
  - Anzahl der Auswertungen des Integranden,
  - ein Fehlercode.

  Der Fehlercode kann die folgenden Werte annehmen:

  Beispiele:

      (%i1) quad_qagi (x^2*exp(-4*x), x, 0, inf, 'epsrel=1d-8);
      (%o1)        [0.03125, 2.95916102995002E-11, 105, 0]
      (%i2) integrate (x^2*exp(-4*x), x, 0, inf);
                                     1
      (%o2)                          --
                                     32

Funktion: quad_qawc (f(x), x, c, a, b, [epsrel, epsabs, limit])
Funktion: quad_qawc (f, x, c, a, b, [epsrel, epsabs, limit])

  Die Funktion `quad_qawc` berechnet den Cauchyschen Hauptwert von f(x)(x - c) über ein endliches Intervall (a, b) und dem Wert c.

                 b
                /
                [  f(x)
                I  ----- dx
                ]  x - c
                /
                 a

  Es wird eine modifizierte Clenshaw-Curtis-Formel angewendet, wenn c im Teilbereich enthalten ist, andernfalls wird eine globale adaptive Strategie mit einem Gauß-Kronrod-Formelpaar angewendet.

  Die Funktion `f(x)/(x - c)`, die von der Variablen x abhängt, wird in den Grenzen a und b integriert.

  Der Integrand kann eine Maxima-Funktion, eine Lisp-Funktion, ein Operator, ein Maxima-Lambda-Ausdruck oder ein allgemeiner Maxima-Ausdruck sein.

  Die Schlüsselwortargumente sind optional und können in beliebiger Reihenfolge angegeben werden. Sie haben die Form `key=val`. Die Schlüsselwortargumente sind:

  `epsrel`

    Gewünschter relativer Fehler der Approximation. Der Standardwert ist `1.0e-8`.

  `epsabs`

    Gewünschter absoluter Fehler der Approximation. Der Standardwert ist `0`.

  `limit`

    Die maximale Zahl an Teilintervallen des adaptiven Algorithmus. Der Standardwert ist `200`.

  `quad_qag` gibt eine Liste mit vier Elementen zurück:

  - eine numerische Näherung des Integrals,
  - geschätzer absoluter Fehler der Näherung,
  - Anzahl der Auswertungen des Integranden,
  - ein Fehlercode.

  Der Fehlercode kann die folgenden Werte annehmen:

  Beispiele:

      (%i1) quad_qawc (2^(-5)*((x-1)^2+4^(-5))^(-1), x, 2, 0, 5,
                       'epsrel=1d-7);
      (%o1)    [- 3.130120337415925, 1.306830140249558E-8, 495, 0]
      (%i2) integrate (2^(-alpha)*(((x-1)^2 + 4^(-alpha))*(x-2))^(-1),
                       x, 0, 5);
      Principal Value
                             alpha
              alpha       9 4                 9
             4      log(------------- + -------------)
                            alpha           alpha
                        64 4      + 4   64 4      + 4
      (%o2) (-----------------------------------------
                              alpha
                           2 4      + 2

             3 alpha                       3 alpha
             -------                       -------
                2            alpha/2          2          alpha/2
          2 4        atan(4 4       )   2 4        atan(4       )   alpha
        - --------------------------- - -------------------------)/2
                    alpha                        alpha
                 2 4      + 2                 2 4      + 2
      (%i3) ev (%, alpha=5, numer);
      (%o3)                    - 3.130120337415917

Funktion: quad_qawf (f(x), x, a, omega, trig, [epsabs, limit, maxp1, limlst])
Funktion: quad_qawf (f, x, a, omega, trig, [epsabs, limit, maxp1, limlst])

  Die Funktion `quad_qawf` berechnet die Sinus- oder Kosinus-Fouriertransformation mit der Gewichtsfunktion w über ein halb-unendliches Intervall.

                 inf
                /
                [
                I    f(x) w(x) dx
                ]
                /
                 a

  Zur Berechnung des Integrals wird die global adaptive Routine `quad_qawo` sukzessive auf endliche Teilintervalle angewendet. Zur Konvergenzbeschleunigung der resultierenden alternierenden Reihe wird der Epsilon-Algorithmus (Wynn, 1956) verwendet.

  Die Gewichtsfunktion w wird mit dem Schlüsselwort trig ausgewählt:

  `cos`

    w(x) = cos (omega x)

  `sin`

    w(x) = sin (omega x)

  Der Integrand kann eine Maxima-Funktion, eine Lisp-Funktion, ein Operator, ein Maxima-Lambda-Ausdruck oder ein allgemeiner Maxima-Ausdruck sein.

  Die Schlüsselwortargumente sind optional und können in beliebiger Reihenfolge angegeben werden. Sie haben die Form `key=val`. Die Schlüsselwortargumente sind:

  `epsabs`

    Gewünschter absoluter Fehler der Näherung. Der Standardwert ist `1.0e-10`.

  `limit`

    `(limit - limlst)/2` ist die maximale Zahl an Teilintervallen des adaptiven Algorithmus. Der Standardwert ist `200`.

  `maxp1`

    Die maximale Anzahl an Chebyshev-Gewichten. Der Wert muss größer als 0 sein. Der Standardwert ist `100`.

  `limlst`

    Obere Grenze für die Anzahl an Zyklen. Der Wert muss größer oder gleich 3 sein. Der Standardwert ist 10.

  `quad_qawf` gibt eine Liste mit vier Elementen zurück:

  - eine numerische Näherung des Integrals,
  - geschätzer absoluter Fehler der Näherung,
  - Anzahl der Auswertungen des Integranden,
  - ein Fehlercode.

  Der Fehlercode kann die folgenden Werte annehmen:

  Beispiele:

      (%i1) quad_qawf (exp(-x^2), x, 0, 1, 'cos, 'epsabs=1d-9);
      (%o1)   [.6901942235215714, 2.84846300257552E-11, 215, 0]
      (%i2) integrate (exp(-x^2)*cos(x), x, 0, inf);
                                - 1/4
                              %e      sqrt(%pi)
      (%o2)                   -----------------
                                      2
      (%i3) ev (%, numer);
      (%o3)                   .6901942235215714

Funktion: quad_qawo (f(x), x, a, b, omega, trig, [epsrel, epsabs, limit, maxp1, limlst])
Funktion: quad_qawo (f, x, a, b, omega, trig, [epsrel, epsabs, limit, maxp1, limlst])

  Die Funktion `quad_qawo` berechnet das folgende Integral mit den trigonometrischen Gewichtsfunktionen cos(omega x) f(x) oder sin(omega x) f(x) über ein endliches Intervall, wobei omega eine Konstante ist.

                 b
                /
                [
                I  f(x) w(x) dx
                ]
                /
                 a

  Der Algorithmus basiert auf eine modifizierte Clenshaw-Curtis-Technik. `quad_qawo` wendet eine adaptive Unterteilung des Integrationsintervalls mit Extrapolation an, die vergleichbar mit dem Algorithmus von `quad_qags` ist. Zusätzlich wird versucht, die Konvergenz der Integralapproximation mit Hilfe des Epsilon-Algorithmus zu beschleunigen.

  Die Gewichtsfunktion w wird mit dem Schlüsselwort trig ausgewählt:

  `cos`

    w(x) = cos (omega x)

  `sin`

    w(x) = sin (omega x)

  Der Integrand kann eine Maxima-Funktion, eine Lisp-Funktion, ein Operator, ein Maxima-Lambda-Ausdruck oder ein allgemeiner Maxima-Ausdruck sein.

  Die Schlüsselwortargumente sind optional und können in beliebiger Reihenfolge angegeben werden. Sie haben die Form `key=val`. Die Schlüsselwortargumente sind:

  `epsrel`

    Gewünschter relativer Fehler der Näherung. Der Standardwert ist `1.0e-8`

  `epsabs`

    Gewünschter absoluter Fehler der Näherung. Der Standardwert ist `0`.

  `limit`

    `limit/2` ist die maximale Zahl an Teilintervallen des adaptiven Algorithmus. Der Standardwert ist `200`.

  `maxp1`

    Die maximale Anzahl an Chebyshev-Gewichten. Der Wert muss größer als 0 sein. Der Standardwert ist `100`.

  `limlst`

    Obere Grenze für die Anzahl an Zyklen. Der Wert muss größer oder gleich 3 sein. Der Standardwert ist 10.

  `quad_qawo` gibt eine Liste mit vier Elementen zurück:

  - eine numerische Näherung des Integrals,
  - geschätzer absoluter Fehler der Näherung,
  - Anzahl der Auswertungen des Integranden,
  - ein Fehlercode.

  Der Fehlercode kann die folgenden Werte annehmen:

  Beispiele:

      (%i1) quad_qawo (x^(-1/2)*exp(-2^(-2)*x), x, 1d-8, 20*2^2, 1, cos);
      (%o1)     [1.376043389877692, 4.72710759424899E-11, 765, 0]
      (%i2) rectform (integrate (x^(-1/2)*exp(-2^(-alpha)*x) * cos(x),
                      x, 0, inf));
                         alpha/2 - 1/2            2 alpha
              sqrt(%pi) 2              sqrt(sqrt(2        + 1) + 1)
      (%o2)   -----------------------------------------------------
                                     2 alpha
                               sqrt(2        + 1)
      (%i3) ev (%, alpha=2, numer);
      (%o3)                     1.376043390090716

Funktion: quad_qaws (f(x), x, a, b, alpha, beta, wfun, [epsrel, epsabs, limit])
Funktion: quad_qaws (f, x, a, b, alpha, beta, wfun, [epsrel, epsabs, limit])

  Die Funktion `quad_qaws` berechnet das Integral von w(x) f(x) über ein endliches Intervall [a, b], wobei w eine Funktion der Form (x - a)^alpha (b - x)^beta v(x) ist und v(x) ist 1 oder log(x - a) oder log(b - x) oder log(x - a) log(b - x), und alpha > -1 und beta > -1.

                 b
                /
                [
                I  f(x) w(x) dx
                ]
                /
                 a

  `quad_qaws` ist speziell für die effiziente Berechnung von Integralen über endliche Intervalle mit algebraischen oder algebraisch-logarithmischen Endpunktsingularität konzipiert. Eine globale adaptive Strategie mit Unterteilung des Integrationsintervalls wird angewendet. Auf Teilintervalle, die keinen Endpunkt des Integrationsintervalls enthalten, kommt ein Gauß-Kronrod-Formelpaar und auf Randintervallen kommen modifizierte Clenshaw-Curtis-Formeln zur Anwendung.

  Die Gewichtsfunktion wird mit dem Schlüsselwort wfun ausgewählt:

  `1`

    w(x) = (x - a)^alpha (b - x)^beta

  `2`

    w(x) = (x - a)^alpha (b - x)^beta log(x - a)

  `3`

    w(x) = (x - a)^alpha (b - x)^beta log(b - x)

  `4`

    w(x) = (x - a)^alpha (b - x)^beta log(x - a) log(b - x)

  Der Integrand kann eine Maxima-Funktion, eine Lisp-Funktion, ein Operator, ein Maxima-Lambda-Ausdruck oder ein allgemeiner Maxima-Ausdruck sein.

  Die Schlüsselwortargumente sind optional und können in beliebiger Reihenfolge angegeben werden. Sie haben die Form `key=val`. Die Schlüsselwortargumente sind:

  `epsrel`

    Gewünschter relativer Fehler der Näherung. Der Standardwert ist `1.0e-8`

  `epsabs`

    Gewünschter absoluter Fehler der Näherung. Der Standardwert ist `0`.

  `limit`

    Maximale Anzahl der Teilintervalle des adaptiven Algorithmus. Der Standardwert ist `200`.

  `quad_qaws` gibt eine Liste mit vier Elementen zurück:

  - eine numerische Näherung des Integrals,
  - geschätzer absoluter Fehler der Näherung,
  - Anzahl der Auswertungen des Integranden,
  - ein Fehlercode.

  Der Fehlercode kann die folgenden Werte annehmen:

  Beispiele:

      (%i1) quad_qaws (1/(x+1+2^(-4)), x, -1, 1, -0.5, -0.5, 1,
                       'epsabs=1d-9);
      (%o1)     [8.750097361672832, 1.24321522715422E-10, 170, 0]
      (%i2) integrate ((1-x*x)^(-1/2)/(x+1+2^(-alpha)), x, -1, 1);
             alpha
      Is  4 2      - 1  positive, negative, or zero?

      pos;
                                alpha         alpha
                         2 %pi 2      sqrt(2 2      + 1)
      (%o2)              -------------------------------
                                     alpha
                                  4 2      + 2
      (%i3) ev (%, alpha=4, numer);
      (%o3)                     8.750097361672829

Function: quad_qagp (f(x), x, a, b, points, [epsrel, epsabs, limit])
Function: quad_qagp (f, x, a, b, points, [epsrel, epsabs, limit])

  Integration of a general function over a finite interval. `quad_qagp` implements globally adaptive interval subdivision with extrapolation (de Doncker, 1978) by the Epsilon algorithm (Wynn, 1956).

  `quad_qagp` computes the integral

  integrate (f(x), x, a, b)

  The function to be integrated is f(x), with dependent variable x, and the function is to be integrated between the limits a and b.

  The integrand may be specified as the name of a Maxima or Lisp function or operator, a Maxima lambda expression, or a general Maxima expression.

  To help the integrator, the user must supply a list of points where the integrand is singular or discontinous.

  The keyword arguments are optional and may be specified in any order. They all take the form `key=val`. The keyword arguments are:

  `epsrel`

    Desired relative error of approximation. Default is 1d-8.

  `epsabs`

    Desired absolute error of approximation. Default is 0.

  `limit`

    Size of internal work array. limit is the maximum number of subintervals to use. Default is 200.

  `quad_qagp` returns a list of four elements:

  The error code (fourth element of the return value) can have the values:

  `0`

    no problems were encountered;

  `1`

    too many sub-intervals were done;

  `2`

    excessive roundoff error is detected;

  `3`

    extremely bad integrand behavior occurs;

  `4`

    failed to converge

  `5`

    integral is probably divergent or slowly convergent

  `6`

    if the input is invalid.

  Examples:

      (%i1) quad_qagp(x^3*log(abs((x^2-1)*(x^2-2))),x,0,3,[1,sqrt(2)]);
      (%o1)   [52.74074838347143, 2.6247632689546663e-7, 1029, 0]
      (%i2) quad_qags(x^3*log(abs((x^2-1)*(x^2-2))), x, 0, 3);
      (%o2)   [52.74074847951494, 4.088443219529836e-7, 1869, 0]

  The integrand has singularities at 1 and sqrt(2) so we supply these points to `quad_qagp`. We also note that `quad_qagp` is more accurate and more efficient that `quad_qags`.

Function: quad_control (parameter, [value])

  Control error handling for quadpack. The parameter should be one of the following symbols:

  `current_error`

    The current error number

  `control`

    Controls if messages are printed or not. If it is set to zero or less, messages are suppressed.

  `max_message`

    The maximum number of times any message is to be printed.

  If value is not given, then the current value of the parameter is returned. If value is given, the value of parameter is set to the given value.

[ < ] | [ > ] |  | [ << ] | [ Up ] | [ >> ] |  |  |  |  | [Top] | [Contents] | [Index] | [ ? ]

## 16.4 Differentialgleichungen

[ < ] | [ > ] |  | [ << ] | [ Up ] | [ >> ] |  |  |  |  | [Top] | [Contents] | [Index] | [ ? ]

### 16.4.1 Einführung in Differentialgleichungen

Dieses Kapitel beschreibt die Funktionen, die in Maxima verfügbar sind, um analytische Lösungen für verschiedene Typen von Differentialgleichungen der 1. und 2. Ordnung zu erhalten. Eine numerische Lösung kann mit den Funktionen in dynamics berechnet werden. Für die graphische Darstellung von Differentialgleichungen siehe das Paket in plotdf.

[ < ] | [ > ] |  | [ << ] | [ Up ] | [ >> ] |  |  |  |  | [Top] | [Contents] | [Index] | [ ? ]

### 16.4.2 Funktionen und Variablen für Differentialgleichungen

Funktion: bc2 (solution, xval1, yval1, xval2, yval2)

  Löst das Randwertproblem einer Differentialgleichung 2. Ordnung. Das Argument solution ist eine allgemeine Lösung, wie sie von der Funktion `ode2` zurückgegeben wird. xval1 gibt den Wert der unabhängigen Variablen im ersten Randpunkt an. Der Randwert wird als ein Ausdruck `x = x1` angegeben. Das Argument yval1 gibt den Wert der abhängigen Variablen in diesem Punkt an. Der Randwert wird als `y = y1` angegeben. Mit den Argumenten xval2 und yval2 werden die entsprechenden Werte an einem zweiten Randpunkt angegeben.

  Siehe die Funktion `ode2` für Beispiele.

Funktion: desolve (eqn, x)
Funktion: desolve ([eqn_1, …, eqn_n], [x_1, …, x_n])

  Die Funktion `desolve` löst lineare Systeme gewöhnlicher Differentialgleichungen mit Hilfe der Methode der Laplacetransformation. Die Argumente eqn_i sind die Differentialgleichungen mit den abhängigen Variablen x_1, …, x_n. Die funktionale Abhängigkeit der Variablen x_1, …, x_n zum Beispiel von einer Variablen x muss explizit für die Variablen und ihrer Ableitungen angegeben werden. Zum Beispiel ist sind die folgenden zwei Gleichungen keine korrekte Definition:

      eqn_1: 'diff(f,x,2) = sin(x) + 'diff(g,x);
      eqn_2: 'diff(f,x) + x^2 - f = 2*'diff(g,x,2);

  Eine korrekte Definition der zwei Gleichungen ist

      eqn_1: 'diff(f(x),x,2) = sin(x) + 'diff(g(x),x);
      eqn_2: 'diff(f(x),x) + x^2 - f(x) = 2*'diff(g(x),x,2);

  Die Funktion `desolve` wird dann folgendermaßen aufgerufen

      desolve([eqn_1, eqn_2], [f(x),g(x)]);

  Sind Anfangswerte für `x=0` bekannt, können diese mit der Funktion `atvalue` vor dem Aufruf der Funktion `desolve` angegeben werden.

      (%i1) 'diff(f(x),x)='diff(g(x),x)+sin(x);
                       d           d
      (%o1)            -- (f(x)) = -- (g(x)) + sin(x)
                       dx          dx
      (%i2) 'diff(g(x),x,2)='diff(f(x),x)-cos(x);
                        2
                       d            d
      (%o2)            --- (g(x)) = -- (f(x)) - cos(x)
                         2          dx
                       dx
      (%i3) atvalue('diff(g(x),x),x=0,a);
      (%o3)                           a
      (%i4) atvalue(f(x),x=0,1);
      (%o4)                           1
      (%i5) desolve([%o1,%o2],[f(x),g(x)]);
                        x
      (%o5) [f(x) = a %e  - a + 1, g(x) =
                                                      x
                                         cos(x) + a %e  - a + g(0) - 1]
      (%i6) [%o1,%o2],%o5,diff;
                   x       x      x                x
      (%o6)   [a %e  = a %e , a %e  - cos(x) = a %e  - cos(x)]

  Kann `desolve` keine Lösung finden, ist die Rückgabe `false`.

Funktion: ic1 (solution, xval, yval)

  Löst das Anfangswertproblem für eine Differentialgleichung 1. Ordnung. Das Argument solution ist eine allgemeine Lösung der Differentialgleichung, wie sie von der Funktion `ode2` zurückgegeben wird. Mit dem Argument xval wird der Anfangswert der unabhängigen Variablen in der Form `x = x0` angegeben. Mit dem Argument yval wird der Anfangswert der unabhängigen Variablen in der Form `y = y0` angegeben.

  Siehe die Funktion `ode2` für ein Beispiel.

Funktion: ic2 (solution, xval, yval, dval)

  Löst das Anfangswertproblem für eine Differentialgleichung 2. Ordnung. Das Argument solution ist eine allgemeine Lösung der Differentialgleichung, wie sie von der Funktion `ode2` zurückgegeben wird. Mit dem Argument xval wird der Anfangswert der unabhängigen Variablen in der Form `x = x0` angegeben. Mit dem Argument yval wird der Anfangswert der abhängigen Variablen in der Form `y = y0` angegeben. Mit dem Argument dval wird der Anfangswert der ersten Ableitung der abhängigen Variablen nach der unabhängigen Variablen in der Form `diff(y,x) = dy0` angegeben. Dem Symbol `diff` muss kein `Quote-Operator` `'` vorangestellt werden.

  Siehe auch `ode2` für ein Beispiel.

Funktion: ode2 (eqn, dvar, ivar)

  Die Funktion `ode2` löst eine gewöhnliche Differentialgleichung der ersten oder zweiten Ordnung. Die Funktion hat drei Argumente: die Differentialgleichung eqn, die abhängige Variable `dvar` und die unabhängige Variable `ivar`. Ist die Funktion `ode2` erfolgreich wird eine explizite oder implizite Lösung für die abhängige Variable zurückgegeben. Im Fall einer Differentialgleichung 1. Ordnung wird die Integrationskonstante mit `%c` bezeichnet. Für eine Differentialgleichung 2. Ordnung werden die Integrationskonstanten mit `%k1` und `%k2` bezeichnet. Die Abhängigkeit der abhängigen Variable von der unabhängigen Variablen muss nicht explizit, wie im Fall von `desolve` angegeben werden.

  Kann `ode2` keine Lösung finden, ist die Rückgabe `false`. Gegebenenfalls wird eine Fehlermeldung ausgegeben. Folgende Methoden werden für das Lösen einer Differentialgleichung 1. Ordnung nacheinander angewendet: linear, separierbar, exakt - wenn notwendig unter Zuhilfenahme eines Integrationsfaktors, homogen, bernoullische Differentialgleichung und eine Methode für verallgemeinerte homogene Gleichungen. Für eine Differentialgleichung 2. Ordnung kommen die folgenden Methoden zur Anwendung: konstante Koeffizienten, exakt, linear homogen mit nicht-konstanten Koeffizienten, die zu konstanten Koeffizienten transformiert werden können, eulersche Differentialgleichung, Variation der Parameter, Reduktion auf eine Differentialgleichung 1. Ordnung, wenn die Differentialgleichung entweder frei von der unabhängigen oder der abhängigen Variablen ist.

  Im Laufe des Lösungsverfahrens werden zur Information des Nutzers globale Variablen gesetzt: `method` bezeichnet die Methode, die von `ode2` zum Auffinden der Lösung verwendet wurde. `intfactor` bezeichnet einen verwendeten Integrationsfaktor. `odeindex` bezeichnet den Index der bernoullischen Gleichung oder der verallgemeinerte Methode für eine homogene Differentialgleichung. `yp` bezeichnet eine partikuläre Lösung, wenn die Variation der Parameter angewendet wird.

  Für das Lösen von Anfangswertproblemen einer Differentialgleichung 1. oder 2. Ordnung können die Funktionen `ic1` und `ic2` verwendet werden. Ein Randwertproblem für eine Differentialgleichung 2. Ordnung kann mit der Funktion `bc2` gelöst werden.

  Beispiele:

      (%i1) x^2*'diff(y,x) + 3*y*x = sin(x)/x;
                            2 dy           sin(x)
      (%o1)                x  -- + 3 x y = ------
                              dx             x
      (%i2) ode2(%,y,x);
                                   %c - cos(x)
      (%o2)                    y = -----------
                                        3
                                       x
      (%i3) ic1(%o2,x=%pi,y=0);
                                    cos(x) + 1
      (%o3)                   y = - ----------
                                         3
                                        x
      (%i4) 'diff(y,x,2) + y*'diff(y,x)^3 = 0;
                               2
                              d y      dy 3
      (%o4)                   --- + y (--)  = 0
                                2      dx
                              dx
      (%i5) ode2(%,y,x);
                            3
                           y  + 6 %k1 y
      (%o5)                ------------ = x + %k2
                                6
      (%i6) ratsimp(ic2(%o5,x=0,y=0,'diff(y,x)=2));
                                   3
                                2 y  - 3 y
      (%o6)                   - ---------- = x
                                    6
      (%i7) bc2(%o5,x=0,y=1,x=1,y=3);
                               3
                              y  - 10 y       3
      (%o7)                   --------- = x - -
                                  6           2

[ << ] | [ >> ] |  |  |  |  |  | [Top] | [Contents] | [Index] | [ ? ]

This document was generated by Viktor T. Toth on September, 27 2018 using texi2html 1.76.