a Routine of the PDEtoolsLibrary; could be any of those shown via with(PDEtools:-Library)

arguments

-

the arguments of Routine, as described in Describe(PDEtools:-Library:-Routine)

options

-

Most LibraryRoutines accept optional arguments of the form name = value

Description

•

Most of the internal Routines of PDEtools, used by the external commands listed in PDEtools, are also available for use as external commands via PDEtools:-Library:-Routine. These Routines can be useful to program your own extensions of PDEtools, or differential equation programs in general, without having to rewrite everything from the scratch. In this sense, these Library Routines are useful mainly for programmers, although some of them, like for instance CloseSystem or ContactCondition can also be seen as differential equation commands.

Instead of providing a help page for each of these Library readable programming tools, only brief information on their use is provided using the Describe command, as in Describe(PDEtools:-Library:-Routine) or just Describe(Routine) if you have first entered with(PDEtools:-Library). Below there is also an alphabetical listing of these Library Routines pointing to sections within this single page, containing the same information provided by Describe(Routine).

Parameters* object - any algebraic object* chi - a name to be used in the returned function chi[j](...)* j - an index for 'chi', typically a number* YX - a list of relevant names* Y - optional, a list of relevant symbols that appear indexed within object* inallcases - optional, default to false, to proceed also when object is already an unknown functionDescription: AbstractedFunction abstracts an algebraic object into a function chi[j](...), of the names found in object that are members of YX or that are indexed symbols found in Y.Example> PDEtools:-Library:-AbstractedFunction(exp(x), phi, 1, [y, x]); phi[1](x)

AssignFromINFO

AssignFromINFO(INFO,Vars)

Parameters* INFO - a table* Vars - a list of names, to be used as indexes of INFODescription: AssignFromINFO assigns to A the value of INFO["A"] for every name A in a list 'Vars'.Example> INFO["a"], INFO["b"] := 5, e:> PDEtools:-Library:-AssignFromINFO('INFO', '[a, b]'):> a; 5> b; e

AssignToINFO

AssignToINFO(INFO,Vars::uneval)

Parameters* INFO - a table* Vars - a list of names, to be used as indexes of INFO, and that may have some value assignedDescription: AssignToINFO assigns INFO["A"] := eval(A) for every name A in a list 'Vars'.Example> a, b := 5, e:> PDEtools:-Library:-AssignToINFO('INFO', [a, b]):> INFO["a"]; 5

Parameters* PDESYS - a set of algebraic differential equations* F - a list with the dependent variables of PDESYS* v - optional, any name to be used as in v[n](..) to represent coefficients of powers of the independent variables found in F* donotusethesesymbols - optional, a set of global names that should not be used when constructing the hint to be returned* dependency - optional, default to the independent variables found in F, can be a list of names indicating the dependency of the hint* ivars - optional, to indicate additional independent variables, possibly not found in F, so that the hint returned should also be polynomial in ivars* undeterminedcoefficients - optional, of type assignable, if given it will be assigned a set with the undetermined coefficients* v_indexshift - optional, default value is 0, used in the v[n+v_indexshift](..) entering the hint returnedDescription: BuildFunctionFieldHint returns a set of equations with the dependent variables of F in the left-hand-sides and a related hint for them, polynomial in the independent variables found in F, in the right-hand-sides, with unknown constant coefficients v[n] (n::integer).Example> PDEtools:-Library:-BuildPolynomialHint((diff(F(x, y), x))*(diff(G(x, y), x))+(diff(F(x, y), y))*(diff(G(x, y), y))+G(x, y)*(diff(diff(F(x, y), x), x)+diff(diff(F(x, y), y), y)) = -1, [F(x, y), G(x, y)], undeterminedcoefficients = 'S'); {F(x, y) = 2 2 v1[1] + v1[2] y + v1[3] x + v1[4] y + v1[5] x y + v1[6] x , G(x, y) = v2[1] + v2[2] y + v2[3] x}> S; {v1[1], v1[2], v1[3], v1[4], v1[5], v1[6], v2[1], v2[2], v2[3]}

