Items tagged with matlab matlab Tagged Items Feed

Hello;

I would like to extract data from a 2D plot to compare my numerical result in Matlab. 

I used this command.

However, I need to spesify the nodes on x axis to get the error in Matlab. My matlab codes give the result as fix step size i.e [0 0.1 0.2 ... 1.0] or [0 0.01 0.02 ... 1.00] etc.

Is there any command in Maple to spesify the nodes on x axis?

Thanks you!

Hi all

In matlab software we have a command namely fmincon which minimizes any linear/nonlinear algebric equations subject to linear/nonlinear constraints.

Now my question is that: what is the same command in maple?or how can we minimize linear/nonlinear function subject to linear/nonlinear constraints in maple?

thanks a lot

Mahmood   Dadkhah

Ph.D Candidate

Applied Mathematics Department

Hi MaplePrime-ers!

I've been using the Maple(17) toolbox in Matlab(2012b) to quickly enumerate systems of equations by: (i) solving them symbolically, (ii) using unapply to make them functions, (iii) then supplying the points (driver equations) to get the system solution.  Speed is a must, because there may be 3 million+ systems to solve.  Symbolics is also very important because I am evaluating topology, so the structure of the equations may change, and therefore a functional approach will not work.

I have had success (seen in the first code snippet).  I would like similiar behaviour in the second code snippet, but sometimes I get 'solutions may be lost' as an error message,  or 'Error, (in unapply) variables must be unique and of type name'

The system of equations include:  Linear equations, 5th order polynomials, absolute functions, and pieceiwse functions.

Here is code with a topology that solves:

#Interconnection Equations
eq2[1] := FD_T + EM2_T = 0;
eq2[2] := ICE_T + GEN_T = 0;
eq2[3] := EM2_A + GEN_A + BAT_A = 0;
eq2[4] := -FD_W + EM2_W = 0;
eq2[5] := -ICE_W + GEN_W = 0;
eq2[6] := -EM2_V + GEN_V = 0;
eq2[7] := -EM2_V + BAT_V = 0;

#ICE
eq_c[1] := ICE_mdot_g=((671.5) + (-21.94)*ICE_T + (0.1942)*ICE_W + (0.5113)*ICE_T^2 + (-0.01271)*ICE_T*ICE_W + ( -0.0008761)*ICE_W^2 + (-0.006071)*ICE_T^3 + (9.867e-07)*ICE_T^2*ICE_W + (5.616e-05)*ICE_T*ICE_W^2 + (1.588e-06)*ICE_W^3 + (3.61e-05)*ICE_T^4 + (8.98e-07)*ICE_T^3*ICE_W + (-2.814e-07)*ICE_T^2*ICE_W^2 + (-8.121e-08)*ICE_T*ICE_W^3 + ( -8.494e-08 )*ICE_T^5 + (-2.444e-09)*ICE_T^4*ICE_W + (-9.311e-10)*ICE_T^3*ICE_W^2 + ( 5.835e-10)*ICE_T^2*ICE_W^3 ) *1/3600/1000 * ICE_T * ICE_W;

#BAT
eq_c[2] := BAT = 271;

#EM2
EM2_ReqPow_eq := (-148.3) + (4.267)*abs(EM2_W) + (12.77)*abs(EM2_T) + (-0.0364)*abs(EM2_W)^2 + ( 1.16)*abs(EM2_W)*abs(EM2_T) + (-0.258)*abs(EM2_T)^2 + ( 0.0001181)*abs(EM2_W)^3 + (-0.0005994)*abs(EM2_W)^2*abs(EM2_T) + ( 0.0001171)*abs(EM2_W)*abs(EM2_T)^2 + (0.001739 )*abs(EM2_T)^3 + (-1.245e-07 )*abs(EM2_W)^4 + ( 1.2e-06)*abs(EM2_W)^3*abs(EM2_T) + ( -1.584e-06)*abs(EM2_W)^2*abs(EM2_T)^2 + ( 4.383e-07)*abs(EM2_W)*abs(EM2_T)^3 + (-2.947e-06)*abs(EM2_T)^4;
eq_c[3] := EM2_P = piecewise( EM2_T = 0, 0, EM2_W = 0, 0, EM2_W*EM2_T < 0,-1 * EM2_ReqPow_eq, EM2_ReqPow_eq);
eq_c[4] := EM2_A = EM2_P/EM2_V;

