WOLFRAM

Wolfram Language & System Documentation Center

"Julia" (External Evaluation System)

Details

ExternalEvaluate Usage

  • ExternalEvaluate["Julia",code] executes the code string in a Julia REPL and returns the results as a Wolfram Language expression.
  • ExternalEvaluate["Julia""String",code] executes the code string in a Julia REPL and returns the output as a Wolfram Language string.

Data Types

  • The following Julia built-in types are supported:
  • BoolTrue | FalseBoolean True/False values
    Int8, Int16, Int32, etc.Integerinteger
    Float16, Float32, etc.Realreal number
    Complex{Float16}, Complex{Float32}, etc.Complexcomplex number (returning from Julia only)
    StringStringstring of characters
    ArrayListlist of objects
    DictAssociationassociative array
    SetListunordered set without duplicates
    TupleListfixed-length container
    Date, DateTimeTemplateBox[{DateObject, paclet:ref/DateObject}, RefLink, BaseStyle -> {3ColumnTableMod}]dates, date intervals
    NaNIndeterminatenot-a-number
    nothingNullno return value

Usage Notes

  • String templates (<*…*>) can be used to evaluate and insert Wolfram Language expressions into the Julia code string.

Examples

open all close all

Basic Examples  (1)

Evaluate 2+2 in Julia and return the result:

Wolfram Language code: ExternalEvaluate["Julia", "2+2"]

Arrays are returned as lists:

Wolfram Language code: ExternalEvaluate["Julia", "[1,2,3,4]"]

Type > and select Julia from the drop-down menu to get a code cell that uses ExternalEvaluate to evaluate:

map(sqrt, 1:1:10)

Dates are returned from Julia as DateObject expressions:

Wolfram Language code: ExternalEvaluate["Julia", "using Dates; DateTime(2022)"]

Scope  (20)

Evaluate a Boolean statement in Julia and return the result:

Wolfram Language code: ExternalEvaluate["Julia", "true || false"]

Concatenate strings in Julia and return the result:

Wolfram Language code: ExternalEvaluate["Julia", "\"hello\" * \" \" * \"world\""]

Dictionaries in Julia are returned as associations:

Wolfram Language code: ExternalEvaluate["Julia", "Dict(\"one\"=>1, \"two\"=>2, \"three\"=>3)"]

Arrays in Julia are returned as List:

Wolfram Language code: ExternalEvaluate["Julia", "[1 2 3;4 5 6]"]

Session Options  (9)

"ReturnType"  (3)

For the Julia evaluation system, the default return type is "Expression":

Wolfram Language code: ExternalEvaluate["Julia", "2+2"] === ExternalEvaluate["Julia" -> "Expression", "2+2"]

Numbers, strings, lists and associations are automatically imported for the "Expression" return type:

Wolfram Language code: ExternalEvaluate["Julia", "[1, 2, 3]"]
Wolfram Language code: MatchQ[%, {__Integer}]

The return type of "String" returns a string of the result by calling the Julia function repr:

Wolfram Language code: ExternalEvaluate["Julia" -> "String", "[1, 2, 'א']"]
Wolfram Language code: ExternalEvaluate["Julia", "repr([1, 2, 'א'])"]

"Version"  (1)

You can use "Version" to make sure only a particular Julia version is going to be used:

Wolfram Language code: ExternalEvaluate[{"Julia", "Version" -> "1.7"}, "repr(VERSION)"]

You can specify a minor or patch version:

Wolfram Language code: ExternalEvaluate[{"Julia", "Version" -> "1.8.2"}, "repr(VERSION)"]

"Evaluator"  (1)

Start a Julia session using a specified "Evaluator":

Wolfram Language code: session = StartExternalSession[{"Julia", "Evaluator" -> "C:\\Users\\WolframUser\\AppData\\Local\\Programs\\Julia-1.8.2\\bin\\julia.exe"}]

Check the evaluator used in the session:

Wolfram Language code: session["Evaluator"]

Close the session:

