Check-ins Using Download Hex

Artifact 6d33de23bb923cc4f4bc0c1b0794ae07b4d6113d829e9895784e1974dd1edbd3:

%*******************************************************************%
%                                                                   %
%                       C R A C K . T S T                           %
%                       -----------------                           %
%  crack.tst contains test examples for the program crack.red.      %
%                                                                   %
%  Author of this file: Thomas Wolf                                 %
%  Date:  11. Sep 1998, 6. May 2003                                 %
%                                                                   %
%  Details about the syntax of crack.red are given in crack.tex.    %
%                                                                   %
%  To run this demo you need to load crack through:                 %
%     load crack$                                                   %
%  and to read in this file as                                      %
%     in "crack.tst";                                               %
%  If you got the source code of a newer version of crack then      %
%  either read it in through                                        %
%     in "crack.red"$                                               %
%  (with the appropriate directory name in front of crack.red)      %
%  or, to speed up the calculation, you compile before with         %
%     faslout "crack"$                                              %
%     in "crack.red"$                                               %
%     faslend$                                                      %
%  and then load it with                                            %
%     load crack$                                                   %
%                                                                   %
%*******************************************************************%

lisp(depl!*:=nil)$           % clearing of all dependencies
setcrackflags()$             % use standart flag-setting
%lisp(print_:=50)$           % if one would want to print expressions 
                             % with up to 50 factors
lisp(print_:=nil)$           % to suppress printing the computation
lisp(initial_proc_list_ :=   % initial_proc_list_ is saved for an 
     proc_list_)$            % application at the end
on dfprint$                  % to print partial deriv. as indices
%off batch_mode$
comment 
-------------------------------------------------------

                     Modules in CRACK 

The following examples illustrate the operation of various
modules of CRACK. These examples are not typical applications
but are chosen to demonstrate individual CRACK modules. 
To see typical applications of CRACK run LIEPDE.TST,
CONLAW.TST or APPLYSYM.TST instead.

The extra assignments in this run that involve proc_list_ 
are to disable all other modules and to demonstrate better 
the action of the individual module. 

-------------------------------------------------------

             Format of the return of CRACK

CRACK returns a list {sol_1,...} of one or more solutions
where each solution is a list:
{ list_of_remaining_unsolved_equations,
  list_of_computed_values_of_functions_or_constants,
  list_of_free_functions_or_constants,
  list_of_inequalities_valid_for_this_solution }
Empty lists are {}.

=======================================================;

write"        Integration: Integrating exact PDEs "$comment

An important part of CRACK are integration routines 
which  employ a number of different techniques which 
are demonstrated next. At first an example for the
integration of exact PDE;

depend f,x,y$
depend g,x$

de:=2*df(f,y)*df(g,x) + 2*df(f,x,y)*g + g*df(g,x)**3 + 
    x*df(g,x)**4 + 3*x*g*df(g,x)**2*df(g,x,2)$ 