Parameters* SYS - any differential equation, or a set or list of them* F - a list of dependent variables* avoidfirstround - optional, to indicate that SYS is of the form 'dF = ...' and written according to some ranking for DepVars and IndepVars* DepVars_ranking - optional, required when passing avoidfirstround, this is the ranking for the dependent variables 'F'* IndepVars_ranking - optional, required when passing avoidfirstround, this is the ranking for the independent variables of 'F'Description: CloseSystem computes a system equivalent to SYS in that it has the same solutions as SYS, and that includes all the integrability conditions explicited.Example> PDEtools:-Library:-CloseSystem([diff(u(x, y), x)-(diff(u(x, y), y)) = 0, diff(u(x, y), y, y) = 0], [u(x, y)]); 2 2 /d \ /d \ d d {|-- u(x, y)| - |-- u(x, y)|, --- u(x, y), --- u(x, y)} \dx / \dy / 2 2 dx dy

CompatibleOptions

CompatibleOptions(command,{exceptions::set(name) := {}})

Parameters* command - any Maple command name* _rest - a sequence of Maple options, typically of the form keyword = value, to be analyzed for compatibility* exceptions - optional, to indicate a set of options to be excluded from the compatibility analysisDescription: CompatibleOptions returns the options that are compatible with a given 'command', among an arbitrary sequence of options (the _rest sequence).Example> PDEtools:-Library:-CompatibleOptions(PDEtools:-DeterminingPDE, order=2, explicit, jetnotation = jetvariables, simplifier = normal, tryrisingtheorder, arbitraryfunctionname, exceptions = {simplifier}); order = 2, jetnotation = jetvariables

Parameters* Fn - a list with N names of arbitrary functions, where N is the number of independent variables in the given 'X'* Y - a list with names of dependent variables* X - a list with names of independent variables* prolongation - optional, default to 0, can be any nonnegative integer indicating the prolongation order of the trivial symmetry to be returned* jetnotation - optional, default is 'jetnumbers', can be any of the jet notations understood in PDEtools (see ?PDEtools:-ToJet)* differentialorder - optional, the maximal differential order of derivatives entering (in jet notation) the functionality of the arbitrary functions of the trivial symmetry* expanded - optional, can be true (default) or false, to return expanded the prolongations of the trivial symmetry (see option expanded in ?InfinitesimalGenerator)Description: ConstructTrivialSymmetry returns a list with the infinitesimals of a trivial symmetry, that is, one that is always admitted by any PDE system but that cannot be used to reduce the number of its independent variables or dependency in general.Example> PDEtools:-Library:-ConstructTrivialSymmetry([_F1, _F2], [u], [x, t], prolongation = 0, jetnotation = jetvariables, differentialorder = 0); [_F1(x, t, u), _F2(x, t, u), _F1(x, t, u) u[x] + _F2(x, t, u) u[t]]

Parameters* EE - any Maple algebraic object, or equation or a set or list of them* X - a name or a set of them* minmax - optional, can be 'min', 'max' (default), or 'both', to request the minimal (equivalent to the lower degree), maximal degree with respect to X, or both (returns a sequence of two numbers)Description: Degree computes the maximum degree of a set of equations EE with respect to variable(s) X. NOTE: if all the equations are equal to 0, the value returned is 0, not -infinity. When the degree cannot be computed, Degree returns FAIL.Example> PDEtools:-Library:-Degree({a, b^2, c^3}, {a, b, c}); 3

Parameters* ee_J - algebraic expression or an equation or a set or list of them, written in jet notation* F - a list of unknown functions of the problem, the ones defining the jet space* ivars - optional, default to all the names entering functionality of functions in F, ivars can be a name or a set of them, or it can be the string "with respect to each of them", to request the differential order with respect to these 'ivars' variables, or alternatively returning the values 'with respect to each of them'* derivatives_J - optional, default to all the derivatives of F in jetnumbers jetnotation, can be a (sub)set of them, to request the differential order only of that (sub)set* minmax - optional, default to 'max', can also be 'min', to respectively request the maximum or minimum differential order* totaldifforder - optional, to return only one number representing the total differential order of derivatives of F found in ee_jDescription: DifforderJet computes the (minimal or maximal) differential order of ee_J (given in jetnumbers jetnotation) with respect to each of the dependent variables (F).Example> PDEtools:-Library:-DifforderJet(u[1]*v[1,2] - u[2,2,2]*v[1,1,1], [u, v](x,t)); [u = 3, v = 3]> PDEtools:-Library:-DifforderJet(u[1]*v[1,2] - u[2,2,2]*v[1,1,1], [u, v](x,t), minmax = min); [u = 1, v = 2]> PDEtools:-Library:-DifforderJet(u[1]*v[1,2] - u[2,2,2]*v[1,1,1], [u, v](x,t), totaldifforder); 3

