ネストされたループのより高速な代替手段？

数字の組み合わせのリストを作成する必要があります。数が非常に少ないので、byteではなく使用できますint。ただし、考えられるすべての組み合わせを取得するには、多くのネストされたループが必要です。私が求めていることを行うためのより効率的な方法があるかどうか疑問に思っています。これまでのコードは次のとおりです。

var data = new List<byte[]>();
for (byte a = 0; a < 2; a++)
for (byte b = 0; b < 3; b++)
for (byte c = 0; c < 4; c++)
for (byte d = 0; d < 3; d++)
for (byte e = 0; e < 4; e++)
for (byte f = 0; f < 3; f++)
for (byte g = 0; g < 3; g++)
for (byte h = 0; h < 4; h++)
for (byte i = 0; i < 2; i++)
for (byte j = 0; j < 4; j++)
for (byte k = 0; k < 4; k++)
for (byte l = 0; l < 3; l++)
for (byte m = 0; m < 4; m++)
{
    data.Add(new [] {a, b, c, d, e, f, g, h, i, j, k, l, m});
}

のようなものを使うことを考えていましたBitArrayが、どうやって組み込むのかわかりません。

任意の推奨事項をいただければ幸いです。あるいは、おそらくこれが私がやりたいことをする最も速い方法ですか？

いくつか の簡単なポイントを編集します（そして私がこれらを元の投稿に入れなかったことをお詫びします）：

• それらの数と順序（2、3、4、3、4、3、3など）は非常に重要であるため、LINQを使用した順列の生成などのソリューションを使用しても、各「列」の最大値は異なる
• 私は数学者ではないので、「順列」や「組み合わせ」などの専門用語を正しく使用していない場合はお詫びします:)
• 私はない、私はちょうど1をつかむことができないか、別のインデックスに基づいて-一度にこれらの組み合わせの全てを移入する必要があります
• 使用byteは使用よりも速いですint、私はそれを保証します。また、メモリ使用量については、intではなく67m以上のバイト配列を使用する方がはるかに優れています。
• ここでの私の最終的な目標は、ネストされたループのより高速な代替手段を探すことです。
• 並列プログラミングの使用を検討しましたが、達成しようとしていることの反復性のため、（を使用してもConcurrentBag）それを成功させる方法を見つけることができませんでした-しかし、間違っていることが証明されてうれしいです:)

結論

Caramirielは、ループから少し時間を短縮する優れたマイクロ最適化を提供しているので、その答えを正解としてマークしました。エリックはまた、リストを事前に割り当てる方が速いと述べました。しかし、この段階では、ネストされたループが実際にこれを行うための可能な限り最速の方法であるように思われます（気のめいるように、私は知っています！）。

私がベンチマークしようとしていたことを正確に試したい場合はStopWatch、各ループで最大4つまでカウントする13のループを使用してください。これにより、リストに約67m以上の行が作成されます。私のマシン（i5-3320M 2.6GHz）では、最適化されたバージョンを実行するのに約2.2秒かかります。

構造体のプロパティを使用して、事前に構造体を割り当てることができます。以下のサンプルではいくつかのレベルを切り取っていますが、詳細を理解できると確信しています。オリジナル（リリースモード）の約5〜6倍の速度で実行されます。

ブロック：

struct ByteBlock
{
    public byte A;
    public byte B;
    public byte C;
    public byte D;
    public byte E;
}

ループ：

var data = new ByteBlock[2*3*4*3*4];
var counter = 0;

var bytes = new ByteBlock();

for (byte a = 0; a < 2; a++)
{
    bytes.A = a;
    for (byte b = 0; b < 3; b++)
    {
        bytes.B = b;
        for (byte c = 0; c < 4; c++)
        {
            bytes.C = c;
            for (byte d = 0; d < 3; d++)
            {
                bytes.D = d;
                for (byte e = 0; e < 4; e++)
                {
                    bytes.E = e;
                    data[counter++] = bytes;
                }
            }
        }
    }
}

リストに追加するたびに新しいリストが割り当てられるわけではないため、高速です。また、このリストを作成しているため、他のすべての値（a、b、c、d、e）への参照が必要です。各値はループ内で一度だけ変更されると想定できるため、そのように最適化できます（データの局所性）。

副作用についてのコメントも読んでください。

のT[]代わりにを使用するように回答を編集しましたList<T>。

あなたがしているのは数えていることです（基数は可変ですが、それでも数えています）。

C＃を使用しているので、コードを実際に最適化できる便利なメモリレイアウトやデータ構造を試してみたくないと思います。

だからここに私はあなたのケースに合わないかもしれない何か違うものを投稿しています、しかしそれは注目に値します：あなたが実際にまばらな方法でリストにアクセスする場合、ここでは線形時間でi番目の要素を計算することを可能にするクラス（むしろ他の答えのように指数関数的よりも）

