Inverse of 3x3 Matrix with Complex Numbers

[toml_12953]

(07-16-2019 05:47 AM)deetee Wrote:  Hi!

At least I found some improvement by myself to reduce the code size by summarizing similar code in subroutines - and call them with (a lot of) index parameters:

Code:

static void _mdetrc(byte r1, byte r2, byte r3, byte c1, byte c2, byte c3, int8_t mult) {
  stack[2] = ma[r1][c1]; stacki[2] = mai[r1][c1];
  stack[1] = ma[r2][c2]; stacki[1] = mai[r2][c2];
  stack[0] = ma[r3][c3]; stacki[0] = mai[r3][c3];
  _mult(); _mult();
  mdet += mult * stack[0]; mdeti += mult * stacki[0];
}
static void _mdet(void) { // MATRIX DET A
  mdet = mdeti = 0.0;
  _mdetrc(0, 1, 2, 0, 1, 2, 1);
  _mdetrc(0, 1, 2, 1, 2, 0, 1);
  _mdetrc(0, 1, 2, 2, 0, 1, 1);
  _mdetrc(2, 1, 0, 0, 1, 2, -1);
  _mdetrc(2, 1, 0, 1, 2, 0, -1);
  _mdetrc(2, 1, 0, 2, 0, 1, -1);
  stack[0] = mdet; stacki[0] = mdeti;
}
static void _minvrc(byte r1, byte r2, byte r3, byte r4, byte c1, byte c2, byte c3, byte c4, byte r, byte c) {
  stack[3] = ma[r1][c1]; stacki[3] = mai[r1][c1]; // Calculates inverse matrix element
  stack[2] = ma[r2][c2]; stacki[2] = mai[r2][c2];
  stack[1] = ma[r3][c3]; stacki[1] = mai[r3][c3];
  stack[0] = ma[r4][c4]; stacki[0] = mai[r4][c4];
  _mult(); _rot(); _mult(); _rotup(); _sub(); _push();
  stack[0] = mdet; stacki[0] = mdeti;
  _div();
  mc[r][c] = stack[0]; mci[r][c] = stacki[0];
}
static void _minv(void) { // MATRIX INVERSE A
  _mdet();
  _minvrc(1, 2, 2, 1, 1, 2, 1, 2, 0, 0); // C00
  _minvrc(0, 2, 0, 2, 2, 1, 1, 2, 0, 1); // C01
  _minvrc(0, 1, 0, 1, 1, 2, 2, 1, 0, 2); // C02
  _minvrc(1, 2, 1, 2, 2, 0, 0, 2, 1, 0); // C10
  _minvrc(0, 2, 0, 2, 0, 2, 2, 0, 1, 1); // C11
  _minvrc(0, 1, 0, 1, 2, 0, 0, 2, 1, 2); // C12
  _minvrc(1, 2, 1, 2, 0, 1, 1, 0, 2, 0); // C20
  _minvrc(0, 2, 0, 2, 1, 0, 0, 1, 2, 1); // C21
  _minvrc(0, 1, 0, 1, 0, 1, 1, 0, 2, 2); // C22
  memcpy(ma, mc, 3 * 3 * sizeof(double)); // A = C
  memcpy(mai, mci, 3 * 3 * sizeof(double));
}

Thanks in advance for any hint.
Regards deetee

Have you benchmarked your routine vs. the built-in routines? I'd be curious to see if there's a significant difference one way or the other.