Search
Dec 11
rumbu
Dec 11
ag0aep6g
```Is there any way to overload specific floating point operators?
https://dlang.org/spec/expression.html#floating-point-comparisons

I'm using a decimal data type (a struct) and one of the possible values is NaN, that's why I need these operators.

I know also that this also was discussed, but is there any way to separately implement == and !=, so both return true or false in the same time?

The reason is the same: NaN == NaN = false and NaN != NaN = false in the same time.

```
```On 12/11/2017 08:28 PM, rumbu wrote:
> Is there any way to overload specific floating point operators?
> https://dlang.org/spec/expression.html#floating-point-comparisons

Those don't seem to work anymore. At least since 2.073, dmd rejects them and says to use std.math.isNaN instead. Looks like someone forgot to upate the spec. I couldn't find anything in the changelog either.

> I'm using a decimal data type (a struct) and one of the possible values is NaN, that's why I need these operators.

You can return float.nan from opCmp to mean "unordered":

----
struct S
{
bool isNaN = true;
int value;

this(int value) { this.isNaN = false; this.value = value; }

bool opEquals(const S other) const pure nothrow @safe @nogc
{
return !this.isNaN && !other.isNaN && this.value == other.value;
}

float opCmp(const S other) const pure nothrow @safe @nogc
{
if (this.isNaN || other.isNaN) return float.nan;
if (this.value < other.value) return -1;
if (this.value > other.value) return 1;
return 0;
}
}

void main()
{
S s1; // NaN
S s2; // NaN

assert(s1 != s2); // neither equal ...
assert(!(s1 < s2)); // nor less than ...
assert(!(s1 > s2)); // nor greater
}
----

> I know also that this also was discussed, but is there any way to separately implement == and !=, so both return true or false in the same time?

I don't think so.

> The reason is the same: NaN == NaN = false and NaN != NaN = false in the same time.

But NaN != NaN is true.
```
```On Monday, December 11, 2017 19:28:47 rumbu via Digitalmars-d-learn wrote:
> Is there any way to overload specific floating point operators? https://dlang.org/spec/expression.html#floating-point-comparisons

If those haven't been deprecated yet, they almost certainly will be. It was decided that they were a mistake, and AFAIK, pretty much no one uses them. opEquals and opCmp are all that there is for overloading comparison operators.

> I'm using a decimal data type (a struct) and one of the possible values is NaN, that's why I need these operators.
>
> I know also that this also was discussed, but is there any way to separately implement == and !=, so both return true or false in the same time?
>
> The reason is the same: NaN == NaN = false and NaN != NaN = false in the same time.

You cannot overload == and != separately, but why would you need to? There's
no reason for a != b to not be the same as !(a == b) even with floating
point
comparisons. e.g.

import std.stdio;

void main()
{
float f;
writeln(f == f);
writeln(f != f);
}

prints

false
true

- Jonathan M Davis

```