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

18.1 Functions and Variables for Differentiation |

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

__Function:__**antid***(*`expr`,`x`,`u(x)`)Returns a two-element list, such that an antiderivative of

`expr`with respect to`x`can be constructed from the list. The expression`expr`may contain an unknown function`u`and its derivatives.Let

`L`, a list of two elements, be the return value of`antid`

. Then

is an antiderivative of`L`[1] + 'integrate (`L`[2],`x`)`expr`with respect to`x`.When

`antid`

succeeds entirely, the second element of the return value is zero. Otherwise, the second element is nonzero, and the first element is nonzero or zero. If`antid`

cannot make any progress, the first element is zero and the second nonzero.`load ("antid")`

loads this function. The`antid`

package also defines the functions`nonzeroandfreeof`

and`linear`

.`antid`

is related to`antidiff`

as follows. Let`L`, a list of two elements, be the return value of`antid`

. Then the return value of`antidiff`

is equal to

where`L`[1] + 'integrate (`L`[2],`x`)`x`is the variable of integration.Examples:

(%i1) load ("antid")$ (%i2) expr: exp (z(x)) * diff (z(x), x) * y(x); z(x) d (%o2) y(x) %e (-- (z(x))) dx (%i3) a1: antid (expr, x, z(x)); z(x) z(x) d (%o3) [y(x) %e , - %e (-- (y(x)))] dx (%i4) a2: antidiff (expr, x, z(x)); / z(x) [ z(x) d (%o4) y(x) %e - I %e (-- (y(x))) dx ] dx / (%i5) a2 - (first (a1) + 'integrate (second (a1), x)); (%o5) 0 (%i6) antid (expr, x, y(x)); z(x) d (%o6) [0, y(x) %e (-- (z(x)))] dx (%i7) antidiff (expr, x, y(x)); / [ z(x) d (%o7) I y(x) %e (-- (z(x))) dx ] dx /

Categories: Integral calculus

__Function:__**antidiff***(*`expr`,`x`,`u`(`x`))Returns an antiderivative of

`expr`with respect to`x`. The expression`expr`may contain an unknown function`u`and its derivatives.When

`antidiff`

succeeds entirely, the resulting expression is free of integral signs (that is, free of the`integrate`

noun). Otherwise,`antidiff`

returns an expression which is partly or entirely within an integral sign. If`antidiff`

cannot make any progress, the return value is entirely within an integral sign.`load ("antid")`

loads this function. The`antid`

package also defines the functions`nonzeroandfreeof`

and`linear`

.`antidiff`

is related to`antid`

as follows. Let`L`, a list of two elements, be the return value of`antid`

. Then the return value of`antidiff`

is equal to

where`L`[1] + 'integrate (`L`[2],`x`)`x`is the variable of integration.Examples:

(%i1) load ("antid")$ (%i2) expr: exp (z(x)) * diff (z(x), x) * y(x); z(x) d (%o2) y(x) %e (-- (z(x))) dx (%i3) a1: antid (expr, x, z(x)); z(x) z(x) d (%o3) [y(x) %e , - %e (-- (y(x)))] dx (%i4) a2: antidiff (expr, x, z(x)); / z(x) [ z(x) d (%o4) y(x) %e - I %e (-- (y(x))) dx ] dx / (%i5) a2 - (first (a1) + 'integrate (second (a1), x)); (%o5) 0 (%i6) antid (expr, x, y(x)); z(x) d (%o6) [0, y(x) %e (-- (z(x)))] dx (%i7) antidiff (expr, x, y(x)); / [ z(x) d (%o7) I y(x) %e (-- (z(x))) dx ] dx /

Categories: Integral calculus

__Function:__**at***(*`expr`, [`eqn_1`, …,`eqn_n`])__Function:__**at***(*`expr`,`eqn`)Evaluates the expression

`expr`with the variables assuming the values as specified for them in the list of equations`[`

or the single equation`eqn_1`, ...,`eqn_n`]`eqn`.If a subexpression depends on any of the variables for which a value is specified but there is no

`atvalue`

specified and it can't be otherwise evaluated, then a noun form of the`at`

is returned which displays in a two-dimensional form.`at`

carries out multiple substitutions in parallel.See also

`atvalue`

. For other functions which carry out substitutions, see also`subst`

and`ev`

.Examples:

(%i1) atvalue (f(x,y), [x = 0, y = 1], a^2); 2 (%o1) a (%i2) atvalue ('diff (f(x,y), x), x = 0, 1 + y); (%o2) @2 + 1 (%i3) printprops (all, atvalue); ! d ! --- (f(@1, @2))! = @2 + 1 d@1 ! !@1 = 0 2 f(0, 1) = a (%o3) done (%i4) diff (4*f(x, y)^2 - u(x, y)^2, x); d d (%o4) 8 f(x, y) (-- (f(x, y))) - 2 u(x, y) (-- (u(x, y))) dx dx (%i5) at (%, [x = 0, y = 1]); ! 2 d ! (%o5) 16 a - 2 u(0, 1) (-- (u(x, y))! ) dx ! !x = 0, y = 1

Categories: Evaluation · Differential equations

__Property:__**atomgrad**`atomgrad`

is the atomic gradient property of an expression. This property is assigned by`gradef`

.Categories: Differential calculus

__Function:__**atvalue***(*`expr`, [`x_1`=`a_1`, …,`x_m`=`a_m`],`c`)__Function:__**atvalue***(*`expr`,`x_1`=`a_1`,`c`)Assigns the value

`c`to`expr`at the point

. Typically boundary values are established by this mechanism.`x`=`a``expr`is a function evaluation,

, or a derivative,`f`(`x_1`, ...,`x_m`)`diff (`

in which the function arguments explicitly appear.`f`(`x_1`, ...,`x_m`),`x_1`,`n_1`, ...,`x_n`,`n_m`)`n_i`is the order of differentiation with respect to`x_i`.The point at which the atvalue is established is given by the list of equations

`[`

. If there is a single variable`x_1`=`a_1`, ...,`x_m`=`a_m`]`x_1`, the sole equation may be given without enclosing it in a list.`printprops ([`

