inline bool CheckVec3Nan(eiVector &val) { if (!_finite(val.x))return true; if (!_finite(val.y))return true; if (!_finite(val.z))return true; return false; }

double CTranosemaEquations::GetSurvivalRate(size_t s, double T) { static const double P[NB_STAGES][2] = { // x s { 7.0251, -0.1735 }, //Egg { 9.6200, -0.2389 }, //Pupa { 1.000, 0.0000 } //Adult }; double r = 0; switch (s) { case EGG: case PUPA: r = 1 / (1 + exp(-(P[s][0] + P[s][1] * T))); break; case ADULT: r = 1; break; default: _ASSERTE(false); } _ASSERTE(!_isnan(r) && _finite(r)); if (_isnan(r) || !_finite(r))//just in case r = 1; return r; }

//============================================================================== void interval_orientation3d(const double* x0, const double* x1, const double* x2, const double* x3, double* lower, double* upper) { fesetround(FE_DOWNWARD); *lower=simple_orientation3d(x0, x1, x2, x3); fesetround(FE_UPWARD); *upper=simple_orientation3d(x0, x1, x2, x3); #ifdef _MSC_VER assert( !_isnan(*lower) ); assert( !_isnan(*upper) ); assert( _finite(*lower) ); assert( _finite(*upper) ); #else assert( !std::isnan(*lower) ); assert( !std::isnan(*upper) ); assert( !std::isinf(*lower) ); assert( !std::isinf(*upper) ); #endif assert(*lower<=*upper); }

//////////////////////////////////////////////////////////////////////////////////////// // Make Sure Entire Vector Has Valid Numbers //////////////////////////////////////////////////////////////////////////////////////// bool CVec3::IsFinite() { #if defined(_MSC_VER) return (_finite(v[0]) && _finite(v[1]) && _finite(v[2])); #else return isfinite(v[0]) && isfinite(v[1]) && isfinite(v[2]); #endif }

static inline void b3SolveContact(b3ContactConstraint4& cs, const b3Vector3& posA, b3Vector3& linVelA, b3Vector3& angVelA, float invMassA, const b3Matrix3x3& invInertiaA, const b3Vector3& posB, b3Vector3& linVelB, b3Vector3& angVelB, float invMassB, const b3Matrix3x3& invInertiaB, float maxRambdaDt[4], float minRambdaDt[4]) { b3Vector3 dLinVelA; dLinVelA.setZero(); b3Vector3 dAngVelA; dAngVelA.setZero(); b3Vector3 dLinVelB; dLinVelB.setZero(); b3Vector3 dAngVelB; dAngVelB.setZero(); for(int ic=0; ic<4; ic++) { // dont necessary because this makes change to 0 if( cs.m_jacCoeffInv[ic] == 0.f ) continue; { b3Vector3 angular0, angular1, linear; b3Vector3 r0 = cs.m_worldPos[ic] - (b3Vector3&)posA; b3Vector3 r1 = cs.m_worldPos[ic] - (b3Vector3&)posB; b3SetLinearAndAngular( (const b3Vector3 &)-cs.m_linear, (const b3Vector3 &)r0, (const b3Vector3 &)r1, linear, angular0, angular1 ); float rambdaDt = b3CalcRelVel((const b3Vector3 &)cs.m_linear,(const b3Vector3 &) -cs.m_linear, angular0, angular1, linVelA, angVelA, linVelB, angVelB ) + cs.m_b[ic]; rambdaDt *= cs.m_jacCoeffInv[ic]; { float prevSum = cs.m_appliedRambdaDt[ic]; float updated = prevSum; updated += rambdaDt; updated = b3Max( updated, minRambdaDt[ic] ); updated = b3Min( updated, maxRambdaDt[ic] ); rambdaDt = updated - prevSum; cs.m_appliedRambdaDt[ic] = updated; } b3Vector3 linImp0 = invMassA*linear*rambdaDt; b3Vector3 linImp1 = invMassB*(-linear)*rambdaDt; b3Vector3 angImp0 = (invInertiaA* angular0)*rambdaDt; b3Vector3 angImp1 = (invInertiaB* angular1)*rambdaDt; #ifdef _WIN32 b3Assert(_finite(linImp0.getX())); b3Assert(_finite(linImp1.getX())); #endif { linVelA += linImp0; angVelA += angImp0; linVelB += linImp1; angVelB += angImp1; } } } }

bool ExtentRect::isCorrupt() { bool retval = false; if (!(_finite(left) && _finite(right) && _finite(bottom) && _finite(top))) { retval = true; } return retval; }

bool IsValidVelocityVector(const Vector3df &pos) { // This is a heuristic check to guard against the OpenSim server sending us stupid velocity vectors. if (fabs(pos.x) > 1e3f || fabs(pos.y) > 1e3f || fabs(pos.z) > 1e3f) return false; if (_isnan(pos.x) || _isnan(pos.y) || _isnan(pos.z)) return false; if (!_finite(pos.x) || !_finite(pos.y) || !_finite(pos.z)) return false; return true; }

//--------------------------------------------------------------------------- void TPolFuncFrame::Eval(const TGraphElem *Elem) { if(const TPolFunc *Func = dynamic_cast<const TPolFunc*>(Elem)) { Clear(); ErrorPrefix = "t: "; long double t = Form1->Data.Calc(ToWString(Edit1->Text)); ErrorPrefix = "r(t): "; long double r = Func->GetFunc().CalcR(t); ErrorPrefix = "x(t): "; long double x = Func->GetFunc().CalcX(t); ErrorPrefix = "y(t): "; long double y = Func->GetFunc().CalcY(t); Edit2->Text = RoundToStr(r); Edit3->Text = RoundToStr(x); Edit4->Text = RoundToStr(y); Form1->SetCrossPos(x, y); ErrorPrefix = "dr/dt: "; Edit5->Text = RoundToStr(Func->GetFunc().MakeDif().CalcR(t)); ErrorPrefix = "dy/dx: "; long double dydx = Func->GetFunc().CalcSlope(t); if(_finite(dydx)) Edit6->Text = RoundToStr(dydx); } }

inline float rmsToDb(float rms) { float db = 20.0f * log10(rms); if(!_finite(db)) return VOL_MIN; return db; }

inline float toDB(float RMS) { float db = 20.0f * log10(RMS); if(!_finite(db)) return VOL_MIN; return db; }

void Cylinder::SetRadius( double top_radius, double bottom_radius ) { if ( !_finite( bottom_radius ) ) bottom_radius = top_radius; this->top_radius = top_radius; this->bottom_radius = bottom_radius; }

/** * Print numer/denum ratio in dB */ static TCHAR * sprint_db_width(double numer, double denum, int width) { static TCHAR buf[FIELDW]; if (numer == 0) { _sntprintf(buf, FIELDW, _T("%-*s"), width, _T("MATCH")); } else if (denum == 0) { _sntprintf(buf, FIELDW, _T("%-*s"), width, _T("INF ")); } else { double db = -10 * log10(numer / denum); if (_isnan(db) || !_finite(db)) { _sntprintf(buf, FIELDW, _T("%-*s"), width, _T("overflow")); } else { _sntprintf(buf, FIELDW, _T("%-*.2f"), width, db); } } buf[width] = 0; return buf; }

/** * Print numer/denum ratio as a bits count for equivalent * uniform quantizer */ static TCHAR * SPrintBips (double numer, double denum, int width) { static TCHAR buf[FIELDW]; if (numer == 0) { _sntprintf(buf, FIELDW, _T("%-*s"), width, _T("MATCH ")); } else if (denum == 0) { _sntprintf(buf, FIELDW, _T("%-*s"), width, _T("INFINITY")); } else { double bips = 1. / sqrt(12 * numer / denum); bips = 1 + log(bips) / log(2); if (_isnan(bips) || !_finite(bips)) { _sntprintf(buf, FIELDW, _T("%-*s"), width, _T("overflow")); } else { _sntprintf(buf, FIELDW, _T("%-*.3f"), width, bips); } } return buf; }

void nan_tmp(FILE * fp) { long count = 0; #ifdef DOUBLE double x; #else float x; #endif /* DOUBLE */ while (freadx(&x, sizeof(x), 1, fp)) { #ifdef WIN32 if (!_finite(x)) fprintf(stdout, "[No. %ld] is Infinity\n", count); if (_isnan(x)) fprintf(stdout, "[No. %ld] is NaN\n", count); #else if (isinf(x)) fprintf(stdout, "[No. %ld] is Infinity\n", count); if (isnan(x)) fprintf(stdout, "[No. %ld] is NaN\n", count); #endif ++count; } return; }

bool is_nan(float64 x) { #ifdef WIN32 return (_isnan(x) != 0) || (_finite(x) == 0) ; #else return isnan(x) || !finite(x); #endif }

double Curve::GetSample(double value) { if (this->identity) { if (_finite(value)) { return clamp(value, 0.0, 1.0); } return 0.0; } if (value > 0.0 && value < 1.0) { value = value * (sampleCount - 1); int index = (int)value; double f = value - index; return (1.0 - f) * samples[index] + f * samples[index + 1]; } else if (value >= 1.0) { return samples[sampleCount - 1]; } else { return samples[0]; } }

GoalStateOfHealth::~GoalStateOfHealth() { if( _player->isOverActivity() ) { Virtues* virtues = getScene()->getCareer()->getVirtues(); assert( _finite( getGoalScore() ) ); virtues->evolution.score += getGoalScore(); if( virtues->evolution.score < 0 ) { virtues->evolution.score = 0; } if( virtues->evolution.health == 0 ) { bool creditsIsAffected = true; // credits is not affected for licensed character creditsIsAffected = !_scene->getCareer()->getLicensedFlag(); // credits is not affected in developer edition if ( Gameplay::iGameplay->_cheatsEnabled ) { creditsIsAffected = false; } #ifdef GAMEPLAY_DEVELOPER_EDITION creditsIsAffected = false; #endif getCore()->logMessage( "creditsIsAffected=%d", creditsIsAffected ); if( creditsIsAffected ) virtues->evolution.credits--; if( virtues->evolution.credits > 0 ) { virtues->evolution.health = 0.125f; } } } }

inline bool isfinite(T arg) { #ifndef _MSC_VER return (std::isfinite)(arg); #else return _finite(arg) != 0; #endif }

inline bool sc_isfinite( T x ) { #if defined ( SC_VS ) && SC_VS < 12 // std::isfinite was added in vs2013 return _finite( x ) != 0; #else return std::isfinite( x ); #endif }

int my_finite(double x) { #ifdef _MSC_VER return _finite(x); #else return finite(x); #endif }

bool IsValid(float val) { #ifdef _MSC_VER return _finite(val) != 0; #else return val == val; #endif }

GoalSmokeball::~GoalSmokeball() { if( _player->isOverActivity() ) { Virtues* virtues = getScene()->getCareer()->getVirtues(); assert( _finite( getGoalScore() ) ); virtues->evolution.score += getGoalScore(); } }

void rpn_exp2(calc_number_t *c) { if (calc.base == IDC_RADIO_DEC) { c->f *= c->f; if (_finite(c->f) == 0) calc.is_nan = TRUE; } else c->i *= c->i; }

/** * \return true if v is Inf. */ bool RMath::isInf(double v) { #ifdef Q_OS_MAC return std::fpclassify(v)==FP_INFINITE; #elif defined Q_OS_WIN32 return !_finite(v); #else return std::fpclassify(v)==FP_INFINITE; #endif }

bool Math::is_inf(double p_val) { #ifdef _MSC_VER return !_finite(p_val); #else return isinf(p_val); #endif }

/* {{{ php_math_is_finite */ static inline int php_math_is_finite(double value) { #if defined(PHP_WIN32) return _finite(value); #elif defined(isfinite) return isfinite(value); #else return value == value && (value == 0. || value * 2. != value); #endif }

double doubleRem(double dividend, double divisor) { double res; if (!_finite(divisor)) { if (_isnan(divisor)) return divisor; if (_finite(dividend)) return dividend; } res = fmod(dividend, divisor); /* With MSVC, "res == 0" succeeds when res is NaN. */ if (!_isnan(res) && res == 0) { /*MSFT fmod doesn't do -0.0 right*/ return _copysign(0.0,dividend); } else { return res; } }

GoalTrackingPerformance::~GoalTrackingPerformance() { if( _player->isOverActivity() ) { Virtues* virtues = getScene()->getCareer()->getVirtues(); assert( _finite( getGoalScore() ) ); virtues->evolution.score += getGoalScore(); } }

Quaternion UnpackQuaternionFromFloat3(float x, float y, float z) { if (_isnan(x) || _isnan(y) || _isnan(z) || !_finite(x) || !_finite(y) || !_finite(z)) return Quaternion(0, 0, 0, 1.f); float sq = x*x+y*y+z*z; // If the inputted coordinates are already too large in magnitude, renormalize the inputs and just set w = 0. // It can happen in two cases: Either float imprecision gave us a bit too high values, so setting w=0 is the proper action, // or then server sent us values that are bad to begin with. Anything is incorrect in this case, but to preserve at least // some sensibility in computations, renormalize the components and set w=0. if (sq >= 1.f) { float invNorm = 1.f / sqrt(sq); return Quaternion(x * invNorm, y * invNorm, z * invNorm, 0.f); } float w = sqrt(1.f - sq); return Quaternion(x, y, z, w); }

void rpn_exp3(calc_number_t *c) { if (calc.base == IDC_RADIO_DEC) { c->f = pow(c->f, 3.); if (_finite(c->f) == 0) calc.is_nan = TRUE; } else c->i *= (c->i*c->i); }