The Julia(x, cgopts) calling sequence translates Maple code to Julia code.

- If the parameter x is an algebraic expression, then a Julia statement assigning the expression to a variable is generated.

- If x is a list, Maple Array, or rtable of algebraic expressions, then a sequence of Julia statements assigning the elements to a Julia array is produced.  Only the initialized elements of the rtable or Maple Array are translated.

- If x is a list of equations $\mathrm{nm}=\mathrm{expr}$, where $\mathrm{nm}$ is a name and $\mathrm{expr}$ is an algebraic expression, then this is understood as a sequence of assignment statements.  In this case, the equivalent sequence of Julia assignment statements is generated.

- If x is a procedure, then a Julia function is generated which is equivalent to the procedure, along with any necessary import statements.

The parameter cgopts may include one or more CodeGeneration options, as described in CodeGenerationOptions.

For more information about how the CodeGeneration package translates Maple code to other languages, see Translation Details. For more information about translation to Julia in particular, see Julia Details.

$\mathrm{with}\left(\mathrm{CodeGeneration}\right)\:$

$\mathrm{Julia}\left(x+yz-2xz\,\mathrm{resultname}=''w''\right)$

w = -2 * x * z + y * z + x

$\mathrm{Julia}\left(\left[\left[x\,2y\right]\,\left[5\,z\right]\right]\,\mathrm{resultname}=''w''\right)$

w = [[x,2 * y],[5,z]]

$\mathrm{cs}≔\left[s=1.0+x\,t=\ln \left(s\right)\exp \left(-x\right)\,r=\exp \left(-x\right)+xt\right]\:$

$\mathrm{Julia}\left(\mathrm{cs}\,\mathrm{optimize}\right)$

s = 0.10e1 + x
t1 = log(s)
t2 = exp(-x)
t = t2 * t1
r = x * t + t2

$s≔\mathrm{Julia}\left(x+y+1\,\mathrm{declare}=\left[x::\mathrm{float}\,y::\mathrm{integer}\right]\,\mathrm{output}=\mathrm{string}\right)$

$s≔''cg\; =\; x\; +\; y\; +\; 1''$

f := proc(x, y, z) return x*y-y*z+x*z; end proc:

$\mathrm{Julia}\left(f\,\mathrm{defaulttype}=\mathrm{integer}\right)$

function f(x, y, z)
    return(y * x - y * z + x * z)
end

f := proc(n)
  local x, i;
  x := 0.0;
  for i to n do
    x := x + i;
  end do;
end proc:

$\mathrm{Julia}\left(f\right)$

function f(n)
    x = 0.0e0
    for i = 1:n
        x = x + i
        cgret = x
    end
    return(cgret)
end

$\mathrm{Julia}\left(2\cosh \left(x\right)-7\tanh \left(x\right)\right)$

cg0 = 2 * cosh(x) - 7 * tanh(x)

f := proc(a::integer, p::integer)
  printf("The integer remainder of %d divided by %d is: %d\n", a, p, irem(a, p));
end proc:

$\mathrm{Julia}\left(f\right)$

function f(a, p)
    printf("The integer remainder of %d divided by %d is: %d\n", a, p, a % p)
end

detHilbert := proc(M, n :: posint) uses LinearAlgebra;
   return Determinant( HilbertMatrix( n ) );
end proc:

$\mathrm{Julia}\left(\mathrm{detHilbert}\right)$

function detHilbert(M, n)
    return(det(LinearAlgebra:-HilbertMatrix(n)))
end

The CodeGeneration[Julia] command was introduced in Maple 2016.

For more information on Maple 2016 changes, see Updates in Maple 2016.