Forget

Forget()

Parameters* This command takes no parameters.Description: Forget clears all the remember tables of the PDEtools commands and subroutines.Example> PDEtools:-Library:-Forget();

Parameters* expr - any mathematical expression* F - a list with the dependent variables* withoutbrackets - optional, it can be true (default) or false, to return the dependent variables in jet notation without or with bracketsDescription: FromJetNumbersToJetVariables returns the given expression after replacing jet numbers 1, 2, ... by the corresponding jet variables x, y, ... according to the order implicit in F.Example> PDEtools:-Library:-FromJetNumbersToJetVariables(u[1]*u[]+v[2,2]*u[1] = 0, [u,v](x,t)); u[x] u + v[t, t] u[x] = 0

Parameters* DepVars - a name or a function or a set or list of them, or the string "not given"* PDESYS - a differential (or not) equation, or a set or list, or the string "not given"* dependencytype - optional, to consider a dependent variable only those of type 'function(dependencytype)'* onlydifferentiatedfunctions - optional, can be true (default) or false, when DepVars = "not given", consider dependent variable only those functions that are found in differentiated within PDESYS* removeDepVarsnotfoundinPDESYS - optional, can be true or false (default), to discard dependent variables indicated in DepVars but not found in PDESYSDescription: GetDepVars checks for inconsistencies in the given DepVars with respect to given PDESYS and returns a list with the input DepVars after removing repeated elements, and when PDEsys is given it also replaces, in the given DepVars, names by the corresponding functions, optionally returning only the functions actually found in PDEsys.Example> PDEtools:-Library:-GetDepVars([u(x,t), v(x,t), w(x,t)], diff(u(x,t),x) = v(x,t)); [u(x, t), v(x, t), w(x, t)]> PDEtools:-Library:-GetDepVars([u, v, w], diff(u(x,t),x) = v(x,t), removeDepVarsnotfoundinPDESYS); [u(x, t), v(x, t)]> PDEtools:-Library:-GetDepVars("not given", diff(u(x,t),x) = v(x,t)); [u(x, t)]> PDEtools:-Library:-GetDepVars("not given", diff(u(x,t),x) = v(x,t), onlydifferentiatedfunctions = false); [u(x, t), v(x, t)]> PDEtools:-Library:-GetDepVars([u(x,t), v(x,t), w(x,t)], diff(u(x,t),x) = u(t, x)); Error, (in PDEtools:-Library:-GetDepVars) unexpected functions with name [u] having different dependency: [[u(t,x), u(x,t)]]

Parameters* F - a set or list of unknowns* _rest - a sequence of equations or of sets of equationsDescription: GetExplicitSolutions returns the equations and sets of equations of '_rest' such that the left-hand-sides are members of the list of unknowns 'F'.Example> PDEtools:-Library:-GetExplicitSolutions([a, u(x,t)], {a=1, u(x,t) = x}, {a-u(x,t) = 0}); {a = 1, u(x, t) = x}

GetFAndDiffVars

GetFAndDiffVars(df,{usephysics::truefalse := false})

Parameters* df - a derivative in diff, %diff or Diff notationDescription: If 'df' is a derivative in diff notation, GetFAndDiffVars returns a sequence: the derivand followed by all the differentiation variables, otherwise it returns the arguments received.Example> PDEtools:-Library:-GetFAndDiffVars(diff(diff(diff(diff(diff(u(x,t),t),t),x),x),x)); u(x, t), t, t, x, x, x

GetFunctionsWithDifferentDependency

