(maxima.info)Functions and Variables for Integration
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 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
-- 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.
-- 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.
-- 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.
-- 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. 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
-- 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
-- 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
-- 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
-- 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
-- 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.
-- 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.
-- 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)
-- Function: tldefint (<expr>, <x>, <a>, <b>)
Equivalent to 'ldefint' with 'tlimswitch' set to 'true'.
automatically generated by info2www version 1.2.2.9