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

16. Analysis


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

16.1 Funktionen und Variablen für Grenzwerte

Optionsvariable: lhospitallim

Standardwert: 4

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 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, wie sie als Ergebnis eines Grenzwertes oder als Wert für die Bestimmung eines Grenzwertes auftreten:

inf

positiv unendlich

minf

negativ unendlich

infinity

komplex unendlich

zeroa

postiv unendlich klein

zerob

negativ unendlich klein

und

nicht definiert

ind

unbestimmt

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 tiefgestelltem Index angezeigt. Ansonsten werden Ableitungen als dy/dy angezeigt.

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.

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)

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.

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.

Auswertungsschalter: diff

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

Funktion: dscalar (f)

Wendet den d'Alembert-Operator auf eine skalare Funktion f an. Der d'Alembert-Operator ist die Verallgemeinerung des Gradienten auf den vierdimensionalen Minkowski-Raum.

Das Kommando load(ctensor) lädt die Funktion.

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 sein als die Anzahl der Argumente n.

gradef(a, x, expr) definierte 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.

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 definiert wurde.


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

16.3 Integration


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

16.3.1 Einführung in die Integration

Maxima hat verschiedene Routinen 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.


[ < ] [ > ]   [ << ] [ 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)
|  |
|  |    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.

Option variable: erfflag

Standardwert: true

Hat erfflag den Wert false, werden von der Funktion risch keine Fehlerfunktion erf 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 die 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 für die Integrationsvariable x. integrate(expr, x ist das unbestimmte Integral. integrate (expr, x, a, b) sucht die Lösung des bestimmten Integrals in den Integrationsgrenzen a und b. Die Integrationsgrenzen sollten 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 Integrale siehe die Funktion quad_gag und verwandte Funktionen. Residuen eines Integranden können mit der Funktion residue berechnet werden. Einen alternativen Algorithmus für das Berechnen von Integralen mit einer unbekannten Funktion bietet die Funktion antid.

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 Parametern im Integranden muss explizit zum Beispiel mit f(x) angegeben werden. integrate beachtet keine Abhängigkeit der mit den Funktion depends definiert werden.

Benötigt integrate Informationen zu einem Parameter, die nicht aus Maximas Datenbank 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 versucht integrate eine partielle Integration anzuwenden.

Beispiele:

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_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_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) integrate (x^2 = 1, x);
                           3
                          x
(%o3)                     -- = x + %c3
                          3
(%i4) reset (integration_constant_counter);
(%o4)            [integration_constant_counter]
(%i5) integrate (x^2 = 1, x);
                           3
                          x
(%o5)                     -- = 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)) 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 Funktion 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. ldefinit 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.

(%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.

(%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 in Maxima enthaltenen QUADPACK-Funktionen versuchen automatisch ein bestimmtes Integral numerisch innerhalb eine spezifierten 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 QUADPACK können in dem QUADPACK-Buch (7) nachgelesen werden.

Übersicht

quad_qag

Integration einer allgemeinen Funktion über ein endliches Intervall. quad_qag implementiert eine 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

Integration einer allgemeinen Funktion über ein unendliches oder halb-unendliches Intervall. 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 zur Integration 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

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 dann 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ä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 zur Anwendung. Auf Randintervallen kommen modifizierte Clenshaw-Curtis-Formeln zur Anwendung.

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.


[ < ] [ > ]   [ << ] [ 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])

Integration einer allgemeinen Funktion über ein endliches Intervall. quad_qag implementiert eine 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_qag berechnet das Integral

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

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-Quadratorformel 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 belieger 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 Teilinterallen des adaptiven Algorithmus. Der Standardwert ist 200.

quad_qag gibt eine Liste mit vier Elementen zurück:

Der Fehlercode kann die folgenden Werte annehmen:

0

wenn kein Fehler aufgetreten ist,

1

wenn zuviele Teilintervalle notwendig wurden,

2

wenn übemäßiger Rundungfehle aufgetreten sind,

3

wenn ein extrem schlechtes Verhalten des Integranden vorliegt,

6

wenn die Eingabe ungültig ist.

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])

