TEST(math, __fpclassifyd) {
#if defined(__GLIBC__)
#define __fpclassifyd __fpclassify
#endif
ASSERT_EQ(FP_INFINITE, __fpclassifyd(HUGE_VAL));
ASSERT_EQ(FP_NAN, __fpclassifyd(nan("")));
ASSERT_EQ(FP_NORMAL, __fpclassifyd(1.0));
ASSERT_EQ(FP_SUBNORMAL, __fpclassifyd(double_subnormal()));
ASSERT_EQ(FP_ZERO, __fpclassifyd(0.0));
}
void nanPayloadsUnitTest() {
REQUIRE_START(testNanPayloads);
REQUIRE(nanPayloadf(nanf("0")) == 0);
REQUIRE(nanPayloadf(nanf("1954")) == 1954);
REQUIRE(nanPayloadf(nanf("0") + 99) == 0);
REQUIRE(nanPayloadf(nanf("1954")+ 99) == 1954);
REQUIRE(nanPayload (nan("0")) == 0);
REQUIRE(nanPayload (nan("1954")) == 1954);
REQUIRE(nanPayload (nan("0") + 99) == 0);
REQUIRE(nanPayload (nan("1954")+ 99) == 1954);
// something wrong with nanPayloadl() at the moment
//REQUIRE(nanPayloadl(nan("0")).low == 0);
//REQUIRE(nanPayloadl(nan("1954")).low == 1954);
//REQUIRE(nanPayloadl(nan("0") + 99).low == 0);
//REQUIRE(nanPayloadl(nan("1954")+ 99).low == 1954);
//int errs = REQUIRE_END(testnanPayloads);
}
float *parse_fields(char *line, int n)
{
float *field = calloc(n, sizeof(float));
char *c, *p, *end;
int count = 0;
int done = 0;
for(c = line, p = line; !done; ++c) {
done = (*c == '\0');
if(*c == ',' || done) {
*c = '\0';
field[count] = strtod(p, &end);
if(p == c) field[count] = nan("");
if(end != c && (end != c-1 || *end != '\r')) field[count] = nan(""); //DOS file formats!
p = c+1;
++count;
}
}
return field;
}
void ValuesTable::ResetValue(int i) {
ValueInfo& v = m_values.at(i);
m_values.at(i).state = ValueInfo::EMPTY;
if (m_stats.Start() <= i && i <= m_stats.End()) {
m_probes_count -= v.max_probes;
if (m_probes_count)
m_data_probes_ratio = double(m_data_probes_count) / m_probes_count;
else
m_data_probes_ratio = nan("");
}
}
double
VNUM(const char *p)
{
const char *t;
double r;
r = VNUMpfx(p, &t);
if (t != NULL)
r = nan("");
return (r);
}
double operator * (const Vector& l, const Vector& r)
{
if (l.size != r.size) return nan(0);
double res = 0;
for (size_t i = 0; i < l.size; i++)
{
res += l.values[i] * r.values[i];
}
return res;
}
TEST(math, __fpclassifyd) {
#if defined(__BIONIC__)
ASSERT_EQ(FP_INFINITE, __fpclassifyd(HUGE_VAL));
ASSERT_EQ(FP_NAN, __fpclassifyd(nan("")));
ASSERT_EQ(FP_NORMAL, __fpclassifyd(1.0));
ASSERT_EQ(FP_SUBNORMAL, __fpclassifyd(double_subnormal()));
ASSERT_EQ(FP_ZERO, __fpclassifyd(0.0));
#else // __BIONIC__
GTEST_LOG_(INFO) << "This test does nothing.\n";
#endif // __BIONIC__
}
double VisualNavbar::addressToLocalX(RVA address)
{
for (auto x2a : xToAddress) {
if ((x2a.address_from <= address) && (address < x2a.address_to)) {
double offset = (double)(address - x2a.address_from) / (double)(x2a.address_to - x2a.address_from);
double size = x2a.x_end - x2a.x_start;
return x2a.x_start + (offset * size);
}
}
return nan("");
}
double MatCTECat( EXPR *name, EXPR *nothing )
{
char *string ;
string = ExprValueString( name ) ;
if( !string )
{
IOerror( MatBomb, "MatCTECat", "cannot evaluate name" ) ;
return nan("") ;
}
return ExprValue( DbaseGetExpr( string, "CTE" ) ) ;
}
TEST(math, round) {
auto guard = make_scope_guard([]() {
fesetenv(FE_DFL_ENV);
});
fesetround(FE_TOWARDZERO); // round ignores the rounding mode and always rounds away from zero.
ASSERT_DOUBLE_EQ(1.0, round(0.5));
ASSERT_DOUBLE_EQ(-1.0, round(-0.5));
ASSERT_DOUBLE_EQ(0.0, round(0.0));
ASSERT_DOUBLE_EQ(-0.0, round(-0.0));
ASSERT_TRUE(isnan(round(nan(""))));
ASSERT_DOUBLE_EQ(HUGE_VAL, round(HUGE_VAL));
}
static void
irt_rpf_mdim_drm_paramInfo(const double *spec, const int param,
const char **type, double *upper, double *lower)
{
int numDims = spec[RPF_ISpecDims];
*upper = nan("unset");
*lower = nan("unset");
if (numDims == 0) {
*type = "intercept";
return;
}
*type = NULL;
if (param >= 0 && param < numDims) {
*type = "slope";
*lower = 1e-6;
} else if (param == numDims) {
*type = "intercept";
} else if (param == numDims+1 || param == numDims+2) {
*type = "bound";
}
}
double calcCombinations(int n, int k){
if(n == k)
return (double)nan("");
else if(n < k)
return (double)INFINITY;
else{
double result;
result = sequentialMultiply(k+1, n);
result /= sequentialMultiply(1,n-k);
return result;
}
}
TEST(math, trunc) {
auto guard = make_scope_guard([]() {
fesetenv(FE_DFL_ENV);
});
fesetround(FE_UPWARD); // trunc ignores the rounding mode and always rounds toward zero.
ASSERT_DOUBLE_EQ(1.0, trunc(1.5));
ASSERT_DOUBLE_EQ(-1.0, trunc(-1.5));
ASSERT_DOUBLE_EQ(0.0, trunc(0.0));
ASSERT_DOUBLE_EQ(-0.0, trunc(-0.0));
ASSERT_TRUE(isnan(trunc(nan(""))));
ASSERT_DOUBLE_EQ(HUGE_VAL, trunc(HUGE_VAL));
}
double solution::euclideanDistance(solution &s2) {
double sum = 0;
if(getNumObjectives() != s2.getNumObjectives())
return nan("");
int i;
for(i=0;i<getNumObjectives();i++)
sum += (getObjective(i) - s2.getObjective(i)) * (getObjective(i) - s2.getObjective(i));
return sqrt(sum);
}
bool bunny_configuration_get_double(const t_bunny_configuration *config,
double *val)
{
SmallConf *conf = (SmallConf*)config;
bool ret;
ret = conf->GetDouble(val);
scream_log_if
("%p conf, %p target -> %s (%f)", "configuration",
config, val, ret ? "true" : "false", ret ? *val : nan(""));
return (ret);
}
static void
irt_rpf_nominal_paramInfo(const double *spec, const int param,
const char **type, double *upper, double *lower)
{
int numDims = spec[RPF_ISpecDims];
const int numOutcomes = spec[RPF_ISpecOutcomes];
*upper = nan("unset");
*lower = nan("unset");
if (numDims == 0) {
*type = "intercept";
return;
}
*type = NULL;
if (param >= 0 && param < numDims) {
*type = "slope";
*lower = 1e-6;
} else if (param < numDims + numOutcomes - 1) {
*type = "slope";
} else {
*type = "intercept";
}
}
double sequentialMultiply(int start, int end) {
double result;
if(start == end)
return (double)start;
if(start > end)
return (double)nan("");
result = (double)start++;
while(start <= end){
result *= start;
start++;
}
return result;
}
void ValuesTable::ClearStats() {
m_count = 0;
m_probes_count = 0;
m_data_probes_count = 0;
m_sum =
m_sum2 =
m_sdev =
m_max =
m_min =
m_hsum =
m_data_probes_ratio =
nan("");
}
double readBranchLength(std::istream &iss)
{
bool foundNext = false;
while(not foundNext)
{
int ch = iss.get();
foundNext = ( ch == ')'
|| ch == ';'
|| ch == ',' ) ;
}
iss.unget();
return nan("");
}
// the callback function for the timer event
void SumAndAverageNode::timerCallback(ros::TimerEvent const& event)
{
// create the message containing the moving average
std_msgs::Float32 moving_average_msg;
if (moving_average_count_ > 0)
moving_average_msg.data = moving_average_sum_ / moving_average_count_;
else
moving_average_msg.data = nan("");
// publish the moving average
moving_average_pub_.publish(moving_average_msg);
// reset the moving average
moving_average_sum_ = 0;
moving_average_count_ = 0;
}
static void update_control(uint32_t comm_period, float dt)
{
/*
* Start/stop management
*/
const enum motor_rtctl_state new_rtctl_state = motor_rtctl_get_state();
const bool just_stopped =
new_rtctl_state == MOTOR_RTCTL_STATE_IDLE &&
_state.rtctl_state != MOTOR_RTCTL_STATE_IDLE;
if (just_stopped) {
handle_unexpected_stop();
}
_state.rtctl_state = new_rtctl_state;
if (comm_period == 0 || _state.rtctl_state != MOTOR_RTCTL_STATE_RUNNING) {
update_control_non_running();
return;
}
/*
* Primary control logic; can return NAN to stop the motor
*/
float new_duty_cycle = nan("");
if (_state.mode == MOTOR_CONTROL_MODE_OPENLOOP) {
new_duty_cycle = update_control_open_loop(comm_period);
}
else if (_state.mode == MOTOR_CONTROL_MODE_RPM) {
new_duty_cycle = update_control_rpm(comm_period, dt);
}
else { assert(0); }
if (!isfinite(new_duty_cycle)) {
stop(true);
return;
}
/*
* Limiters
*/
new_duty_cycle = update_control_current_limit(new_duty_cycle);
new_duty_cycle = update_control_dc_slope(new_duty_cycle, dt);
/*
* Update
*/
_state.dc_actual = new_duty_cycle;
motor_rtctl_set_duty_cycle(_state.dc_actual);
}
void CheckInfNan(int snprintf_fn(T*, size_t, const T*, ...),
const T* fmt, const T* fmt_plus,
const T* minus_inf, const T* inf_, const T* plus_inf,
const T* minus_nan, const T* nan_, const T* plus_nan) {
T buf[BUFSIZ];
snprintf_fn(buf, sizeof(buf), fmt, nan(""));
EXPECT_STREQ(nan_, buf) << fmt;
snprintf_fn(buf, sizeof(buf), fmt, -nan(""));
EXPECT_STREQ(minus_nan, buf) << fmt;
snprintf_fn(buf, sizeof(buf), fmt_plus, nan(""));
EXPECT_STREQ(plus_nan, buf) << fmt_plus;
snprintf_fn(buf, sizeof(buf), fmt_plus, -nan(""));
EXPECT_STREQ(minus_nan, buf) << fmt_plus;
snprintf_fn(buf, sizeof(buf), fmt, HUGE_VAL);
EXPECT_STREQ(inf_, buf) << fmt;
snprintf_fn(buf, sizeof(buf), fmt, -HUGE_VAL);
EXPECT_STREQ(minus_inf, buf) << fmt;
snprintf_fn(buf, sizeof(buf), fmt_plus, HUGE_VAL);
EXPECT_STREQ(plus_inf, buf) << fmt_plus;
snprintf_fn(buf, sizeof(buf), fmt_plus, -HUGE_VAL);
EXPECT_STREQ(minus_inf, buf) << fmt_plus;
}
void Read_Parameter(int i_iArg_Count,const char * i_lpszArg_Values[], const char * i_lpszOption_Name, const double &i_dDefault_Decay, PARAMETER_SET & o_cParameter)
{
double dNan = nan("");
char lpszOption_String[64];
char lpszType[32];
o_cParameter.dRef25 = xParse_Command_Line_Dbl(i_iArg_Count,i_lpszArg_Values,i_lpszOption_Name,dNan);
sprintf(lpszOption_String,"%s-decay",i_lpszOption_Name);
o_cParameter.dDecay = xParse_Command_Line_Dbl(i_iArg_Count,i_lpszArg_Values,lpszOption_String,i_dDefault_Decay);
sprintf(lpszOption_String,"%s-law",i_lpszOption_Name);
xParse_Command_Line_String(i_iArg_Count,i_lpszArg_Values,lpszOption_String,lpszType,sizeof(lpszType),NULL);
o_cParameter.Set_Type(lpszType);
sprintf(lpszOption_String,"%s-extreme",i_lpszOption_Name);
o_cParameter.dRef_Extreme = xParse_Command_Line_Dbl(i_iArg_Count,i_lpszArg_Values,lpszOption_String,0.0);
}
TEST(math, fpclassify) {
ASSERT_EQ(FP_INFINITE, fpclassify(INFINITY));
ASSERT_EQ(FP_INFINITE, fpclassify(HUGE_VALF));
ASSERT_EQ(FP_INFINITE, fpclassify(HUGE_VAL));
ASSERT_EQ(FP_NAN, fpclassify(nanf("")));
ASSERT_EQ(FP_NAN, fpclassify(nan("")));
ASSERT_EQ(FP_NORMAL, fpclassify(1.0f));
ASSERT_EQ(FP_NORMAL, fpclassify(1.0));
ASSERT_EQ(FP_SUBNORMAL, fpclassify(float_subnormal()));
ASSERT_EQ(FP_SUBNORMAL, fpclassify(double_subnormal()));
ASSERT_EQ(FP_ZERO, fpclassify(0.0f));
ASSERT_EQ(FP_ZERO, fpclassify(0.0));
}
double RPNParser::evaluate(double x)
{
size_t last_match_start = 0;
size_t last_match_end = 0;
while(last_match_end != std::string::npos)
{
last_match_end = m_expression.find(' ', last_match_start);
std::string token = m_expression.substr(last_match_start, last_match_end - last_match_start);
last_match_start = last_match_end + 1;
// Evaluate it
if( ! handle_token(token, x))
{
return nan("");
}
}
return m_stack.top();
}
static float update_control_rpm(uint32_t comm_period, float dt)
{
if (_state.rpm_setpoint <= 0) {
return nan("");
}
if (_state.rpm_setpoint < _params.rpm_min) {
_state.rpm_setpoint = _params.rpm_min;
}
const struct rpmctl_input input = {
_state.limit_mask,
dt,
(float)comm_period_to_rpm(comm_period),
_state.rpm_setpoint
};
return rpmctl_update(&input);
}
TEST(ExpressionAlgoIsSubsetOf, Compare_NaN) {
ParsedMatchExpression nan("{x: NaN}");
ParsedMatchExpression lt("{x: {$lt: 5}}");
ParsedMatchExpression lte("{x: {$lte: 5}}");
ParsedMatchExpression gte("{x: {$gte: 5}}");
ParsedMatchExpression gt("{x: {$gt: 5}}");
ASSERT_TRUE(expression::isSubsetOf(nan.get(), nan.get()));
ASSERT_FALSE(expression::isSubsetOf(nan.get(), lt.get()));
ASSERT_FALSE(expression::isSubsetOf(lt.get(), nan.get()));
ASSERT_FALSE(expression::isSubsetOf(nan.get(), lte.get()));
ASSERT_FALSE(expression::isSubsetOf(lte.get(), nan.get()));
ASSERT_FALSE(expression::isSubsetOf(nan.get(), gte.get()));
ASSERT_FALSE(expression::isSubsetOf(gte.get(), nan.get()));
ASSERT_FALSE(expression::isSubsetOf(nan.get(), gt.get()));
ASSERT_FALSE(expression::isSubsetOf(gt.get(), nan.get()));
}
static double nloptObjectiveFunction(unsigned n, const double *x, double *grad, void *f_data)
{
GradientOptimizerContext *goc = (GradientOptimizerContext *) f_data;
nlopt_opt opt = (nlopt_opt) goc->extraData;
FitContext *fc = goc->fc;
assert(n == fc->numParam);
int mode = 0;
double fit = goc->solFun((double*) x, &mode);
if (grad) {
fc->iterations += 1;
if (goc->maxMajorIterations != -1 && fc->iterations >= goc->maxMajorIterations) {
nlopt_force_stop(opt);
}
}
if (grad && goc->verbose >= 2) {
mxLog("major iteration fit=%.12f", fit);
}
if (mode == -1) {
if (!goc->feasible) {
nlopt_force_stop(opt);
}
return nan("infeasible");
}
if (!grad) return fit;
Eigen::Map< Eigen::VectorXd > Epoint((double*) x, n);
Eigen::Map< Eigen::VectorXd > Egrad(grad, n);
if (fc->wanted & FF_COMPUTE_GRADIENT) {
Egrad = fc->grad;
} else if (fc->CI && fc->CI->varIndex >= 0) {
Egrad.setZero();
Egrad[fc->CI->varIndex] = fc->lowerBound? 1 : -1;
fc->grad = Egrad;
} else {
if (goc->verbose >= 3) mxLog("fd_gradient start");
fit_functional ff(*goc);
gradient_with_ref(goc->gradientAlgo, goc->gradientIterations, goc->gradientStepSize,
ff, fit, Epoint, Egrad);
fc->grad = Egrad;
}
if (goc->verbose >= 3) {
mxPrintMat("gradient", Egrad);
}
return fit;
}
static DecimalFormatSymbols* makeDecimalFormatSymbols(JNIEnv* env,
jstring currencySymbol0, jchar decimalSeparator, jchar digit,
jstring exponentSeparator0, jchar groupingSeparator0,
jstring infinity0, jstring internationalCurrencySymbol0,
jchar minusSign, jchar monetaryDecimalSeparator, jstring nan0,
jchar patternSeparator, jchar percent, jchar perMill, jchar zeroDigit) {
ScopedJavaUnicodeString currencySymbol(env, currencySymbol0);
ScopedJavaUnicodeString exponentSeparator(env, exponentSeparator0);
ScopedJavaUnicodeString infinity(env, infinity0);
ScopedJavaUnicodeString internationalCurrencySymbol(env,
internationalCurrencySymbol0);
ScopedJavaUnicodeString nan(env, nan0);
UnicodeString groupingSeparator(groupingSeparator0);
DecimalFormatSymbols* result = new DecimalFormatSymbols;
result->setSymbol(DecimalFormatSymbols::kCurrencySymbol,
currencySymbol.unicodeString());
result->setSymbol(DecimalFormatSymbols::kDecimalSeparatorSymbol,
UnicodeString(decimalSeparator));
result->setSymbol(DecimalFormatSymbols::kDigitSymbol, UnicodeString(digit));
result->setSymbol(DecimalFormatSymbols::kExponentialSymbol,
exponentSeparator.unicodeString());
result->setSymbol(DecimalFormatSymbols::kGroupingSeparatorSymbol,
groupingSeparator);
result->setSymbol(DecimalFormatSymbols::kMonetaryGroupingSeparatorSymbol,
groupingSeparator);
result->setSymbol(DecimalFormatSymbols::kInfinitySymbol,
infinity.unicodeString());
result->setSymbol(DecimalFormatSymbols::kIntlCurrencySymbol,
internationalCurrencySymbol.unicodeString());
result->setSymbol(DecimalFormatSymbols::kMinusSignSymbol,
UnicodeString(minusSign));
result->setSymbol(DecimalFormatSymbols::kMonetarySeparatorSymbol,
UnicodeString(monetaryDecimalSeparator));
result->setSymbol(DecimalFormatSymbols::kNaNSymbol, nan.unicodeString());
result->setSymbol(DecimalFormatSymbols::kPatternSeparatorSymbol,
UnicodeString(patternSeparator));
result->setSymbol(DecimalFormatSymbols::kPercentSymbol,
UnicodeString(percent));
result->setSymbol(DecimalFormatSymbols::kPerMillSymbol,
UnicodeString(perMill));
result->setSymbol(DecimalFormatSymbols::kZeroDigitSymbol,
UnicodeString(zeroDigit));
return result;
}
_WMRTLINK double log1p(double x)
{
double array[] = {ALNRCS1, ALNRCS2, ALNRCS3, ALNRCS4, ALNRCS5,
ALNRCS6, ALNRCS7, ALNRCS8, ALNRCS9, ALNRCS10,
ALNRCS11, ALNRCS12, ALNRCS13, ALNRCS14, ALNRCS15,
ALNRCS16, ALNRCS17, ALNRCS18, ALNRCS19, ALNRCS20,
ALNRCS21, ALNRCS22, ALNRCS23};
if(x == -1.0)
return XINF;
else if(x < -1.0)
return nan("ignore");
if(fabs(x) <= 0.375)
return x * (1.0 - x*_Chebyshev_Evaluate(x/0.375, array, 23));
else
return log(1.0 + x);
}