#GEN
GEN_ReqPow_eq:= (-5.28e-12) + ( 3.849e-14)*abs(GEN_W) + (-71.9)*abs(GEN_T) + (-1.168e-16)*abs(GEN_W)^2 +(1.296)*abs(GEN_W)*abs(GEN_T) + (2.489)*abs(GEN_T)^2 + (1.451e-19)*abs(GEN_W)^3 + (0.0001326)*abs(GEN_W)^2*abs(GEN_T) + (-0.008141)*abs(GEN_W)*abs(GEN_T)^2 + (-0.004539)*abs(GEN_T)^3 +(-6.325e-23)*abs(GEN_W)^4 + (-2.091e-07)*abs(GEN_W)^3*abs(GEN_T) + ( 3.455e-06)*abs(GEN_W)^2*abs(GEN_T)^2 + ( 2.499e-05)*abs(GEN_W)*abs(GEN_T)^3 + (-5.321e-05)*abs(GEN_T)^4;
eq_c[5] := GEN_P = piecewise( GEN_T = 0, 0, GEN_W = 0, 0, GEN_W*GEN_T < 0,-1 * GEN_ReqPow_eq, GEN_ReqPow_eq);
eq_c[6] := GEN_A = GEN_P/GEN_V;

#ASSUMPTIONS
assume(BAT_V::nonnegative);
assume(FD_W::nonnegative);

#FINAL EQUATIONS

sys_eqs2 := convert(eq2,set) union {eq_c[1],eq_c[2],eq_c[3],eq_c[4],eq_c[5],eq_c[6]};

#Selecting which variables to solve for:

drivers2:= { ICE_T,ICE_W,FD_T,FD_W};
symvarnames2:=select(type,indets(convert(sys_eqs2,list)),name);
notdrivers2:=symvarnames2 minus drivers2;


#Symbolic solve

sol2:=solve(sys_eqs2,notdrivers2) assuming real:
symb_sol2:=unapply(sol2,convert(drivers2,list)):


#Enumerate (there will generally be about 40, not 6)

count := 0;
for i1 from 1 to 40 do
     for i2 from 1 to 40 do
          for i3 from 1 to 40 do
               for i4 from 1 to 40 do
                    count := count + 1;
                    solsol2(count) := symb_sol2(i1,i2,i3,i4);
               od;
          od;
     od;
od;
count;



This works great!  I would like simliar output in my second code snippet, but this time with more inputs to symb_sol.  However, if I try and change the interconnection equations a little, and add a piecewise function, and another driver... (differences in bold)

#Interconnection Equations
eq1[1] := FD_T+EM2_T = 0;
eq1[2] := ICE_T+GBb_T = 0;
eq1[3] := GEN_T+GBa_T = 0;
eq1[4] := EM2_A+GEN_A+BAT_A = 0;
eq1[5] := -FD_W+EM2_W = 0;
eq1[6] := -GEN_W+GBa_W = 0;
eq1[7] := -ICE_W+GBb_W = 0;
eq1[8] := -EM2_V+GEN_V = 0;
eq1[9] := -EM2_V+BAT_V = 0;

#ICE
eq_c[1] := ICE_mdot_g=((671.5) + (-21.94)*ICE_T + (0.1942)*ICE_W + (0.5113)*ICE_T^2 + (-0.01271)*ICE_T*ICE_W + ( -0.0008761)*ICE_W^2 + (-0.006071)*ICE_T^3 + (9.867e-07)*ICE_T^2*ICE_W + (5.616e-05)*ICE_T*ICE_W^2 + (1.588e-06)*ICE_W^3 + (3.61e-05)*ICE_T^4 + (8.98e-07)*ICE_T^3*ICE_W + (-2.814e-07)*ICE_T^2*ICE_W^2 + (-8.121e-08)*ICE_T*ICE_W^3 + ( -8.494e-08 )*ICE_T^5 + (-2.444e-09)*ICE_T^4*ICE_W + (-9.311e-10)*ICE_T^3*ICE_W^2 + ( 5.835e-10)*ICE_T^2*ICE_W^3 ) *1/3600/1000 * ICE_T * ICE_W;

#BAT
eq_c[2] := BAT = 271;