class Counter
{
    public int[] Radices;

    public int[] this[int n]
    {
        get 
        { 
            int[] v = new int[Radices.Length];
            int i = Radices.Length - 1;

            while (n != 0 && i >= 0)
            {
                //Hope C# has an IL-opcode for div-and-reminder like x86 do
                v[i] = n % Radices[i];
                n /= Radices[i--];
            }
            return v;
        }
    }
}

このクラスはこのように使用できます

Counter c = new Counter();
c.Radices = new int[] { 2,3,4,3,4,3,3,4,2,4,4,3,4};

今c[i]はあなたのリストと同じです、それに名前を付けてくださいl、l[i]。

ご覧のとおり、Carry-Rippleカウンターを実装するだけなので、すべてのリスト全体を事前に計算した場合でも、これらすべてのループを簡単に回避できます:)。

カウンターは非常に研究された主題です、あなたが感じるならば、私はいくつかの文献を探すことを強く勧めます。

方法1

高速化する1つの方法はList<byte[]>、このように、を使い続ける予定がある場合は容量を指定することです。

var data = new List<byte[]>(2 * 3 * 4 * 3 * 4 * 3 * 3 * 4 * 2 * 4 * 4 * 3 * 4);

方法2

さらに、System.Array直接使用してより高速なアクセスを取得できます。すべての要素を事前にメモリに物理的に入力する必要がある場合は、このアプローチをお勧めします。

var data = new byte[2 * 3 * 4 * 3 * 4 * 3 * 3 * 4 * 2 * 4 * 4 * 3 * 4][];
int counter = 0;

for (byte a = 0; a < 2; a++)
    for (byte b = 0; b < 3; b++)
        for (byte c = 0; c < 4; c++)
            for (byte d = 0; d < 3; d++)
                for (byte e = 0; e < 4; e++)
                    for (byte f = 0; f < 3; f++)
                        for (byte g = 0; g < 3; g++)
                            for (byte h = 0; h < 4; h++)
                                for (byte i = 0; i < 2; i++)
                                    for (byte j = 0; j < 4; j++)
                                        for (byte k = 0; k < 4; k++)
                                            for (byte l = 0; l < 3; l++)
                                                for (byte m = 0; m < 4; m++)
                                                    data[counter++] = new[] { a, b, c, d, e, f, g, h, i, j, k, l, m };

これは私のコンピューターで完了するのに596ミリ秒かかります。これは、問題のコード（658ミリ秒かかる）よりも約10.4％高速です。

方法3

または、次の手法を使用して、まばらな方法でアクセスに適した低コストの初期化を行うこともできます。これは、一部の要素のみが必要であり、それらすべてを事前に決定する必要がないと考えられる場合に特に有利です。さらに、これらのような手法は、メモリが不足しているときに、より広大な要素を操作する場合の唯一の実行可能なオプションになる可能性があります。

この実装では、すべての要素は、アクセス時にオンザフライで遅延的に決定されるように残されています。当然、これにはアクセス中に発生する追加のCPUのコストがかかります。

class HypotheticalBytes
{
    private readonly int _c1, _c2, _c3, _c4, _c5, _c6, _c7, _c8, _c9, _c10, _c11, _c12;
    private readonly int _t0, _t1, _t2, _t3, _t4, _t5, _t6, _t7, _t8, _t9, _t10, _t11;

    public int Count
    {
        get { return _t0; }
    }

    public HypotheticalBytes(
        int c0, int c1, int c2, int c3, int c4, int c5, int c6, int c7, int c8, int c9, int c10, int c11, int c12)
    {
        _c1 = c1;
        _c2 = c2;
        _c3 = c3;
        _c4 = c4;
        _c5 = c5;
        _c6 = c6;
        _c7 = c7;
        _c8 = c8;
        _c9 = c9;
        _c10 = c10;
        _c11 = c11;
        _c12 = c12;
        _t11 = _c12 * c11;
        _t10 = _t11 * c10;
        _t9 = _t10 * c9;
        _t8 = _t9 * c8;
        _t7 = _t8 * c7;
        _t6 = _t7 * c6;
        _t5 = _t6 * c5;
        _t4 = _t5 * c4;
        _t3 = _t4 * c3;
        _t2 = _t3 * c2;
        _t1 = _t2 * c1;
        _t0 = _t1 * c0;
    }

    public byte[] this[int index]
    {
        get
        {
            return new[]
            {
                (byte)(index / _t1),
                (byte)((index / _t2) % _c1),
                (byte)((index / _t3) % _c2),
                (byte)((index / _t4) % _c3),
                (byte)((index / _t5) % _c4),
                (byte)((index / _t6) % _c5),
                (byte)((index / _t7) % _c6),
                (byte)((index / _t8) % _c7),
                (byte)((index / _t9) % _c8),
                (byte)((index / _t10) % _c9),
                (byte)((index / _t11) % _c10),
                (byte)((index / _c12) % _c11),
                (byte)(index % _c12)
            };
        }
    }
}

