order2.c

error correction code

                }
                else
                {
                    non_resource_p[l] = C[k][DD[k]] - C[k][Dd[k]];
                    l++;        /* to be used later */
                }
             }
          }
          if (cost > Max)
          {
              Max = cost;          /* do not reset Max */
              change.n_change = 2;
              change.position[0] = i;
              change.position[1] = j;
              resource_available = resource_init - Max;
/* Recompute resource_dhi for new resource_candidate */
 
                  resource_dh0 = 0.0;
                  resource_dh1 = 0.0;
                  resource_dh2 = 0.0;
                  resource_dh3 = 0.0;

                  for (a=0,b=l-1;a<D_H-e_c2-2;a++,b--)  /* -2 as undo Order 2 */                  {
                      if (a < D_H-e_c2-2-1)
                      {
                         resource_dh0 = resource_dh0 + non_resource_p[b];
                      }
                      if (a < D_H-e_c2-2-2)
                      {
                         resource_dh1 = resource_dh1 + non_resource_p[b];
                      }
                      if (a < D_H-e_c2-2-3)
                      {
                         resource_dh2 = resource_dh2 + non_resource_p[b];
                      }
                      if (a < D_H-e_c2-2-4)
                      {
                         resource_dh3 = resource_dh3 + non_resource_p[b];
                      }
                      sum_tail_init = sum_tail_init + non_resource_p[b];
                  }
              }
             }
             else
             {
                j = -1;
             }
       }            /* end j */
      }             /* end i */
      step = 2;

/* Re permute to obtain the original sequence (use only permute_R as
   permute_I worked on rows). Use DD[] as DD[] no longer useful */

   for (i=0;i<change.n_change;i++)                                 
   {
       Dd[change.position[i]] = DD[change.position[i]];
   }

   for (i=K; i<N; i++)
   {
       Dd[i] = 0;
       for (j=0; j<K; j++)
       { 
          Dd[i] = Dd[i] + Dd[j] * Gg[j][i];
       } 
       Dd[i] = Dd[i] % 2;
   }    

   for (i=0; i<N; i++)
   {
       DD[permutation_final[i]] = Dd[i];
   }
 
   for (i=0; i < N; i++)   /* Using a systematic code */
   {
      if (DD[i] == 0)
         out_D[i] = - 1.0;
      else
         out_D[i] = 1.0;
   }

}


void switch_column_I_0(GG,Gg,R,permutation_R,permutation_final)
  /* copy GG into Gg */   
   int GG[K][N],Gg[K][N];
   double R[];
   int permutation_R[],permutation_final[];
{
    int i,j,index,count,start;
    int record[N],record_I[N];
    double temp[N];
 
    index = 0;
    count = 0;
 
    for (i=0; i < K+index; i++)   /* record the column positions to switch */
    {
         if (GG[i-index][i] == 0)
         {
              record[index] = i;
              index++;
         }
         else
         {
              record_I[count] = i;
              count ++;
         }
    }
    start = K + index - 1;
    i = N-1;
    while (i > start)            /* Unchanged part */
    {
        for(j=0; j<K; j++)
        {
            Gg[j][i] = GG[j][i];
            permutation_final[i] = permutation_R[N-1-i];
        }
        i--;
    }    
    while (index > 0)            /* Copy from R to L dependent columns found
                                    in first positions */
    {
        temp[i] = R[i];
        for(j=0; j<K; j++)
        {
            Gg[j][i] = GG[j][record[index-1]];
            permutation_final[i] = permutation_R[N-1-record[index-1]];
        }
        if (i < record[index-1])
        {
            R[i] = temp[record[index-1]];
        }
        else
        {
            R[i] = R[record[index-1]];
        }
        i--;
        index--;
    }
    while (count > 0)    /* Copy I_columns */
    {
        temp[i] = R[i];
        for(j=0; j<K; j++)
        {
            Gg[j][i] = GG[j][record_I[count-1]];
            permutation_final[i] = permutation_R[N-1-record_I[count-1]];
        }
 
        if (i < record_I[count-1])
        {
            R[i] = temp[record_I[count-1]];
        }
        else
        {
            R[i] = R[record_I[count-1]];
        } 
        i--;
        count--;
    }
}
 
void switch_vector_0(R,permutation,length)
   double R[];
   int permutation[];
   int length;
{
   int i;
   double temp[N];
 
   for (i=0;i<=length;i++)
   {
      temp[i] = R[i];
      if (permutation[length-i] > i)   /* data not overwritten */
      {
          R[i] = R[permutation[length-i]];
      }
      else
      {
          R[i] = temp[permutation[length-i]];
                                      /* data overwritten but stored in temp */
      }
   }
}
 
void switch_matrix_0(Gg,permutation,k,n)
   int Gg[K][N];
   int permutation[];
   int k,n;
{
   int i,j;
   double temp[K][N];
 
   for (j=0;j<=n;j++)
   {
      for (i=0; i<=k; i++)
      {
         temp[i][j] = Gg[i][j];
         if (permutation[n-j] > j)   /* column not overwritten */
         {
             Gg[i][j] = Gg[i][permutation[n-j]];
         }
         else
         {
             Gg[i][j] = temp[i][permutation[n-j]];
                                      /* data overwritten but stored in temp */
         }
      }
   }
}
 
void peterson_I_0(Gg,zero)
   int Gg[K][N];
   double zero[N];
{
   int i,j,l,m;
 
   for (i=0; i<K; i++)
   {
      j = 0;
      zero[i] = 0.0;
      while (Gg[i][j] == 0)
      {
         j++;
         zero[i] = zero[i] + 1.0;
      }
      for (l=0; l<K ; l++)
      {
          if ((l != i) && (Gg[l][j] == 1))
          {
               for (m=0; m<N; m++)
               {
                  Gg[l][m] = (Gg[l][m] + Gg [i][m])%2;
               }
          }
      }
   }
}
 
/* Recursive quick_sort */
void quick_sort_track_0(vals,permutation,left,right) /* Tracks the permutations */        
        double vals[];
        int permutation[];
        int left,right;
{
    /* ascending = left wall, descending = right wall */

    int ascending = left-1, descending = right;
    double ref_val,temp;
    int temp2;

    /* select the comparison value */

    if (right > left)                 
    {
        ref_val = vals [right];

        for(;;)                 
        {

       /* while element smaller than reference value,
          move left wall upwards
       */

             while (vals [++ascending] < ref_val);

       /* while element larger than reference value,
          move right wall downwards
       */

             while (vals [--descending] > ref_val);

             if (ascending >= descending) break;    
 
       /* if the walls have not passed each other,
          exchange values
          (if not access to function need to save index)
       */

            temp=vals[ascending];
            temp2=permutation[ascending];
            vals[ascending]=vals[descending];
            vals[descending]=temp;
            permutation[ascending]=permutation[descending];
            permutation[descending]=temp2;

         }                                 

           
            temp=vals[ascending];
            temp2=permutation[ascending];
            vals[ascending]=vals[right];
            vals[right]=temp;
            permutation[ascending]=permutation[right];
            permutation[right]=temp2;
 

    /* if descending wall has not yet reached left partition,
       call quick-sort again with this smaller array
    */
 
       quick_sort_track_0( vals, permutation, left, ascending-1);

    /* if ascending wall has not yet reached right partition,   
       call quick-sort again with this smaller array
    */
 
       quick_sort_track_0( vals, permutation, ascending+1, right);
   }     

}