Умножение с плавающей запятой Возвращает ovf или -0,0 для небольших целых чисел с плавающей запятой.

Я написал простую функцию умножения матриц. Изначально мои матрицы хранятся в одном массиве в формате (строка, столбец):

(row0, col0), (row0, col1), (row0, colN), (row1, col0), ... (rowN, col0).

так выглядела бы идентификационная матрица 2 x 2

float eye[4] = {1, 0, 0, 1};

В реальной функции я помещаю 2 матрицы массива, умноженные на 2d-массивы (легко читаемые человеком), а затем выполняю умножение, чтобы получить новый вывод матрицы. Затем конвертируйте обратно в один массив. Я имею дело только с матрицами 3x3, 3x1 и 1x3. Так что мой код не на 100% совместим с каждой возможностью матрицы. У меня есть глобальные массивы temp3 для моих матриц 3x1 и 1x3 и temp3x3 для хранения матриц 3x3. Я использую глобальный логический квадрат, чтобы определить, к какому из них перейдет новый вывод.

Я понимаю, что мой код неидеален, но у меня вопрос: почему я получаю переполнение для простых операций? Мой код выглядит следующим образом:

#include <math.h>
#include <WString.h>

#define FLOAT sizeof(float)
void multiplyMatrixAxB(const uint8_t rows1, const uint8_t cols1, const uint8_t size1, float matrix1[], const uint8_t rows2, const uint8_t cols2, const uint8_t size2, float matrix2[]);

float K[3]; // 3x1
float dgdn[3]; // 1x3

bool squared = false;
// Временная переменная для хранения матриц
float temp3x3[9];
float temp3[3];

void setup()
{
  Serial.begin(115200);
  Serial.println(F("Starting Matrix Test Program\n"));
  
  uint8_t i;
  K[0] = 1.0;
  K[1] = 2.0;
  K[2] = 3.0;

  dgdn[0] = 0.0;
  dgdn[1] = 0.0;
  dgdn[2] = 1.0;

  Serial.println(F("Matrix K setup as:"));
  for(i = 0; i < sizeof(K)/FLOAT; i++)
  {
    Serial.print(K[i]);
    Serial.print(F("\n"));
  }

  Serial.println(F("Matrix dgdn setup as:"));
  for(i = 0; i < sizeof(dgdn)/FLOAT; i++)
  {
    Serial.print(dgdn[i]);
    Serial.print(F("\t"));
  }
}

void loop()
{
  squared = true;
  Serial.println(F("\n\nA 3x1 times a 1x3 should give 3x3"));
  multiplyMatrixAxB(3,1, sizeof(K)/FLOAT, K, 1, 3, sizeof(dgdn)/FLOAT, dgdn);
  for(i = 0; i < 9; i++)
  {
    Serial.print(*(temp3x3 + i), 6);
    if(!((i+1)%3))
    {
      Serial.println();
    }
    else
    {
      Serial.print(F("\t"));
    }
  }

  Serial.print(F("\n\n"));
  Serial.println(F("End of Test"));
  while(1){delay(1000);}
}

void multiplyMatrixAxB(const uint8_t rows1, const uint8_t cols1, const uint8_t size1, float matrix1[], const uint8_t rows2, const uint8_t cols2, const uint8_t size2, float matrix2[])
{
  if(cols1 != rows2)
  {
    Serial.println(F("Multiplying Invalid Matrixes. Check ColsA and RowsB"));
    while(1){delay(1000);}
  }
  
  if(size1 != rows1*cols1)
  {
    Serial.println(F("rows and columns do not match size of matrix A"));
    while(1){delay(1000);}
  }
  
  if(size2 != rows2*cols2)
  {
    Serial.println(F("rows and columns do not match size of matrix B"));
    while(1){delay(1000);}
  }
  
  uint8_t row, column, k, i;
  double mat1[rows1][cols1];
  double mat2[rows2][cols2];
  double newMat[rows1][cols2];

  // поместить матрицу1 в массив 2d
  row = 0;
  for(row = 0; row < rows1; row++)
  {
    column = 0;
    for(column = 0; column < cols1; column++)
    {
      mat1[row][column] = matrix1[row*cols1 + column];
    }
  }

  // поместить матрицу2 в массив 2d
  row = 0;
  for(row = 0; row < rows2; row++)
  {
    column = 0;
    for(column = 0; column < cols2; column++)
    {
      mat2[row][column] = matrix2[row*cols2 + column];
    }
  }

  // получаем новый массив с перемноженными значениями
  row = 0;
  for(row = 0; row < rows1; row++)
  {
    column = 0;
    for(column = 0; column < cols2; column++)
    {
      k = 0;
      for(k = 0; k < cols1; k++)
      {
        newMat[row][column] += mat1[row][k]*mat2[k][column];
      }
    }
  }

  row = 0;
  i = 0;
  // Помещаем новую матрицу в формат одного массива
  for(row = 0; row < rows1; row++)
  {
    column = 0;
    for(column = 0; column < cols2; column++)
    {
      if(squared)
      {
        temp3x3[i] = newMat[row][column];
      }
      else
      {
        temp3[i] = newMat[row][column];
      }
      i++;
    }
  }
}

Надеюсь, это все. У меня есть еще код, но он весь в основном закомментирован. В худшем случае я пропустил здесь объявление переменной, но отмечу, что в среде IDE она компилируется и работает нормально. Мой вывод выглядит так:

Starting Matrix Test Program

Matrix K setup as:
1.00
2.00
3.00
Matrix dgdn setup as:
0.00    0.00    1.00    

A 3x1 times a 1x3 should give 3x3
0.000000    0.000000    1.000000
ovf 0.000000    2.000000
0.000000    0.000000    3.000000


End of Test

Откуда взялся этот ovf? Я попытался распечатать в операторе умножения в цикле for индекс mat1 x индекс mat2 = "результат". Это на самом деле распечатает именно то, что я ожидаю увидеть, и тогда мой вывод в основном цикле будет в порядке. Что здесь происходит? Я попробовал некоторые задержки, чтобы увидеть, была ли это проблема между вычислениями. Плохо.

я имею в виду размещение в самом внутреннем цикле for (цикл k):

''' Serial.print (mat1 [строка] [k]); Serial.print("x"); Serial.print (mat2 [k] [столбец]); Serial.print ("+"); ''' А затем сразу за ним,

''' Serial.print(" = "); Serial.println (newMat [строка] [столбец]); '''

В этом сценарии я не получу переполнения.