Giulia è un linguaggio di programmazione ad alte prestazioni con molti utili strumenti di analisi numerica integrati. È facile da scrivere e dispone di un ecosistema in rapida crescita di pacchetti utili per il calcolo scientifico, l'apprendimento automatico e molto altro. Julia, come JMP, è uno strumento prezioso per scienziati, ricercatori e ingegneri.
Julia ha una reputazione per la facile interoperabilità con altri linguaggi di programmazione ed ero curioso di sapere quanto sarebbe stato difficile chiamare Julia da JSL. Se si potesse fare (si può!), Vedo molto potenziale nel chiamare Julia da JSL. È possibile creare interfacce utente JMP interattive che richiamano programmi Julia ad alte prestazioni. Puoi creare modelli in Julia e tracciare risultati in JMP o viceversa. Potresti prendere le parti lente del tuo flusso di lavoro JMP e farle in Julia.
Discuterò due metodi per chiamare Julia da JSL. Il primo metodo utilizza JSL per chiamare Python per chiamare Julia. Nel secondo metodo, incorporiamo Julia in una libreria a collegamento dinamico (DLL) scritta in C.
Nota che non tratterò molto della programmazione in Julia. Se sei curioso di saperne di più su Julia, dai un'occhiata al loro documentazione . Ci sono anche materiali didattici disponibili da Accademia Giulia .
Chiamare Julia tramite Python
Python in JSL
JMP 14 ha aggiunto comandi JSL per interfacciarsi direttamente con Python. Ecco un semplice esempio dall'indice di scripting:
// 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();
Pi Giulia
Se potessimo chiamare Julia da Python, allora potremmo chiamare Julia da JSL. Pi Giulia è un pacchetto Python che ti consente di fare proprio questo. Mettiamolo a punto. Nota: sono riuscito a utilizzare Julia 1.5.4, Python 3.9.5, PyJulia 0.5.7 e JMP 16.1 su Mac.
Supponendo un'installazione Python funzionante, la configurazione è la seguente:
Se non l'hai già fatto, installa Julia. Per istruzioni, visitare Istruzioni specifiche della piattaforma per binari ufficiali . I download dell'ultima versione sono disponibili all'indirizzo Pagina di download di Giulia .
Quindi, segui il Istruzioni per installare PyJulia.
Se sei in grado di usare PyJulia's istruzioni per l'uso in una normale sessione Python, sei a posto!
PyJulia in JSL
Ora in JSL, devi prima inizializzare Julia nella tua sessione Python. Assicurati di passare il percorso al tuo eseguibile Julia come argomento della parola chiave di runtime come di seguito.
Python Init();
// Initialize julia
Python Submit(
"\[
from julia import Julia
Julia(runtime="/usr/local/bin/julia")
]\");
Da qui, puoi usare Invia Python per eseguire qualsiasi codice 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]
Se hai altri pacchetti Julia installati, puoi accedervi tramite l'importazione di Python. Qui ho usato Pandas.jl, DataFrames.jl e Lasso.jl per eseguire un lazo adatto all'altezza su Big Class.jmp. Allora uso JMP Generatore di grafici per tracciare il rapporto effettivo e 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>
Un grafico del Generatore di grafici effettivo rispetto a quello previsto con i risultati calcolati in Julia
Incorporamento di Julia in una DLL
È anche possibile incorpora Giulia nel codice C. Condividerò alcuni esempi banali, ma sono sicuro che qualcuno più familiare con C potrebbe andare oltre.
CaricaDLL
La chiave qui è di JSL CaricaDLL funzione. Una grande risorsa per imparare a usare CaricaDLL è questo articolo . Come semplice esempio, possiamo prendere la seguente funzione C in un file chiamato test.c
// test.c
double myMultiply(double num1, double num2)
{
return num1 * num2;
}
E compilare in una DLL
# On Mac
gcc -shared -o test.dylib test.c
# On Windows
gcc -shared -o test.dll test.c
Quindi in JMP, possiamo chiamare la funzione 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;
Giulia DLL
Ora diamo un'occhiata a una DLL con alcuni Julia incorporati. Creeremo una funzione che calcola il seno del suo input, dove l'input è in gradi.
// 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;
}
Esegui quanto segue per compilare su Mac, dove $JULIA_DIR è una variabile di ambiente con il percorso del tuo binario julia. Per me, questo era /Applications/Julia-1.7.app/Contents/Resources/julia. Non l'ho provato su Windows, ma qualcosa di simile dovrebbe funzionare.
# 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
Ora possiamo chiamare sineInDegrees in 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;
Conclusione
Python di JSL e CaricaDLL le interfacce ci consentono di andare oltre JMP e chiamare Julia. Ci sono voluti alcuni tentativi ed errori per farlo funzionare, ma una volta impostato, funziona abbastanza bene. Ho mostrato alcuni semplici esempi in questo post, ma vedo il potenziale per creare nuove e interessanti applicazioni con JMP e Julia combinate.
Grazie per aver letto. Spero di averti lasciato informato e curioso di esplorare.
Una nota sulle versioni
Sono stato in grado di convincere Julia a lavorare tramite Python solo con Julia 1.5 e Julia 1.8 beta su Mac. Non ho avuto successo usando Julia tramite Python su Windows ma non ho provato tante versioni come su Mac. Ho usato JMP 16 per tutti i miei test.
