[ < ] [ > ] [ << ] [ Up ] [ >> ] [Top] [Contents] [Index] [ ? ]

# 31. abs_integrate

 [ < ] [ > ] [ << ] [ Up ] [ >> ] [Top] [Contents] [Index] [ ? ]

## 31.1 Introduction to abs_integrate

The package `abs_integrate` extends Maxima's integration code to some integrands that involve the absolute value, max, min, signum, or unit step functions. For integrands of the form p(x) |q(x)|, where p is a polynomial and q is a polynomial that `factor` is able to factor into a product of linear or constant terms, the `abs_integrate` package determines an antiderivative that is continuous on the entire real line. Additionally, for an integrand that involves one or more parameters, the function `conditional_integrate` tries to determine an antiderivative that is valid for all parameter values.

Examples:

To use the `abs_integrate` package, you'll first need to load it:

```(%i1) load("abs_integrate.mac")\$
(%i2) integrate(abs(x),x);
x abs(x)
(%o2)                       --------
2
```

To convert (%o2) into an expression involving the absolute value function, apply `signum_to_abs` ; thus

```(%i3) signum_to_abs(%);
x abs(x)
(%o3)                       --------
2
```

When the integrand has the form p(x) |x - c1| |x - c2| ... |x - cn|, where p(x) is a polynomial and c1, c2, ..., cn are constants, the `abs_integrate` package returns an antiderivative that is valid on the entire real line; thus without making assumptions on a and b; for example

```(%i4) factor(convert_to_signum(integrate(abs((x-a)*(x-b)),x,a,b)));
3       2
(b - a)  signum (b - a)
(%o4)                -----------------------
6
```

Additionally, `abs_integrate` is able to find antiderivatives of some integrands involving `max`, `min`, `signum`, and `unit_step`, examples:

```(%i5) integrate(max(x,x^2),x);
3      2                                        3    2
2 x  - 3 x    1                   1               x    x
(%o5) ((----------- + --) signum(x - 1) + --) signum(x) + -- + --
12        12                  12              6    4
(%i6) integrate(signum(x) - signum(1-x),x);
(%o6)                  abs(x) + abs(x - 1)
```

A plot indicates that indeed (%o5) and (%o6) are continuous at zero and at one.

For definite integrals with numerical integration limits (including both minus and plus infinity), the `abs_integrate` package converts the integrand to signum form and then it tries to subdivide the integration region so that the integrand simplifies to a non-signum expression on each subinterval; for example

```(%i1) load(abs_integrate)\$
(%i2) integrate(1 / (1 + abs(x-5)),x,-5,6);
(%o2)                   log(11) + log(2)
```

Finally, `abs_integrate` is able to determine antiderivatives of some functions of the form F(x, |x - a|); examples

```(%i3) integrate(1/(1 + abs(x)),x);
signum(x) (log(x + 1) + log(1 - x))
(%o3) -----------------------------------
2
log(x + 1) - log(1 - x)
+ -----------------------
2
(%i4) integrate(cos(x + abs(x)),x);
(signum(x) + 1) sin(2 x) - 2 x signum(x) + 2 x
(%o4)    ----------------------------------------------
4
```

Barton Willis (Professor of Mathematics, University of Nebraska at Kearney) wrote the `abs_integrate` package and its English language user documentation. This documentation also describes the `partition` package for integration. Richard Fateman wrote `partition`. Additional documentation for `partition` is located at
http://www.cs.berkeley.edu/~fateman/papers/partition.pdf

 [ < ] [ > ] [ << ] [ Up ] [ >> ] [Top] [Contents] [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)\$

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

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

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

 [ << ] [ >> ] [Top] [Contents] [Index] [ ? ]

This document was generated by Crategus on Dezember, 12 2012 using texi2html 1.76.