Previous: Einführung in QUADPACK, Nach oben: Integration [Inhalt][Index]
Die Funktion quad_qag berechnet das folgende Integral über ein
endliches Intervall.
           b
          /
          [
          I  f(x) dx
          ]
          /
           a
quad_qag implementiert einen globalen adaptiven Integrator auf
Grundlage der Strategie von Aind (Piessens, 1973).  Es kann aus 6 verschiedenen 
Paaren von Gauß-Kronrad-Quadraturformeln ausgewählt werden.  Die Formeln 
höheren Grades sind für stark oszillierende Integranden geeignet.
Die Funktion f(x) mit der abhängigen Variablen x wird im Integrationsintervall a und b integriert. key wählt den Grad der Gauß-Kronrod-Quadraturformel aus und kann Werte von 1 bis 6 annehmen. Ein größerer Grad ist geeignet für stark oszillierende Integranden.
Der Integrand kann eine Maxima-Funktion, eine Lisp-Funktion, ein Operator, ein Maxima-Lambda-Ausdruck oder ein allgemeiner Maxima-Ausdruck sein.
Die numerische Integration wird adaptiv ausgeführt. Der Integrationsbereich wird solange geteilt, bis die gewünschte Genauigkeit erreicht wird.
Die Schlüsselwortargumente sind optional und können in beliebiger
Reihenfolge angegeben werden.  Sie haben die Form key=val.  Die
Schlüsselwortargumente sind:
epsrelGewünschter relativer Fehler der Approximation.  Der Standardwert ist 
1.0e-8.
epsabsGewünschter absoluter Fehler der Approximation.  Der Standardwert ist 
0.
limitDie maximale Zahl an Teilintervallen 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 zu viele Teilintervalle notwendig wurden,
2,
wenn übemäßiger Rundungsfehler 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
Die Funktion quad_qags berechnet das folgende Integral über ein
endliches Intervall.
           b
          /
          [
          I  f(x) dx
          ]
          /
           a