displays the atvalues of the functions`f_1`,`f_2`, ...], atvalue)

as specified by calls to`f_1`,`f_2`, ...`atvalue`

.`printprops (`

displays the atvalues of one function`f`, atvalue)`f`.`printprops (all, atvalue)`

displays the atvalues of all functions for which atvalues are defined.The symbols

`@1`

,`@2`

, … represent the variables`x_1`,`x_2`, … when atvalues are displayed.`atvalue`

evaluates its arguments.`atvalue`

returns`c`, the atvalue.Examples:

(%i1) atvalue (f(x,y), [x = 0, y = 1], a^2); 2 (%o1) a (%i2) atvalue ('diff (f(x,y), x), x = 0, 1 + y); (%o2) @2 + 1 (%i3) printprops (all, atvalue); ! d ! --- (f(@1, @2))! = @2 + 1 d@1 ! !@1 = 0 2 f(0, 1) = a (%o3) done (%i4) diff (4*f(x,y)^2 - u(x,y)^2, x); d d (%o4) 8 f(x, y) (-- (f(x, y))) - 2 u(x, y) (-- (u(x, y))) dx dx (%i5) at (%, [x = 0, y = 1]); ! 2 d ! (%o5) 16 a - 2 u(0, 1) (-- (u(x, y))! ) dx ! !x = 0, y = 1

Categories: Differential equations · Declarations and inferences

__Function:__**cartan**The exterior calculus of differential forms is a basic tool of differential geometry developed by Elie Cartan and has important applications in the theory of partial differential equations. The

`cartan`

package implements the functions`ext_diff`

and`lie_diff`

, along with the operators`~`

(wedge product) and`|`

(contraction of a form with a vector.) Type`demo (tensor)`

to see a brief description of these commands along with examples.`cartan`

was implemented by F.B. Estabrook and H.D. Wahlquist.Categories: Differential geometry

__Function:__**del***(*`x`)`del (`

represents the differential of the variable`x`)*x*.`diff`

returns an expression containing`del`

if an independent variable is not specified. In this case, the return value is the so-called "total differential".Examples:

(%i1) diff (log (x)); del(x) (%o1) ------ x (%i2) diff (exp (x*y)); x y x y (%o2) x %e del(y) + y %e del(x) (%i3) diff (x*y*z); (%o3) x y del(z) + x z del(y) + y z del(x)

Categories: Differential calculus

__Function:__**delta***(*`t`)The Dirac Delta function.

Currently only

`laplace`

knows about the`delta`

function.Example:

(%i1) laplace (delta (t - a) * sin(b*t), t, s); Is a positive, negative, or zero? p; - a s (%o1) sin(a b) %e

Categories: Mathematical functions · Laplace transform

__System variable:__**dependencies**__Function:__**dependencies***(*`f_1`, …,`f_n`)The variable

`dependencies`

is the list of atoms which have functional dependencies, assigned by`depends`

, the function`dependencies`

, or`gradef`

. The`dependencies`

list is cumulative: each call to`depends`

,`dependencies`

, or`gradef`

appends additional items. The default value of`dependencies`

is`[]`

.The function

`dependencies(`

appends`f_1`, …,`f_n`)`f_1`, …,`f_n`, to the`dependencies`

list, where`f_1`, …,`f_n`are expressions of the form

, and`f`(`x_1`, …,`x_m`)`x_1`, …,`x_m`are any number of arguments.`dependencies(`

is equivalent to`f`(`x_1`, …,`x_m`))`depends(`

.`f`, [`x_1`, …,`x_m`])See also

`depends`

and`gradef`

.(%i1) dependencies; (%o1) [] (%i2) depends (foo, [bar, baz]); (%o2) [foo(bar, baz)] (%i3) depends ([g, h], [a, b, c]); (%o3) [g(a, b, c), h(a, b, c)] (%i4) dependencies; (%o4) [foo(bar, baz), g(a, b, c), h(a, b, c)] (%i5) dependencies (quux (x, y), mumble (u)); (%o5) [quux(x, y), mumble(u)] (%i6) dependencies; (%o6) [foo(bar, baz), g(a, b, c), h(a, b, c), quux(x, y), mumble(u)] (%i7) remove (quux, dependency); (%o7) done (%i8) dependencies; (%o8) [foo(bar, baz), g(a, b, c), h(a, b, c), mumble(u)]

Categories: Declarations and inferences · Global variables

__Function:__**depends***(*`f_1`,`x_1`, …,`f_n`,`x_n`)Declares functional dependencies among variables for the purpose of computing derivatives. In the absence of declared dependence,

`diff (f, x)`

yields zero. If`depends (f, x)`

is declared,`diff (f, x)`

yields a symbolic derivative (that is, a`diff`

noun).Each argument

`f_1`,`x_1`, etc., can be the name of a variable or array, or a list of names. Every element of`f_i`(perhaps just a single element) is declared to depend on every element of`x_i`(perhaps just a single element). If some`f_i`is the name of an array or contains the name of an array, all elements of the array depend on`x_i`.`diff`

recognizes indirect dependencies established by`depends`

and applies the chain rule in these cases.`remove (`

removes all dependencies declared for`f`, dependency)`f`.`depends`

returns a list of the dependencies established. The dependencies are appended to the global variable`dependencies`

.`depends`

evaluates its arguments.`diff`

is the only Maxima command which recognizes dependencies established by`depends`

. Other functions (`integrate`

,`laplace`

, etc.) only recognize dependencies explicitly represented by their arguments. For example,`integrate`

does not recognize the dependence of`f`

on`x`

unless explicitly represented as`integrate (f(x), x)`

.`depends(`

is equivalent to`f`, [`x_1`, …,`x_n`])`dependencies(`

.`f`(`x_1`, …,`x_n`))(%i1) depends ([f, g], x); (%o1) [f(x), g(x)] (%i2) depends ([r, s], [u, v, w]); (%o2) [r(u, v, w), s(u, v, w)] (%i3) depends (u, t); (%o3) [u(t)] (%i4) dependencies; (%o4) [f(x), g(x), r(u, v, w), s(u, v, w), u(t)] (%i5) diff (r.s, u); dr ds (%o5) -- . s + r . -- du du

