|  |  D.15.12.27 difformListSort Procedure from librarydifform.lib(see  difform_lib).
 
Example:Return:
the sorted list L in ascending order, depending on the optional monomial ordering given
Remarks:
Classical insertion sort is used to sort the list
Note:
- the procedure uses difformIsBigger to compare list elements, therefore
an optional ordering is defined via the pattern in difformIsBigger
- the standard ordering is the ordering on the differential algebra
- the procedure can also handle special lists of lists by using the optional input
"Dlist" or "Llist":
- "Dlist" is used for lists with structure:
 L[1] is a list of differential forms
 L[2] is a list of polynomials of same size,
 The list gets sorted by the elements in L[1]. This is mainly used for the
structure of derivations.
 - "Llist" allows the structure: L[i] is a list with two entries:
L[i][1] is a differential form
 L[i][2] is a polynomial
 The list gets sorted by the elements L[i][1]. This is used to sort
coefficient lists.
 
 See also:
 difformIsBigger;
 difformIsSmaller.|  | LIB "difform.lib";
ring R = 0,(x,y,z,t),dp;
diffAlgebra();
==> // The differential algebra Omega_R was constructed and the differential \
   forms dDx, dDy, dDz, dDt, dx, dy, dz, dt are available.
/////////////////////////
// Sortation of a list //
/////////////////////////
list L = dx*x, x2 - y*t, 12, dt*dy*dx*dz;
// Sort list with standard ordering
difformListSort(L);
==> [1]:
==>    12
==> 
==> [2]:
==>    x2-yt
==> 
==> [3]:
==>    x*dx
==> 
==> [4]:
==>    dx*dy*dz*dt
==> 
// Sort list with changed ordering
difformListSort(L,"gen","ls","ringvar","wp",intvec(-1,1,1,1));
==> [1]:
==>    dx*dy*dz*dt
==> 
==> [2]:
==>    x*dx
==> 
==> [3]:
==>    12
==> 
==> [4]:
==>    x2-yt
==> 
/////////////////////////////////////////////
// Sortation of list with structure "Dlist" //
/////////////////////////////////////////////
list DL;
DL[1] = list(dx,x,t,dt); DL[2] = list(y,t*z,4,x);
// This list has the structure described by "Dlist"
difformListSort(DL,"Dlist","ringvar","ls");
==> [1]:
==>    [1]:
==>       x
==> 
==>    [2]:
==>       t
==> 
==>    [3]:
==>       dt
==> 
==>    [4]:
==>       dx
==> 
==> [2]:
==>    [1]:
==>       zt
==>    [2]:
==>       4
==>    [3]:
==>       x
==>    [4]:
==>       y
/////////////////////////////////////////////
// Sortation of list with structure "Llist" //
/////////////////////////////////////////////
list LL;
LL[1] = list(dx,x); LL[2] = list(t*dt,y); LL[3] = list(x,2);
// This list has the structure described by "Llist"
difformListSort(LL,"Llist");
==> [1]:
==>    [1]:
==>       x
==> 
==>    [2]:
==>       2
==> [2]:
==>    [1]:
==>       t*dt
==> 
==>    [2]:
==>       y
==> [3]:
==>    [1]:
==>       dx
==> 
==>    [2]:
==>       x
kill Omega_R,dx,dy,dz,dt,L,DL,LL;
 | 
 
 |