C#, Calcul numérique - Méthode de calcul et programme source de la classe d'index (Index)

 

utiliser le système ;

espace de noms Legalsoft.Truffer
{     public class Indexx     {         public int n { get; ensemble; } = 0 ;         public int[] index ;

        public Indexx()
        {         }

        public Indexx(double[] arr)
        {             index(arr, arr.Length);         }

        public void sort(double[] brr)
        {             if (brr.Length != n)             {                 throw new Exception("bad size in Index sort");             }             double[] tmp = Globals.CopyFrom(brr);             for (int j = 0; j < n; j++)             {                 brr[j] = tmp[indx[j]];             }         }

        public void sort(int[] brr)
        {             if (brr.Length != n)             {                 throw new Exception("bad size in Index sort");             }             int[] tmp = Globals.CopyFrom(brr);             for (int j = 0; j < n; j++)             {                 brr[j] = tmp[indx[j]];             }         }

        public double el(double[] brr, int j)
        {             return brr[indx[j]] ;         }

        public int el(int[] brr, int j)
        {             return brr[indx[j]] ;         }

        public void setEl(int[] brr, int j, int v)
        {             brr[indx[j]] = v;         }

        public void setEl(double[] brr, int j, double v)
        {             brr[indx[j]] = v;         }

        public void rank(int[] irank)
        {             irank = new int[n] ;             for (int j = 0; j < n; j++)             {                 irank[indx[j]] = j;             }         }

        public void index(double[] arr, int nn)
        {             const int M = 7;             const entier NSTACK = 64 ;

            int jstack = -1 ;
            int[] istack = new int[NSTACK] ;
            n = nn ;
            indx = nouveau int[n] ;
            int ir = n - 1;
            for (int j = 0; j < n; j++)
            {                 indx[j] = j;             }             entier l = 0 ;             for (; ; )             {                 if (ir - l < M)                 {                     for (int j = l + 1; j <= ir; j++)                     {                         int indxt = indx[j];                         double a = arr[indxt] ;                         entier je = j - 1 ;












                        for (; i >= l; i--)
                        {                             if (arr[indx[i]] <= a)                             {                                 break;                             }                             indice[i + 1] = indice[i] ;                         }                         indx[i + 1] = indxt ;                     }                     si (jstack < 0)                     {                         break;                     }                     ir = istack[jstack--] ;                     l = istack[jstack--] ;                 }                 sinon
















                {                     entier k = (l + ir) >> 1 ;                     Globals.SWAP(index de référence[k], index de référence[l + 1]);                     if (arr[indx[l]] > arr[indx[ir]])                     {                         Globals.SWAP(ref indx[l], ref indx[ir]);                     }                     if (arr[indx[l + 1]] > arr[indx[ir]])                     {                         Globals.SWAP(ref indx[l + 1], ref indx[ir]);                     }                     if (arr[indx[l]] > arr[indx[l + 1]])                     {                         Globals.SWAP(ref indx[l], ref indx[l + 1]);                     }














                    int je = l + 1 ;
                    int j = ir ;
                    entier indxt = indx[l + 1] ;
                    double a = arr[indxt] ;
                    pour (; ; )
                    {                         faire                         {                             je++;                         } tandis que (arr[indx[i]] < a);                         faire                         {                             j-- ;                         } tandis que (arr[indx[j]] > a);                         si (j < i)                         {                             pause ;                         }












                        Globals.SWAP(index de référence[i], index de référence[j]);
                    }
                    indice[l + 1] = indice[j] ;
                    indx[j] = indxt ;
                    jstack += 2;
                    if (jstack >= NSTACK)
                    {                         throw new Exception("NSTACK trop petit dans l'index.");                     }                     si (ir - je + 1 >= j - l)                     {                         istack[jstack] = ir;                         istack[jstack - 1] = je ;                         ir = j - 1;                     }                     sinon                     {










                        istack[jstack] = j - 1 ;
                        istack[jstack - 1] = l;
                        l = je ;
                    }
                }
            }
        }
    }
}