Section 1-3 Compatibilty with C language

if, else

goto, break, continue, return

for, while, do while
work also in CEMMATH. Nevertheless, there is still a limitation. For example, the keyword ‘case’ in CEMMATH can admit only a constant integer. Of course, such a limitation will be cleared as CEMMATH is updated.
■ Abbreviation. Although CEMMATH can handle the programs in C language to a considerable degree, it is possible to abbreviate prototypes of a function. For example,
double ftn(double a,double b,double &c,double *d);
can be abbreviated as
double ftn(a,b,&c,*d);
CEMMATH presumes that a preceding declarer applied to the following variables. If no explicit declarer appears as with ‘void’, ‘double’ is by default used as type declarer. This means that
void ftn(a,b,long i,j, char x,y);
in CEMMATH is the same as
void ftn(double a,double b, long i,long j, char x,char y);
■ Compatibility with C-Language. Consider the following two subroutines developed in C language.
double x_fun(double);

double x_fun(double x) { return exp(x)-sin(x)-2; }

double x_bisect(double (*fun)(double),double xa,double xb ) {

double iter,eps,fa,fb,x,f;
iter = 0; eps = 1.e-7;

fa = fun(xa); if( fabs(fa) < eps ) return xa;

fb = fun(xb); if( fabs(fb) < eps ) return xb;

if( fa*fb > 0 ) { return 0; }

while( ++iter < 200 ) {

x = 0.5*(xa+xb);

f = fun(x);

if( fabs(f) < eps) return x;

if( fa*f > 0 ) { xa = x; fa = f; }

else { xb = x; fb = f; }

}

return 0;

double factorial(double n) {

if( n == 0 ) return 1;

return n*factorial(n-1); // recurrence function

}
#> factorial(10);

ans = 3628800

Figure 3 Bessel functions

#> f++( [1,2] ); // extension to matrix

#> f ' (1); f '' (1); // extension to differentiation

ans =

ans = 1.3817733

ans = 0.23913538
Note that the ‘double’-returning function is also upgraded to allow differentiation operator.
■ Dynamic Default Assignment. In C and C++ languages, the default arguments allow only constant initialization, for example
double area(double a, double b = 10);
However, CEMMATH allows dynamic default arguments as long as the variable has appeared in the preceding arguments.
Consider an area of a rectagule which becomes for the case of a retangule with a side . This kind of special degradation can be fulfilled by applying dynamic default assignment
#> double area(a, b=a) = a*b; // semicolon is must-element

#> area(3);

#> area(3,4);

ans = 9

#> void f2(&x2) { x2 = cos(x2);; f1(x2);; z2 = 2;; }

#> void f3(&x3) { x3 = exp(x3);; f2(x3);; z3 = 3;; }

#> void f4(&x4) { x4 = log(x4);; f3(x4);; z4 = 4;; }

#> f4(y);

f4.y = 1.0986123

f4.f3.y = 3

f4.f3.f2.y = -0.9899925

f4.f3.f2.f1.y = -0.83602186

f4.f3.f2.f1.z1 = 1

f4.f3.f2.z2 = 2

f4.f3.z3 = 3

f4.z4 = 4
It is noteworthy that the variable ‘y’ has never been appeared in the contents of functions. Nevertheless, the execution shows the name of ‘y’ in all four functions, since the variable ‘y’ is a refered variable by the prefix ‘&’.
The above discussion can be compared with the following case
#> void g1(x1) { x1 = sin(x1);; z1 = 1;; }

#> void g2(x2) { x2 = cos(x2);; g1(x2);; z2 = 2;; }

#> void g3(x3) { x3 = exp(x3);; g2(x3);; z3 = 3;; }

#> void g4(x4) { x4 = log(x4);; g3(x4);; z4 = 4;; }

#> y=3;

#> g4(y);

g4.x4 = 1.0986123

g4.g3.x3 = 3

g4.g3.g2.x2 = -0.9899925

g4.g3.g2.g1.x1 = -0.83602186

g4.g3.g2.g1.z1 = 1

g4.g3.g2.z2 = 2

g4.g3.z3 = 3

g4.z4 = 4
Note that the variable ‘y’ has been copied before it enters a function as an argument.
The capability of auto tracing would help users to follow what is exactly happening in the course of execution. The auto tracing may replace the heavy burden of debugging mode, even if not fully covered.
//----------------------------------------------------------------------------

// end of file