Inconsistent values with NSNumber to double multiplication

Question

I'm currently parsing NSString values to NSNumbers and then adding them into a NSMutableArray called operands in an object called "data" like so:

NSNumberFormatter * f = [[NSNumberFormatter alloc] init];
[f setNumberStyle:NSNumberFormatterDecimalStyle];
NSNumber * myNumber = [f numberFromString:*operandString];
[data.operands addObject:myNumber];

I then retrieve those numbers, perform some math on them, then update the array:

double x = [[data.operands objectAtIndex: i]doubleValue];
double y = [[data.operands objectAtIndex: i + 1]doubleValue];
double answer = x * y;
[data.operands replaceObjectAtIndex:(i) withObject:[NSNumber numberWithDouble:answer]];

When I get the answer, everything looks fine eg: ( 3.33 * 5 = 16.65)

BUT, when I look in the debugger I'm seeing some crazy values for x and answer, such as:

x = 3.3300000000000001
answer = 16.649999999999999

Why is this happening? Am I loosing some precision with parsing these back and fourth? Is it how I've used the NSNumberFormatter to parse the string?

The reason I'm in trouble with this is because I'm trying to ensure there's no double overflow errors so I'm using this simple test to check the integrity:

    if (answer / y != x){
        //THROW OVERFLOW ERROR
    }

With the above crazy numbers this is always inconsistent. When I NSLog the answer it comes out fine:

NSLog (@"%g", [[data.operands objectAtIndex:i]doubleValue]]);

Same for

NSLog (@"%f", [[data.operands objectAtIndex:i]doubleValue]]);

Answer 1

You are not losing any precision that you need to worry about. Those are the correct values. There are only about 2^60 different double numbers, that finite set has to try to approximately cover the infinite 'number of numbers' in the range that doubles cover.

In other words, there are no exact answers in computer land and your

   if (answer / y != x){
       //THROW OVERFLOW ERROR
   }

Will not work. Or it may work much of the time, but fail if you push it. Instead you need to acknowledge the limited precision (which is pretty high precision) of doubles:

  //Don't waste time worrying like this...
  if (fabs(answer / y - x) > 1e-12*fabs(answer)){
       //Not correct or useful thing to check don't use this - i did not check 
   }


   // let the math package handle it:
   if (isnan(answer)){
     // we gots problems
   }

   if (!isnormal(answer)){
     // we gots some other problems
   }

Also don't forget that 10^300 is a very large number, doubles work pretty well. To use 32 bit floats you need to pay much more attention to order of execution, etc.

NSLog is likely outputting with fewer decimals of precision, and rounds to the nearest thing, so the answers look better.