PDEtools に一覧された外部コマンドが使用する内部ルーチンである PDEtools のほとんどは、外部のコマンドとして、PDEtools:-Library:-Routine という形式を通じて使用することもできます。これらのルーチンを使用すると、すべてを一からリライトする必要がないため、ユーザーが独自に PDEtools を拡張してプログラミングする場合や、さまざまな一般の微分方程式をプログラミングする場合に便利です。この意味で、これら Library Routines は主にプログラマーに有益ですが、そのうちの CloseSystem や ContactCondition などのいくつかのルーチンは微分方程式用のコマンドとして使用することもできます。

これらの Library 読み取り可能プログラミングツールには個別のヘルプページは用意されていませんが、Describe コマンドを使用してこれらの使用法の簡単な説明を表示するには、最初に with(PDEtools:-Library) と入力してから Describe(PDEtools:-Library:-Routine) か、省略形の Describe(Routine) と入力すると画面に説明が表示されます。下記に、Library ルーチンをアルファベット順にした一覧を表示します。それぞれがこのページ内の各セクションにリンクしています。それぞれのリンク先には Describe(Routine) と同じ情報が記載されています。

ルーチンをアルファベット順にした一覧は以下のようになります。

Describe(PDEtools:-Library:-AbstractedFunction);

# abstracts an algebraic object into a function chi[j](...), of the names found in object that are members of YX
#
AbstractedFunction( object, chi, j, YX, Y,
                    { inallcases::truefalse := false } )

Describe(PDEtools:-Library:-AssignFromINFO);

# assigns to A the value of INFO["A"] for some given A and INFO; interrupts with error when INFO["A"] is not assigned
#
AssignFromINFO( INFO, Vars )

Describe(PDEtools:-Library:-AssignToINFO);

# assigns INFO["A"] := eval(A) for a sequence of given (may be assigned) names and a given table name - say INFO
#
AssignToINFO( INFO, Vars::uneval )

Describe(PDEtools:-Library:-BuildPolynomialHint);

# Input: F is a list of dependent variables, PDESYS is the system to be solved, v is a name to be used as in v[n] to represent coefficients of powers of the variables of each function in F
# Output: a sequence of equations, with a function in the lhs and a hint that is polynomial in the variables of that function and has undetermined coefficients v[n]
#
BuildPolynomialHint( PDESYS, F::list, v::{list(name), identical("not given")} := "not given",
                     { degree := "not given", dependency::{list(name), identical("not given")} := "not given", donotusethesesymbols := {}, ivars::{list(name), set(name)} := {}, undeterminedcoefficients::{string, assignable, identical("not given")} := "not given", v_indexshift::nonnegint := 0 }, $ )

Describe(PDEtools:-Library:-ChooseSimilarityVariables);

# Input:  sv is a list of candidates for dependent similarity variables, TY is the similarity transformation for the dependent variables (old to new) and TX is the one for the independent variables; nY is the number of dependent variables and itr is the complete inverse transformation (new to old). Task: to choose which ones, among sv, will be the new nY dependent similarity variables
# Output: a set with the optimal choice for dependent similarity variables
#
ChooseSimilarityVariables( sv, TY, TX, nY, itr, recursing := false )

Describe(PDEtools:-Library:-CloseSystem);

# Input: a DE system, SYS, for the list of unknowns F
# Output: an equivalent DE system, that has only and the same solutions as SYS, that includes all the integrability conditions explicited. To close a system is necessary when computing a determining system for its symmetries in order to get *all* of them
#
CloseSystem( SYS, F::list, X := GetIndepVars(F),
             { DepVars_ranking::list := "not given", IndepVars_ranking::list := "not given", avoidfirstround::truefalse := false } )

Describe(PDEtools:-Library:-CompatibleOptions);

# returns the options that are compatible with a given 'command', from an arbitrary sequence of keyword options
#
CompatibleOptions( command,
                   { exceptions::set(name) := {} } )

Describe(PDEtools:-Library:-ContactCondition);

# Input: the infinitesimals xi and eta as lists ordered according the the order of dependent and independent variables found in the list F, or tables indexed numerically with that ordering, and the unknowns of the problem F as a list
# Output: a sequence of equations representing the conditions for [xi, eta] to be a contact symmetry
#
ContactCondition( xi, eta, F, Y := map2(op,0,F), X := GetIndepVars(F), nY := nops(Y) )

