Meaning of "%" operation in C# for the numeric type double

Question

Recently I discovered that C#'s operator % is applicable to double. Tried some things out, and after all came up with this test:

class Program
{
    static void test(double a, double b)
    {
        if (a % b != a - b * Math.Truncate(a / b))
        {
            Console.WriteLine(a + ", " + b);
        }
    }
    static void Main(string[] args)
    {
        test(2.5, 7);
        test(-6.7, -3);
        test(8.7, 4);
        //...
    }
}

Everything in this test works. Is a % b always equivalent to a - b*Math.Round(a/b)? If not, please explain to me how this operator really works.

EDIT: Answering to James L, I understand that this is a modulo operator and everything. I'm curious only about how it works with double, integers I understand.

Did some more testing. As it turned out, a % b is not always equivalent to a - b*Math.Truncate(a/b). For example, it's not for 1.0 and 0.1. — Sergey, Nov 12 '11 at 17:53

score 16 · Accepted Answer · edited May 23 '17 at 12:09

16

The modulus operator works on floating point values in the same way as it does for integers. So consider a simple example:

4.5 % 2.1

Now, 4.5/2.1 is approximately equal to 2.142857

So, the integer part of the division is 2. Subtract 2*2.1 from 4.5 and you have the remainer, 0.3.

Of course, this process is subject to floating point representability issues so beware – you may see unexpected results. For example, see this question asked here on Stack Overflow: Floating Point Arithmetic - Modulo Operator on Double Type

Is a % b always equivalent to a - b*Math.Round(a/b)?

No it is not. Here is a simple counter example:

static double f(double a, double b)
{
    return a - b * Math.Round(a / b);
}

static void Main(string[] args)
{
    Console.WriteLine(1.9 % 1.0);
    Console.WriteLine(f(1.9, 1.0));
    Console.ReadLine();
}

As to the precise details of how the modulus operator is specified you need to refer to the C# specification – earlNameless's answer gives you a link to that.

It is my understanding that a % b is essentially equivalent, modulo floating point precision, to a - b*Math.Truncate(a/b).

edited May 23 '17 at 12:09

Community

1
1

answered Nov 12 '11 at 16:14

David Heffernan

601,492
42
1,072
1,490

So basically a % b is always equivalent to a - b*Math.Round(a/b)? – Sergey Nov 12 '11 at 16:15
2

No it is not. Replace Round with Trunc and you should be there, certainly for positive `a` and `b`. – David Heffernan Nov 12 '11 at 16:17
1

Just to be sure, then a % b always equals a - b * Math.Truncate(a / b)? – Sergey Nov 12 '11 at 16:24
3

When `a` and `b` are positive that is certainly true. I suspect that it is true for all cases, but I'm not 100% certain. – David Heffernan Nov 12 '11 at 16:26
1

And the downvote is because of what exactly? I want to get this right. – David Heffernan Nov 12 '11 at 16:50
I don't know what you're talking about... I didn't downvote you answer. – Sergey Nov 12 '11 at 17:48
@Sergey The question is addressed at whoever did downvote. I don't know who but it would naturally be odd for you to accept answer and downvote!! If I did make a mistake I'd just like to know so I can fix it. – David Heffernan Nov 12 '11 at 18:25
`a % b` is not equal to `a - b * Math.Truncate(a / b)` for the values a = 1024.0 and b = 25.6. – JLRishe Feb 02 '17 at 14:53
@JLRishe Well, surely that's due to floating point representability? – David Heffernan Feb 02 '17 at 16:13
Most likely. Just thought those tuning in might like to know because there was a recent [question](http://stackoverflow.com/questions/42005119/c-sharp-modulo-function-on-double#comment71190235_42005119) about that pair of numbers. – JLRishe Feb 02 '17 at 16:21

score 5 · Answer 2 · answered Nov 12 '11 at 16:19

From C# Language Specifications page 200:

Floating-point remainder:

float operator %(float x, float y); 
double operator %(double x, double y);

The following table lists the results of all possible combinations of nonzero finite values, zeros, infinities, and NaN’s. In the table, x and y are positive finite values. z is the result of x % y and is computed as x – n * y, rounded to the nearest representable value, where n is the largest integer that is less than or equal to x / y. This method of computing the remainder is analogous to that used for integer operands, but differs from the IEC 60559 definition (in which n is the integer closest to x / y).

Lou Klauder · Answer 3 · 2019-02-02T00:59:33.490

Searching with the phrase "modulo floating point c#" brings up quite a few entries in Stack Overflow, most of them explaining nicely how floating point precision complicates things. I did not recognize any suggestion for a simple practical way to handle that. What I came up with for my own purposes is the following modulo function:

public static double modulo( double a, double b, double num_sig_digits = 14 )
{
   double  int_closest_to_ratio
         , abs_val_of_residue
         ;

   if ( double.IsNaN( a )
      || double.IsNaN( b )
      || 0 == b
      )
   {
      throw new Exception( "function modulo called with a or b == NaN or b == 0" );
   }

   if ( b == Math.Floor( b ) )
   {
      return (a % b);
   }
   else
   {
      int_closest_to_ratio = Math.Round( a / b );
      abs_val_of_residue = Math.Abs( a - int_closest_to_ratio * b );
      if ( abs_val_of_residue < Math.Pow( 10.0, -num_sig_digits ) )
      {
         return 0.0;
      }
      else
      {
         return abs_val_of_residue * Math.Sign( a );
      }
   }
}

Following are some sample results:

modulo( 0.5, 0.1, 17 ) = 0

modulo( 0.5, -0.1, 16 ) = 0

modulo( -0.5, 0.1, 15 ) = 0

modulo( -0.5, -0.1, 14 ) = 0

modulo( 0.52, 0.1, 16 ) = 0.02

modulo( 0.53, -0.1, 15 ) = 0.03

modulo( -0.54, 0.1, 14 ) = -0.04

modulo( -0.55, -0.1, 13 ) = -0.05

modulo( 2.5, 1.01, 17 ) = 0.48

modulo( 2.5, -1.01, 16 ) = 0.48

modulo( -2.5, 1.01, 15 ) = -0.48

modulo( -2.5, -1.01, 14 ) = -0.48

modulo( 0.599999999999977, 0.1, 16 ) = 2.35367281220533E-14

modulo( 0.599999999999977, 0.1, 15 ) = 2.35367281220533E-14

modulo( 0.599999999999977, 0.1, 14 ) = 2.35367281220533E-14

modulo( 0.599999999999977, 0.1, 13 ) = 0

modulo( 0.599999999999977, 0.1, 12 ) = 0

H H · Answer 4 · 2011-11-12T16:17:33.607

2

From the MSDN page :

The modulus operator (%) computes the remainder after dividing its first operand by its second. All numeric types have predefined modulus operators.

And

Note the round-off errors associated with the double type.

edited Nov 12 '11 at 16:17

answered Nov 12 '11 at 16:12

H H

263,252
30
330
514

Meaning of "%" operation in C# for the numeric type double

4 Answers4

Linked