これは私のコンピューターで完了するのに897ミリ秒かかります（方法2のArrayように作成して追加します）。これは問題のコード（658ミリ秒かかります）よりも約36.3％遅くなります。

私のマシンでは、これにより、222ミリ秒と760ミリ秒（13個のforループ）の組み合わせが生成されます。

private static byte[,] GenerateCombinations(byte[] maxNumberPerLevel)
{
    var levels = maxNumberPerLevel.Length;

    var periodsPerLevel = new int[levels];
    var totalItems = 1;
    for (var i = 0; i < levels; i++)
    {
        periodsPerLevel[i] = totalItems;
        totalItems *= maxNumberPerLevel[i];
    }

    var results = new byte[totalItems, levels];

    Parallel.For(0, levels, level =>
    {
        var periodPerLevel = periodsPerLevel[level];
        var maxPerLevel = maxNumberPerLevel[level];
        for (var i = 0; i < totalItems; i++)
            results[i, level] = (byte)(i / periodPerLevel % maxPerLevel);
    });

    return results;
}

var numbers = new[] { 2, 3, 4, 3, 4, 3, 3, 4, 2, 4, 4, 3, 4 };
var result = (numbers.Select(i => Enumerable.Range(0, i))).CartesianProduct();

http://ericlippert.com/2010/06/28/computing-a-cartesian-product-with-linq/で拡張メソッドを使用する

public static IEnumerable<IEnumerable<T>> CartesianProduct<T>(this IEnumerable<IEnumerable<T>> sequences)
{
    // base case: 
    IEnumerable<IEnumerable<T>> result =
        new[] { Enumerable.Empty<T>() };
    foreach (var sequence in sequences)
    {
        // don't close over the loop variable (fixed in C# 5 BTW)
        var s = sequence;
        // recursive case: use SelectMany to build 
        // the new product out of the old one 
        result =
            from seq in result
            from item in s
            select seq.Concat(new[] { item });
    }
    return result;
}

リストには、固定長の値を格納する配列が内部にあります。List.Addを呼び出すと、十分なスペースがあるかどうかがチェックされます。新しい要素を追加できない場合は、より大きなサイズの新しい配列を作成し、前のすべての要素をコピーしてから、新しい要素を追加します。これにはかなりのサイクルがかかります。

すでに要素の数がわかっているので、正しいサイズのリストを作成できます。これは、すでにはるかに高速であるはずです。

また、値にアクセスする方法はわかりませんが、これを作成してコードにイメージを保存することはできます（ディスクからのロードは、現在行っているよりも遅くなる可能性があります。これに対して何回読み取り/書き込みを行いますか事？

これは、2つのループだけが必要な別の方法です。アイデアは、最初の要素を増やし、その数が超えた場合は次の要素を増やすことです。

データを表示する代わりに、currentValues.Cloneを使用して、その複製されたバージョンをリストに追加できます。私にとって、これはあなたのバージョンよりも速く実行されました。

byte[] maxValues = {2, 3, 4};
byte[] currentValues = {0, 0, 0};

do {
    Console.WriteLine("{0}, {1}, {2}", currentValues[0], currentValues[1], currentValues[2]);

    currentValues[0] += 1;

    for (int i = 0; i <= maxValues.Count - 2; i++) {
        if (currentValues[i] < maxValues[i]) {
            break;
        }

        currentValues[i] = 0;
        currentValues[i + 1] += 1;
    }

// Stop the whole thing if the last number is over
// } while (currentValues[currentValues.Length-1] < maxValues[maxValues.Length-1]);
} while (currentValues.Last() < maxValues.Last());

• このコードが機能することを願って、私はそれをvbから変換しました

すべての数値はコンパイル時定数です。

すべてのループをリストに展開するのはどうですか（プログラムを使用してコードを記述します）。

data.Add(new [] {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0});
data.Add(new [] {1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0});
etc.

これにより、少なくともforループのオーバーヘッドが取り除かれるはずです（存在する場合）。

私はC＃にあまり詳しくありませんが、オブジェクトをシリアル化する方法があるようです。そのリストを生成し、何らかの形式でシリアル化した場合はどうなりますか？ただし、逆シリアル化の方がリストを作成して要素を追加するよりも速いかどうかはわかりません。

結果を配列の配列にする必要がありますか？現在の設定では、内部配列の長さは固定されており、構造体に置き換えることができます。これにより、全体を1つの連続したメモリブロックとして予約できるようになり、要素へのアクセスが容易になります（後でこのことをどのように使用するかはわかりません）。

