/* natural log of as Real number */
Real * lnEqReal(Real *a){
switch(a->ok){
case REAL_OK:
if(a->num > 0.0){
a->num = log(a->num);
checkFinite(a);
}
else if(a->num == 0.0){
a->ok = REAL_INF;
a->num = 0.0;
} else {
printf("lnEqReal(<0)\n");
exit(0);
}
break;
case REAL_INF:
a->num = 0.0;
break;
case REAL_NAN:
a->num = 0.0;
break;
default:
fprintf(stderr, "lnReal unknown real type\n");
exit(0);
break;
}
return a;
}
/* log base ten of a Real number */
Real * logReal(Real *a){
Real *p = newReal();
switch(a->ok){
case REAL_OK:
if(a->num > 0.0){
p->ok = a->ok;
p->num = log10(a->num);
checkFinite(p);
}
else if(a->num == 0.0){
p->ok = REAL_INF;
p->num = 0.0;
} else {
printf("logReal(<0)\n");
exit(0);
}
break;
case REAL_INF:
p->ok = REAL_INF;
p->num = 0.0;
break;
case REAL_NAN:
p->ok = REAL_NAN;
p->num = 0.0;
break;
default:
fprintf(stderr, "logReal unknown real type\n");
exit(0);
break;
}
return p;
}
/* negate a Real number */
Real * negReal(Real *a){
Real *p = newReal();
p->ok = a->ok;
p->num = -(a->num);
checkFinite(p);
return p;
}
/* absolute value of a Real number */
Real * absReal(Real *a){
Real *p = newReal();
p->ok = a->ok;
p->num = fabs(a->num);
checkFinite(p);
return p;
}
Real * setRealDouble(Real *a, double d){
a->ok = REAL_OK;
a->num = d;
checkFinite(a);
return a;
}
/* right shift 2 Real Numbers */
Real * rshiftReal(Real *a, Real *b){
Real *p = newReal();
if(a->ok == REAL_OK && b->ok == REAL_OK){
p->ok = REAL_OK;
p->num = (ulong)a->num >> (ulong)b->num;
checkFinite(p);
}
/* Real number to the power */
Real * powRealInt(Real *a, int b){
Real *p = newReal();
p->ok = a->ok;
p->num = pow(a->num, (double)b);
checkFinite(p);
return p;
}
void ReactorNet::eval(doublereal t, doublereal* y,
doublereal* ydot, doublereal* p)
{
updateState(y);
for (size_t n = 0; n < m_reactors.size(); n++) {
m_reactors[n]->evalEqs(t, y + m_start[n], ydot + m_start[n], p);
}
checkFinite("ydot", ydot, m_nv);
}
/*
* This routine checks to see if a number stays bounded. The absolute
* value of the number is required to stay below the trigger.
*
* @param tmp Number to be checked
* @param trigger bounds on the number. Defaults to 1.0E20
*/
void checkMagnitude(const double tmp, const double trigger) throw(std::range_error) {
checkFinite(tmp);
if (fabs(tmp) >= trigger) {
char sbuf[64];
sprintf(sbuf, "checkMagnitude: Trigger %g exceeded: %g\n", trigger,
tmp);
throw std::range_error(sbuf);
}
}
/* invert a Real number */
Real * invEqReal(Real *a){
if(a->num == 0.0){
a->ok = REAL_NAN;
a->num = 0.0;
} else {
a->num = 1.0 / a->num;
checkFinite(a);
}
return a;
}
/* multiply 2 Real numbers */
Real * mulEqReal(Real *a, Real *b){
if(a->ok == REAL_OK && b->ok == REAL_OK){
a->num *= b->num;
checkFinite(a);
}
else if(a->ok == REAL_NAN || b->ok == REAL_NAN) a->ok = REAL_NAN;
else a->ok = REAL_INF;
return a;
}
Real * setRealReal(Real *a, Real *b){
if(a && b){
a->ok = b->ok;
if(b->ok == REAL_OK){
a->num = b->num;
checkFinite(a);
} else {
a->num = 0.0;
}
}
return a;
}
/* Real number to the power */
Real * powEqReal(Real *a, Real *b){
if(a->ok == REAL_OK && b->ok == REAL_OK){
a->num = pow(a->num, b->num);
checkFinite(a);
} else if(a->ok == REAL_NAN || b->ok == REAL_NAN){
a->num = 0.0;
}
return a;
}
/* invert a Real number */
Real * invReal(Real *a){
Real *p = newReal();
p->ok = a->ok;
if(a->num == 0.0){
p->ok = REAL_NAN;
p->num = 0.0;
} else {
p->num = 1.0 / a->num;
checkFinite(p);
}
return p;
}
Real * fromRadixReal(Real *a){
Real *r1;
/* deal with degrees if we need to */
if(getRadixMode() == DEGREES){
r1 = divReal(a, real180Pi);
} else {
r1 = setRealReal(newReal(), a);
}
checkFinite(r1);
return r1;
}
/* left shift 2 Real Numbers */
Real * lshiftReal(Real *a, Real *b){
Real *p = newReal();
if(a->ok == REAL_OK && b->ok == REAL_OK){
p->ok = REAL_OK;
p->num = (ulong)a->num << (ulong)b->num;
checkFinite(p);
}
else if(a->ok == REAL_NAN || b->ok == REAL_NAN) p->ok = REAL_NAN;
else p->ok = REAL_INF;
return p;
}
/* subtract 2 Real numbers */
Real * subReal(Real *a, Real *b){
Real *p = newReal();
if(a->ok == REAL_OK && b->ok == REAL_OK){
p->ok = REAL_OK;
p->num = a->num - b->num;
checkFinite(p);
}
else if(a->ok == REAL_NAN || b->ok == REAL_NAN) p->ok = REAL_NAN;
else p->ok = REAL_INF;
return p;
}
/* trig func */
Real * atan2Real(Real *a, Real *b){
Real *p = newReal();
if(a->ok == REAL_OK && b->ok == REAL_OK){
p->ok = REAL_OK;
p->num = atan2(a->num, b->num);
checkFinite(p);
} else if(a->ok == REAL_NAN || b->ok == REAL_NAN){
p->ok = REAL_NAN;
p->num = 0.0;
} else {
p->ok = REAL_INF;
p->num = 0.0;
}
return p;
}
/* modulo 2 Real numbers */
Real * modReal(Real *a, Real *b){
Real *p = newReal();
switch(a->ok){
case REAL_OK:
switch(b->ok){
case REAL_OK:
if(b->num == 0.0){
p->ok = REAL_NAN;
p->num = 0.0;
} else {
p->ok = REAL_OK;
p->num = fmod(a->num , b->num);
checkFinite(p);
}
break;
case REAL_INF:
p->ok = REAL_NAN;
p->num = 0.0;
break;
case REAL_NAN:
p->ok = REAL_NAN;
p->num = 0.0;
break;
default:
fprintf(stderr, "modReal unknown real type\n");
exit(0);
break;
}
break;
case REAL_INF:
p->ok = REAL_INF;
p->num = 0.0;
break;
case REAL_NAN:
p->ok = REAL_NAN;
p->num = 0.0;
break;
default:
fprintf(stderr, "modReal unknown real type\n");
exit(0);
break;
}
return p;
}
/*
* This routine is accessible from fortran, usually
*
* @param tmp Pointer to the number to check
*
* @todo link it into the usual way Cantera handles Fortran calls
*/
extern "C" void checkfinite_(double * tmp) {
checkFinite(*tmp);
}
/* negate a Real number */
Real * negEqReal(Real *a){
a->num = -a->num;
checkFinite(a);
return a;
}
/* e to a Real number */
Real * expEqReal(Real *a){
a->num = exp(a->num);
checkFinite(a);
return a;
}
/* trig func */
Real * sinEqReal(Real *a){
a->num = sin(a->num);
checkFinite(a);
return a;
}
/* trig func */
Real * tanEqReal(Real *a){
a->num = tan(a->num);
checkFinite(a);
return a;
}
/* trig func */
Real * cosEqReal(Real *a){
a->num = cos(a->num);
checkFinite(a);
return a;
}
