Le package Mathematica.jl
fournit une interface pour utiliser Wolfram Mathematica™ à partir du langage Julia. Vous ne pouvez pas utiliser Mathematica.jl
sans avoir acheté et installé une copie de Mathematica™ de Wolfram Research. Ce package est disponible gratuitement et ne remplace ni n'altère en aucun cas les fonctionnalités du produit Mathematica de Wolfram.
Le package fournit une interface Julia sans tracas pour Mathematica. Il vise à suivre la philosophie de Julia consistant à combiner une expressivité de haut niveau sans sacrifier l'optimisation de bas niveau.
Pkg . add ( " Mathematica " )
À condition que Mathematica soit installé, son utilisation est aussi simple que :
using Mathematica
Fibonacci ( 1000 )
#= > 43466557686937456435688527675040625802564660517371780402481729089536555417949051890403879840079255169295922593080322634775209689623239873322471161642996440906533187938298969649928516003704476137795166849228875
Toutes les fonctions de Mathematica sont disponibles sous forme de fonctions et de macros, et l'épissage ( $
) fonctionne comme prévu :
Integrate (:(x ^ 2 ), :x ) # or
@Integrate (x ^ 2 , x)
#= > :(*(1//3,^(x,3)))
@Integrate(log(x), {x,0,2})
#= > :(+(-2,log(4)))
eval(ans) # or
@N($ans) # or
N(ans) # or
@N(Integrate(log(x), {x,0,2}))
#= > -0.6137056388801094
Y compris ceux qui renvoient des données Mathematica :
@Plot (x ^ 2 , {x, 0 , 2 })
#= > Graphics[{{{},{},{Hue[0.67, 0.6, 0.6],Line[{{4.081632653061224e-8,1.6659725114535607e-15},...}]}}}, {:AspectRatio->Power[:GoldenRatio, -1],:Axes->true, ...}]
Les données mathématiques peuvent participer directement aux fonctions Julia, sans aucun emballage requis. Par exemple -
using MathLink
d = BinomialDistribution ( 10 , 0.2 ) #= > BinomialDistribution[10, 0.2]
probability(b::MExpr{:BinomialDistribution}) = b.args[2]
probability(d) #= > 0.2
Les données compatibles Julia (par exemple, les listes, les nombres complexes, etc.) seront toutes converties automatiquement et vous pourrez étendre la conversion à d'autres types.
Notez que les expressions Mathematica ne sont pas converties en expressions Julia par défaut. Les fonctions/macros avec l'astuce ::Expr
(voir ci-dessous) convertiront leur résultat, mais pour les autres, vous devez utiliser convert
ou MathLink.to_expr
.
Log ( - 1 ) #= > Times[0 + 1im, :Pi]
convert(Expr, ans) #= > :(*(0 + 1im,Pi))
N(Log(-1)) #= > 0.0 + 3.141592653589793im
L'impression et les avertissements sont également pris en charge :
Print ( " hi " )
#= > hi
@Print(x^2/3)
#= > 2
# x
# --
# 3
Binomial(10)
#= > WARNING: Binomial::argr: Binomial called with 1 argument; 2 arguments are expected.
#= > Binomial[10]
Enfin, bien sûr :
WolframAlpha ( " hi " ) #= >
2-element Array{Any,1}:
{{"Input",1},"Plaintext"}->"Hello."
{{"Result",1},"Plaintext"}->"Hello, human."
Dans le fichier Mathematica.jl
, vous verrez une liste de spécifications de fonctions et de macros, chacune dans l'un de ces formats :
Function :: ReturnType # or
Function (Arg1Type, Arg2Type, ... ) :: ReturnType # (functions only)
Par exemple:
Integrate :: Expr
RandomReal (Number) :: Float64
RandomReal (Number, Integer) :: Vector{Float64}
L'indice de type de retour ici est une optimisation ; cela permet à MathLink.jl
de récupérer la valeur de Mathematica sans effectuer au préalable une vérification de type et rend le type de fonction stable - par exemple, RandomReal(10, 5)
renverrait un tableau Any
sans cette définition. Les types d'arguments permettent la vérification de type et plusieurs définitions.
Peu de fonctions ont encore des signatures de type, donc les fournir pour les fonctions que vous souhaitez utiliser est un moyen simple de contribuer.
L'expression de données Mathematica Head[x,y,z,...]
est représentée dans Julia par MExpr{:Head}(args = {x,y,z,...})
. Nous pouvons étendre Mathematica.jl
pour prendre en charge les types personnalisés en surchargeant MathLink.to_mma
et MathLink.from_mma
.
Par exemple, nous pouvons transmettre un Julia Dict directement dans Mathematica avec seulement deux lignes de définitions :
using MathLink; import MathLink : to_mma, from_mma
d = [ :a => 1 , :b => 2 ]
to_mma (d :: Dict ) = MExpr {:Dict} ( map (x -> MExpr ( :Rule , x[ 1 ], x[ 2 ]),d))
Identity (d) #= > Dict[:b->2, :a->1]
from_mma(d::MExpr{:Dict}) = Dict(map(x->x.args[1], d.args), map(x->x.args[2], d.args))
Identity(d) #= > {:b=>2,:a=>1}
using Mathematica
Cela devrait fonctionner tant que l'un ou l'autre math
est sur le chemin (normalement vrai sous Linux). Mathematica.jl
recherchera également math.exe
sous Windows, ce qui devrait fonctionner pour les versions 8 ou 9 de Mathematica installées dans les emplacements par défaut. Si cela ne fonctionne pas pour vous, ouvrez un ticket (en particulier, je ne sais pas comment cela se comportera sur les Mac).