我需要更快地完成我的操作

Question

我有一段从stl读取点的代码，然后我必须对这个stl进行转换，应用一个转换矩阵，并将结果写到其他stl上。我做了所有这些事情，但它太慢了，大约5分钟或更多。

我放入矩阵乘法的代码，它接收两个矩阵，然后进行乘法：

public double[,] MultiplyMatrix(double[,] A, double[,] B)
    {
        int rA = A.GetLength(0);
        int cA = A.GetLength(1);
        int rB = B.GetLength(0);
        int cB = B.GetLength(1);
        double temp = 0;
        double[,] kHasil = new double[rA, cB];
        if (cA != rB)
        {
            MessageBox.Show("matrix can't be multiplied !!");
        }
        else
        {
            for (int i = 0; i < rA; i++)
            {
                for (int j = 0; j < cB; j++)
                {
                    temp = 0;
                    for (int k = 0; k < cA; k++)
                    {
                        temp += A[i, k] * B[k, j];
                    }
                    kHasil[i, j] = temp;
                }
            }
            return kHasil;
        }
        return kHasil;
    }

我的问题是，所有的代码都太慢了，它必须从stl中读取，将所有点相乘，然后将结果写到其他stl中，这需要花费5-10分钟的时间。我发现所有的商业程序，比如cloudcompare，都能在几秒钟内完成所有这些操作。

谁能告诉我怎样才能做得更快？有没有比我的代码更快的库呢？

谢谢！:)

Answer 1

我在互联网上发现了这一点：

 double[] iRowA = A[i];
double[] iRowC = C[i];
for (int k = 0; k < N; k++) {
    double[] kRowB = B[k];
    double ikA = iRowA[k];
    for (int j = 0; j < N; j++) {
        iRowC[j] += ikA * kRowB[j];
    }
}

然后使用Plinq

 var source = Enumerable.Range(0, N);
var pquery = from num in source.AsParallel()
             select num;
pquery.ForAll((e) => Popt(A, B, C, e));

其中Popt是我们的方法名，采用3个锯齿数组(C =A* B)和要计算的行(e)。这有多快：

 1.Name   Milliseconds2.Popt       187

来源：Daniweb

比我们的原始代码快了12倍！有了PLINQ的魔力，我们在这个例子中创建了500个线程，而不需要管理一个线程，所有的事情都会为你处理。

Answer 2

您有两个选项：

1. 使用锯齿数组(如double[][] A)重写代码，它可以将速度提高约2倍。
2. 使用矩阵乘法代码编写非托管C/C++动态链接库。
3. 使用具有本机BLAS实现的第三方数学库。我建议使用Math.NET Numerics，它可以使用吸烟速度很快的switched Intel MKL。

可能，第三种选择是最好的。

Answer 3

仅供记录: CloudCompare不是商业产品。这是一个免费的开源项目。而且没有“庞大的开发团队”(实际上，只有少数人在空闲时间做这件事)。

这是我们最大的秘密:我们使用纯C++代码;)。我们很少使用多线程，但对于非常长的进程(您必须考虑线程管理和处理时间开销)。

下面是一些代码的“最佳实践”规则，这些规则被称为“加载次数”：

将任何动态内存内联为较少(远)函数调用作为possible

• always处理最可能的情况首先是在一个‘if -then- branching

• avoid’非常小的循环中(如果N=2或3，则将它们内联)