If the contract further specified that the type must be ordered
without restricting it to just floating-point you could feature test
var d T = 3
if d/2 != 1 {
// T is floatX
if unsafe.Sizeof(d) == 4 {
// float32
} else {
// float64
}
}
Similarly, you could test for unsigned with
var z T
if z - 1 > 0 {
// T is uintX
} else {
// T is intX or floatX
}
In both cases you have to kick out the complex numbers. Combined you
have a means of classifying the properties of the types that satisfy a
basic ordered arithmetic contract without having to use reflection or
unsafe.
Not especially readable, but it could be pulled out into a generic predicate:
contract Number(t T) { t - t < t }
const (
Int = iota
Uint
Float
)
func Kind(type T Number)(_ T) int {
if T(3)/2 != 1 {
return Float
} else if T(0) - 1 > 0 {
return Uint
}
return Int
}
With that you could write the must-FMA version as:
func maMustFMA(type T Number)(a, b, c T) T {
if Kind(a) == Float {
return T(math.Fma(float64(a), float64(b), float64(c)))
}
return a*b + c
}
}
On Wed, Sep 12, 2018 at 11:08 AM jimmy frasche <soapboxcic...@gmail.com> wrote:
>
> On Wed, Sep 12, 2018 at 11:02 AM Ian Lance Taylor <i...@golang.org> wrote:
> > You could perhaps choose an implementation based on unsafe.Sizeof.
> > But I agree that it's pretty ugly.
>
> Only if the contract were t * t + t < .1
>
> Part of the construction was that it accepted more than just floating points.
--
You received this message because you are subscribed to the Google Groups
"golang-nuts" group.
To unsubscribe from this group and stop receiving emails from it, send an email
to golang-nuts+unsubscr...@googlegroups.com.
For more options, visit https://groups.google.com/d/optout.