Wolfram Language code: DeleteObject[session]

"SessionProlog"  (1)

Wolfram Language code: ExternalEvaluate[{"Julia", "SessionProlog" -> "print(\"session started\")"}, "print(\"evaluating code\"); 2+2"]

"SessionEpilog"  (1)

Use "SessionEpilog" to perform a side effect at the end of a session:

Wolfram Language code: ExternalEvaluate[{"Julia", "SessionEpilog" -> "print(\"session ended\")"}, "print(\"evaluating code\"); 2+2"]

"Prolog"  (1)

Use "Prolog" to perform a side effect before every evaluation:

Wolfram Language code: ExternalEvaluate[{"Julia", "SessionProlog" -> "n=0", "Prolog" -> "print(\"n was \", n)"}, {"n += 3", "n += 3"}]

"Epilog"  (1)

Use "Epilog" to perform a side effect after every evaluation:

Wolfram Language code: ExternalEvaluate[{"Julia", "SessionProlog" -> "n=0", "Prolog" -> "print(\"n was \", n)", "Epilog" -> "print(\"n is \", n)"}, {"n += 3", "n += 3"}]

Command Options  (10)

"Command"  (3)

When only a string of Julia code is provided, the command is directly executed:

Wolfram Language code: ExternalEvaluate["Julia", "2+2"]

The above is equivalent to writing the command using this form:

Wolfram Language code: ExternalEvaluate["Julia", <|"Command" -> "2+2"|>]

Use a File wrapper to run the code in a file:

Wolfram Language code: ExternalEvaluate["Julia", { <|"Command" -> File["ExampleData/add.jl"]|>, <|"Command" -> "add2(3)"|> }]

The above is equivalent to writing the command using this form:

Wolfram Language code: ExternalEvaluate["Julia", { File["ExampleData/add.jl"], "add2(3)" }]

Put code in a CloudObject:

Wolfram Language code: cloudObj = CloudExport["print(\"Hello World!\")", "Text", CloudObject["hello-world-jl"]]

Evaluate directly from the cloud:

Wolfram Language code: ExternalEvaluate["Julia", <|"Command" -> cloudObj|>]

The above is equivalent to writing the command using this form:

Wolfram Language code: ExternalEvaluate["Julia", cloudObj]

"ReturnType"  (1)

By default, the command is executed using the "ReturnType" specified during the session creation:

Wolfram Language code: ExternalEvaluate[ {"Julia", "ReturnType" -> "String"}, "Dict('a'=> 2)" ]

Specifying a "ReturnType" in the command overrides the "ReturnType" for the session:

Wolfram Language code: ExternalEvaluate[ {"Julia", "ReturnType" -> "String"}, { <|"Command" -> "Dict('a'=> 2)"|>, <|"Command" -> "Dict('a'=> 2)", "ReturnType" -> "Expression"|> } ]

"Arguments"  (2)

Use "Arguments" to call the result of the evaluation with arguments:

Wolfram Language code: ExternalEvaluate[ "Julia", <|"Command" -> "+", "Arguments" -> {0, 5}|> ]

When a non-list argument is provided, a single argument is passed to the function:

Wolfram Language code: ExternalEvaluate[ "Julia", <|"Command" -> "repr", "Arguments" -> 1|> ]

If you need to pass a list as the first argument, you must wrap it with an extra list explicitly:

Wolfram Language code: ExternalEvaluate[ "Julia", { <|"Command" -> "repr", "Arguments" -> 1|>, <|"Command" -> "repr", "Arguments" -> {1}|>, <|"Command" -> "repr", "Arguments" -> {{1}}|> } ]

You can define a function inside "Command" and directly call it with "Arguments":

Wolfram Language code: ExternalEvaluate[ "Julia", <|"Command" -> "f(a, b)= a+b", "Arguments" -> {1, 2}|> ]

The same result can be achieved by using a Rule:

Wolfram Language code: ExternalEvaluate[ "Julia", "f(a, b)= a+b" -> {1, 3} ]

