// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package main

// #include <complex.h>
import "C"

//export exportComplex64
func exportComplex64(v complex64) complex64 {
	return v
}

//export exportComplex128
func exportComplex128(v complex128) complex128 {
	return v
}

//export exportComplexfloat
func exportComplexfloat(v C.complexfloat) C.complexfloat {

///
/// if y = Square(x), where x (and so y) are DT_COMPLEX64,
/// <X_T, Y_T, JAC_T> should be <complex64, complex64, float>
/// Note that JAC_T is always real-valued, and should be an appropriate
/// precision to host the partial derivatives for dy/dx
///
/// if y = ComplexAbs(x) where x is DT_COMPLEX64 (so y is DT_FLOAT)
/// <X_T, Y_T, JAC_T> should be <complex64, float, float>
///
/// if y = Complex(x, x) where x is DT_FLOAT (so y is DT_COMPLEX64)

// It would likely be in a constraints package in the standard library.
type Numeric interface {
	~int|~int8|~int16|~int32|~int64|
		~uint|~uint8|~uint16|~uint32|~uint64|~uintptr|
		~float32|~float64|
		~complex64|~complex128
}

func DotProduct[T Numeric](s1, s2 []T) T {
	if len(s1) != len(s2) {
		panic("DotProduct: slices of unequal length")
	}
	var r T
	for i := range s1 {
		r += s1[i] * s2[i]
	}
	return r

// Test that predeclared names can be redeclared by the user.

package main

import (
	"fmt"
	"runtime"
)

func main() {
	n :=
		append +
			bool +
			byte +
			complex +
			complex64 +
			complex128 +
			cap +
			close +
			delete +
			error +
			false +
			float32 +
			float64 +
			imag +
			int +
			int8 +
			int16 +
			int32 +
			int64 +
			len +
			make +

package a

import (
	"math"
)

type Numeric interface {
	~int | ~int8 | ~int16 | ~int32 | ~int64 |
		~uint | ~uint8 | ~uint16 | ~uint32 | ~uint64 | ~uintptr |
		~float32 | ~float64 |
		~complex64 | ~complex128
}

// numericAbs matches a struct containing a numeric type that has an Abs method.
type numericAbs[T Numeric] interface {
	~struct{ Value_ T }
	Abs() T
	Value() T
}

				a[complex64(complex(float32(i), float32(i)))] = complex64(complex(float32(i), float32(i))) + 0.01
				runtime.Gosched()
			}
			for i := 0; i < mods; i++ {
				for k, _ := range a {
					a[k] *= complex(real(a[k])*1.01, imag(a[k])*1.01)
				}
				runtime.Gosched()
			}
		},
		mapPointerKeyT: func() {
			a := make(map[*complex64]complex64)
			for i := 0; i < length; i++ {

	{"imag", `var c complex64; _ = imag(c)`, `func(complex64) float32`},
	{"imag", `var c complex128; _ = imag(c)`, `func(complex128) float64`},
	{"imag", `type C64 complex64; var c C64; _ = imag(c)`, `func(p.C64) float32`},
	{"imag", `type C128 complex128; var c C128; _ = imag(c)`, `func(p.C128) float64`},

	{"real", `_ = real(1i)`, `invalid type`}, // constant
	{"real", `var c complex64; _ = real(c)`, `func(complex64) float32`},

	sink = make([]byte, 1+0i)
	sink = make([]byte, complex64(1+0i))  // ERROR "non-integer.*len|must be integer"
	sink = make([]byte, complex128(1+0i)) // ERROR "non-integer.*len|must be integer"

	sink = make([]byte, 0, 1+0i)
	sink = make([]byte, 0, complex64(1+0i))  // ERROR "non-integer.*cap|must be integer"

	{"imag", `var c complex64; _ = imag(c)`, `func(complex64) float32`},
	{"imag", `var c complex128; _ = imag(c)`, `func(complex128) float64`},
	{"imag", `type C64 complex64; var c C64; _ = imag(c)`, `func(p.C64) float32`},
	{"imag", `type C128 complex128; var c C128; _ = imag(c)`, `func(p.C128) float64`},

	{"real", `_ = real(1i)`, `invalid type`}, // constant
	{"real", `var c complex64; _ = real(c)`, `func(complex64) float32`},

package main

type Numeric interface {
	~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