C# 如何将给定的矩阵与其转置相乘？

我必须创建一个方法，将给定的矩阵乘以它的转置

假设我的矩阵是2d数组

double[][]矩阵

public double[][] MultiplyByTranspose(double[][] matrix) 
{  
    return newMatrix;
}

如果您需要我的矩阵类，请在
中检查它，最简单的方法就是实现转置和乘法

当然，当组合起来时，它可以更有效地完成，但我认为在代码中需要将转置和乘法作为分离的例程（您已经询问了矩阵旋转）

public静态布尔IsRectangle（双[][]值）{
if（Object.ReferenceEquals（null，value））
返回false；
else if（value.Length=0；--i）
if（Object.ReferenceEquals（null，值[i]））
返回false；
else if（值[i]。长度！=大小）
返回false；
返回true；
}
公共静态双[][]转置（双[][]值）{
if（Object.ReferenceEquals（null，value））
抛出新的ArgumentNullException（“值”）；
如果（！IsRectangle（值））
抛出新ArgumentException（“值应该是矩形矩阵。”，“值”）；
int colCount=value.Length；
int rowCount=value[value.Length-1].Length；
Double[]result=新的Double[rowCount][]；
对于（int i=rowCount-1；i>=0；--i）{
Double[]行=新的Double[colCount]；
结果[i]=直线；
对于（int j=colCount-1；j>=0；--j）
第[j]行=值[j][i]；
}
返回结果；
}
//简单quibic算法
公共静态双精度[]乘（左双精度[]乘，右双精度[]乘）{
if（Object.ReferenceEquals（null，左））
抛出新的ArgumentNullException（“左”）；
else if（Object.ReferenceEquals（null，右））
抛出新的异常（“右”）；
如果（！IsRectangle（左））
抛出新ArgumentException（“左应为矩形矩阵”、“左”）；
如果（！IsRectangle（右））
抛出新的ArgumentException（“右边应该是矩形矩阵”，“右边”）；
int leftRows=left.Length；
int leftCols=left[0]。长度；
int rightRows=right.Length；
int rightCols=right[0]。长度；
if（leftCols！=rightRows）
抛出新ArgumentOutOfRangeException（“右”）；
Double[]result=新的Double[leftRows][]；
对于（int r=leftRows-1；r>=0；--r）{
双[]左行=左[r]；
Double[]行=新的Double[rightCols]；
结果[r]=直线；
对于（int c=rightCols-1；c>=0；--c）{
双s=0.0；
对于（int i=leftCols-1；i>=0；--i）
s+=左行[i]*右行[i][c]；
第[c]=s行；
}
}
返回结果；
}
...
公共双[][]多重传输（双[][]矩阵）{
//TODO:检查顺序！哪个矩阵应该是第一个，哪个是第二个，
//线性代数中的A*B！=B*A
返回乘法（矩阵，转置（矩阵））；
//或
//返回乘法（转置（矩阵），矩阵）；
}
@Octoshape如果我不知道如何旋转矩阵，我可以尝试什么！如果你帮不上忙，请停止发布同样的无用评论。请原谅我试图适应本网站的规则，但你似乎没有尝试过任何东西（因此可能是否决票，顺便说一句，这不是我的）。你根本不必旋转矩阵，旋转只是一个简单的工具，可以直观地显示转置矩阵的效果。转置矩阵时，将列视为行，将行视为列，即第一行变为第一列，依此类推。@Dirk这是真的。。我现在正在研究为什么它只适用于矩形矩阵？可能是个愚蠢的问题，但只是想知道。@Octoshape：据我所知，线性代数（转置、乘法等）只使用矩形矩阵，而不是锯齿矩阵。@Octoshape数学上只有矩形矩阵，正方形矩阵是一种特例。但是，使用
double[][]
来描述矩阵并不能保证它是矩形的。为此，您必须使用一个
double[，]
。将索引“转置”不是比进行真正的转置更容易吗？矩阵乘法需要矩阵，所以左和右都应该是double[]。此外，向量有两种可能（即Double[]）：列向量或行向量，它们分别是Double[2][1]和Double[1][2]。如果是2x1矩阵（两行各一项），则Double[]]v=新的Double[]{new Double[]{a11}，新的Double[]{a21}；
public static Boolean IsRectangle(Double[][] value) {
  if (Object.ReferenceEquals(null, value))
    return false;
  else if (value.Length <= 0)
    return false;

  Double[] line = value[value.Length - 1];

  if (Object.ReferenceEquals(null, line))
    return false;

  int size = line.Length;

  for (int i = value.Length - 2; i >= 0; --i)
    if (Object.ReferenceEquals(null, value[i]))
      return false;
    else if (value[i].Length != size)
      return false;

  return true;
}

public static Double[][] Transpose(Double[][] value) {
  if (Object.ReferenceEquals(null, value))
    throw new ArgumentNullException("value");

  if (!IsRectangle(value))
    throw new ArgumentException("value should be a rectangular matrix.", "value");

  int colCount = value.Length;
  int rowCount = value[value.Length - 1].Length;

  Double[][] result = new Double[rowCount][];

  for (int i = rowCount - 1; i >= 0; --i) {
    Double[] line = new Double[colCount];
    result[i] = line;

    for (int j = colCount - 1; j >= 0; --j)
      line[j] = value[j][i];
  }

  return result;
}

// Simple quibic algorithm
public static Double[][] Multiply(Double[][] left, Double[][] right) {
  if (Object.ReferenceEquals(null, left))
    throw new ArgumentNullException("left");
  else if (Object.ReferenceEquals(null, right))
    throw new ArgumentNullException("right");

  if (!IsRectangle(left))
    throw new ArgumentException("left should be a rectangular matrix", "left");
  else if (!IsRectangle(right))
    throw new ArgumentException("right should be a rectangular matrix", "right");

  int leftRows = left.Length;
  int leftCols = left[0].Length;

  int rightRows = right.Length;
  int rightCols = right[0].Length;

  if (leftCols != rightRows)
    throw new ArgumentOutOfRangeException("right");

  Double[][] result = new Double[leftRows][];

  for (int r = leftRows - 1; r >= 0; --r) {
    Double[] leftLine = left[r];
    Double[] line = new Double[rightCols];
    result[r] = line;

    for (int c = rightCols - 1; c >= 0; --c) {
      Double s = 0.0;

      for (int i = leftCols - 1; i >= 0; --i)
        s += leftLine[i] * right[i][c];

      line[c] = s;
    }
  }

  return result;
}

...

public double[][] MultiplyByTranspose(double[][] matrix) {  
  //TODO: Check the order! Which matrix should be the first and which the second,
  // In Linear Algebra A * B != B * A 
  return Multiply(matrix, Transpose(matrix));
  // Or 
  // return Multiply(Transpose(matrix), matrix);
}