GetFunctionsWithDifferentDependency(F,Y := map2(op,0,F))

Parameters* F - a list of distinct functions* Y - optional, a list of function's names positionally corresponding to the functions found in FDescription: GetFunctionsWithDifferentDependency returns a sequences of two lists, with the functions in F that have the same name but (being distinct) they have different functionality.Example> PDEtools:-Library:-GetFunctionsWithDifferentDependency([f(x), g(y), f(z), g(z), f(y)]); [f, g], [[f(x), f(z), f(y)], [g(y), g(z)]]

GetIndepVars

GetIndepVars(F)

Parameters* F - a list of unknown functions, or the string "not given"Description: GetIndepVars returns the variables of type name found in F, typically representing independent variables, preserving the ordering found in the list F and after removing repeated elements.Example> PDEtools:-Library:-GetIndepVars([u(x,t), v(t,z), w(x,y,z)]); [x, t, z, y]

Parameters* S - a list of infinitesimals* Y - the names of the dependent variables* X - the independent variables* functionality - optional, to request the functionality found in the labels of the left-hand-sides of equations in 'S'Description: GetInfinitesimals checks the syntax of a list of infinitesimals 'S' and either interrupts with an error message if there is something unepxected in it, or returns the given list unchanged when everything checks OK. When the option functionality is passed, the received list of infinitesimals is returned within a sequence of two elementes, where the second element is a list with the functionality of the functions found in the left-hand-sides of the received list of infinitesimals when they are given as equations [_xi[x](x,y,..) = ..., ], or the string "not present", when the infinitesimals were passed as a list of algebraic expressions, not equations.Example> PDEtools:-Library:-GetInfinitesimals([_xi[1](x,y,z,t,u[]) = 0, _xi[2](x,y,z,t,u[]) = 1, _xi[3](x,y,z,t,u[]) = 0, _xi[4](x,y,z,t,u[]) = 0, _eta[1](x,y,z,t,u[]) = 0], functionality); [_xi[1] = 0, _xi[2] = 1, _xi[3] = 0, _xi[4] = 0, _eta[1] = 0], [x, y, z, t, u[]]

Parameters* sys - an algebraic object or equation, or a set or list of them* F - a list of unknown functions defining the jet space* includeindependentvariables - optional, can be true (default) or false, to include the independent variables defining the jet space together with the dependent variables* applyToJet - optional, can be true or false (default), to apply 'ToJet' to 'sys' before proceedingDescription: GetJetVariables returns the jet variables found in sys, using jetnumbers notation, taking F as the dependent variables of the problem.Example> PDEtools:-Library:-GetJetVariables(diff(u(x,t),x,x)*x+diff(u(x,t),x), {u(x,t)}, applyToJet); {t, x, u[1], u[1, 1]}

GetNewDepAndIndepVars

GetNewDepAndIndepVars(NewVars,Y,X)

Parameters* newVars - a list of (new) unknown functions typically defininig a (new) jet space* Y - a list with the names of (old) unknown functions, typically defining an (old) jet space* X - a list with the names of (old) independent variablesDescription: GetNewDepAndIndepVars returns two lists with respectively the same number of elements and type as Y and X, typically representing new variables, or an error message when some inconsistency is detected.Example> PDEtools:-Library:-GetNewDepAndIndepVars([u(r,s), v(r,s)], [y, z], [x, t]); [u, v], [r, s]> PDEtools:-Library:-GetNewDepAndIndepVars([u(r,s)], [y, z], [x, t]); Error, (in PDEtools:-Library:-GetNewDepAndIndepVars) expected an indication of 2 new dependent variables, received a list with only 1> PDEtools:-Library:-GetNewDepAndIndepVars([u(r), v(r)], [y, z], [x, t]); Error, (in PDEtools:-Library:-GetNewDepAndIndepVars) expected to find at least 2 new independent variables in the dependency of the indicated new dependent variables, where there are only 1 independent variables

GetNew_Fn

GetNew_Fn(sol,PDE,sorted::truefalse := true)

