Floats not adding up correctly

Excelcius

Hi all Ive been working on a basic physics class for weeks now and Im about to tear my hair out basically the problem is that the floats are randomly not adding up correctly when I add yVelocity to self.y heres my code.

- (bool) updateXY:(float)elapsedTime
{
    if(isMoving)
    {
        double frametime = 1.0f / [SPStage mainStage].frameRate;
        int passedFrames = floor((remainingTime + elapsedTime) / frametime);

        remainingTime = fmod(remainingTime + elapsedTime, frametime);

        if(xyDelay <= 0)
        {
            startPoint.x = self.x;
            startPoint.y = self.y;

            for(int i = 0; i < passedFrames; i++)
            {
                self.x += xVelocity;
                self.y += yVelocity;

                xySpeed = fabs(hypotf(xVelocity, yVelocity));
                xyAngle = atan2(yVelocity, xVelocity);

                endPoint.x = self.x;
                endPoint.y = self.y;

                if(xdest != NONE || ydest != NONE)
                {
                    NSLog(@"y %.20f", self.y);
                    NSLog(@"yvel %f", yVelocity);

                    if(ydest == NONE && fabs(self.x - xdest) < fabs(xVelocity))
                    {
                        return ([self bounceAngle:-PI x:xdest y:round(self.y + sin(xyAngle) * (cos(xyAngle) * (self.x - xdest)))]) ? NO : YES;
                    }

                    else if(xdest == NONE && fabs(self.y - ydest) < fabs(yVelocity))
                    {
                        //this is being called as expected
                        return ([self bounceAngle:-PI x:round(self.x + cos(xyAngle) * (sin(xyAngle) * (self.y - ydest))) y:ydest]) ? NO : YES;
                    }

                    else if(fabs(hypotf((self.x - xdest), (self.y - ydest))) < xySpeed)
                    {
                        self.x = xdest;
                        self.y = ydest;
                        [self stopXY];
                        return YES;
                    }
                }

                xVelocity = (xVelocity + gravityX) * friction;
                yVelocity = (yVelocity + gravityY) * friction;

                if (fabs(xVelocity) <.0002 && fabs(yVelocity) <.0002)
                {
                    //[self stopXY];
                    //return YES;
                }
            }
        }

        else xyDelay -= elapsedTime;

        return NO;
    }

    return YES;
}

- (bool) bounceAngle:(float)aSurfaceAngle
                   x:(float)aX
                   y:(float)aY
{
    if(elasticity != 0)
    {
        float surfaceRightAngle = fmod(TWO_PI - aSurfaceAngle, TWO_PI) + PI;
        xyAngle = fmod(TWO_PI - xyAngle, TWO_PI);
        xyAngle = fmod(surfaceRightAngle + (surfaceRightAngle - xyAngle), TWO_PI) *-1;
        xyAngle += (xyAngle > -PI) ? 0 : 360;

        xySpeed *= elasticity;

        xVelocity = cos(xyAngle) * xySpeed;
        yVelocity = sin(xyAngle) * xySpeed;
    }

    self.x = aX;
    self.y = aY;

    return (fabs(yVelocity) <= fabs(gravityY) && fabs(xVelocity) <= fabs(gravityX)) ? NO : YES;
}

When I test the code with 3 objects above each other with exactly the same values for gravity elasticity ect but with the y and ydest variables set to 300 260 and 220 the objects go up come back down and bounce but one of the objects veers off to the side the problem being that just after the first bounce 1 of the objects doesn't quite reach the distance from the ydest to make this line fabs(self.y - ydest) < fabs(yVelocity) == false when I NSLog the yVelocities they are exactly the same for all 3 objects but when I trace the y coordinate its not as expected for the object which veers off to the side for example heres a bit of the log statement
____
y 295.00000000000000000000
yvel -5.00000000000000000000
y 290.16665649414062500000 1)this not the same decimal number (ignoring the whole number at the beginning) as a)
yvel -4.83333349227905273438 2)but this is the same as b)
y 285.50000000000000000000
yvel -4.66666698455810546875
____
y 255.00000000000000000000
yvel -5.00000000000000000000
y 250.16667175292968750000 a)
yvel -4.83333349227905273438 b)
y 245.50000000000000000000
yvel -4.66666698455810546875
____
y 215.00000000000000000000
yvel -5.00000000000000000000
y 210.16667175292968750000 a)
yvel -4.83333349227905273438 b)
y 205.50000000000000000000
yvel -4.66666698455810546875

Any help greatly appreciated 🙂

Daniel

I must admit that I didn't try to follow your complete code, but floats are in general a little dangerous when it comes to exactness. For example, look a this:

float x = 0.1f + 0.2f;
NSLog(@"%.20f", x); // output: "0.30000001192092895508"

This is because of the way floating points numbers are represented internally. For this reason, when you compare floating point numbers, it's recommended to not compare for an exact value, but to check if it lies within a certain range, e.g.

BOOL isEqual(float a, float b, float e)
{
    return (a < b + e && a > b - e);
}

Where "e" could be small value like "0.0001f". Actually, there is a macro in Sparrow for that: SP_IS_FLOAT_EQUAL.

I hope that helps!

Excelcius

Hi Daniel thanks for answering that I original posted it on here because I thought it might have something to do with how openGL and sparrow adjusted the x and y properties for display I have since learnt of the horrors of floating point arithmetic lol

Im not sure how to translate that into this line of code which is where the problem lies

if(ydest == NONE && fabs(self.y - ydest) < fabs(yVelocity))

given that fabs(self.x - xdest) is returning a value less than fabs(xVelocity) even tho they should be equal but aren't due to the float rounding issue

Does the macro work in the same way as the c method and How would I do the same to compare if a number is "great than" or if a number is "less than"

And in the instance of the c method what tolerance would you suggest to counter the standard floating point inaccuracies if that makes any sense 😉

Thanks

Daniel

Sorry for the late reply!

If you want to check if something is smaller than a certain value, you only need to add the tolerance value to the value you want to check for, e.g.

// smaller than:
if (object.x < value + e) ...

// bigger than:
if (object.x > value - e) ...

The higher the numbers you are checking, the larger "e" needs to be. However, for typical values you'll be using for pixel position, something like "0.00001" should work.

Excelcius

No worries Daniel thanks for taking the time to reply, Thats great I should have been able to figure it out myself but my brain is so frazzled at the moment I didn't want to go down another blind alley and spend weeks wrestling with another problem Thanks 🙂

borrrden

Just my two cents. There is a predefined "e" from the compiler in this case (FLT_EPSILON from float.h). Also, you can simplify your isEqual check into this:

fabs(a - b) < FLT_EPSILON