Don't like ads? PRO users don't see any ads ;-)
Guest

Untitled

By: a guest on Aug 12th, 2012  |  syntax: None  |  size: 9.21 KB  |  hits: 8  |  expires: Never
download  |  raw  |  embed  |  report abuse  |  print
Text below is selected. Please press Ctrl+C to copy to your clipboard. (⌘+C on Mac)
  1. manipulating list into array [closed]
  2. int length = noise.Count;
  3.                    int tdelay1 = 200;
  4.                     int [] embDim = new int [10] {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
  5.  
  6.                     foreach (int m in embDim)
  7.                     {
  8.                         if (m == embDim[0])
  9.                         {
  10.                             float[,] phaseSpace1 = new float[length, m];
  11.                             for (int i = 0; i < length-1; i++)
  12.                             {
  13.                                 phaseSpace1 [i,0] = noise[i];
  14.                             }
  15.                         }
  16.  
  17.                         else if (m == embDim[1])
  18.                         {
  19.                             float[,] phaseSpace2 = new float[(length-tdelay1), m];
  20.                             for (int i = 0; i < (length-tdelay1-1); i++)
  21.                             {
  22.                                 int j = i + tdelay1;
  23.                                 phaseSpace2 [i,0] = noise[i];
  24.                                 phaseSpace2 [i,1] = noise[j];
  25.                             }
  26.                         }
  27.  
  28.                         else if (m == embDim[2])
  29.                         {
  30.                             float[,] phaseSpace3 = new float[(length-2*tdelay1), m];
  31.                             for (int i = 0; i < (length-2*tdelay1-1); i++)
  32.                             {
  33.                                 int j = i + tdelay1;
  34.                                 int k = i + 2 * tdelay1;
  35.                                 phaseSpace3 [i, 0] = noise[i];
  36.                                 phaseSpace3 [i, 1] = noise[j];
  37.                                 phaseSpace3 [i, 2] = noise[k];
  38.                             }
  39.                         }
  40.  
  41.                         else if (m == embDim[3])
  42.                         {
  43.                             float[,] phaseSpace4 = new float[(length-3*tdelay1), m];
  44.                             for (int i = 0; i < (length-3*tdelay1-1); i++)
  45.                             {
  46.                                 int j = i + tdelay1;
  47.                                 int k = i + 2 * tdelay1;
  48.                                 int l = i + 3 * tdelay1;
  49.                                 phaseSpace4[i, 0] = noise[i];
  50.                                 phaseSpace4[i, 1] = noise[j];
  51.                                 phaseSpace4[i, 2] = noise[k];
  52.                                 phaseSpace4[i, 3] = noise[l];
  53.                             }
  54.                         }
  55.  
  56.                         else if (m == embDim[4])
  57.                         {
  58.                             float[,] phaseSpace5 = new float[(length-4*tdelay1), m];
  59.                             for (int i = 0; i < (length-4*tdelay1-1); i++)
  60.                             {
  61.                                 int j = i + tdelay1;
  62.                                 int k = i + 2 * tdelay1;
  63.                                 int l = i + 3 * tdelay1;
  64.                                 int n = i + 4 * tdelay1;
  65.                                 phaseSpace5[i, 0] = noise[i];
  66.                                 phaseSpace5[i, 1] = noise[j];
  67.                                 phaseSpace5[i, 2] = noise[k];
  68.                                 phaseSpace5[i, 3] = noise[l];
  69.                                 phaseSpace5[i, 4] = noise[n];
  70.                             }
  71.                         }
  72.  
  73.                         else if (m == embDim[5])
  74.                         {
  75.                             float[,] phaseSpace6 = new float[(length-5*tdelay1), m];
  76.                             for (int i = 0; i < (length-5*tdelay1-1); i++)
  77.                             {
  78.                                 int j = i + tdelay1;
  79.                                 int k = i + 2 * tdelay1;
  80.                                 int l = i + 3 * tdelay1;
  81.                                 int n = i + 4 * tdelay1;
  82.                                 int o = i + 5 * tdelay1;
  83.                                 phaseSpace6[i, 0] = noise[i];
  84.                                 phaseSpace6[i, 1] = noise[j];
  85.                                 phaseSpace6[i, 2] = noise[k];
  86.                                 phaseSpace6[i, 3] = noise[l];
  87.                                 phaseSpace6[i, 4] = noise[n];
  88.                                 phaseSpace6[i, 5] = noise[o];
  89.                             }
  90.                         }
  91.  
  92.                         else if (m == embDim[6])
  93.                         {
  94.                             float[,] phaseSpace7 = new float[(length-6*tdelay1), m];
  95.                             for (int i = 0; i < (length-6*tdelay1-1); i++)
  96.                             {
  97.                                 int j = i + tdelay1;
  98.                                 int k = i + 2 * tdelay1;
  99.                                 int l = i + 3 * tdelay1;
  100.                                 int n = i + 4 * tdelay1;
  101.                                 int o = i + 5 * tdelay1;
  102.                                 int p = i + 6 * tdelay1;
  103.                                 phaseSpace7[i, 0] = noise[i];
  104.                                 phaseSpace7[i, 1] = noise[j];
  105.                                 phaseSpace7[i, 2] = noise[k];
  106.                                 phaseSpace7[i, 3] = noise[l];
  107.                                 phaseSpace7[i, 4] = noise[n];
  108.                                 phaseSpace7[i, 5] = noise[o];
  109.                                 phaseSpace7[i, 6] = noise[p];
  110.                             }
  111.                         }
  112.  
  113.                         else if (m == embDim[7])
  114.                         {
  115.                             float[,] phaseSpace8 = new float[(length-7*tdelay1), m];
  116.                             for (int i = 0; i < (length-7*tdelay1-1); i++)
  117.                             {
  118.                                 int j = i + tdelay1;
  119.                                 int k = i + 2 * tdelay1;
  120.                                 int l = i + 3 * tdelay1;
  121.                                 int n = i + 4 * tdelay1;
  122.                                 int o = i + 5 * tdelay1;
  123.                                 int p = i + 6 * tdelay1;
  124.                                 int q = i + 7 * tdelay1;
  125.                                 phaseSpace8[i, 0] = noise[i];
  126.                                 phaseSpace8[i, 1] = noise[j];
  127.                                 phaseSpace8[i, 2] = noise[k];
  128.                                 phaseSpace8[i, 3] = noise[l];
  129.                                 phaseSpace8[i, 4] = noise[n];
  130.                                 phaseSpace8[i, 5] = noise[o];
  131.                                 phaseSpace8[i, 6] = noise[p];
  132.                                 phaseSpace8[i, 7] = noise[q];
  133.                             }
  134.                         }
  135.  
  136.                         else if (m == embDim[8])
  137.                         {
  138.                             float[,] phaseSpace9 = new float[(length-8*tdelay1), m];
  139.                             for (int i = 0; i < (length-8*tdelay1-1); i++)
  140.                             {
  141.                                 int j = i + tdelay1;
  142.                                 int k = i + 2 * tdelay1;
  143.                                 int l = i + 3 * tdelay1;
  144.                                 int n = i + 4 * tdelay1;
  145.                                 int o = i + 5 * tdelay1;
  146.                                 int p = i + 6 * tdelay1;
  147.                                 int q = i + 7 * tdelay1;
  148.                                 int r = i + 8 * tdelay1;
  149.                                 phaseSpace9[i, 0] = noise[i];
  150.                                 phaseSpace9[i, 1] = noise[j];
  151.                                 phaseSpace9[i, 2] = noise[k];
  152.                                 phaseSpace9[i, 3] = noise[l];
  153.                                 phaseSpace9[i, 4] = noise[n];
  154.                                 phaseSpace9[i, 5] = noise[o];
  155.                                 phaseSpace9[i, 6] = noise[p];
  156.                                 phaseSpace9[i, 7] = noise[q];
  157.                                 phaseSpace9[i, 8] = noise[r];
  158.                             }
  159.                         }
  160.  
  161.                         else if (m == embDim[9])
  162.                         {
  163.                             float[,] phaseSpace10 = new float[(length-9*tdelay1), m];
  164.                             for (int i = 0; i < (length-9*tdelay1-1); i++)
  165.                             {
  166.                                 int j = i + tdelay1;
  167.                                 int k = i + 2 * tdelay1;
  168.                                 int l = i + 3 * tdelay1;
  169.                                 int n = i + 4 * tdelay1;
  170.                                 int o = i + 5 * tdelay1;
  171.                                 int p = i + 6 * tdelay1;
  172.                                 int q = i + 7 * tdelay1;
  173.                                 int r = i + 8 * tdelay1;
  174.                                 int s = i + 9 * tdelay1;
  175.                                 phaseSpace10[i, 0] = noise[i];
  176.                                 phaseSpace10[i, 1] = noise[j];
  177.                                 phaseSpace10[i, 2] = noise[k];
  178.                                 phaseSpace10[i, 3] = noise[l];
  179.                                 phaseSpace10[i, 4] = noise[n];
  180.                                 phaseSpace10[i, 5] = noise[o];
  181.                                 phaseSpace10[i, 6] = noise[p];
  182.                                 phaseSpace10[i, 7] = noise[q];
  183.                                 phaseSpace10[i, 8] = noise[r];
  184.                                 phaseSpace10[i, 9] = noise[s];
  185.                             }                                
  186.                         }