(%i6) diff (r.s, t); dr du ds du (%o6) -- -- . s + r . -- -- du dt du dt

(%i7) remove (r, dependency); (%o7) done (%i8) diff (r.s, t); ds du (%o8) r . -- -- du dt

Categories: Differential calculus · Declarations and inferences

__Option variable:__**derivabbrev**Default value:

`false`

When

`derivabbrev`

is`true`

, symbolic derivatives (that is,`diff`

nouns) are displayed as subscripts. Otherwise, derivatives are displayed in the Leibniz notation`dy/dx`

.Categories: Differential calculus · Global flags

__Function:__**derivdegree***(*`expr`,`y`,`x`)Returns the highest degree of the derivative of the dependent variable

`y`with respect to the independent variable`x`occuring in`expr`.Example:

(%i1) 'diff (y, x, 2) + 'diff (y, z, 3) + 'diff (y, x) * x^2; 3 2 d y d y 2 dy (%o1) --- + --- + x -- 3 2 dx dz dx (%i2) derivdegree (%, y, x); (%o2) 2

Categories: Differential calculus · Expressions

__Function:__**derivlist***(*`var_1`, …,`var_k`)Causes only differentiations with respect to the indicated variables, within the

`ev`

command.Categories: Differential calculus · Evaluation

__Option variable:__**derivsubst**Default value:

`false`

When

`derivsubst`

is`true`

, a non-syntactic substitution such as`subst (x, 'diff (y, t), 'diff (y, t, 2))`

yields`'diff (x, t)`

.Categories: Differential calculus · Expressions

__Function:__**diff***(*`expr`,`x_1`,`n_1`, …,`x_m`,`n_m`)__Function:__**diff***(*`expr`,`x`,`n`)__Function:__**diff***(*`expr`,`x`)__Function:__**diff***(*`expr`)Returns the derivative or differential of

`expr`with respect to some or all variables in`expr`.`diff (`

returns the`expr`,`x`,`n`)`n`'th derivative of`expr`with respect to`x`.`diff (`

returns the mixed partial derivative of`expr`,`x_1`,`n_1`, ...,`x_m`,`n_m`)`expr`with respect to`x_1`, …,`x_m`. It is equivalent to`diff (... (diff (`

.`expr`,`x_m`,`n_m`) ...),`x_1`,`n_1`)`diff (`

returns the first derivative of`expr`,`x`)`expr`with respect to the variable`x`.`diff (`

returns the total differential of`expr`)`expr`, that is, the sum of the derivatives of`expr`with respect to each its variables times the differential`del`

of each variable. No further simplification of`del`

is offered.The noun form of

`diff`

is required in some contexts, such as stating a differential equation. In these cases,`diff`

may be quoted (as`'diff`

) to yield the noun form instead of carrying out the differentiation.When

`derivabbrev`

is`true`

, derivatives are displayed as subscripts. Otherwise, derivatives are displayed in the Leibniz notation,`dy/dx`

.Examples:

(%i1) diff (exp (f(x)), x, 2); 2 f(x) d f(x) d 2 (%o1) %e (--- (f(x))) + %e (-- (f(x))) 2 dx dx (%i2) derivabbrev: true$ (%i3) 'integrate (f(x, y), y, g(x), h(x)); h(x) / [ (%o3) I f(x, y) dy ] / g(x) (%i4) diff (%, x); h(x) / [ (%o4) I f(x, y) dy + f(x, h(x)) h(x) - f(x, g(x)) g(x) ] x x x / g(x)

For the tensor package, the following modifications have been incorporated:

(1) The derivatives of any indexed objects in

`expr`will have the variables`x_i`appended as additional arguments. Then all the derivative indices will be sorted.(2) The

`x_i`may be integers from 1 up to the value of the variable`dimension`

[default value: 4]. This will cause the differentiation to be carried out with respect to the`x_i`'th member of the list`coordinates`

which should be set to a list of the names of the coordinates, e.g.,`[x, y, z, t]`

. If`coordinates`

is bound to an atomic variable, then that variable subscripted by`x_i`will be used for the variable of differentiation. This permits an array of coordinate names or subscripted names like`X[1]`