Describe(PDEtools:-Library:-Degree);

# computes the maximum degree of a set of equations with respect to given variables X - one or a set of them
#
Degree( EE, X )

Describe(PDEtools:-Library:-DifforderJet);

# computes the (minimal or maximal) differential order of ee_J (in jet notation) with respect to each of the unknowns (F) of the system
#
DifforderJet( ee_J, F,
              { derivatives_J::{set(indexed), identical("not given")} := "not given", ivars::{name, set(name), identical("with respect to each of them","not given")} := "not given", minmax::identical(min,max) := 'max', totaldifforder::truefalse := false } )

Describe(PDEtools:-Library:-FromJetNumbersToJetVariables);

# Input: an expression expr and the unknowns of the problem F
# Output: expr after replacing jet numbers 1, 2, ... by the corresponding jet variables x, y, ... according to the order implicit in F
#
FromJetNumbersToJetVariables( expr, F )

Describe(PDEtools:-Library:-FromJetVariablesToJetNumbers);

# Input: an expression expr and the unknowns of the problem F
# Output: expr after replacing jetvariables x, y, ... u, v by the corresponding jet numbers according to the order implicit in F
#
FromJetVariablesToJetNumbers( expr, F )

Describe(PDEtools:-Library:-GetCoefficients);

# Input: sys is a system of algebraic expressions, vars is a set or list of algebraic objects, typically names
# Output: a set with the coefficients of vars and mathematical objects that have vars found in sys
#
GetCoefficients( sys, vars,
                 { undeterminedcoefficients := "not given" } )

Describe(PDEtools:-Library:-GetDepVars);

# checks for anomalies 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 and only returns the functions actually found in PDEsys
#
GetDepVars( DepVars, PDESYS::{identical("not given"), {`<>`, `=`, algebraic, And(Or(set({`<>`, `=`, algebraic}),list({`<>`, `=`, algebraic})),satisfies(SL -> evalb(0 < nops(SL))))}} := "not given",
            { dependency_type::anything := `PDEtools/F(...)`, onlydifferentiatedfunctions::truefalse := true } )

Describe(PDEtools:-Library:-GetDependency);

# Input: dependency, as an abstract indication of dependency (see option in ?PDEtools:-DeterminingPDE), the system PDESYS and an indication of dependent variables DepVars
# Output: a list of lists with the explicit form of the dependency indicated
#
GetDependency( dependency, PDESYS, DepVars,
               { groupedbynumberofvariables::truefalse := false, onlydifferentiatedfunctions::truefalse := true, sortedbyascendingnumberofvariables::truefalse := FAIL, vars::list(name) := "not given" } )

Describe(PDEtools:-Library:-GetExplicitSolutions);

# given a solution or a set or list of them, returns only those solutions that are explicit
#
GetExplicitSolutions( F )

Describe(PDEtools:-Library:-GetFAndDiffVars);

# receives a derivative and returns a sequence: the derivand followed by all the differentiation variables
#
GetFAndDiffVars( f )

Describe(PDEtools:-Library:-GetFunctionsWithDifferentDependency);

# funcs_0 is a list of function names positionally corresponding to the functions found in funcs; this routine returns the functions in funcs that have the same name but different functionality
#
GetFunctionsWithDifferentDependency( funcs_0, funcs )

Describe(PDEtools:-Library:-GetIndepVars);

# returns the variables of type name found in F, typically representing independent variables, after removing repeated elements
#
GetIndepVars( F )

Describe(PDEtools:-Library:-GetInfinitesimals);

# checks syntax of given list of infinitesimals and returns them, optionally with the functionality of the functions found in the lhs when they are given as equations [xi(x,y,..) = ..., ]
#
GetInfinitesimals( S::list,
                   { functionality::truefalse := false } )

Describe(PDEtools:-Library:-GetJetVariables);

# returns the jet variables found in sys taking F as the dependent variables of the problem
#
GetJetVariables( sys, F,
                 { all::truefalse := true, applyToJet::truefalse := false } )

Describe(PDEtools:-Library:-GetNewDepAndIndepVars);

# Input: newVars::list(`F(...)`), Y::list(name) and X::list(name), where Y and X respectively typically represent the names of dependent and independent old variables
# Output: two lists with respetively the same number of elements and type as Y and X, typically representing new variables
#
GetNewDepAndIndepVars( NewVars, Y, X )

