proc ZSF (matrix A)
"USAGE:      ZSF(A);  A matrix
RETURN:      matrix,  A in reduzierter Zeilen-Stufen-Form
KEYWORDS:    Gauss Elimination, Zeilen-Stufen-Form
EXAMPLE:     example ZSF;   zeigt ein Beispiel"
{
  int m=nrows(A);   // Anzahl der Zeilen
  int n=ncols(A);   // Anzahl der Spalten
  int z=1;          // Zeilenlaufindex fuer die Pivotelementsuche
  // 1. SCHRITT: Wieviele Zeilen hat A
  if (m>1)
  {
    // 2. SCHRITT: 
    // Suche ein Element der ersten Spalte, das nicht Null ist,
    // und merke Dir die Zeile in der Variablen z.
    // Brich die Suche ab, wenn die m-te Zeile erreicht ist.
    while ((z<m) and (A[z,1]==0)) 
    { 
      z=z+1; 
    }
    // 3. SCHRITT:  
    // Falls die Suche erfolgreich war ...
    if (A[z,1]!=0)
    {
      // ... vertausche die 1. und die z-te Zeile, ...
      A=zeilentausch(A,1,z);
      // 4. SCHRITT:
      // ... und reduziere die 2. bis m-te Zeile mit der ersten.
      for (int k=2;k<=m;k++) 
      {   
        // Addiere das -A[k,1]/A[1,1]-fache der ersten Zeile zur k-ten.
        A=zeilenaddition(A,1,k,-A[k,1]/A[1,1]);
      }
    } 
    // Falls A nur  Spalte hatte, sind wir fertig, sonst ....
    if (n>1)
    { 
      // 5.+7. SCHRITT:
      // ... fuehre die Prozedur mit der Matrix aus, die entsteht, wenn wir
      // die erste Zeile und die erste Spalte streichen, sofern die erste Spalte 
      // nicht komplett Null war, ...
      if (A[1,1]!=0)
      { 
        matrix B[m-1][n-1]=A[2..m,2..n]; 
        A[2..m,2..n]=ZSF(B);       
      }
      // 6.+7. SCHRITT:
      // ... und fuehre die Prozedur mit der Matrix aus, die entsteht, wenn wir
      // nur die erste Spalte streichen, sofern die erste Spalte 
      // komplett Null war. 
      else
      { 
        matrix B[m][n-1]=A[1..m,2..n]; 
        A[1..m,2..n]=ZSF(B);       
      }
    }
  }
  // 8. SCHRITT:
  return(A);
}
example
{
   "EXAMPLE:";
   echo=2;
   ring r=0,(x),lp;
   matrix A[3][4]=1,2,3,4,5,6,7,8,9,10,11,12;
   print(A);
   print(ZSF(A));
   matrix B[4][3]=2,3,4,-4,-6,-8,1,4,5,-3,-2,-3;
   print(B);
   print(ZSF(B));
   matrix C[4][3]=0,0,0,0,0,0,0,0,0,0,0,0;
   print(C);
   print(ZSF(C));
   matrix D[1][3]=0,2,3;
   print(D);
   print(ZSF(D));
   matrix E[2][3]=0,0,1,0,1,0;
   print(E);
   print(ZSF(E));
   matrix F[3][4]=1,0,2,3,1,0,3,4,2,0,5,3;
   print(F);
   print(ZSF(F));
}


proc RZSF (matrix A)
"USAGE:      RZSF(A);  A matrix
RETURN:      matrix,  A in reduzierter Zeilen-Stufen-Form
KEYWORDS:    Gauss Elimination, Zeilen-Stufen-Form
EXAMPLE:     example RZSF;   zeigt ein Beispiel"
{
  int m=nrows(A);   // Anzahl der Zeilen
  int n=ncols(A);   // Anzahl der Spalten
  int z,s;          // Zeilen-/Spaltenlaufindex 
  int i;            // Laufindex
  // Berechne die Zeilen-Stufen-Form von A.
  A=ZSF(A);
  // Berechne die reduzierte ZSF von A, indem die Spalten über den Pivot-Elementen
  // zu Null reduziert werden. Dazu beginnen wir mit der letzten Zeile ...
  for (z=m;z>=1;z--)
  {
    // ... finden das Pivot-Element in dieser Zeile (sofern eines existiert, ist es
    // das erste Element ungleich Null in der Zeile) ...
    s=1;
    while ((A[z,s]==0) and (s<n))
    {
      s=s+1;
    }
    // ... und (sofern ein Pivot-Element existiert) ....
    if (A[z,s]!=0)
    {
      // ... normieren wir die Zeile ...
      A=zeilenvielfaches(A,1/A[z,s],z);
      // ... und subtrahieren von den Zeilen 1 bis z-1 das A[i,s]-fache der z-ten Zeile.
      for (i=1;i<z;i++)
      {        
        A=zeilenaddition(A,z,i,-A[i,s]);        
      }        
    }
  }
  return(A);
} 
example
{
   "EXAMPLE:";
   echo=2;
   ring r=0,(x),lp;
   matrix A[3][4]=1,2,3,4,5,6,7,8,9,10,11,12;
   print(A);
   print(RZSF(A));
   matrix B[4][3]=2,3,4,-4,-6,-8,1,4,5,-3,-2,-3;
   print(B);
   print(RZSF(B));
   matrix C[4][3]=0,0,0,0,0,0,0,0,0,0,0,0;
   print(C);
   print(RZSF(C));
   matrix D[1][3]=0,2,3;
   print(D);
   print(RZSF(D));
   matrix E[2][3]=0,0,1,0,1,0;
   print(E);
   print(RZSF(E));
   matrix F[3][4]=1,0,2,3,1,0,3,4,2,0,5,3;
   print(F);
   print(RZSF(F));
}