Vorige: , Nach oben: abs_integrate   [Inhalt][Index]

31.2 Functions and Variables for abs_integrate

Option variable: extra_integration_methods

Default value: ['signum_int, 'abs_integrate_use_if]

The list extra_integration_methods is a list of functions for integration. When integrate is unable to find an antiderivative, Maxima uses the methods in extra_integration_methods to attempt to determine an antiderivative.

Each function f in extra_integration_methods should have the form f(integrand, variable). The function f may either return false to indicate failure, or it may return an expression involving an integration noun form. The integration methods are tried from the first to the last member of extra_integration_methods; when no method returns an expression that does not involve an integration noun form, the value of the integral is the last value that does not fail (or a pure noun form if all methods fail).

When the function abs_integrate_use_if is successful, it returns a conditional expression; for example

(%i1) load("abs_integrate")$
(%i2) integrate(1/(1 + abs(x+1) + abs(x-1)),x);
                           log(1 - 2 x)            2
(%o2) %if(- (x + 1) > 0, - ------------ + log(3) - -, 
                                2                  3
                                   x   log(3)   1  log(2 x + 1)
                %if(- (x - 1) > 0, - + ------ - -, ------------))
                                   3     2      3       2
(%i3) integrate(exp(-abs(x-1) - abs(x)),x);
                     2 x - 1
                   %e              - 1
(%o3) %if(- x > 0, --------- - 2 %e   , 
                       2
                                               - 1      1 - 2 x
                                   - 1     3 %e       %e
              %if(- (x - 1) > 0, %e    x - -------, - ---------))
                                              2           2

For definite integration, these conditional expressions can cause trouble:

(%i4) integrate(exp(-abs(x-1) - abs(x)),x, minf,inf);
                               - 1    2 x
                             %e    (%e    - 4)
(%o4) limit     %if(- x > 0, -----------------, 
      x -> inf-                      2
                     - 1                1 - 2 x
                   %e    (2 x - 3)    %e
%if(- (x - 1) > 0, ---------------, - ---------))
                          2               2
                             - 1    2 x
                           %e    (%e    - 4)
 - limit      %if(- x > 0, -----------------, 
   x -> minf+                      2
                     - 1                1 - 2 x
                   %e    (2 x - 3)    %e
%if(- (x - 1) > 0, ---------------, - ---------))
                          2               2

For such definite integrals, try disallowing the method abs_integrate_use_if:

