// It rounds the result assuming that the original was obtained from a complex
// value of bitSize bits, which must be 64 for complex64 and 128 for complex128.
func FormatComplex(c complex128, fmt byte, prec, bitSize int) string {
	if bitSize != 64 && bitSize != 128 {
		panic("invalid bitSize")
	}
	bitSize >>= 1 // complex64 uses float32 internally

	// Check if imaginary part has a sign. If not, add one.

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

		}
	}
	return err, nil
}

// ParseComplex converts the string s to a complex number
// with the precision specified by bitSize: 64 for complex64, or 128 for complex128.
// When bitSize=64, the result still has type complex128, but it will be
// convertible to complex64 without changing its value.
//
// The number represented by s must be of the form N, Ni, or N±Ni, where N stands

// license that can be found in the LICENSE file.

package a

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

	return a * b
}

//go:noinline
func cx64sum_ssa(a, b complex64) complex64 {
	return a + b
}

//go:noinline
func cx64diff_ssa(a, b complex64) complex64 {
	return a - b
}

//go:noinline
func cx64prod_ssa(a, b complex64) complex64 {
	return a * b
}

//go:noinline
func cx64quot_ssa(a, b complex64) complex64 {
	return a / b
}

//go:noinline

		{uint64(93), "(uint64) 93\n"},
		{uintptr(93), "(uintptr) 0x5d\n"},
		{ptrint(93), "(*int)(93)\n"},
		{float32(93.76), "(float32) 93.76\n"},
		{float64(93.76), "(float64) 93.76\n"},
		{complex64(93i), "(complex64) (0+93i)\n"},
		{complex128(93i), "(complex128) (0+93i)\n"},
		{bool(true), "(bool) true\n"},
		{bool(false), "(bool) false\n"},
		{string("test"), "(string) (len=4) \"test\"\n"},

package main

import (
	"fmt"
	"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
}

		return false
	}
	return encComplex64Slice(state, v.Slice(0, v.Len()))
}

func encComplex64Slice(state *encoderState, v reflect.Value) bool {
	slice, ok := v.Interface().([]complex64)
	if !ok {
		// It is kind complex64 but not type complex64. TODO: We can handle this unsafely.
		return false
	}
	for _, x := range slice {
		if x != 0+0i || state.sendZero {
			rpart := floatBits(float64(real(x)))

// 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

INSTANTIATE_GRAD_ERR_TYPE(float, float, float);
INSTANTIATE_GRAD_ERR_TYPE(double, float, double);
INSTANTIATE_GRAD_ERR_TYPE(double, double, double);
INSTANTIATE_GRAD_ERR_TYPE(complex64, float, float);
INSTANTIATE_GRAD_ERR_TYPE(float, complex64, float);
INSTANTIATE_GRAD_ERR_TYPE(complex64, complex64, float);
INSTANTIATE_GRAD_ERR_TYPE(complex128, complex128, double);