Вычисление сложных математических уравнений в питоне

Question

Существуют ли какие-либо библиотеки или методы, которые упрощают вычислительные уравнения?

Возьмите следующие два примера:

• F = B * {[a * b * sumOf (A / B '' 'для всех i' '')] / [sumOf (c * d * j)]}

  где:

  F = стоимость от i до j

  B, a, b, c, d, j - все векторы в формате [[zone_i, zone_j, cost_of_i_to_j], [..]]

  Это должно создать вектор F [[1,2, F_1_2], ..., [i, j, F_i_j]]

• T_ij = [P_i * A_i * F_i_j] / [SumOf [Aj * F_i_j] // j = 1 до j = n]

  где:

  n - количество зон

  T = вектор [[1, 2, A_1_2, P_1_2], ..., [i, j, A_i_j, P_i_j]]

  F = вектор [1, 2, F_1_2], ..., [i, j, F_i_j]

  поэтому P_i будет суммой всех P_i_j для всех j, а Aj будет суммой всех P_j для всех i

Я не уверен, что я ищу, но, возможно, синтаксический анализатор этих уравнений или методов, чтобы иметь дело с множественными умножениями и произведениями между векторами?

Чтобы вычислить некоторые из факторов, например, A_j, это то, что я использую

from collections import defaultdict

A_j_dict = defaultdict(float)
for A_item in TG: A_j_dict[A_item[1]] += A_item[3]

Хотя это работает нормально, я действительно чувствую, что это метод грубой силы / взлома, и он не поддерживается в случае, если мы хотим добавить больше переменных или параметров. Какие парсеры математических уравнений вы бы порекомендовали?

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

Спасибо:)

Answer 1

Для поэлементного умножения двух массивов NumPy с одинаковым измерением просто 'A * B'.

In [1]: a = arange(50)

In [2]: b = ones(50) * 2

In [3]: a
Out[3]: 
array([ 0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14, 15, 16,
       17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33,
       34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49])

In [4]: b
Out[4]: 
array([ 2.,  2.,  2.,  2.,  2.,  2.,  2.,  2.,  2.,  2.,  2.,  2.,  2.,
        2.,  2.,  2.,  2.,  2.,  2.,  2.,  2.,  2.,  2.,  2.,  2.,  2.,
        2.,  2.,  2.,  2.,  2.,  2.,  2.,  2.,  2.,  2.,  2.,  2.,  2.,
        2.,  2.,  2.,  2.,  2.,  2.,  2.,  2.,  2.,  2.,  2.])

In [5]: a * b
Out[5]: 
array([  0.,   2.,   4.,   6.,   8.,  10.,  12.,  14.,  16.,  18.,  20.,
        22.,  24.,  26.,  28.,  30.,  32.,  34.,  36.,  38.,  40.,  42.,
        44.,  46.,  48.,  50.,  52.,  54.,  56.,  58.,  60.,  62.,  64.,
        66.,  68.,  70.,  72.,  74.,  76.,  78.,  80.,  82.,  84.,  86.,
        88.,  90.,  92.,  94.,  96.,  98.])

In [6]: (a * b).sum()
Out[6]: 2450.0

Если вы можете писать вещи в терминах умножения матриц, вы можете использовать dot():

In [7]: A = arange(25).reshape((5,5))

In [8]: X = arange(5)

In [9]: A
Out[9]: 
array([[ 0,  1,  2,  3,  4],
       [ 5,  6,  7,  8,  9],
       [10, 11, 12, 13, 14],
       [15, 16, 17, 18, 19],
       [20, 21, 22, 23, 24]])

In [12]: dot(A, X) # Sum_j A[i,j] * X[j] for all i
Out[12]: array([ 30,  80, 130, 180, 230])

Это должно начать вас.

Answer 2

Кстати, есть пара математических модулей, nzmath и mpmath, которые имеют больше, чем у Картера, есть печеночные таблетки.

LL

Answer 3

Распространенным решением этой задачи является NumPy .

Ваши уравнения кажутся достаточно близкими к векторным и матричным уравнениям, поэтому массивы и матрицы NumPy должны быть очень полезны.

Вот пример, основанный на том, что вы хотите:

T_ij = [P_i * A_i * F_i_j] / [ SumOf [Aj * F_i_j] // от j = 1 до j = n ]

, где: n - количество зон

T = вектор [[1, 2, A_1_2, P_1_2], ..., [i, j, A_i_j, P_i_j]]

F = вектор [1, 2, F_1_2], ..., [i, j, F_i_j]

так что P_i будет суммой всех P_i_j для всех j и Aj будет сумма все P_j для всех я

Это можно рассчитать, например, с помощью:

import numpy as np
A = np.array([…]); P = np.array(…)  # Vectors (1D arrays)
F = np.array([[…], […],…])  # 2D array
T = (P*A*F.T).T/np.dot(F, A)

Вы видите, что конечный результат выражается в довольно компактной форме благодаря NumPy. Вычисления массива NumPy также очень быстрые.

То, что вы пытаетесь достичь, действительно идеальная работа для NumPy. Если вы готовы освоить этот инструмент, я бы посоветовал вам пройти обучение по Numpy .