Parameters* sol - an algebraic object or a set or list of them, typically representing the solution to a differential equation system* PDE - an algebraic object or a set or list of them, typically representing the system for which 'sol' is a solution* sorted - can be true (default value if not given) or false, to sort or not the output list before returning* applyToJet - optional, can be true or false (default), to apply 'ToJet' to 'sys' before proceedingDescription: GetNew_Fn returns the new _Fn arbitrary function's names entering sol and not found in PDE.Example> PDEtools:-Library:-GetNew_Fn(u(x,t) = Int((Int(_F1(x),x)+_F2(t))/x,x)+_F3(t), diff(u(x,t),x,x)*x+diff(u(x,t),x) = _F1(x)); [_F2, _F3]

Parameters* infinitesimal_generator - a list of infinitesimals or an infinitesimal generator operator* Y - list with the names of the dependent variables defining the jet space* X - list with the names of the independent variablesDescription: GetProlongationValue returns a nonegative integer representing the prolongation of the given infinitesimal.Example> PDEtools:-Library:-GetProlongationValue(f -> x*diff(f,x)+t*diff(f,t)+u*diff(f,u)-u[x,x]*diff(f,u[x,x]), [u], [x,t]); 2

GetRepeatedNames

GetRepeatedNames(Y)

Parameters* Y - a list with names, typically the names of functions defining a jet spaceDescription: GetRepeatedNames returns, in a set, the operands of Y that appear repeated.Example> PDEtools:-Library:-GetRepeatedNames([u, v, w, u]); {u}

Parameters* PDESYS - an algebraic object or equation, or a set or list of them, typically representing a differential equation system* DepVars - an unkonwn, or a set or list with the unknown functions of the problem* onlydifferentiatedfunctions - optional, can be true (default) or false, to include only the differentiated functions of PDESYS in the list of dependent variables within the sequence of objects returnedDescription: GetSysUFYX returns a sequence of five objects: PDESYS in diff format, the unknown functions in it, the dependent variables according to DepVars, their names, and a list with the independent variables.Example> PDEtools:-Library:-GetSysUFYX(diff(u(x,t),x,x)*x+diff(u(x,t),x) = F(x), u(x,t)); / 2 \ |d | /d \[|--- u(x, t)| x + |-- u(x, t)| - F(x)], {F(x), u(x, t)}, [u(x, t)], [u], [x, t] | 2 | \dx / \dx /

Parameters* object - an algebraic object or equation, or a set or list of them* other_unknowns - an algebraic object or equation, or a set or list of them* F - a set or list of unknown functions to be excluded in the output* dependencytype - optional, a type indicating the type of function to be testedDescription: GetUnknownsAndDependency checks syntax of unknowns in 'object' and the absence of conflicts with 'other_unknowns' - for example functions with the same name but different dependency - then returns a sequence with two elements: the unknowns in object and a list with all their dependency.Example> PDEtools:-Library:-GetUnknownsAndDependency(diff(u(x,t),x,x)*x+diff(v(x,t),x), {v(x,t)}, [u(x,t)]); {v(x, t)}, [x, t]

Parameters* SYS - an algebraic object or equation, or a set or list of them representing the system to be solved* _F_ - the unknowns of the problem, it could be a symbol, or a function or a set or list of them* explicitsolutions - optional, can be true (default) or false, to only return solutions when they are explicitDescription: Gsolve is the generic internal solver of the symmetry commands of the PDEtools package, and of the PDEtools:-Solve command. Gsolve automatically handles pdes, odes or algebraic equations; by default it only returns explicit solutions.Example> PDEtools:-Library:-Gsolve(a+b=c, b); {b = -a + c}> PDEtools:-Library:-Gsolve(diff(u(x,t),x,x)*x+diff(v(x,t),x), [u,v](x,t)); d / / -- v(x, t) | | dx {u(x, t) = | | - ---------- dx dx + _F1(t) x + _F2(t), v(x, t) = v(x, t)} | | x / /

