C# 双数组值的快速乘法

你好，我有一个一维数组，它代表一个二维数组。根据每个值的位置，将确定其乘以的系数

此时，我迭代for循环中的每个值，乘以正确的系数，然后将乘积存储在另一个数组中

MultiplyEachValue.cs

internal double[] MultiplyEachValue(double[] oneDimArray, int width, int height, Alignment coeffs)
{
    var toReturn = new double[oneDimArray.Length];
    for (int i = 0; i < oneDimArray.Length; i++)
    {
        double curVal;
        if(isEvenPos(i, width, height) == true)
        {
            curVal = coeffs.Small * oneDimArray[i];
        }
        else if (isOddPos(i, 4, 2) == true)
        {
            curVal = coeffs.Large * oneDimArray[i];
        }
        else if (isOppoPos(i, 4, 2) == true)
        {
            curVal = coeffs.Medium * oneDimArray[i];
        }
        else
        {
            curVal = 1;
        }
        toReturn[i] = curVal;
    }
    return toReturn;
}

internal double[]multilyAChValue（double[]oneDimArray、int-width、int-height、对齐系数）
{
var toReturn=new double[oneDimArray.Length]；
for（int i=0；i

有什么办法可以加快速度吗？

---

我听说过点乘之类的东西，但我不知道它是否可以在这里应用。任何建议都很好。谢谢

你应该在运行应用程序时进行分析，最好是使用大量输入，这样会花费更长的时间。然后确定热点，然后回顾这些热点，看看它们是否可以改进

还要注意，经过的执行时间和CPU消耗时间也是不同的。您是否在寻求降低CPU成本或运行时间

您还应该命令您的if/else梯形图首先测试最常见的场景，例如，如果大多数数据在最后一次if测试中结束，那么将该检查作为第一次检查将改善情况

话虽如此，代码看起来很容易并行化，在多核机器上，原则上，如果您并行化循环，您可以看到一个“n”因子与“n”核一起加速。

（这个问题似乎非常适合。）
拥有单个（一维）数组并不意味着嵌套循环没有优势。
假设“行顺序”（并保留我更愿意做的事情以获得认可）：

double[]multilyAChValue（double[]oneDimArray，
整数宽度、整数高度、对齐系数）
{
var toReturn=new double[oneDimArray.length]；
双精度常数
偶数=系数。小，
相反=系数。中等，
奇数=系数。大；
对于（int i=0，r=0；r如果（height您所说的更快到底是什么意思？
isOddPos

和

isopopos

做什么，以及4和2的参数的原因是什么？应该可以提前预测偶数/奇数位置的位置，然后您就不必测试它们了。对于每个元素，您最多有3个对CHO的方法调用e正确的if分支！制作一个返回元素位置类型的函数。调用它一次，然后进行正确的计算。或者，如果它需要一些复杂的计算来获得元素类型，甚至在每个子集上将其分解为4个循环（对应于您拥有的每个

if

分支）->它完全消除了重复的类型理解。

double[] MultiplyEachValue(double[] oneDimArray,
    int width, int height, Alignment coeffs)
{
    var toReturn = new double[oneDimArray.length];
    const double
        even = coeffs.Small,
        opposed = coeffs.Medium,
        odd = coeffs.Large;
    for (int i = 0, r = 0 ; r < height ; r++) {
        for (int c = 1 ; c < width ; c += 2) {
            toReturn[i] = even * oneDimArray[i]; i++;
            toReturn[i] = opposed * oneDimArray[i]; i++;
        }
        if (1 == (1 & width)) {
            toReturn[i] = even * oneDimArray[i]; i++;
        }
        if (height <= ++r)
            return toReturn;
        for (int c = 1 ; c < width ; c += 2) {
            toReturn[i] = opposed * oneDimArray[i]; i++;
            toReturn[i] = odd * oneDimArray[i]; i++;
        }
        if (1 == (1 & width)) {
            toReturn[i] = opposed * oneDimArray[i]; i++;
        }
    }
    return toReturn;
}