#EM2
EM2_ReqPow_eq := (-148.3) + (4.267)*abs(EM2_W) + (12.77)*abs(EM2_T) + (-0.0364)*abs(EM2_W)^2 + ( 1.16)*abs(EM2_W)*abs(EM2_T) + (-0.258)*abs(EM2_T)^2 + ( 0.0001181)*abs(EM2_W)^3 + (-0.0005994)*abs(EM2_W)^2*abs(EM2_T) + ( 0.0001171)*abs(EM2_W)*abs(EM2_T)^2 + (0.001739 )*abs(EM2_T)^3 + (-1.245e-07 )*abs(EM2_W)^4 + ( 1.2e-06)*abs(EM2_W)^3*abs(EM2_T) + ( -1.584e-06)*abs(EM2_W)^2*abs(EM2_T)^2 + ( 4.383e-07)*abs(EM2_W)*abs(EM2_T)^3 + (-2.947e-06)*abs(EM2_T)^4;
eq_c[3] := EM2_P = piecewise( EM2_T = 0, 0, EM2_W = 0, 0, EM2_W*EM2_T < 0,-1 * EM2_ReqPow_eq, EM2_ReqPow_eq);
eq_c[4] := EM2_A = EM2_P/EM2_V;

#GEN
GEN_ReqPow_eq:= (-5.28e-12) + ( 3.849e-14)*abs(GEN_W) + (-71.9)*abs(GEN_T) + (-1.168e-16)*abs(GEN_W)^2 +(1.296)*abs(GEN_W)*abs(GEN_T) + (2.489)*abs(GEN_T)^2 + (1.451e-19)*abs(GEN_W)^3 + (0.0001326)*abs(GEN_W)^2*abs(GEN_T) + (-0.008141)*abs(GEN_W)*abs(GEN_T)^2 + (-0.004539)*abs(GEN_T)^3 +(-6.325e-23)*abs(GEN_W)^4 + (-2.091e-07)*abs(GEN_W)^3*abs(GEN_T) + ( 3.455e-06)*abs(GEN_W)^2*abs(GEN_T)^2 + ( 2.499e-05)*abs(GEN_W)*abs(GEN_T)^3 + (-5.321e-05)*abs(GEN_T)^4;
eq_c[5] := GEN_P = piecewise( GEN_T = 0, 0, GEN_W = 0, 0, GEN_W*GEN_T < 0,-1 * GEN_ReqPow_eq, GEN_ReqPow_eq);
eq_c[6] := GEN_A = GEN_P/GEN_V;

#GB
FiveSpeedGearbox_R := proc(ig)
local i ,eq;
i[1]:=3.32;
i[2]:=2;
i[3]:=1.36;
i[4]:=1.01;
i[5]:=0.82;
eq:= piecewise(ig=1,i[1],ig=2, i[2],ig=3,i[3],ig=4,i[4],ig=5,i[5],1);
return eq(ig);
end proc;


eq_c[7] := GBb_T = -1/GB_R * GBa_T;
eq_c[8] := GBb_W = GB_R * GBa_W;
eq_c[9] := GB_R = FiveSpeedGearbox_R(ig);

 

#System Equations
sys_eqs := convert(eq1,set) union convert(eq_c,set);

 

 #Solve for variables
symvarnames:=select(type,indets(convert(sys_eqs,list)),name);
drivers:= {ig, ICE_T,ICE_W,FD_T,FD_W};
not_drivers := symvarnames minus drivers;

#Assumptinons

assume(BAT_V::nonnegative);
assume(FD_W::nonnegative);

sol:=(solve(sys_eqs,not_drivers) assuming real);

symb_sol:=unapply(sol,convert(drivers,list)): ---> Error, (in unapply) variables must be unique and of type name

Subsequent parts don't work...

count := 0;
for i1 from 1 to 40 do
     for i2 from 1 to 40 do
          for i3 from 1 to 40 do
               for i4 from 1 to 40 do
                    for i5 from 1 to 40 do
                         count := count + 1;
                         solsol2(count) := symb_sol2(i1,i2,i3,i4,5);
                    od;
               od; 
          od;
     od;
od;
count;

While running the last line sol:, 1 of 2 things will happen, depending on the solver. Maple17 will take a long time (30+ minutes) to solve, then report nothing, or sol will solve, but will report "some solutions have been lost".

Afterwards, evaluating symb_sol(0,0,0,0,0) will return a viable solution (real values for each of the variables).  Whereas evaluating symb_sol(0,X,0,0,0), where X <> 0, will return and empty list [].