,`X[2]`

, … to be used. If`coordinates`

has not been assigned a value, then the variables will be treated as in (1) above.Categories: Differential calculus

__Special symbol:__**diff**When

`diff`

is present as an`evflag`

in call to`ev`

, all differentiations indicated in`expr`

are carried out.

__Function:__**dscalar***(*`f`)Applies the scalar d'Alembertian to the scalar function

`f`.`load ("ctensor")`

loads this function.Categories: Differential calculus · Package ctensor

__Function:__**express***(*`expr`)-
Expands differential operator nouns into expressions in terms of partial derivatives.

`express`

recognizes the operators`grad`

,`div`

,`curl`

,`laplacian`

.`express`

also expands the cross product`~`

.Symbolic derivatives (that is,

`diff`

nouns) in the return value of express may be evaluated by including`diff`

in the`ev`

function call or command line. In this context,`diff`

acts as an`evfun`

.`load ("vect")`

loads this function.Examples:

(%i1) load ("vect")$ (%i2) grad (x^2 + y^2 + z^2); 2 2 2 (%o2) grad (z + y + x ) (%i3) express (%); d 2 2 2 d 2 2 2 d 2 2 2 (%o3) [-- (z + y + x ), -- (z + y + x ), -- (z + y + x )] dx dy dz (%i4) ev (%, diff); (%o4) [2 x, 2 y, 2 z] (%i5) div ([x^2, y^2, z^2]); 2 2 2 (%o5) div [x , y , z ] (%i6) express (%); d 2 d 2 d 2 (%o6) -- (z ) + -- (y ) + -- (x ) dz dy dx (%i7) ev (%, diff); (%o7) 2 z + 2 y + 2 x (%i8) curl ([x^2, y^2, z^2]); 2 2 2 (%o8) curl [x , y , z ] (%i9) express (%); d 2 d 2 d 2 d 2 d 2 d 2 (%o9) [-- (z ) - -- (y ), -- (x ) - -- (z ), -- (y ) - -- (x )] dy dz dz dx dx dy (%i10) ev (%, diff); (%o10) [0, 0, 0] (%i11) laplacian (x^2 * y^2 * z^2); 2 2 2 (%o11) laplacian (x y z ) (%i12) express (%); 2 2 2 d 2 2 2 d 2 2 2 d 2 2 2 (%o12) --- (x y z ) + --- (x y z ) + --- (x y z ) 2 2 2 dz dy dx (%i13) ev (%, diff); 2 2 2 2 2 2 (%o13) 2 y z + 2 x z + 2 x y (%i14) [a, b, c] ~ [x, y, z]; (%o14) [a, b, c] ~ [x, y, z] (%i15) express (%); (%o15) [b z - c y, c x - a z, a y - b x]

Categories: Differential calculus · Vectors · Operators

__Function:__**gradef***(*`f`(`x_1`, …,`x_n`),`g_1`, …,`g_m`)__Function:__**gradef***(*`a`,`x`,`expr`)Defines the partial derivatives (i.e., the components of the gradient) of the function

`f`or variable`a`.`gradef (`

defines`f`(`x_1`, ...,`x_n`),`g_1`, ...,`g_m`)`d`

as`f`/d`x_i``g_i`, where`g_i`is an expression;`g_i`may be a function call, but not the name of a function. The number of partial derivatives`m`may be less than the number of arguments`n`, in which case derivatives are defined with respect to`x_1`through`x_m`only.`gradef (`

defines the derivative of variable`a`,`x`,`expr`)`a`with respect to`x`as`expr`. This also establishes the dependence of`a`on`x`(via`depends (`

).`a`,`x`)The first argument

or`f`(`x_1`, ...,`x_n`)`a`is quoted, but the remaining arguments`g_1`, ...,`g_m`are evaluated.`gradef`

returns the function or variable for which the partial derivatives are defined.`gradef`

can redefine the derivatives of Maxima's built-in functions. For example,`gradef (sin(x), sqrt (1 - sin(x)^2))`

redefines the derivative of`sin`

.`gradef`

