AddTranslator is an extension mechanism that allows anyone to supply a function that will translate a MATLAB command string into an equivalent Maple command string.  The handler must accept as arguments the parameters to the MATLAB function fname.  Each argument passed to the handler has already been translated to parsable Maple strings.

For example, AddTranslator("eye",handler1); will define a translation method for the MATLAB eye command.  handler1 will be invoked when translating the MATLAB command, eye(2,3). handler1 will be called with two string arguments; handler1("2", "3") The handler should not execute any code (ie. it should not create an identity matrix), rather it should return a string that contains Maple syntax for performing the equivalent operation in Maple.  Something like the string "LinearAlgebra[IdentityMatrix](2,3)".

In many cases the MATLAB argument sequence will not exactly match the equivalent Maple command.  For example, the MATLAB eye command accepts either integer dimensions, or an array of dimensions.  Maple's IdentityMatrix command only accepts integer dimensions.  So, translating eye(dims) to LinearAlgebra[IdentityMatrix](dims) is not correct when dims is an array. In these cases it is usually easiest to write a Maple procedure that does the argument conversion.  For example, write:

 Then write a handler that translates eye(dims) to maple_eye(dims).  In this case, where the handler simply needs to rename the function while keeping all the arguments as is, use StringTools[Join] to join all the given arguments together into a string with commas in between.  eye(a,b) becomes "maple_eye(a,b)". The handler will be: 

Most built-in translations handlers try not to map to special procedures that just massage their arguments.  The intent is to make it obvious what the target function is.  In the examples above you really should see LinearAlgebra[IdentityMatrix] in the translated result, rather than a call to maple_eye.  However, this sometimes makes the translated code more verbose than it would normally be if you simply started writing the code in Maple.  Translated code should usually be reviewed and optimized by hand to remove extra cases that don't need to be handled.  

When translating directly to Maple statements, keep in mind that the arguments can themselves be expressions. To avoid multiple evaluations, reference each argument only once.  For example, when translating eye(1+n), the first argument given to the handler will be "1+n".  So, a translation to  will cause  to be evaluated at least twice.  Inline procedures can help.  Rewrite the above to , or, more explicitly .

Similarly the function you are translating could be contained inside another expression.  To support embedded expressions make sure the resulting translation is a single expression (ie don't translate to multiple statements).  As described above, a procedure can be defined and invoked in the same statement -- proc(x) x^2 end(3) is another way to write 9.

translate_brick_handler := proc( ) cat( "maple_brick(", StringTools[Join]([args],", "), ")" ); end proc;

Evaluating:
maple_brick(1, 2);

Evaluating:
maple_brick(Matrix([[1, 2], [3, 4]] ));