# Singular

#### D.15.12.29 difformListSort

Procedure from library `difform.lib` (see difform_lib).

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.

Example:
 ```LIB "difform.lib"; ring R = 0,(x,y,z,t),dp; diffAlgebra(); ==> // The differential algebra Omega_R was constructed and the differential \ forms 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 strcture "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 strcture "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; ```