(%i5) integrate(exp(-abs(x-1) - abs(x)),x, minf,inf),
          extra_integration_methods : ['signum_int];
                                 - 1
(%o5)                        2 %e

Related options extra_definite_integration_methods.

To use load("abs_integrate")

Option variable: extra_definite_integration_methods

Default value: ['abs_defint]

The list extra_definite_integration_methods is a list of extra functions for definite integration. When integrate is unable to find a definite integral, Maxima uses the methods in extra_definite_integration_methods to attempt to determine an antiderivative.

Each function f in extra_definite_integration_methods should have the form f(integrand, variable, lo, hi), where lo and hi are the lower and upper limits of integration, respectively. The function f may either return false to indicate failure, or it may return an expression involving an integration noun form. The integration methods are tried from the first to the last member of extra_definite_integration_methods; when no method returns an expression that does not involve an integration noun form, the value of the integral is the last value that does not fail (or a pure noun form if all methods fail).

Related options extra_integration_methods.

To use load("abs_integrate").

Function: intfudu (e, x)

This function uses the derivative divides rule for integrands of the form \(f(w(x)) * diff(w(x),x)\). When infudu is unable to find an antiderivative, it returns false.

(%i1) load("abs_integrate")$
(%i2) intfudu(cos(x^2) * x,x);
                                  2
                             sin(x )
(%o2)                        -------
                                2
(%i3) intfudu(x * sqrt(1+x^2),x);
                             2     3/2
                           (x  + 1)
(%o3)                      -----------
                                3
(%i4) intfudu(x * sqrt(1 + x^4),x);
(%o4)                         false

For the last example, the derivative divides rule fails, so intfudu returns false.

A hashed array intable contains the antiderivative data. To append a fact to the hash table, say \(integrate(f) = g\), do this:

(%i5) intable[f] : lambda([u],  [g(u),diff(u,%voi)]);
(%o5)          lambda([u], [g(u), diff(u, %voi)])
(%i6) intfudu(f(z),z);
(%o6)                         g(z)
(%i7) intfudu(f(w(x)) * diff(w(x),x),x);
(%o7)                        g(w(x))

An alternative to calling intfudu directly is to use the extra_integration_methods mechanism; an example:

(%i1) load("abs_integrate")$
(%i2) load("basic")$
(%i3) load("partition.mac")$

(%i4) integrate(bessel_j(1,x^2) * x,x);
                                       2
                          bessel_j(0, x )
(%o4)                   - ---------------
                                 2
(%i5) push('intfudu, extra_integration_methods)$

(%i6) integrate(bessel_j(1,x^2) * x,x);
                                       2
                          bessel_j(0, x )
(%o6)                   - ---------------
                                 2

To use load("partition").

Additional documentation
http://www.cs.berkeley.edu/~fateman/papers/partition.pdf.

Related functions intfugudu.

Function: intfugudu (e, x)

This function uses the derivative divides rule for integrands of the form \(f(w(x)) * g(w(x)) * diff(w(x),x)\). When infugudu is unable to find an antiderivative, it returns false.

(%i1) load("abs_integrate")$
(%i2) diff(jacobi_sn(x,2/3),x);
                              2               2
(%o2)            jacobi_cn(x, -) jacobi_dn(x, -)
                              3               3
(%i3) intfugudu(%,x);
                                      2
(%o3)                    jacobi_sn(x, -)
                                      3
(%i4) diff(jacobi_dn(x^2,a),x);
                               2                2
(%o4)       - 2 a x jacobi_cn(x , a) jacobi_sn(x , a)
(%i5) intfugudu(%,x);
                                   2
(%o5)                   jacobi_dn(x , a)

For a method for automatically calling infugudu from integrate, see the documentation for intfudu.

To use load("partition").

Additional documentation
http://www.cs.berkeley.edu/~fateman/papers/partition.pdf

Related functions intfudu.

Function: signum_to_abs (e)

This function replaces subexpressions of the form \(q signum(q)\) by \(abs(q)\). Before it does these substitutions, it replaces subexpressions of the form \(signum(p) * signum(q)\) by \(signum(p * q)\); examples:

(%i1) load("abs_integrate")$
(%i2) map('signum_to_abs, [x * signum(x), 
                           x * y * signum(x)* signum(y)/2]);
                              abs(x) abs(y)
(%o2)                [abs(x), -------------]
                                    2

To use load("abs_integrate").

Macro: simp_assuming (e, f_1, f_2, …, f_n)

Appended the facts \(f_1, f_2, …, f_n\) to the current context and simplify \(e\). The facts are removed before returning the simplified expression \(e\).

(%i1) load("abs_integrate")$
(%i2) simp_assuming(x + abs(x), x < 0);
(%o2)                           0

The facts in the current context aren’t ignored:

(%i3) assume(x > 0)$
(%i4) simp_assuming(x + abs(x),x < 0);
(%o4)                          2 x

Since simp_assuming is a macro, effectively simp_assuming quotes is arguments; this allows

(%i5) simp_assuming(asksign(p), p < 0);
(%o5)                          neg

To use load("abs_integrate").

Function: conditional_integrate (e, x)

For an integrand with one or more parameters, this function tries to determine an antiderivative that is valid for all parameter values. When successful, this function returns a conditional expression for the antiderivative.

(%i1) load("abs_integrate")$
(%i2) conditional_integrate(cos(m*x),x);
                                sin(m x)
(%o2)                %if(m # 0, --------, x)
                                   m
(%i3) conditional_integrate(cos(m*x)*cos(x),x);

(%o3) %if((m - 1 # 0) %and (m + 1 # 0), 
(m - 1) sin((m + 1) x) + (- m - 1) sin((1 - m) x)
-------------------------------------------------, 
                       2
                    2 m  - 2
sin(2 x) + 2 x
--------------)
      4
(%i4) sublis([m=6],%);
                     5 sin(7 x) + 7 sin(5 x)
(%o4)                -----------------------
                               70
(%i5) conditional_integrate(exp(a*x^2+b*x),x);
                                  2
                                 b
                               - ---
                                 4 a      2 a x + b
                   sqrt(%pi) %e      erf(-----------)
                                         2 sqrt(- a)
(%o5) %if(a # 0, - ----------------------------------, 
                              2 sqrt(- a)
                                                         b x
                                                       %e
                                            %if(b # 0, -----, x))
                                                         b
Function: convert_to_signum (e)

This function replaces subexpressions of the form abs(q), unit_step(q), min(q1, q2, ..., qn) and max(q1, q2, ..., qn) by equivalent \(signum\) terms.

(%i1) load("abs_integrate")$
(%i2) map('convert_to_signum, [abs(x), unit_step(x), 
                               max(a,2), min(a,2)]);

                    signum(x) (signum(x) + 1)
(%o2) [x signum(x), -------------------------, 
                                2
  (a - 2) signum(a - 2) + a + 2  - (a - 2) signum(a - 2) + a + 2
  -----------------------------, -------------------------------]
                2                               2

To convert unit_step to signum form, the function convert_to_signum uses \(unit_step(x) = (1 + signum(x))/2\).

To use load("abs_integrate").

Related functions signum_to_abs.


Vorige: , Nach oben: abs_integrate   [Inhalt][Index]

JavaScript license information