Integration einer allgemeinen Funktion über ein endliches Intervall. 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_qags berechnet das Integral

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

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 belieger 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 Teilinterallen des adaptiven Algorithmus. Der Standardwert ist 200.

quad_qag gibt eine Liste mit vier Elementen zurück:

Der Fehlercode kann die folgenden Werte annehmen:

0

wenn kein Fehler aufgetreten ist,

1

wenn zuviele Teilintervalle notwendig wurden,

2

wenn übemäßiger Rundungfehle aufgetreten sind,

3

wenn ein extrem schlechtes Verhalten des Integranden vorliegt,

6

wenn die Eingabe ungültig ist.

Beispiele:

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

quad_qags ist genauer und effiziener als quad_qag für den obigen Integranden.

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

Integration einer allgemeinen Funktion über ein unendliches oder halb-unendliches Intervall. 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_qagi evaluates one of the following integrals

quad_qagi berechnet die folgenden Integrale

integrate (f(x), x, a, inf)

integrate (f(x), x, minf, a)

integrate (f(x), x, minf, inf)

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 belieger 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 Teilinterallen des adaptiven Algorithmus. Der Standardwert ist 200.

quad_qag gibt eine Liste mit vier Elementen zurück:

Der Fehlercode kann die folgenden Werte annehmen:

0

wenn kein Fehler aufgetreten ist,

1

wenn zuviele Teilintervalle notwendig wurden,

2

wenn übemäßiger Rundungfehle aufgetreten sind,

3

wenn ein extrem schlechtes Verhalten des Integranden vorliegt,

6

wenn die Eingabe ungültig ist.

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])

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_qawc berechnet den Cauchyschen Hauptwert von

integrate (f(x)/(x - c), x, a, b)

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 belieger 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 Teilinterallen des adaptiven Algorithmus. Der Standardwert ist 200.

quad_qag gibt eine Liste mit vier Elementen zurück:

Der Fehlercode kann die folgenden Werte annehmen:

0

wenn kein Fehler aufgetreten ist,

1

wenn zuviele Teilintervalle notwendig wurden,

2

wenn übemäßiger Rundungfehle aufgetreten sind,

3

wenn ein extrem schlechtes Verhalten des Integranden vorliegt,

6

wenn die Eingabe ungültig ist.

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])

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 dann der Epsilon-Algorithmus (Wynn, 1956) verwendet.

quad_qawf berechnet das Integral

integrate (f(x)*w(x), x, a, inf)

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 belieger 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 maxima 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:

Der Fehlercode kann die folgenden Werte annehmen:

0

wenn kein Fehler aufgetreten ist,

1

wenn zuviele Teilintervalle notwendig wurden,

2

wenn übemäßiger Rundungfehle aufgetreten sind,

3

wenn ein extrem schlechtes Verhalten des Integranden vorliegt,

6

wenn die Eingabe ungültig ist.

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])

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 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.

quad_qawo berechnet das Integral

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

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 belieger Reihenfolge angegeben werden. Sie haben die Form key=val. Die Schlüsselwortargumente sind:

epsrel

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

epsabs

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

limit

limit/2 ist die maxima 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:

Der Fehlercode kann die folgenden Werte annehmen:

0

wenn kein Fehler aufgetreten ist,

1

wenn zuviele Teilintervalle notwendig wurden,

2

wenn übemäßiger Rundungfehle aufgetreten sind,

3

wenn ein extrem schlechtes Verhalten des Integranden vorliegt,

6

wenn die Eingabe ungültig ist.

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])

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ä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 zur Anwendung. Auf Randintervallen kommen modifizierte Clenshaw-Curtis-Formeln zur Anwendung.

quad_qaws berechnet das Integral

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

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 belieger Reihenfolge angegeben werden. Sie haben die Form key=val. Die Schlüsselwortargumente sind:

epsrel

Gewünschter relativer Fehler der Näherung. Der Standardwert is 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:

