Устранение ошибок округления из матрицы

Это не решение; просто более математическое описание того, чего вы пытаетесь достичь (без оценки того, правильно ли это делать):

Поскольку вы округляете все числа до десятичных знаков x, мы можем рассматривать эти числа как целые (просто умножьте их на 10 ^ x).

Теперь вы пытаетесь решить следующую проблему:

Учитывая матрицу

A11+Adj11   A12+Adj12   ...   A1n+Adj1n
A21+Adj21   A22+Adj22   ...   A2n+Adj2n
A31+Adj31   A32+Adj32   ...   A3n+Adj3n
...         ...         ...   ...
Am1+Adjm1   Am2+Adjm2   ...   Amn+Adjmn

Где A11..Amn - постоянные целые числа,

Найти целые числа Adj11 ... Adjmn

Минимизирующая сумма (абс (Adjxy))

(или, может быть, вы предпочитаете: Минимизирующая сумма ((Adjxy) ^ 2)

При условии:

- for each row m: Adjm1+Adjm2+...+Adjmn = - (Am1+Am2+...+Amn)
- for each col n: Adj1n+Adj2n+...+Adjmn = - (A1n+A2n+...+Amn)

Это проблема целочисленного программирования с m * n переменными и m + n ограничениями. Функция, которую вы пытаетесь минимизировать, не является линейной.

Боюсь, что эта проблема далеко не тривиальная. Я считаю, что вам лучше разместить его на https://math.stackexchange.com/

То, что вы здесь испытываете, по сути, является ошибкой точности. Вы ничего не можете сделать, если совсем не округлите. Это похоже на сохранение фотографии как 256-цветного изображения. Вы теряете информацию (по сути, точность; из-за дискретности) и ничего не можете сделать. Для изображений существуют алгоритмы, позволяющие сделать изображения более гладкими / близкими к оригиналу (например, дизеринг), но у вас нет таких вещей для однозначных чисел.

Возможные решения (на самом деле только одно с двумя разными способами визуализации):

• Только круглый для показа. Пользователь должен иметь возможность интерпретировать, что числа усечены / округлены. В вашем примере должно быть очевидно, что 6.67 на самом деле будет 6.66666....

• Не округляйте вообще, а просто обрежьте числа после фиксированного числа десятичных знаков (при необходимости добавьте ...; это фактически похоже на другое решение).

В общем, если вы хотите решать линейные уравнения (или математику в целом), всегда используйте доступный (и разумный; с точки зрения производительности) тип данных с максимальной доступной точностью, обычно это значения с одинарной или двойной точностью. В противном случае вы вводите пределы погрешности, которые становятся все хуже и хуже, чем больше вы рассчитываете с ними.

Вы не можете исключить округление, когда работаете с числами с плавающей запятой. Лучшим решением может быть использование целых чисел в матрице, а затем применение последнего 1/6 к результату.

Обычный способ убедиться, что небольшие ошибки округления не приведут к большой ошибке в сумме, - это проверить, не становится ли ошибка слишком большой для каждой частичной суммы.

С помощью одномерного вектора [a[1], a[2], ..., a[n]] вы можете вычислить частичные суммы [a[1], a[1]+a[2], ..., a[1]+a[2]+...+a[n]], умножить его, а затем восстановить хороший вектор, вычтя предыдущую ячейку из текущей: [a[1]*b, (a[1]+a[2])*b-a[1]*b, ..., (a[1]+a[2]+...+a[n])*b-(a[1]+a[2]+...+a[n-1])*b]. При использовании этого трюка ошибка любой частичной суммы не превышает 10 ^ (- x).

Вы можете адаптировать этот метод для двухмерной матрицы с помощью трех следующих процедур:

partial_sum(M) =
  for i = 0 to n-1 do
    for j = 1 to m-1 do
      M[i][j] += M[i][j-1]
    done
  done
  for i = 0 to n-1 do
    for j = 1 to m-1 do
      M[j][i] += M[j-1][i]
    done
  done

multiply(M, a) =
  for i = 0 to n-1 do
    for j = 0 to m-1 do
      M[i][j] *= a
    done
  done

restore(M) =
  for i = 0 to n-1 do
    for j = 1 to m-1 do
      M[i][j] -= M[i][j-1]
    done
  done
  for i = 0 to n-1 do
    for j = 1 to m-1 do
      M[j][i] -= M[j-1][i]
    done
  done