Is there any function like floorMod in Java?

[tasty0tomato]

https://docs.oracle.com/javase/8/docs/api/java/lang/Math.html#floorMod-int-int-
There is some kind of discussion in stackoverflow
It might be more useful than %?

[BL1NDX3N0N]

floorMod is a function whereas % is an operator. Functions are part of frameworks/libraries which require importing while operators are built into the compiler and can be used anywhere. As far as being useful, it is subjective since not everyone has the same requirements.

I recommend you check out the existing Math class and use the methods in it to create your own methods which suit your requirements.

• https://docs.microsoft.com/en-us/dotnet/api/system.math?view=net-6.0

Also, it is worth mentioning that the Java function you linked calculates the modulus of two integers and the C# operator you referenced is the remainder operator, they do not work the same and will yield different results.

• https://docs.microsoft.com/en-us/dotnet/csharp/language-reference/operators/arithmetic-operators#remainder-operator-

Additional links:

• https://docs.microsoft.com/en-us/dotnet/api/system.decimal.op_modulus?view=net-6.0

[tannergooding]

User-defined operators are simply functions with special names that the compiler maps back to symbols.

x + y maps to a static function called op_Addition. x[y] maps to a static or instance function called get_Item (and set_Item in the case of a setter). The same is true of any operator which you can define on your own types.

For the primitive types, rather than mapping to a static function defined on the type the language ignores any user-defined operators and compiles it down to the built-in operators represented by IL instructions like add, sub, mul, and div.

[BL1NDX3N0N]

We are aware of what they are.

[huoyaoyuan]

Be aware of what "compiler" is. The C# compiler is only aware of primitive types and primitive operators on it.
The JIT compiler has "built-in" support for much more functions. The appear as functions in IL code, but JIT will emit special instructions for them.

[BL1NDX3N0N]

I'm well aware of what a compiler is, considering I've written my own compilers and runtimes for engines I've designed. You have jumped into these comments as a way for you to butt heads on the smallest of things so that you appear smarter than what you are.

The whole "not true" is what gave it away by the way...

[tannergooding]

@BL1NDX3N0N please be respectful to other members of the community and be mindful of the .NET Code of Conduct: https://dotnetfoundation.org/about/code-of-conduct

There are people from all backgrounds here and @huoyaoyuan has proven themselves time and time again to be respectful and considerate of others. Enough so that they are one of the few community triager's for the repo.

The comment on the differences between functions and operators was made because there was a potentially confusing statement made on how they were different and it is important, especially in the context of what APIs and functionality is exposed by the library team to disambiguate.

[huoyaoyuan]

There can be multiple options for rounding of division when any operand is negative. Currently there is only one option implemented in .NET, which is rounding quotient towards 0 and making remainder the same sign of dividend.

It might be more useful than %?

It depends. Notice that the result of integer / and % are in pair and should be kept consistent. .NET also provides a DivRem method to get them together.

The rule of .NET is also the rule of x86 IDIV instruction.

[tannergooding]

For those unfamiliar FloorMod is the "full name" of the C API known as fmod whose formal definition is:

The fmod functions return the value x − ny, for some integer n such that, if y is nonzero, the result
has the same sign as x and magnitude less than the magnitude of y. If y is zero, whether a domain
error occurs or the fmod functions return zero is implementation-defined.

The C spec then gives an example that the IEEE 754 compliant is equivalent to:

double fmod(double x, double y)
{
    double result;
    result = remainder(fabs(x), (y = fabs(y)));
    if (signbit(result)) result += y;
    return copysign(result, x);
}

remainder is itself defined to match the IEEE 754 required implementation of sourceFormat remainder(source, source) whose formal definition is:

When y ≠ 0, the remainder r = remainder(x, y) is defined for finite x and y regardless of the
rounding-direction attribute by the mathematical relation r = x − y × n , where n is the integer
nearest the exact number x / y ; whenever | n − x / y | = ½ , then n is even. Thus, the remainder is
always exact. If r = 0, its sign shall be that of x. remainder(x, ∞) is x for finite x.

---

C# defines x % y as

In the table, x and y are positive finite values. z is the result of x % y and is computed as x – n * y, where n is the largest possible integer that is less than or equal to x / y

---

These definitions are notably very close to each other with the difference being in how rounding occurs. There is a related issue #62992 that discusses some of the perceived differences here between spec and implementation noting that the runtime effectively implements floating-point % as fmod.

You'll first note that remainder(1.0, 0.1) in C/C++ returns -5.5511151231257827021181583404541015625E-17 and this matches what Math.IEEERemainder returns. The reasoning for this is that 1.0 is exactly representable but 0.1 is not, the latter is actually 0.1000000000000000055511151231257827021181583404541015625. The exact result of x / y given these two inputs is 9.999999999999999444888487687421760603063276150361782076232622354... and the integer nearest that is logically 10. 1 - 10 * 0.1 as a single fused operation then returns -5.5511151231257827021181583404541015625E-17 as expected.

Then when you consider fmod you'll note that since the result of remainder is negative, we must add y and -5.5511151231257827021181583404541015625E-17 + 0.1000000000000000055511151231257827021181583404541015625 results in 0.0999999999999999500399638918679556809365749359130859375 thus having the same sign (positive in this case) as x and being less than y

---

Now when compared to the official C# definition there is a quirk here since n has to be the largest possible integer less than or equal to x / y. Given the above algorithm this effectively computes floor(1.0 / 0.1) and so due to the imprecision in representing 0.1 should result in an integer n = 9 and therefore the infinitely precise result of the operation is 0.0999999999999999500399638918679556809365749359130859375. -- There is notably an ambiguity here being discussed in the issue I linked just a bit back.

The question then remains to determine whether or not FloorMod(x, y) is equivalent to fma(floor(x, y), -y, x) and while I believe this is the case, I've not actually sat down to work out and confirm that yet.