julia es un lenguaje de programación de alto rendimiento con muchas herramientas útiles de análisis numérico incorporadas. Es fácil de escribir y tiene un ecosistema de rápido crecimiento de paquetes útiles para computación científica, aprendizaje automático y mucho más. Julia, como JMP, es una herramienta invaluable para científicos, investigadores e ingenieros.
Julia tiene una reputación de fácil interoperabilidad con otros lenguajes de programación, y tenía curiosidad por lo difícil que sería llamar a Julia desde JSL. Si se pudiera (¡se puede!), Veo mucho potencial en llamar a Julia de JSL. Podría crear interfaces de usuario JMP interactivas que llamen a programas Julia de alto rendimiento. Puede crear modelos en Julia y trazar resultados en JMP o viceversa. Puede tomar las partes lentas de su flujo de trabajo JMP y hacerlas en Julia.
Discutiré dos métodos para llamar a Julia desde JSL. El primer método usa JSL para llamar a Python para llamar a Julia. En el segundo método, incrustamos a Julia en una biblioteca de enlace dinámico (DLL) escrita en C.
Tenga en cuenta que no cubriré mucho sobre la programación en Julia. Si tienes curiosidad por saber más sobre Julia, echa un vistazo a sus documentación . También hay materiales de aprendizaje disponibles en julia academia .
Llamar a Julia a través de Python
Pitón en JSL
JMP 14 agregó comandos JSL para interactuar con Python directamente. Aquí hay un ejemplo simple del índice de secuencias de comandos:
// Initialize the Python interface
PythonInit();
// Submit some Python code to run as a JSL string
PythonSubmit("\[message = 'The quick brown fox jumps over the lazy dog']\");
// message is now a variable in Python and can be accessed from JSL with PythonGet()
getStr = PythonGet(message);
Show(getStr);
// Terminate the Python interface
PythonTerm();
PyJulia
Si pudiéramos llamar a Julia desde Python, entonces podríamos llamar a Julia desde JSL. PyJulia es un paquete de Python que le permite hacer precisamente eso. Vamos a configurarlo. Nota: Tuve éxito al usar Julia 1.5.4, Python 3.9.5, PyJulia 0.5.7 y JMP 16.1 en Mac.
Suponiendo que la instalación de Python funcione, la configuración es la siguiente:
Si aún no lo ha hecho, instale Julia. Para obtener instrucciones, visite Instrucciones específicas de la plataforma para binarios oficiales . Las descargas de la última versión están disponibles en el Página de descarga de Julia .
A continuación, siga el instrucciones para instalar PyJulia.
Si puede usar PyJulia's instrucciones de uso en una sesión normal de Python, ¡ya está listo!
PyJulia en JSL
Ahora en JSL, primero debe inicializar a Julia en su sesión de Python. Asegúrese de pasar la ruta a su ejecutable de Julia como el argumento de palabra clave en tiempo de ejecución como se muestra a continuación.
Python Init();
// Initialize julia
Python Submit(
"\[
from julia import Julia
Julia(runtime="/usr/local/bin/julia")
]\");
Desde aquí, puede utilizar Python Enviar para ejecutar cualquier código de Julia.
// Import the main module. This is Julia's workspace.
Python Submit("\[
from julia import Main
Main.xs = [1,2,3] # xs belongs to julia
sines = Main.eval("sin.(xs)") # This returns the sine of each element in xs
]\");
show(PythonGet(sines)); // [0.841470984807897 0.909297426825682 0.141120008059867]
Si tiene otros paquetes de Julia instalados, puede acceder a ellos mediante la importación de Python. Aquí he usado Pandas.jl, DataFrames.jl y Lasso.jl para ejecutar un ajuste de lazo para la altura en Big Class.jmp. entonces uso JMP Generador de gráficos para trazar el real frente al previsto.
// Convert datatable to julia dataframe
// Must convert it to a julia Pandas dataframe first
dt = open("$SAMPLE_DATA/Big Class.jmp");
Pythonsend(dt);
Python Submit(
"\[
from julia import Pandas
from julia import DataFrames
from julia import Lasso
Main.dt = dt
predicted = Main.eval("""
using Lasso
df = DataFrames.DataFrame(Pandas.DataFrame(dt))
m = fit(LassoModel, @formula(height ~ sex + weight), df)
predict(m, df)
""")
]\");
// Back to JMP where we plot Actual vs. Predicted
predicted = pythonget("predicted");
dt << newColumn("Predicted height", <<SETVALUES></SETVALUES>
Una gráfica de Graph Builder real versus predicha con resultados calculados en Julia
Incrustando a Julia en una DLL
También es posible incrustar julia en código C. Compartiré algunos ejemplos triviales, pero estoy seguro de que alguien más familiarizado con C podría llevar esto más lejos.
Cargar DLL
La clave aquí es JSL Cargar DLL función. Un gran recurso para aprender a usar Cargar DLL es este papel . Como ejemplo simple, podemos tomar la siguiente función de C en un archivo llamado test.c
// test.c
double myMultiply(double num1, double num2)
{
return num1 * num2;
}
Y compilar a una DLL
# On Mac
gcc -shared -o test.dylib test.c
# On Windows
gcc -shared -o test.dll test.c
Luego, en JMP, podemos llamar a la función C
dll = loadDLL(convertfilepath("/path/to/my/test.dylib"));
dll << declareFunction("myMultiply",
Convention( STDCALL ),
Arg(Double, "num1"),
Arg(Double, "num2"),
Returns( Double )
);
show(dll << myMultiply(Pi(), 100));
dll << unloadDLL;
Julia DLL
Ahora echemos un vistazo a una DLL con algo de Julia incrustado. Vamos a crear una función que calcule el seno de su entrada, donde la entrada está en grados.
// call_julia.c
#include <julia.h>
double sineInDegrees(double degrees)
{
// required: setup the Julia context
jl_init();
// You can evaluate Julia code from strings
jl_value_t *factor = jl_eval_string("pi/180");
double factor_unboxed = jl_unbox_float64(factor);
double radians = degrees * factor_unboxed;
// You can call Julia functions directly
jl_function_t *func = jl_get_function(jl_base_module, "sin");
jl_value_t *argument = jl_box_float64(radians);
jl_value_t *ret = jl_call1(func, argument);
double ret_unboxed = jl_unbox_float64(ret);
jl_atexit_hook(0);
return ret_unboxed;
}
Ejecute lo siguiente para compilar en Mac, donde $JULIA_DIR es una variable de entorno con la ruta a su binario julia. Para mí, esto fue /Aplicaciones/Julia-1.7.app/Contents/Resources/julia. No probé esto en Windows, pero algo similar debería funcionar.
# On Mac
gcc -shared -o call_julia.dylib call_julia.c -fPIC -I$JULIA_DIR/include/julia -L$JULIA_DIR/lib -Wl,-rpath,$JULIA_DIR/lib -ljulia
Ahora podemos llamar sinusoidal en grados en JSL!
dll = loadDLL(convertfilepath("/path/to/my/call_julia.dylib"));
dll << declareFunction("sineInDegrees",
Convention( STDCALL ),
Arg( Double, "degrees" ),
Returns( Double )
);
show(dll << sineInDegrees(90)); // 1
dll << unloadDLL;
Conclusión
Python de JSL y Cargar DLL Las interfaces nos permiten llegar más allá de JMP y llamar a Julia. Tomó un poco de prueba y error hacer que esto funcionara, pero una vez que está configurado, funciona bastante bien. He mostrado algunos ejemplos simples en esta publicación, pero veo el potencial para crear aplicaciones nuevas e interesantes con JMP y Julia combinados.
Gracias por leer. Espero haberlos dejado informados y con curiosidad por explorar.
Una nota sobre las versiones
Solo pude hacer que Julia trabajara a través de Python con Julia 1.5 y la versión beta de Julia 1.8 en Mac. No tuve éxito usando Julia a través de Python en Windows pero no probé tantas versiones como en Mac. Usé JMP 16 para todas mis pruebas.