Does anyone know how to (i) speed up the symbolic solve time?  (ii) Return ALL of the solutions?

 

Thanks in advance for reading this.  I've really no idea why this isn't working.  I've also attached two worksheets with the code: noGB.mw   withGB.mw

 Adam

Dear all

I would like to convert Matlab code to Maple, is there anu idea, this is the code.

 

% Usage: [y t] = abm4(f,a,b,ya,n) or y = abm4(f,a,b,ya,n)
% Adams-Bashforth-Moulton 4-th order predictor-corrector method for initial value problems
% It uses
% Adams-Bashforth 4-step method as a precdictor,
% Adams-Moulton 3-step method as a corrector, and
% Runge-Kutta method of order 4 as a starter
%
% Input:
% f - Matlab inline function f(t,y)
% a,b - interval
% ya - initial condition
% n - number of subintervals (panels)
%
% Output:
% y - computed solution
% t - time steps
%
% Examples:
% [y t]=abm4(@myfunc,0,1,1,10);          here 'myfunc' is a user-defined function in M-file
% y=abm4(inline('sin(y*t)','t','y'),0,1,1,10);
% f=inline('sin(y(1))-cos(y(2))','t','y');
% y=abm4(f,0,1,1,10);

function [y t] = abm4(f,a,b,ya,n)
h = (b - a) / n;
h24 = h / 24;

y(1,:) = ya;
t(1) = a;

m = min(3,n);

for i = 1 : m % start-up phase, using Runge-Kutta of order 4
    t(i+1) = t(i) + h;
    s(i,:) = f(t(i), y(i,:));
    s2 = f(t(i) + h / 2, y(i,:) + s(i,:) * h /2);
    s3 = f(t(i) + h / 2, y(i,:) + s2 * h /2);
    s4 = f(t(i+1), y(i,:) + s3 * h);
    y(i+1,:) = y(i,:) + (s(i,:) + s2+s2 + s3+s3 + s4) * h / 6;
end;

for i = m + 1 : n % main phase
    s(i,:) = f(t(i), y(i,:));
    y(i+1,:) = y(i,:) + (55 * s(i,:) - 59 * s(i-1,:) + 37 * s(i-2,:) - 9 * s(i-3,:)) * h24; % predictor
    t(i+1) = t(i) + h;
    y(i+1,:) = y(i,:) + (9 * f(t(i+1), y(i+1,:)) + 19 * s(i,:) - 5 * s(i-1,:) + s(i-2,:)) * h24; % corrector
end;

I have 2 problem with my jacobian matrix:

first: i can not evaluate 11*11 jacobian matrix. at last i can evaluate 10*10 matrix. can i solve this?
second: i want to export my matrix for matlab but i see this error : {export matrix"cannot convert matrix element to float[8] data type"}
so how i can use this matrix in my matlab code?
 my jacobian matrix:


with(VectorCalculus); Jacobian([VectorCalculus:-`+`(VectorCalculus:-`+`(VectorCalculus:-`+`(VectorCalculus:-`*`(2.68, ex), VectorCalculus:-`-`(VectorCalculus:-`*`(2, vx))), VectorCalculus:-`*`(VectorCalculus:-`*`(VectorCalculus:-`*`(VectorCalculus:-`*`(VectorCalculus:-`*`(3.500000001, e^VectorCalculus:-`*`(1.666666667, sqrt(VectorCalculus:-`+`(VectorCalculus:-`-`(VectorCalculus:-`+`(sqrt(VectorCalculus:-`+`(rx^2, ry^2)), sqrt(VectorCalculus:-`+`(VectorCalculus:-`+`(rx, VectorCalculus:-`-`(VectorCalculus:-`*`(2, vb(ex))))^2, VectorCalculus:-`+`(ry, VectorCalculus:-`-`(VectorCalculus:-`*`(2, vb(ey))))^2)))^2), VectorCalculus:-`-`(VectorCalculus:-`*`(4, vb^2)))))), VectorCalculus:-`+`(sqrt(VectorCalculus:-`+`(rx^2, ry^2)), sqrt(VectorCalculus:-`+`(VectorCalculus:-`+`(rx, VectorCalculus:-`-`(VectorCalculus:-`*`(2, vb(ex))))^2, VectorCalculus:-`+`(ry, VectorCalculus:-`-`(VectorCalculus:-`*`(2, vb(ey))))^2)))), VectorCalculus:-`+`(VectorCalculus:-`*`(rx, 1/sqrt(VectorCalculus:-`+`(rx^2, ry^2))), VectorCalculus:-`*`(1/2, VectorCalculus:-`*`(VectorCalculus:-`+`(VectorCalculus:-`*`(2, rx), VectorCalculus:-`-`(VectorCalculus:-`*`(4, vb(ex)))), 1/sqrt(VectorCalculus:-`+`(VectorCalculus:-`+`(rx, VectorCalculus:-`-`(VectorCalculus:-`*`(2, vb(ex))))^2, VectorCalculus:-`+`(ry, VectorCalculus:-`-`(VectorCalculus:-`*`(2, vb(ey))))^2)))))), ln(e)), 1/sqrt(VectorCalculus:-`+`(VectorCalculus:-`-`(VectorCalculus:-`+`(sqrt(VectorCalculus:-`+`(rx^2, ry^2)), sqrt(VectorCalculus:-`+`(VectorCalculus:-`+`(rx, VectorCalculus:-`-`(VectorCalculus:-`*`(2, vb(ex))))^2, VectorCalculus:-`+`(ry, VectorCalculus:-`-`(VectorCalculus:-`*`(2, vb(ey))))^2)))^2), VectorCalculus:-`-`(VectorCalculus:-`*`(4, vb^2)))))), VectorCalculus:-`*`(VectorCalculus:-`*`(VectorCalculus:-`*`(VectorCalculus:-`*`(50.00000000, e^VectorCalculus:-`-`(VectorCalculus:-`*`(5.000000000, sqrt(VectorCalculus:-`+`(Rx^2, Ry^2))))), Rx), ln(e)), 1/sqrt(VectorCalculus:-`+`(Rx^2, Ry^2)))), VectorCalculus:-`+`(VectorCalculus:-`+`(VectorCalculus:-`+`(VectorCalculus:-`*`(2.68, ey), VectorCalculus:-`-`(VectorCalculus:-`*`(2, vy))), VectorCalculus:-`*`(VectorCalculus:-`*`(VectorCalculus:-`*`(VectorCalculus:-`*`(VectorCalculus:-`*`(3.500000001, e^VectorCalculus:-`*`(1.666666667, sqrt(VectorCalculus:-`+`(VectorCalculus:-`-`(VectorCalculus:-`+`(sqrt(VectorCalculus:-`+`(rx^2, ry^2)), sqrt(VectorCalculus:-`+`(VectorCalculus:-`+`(rx, VectorCalculus:-`-`(VectorCalculus:-`*`(2, vb(ex))))^2, VectorCalculus:-`+`(ry, VectorCalculus:-`-`(VectorCalculus:-`*`(2, vb(ey))))^2)))^2), VectorCalculus:-`-`(VectorCalculus:-`*`(4, vb^2)))))), VectorCalculus:-`+`(sqrt(VectorCalculus:-`+`(rx^2, ry^2)), sqrt(VectorCalculus:-`+`(VectorCalculus:-`+`(rx, VectorCalculus:-`-`(VectorCalculus:-`*`(2, vb(ex))))^2, VectorCalculus:-`+`(ry, VectorCalculus:-`-`(VectorCalculus:-`*`(2, vb(ey))))^2)))), VectorCalculus:-`+`(VectorCalculus:-`*`(ry, 1/sqrt(VectorCalculus:-`+`(rx^2, ry^2))), VectorCalculus:-`*`(1/2, VectorCalculus:-`*`(VectorCalculus:-`+`(VectorCalculus:-`*`(2, ry), VectorCalculus:-`-`(VectorCalculus:-`*`(4, vb(ey)))), 1/sqrt(VectorCalculus:-`+`(VectorCalculus:-`+`(rx, VectorCalculus:-`-`(VectorCalculus:-`*`(2, vb(ex))))^2, VectorCalculus:-`+`(ry, VectorCalculus:-`-`(VectorCalculus:-`*`(2, vb(ey))))^2)))))), ln(e)), 1/sqrt(VectorCalculus:-`+`(VectorCalculus:-`-`(VectorCalculus:-`+`(sqrt(VectorCalculus:-`+`(rx^2, ry^2)), sqrt(VectorCalculus:-`+`(VectorCalculus:-`+`(rx, VectorCalculus:-`-`(VectorCalculus:-`*`(2, vb(ex))))^2, VectorCalculus:-`+`(ry, VectorCalculus:-`-`(VectorCalculus:-`*`(2, vb(ey))))^2)))^2), VectorCalculus:-`-`(VectorCalculus:-`*`(4, vb^2)))))), VectorCalculus:-`*`(VectorCalculus:-`*`(VectorCalculus:-`*`(VectorCalculus:-`*`(50.00000000, e^VectorCalculus:-`-`(VectorCalculus:-`*`(5.000000000, sqrt(VectorCalculus:-`+`(Rx^2, Ry^2))))), Ry), ln(e)), 1/sqrt(VectorCalculus:-`+`(Rx^2, Ry^2)))), 1, 1, 1, 1, 1, 1, 1, 1, 1], [vx, vy, ex, ey, rx, ry, Ex, Ey, vb, Rx, Ry])