Der Fehlercode kann die folgenden Werte annehmen:

0

wenn kein Fehler aufgetreten ist,

1

wenn zuviele Teilintervalle notwendig wurden,

2

wenn übemäßiger Rundungfehle aufgetreten sind,

3

wenn ein extrem schlechtes Verhalten des Integranden vorliegt,

6

wenn die Eingabe ungültig ist.

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

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

16.4 Differentialgleichungen


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

16.4.1 Einführung in Differentialgleichungen

This section describes the functions available in Maxima to obtain analytic solutions for some specific types of first and second-order equations. To obtain a numerical solution for a system of differential equations, see the additional package dynamics. For graphical representations in phase space, see the additional package plotdf.


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

16.4.2 Funktionen und Variablen für Differentialgleichungen

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

Solves a boundary value problem for a second order differential equation. Here: solution is a general solution to the equation, as found by ode2; xval1 specifies the value of the independent variable in a first point, in the form x = x1, and yval1 gives the value of the dependent variable in that point, in the form y = y1. The expressions xval2 and yval2 give the values for these variables at a second point, using the same form.

See ode2 for an example of its usage.

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

The function desolve solves systems of linear ordinary differential equations using Laplace transform. Here the eqn's are differential equations in the dependent variables x_1, …, x_n. The functional dependence of x_1, …, x_n on an independent variable, for instance x, must be explicitly indicated in the variables and its derivatives. For example, this would not be the correct way to define two equations:

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

The correct way would be:

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);

The call to the function desolve would then be

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

If initial conditions at x=0 are known, they can be supplied before calling desolve by using atvalue.

(%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)]

If desolve cannot obtain a solution, it returns false.

Funktion: ic1 (solution, xval, yval)

Solves initial value problems for first order differential equations. Here solution is a general solution to the equation, as found by ode2, xval gives an initial value for the independent variable in the form x = x0, and yval gives the initial value for the dependent variable in the form y = y0.

See ode2 for an example of its usage.

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

Solves initial value problems for second-order differential equations. Here solution is a general solution to the equation, as found by ode2, xval gives the initial value for the independent variable in the form x = x0, yval gives the initial value of the dependent variable in the form y = y0, and dval gives the initial value for the first derivative of the dependent variable with respect to independent variable, in the form diff(y,x) = dy0 (diff does not have to be quoted).

See ode2 for an example of its usage.

Funktion: ode2 (eqn, dvar, ivar)

The function ode2 solves an ordinary differential equation (ODE) of first or second order. It takes three arguments: an ODE given by eqn, the dependent variable dvar, and the independent variable ivar. When successful, it returns either an explicit or implicit solution for the dependent variable. %c is used to represent the integration constant in the case of first-order equations, and %k1 and %k2 the constants for second-order equations. The dependence of the dependent variable on the independent variable does not have to be written explicitly, as in the case of desolve, but the independent variable must always be given as the third argument.

If ode2 cannot obtain a solution for whatever reason, it returns false, after perhaps printing out an error message. The methods implemented for first order equations in the order in which they are tested are: linear, separable, exact - perhaps requiring an integrating factor, homogeneous, Bernoulli's equation, and a generalized homogeneous method. The types of second-order equations which can be solved are: constant coefficients, exact, linear homogeneous with non-constant coefficients which can be transformed to constant coefficients, the Euler or equi-dimensional equation, equations solvable by the method of variation of parameters, and equations which are free of either the independent or of the dependent variable so that they can be reduced to two first order linear equations to be solved sequentially.

In the course of solving ODE's, several variables are set purely for informational purposes: method denotes the method of solution used (e.g., linear), intfactor denotes any integrating factor used, odeindex denotes the index for Bernoulli's method or for the generalized homogeneous method, and yp denotes the particular solution for the variation of parameters technique.

In order to solve initial value problems (IVP) functions ic1 and ic2 are available for first and second order equations, and to solve second-order boundary value problems (BVP) the function bc2 can be used.

Example:

(%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 Robert Dodier on April, 4 2011 using texi2html 1.76.