以下のアプローチははるかに高速です（私のボックスのオリジナルの1071msに対して41ms）：

struct element {
    public byte a;
    public byte b;
    public byte c;
    public byte d;
    public byte e;
    public byte f;
    public byte g;
    public byte h;
    public byte i;
    public byte j;
    public byte k;
    public byte l;
    public byte m;
}

element[] WithStruct() {
    var t = new element[3981312];
    int z = 0;
    for (byte a = 0; a < 2; a++)
    for (byte b = 0; b < 3; b++)
    for (byte c = 0; c < 4; c++)
    for (byte d = 0; d < 3; d++)
    for (byte e = 0; e < 4; e++)
    for (byte f = 0; f < 3; f++)
    for (byte g = 0; g < 3; g++)
    for (byte h = 0; h < 4; h++)
    for (byte i = 0; i < 2; i++)
    for (byte j = 0; j < 4; j++)
    for (byte k = 0; k < 4; k++)
    for (byte l = 0; l < 3; l++)
    for (byte m = 0; m < 4; m++)
    {
        t[z].a = a;
        t[z].b = b;
        t[z].c = c;
        t[z].d = d;
        t[z].e = e;
        t[z].f = f;
        t[z].g = g;
        t[z].h = h;
        t[z].i = i;
        t[z].j = j;
        t[z].k = k;
        t[z].l = l;
        t[z].m = m;
        z++;
    }
    return t;
}

Parallel.For()それを実行するために使用するのはどうですか？（への構造体の最適化名声を@Caramiriel）。値を少し変更したので（aは2ではなく5）、結果に自信が持てるようになりました。

    var data = new ConcurrentStack<List<Bytes>>();
    var sw = new Stopwatch();

    sw.Start();

    Parallel.For(0, 5, () => new List<Bytes>(3*4*3*4*3*3*4*2*4*4*3*4),
      (a, loop, localList) => {
        var bytes = new Bytes();
        bytes.A = (byte) a;
        for (byte b = 0; b < 3; b++) {
          bytes.B = b;
          for (byte c = 0; c < 4; c++) {
            bytes.C = c; 
            for (byte d = 0; d < 3; d++) {
              bytes.D = d; 
              for (byte e = 0; e < 4; e++) {
                bytes.E = e; 
                for (byte f = 0; f < 3; f++) {
                  bytes.F = f; 
                  for (byte g = 0; g < 3; g++) {
                    bytes.G = g; 
                    for (byte h = 0; h < 4; h++) {
                      bytes.H = h; 
                      for (byte i = 0; i < 2; i++) {
                        bytes.I = i; 
                        for (byte j = 0; j < 4; j++) {
                          bytes.J = j; 
                          for (byte k = 0; k < 4; k++) {
                            bytes.K = k; 
                            for (byte l = 0; l < 3; l++) {
                              bytes.L = l;
                              for (byte m = 0; m < 4; m++) {
                                bytes.M = m;
                                localList.Add(bytes);
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }


        return localList;
      }, x => {
        data.Push(x);
    });

    var joinedData = _join(data);

_join() はプライベートメソッドであり、次のように定義されます。

private static IList<Bytes> _join(IEnumerable<IList<Bytes>> data) {
  var value = new List<Bytes>();
  foreach (var d in data) {
    value.AddRange(d);
  }
  return value;
}

私のシステムでは、このバージョンは約6倍高速に実行されます（1.718秒対0.266秒）。

あなたの数のいくつかは完全にビットの整数の数に収まるので、あなたはそれらを上位レベルの数で「詰める」ことができます：

for (byte lm = 0; lm < 12; lm++)
{
    ...
    t[z].l = (lm&12)>>2;
    t[z].m = lm&3;
    ...
}

もちろん、これによりコードが読みにくくなりますが、1つのループを節約できました。これは、数値の1つが2の累乗になるたびに実行できます。これは、あなたの場合は7倍です。

これが別の解決策です。VSの外では、437.5ミリ秒の速度で実行されます。これは元のコード（私のコンピューターでは593.7）よりも26％高速です。

static List<byte[]> Combinations(byte[] maxs)
{
  int length = maxs.Length;
  int count = 1; // 3981312;
  Array.ForEach(maxs, m => count *= m);
  byte[][] data = new byte[count][];
  byte[] counters = new byte[length];

  for (int r = 0; r < count; r++)
  {
    byte[] row = new byte[length];
    for (int c = 0; c < length; c++)
      row[c] = counters[c];
    data[r] = row;

    for (int i = length - 1; i >= 0; i--)
    {
      counters[i]++;
      if (counters[i] == maxs[i])
        counters[i] = 0;
      else
        break;
    }
  }

  return data.ToList();
}