Describe(PDEtools:-Library:-GetPDESYS);

# returns a list with the input system after removing repeated elements, optionally mapping `=` into lhs-rhs
#
GetPDESYS( PDESYS,
           { equation_to_algebraic::truefalse := true, notation::Or("as given",And(symbol,satisfies(s -> member(cat(s),'{:-D, :-diff}')))) := :-diff } )

Describe(PDEtools:-Library:-GetRepeatedNames);

# returns, in a set, the operands of funcs_0 (that is typically a list of function names) that appear repeated
#
GetRepeatedNames( funcs_0 )

Describe(PDEtools:-Library:-GetSysUFYX);

# returns a sequence of five objects: PDESYS in diff format, the functions in it, the dependent variables, the names of them and a list of the independent variables
#
GetSysUFYX( PDESYS, DepVars,
            { dependency_type::anything := `PDEtools/F(...)`, onlydifferentiatedfunctions::truefalse := true } )

Describe(PDEtools:-Library:-GetUnknownsAndDependency);

# checks syntax of unknowns in 'object' and absence of conflicts with 'other_unknowns', then returns a sequence of two objects: the unknowns in the given system and a list with all their dependency
#
GetUnknownsAndDependency( object, other_unknowns, F, Y := map2(op,0,F),
                          { dependency_type::anything := `PDEtools/F(...)`, kind_of_object::{string, symbol} := "received object" } )

Describe(PDEtools:-Library:-Gsolve);

# generic solver of the PDEtools package, automatically handles pdes, odes or algebraic equations; by default only returns explicit solutions
#
Gsolve( SYS, _F_,
        { derivatives::{set, identical("not given")} := "not given", explicitsolutions::truefalse := true, solver::identical("not given",pdsolve,dsolve,`ODEtools/Solve/EnvDropMultiplicity`,:-solve,`ODEtools/Solve`,InvariantSolutions,SimilaritySolutions,PolynomialSolutions) := "not given" } )

Describe(PDEtools:-Library:-HasDependency);

# returns true or false, according to whether sol of type `=` has the dependency indicated in DEP, a set or list of names
#
HasDependency( sol::`=`, DEP::{list(name), set(name)} )

Describe(PDEtools:-Library:-HasDerivatives);

# returns true or false, according to whether ee has or not derivatives of F
#
HasDerivatives( ee, DY, F := NULL,
                { derivatives_ee::{set(specfunc(anything,diff)), identical(NULL)} := NULL, gotofunctionnotation::truefalse := true } )

Describe(PDEtools:-Library:-HasHigherDerivatives);

# returns true or false, according to whether `a` has higher derivatives than `b`, where `a` and `b` are sets of derivatives in jet notation
#
HasHigherDerivatives( a, b )

Describe(PDEtools:-Library:-HideFalseDerivatives);

# returns a sequence of two objects: sys after hiding in it the false derivatives (DESol, ODESolStruc and PDESolStruc) and the equations to use to restore them
#
HideFalseDerivatives( sys )

Describe(PDEtools:-Library:-IsAutonomousPDE);

# Input: PDESYS and F are the system and the unknowns
# Output: true or false, according to whether PDESYS is autonomous; i.e. the independent variables in PDESYS appear only through the dependent variables
#
IsAutonomousPDE( PDESYS, F )

Describe(PDEtools:-Library:-IsLinearPDE);

# Input: PDESYS and F are the system and the unknowns
# Output: true or false, according to whether PDESYS is linear in F and its derivatives
#
IsLinearPDE( PDESYS, F )

Describe(PDEtools:-Library:-IsPointSymmetry);

# returns true or false, according to whether S is a list of point symmetry infinitesimals taking F as the unknowns of the problem
#
IsPointSymmetry( S, F::list(`PDEtools/F(...)`), Y := map2(op,0,F) )

Describe(PDEtools:-Library:-MapHintIntoPDESolution);

# Input: some hinted solution, as a set of names or functions, and any Maple object containing symbols not to be introduced in the solution
# Output: a set, with a PDE solution constructed mapping - say - a into a, f() into _C1, and f(x) into _F1(x).
#
MapHintIntoPDESolution( hinted_solution::set({name, function}), forbbiden_symbols )

