Next: , Previous: , Up: Integration   [Contents][Index]

19.2 Functions and Variables for Integration

Function: changevar (expr, f(x,y), y, x)

Makes the change of variable given by f(x,y) = 0 in all integrals occurring in expr with integration with respect to x. The new variable is y.

The change of variable can also be written f(x) = g(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

An expression containing a noun form, such as the instances of 'integrate above, may be evaluated by ev with the nouns flag. For example, the expression returned by changevar above may be evaluated by ev (%o3, nouns).

changevar may also be used to make changes in the indices of a sum or product. However, it must be realized that when a change is made in a sum or product, this change must be a shift, i.e., i = j+ ..., not a higher degree function. E.g.,

(%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
Categories: Integral calculus ·
Function: dblint (f, r, s, a, b)

A double-integral routine which was written in top-level Maxima and then translated and compiled to machine code. Use load ("dblint") to access this package. It uses the Simpson’s rule method in both the x and y directions to calculate

/b /s(x)
|  |
|  |    f(x,y) dy dx
|  |
/a /r(x)

The function f must be a translated or compiled function of two variables, and r and s must each be a translated or compiled function of one variable, while a and b must be floating point numbers. The routine has two global variables which determine the number of divisions of the x and y intervals: dblint_x and dblint_y, both of which are initially 10, and can be changed independently to other integer values (there are 2*dblint_x+1 points computed in the x direction, and 2*dblint_y+1 in the y direction). The routine subdivides the X axis and then for each value of X it first computes r(x) and s(x); then the Y axis between r(x) and s(x) is subdivided and the integral along the Y axis is performed using Simpson’s rule; then the integral along the X axis is done using Simpson’s rule with the function values being the Y-integrals. This procedure may be numerically unstable for a great variety of reasons, but is reasonably fast: avoid using it on highly oscillatory functions and functions with singularities (poles or branch points in the region). The Y integrals depend on how far apart r(x) and s(x) are, so if the distance s(x) - r(x) varies rapidly with X, there may be substantial errors arising from truncation with different step-sizes in the various Y integrals. One can increase dblint_x and dblint_y in an effort to improve the coverage of the region, at the expense of computation time. The function values are not saved, so if the function is very time-consuming, you will have to wait for re-computation if you change anything (sorry). It is required that the functions f, r, and s be either translated or compiled prior to calling dblint. This will result in orders of magnitude speed improvement over interpreted code in many cases!

demo ("dblint") executes a demonstration of dblint applied to an example problem.

Categories: Integral calculus ·
Function: defint (expr, x, a, b)

Attempts to compute a definite integral. defint is called by integrate when limits of integration are specified, i.e., when integrate is called as integrate (expr, x, a, b). Thus from the user’s point of view, it is sufficient to call integrate.

defint returns a symbolic expression, either the computed integral or the noun form of the integral. See quad_qag and related functions for numerical approximation of definite integrals.

Categories: Integral calculus ·
Option variable: erfflag

Default value: true

When erfflag is false, prevents risch from introducing the erf function in the answer if there were none in the integrand to begin with.

Categories: Integral calculus ·
Function: ilt (expr, s, t)

Computes the inverse Laplace transform of expr with respect to s and parameter t. expr must be a ratio of polynomials whose denominator has only linear and quadratic factors; there is an extension of ilt, called pwilt (Piece-Wise Inverse Laplace Transform) that handles several other cases where ilt fails.

By using the functions laplace and ilt together with the solve or linsolve functions the user can solve a single differential or convolution integral equation or a set of them.

(%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
Categories: Laplace transform ·
Option variable: intanalysis

Default value: true

When true, definite integration tries to find poles in the integrand in the interval of integration. If there are, then the integral is evaluated appropriately as a principal value integral. If intanalysis is false, this check is not performed and integration is done assuming there are no poles.

See also ldefint.

Examples:

Maxima can solve the following integrals, when intanalysis is set to false:

(%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
Categories: Integral calculus ·
Function: integrate
    integrate (expr, x)
    integrate (expr, x, a, b)

Attempts to symbolically compute the integral of expr with respect to x. integrate (expr, x) is an indefinite integral, while integrate (expr, x, a, b) is a definite integral, with limits of integration a and b. The limits should not contain x, although integrate does not enforce this restriction. a need not be less than b. If b is equal to a, integrate returns zero.

See quad_qag and related functions for numerical approximation of definite integrals. See residue for computation of residues (complex integration). See antid for an alternative means of computing indefinite integrals.

The integral (an expression free of integrate) is returned if integrate succeeds. Otherwise the return value is the noun form of the integral (the quoted operator 'integrate) or an expression containing one or more noun forms. The noun form of integrate is displayed with an integral sign.

In some circumstances it is useful to construct a noun form by hand, by quoting integrate with a single quote, e.g., 'integrate (expr, x). For example, the integral may depend on some parameters which are not yet computed. The noun may be applied to its arguments by ev (i, nouns) where i is the noun form of interest.

integrate handles definite integrals separately from indefinite, and employs a range of heuristics to handle each case. Special cases of definite integrals include limits of integration equal to zero or infinity (inf or minf), trigonometric functions with limits of integration equal to zero and %pi or 2 %pi, rational functions, integrals related to the definitions of the beta and psi functions, and some logarithmic and trigonometric integrals. Processing rational functions may include computation of residues. If an applicable special case is not found, an attempt will be made to compute the indefinite integral and evaluate it at the limits of integration. This may include taking a limit as a limit of integration goes to infinity or negative infinity; see also ldefint.

Special cases of indefinite integrals include trigonometric functions, exponential and logarithmic functions, and rational functions. integrate may also make use of a short table of elementary integrals.

integrate may carry out a change of variable if the integrand has the form f(g(x)) * diff(g(x), x). integrate attempts to find a subexpression g(x) such that the derivative of g(x) divides the integrand. This search may make use of derivatives defined by the gradef function. See also changevar and antid.

If none of the preceding heuristics find the indefinite integral, the Risch algorithm is executed. The flag risch may be set as an evflag, in a call to ev or on the command line, e.g., ev (integrate (expr, x), risch) or integrate (expr, x), risch. If risch is present, integrate calls the risch function without attempting heuristics first. See also risch.

integrate works only with functional relations represented explicitly with the f(x) notation. integrate does not respect implicit dependencies established by the depends function.

integrate may need to know some property of a parameter in the integrand. integrate will first consult the assume database, and, if the variable of interest is not there, integrate will ask the user. Depending on the question, suitable responses are yes; or no;, or pos;, zero;, or neg;.

integrate is not, by default, declared to be linear. See declare and linear.

integrate attempts integration by parts only in a few special cases.

Examples:

  • Elementary indefinite and definite integrals.
    (%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
    
  • Use of assume and interactive query.
    (%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
    
  • Change of variable. There are two changes of variable in this example: one using a derivative established by gradef, and one using the derivation diff(r(x)) of an unspecified function 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)))
    
  • Return value contains the 'integrate noun form. In this example, Maxima can extract one factor of the denominator of a rational function, but cannot factor the remainder or otherwise find its integral. grind shows the noun form 'integrate in the result. See also integrate_use_rootsof for more on integrals of rational functions.
    (%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$
    
  • Defining a function in terms of an integral. The body of a function is not evaluated when the function is defined. Thus the body of f_1 in this example contains the noun form of integrate. The quote-quote operator '' causes the integral to be evaluated, and the result becomes the body of f_2.
    (%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
    
Categories: Integral calculus ·
System variable: integration_constant

Default value: %c

When a constant of integration is introduced by indefinite integration of an equation, the name of the constant is constructed by concatenating integration_constant and integration_constant_counter.

integration_constant may be assigned any symbol.

Examples:

(%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
Categories: Integral calculus ·
System variable: integration_constant_counter

Default value: 0

When a constant of integration is introduced by indefinite integration of an equation, the name of the constant is constructed by concatenating integration_constant and integration_constant_counter.

integration_constant_counter is incremented before constructing the next integration constant.

Examples:

(%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
Categories: Integral calculus ·
Option variable: integrate_use_rootsof

Default value: false

When integrate_use_rootsof is true and the denominator of a rational function cannot be factored, integrate returns the integral in a form which is a sum over the roots (not yet known) of the denominator.

For example, with integrate_use_rootsof set to false, integrate returns an unsolved integral of a rational function in noun form:

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

Now we set the flag to be true and the unsolved part of the integral will be expressed as a summation over the roots of the denominator of the rational function:

(%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(%r4  - %r4  + 1, %r4)
(%o4) ----------------------------------------------------------
               7

                                                      2 x + 1
                                  2            5 atan(-------)
                             log(x  + x + 1)          sqrt(3)
                           - --------------- + ---------------
                                   14             7 sqrt(3)

Alternatively the user may compute the roots of the denominator separately, and then express the integrand in terms of these roots, e.g., 1/((x - a)*(x - b)*(x - c)) or 1/((x^2 - (a+b)*x + a*b)*(x - c)) if the denominator is a cubic polynomial. Sometimes this will help Maxima obtain a more useful result.

Categories: Integral calculus ·
Function: ldefint (expr, x, a, b)

Attempts to compute the definite integral of expr by using limit to evaluate the indefinite integral of expr with respect to x at the upper limit b and at the lower limit a. If it fails to compute the definite integral, ldefint returns an expression containing limits as noun forms.

ldefint is not called from integrate, so executing ldefint (expr, x, a, b) may yield a different result than integrate (expr, x, a, b). ldefint always uses the same method to evaluate the definite integral, while integrate may employ various heuristics and may recognize some special cases.

Categories: Integral calculus ·
Function: pwilt (expr, s, t)

Computes the inverse Laplace transform of expr with respect to s and parameter t. Unlike ilt, pwilt is able to return piece-wise and periodic functions and can also handle some cases with polynomials of degree greater than 3 in the denominator.

Two examples where ilt fails:

(%i1) pwilt (exp(-s)*s/(s^3-2*s-s+2), s, t);
                                       t - 1       - 2 (t - 1)
                             (t - 1) %e        2 %e
(%o1)         hstep(t - 1) (--------------- - ---------------)
                                    3                 9
                                    
(%i2) pwilt ((s^2+2)/(s^2-1), s, t);
                                         t       - t
                                     3 %e    3 %e
(%o2)                    delta(t) + ----- - -------
                                       2        2
Categories: Laplace transform ·
Function: potential (givengradient)

The calculation makes use of the global variable potentialzeroloc[0] which must be nonlist or of the form

[indeterminatej=expressionj, indeterminatek=expressionk, ...]

the former being equivalent to the nonlist expression for all right-hand sides in the latter. The indicated right-hand sides are used as the lower limit of integration. The success of the integrations may depend upon their values and order. potentialzeroloc is initially set to 0.

Function: residue (expr, z, z_0)

Computes the residue in the complex plane of the expression expr when the variable z assumes the value z_0. The residue is the coefficient of (z - z_0)^(-1) in the Laurent series for expr.

(%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
Function: risch (expr, x)

Integrates expr with respect to x using the transcendental case of the Risch algorithm. (The algebraic case of the Risch algorithm has not been implemented.) This currently handles the cases of nested exponentials and logarithms which the main part of integrate can’t do. integrate will automatically apply risch if given these cases.

erfflag, if false, prevents risch from introducing the erf function in the answer if there were none in the integrand to begin with.

(%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)
Categories: Integral calculus ·
Function: tldefint (expr, x, a, b)

Equivalent to ldefint with tlimswitch set to true.

Categories: Integral calculus ·

Next: , Previous: , Up: Integration   [Contents][Index]