void
prim_modf(PRIM_PROTOTYPE)
{
float tresult;
double dresult;
CHECKOP(1);
oper1 = POP();
if ( oper1->type == PROG_INTEGER )
{ oper1->type = PROG_FLOAT;
oper1->data.fnumber = oper1->data.number;
}
if (oper1->type != PROG_FLOAT)
abort_interp("Non-float argument. (1)");
if (!no_good(oper1->data.fnumber)) {
fresult = (float) modf((double) oper1->data.fnumber, &dresult);
} else {
fresult = 0.0;
tresult = 0.0;
fr->error.error_flags.f_bounds = 1;
}
CLEAR(oper1);
tresult = (float) dresult;
CHECKOFLOW(2);
PushFloat(tresult);
PushFloat(fresult);
}
static uchar PushPowHouGrp(uchar ibGrp, uint iwHhr, uchar bMultiplier)
{
if (iwHhr == iwHardHou)
return PushFloat(GetPowGrpHouCurr(ibGrp, bMultiplier));
else
return PushFloat(GetGrpHouInt2Real(mpwImpHouCan[ PrevSoftHou() ], ibGrp, bMultiplier));
}
void
prim_xyz_to_polar(PRIM_PROTOTYPE)
{
float dist, theta, phi;
double x, y, z;
CHECKOP(3);
oper3 = POP();
oper2 = POP();
oper1 = POP();
if ( oper1->type == PROG_INTEGER )
{ oper1->type = PROG_FLOAT;
oper1->data.fnumber = oper1->data.number;
}
if ( oper2->type == PROG_INTEGER )
{ oper2->type = PROG_FLOAT;
oper2->data.fnumber = oper1->data.number;
}
if ( oper3->type == PROG_INTEGER )
{ oper3->type = PROG_FLOAT;
oper3->data.fnumber = oper1->data.number;
}
if (oper1->type != PROG_FLOAT)
abort_interp("Non-float argument. (1)");
if (oper2->type != PROG_FLOAT)
abort_interp("Non-float argument. (2)");
if (oper3->type != PROG_FLOAT)
abort_interp("Non-float argument. (3)");
x = oper1->data.fnumber;
y = oper2->data.fnumber;
z = oper3->data.fnumber;
if (no_good(x) || no_good(y) || no_good(z)) {
dist = 0.0;
theta = 0.0;
phi = 0.0;
fr->error.error_flags.nan = 1;
} else {
dist = (float) sqrt((x * x) + (y * y) + (z * z));
if (dist > 0.0) {
theta = (float) atan2(y, x);
phi = (float) acos(z / dist);
} else {
theta = 0.0;
phi = 0.0;
}
}
CLEAR(oper1);
CLEAR(oper2);
CLEAR(oper3);
PushFloat(dist);
PushFloat(theta);
PushFloat(phi);
}
void
prim_diff3(PRIM_PROTOTYPE)
{
double xout, yout, zout;
double x, y, z;
double x2, y2, z2;
CHECKOP(3);
oper3 = POP();
oper2 = POP();
oper1 = POP();
if (oper1->type != PROG_FLOAT)
abort_interp("Non-float argument. (4)");
if (oper2->type != PROG_FLOAT)
abort_interp("Non-float argument. (5)");
if (oper3->type != PROG_FLOAT)
abort_interp("Non-float argument. (6)");
x = oper1->data.fnumber;
y = oper2->data.fnumber;
z = oper3->data.fnumber;
CLEAR(oper1);
CLEAR(oper2);
CLEAR(oper3);
CHECKOP(3);
oper3 = POP();
oper2 = POP();
oper1 = POP();
if (oper1->type != PROG_FLOAT)
abort_interp("Non-float argument. (1)");
if (oper2->type != PROG_FLOAT)
abort_interp("Non-float argument. (2)");
if (oper3->type != PROG_FLOAT)
abort_interp("Non-float argument. (3)");
x2 = oper1->data.fnumber;
y2 = oper2->data.fnumber;
z2 = oper3->data.fnumber;
CLEAR(oper1);
CLEAR(oper2);
CLEAR(oper3);
xout = x - x2;
yout = y - y2;
zout = z - z2;
PushFloat(xout);
PushFloat(yout);
PushFloat(zout);
}
void
prim_polar_to_xyz(PRIM_PROTOTYPE)
{
float x, y, z;
double dist, theta, phi;
CHECKOP(3);
oper3 = POP();
oper2 = POP();
oper1 = POP();
if ( oper1->type == PROG_INTEGER )
{ oper1->type = PROG_FLOAT;
oper1->data.fnumber = oper1->data.number;
}
if ( oper2->type == PROG_INTEGER )
{ oper2->type = PROG_FLOAT;
oper2->data.fnumber = oper1->data.number;
}
if ( oper3->type == PROG_INTEGER )
{ oper3->type = PROG_FLOAT;
oper3->data.fnumber = oper1->data.number;
}
if (oper1->type != PROG_FLOAT)
abort_interp("Non-float argument. (1)");
if (oper2->type != PROG_FLOAT)
abort_interp("Non-float argument. (2)");
if (oper3->type != PROG_FLOAT)
abort_interp("Non-float argument. (3)");
dist = oper1->data.fnumber;
theta = oper2->data.fnumber;
phi = oper3->data.fnumber;
if (no_good(dist) || no_good(theta) || no_good(phi)) {
x = 0.0;
y = 0.0;
z = 0.0;
fr->error.error_flags.nan = 1;
} else {
x = (float) (dist * cos(theta) * sin(phi));
y = (float) (dist * sin(theta) * sin(phi));
z = (float) (dist * cos(phi));
}
CLEAR(oper1);
CLEAR(oper2);
CLEAR(oper3);
PushFloat(x);
PushFloat(y);
PushFloat(z);
}
void
prim_pow(PRIM_PROTOTYPE)
{
CHECKOP(2);
oper1 = POP();
oper2 = POP();
if (oper2->type != PROG_FLOAT)
abort_interp("Non-float argument. (1)");
if (oper1->type != PROG_FLOAT)
abort_interp("Non-float argument. (2)");
if (!no_good(oper1->data.fnumber) && !no_good(oper2->data.fnumber)) {
if (fabs(oper2->data.fnumber) < DBL_EPSILON) {
fresult = 0.0;
} else if (oper2->data.fnumber < 0.0 &&
oper1->data.fnumber != floor(oper1->data.fnumber))
{
fresult = 0.0;
fr->error.error_flags.imaginary = 1;
} else {
fresult = pow(oper2->data.fnumber, oper1->data.fnumber);
}
} else {
fresult = 0.0;
fr->error.error_flags.f_bounds = 1;
}
CLEAR(oper1);
CLEAR(oper2);
PushFloat(fresult);
}
void
prim_dist3d(PRIM_PROTOTYPE)
{
double dist;
double x, y, z;
CHECKOP(3);
oper3 = POP();
oper2 = POP();
oper1 = POP();
if (oper1->type != PROG_FLOAT)
abort_interp("Non-float argument. (1)");
if (oper2->type != PROG_FLOAT)
abort_interp("Non-float argument. (2)");
if (oper3->type != PROG_FLOAT)
abort_interp("Non-float argument. (3)");
x = oper1->data.fnumber;
y = oper2->data.fnumber;
z = oper3->data.fnumber;
dist = sqrt((x * x) + (y * y) + (z * z));
CLEAR(oper1);
CLEAR(oper2);
CLEAR(oper3);
PushFloat(dist);
}
void
prim_fmod(PRIM_PROTOTYPE)
{
CHECKOP(2);
oper1 = POP();
oper2 = POP();
if ( oper1->type == PROG_INTEGER )
{ oper1->type = PROG_FLOAT;
oper1->data.fnumber = oper1->data.number;
}
if ( oper2->type == PROG_INTEGER )
{ oper2->type = PROG_FLOAT;
oper2->data.fnumber = oper1->data.number;
}
if (oper2->type != PROG_FLOAT)
abort_interp("Non-float argument. (1)");
if (oper1->type != PROG_FLOAT)
abort_interp("Non-float argument. (2)");
if (oper1->data.fnumber < SMALL_NUM && oper1->data.fnumber > NSMALL_NUM) {
fresult = 0.0;
fr->error.error_flags.div_zero = 1;
} else {
fresult = oper2->data.fnumber / oper1->data.fnumber;
fresult = fresult - (float) ((int) fresult);
}
CLEAR(oper1);
CLEAR(oper2);
PushFloat(fresult);
}
void
prim_sqrt(PRIM_PROTOTYPE)
{
CHECKOP(1);
oper1 = POP();
if ( oper1->type == PROG_INTEGER )
{ oper1->type = PROG_FLOAT;
oper1->data.fnumber = oper1->data.number;
}
if (oper1->type != PROG_FLOAT)
abort_interp("Non-float argument. (1)");
if (!no_good(oper1->data.fnumber)) {
if (oper1->data.fnumber < 0.0) {
fresult = 0.0;
fr->error.error_flags.imaginary = 1;
} else {
fresult = (float) sqrt((double) oper1->data.fnumber);
}
} else {
fresult = 0.0;
fr->error.error_flags.f_bounds = 1;
}
CLEAR(oper1);
PushFloat(fresult);
}
void
prim_tan(PRIM_PROTOTYPE)
{
CHECKOP(1);
oper1 = POP();
if ( oper1->type == PROG_INTEGER )
{ oper1->type = PROG_FLOAT;
oper1->data.fnumber = oper1->data.number;
}
if (oper1->type != PROG_FLOAT)
abort_interp("Non-float argument. (1)");
if (!no_good(oper1->data.fnumber)) {
fresult = fmod((oper1->data.fnumber - H_PI), F_PI);
if (fresult < 0.000001 || fresult > (F_PI - 0.000001)) {
fresult = (float) tan((double) oper1->data.fnumber);
} else {
fresult = 0.0;
fr->error.error_flags.nan = 1;
}
} else {
fresult = 0.0;
fr->error.error_flags.f_bounds = 1;
}
CLEAR(oper1);
PushFloat(fresult);
}
void
prim_round(PRIM_PROTOTYPE)
{
double temp, tshift, tnum, fstore;
CHECKOP(2);
oper1 = POP();
oper2 = POP();
if (oper1->type != PROG_INTEGER)
abort_interp("Non-integer argument. (2)");
if (oper2->type != PROG_FLOAT)
abort_interp("Non-float argument. (1)");
if (oper1->type < 0)
abort_interp("Precision argument must be a positive integer. (2)");
if (!no_good(oper2->data.fnumber)) {
temp = pow(10.0, (double) oper1->data.number);
tshift = temp * ((double) oper2->data.fnumber);
tnum = modf(tshift, &fstore);
if (tnum >= 0.5) {
fstore = fstore + 1.0;
} else {
if (tnum <= -0.5) {
fstore = fstore - 1.0;
}
}
fstore = fstore / temp;
fresult = (float) fstore;
} else {
fresult = 0.0;
fr->error.error_flags.f_bounds = 1;
}
CLEAR(oper1);
CLEAR(oper2);
PushFloat(fresult);
}
void
prim_pi(PRIM_PROTOTYPE)
{
CHECKOP(0);
fresult = F_PI;
CHECKOFLOW(1);
PushFloat(fresult);
}
void
prim_inf(PRIM_PROTOTYPE)
{
CHECKOP(0);
fresult = INF;
CHECKOFLOW(1);
PushFloat(fresult);
}
void
prim_frand(PRIM_PROTOTYPE)
{
CHECKOP(0);
CHECKOFLOW(1);
fresult = _int_f_rand();
PushFloat( fresult );
}
void
prim_epsilon(PRIM_PROTOTYPE)
{
CHECKOP(0);
fresult = DBL_EPSILON;
CHECKOFLOW(1);
PushFloat(fresult);
}
void
prim_float(PRIM_PROTOTYPE)
{
CHECKOP(1);
oper1 = POP();
if (oper1->type != PROG_INTEGER)
abort_interp("Non-integer argument. (1)");
fresult = (float) oper1->data.number;
CLEAR(oper1);
PushFloat(fresult);
}
void OutCntCanMonExt(void)
{
SaveDisplay();
sprintf(szHi,"—четчики: %02u-%02u",bInBuff6+1,bInBuff7+1); Clear();
if ((bInBuff6 < bCANALS) && (bInBuff7 < 12))
{
InitPushPtr();
if (GetDigitalPhone(bInBuff6) != 0)
{
PushChar(3);
PushChar(0xFF);
PushChar(0xFF);
PushChar(0xFF);
PushChar(0xFF);
}
else if (mpboEnblCan[bInBuff6] == false)
{
PushChar(2);
PushChar(0xFF);
PushChar(0xFF);
PushChar(0xFF);
PushChar(0xFF);
}
else
{
uchar p = ibPort;
double2 db2 = ReadCntMonCan(bInBuff7,bInBuff6);
ibPort = p;
if (db2.fValid == false)
{
PushChar(1);
PushChar(0xFF);
PushChar(0xFF);
PushChar(0xFF);
PushChar(0xFF);
}
else
{
PushChar(0);
PushFloat(db2.dbValue);
}
}
OutptrOutBuff(1+sizeof(float));
}
else Result(bRES_BADADDRESS);
LoadDisplay();
NextPause(); // внимание !
}
void
prim_systime_precise(PRIM_PROTOTYPE)
{
struct timeval fulltime;
double dbltime;
CHECKOP(0);
gettimeofday(&fulltime, (struct timezone *) 0);
CHECKOFLOW(1);
dbltime = fulltime.tv_sec + (((double) fulltime.tv_usec) / 1.0e6);
PushFloat(dbltime);
}
void
prim_atan(PRIM_PROTOTYPE)
{
CHECKOP(1);
oper1 = POP();
if (oper1->type != PROG_FLOAT)
abort_interp("Non-float argument. (1)");
if (!no_good(oper1->data.fnumber)) {
fresult = atan(oper1->data.fnumber);
} else {
fresult = H_PI;
}
CLEAR(oper1);
PushFloat(fresult);
}
void
prim_atan2(PRIM_PROTOTYPE)
{
CHECKOP(2);
oper2 = POP();
oper1 = POP();
if (oper1->type != PROG_FLOAT)
abort_interp("Non-float argument. (1)");
if (oper2->type != PROG_FLOAT)
abort_interp("Non-float argument. (2)");
fresult = atan2(oper1->data.fnumber, oper2->data.fnumber);
CLEAR(oper1);
CLEAR(oper2);
PushFloat(fresult);
}
void
prim_acos(PRIM_PROTOTYPE)
{
CHECKOP(1);
oper1 = POP();
if (oper1->type != PROG_FLOAT)
abort_interp("Non-float argument. (1)");
if ((oper1->data.fnumber >= -1.0) && (oper1->data.fnumber <= 1.0)) {
fresult = acos(oper1->data.fnumber);
} else {
fresult = 0.0;
fr->error.error_flags.nan = 1;
}
CLEAR(oper1);
PushFloat(fresult);
}
void
prim_floor(PRIM_PROTOTYPE)
{
CHECKOP(1);
oper1 = POP();
if (oper1->type != PROG_FLOAT)
abort_interp("Non-float argument. (1)");
if (!no_good(oper1->data.fnumber)) {
fresult = (float) floor((double) oper1->data.fnumber);
} else {
fresult = 0.0;
fr->error.error_flags.f_bounds = 1;
}
CLEAR(oper1);
PushFloat(fresult);
}
void GetEngGrpMonUni(bool fDouble)
{
if ((bInBuff6 != 0) || (bInBuff8 != 0) || (bInBuffA != 0))
Result2(bUNI_BADDATA);
else if (bInBuff7 > bGROUPS)
Result2(bUNI_BADDATA);
else if (bInBuff7+bInBuff9-1 > bGROUPS)
Result2(bUNI_BADDATA);
else if (bInBuffB >= bMONTHS)
Result2(bUNI_BADDATA);
else if (bInBuffC > bTARIFFS)
Result2(bUNI_BADDATA);
else if (bInBuffC+bInBuffD-1 > bTARIFFS)
Result2(bUNI_BADDATA);
else
{
InitPushUni();
LoadImpMon((bMONTHS+ibHardMon-bInBuffB) % bMONTHS);
uint wSize = 0;
uchar g;
for (g=bInBuff7; g<bInBuff7+bInBuff9; g++)
{
uchar i;
for (i=bInBuffC; i<bInBuffC+bInBuffD; i++)
{
if (fDouble)
{
PushDouble(GetGrpImp2DoubleEng(mpimMonCan[ PrevSoftMon() ], g-1, 0x01 << (i-1)));
wSize += sizeof(double);
}
else
{
PushFloat(GetGrpImp2FloatEng(mpimMonCan[ PrevSoftMon() ], g-1, 0x01 << (i-1)));
wSize += sizeof(float);
}
}
}
ulong dw = DateToMonIndex(*GetCurrTimeDate());
dw -= bInBuffB;
time ti = MonIndexToDate(dw);
Output2_Code(wSize, ((CheckDefGrpMonUni(ti.bMonth) == 0) ? bUNI_OK : bUNI_DEFECT), ti);
}
}
void GetEngCanDayUni(bool fDouble)
{
if ((bInBuff6 != 0) || (bInBuff8 != 0) || (bInBuffA != 0))
Result2(bUNI_BADDATA);
else if (bInBuff7 > bCANALS)
Result2(bUNI_BADDATA);
else if (bInBuff7+bInBuff9-1 > bCANALS)
Result2(bUNI_BADDATA);
else if (bInBuffB >= bDAYS)
Result2(bUNI_BADDATA);
else if (bInBuffC > bTARIFFS)
Result2(bUNI_BADDATA);
else if (bInBuffC+bInBuffD-1 > bTARIFFS)
Result2(bUNI_BADDATA);
else
{
InitPushUni();
LoadImpDay((bDAYS+ibHardDay-bInBuffB) % bDAYS);
uint wSize = 0;
uchar c;
for (c=bInBuff7; c<bInBuff7+bInBuff9; c++)
{
uchar i;
for (i=bInBuffC; i<bInBuffC+bInBuffD; i++)
{
if (fDouble)
{
PushDouble(GetCanImp2DoubleEng(mpimDayCan[ PrevSoftDay() ], c-1, 0x01 << (i-1)));
wSize += sizeof(double);
}
else
{
PushFloat(GetCanImp2FloatEng(mpimDayCan[ PrevSoftDay() ], c-1, 0x01 << (i-1)));
wSize += sizeof(float);
}
}
}
ulong dw = DateToDayIndex(*GetCurrTimeDate());
dw -= bInBuffB;
time ti = DayIndexToDate(dw);
Output2_Code(wSize, ((CheckDefCanDayUni() == 0) ? bUNI_OK : bUNI_DEFECT), ti);
}
}
void
prim_cos(PRIM_PROTOTYPE)
{
CHECKOP(1);
oper1 = POP();
if (oper1->type != PROG_FLOAT)
abort_interp("Non-float argument. (1)");
if (!no_good(oper1->data.fnumber)) {
fresult = cos(oper1->data.fnumber);
} else {
/* FIXME: This should be NaN. */
fresult = 0.0;
fr->error.error_flags.f_bounds = 1;
}
CLEAR(oper1);
PushFloat(fresult);
}
void
prim_strtof(PRIM_PROTOTYPE)
{
CHECKOP(1);
oper1 = POP();
if (oper1->type != PROG_STRING)
abort_interp("Non-string argument. (1)");
fresult = 0.0;
if (!oper1->data.string || !ifloat(oper1->data.string->data)) {
fresult = 0.0;
fr->error.error_flags.nan = 1;
} else {
sscanf(oper1->data.string->data, "%g", &fresult);
}
CLEAR(oper1);
PushFloat(fresult);
}
void
prim_log10(PRIM_PROTOTYPE)
{
CHECKOP(1);
oper1 = POP();
if (oper1->type != PROG_FLOAT)
abort_interp("Non-float argument. (1)");
if (!no_good(oper1->data.fnumber) && oper1->data.fnumber > 0.0) {
fresult = log10(oper1->data.fnumber);
} else if (oper1->data.fnumber > 0.0) {
fresult = INF;
fr->error.error_flags.f_bounds = 1;
} else {
fresult = 0.0;
fr->error.error_flags.imaginary = 1;
}
CLEAR(oper1);
PushFloat(fresult);
}
void prim_gaussian(PRIM_PROTOTYPE)
{
/* We use these two statics to prevent lost work. */
float srca=0.0, srcb=0.0;
float resulta;
float radius = 1.0;
static float resultb;
static char second_call = 0;
CHECKOP(2);
oper1 = POP(); /* Arg1 - mean */
oper2 = POP(); /* Arg2 - std dev. */
if (oper2->type != PROG_FLOAT)
abort_interp("Non-float argument. (1)");
if (oper1->type != PROG_FLOAT)
abort_interp("Non-float argument. (2)");
/* This is a Box-Muller polar conversion.
* Taken in part from code as demonstrated by Everett F. Carter, Jr.
* This code is not copyrighted. */
if( second_call ) {
/* We should have a correlated value to use from the
* previous call, still. */
resulta = resultb;
second_call = 0;
} else {
while( radius >= 1.0 ) {
srca = 2.0 * _int_f_rand() - 1.0;
srcb = 2.0 * _int_f_rand() - 1.0;
radius = srca * srca + srcb * srcb;
}
radius = sqrt( (-2.0 * log(radius) ) / radius );
resulta = srca * radius;
resultb = srcb * radius;
second_call = 1; /* Prime for next call in. */
}
fresult = oper1->data.fnumber + resulta * oper2->data.fnumber;
CLEAR(oper1);
CLEAR(oper2);
PushFloat( fresult );
}
void
prim_atan(PRIM_PROTOTYPE)
{
CHECKOP(1);
oper1 = POP();
if ( oper1->type == PROG_INTEGER )
{ oper1->type = PROG_FLOAT;
oper1->data.fnumber = oper1->data.number;
}
if (oper1->type != PROG_FLOAT)
abort_interp("Non-float argument. (1)");
if (!no_good(oper1->data.fnumber)) {
fresult = (float) atan((double) oper1->data.fnumber);
} else {
fresult = H_PI;
}
CLEAR(oper1);
PushFloat(fresult);
}
void
prim_acos(PRIM_PROTOTYPE)
{
CHECKOP(1);
oper1 = POP();
if ( oper1->type == PROG_INTEGER )
{ oper1->type = PROG_FLOAT;
oper1->data.fnumber = oper1->data.number;
}
if (oper1->type != PROG_FLOAT)
abort_interp("Non-float argument. (1)");
if (!((oper1->data.fnumber < -1.0) || (oper1->data.fnumber > 1.0))) {
fresult = (float) acos((double) oper1->data.fnumber);
} else {
fresult = 0.0;
fr->error.error_flags.nan = 1;
}
CLEAR(oper1);
PushFloat(fresult);
}