You can also pass arguments by creating an ExternalFunction:

Wolfram Language code: session = StartExternalSession["Julia"]
Wolfram Language code: function = ExternalFunction[session, "f(a, b)= a+b"]
Wolfram Language code: function[1, 3]
Wolfram Language code: DeleteObject[session]

"Constants"  (1)

Use "Constants" to permanently set global variables before the command runs:

Wolfram Language code: ExternalEvaluate[ "Julia", <|"Constants" -> <|"a" -> 2, "b" -> 3|>, "Command" -> "a + b + 2"|> ]

"TemplateArguments"  (3)

When running a command, you can inline a TemplateExpression:

Wolfram Language code: x = RandomReal[] ExternalEvaluate["Julia", "1 + <* x *>"]

You can explicitly fill TemplateSlot using "TemplateArguments":

Wolfram Language code: ExternalEvaluate[ "Julia", <|"Command" -> "2 + ``", "TemplateArguments" -> 1|> ]

When a non-list argument is provided, a single template argument is passed to the template:

Wolfram Language code: ExternalEvaluate[ "Julia", <|"Command" -> "repr(``)", "TemplateArguments" -> 1|> ]

If you need to pass a list as the first argument, you must wrap it with an extra list explicitly:

Wolfram Language code: ExternalEvaluate[ "Julia", { <|"Command" -> "repr(``)", "TemplateArguments" -> 1|>, <|"Command" -> "repr(``)", "TemplateArguments" -> {1}|>, <|"Command" -> "repr(``)", "TemplateArguments" -> {{1}}|> } ]

You can name template slots and use an Association to pass named arguments to the template:

Wolfram Language code: ExternalEvaluate[ "Julia", <|"Command" -> "collect(range(`start`, `length`, `end`))", "TemplateArguments" -> <|"start" -> 1, "end" -> 10, "length" -> 10|>|> ]

Applications  (2)

Use the mean function from the Statistics package in Julia:

Wolfram Language code: session = StartExternalSession["Julia"]; ExternalEvaluate[session, "using Pkg; Pkg.add(\"Statistics\")"]; mean = ExternalEvaluate[session, "using Statistics; mean"]

Use the function:

Wolfram Language code: mean[Range[50]]

Close the session:

Wolfram Language code: DeleteObject[session]

Use the OrdinaryDiffEq package in Julia to solve a radioactive decay problem:

Wolfram Language code: session = StartExternalSession["Julia"]; ExternalEvaluate[session, "using Pkg; Pkg.add(\"OrdinaryDiffEq\")"];
Wolfram Language code: {t, u} = ExternalEvaluate[session, "using OrdinaryDiffEq c1 = 5.730 u0=1.0 tspan = (0.0, 1.0) radioactivedecay(u,p,t) =-c1*u prob = ODEProblem(radioactivedecay,u0,tspan) sol = solve(prob,Tsit5()) [sol.t,sol.u] "];

Plot the solution in Wolfram Language:

Wolfram Language code: ListLinePlot[Transpose[{t, u}], PlotLabel -> "Carbon-14 half-life", PlotStyle -> Red, Epilog -> Point[Transpose[{t, u}]], ImageSize -> 400, Frame -> True, FrameLabel -> {"Time in thousands of years", "Percentage left"} ]

Properties & Relations  (2)

Define a Wolfram Language function that calls a Julia function:

Wolfram Language code: session = StartExternalSession["Julia"];
Wolfram Language code: sqrt = ExternalFunction[session, "sqrt"]
Wolfram Language code: sqrt[4]

Close the session:

Wolfram Language code: DeleteObject[session]

A NumericArray is sent to Julia as an array with the same element type:

Wolfram Language code: session = StartExternalSession["Julia"]

This shows the native Julia type for the incoming array:

Wolfram Language code: juliaTypeOf = ExternalFunction[session, "typeof"];juliaTypeOf[NumericArray[Range[100], "UnsignedInteger16"]]

Close the session:

Wolfram Language code: DeleteObject[session]