quad_qags implementiert die Strategie einer globalen adaptiven 
Unterteilung des Integrationsintervalls mit Extrapolation (de Doncker, 1978).
Zusätzlich wird versucht, die Konvergenz der Integralapproximation mit Hilfe
des Epsilon-Algorithmus (Wynn, 1956) zu beschleunigen.  Dies führt zum 
Beispiel bei Integranden mit Singularitäten, deren Lage und Typ unbekannt 
sind, zu einer Effizienzsteigerung.
Die Funktion f(x) mit der abhängigen Variablen x wird im Integrationsintervall a und b integriert.
Der Integrand kann eine Maxima-Funktion, eine Lisp-Funktion, ein Operator, ein Maxima-Lambda-Ausdruck oder ein allgemeiner Maxima-Ausdruck sein.
Die Schlüsselwortargumente sind optional und können in beliebiger
Reihenfolge angegeben werden.  Sie haben die Form key=val.  Die
Schlüsselwortargumente sind:
epsrelGewünschter relativer Fehler der Approximation.  Der Standardwert ist 
1.0e-8.
epsabsGewünschter absoluter Fehler der Approximation.  Der Standardwert ist 
0.
limitDie maximale Zahl an Teilintervallen 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 zu viele Teilintervalle notwendig wurden,
2,
wenn übemäßiger Rundungsfehler aufgetreten sind,
3,
wenn ein extrem schlechtes Verhalten des Integranden vorliegt,
6,
wenn die Eingabe ungültig ist.
Beispiele:
quad_qags ist genauer und effizienter als quad_qag für das
folgende Beispiel.
(%i1) quad_qags (x^(1/2)*log(1/x), x, 0, 1, 'epsrel=1d-10); (%o1) [.4444444444444448, 1.11022302462516E-15, 315, 0]
Die Funktion quad_qagi berechnet die folgenden Integrale über ein
unendliches oder halb-unendliches Intervall.
           inf
          /
          [
          I    f(x) dx
          ]
          /
           a
           a
          /
          [
          I     f(x) dx
          ]
          /
           minf
           inf
          /
          [
          I     f(x) dx
          ]
          /
           minf
Das Intervall wird auf ein endliches Intervall transformiert.  Das
transformierte Integrationsproblem wird dann mit einem geringfügig
modifizierten Algorithmus wie in quad_qags gelöst.
Die Funktion f(x) mit der abhängigen Variablen x wird über einen unendlichen Bereich integriert.
Der Integrand kann eine Maxima-Funktion, eine Lisp-Funktion, ein Operator, ein Maxima-Lambda-Ausdruck oder ein allgemeiner Maxima-Ausdruck sein.
Eine der Grenzen des Integrationsbereiches kann unendlich sein.  Ist dies nicht
der Fall gibt quad_qagi eine Substantivform zurück.
Die Schlüsselwortargumente sind optional und können in beliebiger
Reihenfolge angegeben werden.  Sie haben die Form key=val.  Die
Schlüsselwortargumente sind:
epsrelGewünschter relativer Fehler der Approximation.  Der Standardwert ist 
1.0e-8.
epsabsGewünschter absoluter Fehler der Approximation.  Der Standardwert ist 
0.
limitDie maximale Zahl an Teilintervallen 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 zu viele Teilintervalle notwendig wurden,
2,
wenn übemäßiger Rundungsfehler 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
Die Funktion quad_qawc berechnet den Cauchyschen Hauptwert von
f(x)(x - c) über ein endliches Intervall (a, b) und dem Wert
c.
           b
          /
          [  f(x)
          I  ----- dx
          ]  x - c
          /
           a
Es wird eine modifizierte Clenshaw-Curtis-Formel angewendet, wenn c im Teilbereich enthalten ist, andernfalls wird eine globale adaptive Strategie mit einem Gauß-Kronrod-Formelpaar angewendet.
Die Funktion f(x)/(x - c), die von der Variablen
x abhängt, wird in den Grenzen a und b integriert.
Der Integrand kann eine Maxima-Funktion, eine Lisp-Funktion, ein Operator, ein Maxima-Lambda-Ausdruck oder ein allgemeiner Maxima-Ausdruck sein.
Die Schlüsselwortargumente sind optional und können in beliebiger
Reihenfolge angegeben werden.  Sie haben die Form key=val.  Die
Schlüsselwortargumente sind:
epsrelGewünschter relativer Fehler der Approximation.  Der Standardwert ist 
1.0e-8.
epsabsGewünschter absoluter Fehler der Approximation.  Der Standardwert ist 
0.
limitDie maximale Zahl an Teilintervallen 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 zu viele Teilintervalle notwendig wurden,
2,
wenn übemäßiger Rundungsfehler 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
Die Funktion quad_qawf berechnet die Sinus- oder
Kosinus-Fouriertransformation mit der Gewichtsfunktion w über ein
halb-unendliches Intervall.
           inf
          /
          [
          I    f(x) w(x) dx
          ]
          /
           a
Zur Berechnung des Integrals wird die global adaptive Routine
quad_qawo sukzessive auf endliche Teilintervalle angewendet.  Zur
Konvergenzbeschleunigung der resultierenden alternierenden Reihe wird
der Epsilon-Algorithmus (Wynn, 1956) verwendet.
Die Gewichtsfunktion w wird mit dem Schlüsselwort trig ausgewählt:
cosw(x) = cos (omega x)
sinw(x) = sin (omega x)
Der Integrand kann eine Maxima-Funktion, eine Lisp-Funktion, ein Operator, ein Maxima-Lambda-Ausdruck oder ein allgemeiner Maxima-Ausdruck sein.
Die Schlüsselwortargumente sind optional und können in beliebiger
Reihenfolge angegeben werden.  Sie haben die Form key=val.
Die Schlüsselwortargumente sind:
epsabsGewünschter absoluter Fehler der Näherung.  Der Standardwert ist 
1.0e-10.
limit(limit - limlst)/2 ist die maximale Zahl an Teilintervallen
des adaptiven Algorithmus.  Der Standardwert ist 200.
maxp1Die maximale Anzahl an Chebyshev-Gewichten.  Der Wert muss größer als 0 
sein.  Der Standardwert ist 100.
limlstObere 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 zu viele Teilintervalle notwendig wurden,
2,
wenn übemäßiger Rundungsfehler 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
Die Funktion quad_qawo berechnet das folgende Integral mit den
trigonometrischen Gewichtsfunktionen cos(omega x) f(x) oder
sin(omega x) f(x) über ein endliches Intervall, wobei omega
eine Konstante ist.
           b
          /
          [
          I  f(x) w(x) dx
          ]
          /
           a
Der Algorithmus basiert auf eine modifizierte Clenshaw-Curtis-Technik.
quad_qawo wendet eine adaptive Unterteilung des Integrationsintervalls
mit Extrapolation an, die vergleichbar mit dem Algorithmus von
quad_qags ist.  Zusätzlich wird versucht, die Konvergenz der
Integralapproximation mit Hilfe des Epsilon-Algorithmus zu beschleunigen.
Die Gewichtsfunktion w wird mit dem Schlüsselwort trig ausgewählt:
cosw(x) = cos (omega x)
sinw(x) = sin (omega x)
Der Integrand kann eine Maxima-Funktion, eine Lisp-Funktion, ein Operator, ein Maxima-Lambda-Ausdruck oder ein allgemeiner Maxima-Ausdruck sein.
Die Schlüsselwortargumente sind optional und können in beliebiger
Reihenfolge angegeben werden.  Sie haben die Form key=val.
Die Schlüsselwortargumente sind:
epsrelGewünschter relativer Fehler der Näherung.  Der Standardwert ist
1.0e-8
epsabsGewünschter absoluter Fehler der Näherung.  Der Standardwert ist 0.
limitlimit/2 ist die maximale Zahl an Teilintervallen des adaptiven 
Algorithmus.  Der Standardwert ist 200.
maxp1Die maximale Anzahl an Chebyshev-Gewichten.  Der Wert muss größer als 0 
sein.  Der Standardwert ist 100.
limlstObere 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 zu viele Teilintervalle notwendig wurden,
2,
wenn übemäßiger Rundungsfehler 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
Die Funktion quad_qaws berechnet das Integral von w(x) f(x) über
ein endliches Intervall [a, b], wobei w eine Funktion der Form
(x - a)^alpha (b - x)^beta v(x) ist und v(x) ist 1 oder
log(x - a) oder log(b - x) oder log(x - a) log(b - x), und
alpha > -1 und beta > -1.
           b
          /
          [
          I  f(x) w(x) dx
          ]
          /
           a
quad_qaws ist speziell für die effiziente Berechnung von Integralen
über endliche Intervalle mit algebraischen oder algebraisch-logarithmischen
Endpunktsingularität konzipiert.  Eine globale adaptive Strategie mit 
Unterteilung des Integrationsintervalls wird angewendet.  Auf Teilintervalle,
die keinen Endpunkt des Integrationsintervalls enthalten, kommt ein 
Gauß-Kronrod-Formelpaar und auf Randintervallen kommen modifizierte
Clenshaw-Curtis-Formeln zur Anwendung.
Die Gewichtsfunktion wird mit dem Schlüsselwort wfun ausgewählt:
1w(x) = (x - a)^alpha (b - x)^beta
2w(x) = (x - a)^alpha (b - x)^beta log(x - a)
3w(x) = (x - a)^alpha (b - x)^beta log(b - x)
4w(x) = (x - a)^alpha (b - x)^beta log(x - a) log(b - x)
Der Integrand kann eine Maxima-Funktion, eine Lisp-Funktion, ein Operator, ein Maxima-Lambda-Ausdruck oder ein allgemeiner Maxima-Ausdruck sein.
Die Schlüsselwortargumente sind optional und können in beliebiger
Reihenfolge angegeben werden.  Sie haben die Form key=val.
Die Schlüsselwortargumente sind:
epsrelGewünschter relativer Fehler der Näherung.  Der Standardwert ist
1.0e-8
epsabsGewünschter absoluter Fehler der Näherung.  Der Standardwert ist 0.
limitMaximale 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 zu viele Teilintervalle notwendig wurden,
2,
wenn übemäßiger Rundungsfehler 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
Integration of a general function over a finite interval.
quad_qagp implements globally adaptive interval subdivision with
extrapolation (de Doncker, 1978) by the Epsilon algorithm (Wynn, 1956).
quad_qagp computes the integral
integrate (f(x), x, a, b)
The function to be integrated is f(x), with dependent variable x, and the function is to be integrated between the limits a and b.
The integrand may be specified as the name of a Maxima or Lisp function or operator, a Maxima lambda expression, or a general Maxima expression.
To help the integrator, the user must supply a list of points where the integrand is singular or discontinous.
The keyword arguments are optional and may be specified in any order.
They all take the form key=val.  The keyword arguments are:
epsrelDesired relative error of approximation. Default is 1d-8.
epsabsDesired absolute error of approximation. Default is 0.
limitSize of internal work array. limit is the maximum number of subintervals to use. Default is 200.
quad_qagp returns a list of four elements:
The error code (fourth element of the return value) can have the values:
0no problems were encountered;
1too many sub-intervals were done;
2excessive roundoff error is detected;
3extremely bad integrand behavior occurs;
4failed to converge
5integral is probably divergent or slowly convergent
6if the input is invalid.
Examples:
(%i1) quad_qagp(x^3*log(abs((x^2-1)*(x^2-2))),x,0,3,[1,sqrt(2)]); (%o1) [52.74074838347143, 2.6247632689546663e-7, 1029, 0]
(%i2) quad_qags(x^3*log(abs((x^2-1)*(x^2-2))), x, 0, 3); (%o2) [52.74074847951494, 4.088443219529836e-7, 1869, 0]
The integrand has singularities at 1 and sqrt(2) so we supply these
points to quad_qagp.  We also note that quad_qagp is
more accurate and more efficient that quad_qags.
Control error handling for quadpack. The parameter should be one of the following symbols:
current_errorThe current error number
controlControls if messages are printed or not. If it is set to zero or less, messages are suppressed.
max_messageThe maximum number of times any message is to be printed.
If value is not given, then the current value of the parameter is returned. If value is given, the value of parameter is set to the given value.
Previous: Einführung in QUADPACK, Nach oben: Integration [Inhalt][Index]