 JavaScript - Maple Help

CodeGeneration

 JavaScript
 translate Maple code to JavaScript code Calling Sequence JavaScript(x, cgopts) Parameters

 x - expression, list, rtable, procedure, or module cgopts - (optional) one or more CodeGeneration options Description

 • The JavaScript(x, cgopts) calling sequence translates Maple code to JavaScript code.
 - If the parameter x is an algebraic expression, then a JavaScript 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 JavaScript statements assigning the elements to a JavaScript 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, this is understood as a sequence of assignment statements.  In this case, the equivalent sequence of JavaScript assignment statements is generated.
 - If x is a procedure, then a JavaScript class is generated containing a function equivalent to the procedure, along with any necessary import statements.
 - If x is a module, then a JavaScript class is generated, as described on the JavaScriptDetails help page.
 • The parameter cgopts may include one or more CodeGeneration options, as described in CodeGenerationOptions. Examples

For a description of the options used in the following examples, see CodeGenerationOptions.

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

Translate a simple expression and assign to the name $w$ in the target code.

 > $\mathrm{JavaScript}\left(x+yz-2xz,\mathrm{resultname}="w"\right)$
 w = -2 * x * z + y * z + x;

Translate a list and assign to an array with name $w$ in the target code.

 > $\mathrm{JavaScript}\left(\left[\left[x,2y\right],\left[5,z\right]\right],\mathrm{resultname}="w"\right)$
 w = [[x, 2 * y], [5, z]];

Translate a computation sequence.  Optimize the input first.

 > $\mathrm{cs}≔\left[s=1.0+x,t=\mathrm{ln}\left(s\right){ⅇ}^{-x},r={ⅇ}^{-x}+xt\right]:$
 > $\mathrm{JavaScript}\left(\mathrm{cs},\mathrm{optimize}\right)$
 s = 0.10e1 + x; t1 = Math.log(s); t2 = Math.exp(-x); t = t2 * t1; r = x * t + t2;

Declare that $x$ is a float and $y$ is an integer. Return the result in a string.

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

Translate a procedure.  Assume that all untyped variables have type integer.

 > f := proc(x, y, z) return x*y-y*z+x*z; end proc:
 > $\mathrm{JavaScript}\left(f,\mathrm{defaulttype}=\mathrm{integer}\right)$
 function f(x, y, z) {   return(y * x - y * z + x * z); }

Translate a procedure containing an implicit return.  A new variable is created to hold the return value.

 > f := proc(n)   local x, i;   x := 0.0;   for i to n do     x := x + i;   end do; end proc:
 > $\mathrm{JavaScript}\left(f\right)$
 function f(n) {   var x;   var i;   var cgret;   x = 0.0e0;   for (i in 1...n)   {     x = x + i;     cgret = x;   }   return(cgret); }

Translate a procedure accepting an Array as a parameter.  Note that the indices are renumbered so that the JavaScript array starts at index 0.

 > f := proc(x::Array(numeric, 5..7))   return x+x+x; end proc:
 > $\mathrm{JavaScript}\left(f\right)$
 function f(x) {   return(x + x + x); }

Translate a module.

 > m := module() export p; local q;     p := proc(x,y) if y>0 then trunc(x); else ceil(x); end if; end proc:     q := proc(x) sin(x)^2; end proc: end module:
 > $\mathrm{JavaScript}\left(m,\mathrm{resultname}=\mathrm{t0}\right)$
 var m = {   "p": function(x, y) {       if (0 < y)       {         return(trunc(x));       }       else       {         return(Math.ceil(x));       }   },   "q": function(x) {       return(Math.pow(Math.sin(x), 2));   } }

Translate a linear combination of hyperbolic trigonometric functions.

 > $\mathrm{JavaScript}\left(2\mathrm{cosh}\left(x\right)-7\mathrm{tanh}\left(x\right)\right)$
 cg0 = 2 * (Math.exp(x) + Math.exp((-0.1e1) * x)) / 0.2e1 - 7 * (Math.exp(0.2e1 * x) - 0.1e1) / (Math.exp(0.2e1 * x) + 0.1e1);

Translate a procedure with no return value containing a printf statement.

 > 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{JavaScript}\left(f\right)$
 function f(a, p) {   printf("The integer remainder of %d divided by %d is: %d\n", a, p, a % p); } Compatibility

 • The CodeGeneration[JavaScript] command was introduced in Maple 2015.