int main ()
{
printf ("rounding using ");
switch (fegetround())
{
case FE_DOWNWARD:
printf ("downward");
break;
case FE_TONEAREST:
printf ("to-nearest");
break;
case FE_TOWARDZERO:
printf ("toward-zero");
break;
case FE_UPWARD:
printf ("upward");
break;
default:
printf ("unknown");
}
printf (" rounding:\n");
printf ( "nearbyint (2.3) = %.1f\n", nearbyint(2.3) );
printf ( "nearbyint (3.8) = %.1f\n", nearbyint(3.8) );
printf ( "nearbyint (-2.3) = %.1f\n", nearbyint(-2.3) );
printf ( "nearbyint (-3.8) = %.1f\n", nearbyint(-3.8) );
return 0;
}
TEST(math, nearbyint) {
auto guard = make_scope_guard([]() {
fesetenv(FE_DFL_ENV);
});
fesetround(FE_UPWARD); // nearbyint/nearbyintf/nearbyintl obey the rounding mode.
feclearexcept(FE_ALL_EXCEPT); // nearbyint/nearbyintf/nearbyintl don't set the FE_INEXACT flag.
ASSERT_EQ(1234.0, nearbyint(1234.0));
ASSERT_TRUE((fetestexcept(FE_ALL_EXCEPT) & FE_INEXACT) == 0);
ASSERT_EQ(1235.0, nearbyint(1234.01));
ASSERT_TRUE((fetestexcept(FE_ALL_EXCEPT) & FE_INEXACT) == 0);
feclearexcept(FE_ALL_EXCEPT);
ASSERT_EQ(1234.0f, nearbyintf(1234.0f));
ASSERT_TRUE((fetestexcept(FE_ALL_EXCEPT) & FE_INEXACT) == 0);
ASSERT_EQ(1235.0f, nearbyintf(1234.01f));
ASSERT_TRUE((fetestexcept(FE_ALL_EXCEPT) & FE_INEXACT) == 0);
feclearexcept(FE_ALL_EXCEPT); // nearbyint/nearbyintf/nearbyintl don't set the FE_INEXACT flag.
ASSERT_EQ(1234.0, nearbyintl(1234.0L));
ASSERT_TRUE((fetestexcept(FE_ALL_EXCEPT) & FE_INEXACT) == 0);
ASSERT_EQ(1235.0, nearbyintl(1234.01L));
ASSERT_TRUE((fetestexcept(FE_ALL_EXCEPT) & FE_INEXACT) == 0);
fesetround(FE_TOWARDZERO); // nearbyint/nearbyintf/nearbyintl obey the rounding mode.
ASSERT_EQ(1234.0, nearbyint(1234.01));
ASSERT_EQ(1234.0f, nearbyintf(1234.01f));
ASSERT_EQ(1234.0, nearbyintl(1234.01L));
}
void test_nearbyint()
{
static_assert((std::is_same<decltype(nearbyint((double)0)), double>::value), "");
static_assert((std::is_same<decltype(nearbyintf(0)), float>::value), "");
static_assert((std::is_same<decltype(nearbyintl(0)), long double>::value), "");
assert(nearbyint(1) == 1);
}
bool Net::timop(tick_t base, tick_t timo) {
// Even though uniform_int_distribution takes an int, it is unsigned
tick_t rtimo = timo
+ dssim->rand_int(0, (int)nearbyint(0.3*timo))
- (int)nearbyint(0.15*timo);
if(rtimo <= 1) rtimo = timo;
return now() >= (base + rtimo);
}
void _sir_init (double *x, const double *p, double t,
const int *stateindex, const int *parindex, const int *covindex,
const double *covars) {
double m;
m = POPSIZE/(S0+I0+R0);
SUSC = nearbyint(m*S0);
INFD = nearbyint(m*I0);
RCVD = nearbyint(m*R0);
CASE = 0;
W = 0;
}
int CompareDoubles2 (double A, double B)
{
if ((nearbyint(A*1000000.0)-nearbyint(B*1000000.0))>0.0) {
return 1;
}else if ((nearbyint(A*1000000.0)-nearbyint(B*1000000.0))==0.0){
return 0;
}else{
return -1;
}
}
void GrowAxis::format_text( char *text, char *fmt, double value)
{
if ( strcmp( fmt, "%1t") == 0) {
// Hours, minutes and seconds, value in seconds
int val = (int) nearbyint(value);
int hours = val / 3600;
int minutes = (val - hours * 3600) / 60;
int seconds = (val - hours * 3600 - minutes * 60);
sprintf( text, "%d:%02d:%02d", hours, minutes, seconds);
}
else if ( strcmp( fmt, "%2t") == 0) {
// Hours and minutes, value in seconds
int val = (int) nearbyint(value);
int hours = val / 3600;
int minutes = (val - hours * 3600) / 60;
sprintf( text, "%d:%02d", hours, minutes);
}
else if ( strcmp( fmt, "%3t") == 0) {
// Days, hours and minues, value in seconds
int val = (int) nearbyint(value);
int days = val / (24 * 3600);
int hours = (val - days * 24 * 3600) / 3600;
int minutes = (val - days * 24 * 3600 - hours * 3600) / 60;
sprintf( text, "%d %02d:%02d", days, hours, minutes);
}
else if ( strcmp( fmt, "%10t") == 0) {
// Date
char timstr[40];
pwr_tTime t;
t.tv_sec = (int) nearbyint(value);
t.tv_nsec = 0;
time_AtoAscii( &t, time_eFormat_NumDateAndTime, timstr, sizeof(timstr));
timstr[19] = 0;
strcpy( text, timstr);
}
else if ( strcmp( fmt, "%11t") == 0) {
// Date, no seconds
char timstr[40];
pwr_tTime t;
t.tv_sec = (int) nearbyint(value);
t.tv_nsec = 0;
time_AtoAscii( &t, time_eFormat_NumDateAndTime, timstr, sizeof(timstr));
timstr[16] = 0;
strcpy( text, timstr);
}
else {
if ( fabs(value) < FLT_EPSILON)
value = 0;
sprintf( text, fmt, value);
}
}
std::string DEGU_CORNER::getValue(SpMObject mobile, Datapool& datapool) {
if(checked) {
checked = true;
valid = true;
//First check zones
std::vector< QSharedPointer<world::ZoneH> > &zones = datapool.sceneModel->ZonesH;
if (zones.empty())
valid = false;
else {
int num = 0;
std::vector< QSharedPointer<world::ZoneH> >::iterator zone_it, zone_end = zones.end();
for(zone_it = zones.begin(); zone_it != zone_end; zone_it++ ) {
if(values.count((*zone_it)->name.toStdString()) == 1) {
num++;
DEGU_CORNER::zones[(*zone_it)->name.toStdString()] = (*zone_it);
}
}
if(num != values.size() - 1)
valid = false;
}
}
SpReliabilitySingleModelInterface m = mobile->getSubModel("BaseModel");
if(m.isNull())
return "NONE";
if(valid) {
double dist, X, Y, min_dist = DBL_MAX;
std::string nearest;
if(datapool.sceneModel->hmatrix_filled) {
datapool.sceneModel->imgToHomographyCoords(datapool.sceneModel->h_matrix,
nearbyint(m->dynamics.dynamics["X"].att.value),
nearbyint(m->dynamics.dynamics["Y"].att.value),
&X, &Y);
QSharedPointer<world::ZoneH> z;
std::map< std::string, QSharedPointer<world::ZoneH> >::iterator it, it_end = zones.end();
for(it = zones.begin();it != it_end; it++) {
z = (*it).second;
if(z->pointInZone(X,Y)) {
dist = z->distanceToCenter(X,Y);
if(dist < min_dist) {
min_dist = dist;
nearest = (*it).first;
}
}
}
if(min_dist < DBL_MAX)
return nearest;
}
}
return "NONE";
}
int main()
{
if ( fesetround( FE_TOWARDZERO) == 0)
printf("The current rounding mode is \"round toward 0.\"\n");
else
printf("The rounding mode is unchanged.\n");
printf( "nearbyint(1.9) = %4.1f nearbyint(-1.9) = %4.1f\n",
nearbyint(1.9), nearbyint(-1.9) );
printf( "round(1.9) = %4.1f round(-1.9) = %4.1f\n",
round(1.9), round(-1.9) );
return 0;
}
void create_spherical_texture(int size, GLuint& tex)
{
struct elem {
unsigned char l;
unsigned char a;
};
elem* buffer = (elem *) malloc(size * size * sizeof(elem));
float r = (float)size / 2.0;
for(int i = 0; i < size; ++i)
{
for(int j = 0; j < size; ++j)
{
float d = hypotf(i - r, j - r);
buffer[(i * size) + j].l = 255u;
buffer[(i * size) + j].a = d > r ? 0u : (unsigned char)nearbyint(sqrtf(r*r - d*d) / r * 255.0);
}
}
glGenTextures(1, &tex);
glBindTexture(GL_TEXTURE_2D, tex);
glTexImage2D(GL_TEXTURE_2D, 0, GL_LUMINANCE_ALPHA, size, size, 0, GL_LUMINANCE_ALPHA, GL_UNSIGNED_BYTE, (GLvoid*)buffer);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
glBindTexture(GL_TEXTURE_2D, 0);
free(buffer);
}
void
dockapp_draw_bar_calculate( float draw_size, int bar_draw_x, int bar_draw_y )
{
float draw_percent_f;
int draw_percent;
draw_percent_f = ( GET_HRS_F( draw_size ) / DOCKAPP_BAR_WIDTH ) * 100.0f;
draw_percent = ( int ) nearbyint( draw_percent_f );
if ( DOCKAPP_BAR_WIDTH == draw_percent )
{
dockapp_draw_bar( draw_percent,
bar_draw_x,
bar_draw_y,
DOCKAPP_BAR_OFF_X,
DOCKAPP_BAR_OFF_Y );
}
else
{
dockapp_draw_bar( draw_percent,
bar_draw_x,
bar_draw_y,
DOCKAPP_BAR_ON_X,
DOCKAPP_BAR_ON_Y );
}
}
void mtsIntuitiveResearchKitPSM::RunPositionCartesian(void)
{
//! \todo: should prevent user to go to close to RCM!
if (IsCartesianGoalSet == true) {
vctDoubleVec jointSet(6, 0.0);
jointSet.Assign(JointCurrent, 6);
// compute desired slave position
CartesianPositionFrm.From(CartesianGoalSet.Goal());
CartesianPositionFrm = CartesianPositionFrm * Frame6to7Inverse;
Manipulator.InverseKinematics(jointSet, CartesianPositionFrm);
jointSet.resize(7);
jointSet[6] = DesiredOpenAngle;
#if 1 // Anton
const double difference = JointCurrent[3] - jointSet[3];
const double differenceInTurns = nearbyint(difference / (2.0 * cmnPI));
jointSet[3] = jointSet[3] + differenceInTurns * 2.0 * cmnPI;
/*
if (differenceInTurns != 0.0) {
CMN_LOG_CLASS_RUN_DEBUG << GetName()
<< " diff = " << difference
<< " turns = " << difference / (2.0 * cmnPI)
<< " corr = " << differenceInTurns
<< " res = " << jointSet[3] << std::endl;
}
*/
#endif // Anton
SetPositionJointLocal(jointSet);
// reset flag
IsCartesianGoalSet = false;
}
}
/**
* This is a microbenchmark to get cpu frequency the process is running on. The
* returned value is used to convert TSC counter values to microseconds.
*
* @return int64.
* @author cjiang
*/
static int64_t get_cpu_frequency() {
struct timeval start;
struct timeval end;
if (gettimeofday(&start, 0)) {
perror("gettimeofday");
return 0.0;
}
uint64_t tsc_start = cpuCycles();
uint64_t tsc_end;
volatile int i;
// Busy loop for 5 miliseconds. Don't use usleep() here since it causes the
// CPU to halt which will generate meaningless results.
do {
for (i = 0; i < 1000000; i++);
if (gettimeofday(&end, 0)) {
perror("gettimeofday");
return 0.0;
}
tsc_end = cpuCycles();
} while (get_us_interval(&start, &end) < 5000);
return nearbyint((tsc_end - tsc_start) * 1.0
/ (get_us_interval(&start, &end)));
}
void on_colorselection_color_changed (GtkColorSelection *colorselection, gpointer user_data)
{
char szhsv[64];
gdouble r, g, b;
gdouble h, s, v;
gtk_color_selection_get_current_color (colorselection, &colorvalue);
r = 1.0 * colorvalue.red / 65535;
g = 1.0 * colorvalue.green / 65535;
b = 1.0 * colorvalue.blue / 65535;
gtk_rgb_to_hsv(r, g, b, &h, &s, &v);
snprintf(szhsv, sizeof(szhsv), "OpenCV H: %hu S: %hu V: %hu",
(uint16_t)nearbyint(h * 180.0),
(uint16_t)nearbyint(s * 255.0),
(uint16_t)nearbyint(v * 255.0));
gtk_entry_set_text((GtkEntry *)mytext, szhsv);
}
static int64_t* get_cpu_frequency_from_file(const char *file, int ncpus)
{
std::ifstream cpuinfo(file);
if (cpuinfo.fail()) {
return nullptr;
}
char line[MAX_LINELENGTH];
int64_t* freqs = new int64_t[ncpus];
for (int i = 0; i < ncpus; ++i) {
freqs[i] = 0;
}
int processor = -1;
while (cpuinfo.getline(line, sizeof(line))) {
if (sscanf(line, "processor : %d", &processor) == 1) {
continue;
}
float freq;
if (sscanf(line, "cpu MHz : %f", &freq) == 1) {
if (processor != -1 && processor < ncpus) {
freqs[processor] = nearbyint(freq);
processor = -1;
}
}
}
for (int i = 0; i < ncpus; ++i) {
if (freqs[i] == 0) {
delete[] freqs;
return nullptr;
}
}
return freqs;
}
void rndit(double *a, double *b, int n)
{
int i ;
for (i=0; i<n; ++i) {
a[i] = nearbyint(b[i]) ;
}
}
static inline int_check_t is_unconvertible_double(const double x, const double tol) {
if (!ISNAN(x)) {
if (x <= INT_MIN || x > INT_MAX)
return INT_RANGE;
if (fabs(x - nearbyint(x)) >= tol)
return INT_TOL;
}
return INT_OK;
}
// setters
void
OWLDatabase::update_node(id_t id, const tags_t &attrs, const tags_t &tags) {
// simple implementation as a delete-add. this isn't efficient, but it might not need to be.
const int lat = nearbyint(lexical_cast<double>(required_attribute(attrs, "lat")) * SCALE);
const int lon = nearbyint(lexical_cast<double>(required_attribute(attrs, "lon")) * SCALE);
delete_node(id);
stringstream query;
query << "insert into nodes (id, version, changeset, lat, lon, tile) values ("
<< id << ", "
<< required_attribute(attrs, "version") << ", "
<< required_attribute(attrs, "changeset") << ", "
<< lat << ", " << lon << ", "
<< util::xy2tile(util::lon2x(lon), util::lat2y(lat)) << ")";
transaction.exec(query);
add_tags(transaction, "node_tags", id, tags);
}
double
PTnint(double arg1)
{
/* round to "nearest integer",
* round half-integers to the nearest even integer
* rely on default rounding mode of IEEE 754 to do so
*/
return nearbyint(arg1);
}
static inline double qwtRoundValueF( double value )
{
#if 1
// MS Windows and at least IRIX does not have C99's nearbyint() function
return ( value >= 0.0 ) ? ::floor( value + 0.5 ) : ::ceil( value - 0.5 );
#else
return nearbyint( value );
#endif
}
static void testit(int testnum, float in, float out)
{
feclearexcept(ALL_STD_EXCEPT);
assert(fpequal(out, nearbyintf(in)));
assert(fpequal(-out, nearbyintf(-in)));
assert(fetestexcept(ALL_STD_EXCEPT) == 0);
assert(fpequal(out, nearbyint(in)));
assert(fpequal(-out, nearbyint(-in)));
assert(fetestexcept(ALL_STD_EXCEPT) == 0);
assert(fpequal(out, nearbyintl(in)));
assert(fpequal(-out, nearbyintl(-in)));
assert(fetestexcept(ALL_STD_EXCEPT) == 0);
printf("ok %d\t\t# nearbyint(%g)\n", testnum, in);
}
int calcProb(int skill, int d) {
int maxProb = 100;
int prob = nearbyint((10+90.0*skill)/(0.5*d*sqrt(d) - 0.5));
if (prob > maxProb) {
prob = maxProb;
}
return prob;
}
static int colour8(double d)
{
int i = nearbyint(255*d);
i = MAX(i, 0);
i = MIN(i, 255);
return i;
}
double qpois(double p, double lambda, int lower_tail, int log_p)
{
double mu, sigma, gamma, z, y;
#ifdef IEEE_754
if (ISNAN(p) || ISNAN(lambda))
return p + lambda;
#endif
if(!R_FINITE(lambda))
ML_ERR_return_NAN;
if(lambda < 0) ML_ERR_return_NAN;
R_Q_P01_check(p);
if(lambda == 0) return 0;
if(p == R_DT_0) return 0;
if(p == R_DT_1) return ML_POSINF;
mu = lambda;
sigma = sqrt(lambda);
/* gamma = sigma; PR#8058 should be kurtosis which is mu^-0.5 */
gamma = 1.0/sigma;
/* Note : "same" code in qpois.c, qbinom.c, qnbinom.c --
* FIXME: This is far from optimal [cancellation for p ~= 1, etc]: */
if(!lower_tail || log_p) {
p = R_DT_qIv(p); /* need check again (cancellation!): */
if (p == 0.) return 0;
if (p == 1.) return ML_POSINF;
}
/* temporary hack --- FIXME --- */
if (p + 1.01*DBL_EPSILON >= 1.) return ML_POSINF;
/* y := approx.value (Cornish-Fisher expansion) : */
z = qnorm(p, 0., 1., /*lower_tail*/TRUE, /*log_p*/FALSE);
#ifdef HAVE_NEARBYINT
y = nearbyint(mu + sigma * (z + gamma * (z*z - 1) / 6));
#else
y = round(mu + sigma * (z + gamma * (z*z - 1) / 6));
#endif
z = ppois(y, lambda, /*lower_tail*/TRUE, /*log_p*/FALSE);
/* fuzz to ensure left continuity; 1 - 1e-7 may lose too much : */
p *= 1 - 64*DBL_EPSILON;
/* If the mean is not too large a simple search is OK */
if(lambda < 1e5) return do_search(y, &z, p, lambda, 1);
/* Otherwise be a bit cleverer in the search */
{
double incr = floor(y * 0.001), oldincr;
do {
oldincr = incr;
y = do_search(y, &z, p, lambda, incr);
incr = fmax2(1, floor(incr/100));
} while(oldincr > 1 && incr > lambda*1e-15);
return y;
}
}
//get the distance between two cities
int getDistance(struct structCity A, struct structCity B)
{
//get distance between two cities
int x=A.iX-B.iX;//subtract x coordinates
int y=A.iY-B.iY;//subtract y coordinates
double dist=pow(y,2)+pow(x,2);// raise both to the power of two and add
double distance=sqrt(dist);//sqrt of the sum of x^2+y^2
int myDistance=nearbyint(distance);//round to nearest int
return myDistance;
}
// return the objective value
CUDFcoefficient cplex_solver::objective_value() {
double objval;
int status = CPXgetobjval (env, lp, &objval);
if (status) {
fprintf (stderr,"No MIP objective value available. Exiting...\n");
exit(-1);
}
// printf("Objective value = % 24.24e\n", objval);
return (CUDFcoefficient)nearbyint(objval);
}
void _sir_binom_rmeasure (double *y, double *x, double *p,
int *obsindex, int *stateindex, int *parindex, int *covindex,
int ncovars, double *covars, double t) {
double mean, sd;
double rep;
mean = CASE*RHO;
sd = sqrt(CASE*RHO*(1-RHO));
rep = nearbyint(rnorm(mean,sd));
REPORTS = (rep > 0) ? rep : 0;
}
/*
* Compression: converts the arguments of floats and returns a scaled integer in
* the range of plus or minus 15.
*/
static int convertToScaledInt(float num) {
if(num > .3) num = .3;
else if (num < -.3) num = -.3;
int scaled = nearbyint(50.0*num);
if (scaled > 15)
scaled = 15;
if (scaled < -15)
scaled = -15;
return scaled;
}
int ResetStateOnTriggerTestProbe::outputState(double timevalue) {
getValues(timevalue); // calls calcValues
if (parent->columnId()!=0) { return PV_SUCCESS; }
if (probeStatus != 0) {
int nBatch = getNumValues();
if (nBatch==1) {
int nnz = (int) nearbyint(getValuesBuffer()[0]);
fprintf(outputstream->fp, "%s t=%f, %d neuron%s the wrong value.\n",
getMessage(), timevalue, nnz, nnz==1 ? " has" : "s have");
}
else {
for (int k=0; k<nBatch; k++) {
int nnz = (int) nearbyint(getValuesBuffer()[k]);
fprintf(outputstream->fp, "%s t=%f, batch element %d, %d neuron%s the wrong value.\n",
getMessage(), timevalue, k, nnz, nnz==1 ? " has" : "s have");
}
}
}
return PV_SUCCESS;
}
void SunMoonStripWidget::display_moons(uint8 day, uint8 hour, uint8 minute)
{
uint8 phase = 0;
// trammel (starts 1 hour ahead of sun)
phase = uint8(nearbyint((day-1)/TRAMMEL_PHASE)) % 8;
Tile *tileA = tile_manager->get_tile((phase == 0) ? 584 : 584 + (8-phase)); // reverse order in tilelist
uint8 posA = ((hour + 1) + 3*phase) % 24; // advance 3 positions each phase-change
// felucca (starts 1 hour behind sun)
// ...my FELUCCA_PHASE may be wrong but this method works with it...
sint8 phaseb = (day-1) % uint8(nearbyint(FELUCCA_PHASE*8)) - 1;
phase = (phaseb >= 0) ? phaseb : 0;
Tile *tileB = tile_manager->get_tile((phase == 0) ? 584 : 584 + (8-phase)); // reverse order in tilelist
uint8 posB = ((hour - 1) + 3*phase) % 24; // advance 3 positions per phase-change
if(posA >= 5 && posA <= 19)
display_sun_moon(tileA, posA - 5);
if(posB >= 5 && posB <= 19)
display_sun_moon(tileB, posB - 5);
}
