c#将一维数组赋值给具有移位值的二维数组

我有一个双值向量（1D数组），比如说X。我需要将这个值向量复制到一个矩阵（2D数组），比如Y，这样Y的第一行与X转置相同，第二行与X向左移动一个值相同，第三行与X向左移动两个值相同，依此类推

比如说,

X = { 1.0, 2.0. 3.0, 4.0, 5.0 }

我需要

Y =  1.0  2.0  3.0  4.0  5.0
     2.0  3.0  4.0  5.0  0.0
     3.0  4.0  5.0  0.0  0.0
     4.0  5.0  0.0  0.0  0.0
     5.0  0.0  0.0  0.0  0.0

不久前，Mathew Finlay发布了一段代码，用于将值类型的一维数组复制到二维数组。我已将代码修改如下：

for (int targetRow = 0; targetRow < N; targetRow++)
{
    Buffer.BlockCopy
    (
        X,                                                    // 1D source array
        0,                                                    // source array offset
        Y,                                                    // 2D target (destination) array
        targetRow * Y.GetLength(targetRow) * sizeof(double),  // target array offset
        X.Length * sizeof(double)                             // count
    );
}

for（int-targetRow=0；targetRow

我不确定这是否会奏效，更重要的是，这是否是最好的方法。这是较大代码的一部分，这部分需要快速高效，因为向量X和矩阵Y可能变得非常大

另外，更复杂的是，我可能不需要向量X的全长（所有值），而只需要它的一部分，这样矩阵Y就可以是nxm，其中M呢

       double[] X = new double[]{ 1.0, 2.0, 3.0, 4.0, 5.0 };

        var lbound = X.GetLowerBound(0);
        var ubound = X.GetUpperBound(0);

       double[,] Y = new double[ubound + 1, ubound + 1];

       for (var i = lbound; i <= ubound; i++)
       {
           for (var j = lbound ; j <= ubound ; j++)
           {
               Y[i, j] = (i + j) > ubound ? 0.0 : X[i +j];
           }  
       }

输出：

怎么办

       double[] X = new double[]{ 1.0, 2.0, 3.0, 4.0, 5.0 };

        var lbound = X.GetLowerBound(0);
        var ubound = X.GetUpperBound(0);

       double[,] Y = new double[ubound + 1, ubound + 1];

       for (var i = lbound; i <= ubound; i++)
       {
           for (var j = lbound ; j <= ubound ; j++)
           {
               Y[i, j] = (i + j) > ubound ? 0.0 : X[i +j];
           }  
       }

输出：

---

假设

x

类型为

double[]

，使用：

var y = new double[x.Length, x.Length];
for (int row = 0; row < x.Length; ++row)
{
  for (int col = 0; col < x.Length - row; ++col)
  {
    y[row, col] = x[col - row];
  }
}

var y=新的双精度[x.Length，x.Length]；
用于（int行=0；行

---

或类似。

假设

x

类型为

double[]

，则使用：

var y = new double[x.Length, x.Length];
for (int row = 0; row < x.Length; ++row)
{
  for (int col = 0; col < x.Length - row; ++col)
  {
    y[row, col] = x[col - row];
  }
}

var y=新的双精度[x.Length，x.Length]；
用于（int行=0；行

---

---

或类似的。

谢谢您的回复。为了提高速度，我试着远离循环。我想我可以简单地调整Buffer.BlockCopy中的偏移量，以有效地完成此操作。@PBrenek我找到了一种使用

Buffer.BlockCopy

来实现所需的方法。我不知道这有多实际……谢谢你的努力。我真的很感激。这其实很有趣。不幸的是，正如Jeppe Stig Nielsen在下面指出的那样，数组的大小有2GB的限制，使用Buffer.BlockCopy的方法需要将数组大小加倍—这是由于零填充。这将有效地将要分析的值的数量减少一半。看来我可能需要使用循环而不是Buffer.BlockCopy。非常感谢。@PBrenek我更新了我的答案，并想出了如何在不使数组大小加倍的情况下实现它：-）这太棒了！非常感谢你。不幸的是，有一个小故障。此方法用于创建方形矩阵。然而，有时矩阵不是平方的。因此，使用您的示例，我需要10行，但只需要可变的列数，小于或等于10。因此，假设输出如上所述，但只有6或7列。我将尝试在for循环中调整ubound。谢谢您的回复。为了提高速度，我试着远离循环。我想我可以简单地调整Buffer.BlockCopy中的偏移量，以有效地完成此操作。@PBrenek我找到了一种使用

Buffer.BlockCopy

来实现所需的方法。我不知道这有多实际……谢谢你的努力。我真的很感激。这其实很有趣。不幸的是，正如Jeppe Stig Nielsen在下面指出的那样，数组的大小有2GB的限制，使用Buffer.BlockCopy的方法需要将数组大小加倍—这是由于零填充。这将有效地将要分析的值的数量减少一半。看来我可能需要使用循环而不是Buffer.BlockCopy。非常感谢。@PBrenek我更新了我的答案，并想出了如何在不使数组大小加倍的情况下实现它：-）这太棒了！非常感谢你。不幸的是，有一个小故障。此方法用于创建方形矩阵。然而，有时矩阵不是平方的。因此，使用您的示例，我需要10行，但只需要可变的列数，小于或等于10。因此，假设输出如上所述，但只有6或7列。我将尝试调整for循环中的ubound。我将检查这一点。非常感谢。我的印象是Buffer.BlockCopy比循环快得多，所以我希望使用它而不是循环，只是调整偏移量。@PBrenek循环非常快。内存访问也应该非常快。你的数组有多大？很难说，因为没有上限，大小由用户决定，但很容易是1000000 x 1000000。@PBrenek这是一百万个条目。每个

double

是八个字节。所以总共是8 TB。你确定你有足够的记忆力吗？（实际上，在.NET中，没有一个数组可以超过2G字节。）嗯，我没有想到这一点。我可能需要设定一个上限。然而，我希望传达的一点是，矩阵可以足够大，以便内存拷贝比循环执行得更好。谢谢你提醒我关于内存大小的问题。我会查出来的。非常感谢。我的印象是Buffer.BlockCopy比循环快得多，所以我希望使用它而不是循环，只是调整偏移量。@PBrenek循环非常快。内存访问也应该非常快。你的阵列有多大？很难说，因为没有上限，大小由用户决定，但是