Tengo el siguiente problema:

Quiero usar autowrap para generar una versión compilada de una matriz sympy, con celdas que contengan expresiones sympy. Dependiendo de la especificación de mi problema, la cantidad de argumentos puede ser muy grande.

Me encontré con los siguientes 2 problemas:

El número de argumentos que acepta el ajuste automático parece estar limitado a 509.

es decir, esto funciona:

import sympy
from sympy.utilities.autowrap import autowrap

x = sympy.symbols("x:509")
exp = sum(x)
cyt = autowrap(exp, backend="cython", args=x) 

y esto no puede compilar:

x = sympy.symbols("x:510")
exp = sum(x)
cyt = autowrap(exp, backend="cython", args=x) 

El mensaje que recibo parece poco revelador:

[...] (Full output upon request)
Generating code
c:\users\[classified]\appdata\local\temp\tmp2zer8vfe_sympy_compile\wrapper_module_17.c(6293) : fatal error C1001: An internal error has occurred in the compiler.
(compiler file 'f:\dd\vctools\compiler\utc\src\p2\hash.c', line 884)
 To work around this problem, try simplifying or changing the program near the locations listed above.
Please choose the Technical Support command on the Visual C++ 
 Help menu, or open the Technical Support help file for more information
LINK : fatal error LNK1257: code generation failed
error: command 'C:\\Program Files (x86)\\Microsoft Visual Studio 14.0\\VC\\BIN\\x86_amd64\\link.exe' failed with exit status 1257

¿Hay alguna forma de evitar esto? Me gustaría usar versiones de mi programa que necesiten ~ 1000 variables de entrada. (No entiendo C / cython. ¿Es esta una limitación de autoenvoltura, una limitación de C ...?)

Parcialmente conectado a lo anterior:

¿Se pueden compilar funciones que acepten los argumentos como matriz?

¿Hay alguna forma de generar código que acepte una matriz numpy como entrada? Me refiero específicamente a una matriz para todos los argumentos, en lugar de proporcionar los argumentos como una lista. (Similar a lambdify usando un DeferredVector). ufuncify admite entrada de matriz, pero como entiendo solo para transmitir / vectorizar la función.

Espero que una matriz como argumento pueda eludir el primer problema anterior, que es lo más urgente para mí. Aparte de eso, preferiría la entrada de matriz de todos modos, tanto porque parece más rápido (no es necesario desempaquetar la matriz numpy que tengo como entrada en una lista), y también más directa y natural.

¿Alguien tiene alguna sugerencia de lo que puedo hacer? Además, ¿alguien podría decirme si f2py tiene limitaciones similares? Esto también sería una opción para mí si fuera factible, pero no lo tengo configurado para funcionar actualmente, y preferiría saber si me ayuda antes de invertir el tiempo. ¡Gracias!

Editar:

Jugué un poco con los diferentes candidatos para contarautowrap que el argumento de entrada será algo en forma de matriz, en lugar de una lista de números. Documentaré mis pasos aquí para la posteridad, y también para aumentar las posibilidades de obtener alguna información:

sympy.DeferredVector

Es lo que uso con lambdify para el mismo propósito, así que pensé en probarlo. Sin embargo,advertencia:

A = sympy.DeferredVector("A")
expression = A[0]+A[1]
cyt = autowrap(expression, backend="cython", args=A)

simplemente bloqueé por completo mi sistema operativo: la última declaración comenzó a ejecutarse, (sin comentarios), todo se puso muy lento, luego no hubo más reacciones. (Solo puede especular, tal vez tenga que ver con el hecho de que A no tiene información de forma, lo que no parece molestar a Lambdify, pero podría ser un problema aquí. De todos modos, parece que no es el camino correcto).

Todo tipo de objetos de tipo matriz llenados con los símbolos en la expresión a envolver.

p.ej.

x0 ,x1 = sympy.symbols("x:2")
expression = x0 + x1
cyt = autowrap(expression, backend="cython", args=np.array([x0,x1]))

Todavía quiere argumentos sin empaquetar. Reemplazando la última fila por

cyt = autowrap(expression, backend="cython", args=[np.array([x0,x1])])

Da el mensaje

CodeGenArgumentListError: ("Argument list didn't specify: x0, x1 ", [InputArgument(x0), InputArgument(x1)])

Lo cual es un tema recurrente para este enfoque: también ocurre cuando se usa una matriz simétrica, una tupla, etc. dentro de la lista de argumentos.

sympy.IndexedBase

Esto se usa realmente en los ejemplos de autowrap; sin embargo, de una manera intuitiva (para mí), usando una ecuación como la expresión que se va a envolver. Además, la forma en que se usa allí no me parece realmente factible: la expresión que quiero cythonize es una matriz, pero sus celdas son expresiones largas, que no puedo obtener a través de operaciones de índice.

Lo bueno es que obtuve un ejemplo mínimo para trabajar:

X = sympy.IndexedBase("X",shape=(1,1))
expression = 2*X[0,0]
cyt = autowrap(expression, backend="cython", args=[X])

en realidad se compila, y la función resultante se evalúa correctamente, cuando se pasa un 2d-np.array.

Por lo tanto, esta parece ser la vía más prometedora, a pesar de que otras extensiones de este enfoque sigo intentando fallar.

Por ejemplo esto

X = sympy.IndexedBase("X",shape=(1,))
expression = 2*X[0]
cyt = autowrap(expression, backend="cython", args=[X])

me atrapa

[...]\site-packages\sympy\printing\codeprinter.py", line 258, in _get_expression_indices " rhs indices in %s" % expr)
ValueError: lhs indices must match non-dummy rhs indices in 2*X[0]

a pesar de que no veo cómo debería ser diferente del trabajo anterior.

Mismo mensaje de error cuando se adhiere a dos dimensiones, pero aumenta el tamaño deX:

X = sympy.IndexedBase("X",shape=(2,2))
expression = 2*X[0,0]+X[0,1]+X[1,0]+X[1,1]
cyt = autowrap(expression, backend="cython", args=[X])

ValueError: lhs indices must match non-dummy rhs indices in 2*X[0, 0] + X[0, 1] + X[1, 0] + X[1, 1]

Traté de husmear el código porautowrap, pero me siento un poco perdido allí ...

Así que todavía estoy buscando una solución y estoy feliz por cualquier aporte.