cannot define partial derivatives for a subscripted function.`printprops ([`

displays the partial derivatives of the functions`f_1`, ...,`f_n`], gradef)`f_1`, ...,`f_n`, as defined by`gradef`

.`printprops ([`

displays the partial derivatives of the variables`a_n`, ...,`a_n`], atomgrad)`a_n`, ...,`a_n`, as defined by`gradef`

.`gradefs`

is the list of the functions for which partial derivatives have been defined by`gradef`

.`gradefs`

does not include any variables for which partial derivatives have been defined by`gradef`

.Gradients are needed when, for example, a function is not known explicitly but its first derivatives are and it is desired to obtain higher order derivatives.

Categories: Differential calculus · Declarations and inferences

__System variable:__**gradefs**Default value:

`[]`

`gradefs`

is the list of the functions for which partial derivatives have been defined by`gradef`

.`gradefs`

does not include any variables for which partial derivatives have been defined by`gradef`

.Categories: Differential calculus · Declarations and inferences

__Function:__**laplace***(*`expr`,`t`,`s`)Attempts to compute the Laplace transform of

`expr`with respect to the variable`t`and transform parameter`s`.`laplace`

recognizes in`expr`the functions`delta`

,`exp`

,`log`

,`sin`

,`cos`

,`sinh`

,`cosh`

, and`erf`

, as well as`derivative`

,`integrate`

,`sum`

, and`ilt`

. If laplace fails to find a transform the function`specint`

is called.`specint`

can find the laplace transform for expressions with special functions like the bessel functions`bessel_j`

,`bessel_i`

, … and can handle the`unit_step`

function. See also`specint`

.If

`specint`

cannot find a solution too, a noun`laplace`

is returned.`expr`may also be a linear, constant coefficient differential equation in which case`atvalue`

of the dependent variable is used. The required atvalue may be supplied either before or after the transform is computed. Since the initial conditions must be specified at zero, if one has boundary conditions imposed elsewhere he can impose these on the general solution and eliminate the constants by solving the general solution for them and substituting their values back.`laplace`

recognizes convolution integrals of the form`integrate (f(x) * g(t - x), x, 0, t)`

; other kinds of convolutions are not recognized.Functional relations must be explicitly represented in

`expr`; implicit relations, established by`depends`

, are not recognized. That is, if`f`depends on`x`and`y`,`f (x, y)`

must appear in`expr`.See also

`ilt`

, the inverse Laplace transform.Examples:

(%i1) laplace (exp (2*t + a) * sin(t) * t, t, s); a %e (2 s - 4) (%o1) --------------- 2 2 (s - 4 s + 5) (%i2) laplace ('diff (f (x), x), x, s); (%o2) s laplace(f(x), x, s) - f(0) (%i3) diff (diff (delta (t), t), t); 2 d (%o3) --- (delta(t)) 2 dt (%i4) laplace (%, t, s); ! d ! 2 (%o4) - -- (delta(t))! + s - delta(0) s dt ! !t = 0 (%i5) assume(a>0)$ (%i6) laplace(gamma_incomplete(a,t),t,s),gamma_expand:true; - a - 1 gamma(a) gamma(a) s (%o6) -------- - ----------------- s 1 a (- + 1) s (%i7) factor(laplace(gamma_incomplete(1/2,t),t,s)); s + 1 sqrt(%pi) (sqrt(s) sqrt(-----) - 1) s (%o7) ----------------------------------- 3/2 s + 1 s sqrt(-----) s (%i8) assume(exp(%pi*s)>1)$ (%i9) laplace(sum((-1)^n*unit_step(t-n*%pi)*sin(t),n,0,inf),t,s), simpsum; %i %i ------------------------ - ------------------------ - %pi s - %pi s (s + %i) (1 - %e ) (s - %i) (1 - %e ) (%o9) --------------------------------------------------- 2 (%i9) factor(%); %pi s %e (%o9) ------------------------------- %pi s (s - %i) (s + %i) (%e - 1)

Categories: Laplace transform · Differential equations

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

This document was generated by *Jaime Villate* on *October, 14 2014* using *texi2html 1.76*.