|
The brief systax comparison of MATLAB and Ch below highlights
how code written in mathematical software packages such as
MATLAB can be
easily ported to run in Ch. Ch follows conventional mathematics
within the framework of ISO C/C++ standards.
Some operators such as '\' not commonly used in
conventional mathematics are excluded in Ch
to avoid confusion for learners.
Symbols Used in Comparison of Ch and MATLAB.
| Symbol | Data Type |
| x | scalar or computational array of real or complex type. |
| A, Ai, B, Bi | computational arrays of real or complex type. |
| Av, Avi, Bv, Bvi | one-dimensional computational arrays
of real or complex type. |
| R, Ri | computational arrays of real type. |
| Rv, Rvi | one-dimensional computational arrays of real type. |
| I, Ii | computational arrays of integral type. |
| Iv,Ivi | one-dimensional computational arrays of integral type. |
| C, Ci | arrays of char type. |
| Z, Zi | computational arrays of complex type. |
| Zv, Zvi | one-dimensional computational arrays of complex type. |
| s | scalar of real or complex type. |
| z | scalar complex type. |
| r | scalar real type. |
| f | scalar floating-point type. |
| i | scalar integral type. |
| p | pointer type. |
| str | a string. |
Comparisons of Operators in MATLAB and Ch.
| Operators | MATLAB | Ch |
| ~ | ~A | !A |
| | ~s | !s |
| + | +A | +A |
| | +s | +s |
| - | -A | -A |
| | -s | -s |
| > | A > B | A > B |
| | A > s | A > r |
| | s > A | s > A |
| >= | A >= B | A >= B |
| | A >= s | A >= r |
| | s >= A | r >= A |
| == | A == B | A == B |
| | A == s | A == s |
| | s == A | s == A |
| <= | A <= B | A <= B |
| | A <= s | A <= r |
| | s <= A | r <= A |
| < | A < B | A < B |
| | A < s | A < r |
| | s < A | r < A |
| ~= | A ~= B | A != B |
| | A ~= s | A != s |
| | s ~= A | s != A |
| | | A | B | A || B |
| | A | s | A || r |
| | s | A | r || A |
| & | A & B | A && B |
| | A & s | A && s |
| | s & A | s && A |
| + | A+B | A+B |
| | A+s | A+s |
| | s+A | s+A |
| | A = A+B | A = A+B |
| | A = A+B | A += B |
| - | A-B | A-B |
| | A-s | A-s |
| | s-A | s-A |
| | A = A-B | A = A-B |
| | A = A-B | A -= B |
| * | A*B | A*B |
| | A*s | A*s |
| | s*A | s*A |
| | A = A*B | A = A*B |
| | A = A*B | A *= B |
| / | A = A1/B1 | A=A1*inverse(B1) |
| | A/s | A/s |
| | A = A/s | A = A/s |
| | A = A/s | A /= s |
| ^ | i1^i2 | pow(i1,i2) |
| | s1^s2 | pow(s1,s2) |
| | I^i | pow(I,i) |
| | A^i | pow(A,i) |
| \ | A=A1\B1 | A=inverse(A1)*B1 |
| \ | Av=A\Bv' | linsolve(Av,A,Bv) |
| | | Av=inverse(A)*Bv |
| | | llsqsolve(Av,A,Bv) |
| ' | A' | transpose(A) |
| ' | Z' | transpose(conj(Z)) |
| .* | A .* B | A .* B |
| ./ | A ./ B | A ./ B |
| ./ | s ./ A | s ./ A |
| .^ | A.^B | pow(A, B) |
| .^ | A.^s | pow(A, (array double [n])s) |
| .^ | s.^A | pow((array double [n])s, A) |
| .\ | A.\B | (not valid) |
Comparisons of Functions in MATLAB and Ch
| Functions | MATLAB | Ch |
| abs | r=abs(s) | r=abs(s) |
| | r=abs(A) | r=abs(A) |
| | Iv=abs('str') | array int Iv[strlen("str")+1]={'s','t','r'} |
| addpath | addpath('/new/dir') | _path=stradd("/new/dir;", _path) |
|
addpath('/new/dir', '/dir2', begin) |
_path=stradd(_path, "/new/dir;/dir;") |
|
addpath('/new/dir', '/dir2', begin) |
_path=stradd(_path, "/new/dir;", "/dir;") |
| acos | x=acos(x) | x=acos(x) |
| acosh | x=acosh(x) | x=acosh(x) |
| all | i=all(A) | i=sum(!A=0)==0 |
| angle | r=angle(z) | r=carg(z) |
| any | i=any(A) | i=sum(A!=0)!=0 |
| asin | x=asin(x) | x=asin(x) |
| asinh | x=asinh(x) | x=asinh(x) |
| atan | x=atan(x) | x=atan(x) |
| atan2 | r=atan2(r1,r2) | r=atan2(r1,r2) |
| atanh | x=atanh(x) | x=atanh(x) |
| balance | [A, B] = balance(A1) | balance(A1, A, B) |
| base2dec | i=base2dec('str',i2) | i=strtol("str", NULL, i2) |
| blanks | str=blank(n) | " " |
| break | break | break |
| ceil | x=ceil(x) | s=ceil(s) |
| choly | A = chol(A1) | choldecomp(A1, A) |
| clear | clear name | remvar name |
| clear name | #pragma remvar(name) |
| compan | A=compan(Av) | R=companionmatrix(Rv) |
| | | Z=ccompanionmatrix(Zv) |
| cond | r=cond(A) | r=condnum(A) |
| condest | r=condest(A) | r=condnum(A) |
| conj | x=conj(x) | x=conj(x) |
| conv | Av = conv(Av1, Av2) | conv(Av, Av1, Av2) |
| conv2 | A = conv2(A1, A2) | conv2(A, A1, A2) |
| corr2 | r = corr2(R1, R2) | r = correlation2(R1, R2) |
| corrcoef | R = corrcoef(R1) | corrcoef(R, R1) |
| cos | x=cos(x) | x=cos(x) |
| cosh | x=cosh(x) | x=cosh(x) |
| cov | R = cov(R1) | covariance(R, R1) |
| cross | Rv=cross(Rv1,Rv2) | Rv=cross(Rv1,Rv2) |
| cumprod | A = cumprod(A1') | cumprod(A, A1) |
|
| | A = cumprod(A1) | cumprod(A, trasnpose(A1)) |
| | Av =cumprod(Av1) | cumprod(Av, Av1) |
| cumsum | A = cumsum(A1') | cumsum(A, A1) |
| | A = cumsum(A1) | cumsum(A, trasnpose(A1)) |
| | Av =cumsum(Av1) | cumsum(Av, Av1) |
| dec2bin | i=dec2bin(i2) | printf(%b", i2) |
| | | printf(%10b", i2) |
| dec2hex | str=dec2hex(x) | sprintf(str,"%x", r) |
| deconv | A=deconv(A1,B1) | deconv(A,A1,B1) |
| | [A, B]=deconv(A1,B1) | deconv(A,A1,B1,B) |
| deblank() | deblank('str') | (not valid) |
| det | s=det(A) | r=determinant(A) |
| | | z=cdeterminant(Z) |
| diag | Av=diag(A) | Rv=diagonal(R) |
| | | Zv=diagonal(Z) |
| | A=dia(Av) | R=diagonalmatrix(Rv) |
| | | Z=cdiagonalmatrix(Zv) |
| diff | A=diff(A) | Rv=difference(Rv) |
| | | r=derivative(func,r) |
| | | R=derivatives(func,R) |
| dot | x=dot(Av1,Av2) | r=dot(Rv1,Rv2) |
| eig | Av=eig(A1) | eigensystem(A1, Av, NULL) |
| | [Av, B]=eig(A1) | eigensystem(A1, Av, B) |
| | [Av, B]=eig(A1,'nobalance') | eigensystem(A1, Av, B, "nobalance") |
| eps | eps | #include <float.h> |
| | | FLT_EPSILON, DBL_EPSILON |
| eval | eval('cmd') | system("cmd") |
| | eval('expr') | streval("expr") |
| | eval(try,catch) | |
| eye | R=eye(i) | R=identitymatrix(i) |
| exp | x=exp(x) | x=exp(x) |
| expm | A = expm(A1) | expm(A,A1) |
| fclose | fclose | see fclose() |
| feval | feval('fun') | streval("fun") |
| feof | feof | see feof() |
| ferror | ferror | see perror() and other I/O functions |
| fft | Av = fft(Av1) | fft(Av, Av1) |
| | Av = fft(Av1, i) | A = fft(A1, i) |
| fft2 | A=fft2(A1) | fft(A, A1) |
| | A = fft(A1, i1, i2) | Iv[0]=i1, Iv[1] =i2, A = fft(A1, Iv) |
| fftn | A=fftn(A1) | fft(A, A1) /* 3D only */ |
| | A = fftn(A1, i) | Iv[0]=Iv[1]=Iv[2]=i, fft(A,A1,Iv) /* 3D only */ |
| fgetl | str = fgetl(fid) | i=strlen(str) |
| | | getline(fid, str, i) |
| fgets | fgets | see fgets() |
| fix | i=fix(r) | i=r |
| filter | Av = filter(Bv1, Bv2, Av1) | filter(Bv1, Bv2, Av1, Av) |
| filter2 | A = filter2(A1, B1) | filter2(A, A1, B1) |
| finite | i=finite(s) | i=isfinite(s) |
| | I=finite(A) | fevalarray(I,isfinite,R); |
| find() | i=find(x) | |
| | [r,c]=find(x) | |
| | I = find(A) | i=findvalue(I, A) /* i is # of values found */ |
| findstr() | i=findstr('str1', 'str2') | p=strstr(str1, str2) |
| fliplr | A = fliplr(A1) | fliplr(A, A1) |
| flipud | A = flipud(A1) | flipud(A, A1) |
| floor | floor(x) | floor(x) |
| flops | flops | (Not valid) |
| fmin | r = fmin('fun', r1, r2) | fminimum(&r3, &r, fun, r1, r2) |
| fmins | Rv = fmins('fun', Rv1) | fminimums(&r3, Rv, fun, Rv1) |
| fplot | fplot('fun', [r1 r2]) | fplotxy(fun,r1,r2) |
| | | fplotxyz() |
| | | CPlot:memberFunctions() |
| fprintf | fprintf() | see fprintf() |
| fread | fread() | see fread() |
| frewind | frewind() | see frewind() |
| fscanf | fscanf() | see fscanf() |
| fseek | fseek() | see fseek() |
| ftell | ftell() | see ftell() |
| funm | R = funm(R1,'fun') | funm(R, fun, R1) |
| | Z = funm(Z,'fun') | cfunm(Z, /* complex */ cfun, Z1) |
| fwrite | fwrite() | see fwrite() |
| fsolve | R =fsolve('fun', Ri) | fsolve(R, fun, Ri) |
| fzero | r = fzero('fun', r1) | fzero(&r, fun, r1) |
| gallery | A=gallery(name,arg1) | A=specialmatrix(Name,arg1) |
| | A=gallery(name,arg1,agr2) | A=specialmatrix(Name,arg1,arg2) |
| | A=gallery(name,arg1,agr2,arg3) | A=specialmatrix(Name,arg1,arg2,arg3) |
| | A=gallery('caychy',Av1) | specialmatrix("Cauchy",Av1) |
| | A=gallery('caychy',Av1,Av2) | specialmatrix("Cauchy",Av1,Av2) |
| | A=gallery('chebvand',Av1) | specialmatrix("ChebyshevVandemonde",Av1) |
| | A=gallery('chebvand',i,Av1) | specialmatrix("ChebyshevVandemonde",Av1,i) |
| | A=gallery('chow',i) | specialmatrix("Chow",i) |
| | A=gallery('chow',i,r1) | specialmatrix("Chow",i,r1) |
| | A=gallery('chow',i,r1,r2) | specialmatrix("Chow",i,r1,r2) |
| | A=gallery('circul',Av1) | specialmatrix("Circul",Av1) |
| | A=gallery('clement',i1,i2) | specialmatrix("Clement",i1,i2) |
| | | specialmatrix("DenavitHartenberg",r1,r2,r3,r4) |
| | | specialmatrix("DenavitHartenberg2",r1,r2,r3,r4) |
| | A=gallery('dramadah',i1) | specialmatrix("Dramadah",i1) |
| | A=gallery('dramadah',i1,i2) | specialmatrix("Dramadah",i1,i2) |
| | A=gallery('fiedler',Av1) | specialmatrix("Fiedler",Av1) |
| | A=gallery('frank',i1) | specialmatrix("Frank",i1) |
| | A=gallery('frank',i1,i2) | specialmatrix("Frank",i1,i2) |
| | A=gallery('gearmat',i1) | specialmatrix("Gear",i1) |
| | AV=gallery('house',Av1) | householdermatrix(Av1,Av) |
| | [AV,r]=gallery('house',Av1) | householdermatrix(Av1,Av,r) |
| | A=gallery('wilk',i1) | specialmatrix("Wilkinson",i1) |
| gcd() | I = gcd(I1, I2) | gcd(I1, I2, I) |
| | [I,I3,I4]=gcd(I1,I2) | gcd(I1, I2, I, I3, I4) |
| hadamard | A=hadamard(i1) | specialmatrix("Hadamard",i1) |
| hankel | A=hankel(Av1) | specialmatrix("Hankel",Av1) |
| | A=hankel(Av1,Av1) | specialmatrix("Hankel",Av1,Av2) |
| hex2dec | i=hex2dec('str') | i=strtol("str", NULL, 16) |
| hex2num() | r=hex2num('str') | |
| hess | [B, A] = hess(A1) | hessdecomp(A1, A, B) |
| hilb() | A=hilb(i1) | specialmatrix("Hilbert",i1) |
| hist | hist() | histogram() |
| i | i | #include <complex.h> |
| | | I |
| ifft | Av=ifft(Av1) | ifft(Av, Av1) |
| | Av=ifft(Av1, i) | ifft(A, A1, i) |
| ifft2 | A=ifft2(A1) | ifft(A,A1) |
| | A = ifft(A1, i1, i2) | Iv[0]=i1, Iv[2] =i2, ifft2(A, A1, Iv) |
| ifftn | A=ifftn(A1) | ifft(A, A1) /* 3D only */ |
| | A = iftn(A1, i) | Iv[0]=Iv[1]=Iv[2]=i, ifft(A, A1,Iv) |
| imag | r=imag(s) | r=imag(s) |
| | R=imag(A) | R=imag(A) |
| inf | inf | Inf |
| input | s=input(str) | r=getnum(str,r) |
| int2str | str=int2str(i) | sprintf(str,"%s", i) |
| interp1 | Ri=interp1(R1, R2, Ri1) | interp1(Ri, Ri1, R1, R2, "linear") |
| | Ri=interp1(R1, R2, Ri1,'linear') | interp1(Ri, Ri1, R1, R2, "linear") |
| | Ri=interp1(R1, R2, Ri1,'spline') | interp1(Ri, Ri1, R1, R2, "spline") |
| interp2 | Ri=interp2(R1, R2, R3, Ri1, Ri2) | interp2(Ri, Ri1, Ri2, R1, R2, R3, "linear") |
| | Ri=interp2(R1, R2, R3, Ri1, Ri2, 'linear') | interp2(Ri, Ri1, Ri2, R1, R2, R3, "linear") |
| | Ri = interp2(R1, R2, R3, Ri1, Ri2, 'spline') | interp2(Ri, Ri1, Ri2, R1, R2, R3, "spliine") |
| inv | A=inv(A) | R=inverse(R) |
| | | Z=cinverse(Z) |
| invhilb | A=invhilb(i1) | specialmatrix("InverseHilbert",i1) |
| isempty | i=isempty(A) | (not valid) |
| isglobal | i=isglobal(x) | #include <chshell.h> |
| | | isvar("x")==CH_SYSTEMVAR |
| ishold | i=ishold | (not valid) |
| isieee | i=isieee | (not valid) |
| isinf | i=isinf(s) | i=isinf(s) |
| | I=isinf(A) | fevalarray(I,isinf,R); |
| isletter | i=isletter(s) | i=isalpha(s) |
| | I=isletter(A) | fevalarray(I,isalpha,R); |
| isnan | i=isnan(s) | i=isnan(s) |
| | I=isnan(A) | fevalarray(I,isnan,R); |
| isreal | i=isreal(s) | i=elementtype(x) != elementtype(complex) && |
| | | elementtype(x) != elementtype(double complex) |
| isspace | i=isspace(s) | i=isspace(s) |
| | I=isspace(A) | fevalarray(I,isspace,R); |
| issparse | i=issparse(x) | |
| isstr | i=isstr(x) | i=elementtype(x)==elementtype(string_t) |
| isstudent | i=isstudent | i=isstudent() |
| isunix | i=isunix | #ifndef _WIN32_ |
| isvms | i=isvms | (not valid) |
| invhilb() | | |
| j | j | #include <complex.h> |
| | | I |
| lasterr | lasterr('') | see perror(), strerror() |
| lcm() | I = lcm(I1,I2) | lcm(I,I1,I2) |
| length | i=length(A) | i=max(shape(A) |
| linspace | x=linspace(first,last,n) | linspace(x,first,last) |
| loglog | loglog(x, y) | plot.loglog(x,y) |
| logspace | x=logspace(first,last,n) | logspace(x,first,last) |
| log | x=log(x) | x=log(x) |
| log10 | x=log10(x) | x=log10(x) |
| log2 | x=log2(x) | x=log(x)/log(2) |
| | r=log2(r) | r=log2(r) |
| logm | A=logm(A1) | logm(A,A1) |
| lower | str=lower('str') | see tolower() |
| lscov() | R = lscov(A1,R1,A2) | llsqcovsolve(A1,R1,A2,R) |
| | [R,R2]=lscov(A1,R1,A2) | llsqcovsolve(A1,R1,A2,R,R2) |
| lu | [R1,R2]=lu(A) | ludecomp(A,R1,R2) |
| | [R1,R2,I]=lu(A) | ludecomp(A,R1,R2,I) |
| magic() | A=magic(i1) | specialmatrix("Magic",i1) |
| max | r=max(s1,s2) | r=max(r1,r2) |
| | r=max(Av) | r=max(R) |
| | Rv=max(A) | Rv=maxv(R) |
| | | Rv=transpose(maxv(transpose(R)) |
| min | r=min(s1,s2) | r=min(r1,r2) |
| | r=min(Av) | r=min(R) |
| | Rv=min(A) | Rv=minv(R) |
| | | Rv=transpose(minv(transpose(R)) |
| mean | r=mean(R) | r=mean(R) |
| | Rv=mean(R) | r=mean(R, Rv) |
| | | mean(transpose(R), Rv) |
| | z = mean(Z) | z = cmean(Z) |
| | Zv = mean(Z) | cmean(Z, Zv) |
| median | r=median(R) | r=median(R) |
| | Rv=median(R) | r=median(R, Rv) |
| | | median(transpose(R), Rv) |
| mod | i=mod(i1,i2) | i=i1%i2 |
| | r=mod(r1,r2) | r=fmod(r1,r2) |
| NaN | NaN | NaN |
| nargin | nargin | (not valid) |
| nargout | nargout | (not valid) |
| nextpow2 | i=nextpow2(r) | i=ceil(log2(r)) |
| | i=nextpow2(z) | i=ceil(log2(abs(z))) |
| | i=nextpow2(Av) | i=ceil(log2((int)shape(Av))) |
| nnls() | R=nnls(A1,R1) | llsqnonnegsolve(A1,R1,R) |
| | R=nnls(A1,R1,r) | llsqnonnegsolve(A1,R1,R,r) |
| | [R,R2]=nnls(A1,R1) | llsqnonnegsolve(A1,R1,R,0.0,R2) |
| | [R,R2]=nnls(A1,R1,r) | llsqnonnegsolve(A1,R1,R,r,R2) |
| norm | norm(A) | norm(A,"2") |
| | norm(A,1) | norm(A,"1") |
| | norm(A,2) | norm(A,"2") |
| | norm(A,inf) | norm(A,"i") |
| | norm(A,'fro') | norm(A,"f") |
| | norm(Av) | norm(Av,"2") |
| | norm(Av,inf) | norm(Av,"i") |
| | norm(Av,-inf) | norm(Av,"-i") |
| | norm(Av,p) | norm(Av,"p") |
| num2str | str=num2str(s) | sprintf(str,"%s", s) |
| null | A=null(Ai) | nullspace(Ai, A) |
| ones | ones(i1) | (array int a[i1][i1])1 |
| | ones(i1,i2) | (array int a[i1][i2])1 |
| | ones(size(A)) | array int dim[2]=shape(A); |
| | | (array int a[dim[0]][dim[1]])1 |
| ode23 | [Rv1,Rv2]=ode23('fun',r1,r2,Rv) | odesolve(Rv1,Rv2,fun,r1,r2,Rv) |
| ode45 | [Rv1,Rv2]=ode45('fun',r1,r2,Rv) | odesolve(Rv1,Rv2,fun,r1,r2,Rv) |
| orth | A = orth(Ai) | orthonormalbase(Ai, A) |
| pascal() | A=pascal(i1) | specialmatrix("Pascal",i1) |
| | A=pascal(i1,i2) | specialmatrix("Pascal",i1,i2) |
| pi | pi | #include <math.h> |
| | | M_PI |
| pinv | A1=pinv(A) | R1=pinverse(R) |
| poly | Av=poly(A) | charpolycoef(Av,A) |
| | Bv=poly(Av) | polycoef(Bv,Av) |
| polyder | Av = polyder(Bv) | polyder(Av, Bv) |
| polyder2 | Av = polyder(Av1, Bv1) | polyder2(Av, NULL, Av1, Bv1) |
| | [Av, Bv] = polyder(Av1, Bv1) | polyder2(Av, Bv, Av1, Bv1) |
| polyfit | Rv=polyfit(Rv1, Rv2, i) | polyfit(Rv, Rv1, Rv2) |
| polyval | r = polyval(Rv1, r1) | r = polyeval(Rv1, r1) |
| | r = polyval(Rv1, r1, Rv) | r = polyeval(Rv1, r1, Rv) |
| | z = polyval(Av1, s) | z = cpolyeval(Av1, s) |
| | z = polyval(Av1, s, Av) | z = cpolyeval(Av1, s, Av) |
| | Av = polyval(Bv, Av1) | polyevalarray(Av, Bv, Av1) |
| | A=polyval(Av,A1) | polyeval(A,Av,A1) |
| polyvalm() | A=polyvalm(Av,A1) | polyevalm(A,Av,A1) |
| plot | plot(Rv1,Rv2) | plotxy(Rv1,Rv2) |
| | | plotxyf(file) |
| | | CPlot:memberFunctions() |
| plot3 | plot3(Rv1,Rv2,Rv3) | plotxyz(Rv1,Rv2,Rv3) |
| | | plotxyzf(file) |
| | | CPlot:memberFunctions() |
| prod | s=prod(A) | r=product(R) |
| | | z=cproduct(Z) |
| | Av=prod(A) | r=product(R, Rv) |
| | Av=prod(A, 1) | r=product(R, Rv) |
| | Av=prod(A, 2) | r=product(transpose(R), Rv) |
| | | z=cproduct(Z,Zv) |
| | | product(transpose(R), Rv) |
| | | cproduct(transpose(Z), Zv) |
| quad | r=quad('fun',r1,r2) | r=integral1(fun,r1,r2) |
| quad8 | r=quad8('fun',r1,r2) | r=integral1(fun,r1,r2) |
| qr | [A1, A2] = qr(A) | qrdecomp(A, A1, A2) |
| | [A1, A2, A3] = qr(A) | |
| | [A1,A2]=qr(A,0) | qrdecomp(A,A1,A2) |
| qrdelete | [A1, B1] = qrdelete(A, B, j) | qrdelete(A1, B1, A, B, j) |
| qrinsert | [A1, B1] = qrinsert(A, B, j, Av) | qrinsert(A1, B1, A, B, j, Av) |
| rank | i = rank(A) | i = rank(A) |
| | i = rank(A, r) | i = rank(A) |
| real | r=real(s) | r=real(s) |
| | R=real(A) | R=real(A) |
| realmax | realmax | #include <float.h> |
| | | FLT_MAX, DBL_MAX |
| realmin | realmin | #include <float.h> |
| | | FLT_MIN, DBL_MIN |
| rem | r=rem(r1,r2) | r=fmod(r1,r2) |
| | | r=remainder(r1,r2)+r2 |
| residue | [Av,Bv,Rv]=residue(Rv1,Rv2) | residue(Rv1, Rv2, Av, Bv, Rv) |
| round | i=round(r) | i=(int)(r>0?r+0.5:r-0.5) |
| roots | Av=roots(Bv) | roots(Av,Bv) |
| rosser | A=rosser() | specialmatrix("Rosser") |
| rot90(A) | A = rot90(A1) | rot90(A,A1) |
| | A = rot90(A1,i) | rot90(A,A1,i) |
| rand | r=rand() | r=urand() |
| randn | R=rand(i1, i2) | urand(R) |
| rcond | r = rcond(A) | r = rcondnum(A) |
| reshape | reshape(A, m, n) | (array type [m][n])A |
| rsf2csf | [A1, B1] = rsf2csf(A, B) | rsf2csf(A1, B1, A, B) |
| schur | A1 = schur(A) | schurdecomp(A, A1, NULL) |
| | [A1, A2] = schur(A) | schurdecomp(A, A1, A2) |
| semilogx | semilogx(x, y) | plot.semilogx(x,y) |
| semilogy | semilogy(x, y) | plot.semilogy(x,y) |
| sign | i=sign(r) | i=sign(r) |
| | z=sign(z) | z=z/abs(z) |
| sqrt | x=sqrt(x) | x=sqrt(x) |
| sqrtm | A = sqrtm(A1) | sqrtm(A,A1) |
| size | Iv=size(A) | Iv=shape(A) |
| | [i1,i2]=size(A) | Iv=shape(A); i1=Iv[0]; i2=Iv[1] |
| | i=size(A,1) | i = (int)shape(A) |
| | i=size(A,2) | Iv=shape(A); i=Iv[1] |
| sort | Av=sort(Av1) | sort(Av, Av1) |
| | | sort(Av, Av1, "array") |
| | A=sort(A1) | sort(A, A1, "column") |
| | A=sortrows(A1) | sort(A, A1, "row") |
| | [Av, I]=sort(Av1) | sort(Av, Av1, "array", I) |
| | | sort(Av, Av1, NULL, I) |
| | [A, I]=sort(A1) | sort(A, A1, "column", I) |
| | [A, I]=sortrows(A1) | sort(A, A1, "rows", I) |
| spline | Ri = spline(R1, R2, Ri1) | interp1(Ri, R1i, R2i, "spline") |
| | ri = spline(R1, R2, r) | CSpline::Interp(r) |
| | Ri = spline(R1, R2, Ri1) | CSpline::Interpm(Ri1, Ri) |
| sprintf | sprintf() | see sprintf() |
| sscanf | sscanf() | see sscanf() |
| std | r=std(R) | r=std(R) |
| | Rv=std(R) | r=std(R, Rv) |
| | | std(transpose(R), Rv) |
| str2mat | C=str2mat('str1', 'str2', ...) |
str2mat(C, str1, str2) |
| str2num | i=str2num('str') | i=atol(str), see strtod() |
| strcmp | strcmp('str1','str2') | !strcmp("str1","str2") |
| strrep | str = strrep('str1', 'str2', 'str3') |
str=strrep(str1, str2, str3) |
| strtok | strtok | see strtok(), strtok_r() |
| subplot | subplot() | CPlot::subplot() |
| | | CPlot::getSubplot() |
| sum | r=sum(A) | r=sum(R) |
| | | z=csum(Z) |
| | Av=sum(A) | r=sum(R, Rv) |
| | | z=csum(Z,Zv) |
| | | sum(transpose(R), Rv) |
| | | csum(transpose(Z), Zv) |
| svd | R = svd(A) | svd(A, R, NULL, NULL) |
| | [A1, R, A2] = svd(A)) | svd(A, R, A1, A2) |
| tan | x=tan(x) | x=tan(x) |
| tanh | x=tanh(x) | x=tanh(x) |
| toeplitz | A=toeplitz(Av1) | specialmatrix("Toeplitz",Av1) |
| | A=toeplitz(Av1,Av2) | specialmatrix("Toeplitz",Av1,Av2) |
| trace | s=trace(A) | r=trace(R) |
| | | z=ctrace(Z) |
| trapz | r=trapz(Rv1,Rv2) | see integral1() |
| tril | A1=tril(A) | A1=triangularmatrix("lower",A) |
| | Z1=tril(Z) | Z1=ctriangularmatrix("lower",Z) |
| | A1=tril(A,i) | A1=triangularmatrix("lower",A,i) |
| | Z1=tril(Z,i) | Z1=ctriangularmatrix("lower",Z,i) |
| triu | A1=triu(A) | A1=triangularmatrix("upper",A) |
| | Z1=triu(Z) | Z1=ctriangularmatrix("upper",Z) |
| | A1=triu(A,i) | A1=triangularmatrix("upper",A,i) |
| | Z1=triu(Z,i) | Z1=ctriangularmatrix("upper",Z,i) |
| vander | R=vander(Rv) | R=vandermatrix(Rv) |
| | A=vander(Av) | specialmatrix("Vandermonde", Av) |
| unwrap() | A=unwrap(A1) | unwrap(A,A1) |
| | A=unwrap(A1,r) | unwrap(A,A1,r) |
| upper | str=upper('str') | see toupper() |
| who | who | display |
| xcorr | Av = xcorr(Av1, Av2) | correlation(Av, Av1, Av2) |
| xor | xor(A,B) | A ^^ B |
| | xor(A,s) | A ^^ r |
| | xor(s,A) | r ^^ A |
| zeros | zeros(i1) | (array int a[i1][i1])0 |
| | zeros(i1,i2) | (array int a[i1][i2])0 |
| | zeros(size(A)) | array int dim[2]=shape(A); |
| | | (array int a[dim[0]][dim[1]])0 |
Control Flow Comparison Between MATLAB and Ch
| descriptions | MATLAB | Ch |
| for-loop | For n=n1:n2:n3
commands
end | for (n=n1; n<=n3; n+=n2) {
commands
} |
| while-loop | while expr
commands
end | while(expr) {
commands
} |
| if | if expr
commands
end | if (expr) {
commands
} |
| if-else | if expr1
commands1
else
commands2
end | if (expr1) {
commands1
}
else{
commands2
} |
| if-else if-else | if expr1
commands1
elseif expr2
commands2
else
commands3
end |
if (expr1) {
commands1
}
else if(expr2) {
commands2
}
else {
commands3
} |
References:
-
The Ch Language Environment, ---
User's Guide, Version 2.0,
Harry H. Cheng, SoftIntegration, Inc., September 2001.
-
The Ch Language Environment, ---
Reference Guide, Version 2.0,
SoftIntegration, Inc., September 2001.
-
MATLAB Function Reference, Version 6, The MathWorks, Inc., 2001.
MATLAB® is a registered trademark of The MathWorks, Inc.
Motif® is a registered trademark of the Open Group.
OpenGL® is a registered trademark of SGI.
|