Previous: Einführung in QUADPACK, Up: Integration [Contents][Index]

#### 16.3.4 Funktionen und Variablen für QUADPACK

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

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

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

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

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

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

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

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

  `epsrel`

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

  `epsabs`

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

  `limit`

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

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

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

  Der Fehlercode kann die folgenden Werte annehmen:

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

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

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

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

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

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

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

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

  `epsrel`

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

  `epsabs`

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

  `limit`

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

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

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

  Der Fehlercode kann die folgenden Werte annehmen:

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

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

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

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

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

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

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

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

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

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

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

  `epsrel`

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

  `epsabs`

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

  `limit`

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

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

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

  Der Fehlercode kann die folgenden Werte annehmen:

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

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

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

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

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

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

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

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

  `epsrel`

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

  `epsabs`

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

  `limit`

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

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

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

  Der Fehlercode kann die folgenden Werte annehmen:

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

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

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

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

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

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

  `cos`

    w(x) = cos (omega x)

  `sin`

    w(x) = sin (omega x)

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

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

  `epsabs`

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

  `limit`

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

  `maxp1`

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

  `limlst`

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

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

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

  Der Fehlercode kann die folgenden Werte annehmen:

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

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

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

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

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

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

  `cos`

    w(x) = cos (omega x)

  `sin`

    w(x) = sin (omega x)

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

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

  `epsrel`

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

  `epsabs`

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

  `limit`

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

  `maxp1`

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

  `limlst`

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

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

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

  Der Fehlercode kann die folgenden Werte annehmen:

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

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

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

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

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

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

  `1`

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

  `2`

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

  `3`

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

  `4`

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

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

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

  `epsrel`

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

  `epsabs`

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

  `limit`

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

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

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

  Der Fehlercode kann die folgenden Werte annehmen:

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

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

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

  `quad_qagp` computes the integral

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

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

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

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

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

  `epsrel`

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

  `epsabs`

    Desired absolute error of approximation. Default is 0.

  `limit`

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

  `quad_qagp` returns a list of four elements:

  - an approximation to the integral,
  - the estimated absolute error of the approximation,
  - the number integrand evaluations,
  - an error code.

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

  `0`

    no problems were encountered;

  `1`

    too many sub-intervals were done;

  `2`

    excessive roundoff error is detected;

  `3`

    extremely bad integrand behavior occurs;

  `4`

    failed to converge

  `5`

    integral is probably divergent or slowly convergent

  `6`

    if the input is invalid.

  Examples:

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

      (%i2) quad_qags(x^3*log(abs((x^2-1)*(x^2-2))), x, 0, 3);
      (%o2)   [52.74074847951494, 4.088443219529836e-7, 1869, 0]

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

Function: quad_control (parameter, [value])

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

  `current_error`

    The current error number

  `control`

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

  `max_message`

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

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

Previous: Einführung in QUADPACK, Up: Integration [Contents][Index]