python - integrales - como usar sympy

SymPy-Número arbitrario de símbolos

Question

Estoy codificando una función que resuelve un número arbitrario de ecuaciones simultáneas. El número de ecuaciones se establece mediante uno de los parámetros de la función y cada ecuación se construye a partir de una serie de símbolos, tantos símbolos como ecuaciones. Esto significa que no puedo simplemente codificar las ecuaciones, o incluso los símbolos necesarios para armar las ecuaciones; la función debe ser capaz de manejar cualquier número de ecuaciones. Entonces, mi pregunta es, ¿cómo puedo producir una lista de símbolos?

Tengo una solución posible, pero mi instinto me dice que no va a ser muy eficiente. Por favor, hágamelo saber si hay una mejor manera de hacerlo.

Soy nuevo en SymPy y sigo sintiendo mi camino. Por lo que puedo ver, los símbolos deben definirse con una cadena. Por lo tanto, puedo producir una serie de cadenas mediante la adición de un número creciente a una letra (por ejemplo, ''t0'', ''t1'', etc.), agregarlas a una lista y luego crear los símbolos utilizando esas cadenas como parámetros. Esos símbolos se almacenarían en una lista y se usarían para producir las ecuaciones.

def solveEquations(numEquations):
    symbolNameList = []
    symbolList = []
    equationList = []
    for i in range(numEquations):
        name = ''t'' + str(i)
        symbolNameList.append(name)
        symbolList.append(Symbol(name))

    for i in range(numEquations):
        equation = 0
        for sym in symbolList:
            equation += sym ** i # Or whatever structure the equation needs
        equationList.append(equation)


    #Then go on to solve the equations...

¿Es esta la mejor manera de hacer esto o existe un enfoque más eficiente?

Answer 1

Con locals() y la comprensión del diccionario, puede generar iterativamente símbolos y variables locales de python con un nombre similar. Por ejemplo:

>>> symbols_dict = dict((''a%d''%k, symbols(''a%d''%k)) for k in range(3))
>>> locals().update(symbols_dict)

Comprobando que funciona:

>>> print(expand((a0+a2)*(a0+a1**2)))
a0**2 + a0*a1**2 + a0*a2 + a1**2*a2

Answer 2

La función de symbols se puede utilizar para generar fácilmente listas de símbolos.

In [1]: symbols(''a0:3'')
Out[1]: (a₀, a₁, a₂)

In [2]: numEquations = 15

In [3]: symbols(''a0:%d''%numEquations)
Out[3]: (a₀, a₁, a₂, a₃, a₄, a₅, a₆, a₇, a₈, a₉, a₁₀, a₁₁, a₁₂, a₁₃, a₁₄)

Answer 3

Podrías hacer una subclase de dict que devuelva automáticamente los Symbols :

import sympy as sym

class SymDict(dict):
    # http://.com/a/3405143/190597
    def __missing__(self, key):
        self[key]=sym.Symbol(key)
        return self[key]

def solveEquations(numEquations):
    symbol = SymDict()
    symbolList = [''t''+str(i) for i in range(numEquations)]
    equationList = [sum(symbol[s]**i for s in symbolList)
                    for i in range(numEquations)]
    print(equationList)

solveEquations(3)    
# [3, t0 + t1 + t2, t0**2 + t1**2 + t2**2]

Answer 4

Su enfoque está bien, aunque no es necesario almacenar los nombres de los símbolos por separado (puede acceder al nombre de un símbolo a través de su propiedad de name ).

Además, podría expresar la creación del símbolo de forma más concisa (aunque no de manera más eficiente), por ejemplo:

symbolList = map(lambda i: Symbol(''t'' + str(i)), xrange(numEquations))

Sin embargo, para su caso de uso (variables temporales), las variables ficticias son probablemente el camino a seguir:

symbolList = map(Dummy, xrange(numEquations))

Esto realmente no es más eficiente, ya que internamente la clase Dummy también está usando un contador para generar nombres únicos, pero es un poco más claro y claro.

Answer 5

numbered_symbols("t") devolverá un generador que genera t0 , t1 , t2 , etc. Puede usar el parámetro de start para elegir un valor de inicio diferente. Y si desea usar variables ficticias, use numbered_symbols("t", cls=Dummy) .