Parameters* ee - an algebraic object or equation, or a set or list of them* DY - a derivative in jetnotation, or in function notation using diff, possibly of order zero (i.e. an unknown function), or set or list of them* F - a list of unknown functions defining a jet space, to be used when ee is passed in jet notation* gotofunctionnotation - optional, can be true (default) or false, to rewrite ee from jet notation to function notation before proceedingDescription: HasDerivatives returns true or false, according to whether derivatives of ee are derivatives of derivatives of DY.Example> PDEtools:-Library:-HasDerivatives(u[x,x,t]*x+u[x], diff(u(x,t), x,t)); true> PDEtools:-Library:-HasDerivatives(diff(u(x,t), x,x,t)*x + diff(u(x,t), x), diff(u(x,t), x,t)); true> PDEtools:-Library:-HasDerivatives(u[x,x,t]*x+u[x], u[t,x], u(x,t)); true> PDEtools:-Library:-HasDerivatives(u[x,x,t]*x+u[x], u[t,t], u(x,t)); false

Parameters* PDESYS - a set or list of algebraic expressions or equations* F - a set or list of unknownsDescription: IsAutonomousPDE returns true or false, according to whether PDESYS is autonomous; i.e. the independent variables in PDESYS appear only through the dependent variables.Example> PDEtools:-Library:-IsAutonomousPDE({diff(u(x,t),x,x) * x + diff(u(x,t),x)}, {u(x,t)}); false> PDEtools:-Library:-IsAutonomousPDE({diff(u(x,t),x,x) * u(x,t) + diff(u(x,t),x)}, {u(x,t)}); true

IsHigherDerivative

IsHigherDerivative(a,b,X := "not given")

Parameters* a - an indexed name where the index is a positive integer, typically representing a derivative in jetnumbers notation* b - same as aDescription: IsHigherDerivative returns true or false, according to whether `a` is a derivative of higher or equal order than `b`, where `a` and `b` are indexed objects typically representing derivatives in jet numbers notation.Example> PDEtools:-Library:-IsHigherDerivative(v[1,1,1], v[2,2]); true> PDEtools:-Library:-IsHigherDerivative(u[2,2], v[1,1,2]); false

IsLinearPDE

IsLinearPDE(PDESYS,F)

Parameters* PDESYS - a set or list of algebraic expressions or equations* F - an unknown, or a set or list of themDescription: IsLinearPDE returns true or false, according to whether PDESYS is linear in F and its derivatives.Example> PDEtools:-Library:-IsLinearPDE({diff(u(x,t),x,x) * x + diff(u(x,t),x)^2}, {u(x,t)}); true> PDEtools:-Library:-IsLinearPDE({diff(u(x,t),x,x) * u(x,t) + diff(u(x,t),x)}, {u(x,t)}); false

Parameters* sys1 - an algebraic object or equation, or a set or list of them, typically representing a differential equation system* sys2 - an equation, or a set or list of them, typically representing another differential equation system* F - a list with the unknown functions of the problem* rewriteinjetvariables - optional, can be true (default) or false, to rewrite sys1 and sys2 in jetvariables notation before proceeding* tryhasYshortcut - optional, can be true (default) or false, to check first whether sys1 and 'has' any of the function names of F, as a shortcut for 'false'Description: IsReducible returns true or false, according to whether any of the derivatives found in sys1 is reducible by any derivative found in left-hand-sides of sys2.Example> PDEtools:-Library:-IsReducible({u[x,x,t]*x+u[x]}, {u[x,t] = 0}, [u(x,t)]); true> PDEtools:-Library:-IsReducible({diff(u(x,t), x,x,t) * x + diff(u(x,t), x)}, {diff(u(x,t), x,t)=0}, [u(x,t)]); true> PDEtools:-Library:-IsReducible({diff(u(x,t), x,x,t) * x + diff(u(x,t), x)}, {diff(u(x,t), t,t)=0}, [u(x,t)]); false

Parameters* hinted_solution - a set of names or functions to be mapped into arbitrary constants and functions* forbbiden_symbols - any Maple object containing names not to enter the right-hand-sides of the returned equationsDescription: MapHintIntoPDESolution returns a set with equations where each name or function in hinted_solution is equated to an arbitrary constant or function as in - say - f into f, f() into _C1, and f(x) into _F1(x).Example> PDEtools:-Library:-MapHintIntoPDESolution({f, _xi[1](), _xi[2](), _eta[1](), _eta[2](x,y)}, [_C1, _F1]); {f = f, _xi[1]() = _C2, _xi[2]() = _C3, _eta[1]() = _C4, _eta[2](x, y) = _F2(x, y)}

