Strange decimal behaviour

Thx for all the replies guys the answer turned out to be very simple but I learned alot about number in the process

All I did was change my CalculateStringMath Method.
UltimaRegex is just my own class wich is sort of a library for regex patterns I use alot, but the expression comes down to: "[0-9]*\.?[0-9]+".

private decimal CalculateStringMath(string calculation)
     {
            MSScriptControl.ScriptControl script = new MSScriptControl.ScriptControl() ;
            script.Language = "VBScript";

            //====Alter calculation string===
            calculation = calculation.Replace("%", "mod");
            //Convert all numbers to decimal
            MatchCollection numbers = UltimaRegex.GetMatches(null,UltimaRegex.Expression.Number,null,calculation);
            foreach (Match m in numbers)
            {
               calculation = calculation.Replace(m.ToString(),"CCur(" + m.ToString() + ")");
            }
            //==============================

            Object result = script.Eval(calculation);
            return Convert.ToDecimal(result);
        }

Ok I think understand the problem and it would probably be a easy fix by just using decimal,
but the method I'm using is not my own its MSScriptControl and if I understand correctly MSScript is using double internally instead of decimal ?
which creates the problem... 

My Method to calculate looks like this:

private decimal CalculateStringMath(string calculation)

   {

      MSScriptControl.ScriptControl script = new MSScriptControl.ScriptControl();

      script.Language = "VBScript";

            calculation = calculation.Replace("%", "mod");

            Object result = script.Eval(calculation);

            return Convert.ToDecimal(result);

    }

Is there any way I can work arround it with MSScriptControl because I find it hard to believe MSScript is this limiting or should I try somthing like...

I think should solve the prob but will limit my equations :(.

return Math.Round(Convert.ToDecimal(result),8);

Also see this.

Floating point numbers do not cover all possible values in range, but rather some points on the axis plus some special values (like plus and minus infinite). Hence, in floating point arithmetic, expression like 10000000.9-10000000.6 might not evaluate to 0.3 because exact values of the two numbers could not be represented in numerical system used. Note that all floating point and decimal numbers used today in computing are precisely defined by their IEEE standards.

Anyway, if you print out the result with up to, say, five decimal places, you would certainly get the result 0.3 printed out because error caused by the particular floating point format cannot be that large and hence will not affect the result.

This becomes a major problem when working with money, for example. In those cases, many additions of slightly incorrect values may propagate the error to order of 10^-2 or 10^-3, which then affects the exact monetary value, which cannot be allowed. In cases like that, positional systems are used to store values, so that rounding is done at decimal positions rather than to rational values that are distributed over the whole range represented by the particular numerical type.

If you can get a hold of the first volume of Donald Knuth's The Art of Computer Programming, then you should find there probably the most exhaustive explanation of how numbers are represented in computers today, which off course includes fixed point and floating point decimal numbers. As a shortcut, you may refer to Wikipedia for the same thing.

Zoran

If you use floating point arithmetic (double or float types), then you will get these discrepancies from time to time because the representation of these numbers in the machine is not usually exact.

Internally, calculations are carried out to 10 bytes precision and are then rounded to 8 bytes (double) or 4 bytes(float) which sometimes results in these 'rounding errors'.

To avoid this, use the decimal type instead which uses 16 bytes precision and is always correct to at least 28 digits. The drawback is that calculations involving the decimal type are much slower than floating point and require more memory though, unless you're doing a large number of calculations, you're unlikely to notice much difference.