lisp(proc_list_ := '(integration))$
crack({de},{},{f,g},{});

write"-------------------------------------------------------"$ 

write"  Integration: Integration of an exact PDE + terms "$
write"               which are not exact (are not a total "$
write"               derivative) but which only involve "$
write"               unknown functions of fewer variables"$ comment

The price of integrating non-exact expressions will be 
the introduction of extra conditions but in fewer variables 
than the integrated PDE has. A special algorithm minimizes
the number of new functions of fewer variables to be   
introduced. The bracket below is a polynomial in the   
integration variable x, as a consequence the algorithm 
is applicable such that only one extra function has to be 
introduced. $

de:=de + g^2*(y^2 + x*sin y + x^2*exp y)$

crack({de},{},{f,g},{});
nodepnd {f,g}$

write"-------------------------------------------------------"$

write"          Integration: Integrating Factors"$ comment

Heuristics for the determination of integrating factors
in CRACK are not rigorous but often useful. $

depend f,x,y$

g:=df(f,x)/e**x+df(f,y)/x**2$

crack({num(df(g,x))},{},{f},{});

clear g$
nodepnd {f}$

write"-------------------------------------------------------"$

write"     Integration: Recognizing a 2-dim divergence"$ comment

Being able to recognize a structure 0=df(a,x)+df(b,y)
where a,b are differential expressions is of benefit
if a,b can both be solved for a unknown function as
in the following example. $

lisp(proc_list_ := '(subst_level_4 integration))$

depend f,x,y$
depend g,x,y$
depend h,x,y$

a:=x*f+y*df(g,y)$
b:=df(g,x,y)*sin(x)+h/y$

crack({df(a,x)+df(b,y)},{},{f,g,h},{});

nodepnd {f,g,h}$

write"-------------------------------------------------------"$

write"      Integration: Solving ODEs for partial derivatives"$ comment

In CRACK ODEs and PDEs which are ODEs for a single partial
derivative are investigated by the program ODESOLVE by
MacCallum/Wright. In the following example this technique
together with a previous one are successful. $

depend f,x,y$
lisp(proc_list_ := '(subst_level_4 integration))$

crack({x**2*df(f,x,2,y)-2*x*df(f,x,y)-df(f,y)+x**3/y**2},
      {},{f},{});

nodepnd {f}$

write"======================================================="$

write"       Separation: Direct separation of PDEs"$ comment

Another important group of modules concerns separations.
In this example z is an extra independent variable on which
f and g do not depend (therefore z is in the 4th argument 
to crack). There is furthermore a function h=h(z) which
is assumed to be given and is not to be calculated as it
is not element of the third argument to CRACK, i.e. the 
question is to find expressions for f,g for arbitrary h. 
In the computation below, h is treated as being linear 
independent from z because h is declared as arbitrary. 
If h would be added to the list {f,g} then h would have 
to be computed and direct separation would not be possible 
but only indirect separation (see next example). $

depend f,x$
depend g,y$
depend h,z$
de:=z*f + h*y*g$
lisp(proc_list_ := '(subst_level_4 separation))$
crack({de},{},{f,g},{z});
nodepnd {f,g,h}$

write"-------------------------------------------------------"$

write"       Separation: Indirect separation of PDEs"$
write"                   (combined with integration)"$ comment

This example is the same as before, only now h is not assumed
to be given but to be calculated. In this example there is no 
variable turning up only explicitly to allow a direct separation. 
But there is also no function which depends on all variables 
and this allows the use of an indirect separation method. This 
example also demonstrates factorization and the splitting 
into subcases to do substitutions in non-linear problems.  
Three solutions result, 
1. f=h=0, g arbitrary, 
2. f,g,h given in terms of two constants, both non-vanishing
3. f=g=0, h arbitrary, h non-vanishing. $

depend f,y$
depend g,x$
depend h,z$
de:=z*f + h*y*g$
lisp(proc_list_ := '(subst_level_3 separation
                     gen_separation alg_solve_single))$
crack({de},{},{f,g,h},{});
nodepnd {f,g,h}$

write"======================================================="$

write"    Combination: Pseudo Differential Groebner Basis"$ comment

Another group of modules tries to take advantage of 
combining equations or their derivatives. The main tool
in this respect computes a Pseudo Differential Groebner
Basis. In interactive mode (off batch_mode) it is possible
to choose between different orderings of derivatives which
is not demonstrated here. (The origin of the following 
example is described at the end of this file.) ;

depend xi ,x,y$
depend eta,x,y$
lisp(proc_list_ := '(separation decoupling))$ 

crack({2*df(eta,x,y)*x**5*y1
       + df(eta,x,2)*x**5 - df(eta,x)*x**4 
       - 2*df(eta,x)*x**2*y + df(eta,y,2)*x**5*y1**2 
       - 4*df(eta,y)*x*y**2 - 2*df(xi,x,y)*x**5*y1**2
       - df(xi,x,2)*x**5*y1 - df(xi,x)*x**4*y1
       - 2*df(xi,x)*x**2*y*y1 
       + 8*df(xi,x)*x*y**2 - df(xi,y,2)*x**5*y1**3 
       - 2*df(xi,y)*x**4*y1**2 - 4*df(xi,y)*x**2*y*y1**2 
       + 12*df(xi,y)*x*y**2*y1 - 2*eta*x**2*y1 + 8*eta*x*y 
       + x**3*xi*y1 + 6*x*xi*y*y1 - 16*xi*y**2},
      {},{eta,xi},{x,y,y1});

nodepnd {xi,eta}$

write"-------------------------------------------------------"$

write"      Combination: Shortening linear PDE systems"$ comment

To reduce memory requirements now and for further
computations with a system of equations it is advisable
to find length reducing linear combinations. The shorther
equations become, the more useful they are to shorten
other equations and the more likely they are integrable.;

depend f,x,y$
a:=sin(x)*y+7*x+3*df(f,x)$
b:=df(f,y)*y+f*x+x*y**2$
c:=3*x*y**2+sin(x)*y-4$
lisp(proc_list_ := '(alg_length_reduction))$

crack({a,a*c+b},{},{f},{});
clear a,b,c$
nodepnd {f}$

write"======================================================="$

write"  Parametric solution of linear underdetermined ODEs"$ comment

The following example demonstrates an algorithm for the
parametric solution of underdetermined linear ODEs with
arbitrary non-constant cefficients. $

depend f,x$
depend g,x$
lisp(proc_list_ := '(subst_level_4 undetlinode))$
crack({cos(x)*df(f,x,2) - df(g,x,2)},{},{f,g},{});
nodepnd {f,g}$

write"======================================================="$

write"Application: Investigating point symmetries of an ODE"$ comment

Finally a  small real life example that demonstrates
the interplay of different modules to solve completely
an overdetermined system which is generated when  
investigating the point symmetries of the ODE 6.97
in Kamke's book using the following CRACK input:  $

% depend y,x$
% load_package crack,liepde$
% liepde({{df(y,x,2)*x**4-df(y,x)*(2*x*y+x**3)+4*y**2},{y},{x}},
%        {"point"},{})$ 

comment 
(and renaming xi_x --> xi, eta_y --> eta, y!`1 --> y1
which is only done to ease reading). Instead of just 
doing this liepde-call which would take care of 
everything, we call crack below explicitly for 
demonstration. Two arbitrary constants in the solution 
stand for two symmetries. $

depend xi ,x,y$
depend eta,x,y$
lisp(proc_list_ := initial_proc_list_)$   % this was saved at the start

crack({2*df(eta,x,y)*x**5*y1
       + df(eta,x,2)*x**5 - df(eta,x)*x**4 
       - 2*df(eta,x)*x**2*y + df(eta,y,2)*x**5*y1**2 
       - 4*df(eta,y)*x*y**2 - 2*df(xi,x,y)*x**5*y1**2
       - df(xi,x,2)*x**5*y1 - df(xi,x)*x**4*y1
       - 2*df(xi,x)*x**2*y*y1 
       + 8*df(xi,x)*x*y**2 - df(xi,y,2)*x**5*y1**3 
       - 2*df(xi,y)*x**4*y1**2 - 4*df(xi,y)*x**2*y*y1**2 
       + 12*df(xi,y)*x*y**2*y1 - 2*eta*x**2*y1 + 8*eta*x*y 
       + x**3*xi*y1 + 6*x*xi*y*y1 - 16*xi*y**2},
      {},{xi,eta},{x,y,y1});

nodepnd {xi,eta}$

write"======================================================="$

write"  Integration: Solving a linear 1st order PDE"$ comment

If the computation of a differential Groebner Basis is getting
bigger and bigger and normal integration is not successful and
also no functions of fewer variables are present then trying
the solution of a 1st order linear PDE is recommended. $

lisp(proc_list_ := '(subst_level_4 full_integration 
                     gen_separation find_trafo))$
depend f,x,y;
crack({df(f,x)-x**2*y*df(f,y)+x},{},{f},{});
write "The list of transformations done (here only one): ",
      lisp done_trafo;

nodepnd {f}$

write"======================================================="$

lisp(depl!*:=nil)$ % to delete all dependencies of functions on variables

end$
REDUCE Historical
[ REDUCE Sourceforge Project | Historical SVN Repository | GitHub Mirror | SourceHut Mirror | NotABug Mirror | Chisel Mirror | Chisel RSS ]