Go to the first, previous, next, last section, table of contents.
hypgeo
is a package for handling Laplace transforms of special functions.
hyp
is a package for handling generalized Hypergeometric functions.
specint
attempts to compute the definite integral
(over the range from zero to infinity) of an expression containing special functions.
When the integrand contains a factor exp (-s t)
,
the result is a Laplace transform.
The syntax is as follows:
specint (exp (-s*t) * expr, t);
where t is the variable of integration and expr is an expression containing special functions.
If specint
cannot compute the integral, the return value may
contain various Lisp symbols, including
other-defint-to-follow-negtest
,
other-lt-exponential-to-follow
,
product-of-y-with-nofract-indices
, etc.; this is a bug.
Special function notation follows:
bessel_j (index, expr) Bessel function, 1st kind bessel_y (index, expr) Bessel function, 2nd kind bessel_i (index, expr) Modified Bessel function, 1st kind bessel_k (index, expr) Modified Bessel function, 2nd kind %he[n] (z) Hermite polynomial (Nota bene:he
, noth
. See A&S 22.5.18) %p[u,v] (z) Legendre function %q[u,v] (z) Legendre function, 2nd kind hstruve[n] (z) Struve H function lstruve[n] (z) Struve L function %f[p,q] ([], [], expr) Generalized Hypergeometric function gamma() Gamma function gammagreek(a,z) Incomplete gamma function gammaincomplete(a,z) Tail of incomplete gamma function slommel %m[u,k] (z) Whittaker function, 1st kind %w[u,k] (z) Whittaker function, 2nd kind erfc (z) Complement of the erf function ei (z) Exponential integral (?) kelliptic (z) Complete elliptic integral of the first kind (K) %d [n] (z) Parabolic cylinder function
demo ("hypgeo")
displays several examples of Laplace transforms computed by specint
.
This is a work in progress. Some of the function names may change.
airy (x)
is returned.
Otherwise, an unevaluated expression airy (x)
is returned.
The Airy equation diff (y(x), x, 2) - x y(x) = 0
has two linearly independent
solutions, named ai
and bi
. This equation is very popular
as an approximation to more complicated problems in many mathematical
physics settings.
load ("airy")
loads the functions ai
, bi
, dai
, and dbi
.
The airy
package contains routines to compute
ai
and bi
and their derivatives dai
and dbi
. The result is
a floating point number if the argument is a number, and an
unevaluated expression otherwise.
An error occurs if the argument is large
enough to cause an overflow in the exponentials, or a loss of
accuracy in sin
or cos
. This makes the range of validity
about -2800 to 10^38 for ai
and dai
, and -2800 to 25 for bi
and dbi
.
These derivative rules are known to Maxima:
diff (ai(x), x)
yields dai(x)
,
diff (dai(x), x)
yields x ai(x)
,
diff (bi(x), x)
yields dbi(x)
,
diff (dbi(x), x)
yields x bi(x)
.
Function values are computed from the convergent Taylor series for abs(x) < 3
,
and from the asymptotic expansions for x < -3
or x > 3
as needed.
This results in only very minor numerical discrepancies at x = 3
and x = -3
.
For details, see Abramowitz and Stegun,
Handbook of Mathematical Functions, Section 10.4 and Table 10.11.
ev (taylor (ai(x), x, 0, 9), infeval)
yields a
floating point Taylor expansions of the function ai
.
A similar expression can be constructed for bi
.
The Airy equation diff (y(x), x, 2) - x y(x) = 0
has two
linearly independent solutions, y = Ai(x)
and y = Bi(x)
.
The derivative diff (airy_ai(x), x)
is airy_dai(x)
.
If the argument x
is a real or complex floating point
number, the numerical value of airy_ai
is returned
when possible.
See also airy_bi
, airy_dai
, airy_dbi
.
airy_ai(x)
.
See airy_ai
.
diff (y(x), x, 2) - x y(x) = 0
.
If the argument x
is a real or complex floating point number,
the numerical value of airy_bi
is returned when possible.
In other cases the unevaluated expression is returned.
The derivative diff (airy_bi(x), x)
is airy_dbi(x)
.
See airy_ai
, airy_dbi
.
airy_bi(x)
.
See airy_ai
and airy_bi
.
asympa
is a package for asymptotic analysis. The package contains
simplification functions for asymptotic analysis, including the "big O"
and "little o" functions that are widely used in complexity analysis and
numerical analysis.
load ("asympa")
loads this package.
This function is deprecated. Write bessel_j (z, a)
instead.
bessel_j
computes the array besselarray
such that
besselarray [i] = bessel_j [i + v - int(v)] (z)
for i
from zero to int(v)
.
bessel_j
is defined as
@example
inf
==== k - v - 2 k v + 2 k
\ (- 1) 2 z
> --------------------------
/ k! gamma(v + k + 1)
====
k = 0
@end example
although the infinite series is not used for computations.
bessel_y
computes the array besselarray
such that
besselarray [i] = bessel_y [i + v - int(v)] (z)
for i
from zero to int(v)
.
bessel_y
is defined as
@example
cos(%pi v) bessel_j(v, z) - bessel_j(-v, z)
-------------------------------------------
sin(%pi v)
@end example
when v is not an integer. When v is an integer n, the limit as v approaches n is taken.
bessel_i
computes the array besselarray
such that
besselarray [i] = bessel_i [i + v - int(v)] (z)
for i
from zero to int(v)
.
bessel_i
is defined as
@example
inf
==== - v - 2 k v + 2 k
\ 2 z
> -------------------
/ k! gamma(v + k + 1)
====
k = 0
@end example
although the infinite series is not used for computations.
bessel_k
computes the array besselarray
such that
besselarray [i] = bessel_k [i + v - int(v)] (z)
for i
from zero to int(v)
.
bessel_k
is defined as
@example
%pi csc(%pi v) (bessel_i(-v, z) - bessel_i(v, z))
-------------------------------------------------
2
@end example
when v is not an integer. If v is an integer n, then the limit as v approaches n is taken.
false
Controls expansion of the Bessel functions when the order is half of
an odd integer. In this case, the Bessel functions can be expanded
in terms of other elementary functions. When besselexpand
is true
,
the Bessel function is expanded.
(%i1) besselexpand: false$ (%i2) bessel_j (3/2, z); 3 (%o2) bessel_j(-, z) 2 (%i3) besselexpand: true$ (%i4) bessel_j (3/2, z); 2 z sin(z) cos(z) (%o4) sqrt(---) (------ - ------) %pi 2 z z
This function is deprecated. Write bessel_j (0, x)
instead.
This function is deprecated. Write bessel_j (1, x)
instead.
This function is deprecated. Write bessel_j (n, x)
instead.
This function is deprecated. Write bessel_i (0, x)
instead.
This function is deprecated. Write bessel_i (1,
instead.
x
)
gamma(x) gamma(y)/gamma(x + y)
.
See also makegamma
.
The variable gammalim
controls simplification of the gamma function.
The Euler-Mascheroni constant is %gamma
.
gammalim
controls simplification of the gamma
function for integral and rational number arguments. If the absolute
value of the argument is not greater than gammalim
, then
simplification will occur. Note that the factlim
switch controls
simplification of the result of gamma
of an integer argument as well.
See also makegamma
.
See also makefact
.
content
returns the greatest common divisor (gcd) of all terms in a sum.
(%i1) gamma (7/2); 15 sqrt(%pi) (%o1) ------------ 8 (%i2) numfactor (%); 15 (%o2) -- 8
outofpois
carries out the conversion,
i.e., the return value is outofpois (intopois (a))
.
This function is thus a canonical simplifier
for sums of powers of sine and cosine terms of a particular type.
intopois (a^b)
.
b must be a positive integer.
poisdiff
). Non-periodic terms in b are dropped if b is in the trig
arguments.
poislim
determines the domain of the coefficients in
the arguments of the trig functions. The initial value of 5
corresponds to the interval [-2^(5-1)+1,2^(5-1)], or [-15,16], but it
can be set to [-2^(n-1)+1, 2^(n-1)].
intopois (a + b)
.
/P/
follows the line label of Poisson series
expressions.
(1) Where B is a variable u, v, w, x, y, or z,
then a must be an
expression linear in those variables (e.g., 6*u + 4*v
).
(2) Where b is other than those variables, then a must also be free of those variables, and furthermore, free of sines or cosines.
poissubst (a, b, c, d, n)
is a special type of substitution which
operates on a and b as in type (1) above, but where d is a Poisson
series, expands cos(d)
and sin(d)
to order n so as to provide the
result of substituting a + d
for b in c. The idea is that d is an
expansion in terms of a small parameter. For example,
poissubst (u, v, cos(v), %e, 3)
yields cos(u)*(1 - %e^2/2) - sin(u)*(%e - %e^3/6)
.
intopois (a*b)
.
poistrim
is true
(for the coefficients of
that term) are eliminated during multiplication.
outofpois
, it will convert a into a Poisson encoding first, if
necessary.
log (gamma (x))
.
Maxima does not know how to compute a numerical value of psi
.
However, the function bfpsi
in the bffac
package can compute numerical values.
Go to the first, previous, next, last section, table of contents.