Hello,

I was wondering if I can call Matlab R2012b with maple 14 on my macos 10.7.5.

When I try to do this:

> Matlab[setvar]("x", 3.14);

I get this:


Error, (in Matlab:-setvar) there was a problem finding or loading matlink.so. Refer to ?Matlab,setup for help configuring your system to work with the Matlab-link.

I read that I may have to change a script. Where are those scripts located?

Regards,

Hi all

I want to simulate the threshold effect in FM modulation\ demodulation, in theory ,when the carrier to noise ratio (the modulated signal SNR)fall below a certain value ,then the signal to noise ratio(of the demodulated signal will fall dramatically and the signal will not demodulated , click sounds will be heard in the output of demodulator. I have tried first "slope detector" as a demodulator, but the threshold effect didn't appear at all when i decrease...

Dear All,

 

I am trying to call the maple function fsolve in the matlab. I have used maple('fsolve(x^2-4)'). It worked.

 

Now in the matlab code I have defined another variable. let us say a = 10.  Now I am trying to call the fsolve as follows.

maple('fsolve(a*x^2-4)')

I ended up with the following error.

 

Error, (in fsolve) number of equations, 1, does not match number of variables, 2

Hi, I'm starting my program using Maple, then will bring some data to calculate in matlab, later on bring the data back to be calculated in Maple.

My equations have lots of trigonometry multiplication of matrix. When I run it in matlab, it runs fine. But when I try to use Matlab[FromMFile]("test.m",'evaluate') it gives me this statement:

"Error, (in Matlab:-FromMFile) unable to strore '(3.500000000*I)*2^(1/2)' when datatype=float(8)"

Could someone please...

I have a Matrix 'A' in maple with symbolic entries and I need to use that Matrix in matlab M file. The symbols with in 'A' are already initialized in M file.

How is this possible?

For Matrices 'A' of small dimension, I can use the codegeneration package to convert 'A' to Matlab Matrix and then copy paste.

But for matrices of 1000x1000, lets say, does not seem as a option.

 

Hello everybody,

I' m trying to run completely The optmization template from a batch file (.bat) and wonder how to :

  1.  Make the buttons working automatically.
  2.  What  command should be used in a batch file to execute utterly a maple program
  3. What kind of script file can be perfect for Matlab / Maple.

The point is to run in parallel Matlab and Maple, using a script file(.bat) or another external script format.

Hi,
I'm trying to import matlab function from m-file.

File looks like this:

    function out = xxx(omega)
    out = heaviside(omega);

It's only heaviside function.

And now, when I'm using "FromMFile" command in Maple it doesn't recognize Heaviside function. It imports that function as "heaviside" - witch small first character (in Maple we needs big "H").

Any help? 

thx 

Hi, experts

 

I have an array which is empty, say

 

f:= []:

 

is there away to check if it's empty? I want to do something like in Matlab:

 

if isempty(f)

......

end

 

Many thanks

Kyle

 

Hi there, I'm trying to pass some calculation to Matlab then retrive the result by getvar(), but seems something is getting wrong.

my matlab function is very simple:

 

function out =maple_fun(a, b)

out = a + b;

return

 

this function is saved as maple_fun.m.

 

in Maple,

restart:
with(Matlab):
openlink():
DirectoryLocation := " cd  '/Users/Kyle/Documents/MATLAB/'  ":

1 2 3 4 Page 1 of 4