Parameters* S - is a list of symmetry infinitesimals* F - a list of unknown functions defining the jet space* characteristicQ - optional, of type 'assignable', to be assigned the value of CharacteristicQ(S, F, ':-jetnotation' = ':-jetnumbers')Description: ProfitableSymmetry returns true or false, according to whether S is a profitable symmetry, i.e., one that can be used to diminish the number of independent variables. For Q = CharacteristicQ(S, F, ':-jetnotation' = ':-jetnumbers'), if any of the Q(j) (j=1..nops(F)) does not depend on derivatives of F, then the symmetry is not profitable. Equally, if a symmetry in evolutionary form does not depend on derivatives of F then it is not profitable.Example> PDEtools:-Library:-ProfitableSymmetry([t, 0, t*u[x]+u], [u(x,t)]); false> PDEtools:-Library:-ProfitableSymmetry([t, 1, t*u[x]+u], [u(x,t)]); true

Parameters* S - is a list of symmetry infinitesimals* F - a list of unknown functions defining the jet space* xi_eta = ... - optional, the right-hand-side is a list with two names to be used as roots of infinitesimal labels* jetnotation = ... - optional, default is notation found in S, can be any jet notation in use in PDEtools (see ?PDEtools:-ToJet)* prolongation = ... - optional, a positive integer indicating the prolongation order, default is the prolongation of SDescription: PutInfinitesimalLabels returns the given list of infinitesimals after transforming each infinitesimal into an equation, where the rhs is the infinitesimal itself and the lhs is an infinitesimal label identifying the infinitesimal.Example> PDEtools:-Library:-PutInfinitesimalLabels([t, 0, t*u[x]+u], [u(x,t)]); [_xi[x] = t, _xi[t] = 0, _eta[u] = t u[x] + u]

Parameters* L_Fn_Cn - a list of _Fn functions and/or _Cn constants, where n is an integer, introduced by pdsolve and dsolve in the solutions they return* SOL - a set or list of expressions or equations containing the elements of L_Fn_Cn, typically representing the solution of a differential equation system* allowzero - optional, can be true or false (default), to consider 'specializable' an object that, when specialized, it cancels other _Fn or _Cn objects in SOL, or perhaps cancels SOL entirelyDescription: SelectRemoveSpecializable_Fn_Cn returns two lists obtained splitting L_Fn_Cn into that can (first list) and cannot (second list) be specialized attributing value 0. A _Fn function or _Cn constant cannot be specialized when it leads to division by zero or its specialization automatically removes another _Cn or _Fn from 'SOL'.Example> SOL := u(x,t) = (x/_C1 + _C2*_F1(x+t))*_F2(t):> PDEtools:-Library:-SelectRemoveSpecializable_Fn_Cn([_C1, _C2, _F1, _F2], SOL); [], [_C1, _C2, _F1, _F2]> PDEtools:-Library:-SelectRemoveSpecializable_Fn_Cn([_C1, _C2, _F1, _F2], SOL, allowzero); [_C2, _F1, _F2], [_C1]

SortDerivatives

SortDerivatives(dY::list(indexed(posint)),Y::list(name))

Parameters* dY - a list of elements of type 'indexed(posint)' typically representing derivatives in jetnumbers notation* Y - a list of names, typically the names of the unknown functions defining the jet spaceDescription: SortDerivatives returns the list dY after sorting it, ascending with respect to differential order (number of indexes); if two derivatives are of the same order then sort and according to the order in the list Y, and if both derivatives are related to the same name in Y then sort according to the order of independent variables (for jet numbers that is equivalent to sort by `<`).Example> PDEtools:-Library:-SortDerivatives([v[2,2,3], u[1,2], v[1,2,3], v[1,1], v[]], [u, v]); [v[], u[1, 2], v[1, 1], v[1, 2, 3], v[2, 2, 3]]

