[ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
16.1 Funktionen und Variablen für Grenzwerte | ||
16.2 Funktionen und Variablen der Differentiation | ||
16.3 Integration | ||
16.4 Differentialgleichungen |
[ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
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.
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
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)
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.
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] | [ ? ] |
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
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 /
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
.
Wird für ein Symbol eine Ableitung mit der Funktion gradef
definiert,
dann erhält das Symbol die Eigenschaft atomgrad
.
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
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.
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)
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
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
.
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
Standardwert: false
Hat derivabbrev
den Wert true
, werden symbolische Ableitungen
mit einem tiefgestelltem Index angezeigt. Ansonsten werden Ableitungen als
dy/dy
angezeigt.
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
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.
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)
.
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:
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.
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
.
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.
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.
Standardwert: []
gradefs
ist eine Liste der Funktionen, für die eine Ableitung definiert
wurde.
[ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
16.3.1 Einführung in die Integration | ||
16.3.2 Funktionen und Variablen der Integration | ||
16.3.3 Einführung in QUADPACK | ||
16.3.4 Funktionen und Variablen für QUADPACK |
[ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
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] | [ ? ] |
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
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.
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.
Standardwert: true
Hat erfflag
den Wert false
, werden von der Funktion risch
keine Fehlerfunktion erf
in die Lösung eingeführt.
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
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
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:
(%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
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
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)))
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 (%i3) grind (%); log(x-4)/73-('integrate((x^2+4*x+18)/(x^3+2*x+1),x))/73$
''
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
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
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
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.
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)
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.
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
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)
Entspricht der Funktion ldefint
mit dem Wert true
für die
Optionsvariable tlimswitch
.
[ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
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.
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] | [ ? ] |
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:
Gewünschter relativer Fehler der Approximation. Der Standardwert ist
1.0e-8
.
Gewünschter absoluter Fehler der Approximation. Der Standardwert ist
0
.
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
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:
Gewünschter relativer Fehler der Approximation. Der Standardwert ist
1.0e-8
.
Gewünschter absoluter Fehler der Approximation. Der Standardwert ist
0
.
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.
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:
Gewünschter relativer Fehler der Approximation. Der Standardwert ist
1.0e-8
.
Gewünschter absoluter Fehler der Approximation. Der Standardwert ist
0
.
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
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:
Gewünschter relativer Fehler der Approximation. Der Standardwert ist
1.0e-8
.
Gewünschter absoluter Fehler der Approximation. Der Standardwert ist
0
.
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
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:
Gewünschter absoluter Fehler der Näherung. Der Standardwert ist
1.0e-10
.
(limit - limlst)/2
ist die maxima Zahl an Teilintervallen
des adaptiven Algorithmus. Der Standardwert ist 200
.
Die maximale Anzahl an Chebyshev-Gewichten. Der Wert muss größer als 0
sein. Der Standardwert ist 100
.
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
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:
Gewünschter relativer Fehler der Näherung. Der Standardwert is
1.0e-8
Gewünschter absoluter Fehler der Näherung. Der Standardwert ist 0
.
limit/2
ist die maxima Zahl an Teilintervallen des adaptiven
Algorithmus. Der Standardwert ist 200
.
Die maximale Anzahl an Chebyshev-Gewichten. Der Wert muss größer als 0
sein. Der Standardwert ist 100
.
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
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:
Gewünschter relativer Fehler der Näherung. Der Standardwert is
1.0e-8
Gewünschter absoluter Fehler der Näherung. Der Standardwert ist 0
.
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.1 Einführung in Differentialgleichungen | ||
16.4.2 Funktionen und Variablen für Differentialgleichungen |
[ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
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] | [ ? ] |
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.
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
.
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.
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.
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.