Describe(PDEtools:-Library:-Normalize_Fn_Cn);

# Input: sol = a list of objects where _Fn and _Cn are to be renumbered as low as possible and in sequence
# Output: op(sol2) where sol2 is sol after renumbering the _Cn and _Fn. If nothing is to be done, sol2 = sol.
#
Normalize_Fn_Cn( sol::{list, set},
                 { ignore_Cn::truefalse := false, ignore_Fn::truefalse := false, set_F_C_in_use::truefalse := true, symbolsininput::set(symbol) := "not given", symbolsinsol::set(symbol) := "not given", update_Cn::truefalse := true, update_Fn::truefalse := true } )

Describe(PDEtools:-Library:-PartialDerivatives);

# Input: a function name F0, and a list of numbers dx_diff_order representing differential order with respect to each independent variable, optionally specifies maxdifforder = M, a positive integer, the maximum differential order with respect to all the variables, expected in the output
# Output: a sequence of of F0[n, m, ...], representing derivatives in jet notation, where n, m, ... are not bigger than the differential orders specified in dx_diff_order, and the total differential order is not bigger than the optionally specified maxdifforder
#
PartialDerivatives( F0, dx_difforder,
                    { maxdifforder::nonnegint := NULL } )

Describe(PDEtools:-Library:-ProfitableSymmetry);

# Input: S is a list of infinitesimals, F are the dependent variables, Y (optional) is a list with the names of the functions in F
# Output: 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
#
ProfitableSymmetry( S, F, Y::list(name) := map2(op,0,F), nY::posint := nops(Y),
                    { characteristicQ::assignable := NULL } )

Describe(PDEtools:-Library:-RecycleArguments);

# Input: 'arguments' is a list of selected arguments received by 'command' to be matched against the keywords of 'command'; 'argspassed' is a list with all the arguments passed to 'command
# Output: a list where the matched arguments were replaced by the correct match of optional keywords of 'command', or a set of many options when there is more than one match, or an error when there is no match
#
RecycleArguments( arguments::list, command, argspassed::list )

Describe(PDEtools:-Library:-SelectRemoveSpecializable_Fn_Cn);

# Input: L_Fn_Cn is a list of _Fn_Cn and SOL is a set of solutions
# Output: two lists obtained splitting L_Fn_Cn into that can (first list) and cannot (second list) be specialed attributing values 0 and 1
#
SelectRemoveSpecializable_Fn_Cn( L_Fn_Cn::list, SOL,
                                 { allowzero::truefalse := false } )

Describe(PDEtools:-Library:-Specialize\_Cn);

# Input: sol is a Maple object involving _Cn that are not found in excluded (a set or list of _Cn)Output: 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
#
Specialize_Cn( sol, excluded::{list(And(symbol,suffixed(_C,nonnegint))), set(And(symbol,suffixed(_C,nonnegint)))} := {},
               { allowzero::truefalse := false } )

Describe(PDEtools:-Library:-Specialize_Fn);

# Input: sol is a Maple object involving _Fn(...) functions whose names are not found in excluded (a set or list of _Fn)Output: a list of objects obtained specializing the _Fn(...) not found in excluded, making all of them but one equal to zero, and the remaining one equal to each of its arguments
#
Specialize_Fn( sol, excluded::{list(And(symbol,suffixed(_F,nonnegint))), set(And(symbol,suffixed(_F,nonnegint)))} := {},
               { allowzero::truefalse := false, specializations::{list(procedure), set(procedure), identical("not given")} := "not given" } )

Describe(PDEtools:-Library:-UpperBounds);

# Input: a PDE system PDESYS and a list of dependent variables F
# Output: 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
#
UpperBounds( PDESYS, F,
             { X::list(name) := GetIndepVars(F) } )

Describe(PDEtools:-Library:-YBracketsToY);

# Input: ans is an expression, equation, or a set or list of them; Y is a list of names
# Output: ans after replacying objects of the form y[] by y, where y is a member of Y
#
YBracketsToY( ans, Y )

Describe(PDEtools:-Library:-YToYBrackets);

# Input: ans is an expression, equation, or a set or list of them; Y is a list of names
# Output: ans after replacying objects of the form y by y[], where y is a member of Y
#
YToYBrackets( ans, Y )