Parameters* sol - an algebraic expression or equation, or a set or list of them, typically representing the solution of a differential equation system containing arbitrary constants _Cn introduced by dsolve* excluded - a set of _Cn constants to be excluded from the specialization process* allowzero - optional, can be true or false (default), to 'specialize' a _Cn even if, in doing so, it cancels the terms that contain other _Cn constantsDescription: Specialize_Cn returns a list of objects obtained specializing the _Cn not found in excluded, making all of them but one equal to zero, and the remaining one equal to 1. In addition, all _Cn that, when substituted by zero, produce division by zero, are also specialized to 1.Example> sol := u(x,t) = (x/_C1 + _C2 + _C3*(x + _C4)):> PDEtools:-Library:-Specialize_Cn(sol); u(x, t) = 2 x + 1, u(x, t) = 2 x + 1> PDEtools:-Library:-Specialize_Cn(sol, allowzero); u(x, t) = x + 1, u(x, t) = 2 x, u(x, t) = x

Parameters* SYS - an algebraic object or equation, or a set or list of them* F - optional - a list of unknown functions defining the jet space, if not given they are derived from SYS* X - optional - a list of independent variables, if not given it is derived from F* includingzeroderivatives - optional, can be true (default) or false, to include, in the second list in the output, the derivatives that are equal to zero, that are a consequence of having augmented the functionality of some of the functions of F* converttodiff - optional, can be true or false (default), to convert SYS to diff notation before proceedingDescription: ToSameVariables returns a sequence of three objects: SYS rewritten with all its functions depending on the same variables, then a list with the extra derivatives equal to zero implied by the conversion, and next another list of equivalences with the old and new functions respectively in the left and right hand sides.Example> PDEtools:-Library:-ToSameVariables(u(x)+v(t),[u(x), v(t)],[x, t]); d d u(x, t) + v(x, t), [-- u(x, t), -- v(x, t)], dt dx [u(x) = u(x, t), v(t) = v(x, t)]> PDEtools:-Library:-ToSameVariables(u(x)+v(t),[u(x), v(t)],[x, t], includingzeroderivatives = false); u(x, t) + v(x, t), [], [u(x) = u(x, t), v(t) = v(x, t)]

Parameters* PDESYS - a PDE system; it can contain PDEs, ODEs, and also non-differential equations* F - a list of the unknown functions of PDESYS* increasefornonautonomous - optional, can be true (default) or false, to increase the upper bounds by 1 in the presence of nonautonomous equations in PDESYSDescription: UpperBounds returns a sequence of sets of equations, where the lhs is a function of F and the rhs is an upper bound for the degree of a solution polynomial in the independent variables.Example> sys := diff(f(x,y),x)*diff(g(y),y) + diff(f(x,y),y)*diff(g(y),y) + f(x,y)*(diff(f(x,y),x,x) + diff(f(x,y),y,y)) = x*y:> PDEtools:-Library:-UpperBounds(sys, [f(x,y), g(y)]); {f(x, y) = 3, g(y) = 2}> PDEtools:-Library:-UpperBounds(sys, [f(x,y), g(y)], increasefornonautonomous = false); {f(x, y) = 2, g(y) = 1}

YBracketsToY

YBracketsToY(ans,Y)

Parameters* ans - an algebraic expression, equation, or a set or list of them* Y - a list with the names, typically the names of the unknown functions definining a jet spaceDescription: YBracketsToY returns ans after replacing objects of the form y[] by y, where y is a member of Y.Example> PDEtools:-Library:-YBracketsToY(f[]*g[]+f[y]*g[]+f[]*(f[x,x]+f[y,y]), [f, g]); f g + f[y] g + f (f[x, x] + f[y, y])

YToYBrackets

YToYBrackets(ans,Y)

Parameters* ans - an algebraic expression, equation, or a set or list of them* Y - a list with the names, typically the names of the unknown functions definining a jet spaceDescription: YBracketsToY returns ans after replacing objects of the form y by y[], where y is a member of Y.Example> PDEtools:-Library:-YToYBrackets(f*g+f[y]*g+f*(f[x,x]+f[y,y]), [f, g]); f[] g[] + f[y] g[] + f[] (f[x, x] + f[y, y])