Julia est un langage de programmation hautes performances avec de nombreux outils d'analyse numérique utiles intégrés. Il est facile à écrire et dispose d'un écosystème en croissance rapide de packages utiles pour le calcul scientifique, l'apprentissage automatique et bien plus encore. Julia, comme JMP, est un outil inestimable pour les scientifiques, les chercheurs et les ingénieurs.
Julia est réputée pour son interopérabilité facile avec d'autres langages de programmation, et j'étais curieux de savoir à quel point il serait difficile d'appeler Julia depuis JSL. Si cela pouvait être fait (c'est possible !), Je vois beaucoup de potentiel à appeler Julia de JSL. Vous pouvez créer des interfaces utilisateur JMP interactives qui appellent des programmes Julia très performants. Vous pouvez créer des modèles dans Julia et tracer les résultats dans JMP ou vice versa. Vous pouvez prendre les parties lentes de votre flux de travail JMP et les faire dans Julia.
Je vais discuter de deux méthodes pour appeler Julia depuis JSL. La première méthode utilise JSL pour appeler Python pour appeler Julia. Dans la deuxième méthode, nous intégrons Julia dans une bibliothèque de liens dynamiques (DLL) écrite en C.
Notez que je ne couvrirai pas grand-chose de la programmation dans Julia. Si vous êtes curieux d'en savoir plus sur Julia, consultez leur Documentation . Il existe également du matériel d'apprentissage disponible auprès de Julia Académie .
Appeler Julia via Python
Python en JSL
JMP 14 a ajouté des commandes JSL pour s'interfacer directement avec Python. Voici un exemple simple tiré de l'index de script :
// 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 nous pouvions appeler Julia depuis Python, nous pourrions appeler Julia depuis JSL. PyJulia est un package Python qui vous permet de faire exactement cela. Mettons-le en place. Remarque : J'ai réussi à utiliser Julia 1.5.4, Python 3.9.5, PyJulia 0.5.7 et JMP 16.1 sur Mac.
En supposant une installation Python fonctionnelle, la configuration est la suivante :
Si vous ne l'avez pas déjà fait, installez Julia. Pour obtenir des instructions, visitez Instructions spécifiques à la plate-forme pour les binaires officiels . Les téléchargements de la dernière version sont disponibles sur Page de téléchargement Julia .
Ensuite, suivez le des instructions pour installer PyJulia.
Si vous êtes capable d'utiliser PyJulia mode d'emploi dans une session Python normale, vous êtes prêt à partir !
PyJulia en JSL
Maintenant dans JSL, vous devez d'abord initialiser Julia dans votre session Python. Assurez-vous de transmettre le chemin d'accès à votre exécutable Julia en tant qu'argument de mot-clé d'exécution comme ci-dessous.
Python Init();
// Initialize julia
Python Submit(
"\[
from julia import Julia
Julia(runtime="/usr/local/bin/julia")
]\");
À partir de là, vous pouvez utiliser Soumission Python pour exécuter n'importe quel code 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 vous avez d'autres packages Julia installés, vous pouvez y accéder par importation Python. Ici, j'ai utilisé Pandas.jl, DataFrames.jl et Lasso.jl pour exécuter un lasso adapté à la hauteur sur Big Class.jmp. Ensuite j'utilise JMP Générateur de graphiques pour tracer le réel par rapport aux prévisions.
// 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 graphique Graph Builder réel par rapport à prévu avec des résultats calculés dans Julia
Intégration de Julia dans une DLL
Il est également possible de intégrer Julia en code C. Je vais partager quelques exemples triviaux, mais je suis sûr que quelqu'un de plus familier avec C pourrait aller plus loin.
ChargerDLL
La clé ici est celle de JSL ChargerDLL une fonction. Une excellente ressource pour apprendre à utiliser ChargerDLL est ce papier . Comme exemple simple, nous pouvons prendre la fonction C suivante dans un fichier appelé test.c
// test.c
double myMultiply(double num1, double num2)
{
return num1 * num2;
}
Et compiler dans une DLL
# On Mac
gcc -shared -o test.dylib test.c
# On Windows
gcc -shared -o test.dll test.c
Ensuite, dans JMP, nous pouvons appeler la fonction 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
Examinons maintenant une DLL avec une Julia intégrée. Nous allons créer une fonction qui calcule le sinus de son entrée, où l'entrée est en degrés.
// 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;
}
Exécutez ci-dessous pour compiler sur Mac, où $JULIA_DIR est une variable d'environnement avec le chemin vers votre binaire julia. Pour moi, c'était /Applications/Julia-1.7.app/Contents/Resources/julia. Je n'ai pas essayé cela sur Windows, mais quelque chose de similaire devrait fonctionner.
# 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
Maintenant, nous pouvons appeler sinus en degrés 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;
Conclusion
Python de JSL et ChargerDLL les interfaces nous permettent d'aller au-delà de JMP et d'appeler Julia. Il a fallu quelques essais et erreurs pour que cela fonctionne, mais une fois qu'il est configuré, cela fonctionne très bien. J'ai montré quelques exemples simples dans cet article, mais je vois le potentiel de créer de nouvelles applications intéressantes avec JMP et Julia combinés.
Merci d'avoir lu. J'espère que je vous ai laissé informé et curieux d'explorer.
Une note sur les versions
Je n'ai pu faire fonctionner Julia qu'avec Python avec Julia 1.5 et la bêta de Julia 1.8 sur Mac. Je n'ai pas réussi à utiliser Julia via Python sous Windows mais je n'ai pas essayé autant de versions que sur Mac. J'ai utilisé JMP 16 pour tous mes tests.
