Question

我正在寻找在C＃中对3x3轮换和4x4转换矩阵执行matrix * matrix和matrix * vector操作的最有效方法。

我目前将我的矩阵存储在多维数组中（new double[3,3]，new double[4,4]）。我并不完全不喜欢改变它，但如果可能的话我想保留语法。我使用3标准嵌套for循环的当前乘法工作正常但可能是瓶颈。

到目前为止我的想法：

像Strassen这样的优化算法对于这些尺寸不实用
并行化在单个4x4乘法的水平上没有多大意义;在更高的层次上做得更好。
由于边界检查效率较低，多维数组在c＃中较慢（为？），但是这可以通过不安全的指针算法来克服。（我不确定这些信息目前是多少）
旋转矩阵是对称的，可能有办法利用它吗？
可以通过使用缓存局部性来实现最大的收益，确保一起访问内存中靠近的值;但我不确定该怎么做。

所以在我使用不安全，固定和3 for循环来解决我自己的解决方案之前，是否已针对此标准问题进行了经过测试和优化的解决方案？

还是有其他优化我忽略了吗？

Answer 1

这是我使用的，它的工作速度惊人。

public struct Matrix3 
{
    public readonly double a11, a12, a13;
    public readonly double a21, a22, a23;
    public readonly double a31, a32, a33;
    ...
    public vec3 Multiply(vec3 rhs)
    {
        // y= A*x
        // fill vector by element
        return new vec3(
            (a11*rhs.X+a12*rhs.Y+a13*rhs.Z),
            (a21*rhs.X+a22*rhs.Y+a23*rhs.Z),
            (a31*rhs.X+a32*rhs.Y+a33*rhs.Z));
    }

    public mat3 Multiply(mat3 rhs)
    {
        // Y = A*X
        // fill matrix by row
        return new mat3(
            (a11*rhs.a11+a12*rhs.a21+a13*rhs.a31),
            (a11*rhs.a12+a12*rhs.a22+a13*rhs.a32),
            (a11*rhs.a13+a12*rhs.a23+a13*rhs.a33),

            (a21*rhs.a11+a22*rhs.a21+a23*rhs.a31),
            (a21*rhs.a12+a22*rhs.a22+a23*rhs.a32),
            (a21*rhs.a13+a22*rhs.a23+a23*rhs.a33),

            (a31*rhs.a11+a32*rhs.a21+a33*rhs.a31),
            (a31*rhs.a12+a32*rhs.a22+a33*rhs.a32),
            (a31*rhs.a13+a32*rhs.a23+a33*rhs.a33));
    }
}

其中vec3和mat3是我自己的Vector3和Matrix3结构的别名，它们存储元素是字段。类似地，对于4个元素结构我也把它编码为这样的反转：

    public double Determinant()
    {
        return a11*(a22*a33-a23*a32)
            +a12*(a23*a31-a21*a33)
            +a13*(a21*a32-a22*a31);
    }
    /// <summary>
    /// Solves the system of equations this*x=rhs for x
    /// </summary>
    public vec3 Solve(vec3 rhs)
    {
        double D=Determinant();
        double ID=1/D;
        return new vec3(
            (((a22*a33-a23*a32)*rhs.X+(a13*a32-a12*a33)*rhs.Y+(a12*a23-a13*a22)*rhs.Z)*ID),
            -(((a21*a33-a23*a31)*rhs.X+(a13*a31-a11*a33)*rhs.Y+(a11*a23-a13*a21)*rhs.Z)*ID),
            (((a21*a32-a22*a31)*rhs.X+(a12*a31-a11*a32)*rhs.Y+(a11*a22-a12*a21)*rhs.Z)*ID));
    }
    /// <summary>
    /// Solves the system of equations this*X = rhs for X
    /// </summary>
    public mat3 Solve(mat3 rhs)
    {
        double D=Determinant();
        double ID=1/D;
        return new mat3(
            (((a22*a33-a23*a32)*rhs.a11+(a13*a32-a12*a33)*rhs.a21+(a12*a23-a13*a22)*rhs.a31)*ID),
            (((a22*a33-a23*a32)*rhs.a12+(a13*a32-a12*a33)*rhs.a22+(a12*a23-a13*a22)*rhs.a32)*ID),
            (((a22*a33-a23*a32)*rhs.a13+(a13*a32-a12*a33)*rhs.a23+(a12*a23-a13*a22)*rhs.a33)*ID),

            -(((a21*a33-a23*a31)*rhs.a11+(a13*a31-a11*a33)*rhs.a21+(a11*a23-a13*a21)*rhs.a31)*ID),
            -(((a21*a33-a23*a31)*rhs.a12+(a13*a31-a11*a33)*rhs.a22+(a11*a23-a13*a21)*rhs.a32)*ID),
            -(((a21*a33-a23*a31)*rhs.a13+(a13*a31-a11*a33)*rhs.a23+(a11*a23-a13*a21)*rhs.a33)*ID),

            (((a21*a32-a22*a31)*rhs.a11+(a12*a31-a11*a32)*rhs.a21+(a11*a22-a12*a21)*rhs.a31)*ID),
            (((a21*a32-a22*a31)*rhs.a12+(a12*a31-a11*a32)*rhs.a22+(a11*a22-a12*a21)*rhs.a32)*ID),
            (((a21*a32-a22*a31)*rhs.a13+(a12*a31-a11*a32)*rhs.a23+(a11*a22-a12*a21)*rhs.a33)*ID));
    }

Answer 2

如果你希望它在Microsoft C＃中进行性能，我会;

推出循环。不要使用循环，而是全部写出来这对于这些较小的固定大小乘法是可行的。
应用第一个建议后，请尝试使用不安全的固定版本（这对许多快速阵列访问仍然很重要）

对于Mono，Mono.SIMD库可能值得一看。

对于使用GPU的并行性，如果可以卸载则非常适合其中许多是同时的。对于C＃，我会调查http://www.hybriddsp.com/Products/CUDAfyNET.aspx，但可能还有其他人。我还没有从C＃中做过任何GPU的东西，但这个是我的起点。

快速旋转/变换矩阵乘法

2 个答案: