Как единицы проходят через матричные операции?

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

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

Пекарня Боба продает бублик и кексы. Чтобы испечь десяток бубликов, Бобу нужно 5 чашек муки, 2 яйца и одну чашку сахара. Чтобы испечь дюжину кексов, Бобу нужно 4 чашки муки, 4 яйца и две чашки сахара. Боб может продавать рогалики по 10 долларов за дюжину, а кексы - по 12 долларов за дюжину. У Боба 50 чашек муки, 30 яиц и 20 чашек сахара. Сколько бубликов и кексов должен испечь Боб, чтобы максимизировать свой доход?

Итак, давайте поместим это в матричную форму (произвольный конкретный синтаксис...):

 A = [ [ 5 cups of flour / dozen bagels, 4 cups of flour / dozen muffins ],
       [ 2 eggs          / dozen bagels, 4 eggs          / dozen muffins ],
       [ 1 cups of sugar / dozen bagels, 2 cups of sugar / dozen muffins ] ]

 B = [ [ 10 dollars      / dozen bagels, 12 dollars      / dozen muffins ] ]

 C = [ [ 50 cups of flour ],
       [ 30 eggs          ],
       [ 20 cups of sugar ] ]

Теперь мы хотим максимизировать внутренний продукт B * X такой, что A * X <= C а также X >= 0 обычная задача линейного программирования.

На гипотетическом языке с проверкой единиц, как бы мы идеально представляли типы этих матриц?

Я думаю, что матрице m на n нужны только единицы m + n, а не полные единицы m * n, потому что, если единицы не распределены разумным образом по строкам и столбцам, то единственной разумной оставшейся операцией является сложение / вычитание полностью общая матрица с другой точно такой же формы или умножить ее на скаляр.

Я имею в виду, что расположение подразделений в A гораздо полезнее, чем в:

WTF = [ [ 6 pigeons,      11 cups of sugar ],
        [ 1 cup of sugar, 27 meters        ],
        [ 2 ohms,         2 meters         ] ]

Более того, подобные ситуации просто не возникают на практике. (Кто-нибудь получил контрпример?)

В этом упрощенном предположении мы можем представить единицы матрицы с m + n единицами следующим образом. Для каждой из m строк мы выясним, какие единицы являются общими для всех записей в этой строке, и аналогично для n столбцов. Давайте поместим блоки строк в векторы столбцов и блоки столбцов в векторы строк, потому что это делает Units(M) = RowUnits(M) * ColUnits(M), который выглядит как хорошая собственность. Итак, в примере:

RowUnits(A) = [ [ cups of flour ],
                [ eggs ],
                [ cups of sugar ] ]
ColUnits(A) = [ [ dozen bagels ^ -1, dozen muffins ^ -1 ] ]

RowUnits(B) = [ [ dollars ] ]
ColUnits(B) = [ [ dozen bagels ^ -1, dozen muffins ^ -1 ] ]

RowUnits(C) = [ [ cups of flour ],
                [ eggs ],
                [ cups of sugar ] ]
ColUnits(C) = [ [ 1 ] ]

Кажется, что (хотя я не уверен, как это доказать...) единиц M1 * M2 являются RowUnits(M1 * M2) = RowUnits(M1), ColUnits(M1 * M2) = ColUnits(M2) и для умножения, чтобы иметь смысл, мы требуем ColUnits(M1) * RowUnits(M2) = 1,

Теперь мы можем вывести единицы для X потому что выражение A * X <= C должно означать, что A * X а также C имеют одинаковые единицы. Это означает, что RowUnits(A) = RowUnits(C) (который проверяет), ColUnits(X) = ColUnits(C), а также RowUnits(X) является поэтапной взаимностью транспонирования ColUnits(A), другими словами RowUnits(X) = [ [ dozen bagels ], [ dozen muffins ] ],

("Ура", я слышу, как вы подбадриваете: "Мы просто обошли Луну, чтобы посмотреть на что-то совершенно очевидное!"

У меня такие вопросы:

  1. Можете ли вы вспомнить примеры из реального мира, в которых элементы матрицы имеют единицы, которые не попадают в "единицы строки" и "единицы столбца", как это?
  2. Можете ли вы придумать элегантный способ справиться с ситуациями, когда одна и та же единица является фактором в каждой ячейке, и поэтому она может быть эквивалентно размещена в каждой "строке" или в каждом "столбце", и, таким образом, единицы измерения строки и единицы столбца не являются уникальное представление? Каким должно быть побочное условие, которое удерживает их в "низших терминах" и устраняет глупости, такие как умножение каждой строки на furlongs ^ 17 просто чтобы вы могли умножить каждый столбец на furlongs ^ -17?
  3. Можете ли вы доказать правила, которые я упомянул для распространения этих единичных аннотаций с помощью умножения матриц?
  4. Можете ли вы обнаружить / показать правило для того, как эти аннотации единиц распространяются через операции обратной матрицы? Некоторые ручные вычисления, которые я сделал с матрицей 2x2, показывают, что единицы Inverse(M) поэлементно взаимные единицы Transpose(M), но я не знаю, как показать это для общего случая или даже если это верно для общего случая.
  5. Вам известна какая-либо научная работа по этим вопросам? Или программное обеспечение, которое выполняет этот статический анализ для программ на каком-то языке? Возможно, я использую неправильные условия поиска, но мне трудно что-то найти.

Мои реальные приложения, представляющие интерес, предотвращают провалы в программном обеспечении для обработки сигналов / контроллеров, следя за тем, чтобы все коэффициенты усиления фильтров и т. Д. Имели правильные единицы измерения везде, и использование таких матриц с различными единицами в разных ячейках чрезвычайно распространено в этих приложениях.

Источник

3 ответа

Решение

4) Если вы признаете, что inv(M)*M = Идентичность безразмерна (Id*X=X), это то же самое доказательство, что и 3)

5) Я бы поинтересовался, можно ли расширить BOOST UNITS http://www.boost.org/doc/libs/1_50_0/doc/html/boost_units.html и в конце концов связаться с авторами

1 и 3)
Ваша размерная задача Adim*Xdim=Ydim может быть преобразована в безразмерную задачу A*X=Y

  • Вы делите свои входные параметры X на их соответствующие единицы (X)
  • и вы умножаете свои выходы Y на их соответствующие единицы (Y) впоследствии

То есть

Ydim=diag(units(Y))*Y
Ydim=diag(units(Y))*A*X
Ydim=diag(units(Y))*A*inv(diag(units(X)))*Xdim
Ydim=Adim*Xdim

Или другой способ

Adim*Xdim=Ydim
Adim*diag(units(X))*X=diag(units(Y))*Y
Adim*diag(units(X))*X=diag(units(Y))*A*X

Это верно для любого X, так что вы обнаружите, что

A=inv(diag(units(Y))) * Adim * diag(units(X))
Adim=diag(units(Y)) * A * inv(diag(units(X)))

То есть строки безразмерного A умножаются на единицы Y и столбцы на обратные единицы X

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

Источник

Очень хорошим источником информации по этой теме является Книга «Многомерный анализ» Джорджа У. Харта, на которую также ссылаются в комментариях к вопросу. Относительно отдельных вопросов (математические результаты объясняются в книге):

Прежде всего, нам нужно ввести небольшое обозначение. Оператор квадратных скобок извлекает физическую единицу (единицы) матрицы / элемента матрицы, т . е . дает нам единицу элемента (i, j) в матрице A. Кроме того, оператор ~ транспонирует вектор / матрицу и инвертирует ее единицы. , т.е.

Затем нам нужен еще один результат из книги, который говорит, что единицы в любой умножаемой матрице A могут быть записаны как , т.е. единицы элементов матрицы могут быть описаны внешним произведением 2 векторов a и b, где a - вектор-столбец, а b^\sim — вектор-строка с инвертированными единицами измерения.

Ответ на 4): заданы единицы, обратные матрице A, что означает, что единицы поэлементно обратны исходным единицам, как уже было предложено в исходном вопросе.

Относительно 3): Да, ваши правила умножения матриц верны, если внутренние единицы идентичны и, таким образом, сокращаются, т.е.

Однако также можно было бы умножать матрицы, в которых внутренние единицы столбца / строки параллельны по размеру: (здесь b / c неофициально относится к общему единичному коэффициенту, на который необходимо умножить c, чтобы получить c )

Относительно 2): обычно каждая строка или столбец матрицы относится к определенной физической величине, которая индуцирует каноническое представление единиц строки и столбца. В качестве примера рассмотрим ковариационную матрицу положения (x,y) в приложении фильтрации Калмана. Там ясно, что строки и столбцы описывают x- и y-позицию в определенной физической единице, например, все единицы строки и столбца равны [m], что приводит к единице [m^2] для каждого из элементов матрицы. . Также можно было бы использовать [м/с] и [с*м] в качестве единиц строки и столбца, что также привело бы к единице измерения [м^2] для каждого элемента.

Однако из описания задачи должно быть ясно, что первое представление является более содержательным.

Относительно 5): есть книга Джорджа У. Харта и очень короткая статья с несколькими ключевыми результатами из книги https://www.georgehart.com/research/tdm.ps . Что касается программных реализаций, то в этом выступлении на конференции Meeting C++ 2021 https://www.youtube.com/watch?v=4LmMwhM8ODI описывается реализация библиотеки, способной аннотировать матрицы и векторы физическими единицами, где все проверки выполняются во время компиляции. Представленная библиотека также может полностью обрабатывать пример дискретного фильтра Калмана, который описан в одном из других ответов.

Источник

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

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

Я только что коснулся этой проблемы, пытаясь реализовать алгоритм объединения сенсоров, используя DKF с C++ и строго типизированное представление значений в коде.

Существует множество реализаций фильтра Калмана, в которых разработчики просто используют векторы и матрицы целых чисел, чисел с плавающей точкой, двойных чисел и т. Д., Но я хотел бы отслеживать размерность всех используемых значений, а затем возникла проблема.

К сожалению, я достаточно свежа в этой проблеме (все еще работаю над ней), поэтому я пока не могу помочь вам с ответами со 2 по 5:-/

Источник
Другие вопросы по тегам