|
Calling Sequence
|
|
LHLibrary:-Routine(arguments, options)
|
|
|
Parameters
|
|
|
Routine
|
-
|
a Routine of the LHLibrary subpackage; could be any of those shown via with(LHLibrary)
|
|
arguments
|
-
|
the arguments of Routine
|
|
options
|
-
|
some LHLibrary Routines accept optional arguments of the form name = value
|
|
|
|
|
|
Description
|
|
|
•
|
The LHLibrary subpackage includes several useful commands that are used as internal routines in the LieAlgebrasOfVectorFields package. These commands are mainly for dealing with differential equations.
|
|
•
|
Any Routine can be used in the form Routine(...) only after executing the command with(LHLibrary), but can always be used in the form LHLibrary:-Routine(..).
|
|
|
|
List of Routines in LHLibrary Subpackage & examples
|
|
|
>
|
with(LieAlgebrasOfVectorFields);
|
|
|
AddBrackets, RemoveBrackets
|
|
|
|
Calling Sequence & Parameters
|
|
AddBrackets(x)
RemoveBrackets(x)
x - a name or function, or a list of them
|
|
•
|
If is a name then AddBrackets(x) adds brackets to (i.e. ) When is a function, the function is returned unchanged.
|
|
•
|
RemoveBrackets(x) reverses the process from the previous dot point.
|
|
•
|
If is a list then both commands distribute themselves over the list.
|
|
|
Example
|
|
|
>
|
AddBrackets([a, b(x), c(b(x))]);
|
|
>
|
RemoveBrackets([a, b(),u(x),k(u(x))]);
|
Adding & removing brackets to a name should return it unchanged.
|
>
|
RemoveBrackets(AddBrackets(a));
|
|
|
|
|
Erase
|
|
|
|
Calling Sequence & Parameters
|
|
Erase(x,L)
x, L - a list or set of functions or names
|
|
•
|
Erase(x,L) returns a new list where the variables in x are removed from the list L.
|
|
|
Example
|
|
|
>
|
Erase([u(x),k(z)], [u(x),v(y),k(z)]);
|
|
|
|
|
EssentialDependencies
|
|
|
|
Calling Sequence & Parameters
|
|
EssentialDependencies(sys, deps)
sys - a DEs system (as a list of equations) that is assumed to be fully reduced
deps - a list of names or functions of name
|
|
•
|
Let sys be a list of DEs with its dependent variables named deps. Then EssentialDependencies(sys, deps) returns the list of essential dependencies from the system sys. For example, a dep like is essentially dependent on if is not 0, or more precisely if it does not reduce to 0 modulo the DEs system sys.
|
|
•
|
Typically, the input arguments come from a LHPDE object S (i.e. sys := GetSystem(S), deps = GetDependents(S)). See Overview of the LHPDE object for more detail.
|
|
|
Example
|
|
|
>
|
S := [diff(xi(x,y),y,y)=0, diff(eta(x,y),x)+diff(xi(x,y),y)=0, diff(eta(x,y),y)=0, diff(xi(x,y),x)=0];
|
|
>
|
EssentialDependencies(S, [xi(x,y), eta(x,y)]);
|
|
|
|
|
GetDerivativeList
|
|
|
|
Calling Sequence & Parameters
|
|
GetDerivativeList(x, n)
GetDerivativeList(x, m..n)
x - a list of functions or names representing dependent variables
m,n - a non-negative integer
|
|
•
|
GetDerivativeList(x, n) returns a list of all derivatives of dependent variables x of differential order exactly n.
|
|
•
|
GetDerivativeList(x, m..n) returns a list of all derivatives of dependent variables x from order m to order n.
|
|
•
|
For each dep in x , the command differentiates it with respect to all variable names in the argument list of dep.
|
|
|
Example
|
|
|
>
|
GetDerivativeList([u(x,y)], 2);
|
|
>
|
GetDerivativeList([u(x)],0..2);
|
|
>
|
GetDerivativeList([u(x,y,z),v(y),w(z),A],0..1);
|
|
|
|
|
GetFunctionDependencies
|
|
|
|
Calling Sequence & Parameters
|
|
GetFunctionDependencies(func)
func - a function or name
|
|
•
|
GetFunctionDependencies(func) returns a list of dependencies of the function as names in order
|
|
|
Example
|
|
|
>
|
GetFunctionDependencies(G(x));
|
|
>
|
GetFunctionDependencies(a);
|
|
>
|
GetFunctionDependencies(u(a(x),y));
|
|
>
|
GetFunctionDependencies(F(u(x,t), v(x,t), x, k(r), b(q), a, b));
|
|
|
|
|
GetFunctionNames
|
|
|
|
Calling Sequence & Parameters
|
|
GetFunctionNames(funcL)
funcL - a list or set of functions or names
|
|
•
|
GetFunctionNames(funcL) returns a list of function names in order
|
|
|
Example
|
|
|
>
|
GetFunctionNames([a(x), b(y)]);
|
|
>
|
GetFunctionNames([a, u(x,y), v(x,y), K(v(x,y),u(x,y)), B(x)]);
|
|
|
|
|
IsAdmissibleDependency
|
|
|
|
Calling Sequence & Parameters
|
|
IsAdmissibleDependency(u,vars)
u - a variable or a list (or set) of variables
vars - a sequence of names
|
|
•
|
IsAdmissibleDependency(u, vars) checks whether u is an admissible function respect to a set/list of variable names.
|
|
•
|
The command will either return true or an exception is thrown.
|
|
|
Example
|
|
|
>
|
IsAdmissibleDependency([u(x,y),v(x,y)], x,y);
|
|
>
|
IsAdmissibleDependency([w(x)], x,y);
|
|
>
|
IsAdmissibleDependency([u(x,y,z), v(x,y,z), w(a,b)], x,y,z);
|
|
|
|
|
IsHomogeneous
|
|
|
|
Calling Sequence & Parameters
|
|
IsHomogeneous(sys, vars)
sys - a list of equations
vars - a list of names or function of names
|
|
•
|
IsHomogeneous(sys, vars) checks if the DEs system sys is linear homogeneous with respect to vars.
|
|
|
Example
|
|
|
>
|
IsHomogeneous([diff(u(x,y),x,x) + diff(u(x,y),y,y) = 0], [u(x,y)]);
|
|
>
|
IsHomogeneous([diff(u(x,y),x,x) + diff(u(x,y),y,y) = b], [u(x,y),b]);
|
|
>
|
IsHomogeneous([a*diff(u(x,y),x,x) + diff(u(x,y),y,y) = 0], [u(x,y),a]);
|
|
|
|
|
RifDsubs
|
|
|
|
Calling Sequence & Parameters
|
|
RifDsubs(sys, expr)
sys - a sequence of equations
expr - an expression
|
|
•
|
The command is front-end to dsubs from Maple version 9.5. It performs differential substitutions into expressions.
|
|
•
|
RifDsubs ensures of fully substitution and termination, via calling dsubs multiple times.
|
|
•
|
The calling interface of RifDsubs is identical to the dsubs command. All input arguments will be passed down to dsubs.
|
|
|
|
Rifsimp
|
|
|
|
Calling Sequence & Parameters
|
|
Rifsimp(sys, options)
sys - a list of set of polynomially nonlinear PDEs or ODEs
options - (options) a sequence of option that pass down to DEtools[rifsimp]
|
|
•
|
The command is front-end to rifsimp from the DEtools library. The only difference between these two commands is that Rifsimp returns an empty system when the input argument syst is an empty list.
|
|
•
|
The calling interface of Rifsimp is identical to the rifsimp command. All input arguments will be passed down to rifsimp.
|
|
|
|
SortFunctionList
|
|
|
|
Calling Sequence & Parameters
|
|
SortFunctionList(funcL, L)
funcL - a list of functions
L - a list of variable names
|
|
•
|
SortFunctionList(funL, L) returns a list of functions after sorted according to the order in L.
|
|
|
Example
|
|
|
>
|
deps := [A(x),B(x,y),C(A(x),B(x,y))];
|
|
>
|
SortFunctionList(deps, [C,B,A]);
|
|
|
|
|
|
Compatibility
|
|
|
•
|
The LieAlgebrasOfVectorFields[LHLibrary] command was introduced in Maple 2020.
|
|
|
|
