Alternative Eq/Neq implementation?

[dmitshur]

Right now the implementation of Eq and Neq methods looks like this:

// Eq is "==" operation.
func (c Complex64) Eq(x Complex64) bool {
	return c.r == x.r && c.i == x.i
}

// Neq is "!=" operation.
func (c Complex64) Neq(x Complex64) bool {
	return c.r != x.r || c.i != x.i
}

I'm just wondering, have you considered the following alternative implementation?

// Eq is "==" operation.
func (c Complex64) Eq(x Complex64) bool {
	return c == x
}

// Neq is "!=" operation.
func (c Complex64) Neq(x Complex64) bool {
	return c != x
}

Since the struct contains just two float32 fields, the behavior would be identical. But it's shorter, and perhaps simpler/more readable? Of course, that's debatable.

I would expect it to generate identical assembly, but case it's not, would it be faster or slower?

It's just a thought that came to mind when seeing that code, so I wanted to share it.

[dmitshur]

Also, related to the above, here's an alternative IsZero implementation:

// IsZero returns true if both c.Real() and c.Imag() return 0.
func (c Complex64) IsZero() bool {
	return c == zero
}

var zero Complex64

[quasilyte]

Also, related to the above, here's an alternative IsZero implementation:

@shurcooL, comparison with zero value looks better, thank you.

Thought using a global variable will introduce memory read here,
maybe c == Complex64{} is good enough?
(there would be no problem if it was const, but we have no constant structures at our disposal)

[dmitshur]

Yes, return c == Complex64{} is an option too, but I don't know whether that would cause an allocation or not.

[quasilyte]

@shurcooL, in this case no real object is created.
If I get it right, X1 is zeroed and used to compare both c fields against it.

// 0x25d6  REP MOVSS 0x8(SP), X0
// 0x25dc  XORPS X1, X1
// 0x25df  UCOMISS X1, X0
// 0x25e2  JNE 0x25fc
// 0x25e4  JP 0x25fc
// 0x25e6  REP MOVSS 0xc(SP), X0
// 0x25ec  UCOMISS X1, X0
// 0x25ef  SETE CL
// 0x25f2  SETNP AL
// 0x25f5  ANDL AX, CX
// 0x25f7  MOVB CL, 0x10(SP)
// 0x25fb  RET
// 0x25fc  XORL CX, CX
// 0x25fe  JMP 0x25f7
func isZero64(c Complex64) bool { return c.IsZero() }

I have about zero knowledge about Go optimizer, so this is merely an output inspection which may be x86-backend dependent.