2021-03-06 06:07:56 +00:00
|
|
|
// run -gcflags=-G=3
|
|
|
|
|
|
|
|
// Copyright 2020 The Go Authors. All rights reserved.
|
|
|
|
// Use of this source code is governed by a BSD-style
|
|
|
|
// license that can be found in the LICENSE file.
|
|
|
|
|
|
|
|
package main
|
|
|
|
|
|
|
|
import (
|
|
|
|
"fmt"
|
cmd/compile: getting more built-ins to work with generics
For Builtin ops, we currently stay with using the old
typechecker to transform the call to a more specific expression
and possibly use more specific ops. However, for a bunch of the
ops, we delay calling the old typechecker if any of the args have
type params, for a variety of reasons.
In the near future, we will start creating separate functions that do
the same transformations as the old typechecker for calls, builtins,
indexing, comparisons, etc. These functions can then be called at noder
time for nodes with no type params, and at stenciling time for nodes
with type params.
Remove unnecessary calls to types1 typechecker for most kinds of
statements (still need it for SendStmt, AssignStmt, ReturnStmt, and
SelectStmt). In particular, we don't need it for RangeStmt, and this
avoids some complaints by the types1 typechecker on generic code.
Other small changes:
- Fix check on whether to delay calling types1-typechecker on type
conversions. Should check if HasTParam is true, rather than if the
type is directly a TYPEPARAM.
- Don't call types1-typechecker on an indexing operation if the left
operand has a typeparam in its type and is not obviously a TMAP,
TSLICE, or TARRAY. As above, we will eventually have to create a new
function that can do the required transformations (for complicated
cases) at noder time or stenciling time.
- Copy n.BuiltinOp in subster.node()
- The complex arithmetic example in absdiff.go now works.
- Added new tests double.go and append.go
- Added new example with a new() call in settable.go
Change-Id: I8f377afb6126cab1826bd3c2732aa8cdf1f7e0b4
Reviewed-on: https://go-review.googlesource.com/c/go/+/301951
Run-TryBot: Dan Scales <danscales@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Trust: Dan Scales <danscales@google.com>
Trust: Robert Griesemer <gri@golang.org>
Reviewed-by: Robert Griesemer <gri@golang.org>
2021-03-12 19:36:02 +00:00
|
|
|
"math"
|
2021-03-06 06:07:56 +00:00
|
|
|
)
|
|
|
|
|
|
|
|
type Numeric interface {
|
|
|
|
type int, int8, int16, int32, int64,
|
|
|
|
uint, uint8, uint16, uint32, uint64, uintptr,
|
|
|
|
float32, float64,
|
|
|
|
complex64, complex128
|
|
|
|
}
|
|
|
|
|
|
|
|
// numericAbs matches numeric types with an Abs method.
|
|
|
|
type numericAbs[T any] interface {
|
|
|
|
Numeric
|
|
|
|
Abs() T
|
|
|
|
}
|
|
|
|
|
|
|
|
// AbsDifference computes the absolute value of the difference of
|
|
|
|
// a and b, where the absolute value is determined by the Abs method.
|
|
|
|
func absDifference[T numericAbs[T]](a, b T) T {
|
|
|
|
d := a - b
|
|
|
|
return d.Abs()
|
|
|
|
}
|
|
|
|
|
|
|
|
// orderedNumeric matches numeric types that support the < operator.
|
|
|
|
type orderedNumeric interface {
|
|
|
|
type int, int8, int16, int32, int64,
|
|
|
|
uint, uint8, uint16, uint32, uint64, uintptr,
|
|
|
|
float32, float64
|
|
|
|
}
|
|
|
|
|
|
|
|
// Complex matches the two complex types, which do not have a < operator.
|
|
|
|
type Complex interface {
|
|
|
|
type complex64, complex128
|
|
|
|
}
|
|
|
|
|
|
|
|
// orderedAbs is a helper type that defines an Abs method for
|
|
|
|
// ordered numeric types.
|
|
|
|
type orderedAbs[T orderedNumeric] T
|
|
|
|
|
|
|
|
func (a orderedAbs[T]) Abs() orderedAbs[T] {
|
|
|
|
// TODO(danscales): orderedAbs[T] conversion shouldn't be needed
|
|
|
|
if a < orderedAbs[T](0) {
|
|
|
|
return -a
|
|
|
|
}
|
|
|
|
return a
|
|
|
|
}
|
|
|
|
|
|
|
|
// complexAbs is a helper type that defines an Abs method for
|
|
|
|
// complex types.
|
cmd/compile: getting more built-ins to work with generics
For Builtin ops, we currently stay with using the old
typechecker to transform the call to a more specific expression
and possibly use more specific ops. However, for a bunch of the
ops, we delay calling the old typechecker if any of the args have
type params, for a variety of reasons.
In the near future, we will start creating separate functions that do
the same transformations as the old typechecker for calls, builtins,
indexing, comparisons, etc. These functions can then be called at noder
time for nodes with no type params, and at stenciling time for nodes
with type params.
Remove unnecessary calls to types1 typechecker for most kinds of
statements (still need it for SendStmt, AssignStmt, ReturnStmt, and
SelectStmt). In particular, we don't need it for RangeStmt, and this
avoids some complaints by the types1 typechecker on generic code.
Other small changes:
- Fix check on whether to delay calling types1-typechecker on type
conversions. Should check if HasTParam is true, rather than if the
type is directly a TYPEPARAM.
- Don't call types1-typechecker on an indexing operation if the left
operand has a typeparam in its type and is not obviously a TMAP,
TSLICE, or TARRAY. As above, we will eventually have to create a new
function that can do the required transformations (for complicated
cases) at noder time or stenciling time.
- Copy n.BuiltinOp in subster.node()
- The complex arithmetic example in absdiff.go now works.
- Added new tests double.go and append.go
- Added new example with a new() call in settable.go
Change-Id: I8f377afb6126cab1826bd3c2732aa8cdf1f7e0b4
Reviewed-on: https://go-review.googlesource.com/c/go/+/301951
Run-TryBot: Dan Scales <danscales@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Trust: Dan Scales <danscales@google.com>
Trust: Robert Griesemer <gri@golang.org>
Reviewed-by: Robert Griesemer <gri@golang.org>
2021-03-12 19:36:02 +00:00
|
|
|
type complexAbs[T Complex] T
|
2021-03-06 06:07:56 +00:00
|
|
|
|
cmd/compile: getting more built-ins to work with generics
For Builtin ops, we currently stay with using the old
typechecker to transform the call to a more specific expression
and possibly use more specific ops. However, for a bunch of the
ops, we delay calling the old typechecker if any of the args have
type params, for a variety of reasons.
In the near future, we will start creating separate functions that do
the same transformations as the old typechecker for calls, builtins,
indexing, comparisons, etc. These functions can then be called at noder
time for nodes with no type params, and at stenciling time for nodes
with type params.
Remove unnecessary calls to types1 typechecker for most kinds of
statements (still need it for SendStmt, AssignStmt, ReturnStmt, and
SelectStmt). In particular, we don't need it for RangeStmt, and this
avoids some complaints by the types1 typechecker on generic code.
Other small changes:
- Fix check on whether to delay calling types1-typechecker on type
conversions. Should check if HasTParam is true, rather than if the
type is directly a TYPEPARAM.
- Don't call types1-typechecker on an indexing operation if the left
operand has a typeparam in its type and is not obviously a TMAP,
TSLICE, or TARRAY. As above, we will eventually have to create a new
function that can do the required transformations (for complicated
cases) at noder time or stenciling time.
- Copy n.BuiltinOp in subster.node()
- The complex arithmetic example in absdiff.go now works.
- Added new tests double.go and append.go
- Added new example with a new() call in settable.go
Change-Id: I8f377afb6126cab1826bd3c2732aa8cdf1f7e0b4
Reviewed-on: https://go-review.googlesource.com/c/go/+/301951
Run-TryBot: Dan Scales <danscales@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Trust: Dan Scales <danscales@google.com>
Trust: Robert Griesemer <gri@golang.org>
Reviewed-by: Robert Griesemer <gri@golang.org>
2021-03-12 19:36:02 +00:00
|
|
|
func (a complexAbs[T]) Abs() complexAbs[T] {
|
|
|
|
r := float64(real(a))
|
|
|
|
i := float64(imag(a))
|
|
|
|
d := math.Sqrt(r * r + i * i)
|
|
|
|
return complexAbs[T](complex(d, 0))
|
|
|
|
}
|
2021-03-06 06:07:56 +00:00
|
|
|
|
|
|
|
// OrderedAbsDifference returns the absolute value of the difference
|
|
|
|
// between a and b, where a and b are of an ordered type.
|
|
|
|
func orderedAbsDifference[T orderedNumeric](a, b T) T {
|
|
|
|
return T(absDifference(orderedAbs[T](a), orderedAbs[T](b)))
|
|
|
|
}
|
|
|
|
|
|
|
|
// ComplexAbsDifference returns the absolute value of the difference
|
|
|
|
// between a and b, where a and b are of a complex type.
|
cmd/compile: getting more built-ins to work with generics
For Builtin ops, we currently stay with using the old
typechecker to transform the call to a more specific expression
and possibly use more specific ops. However, for a bunch of the
ops, we delay calling the old typechecker if any of the args have
type params, for a variety of reasons.
In the near future, we will start creating separate functions that do
the same transformations as the old typechecker for calls, builtins,
indexing, comparisons, etc. These functions can then be called at noder
time for nodes with no type params, and at stenciling time for nodes
with type params.
Remove unnecessary calls to types1 typechecker for most kinds of
statements (still need it for SendStmt, AssignStmt, ReturnStmt, and
SelectStmt). In particular, we don't need it for RangeStmt, and this
avoids some complaints by the types1 typechecker on generic code.
Other small changes:
- Fix check on whether to delay calling types1-typechecker on type
conversions. Should check if HasTParam is true, rather than if the
type is directly a TYPEPARAM.
- Don't call types1-typechecker on an indexing operation if the left
operand has a typeparam in its type and is not obviously a TMAP,
TSLICE, or TARRAY. As above, we will eventually have to create a new
function that can do the required transformations (for complicated
cases) at noder time or stenciling time.
- Copy n.BuiltinOp in subster.node()
- The complex arithmetic example in absdiff.go now works.
- Added new tests double.go and append.go
- Added new example with a new() call in settable.go
Change-Id: I8f377afb6126cab1826bd3c2732aa8cdf1f7e0b4
Reviewed-on: https://go-review.googlesource.com/c/go/+/301951
Run-TryBot: Dan Scales <danscales@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Trust: Dan Scales <danscales@google.com>
Trust: Robert Griesemer <gri@golang.org>
Reviewed-by: Robert Griesemer <gri@golang.org>
2021-03-12 19:36:02 +00:00
|
|
|
func complexAbsDifference[T Complex](a, b T) T {
|
|
|
|
return T(absDifference(complexAbs[T](a), complexAbs[T](b)))
|
|
|
|
}
|
2021-03-06 06:07:56 +00:00
|
|
|
|
|
|
|
func main() {
|
|
|
|
if got, want := orderedAbsDifference(1.0, -2.0), 3.0; got != want {
|
|
|
|
panic(fmt.Sprintf("got = %v, want = %v", got, want))
|
|
|
|
}
|
|
|
|
if got, want := orderedAbsDifference(-1.0, 2.0), 3.0; got != want {
|
|
|
|
panic(fmt.Sprintf("got = %v, want = %v", got, want))
|
|
|
|
}
|
|
|
|
if got, want := orderedAbsDifference(-20, 15), 35; got != want {
|
|
|
|
panic(fmt.Sprintf("got = %v, want = %v", got, want))
|
|
|
|
}
|
|
|
|
|
cmd/compile: getting more built-ins to work with generics
For Builtin ops, we currently stay with using the old
typechecker to transform the call to a more specific expression
and possibly use more specific ops. However, for a bunch of the
ops, we delay calling the old typechecker if any of the args have
type params, for a variety of reasons.
In the near future, we will start creating separate functions that do
the same transformations as the old typechecker for calls, builtins,
indexing, comparisons, etc. These functions can then be called at noder
time for nodes with no type params, and at stenciling time for nodes
with type params.
Remove unnecessary calls to types1 typechecker for most kinds of
statements (still need it for SendStmt, AssignStmt, ReturnStmt, and
SelectStmt). In particular, we don't need it for RangeStmt, and this
avoids some complaints by the types1 typechecker on generic code.
Other small changes:
- Fix check on whether to delay calling types1-typechecker on type
conversions. Should check if HasTParam is true, rather than if the
type is directly a TYPEPARAM.
- Don't call types1-typechecker on an indexing operation if the left
operand has a typeparam in its type and is not obviously a TMAP,
TSLICE, or TARRAY. As above, we will eventually have to create a new
function that can do the required transformations (for complicated
cases) at noder time or stenciling time.
- Copy n.BuiltinOp in subster.node()
- The complex arithmetic example in absdiff.go now works.
- Added new tests double.go and append.go
- Added new example with a new() call in settable.go
Change-Id: I8f377afb6126cab1826bd3c2732aa8cdf1f7e0b4
Reviewed-on: https://go-review.googlesource.com/c/go/+/301951
Run-TryBot: Dan Scales <danscales@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Trust: Dan Scales <danscales@google.com>
Trust: Robert Griesemer <gri@golang.org>
Reviewed-by: Robert Griesemer <gri@golang.org>
2021-03-12 19:36:02 +00:00
|
|
|
if got, want := complexAbsDifference(5.0 + 2.0i, 2.0 - 2.0i), 5+0i; got != want {
|
|
|
|
panic(fmt.Sprintf("got = %v, want = %v", got, want))
|
|
|
|
}
|
|
|
|
if got, want := complexAbsDifference(2.0 - 2.0i, 5.0 + 2.0i), 5+0i; got != want {
|
|
|
|
panic(fmt.Sprintf("got = %v, want = %v", got, want))
|
|
|
|
}
|
2021-03-06 06:07:56 +00:00
|
|
|
}
|