C++ function "ceil" in Flexscript

Hi,

for the c++ function "floor" I can use trunc so far, but for "ceil" I haven't found a similar function in flexscript.

I built two variants:

// Ceil Function
// ceil(4/3) = 2
int result;
double g = 4;
double h = 3;
// Variant 1

result = g/h;
if (fmod(g,h))
{
pt("rest: ");pf(fmod(g,h));pr();
result = trunc(g/h)+1;
}

// Variant 2
double temp1=g/h;
double temp2=temp1+0.9999999;
result=maxof(trunc(temp1),trunc((temp2)));
//----
//Variants End
//----
pt("result: ");pd(result);pr();

Are there any shorter and faster ways to build a ceil-function in flexscript?

Have some fun with this quest.

Jörg

Jorg,

I have aways used:

// Variant 3

int result;
double g = 4;
double h = 3;
result = round((g/h) +0.5);
return result;



Rgds,
DJ

My version:

double n = 3.2;
//double n = 3.0;
int res;
if(frac(n)==0) res = n;
else res = trunc(n+1);
pd(res);pr();

When I check Dirk-Jan's version, it is a surprise that his formula gives me correct result when g/h is an integer. Then I found Flexsim script has a different understanding of rounding .5 fraction as we typically do. Shouldn't round(1.5) return 2 instead of 1 as the Flexsim script do?

When doing rounding, a commonly used rule is called Round-to-Even method (see http://en.wikipedia.org/wiki/Roundin...to-even_method). So
round(0.5) = 0
round(1.5) = 2
round(2.5) = 2
round(3.5) = 4
round(4.5) = 4
etc.

If Flexsim script follows the Round-to-Even rule (which I think it should), Dirk-Jan's version won't give you correct answer.

Alan,

I do not think a round to even function is that common.

Rounding in my opinion is done to the nearest integer. I would have thought that round(1.5) would result in 2 rather than 1 (as Flexscript does). But I am not sure Flexscript will be changed to calculate it like that. And if they do I need to change this solution :-)


DJ

DJ,

Round-to-even is mainly for statistical purpose so that you won't get a biased result when you always round up. The reason is that statistically .5 is not closer to either the immediately integer number larger than it or the one smaller than it. So it should get half of chance to round up, and half of chance to round down. This may not be that significant from a practical standpoint. But since Flexsim is a simulation software and statistics is the main thing that we should care when doing simulation, we may need "right" statistics here. And it is not hard to do, right? :-)

Flexscript will always round down. That is,
round(0.5) = 0
round(1.5) = 1
round(2.5) = 2
...
This is definitely different from what we typically do (either round up or round-to-even).

Alan