// Copyright 2022 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 a

func F() complex128 {
	return 0+0i

	printf("\tnan     = math.NaN()\n");
	printf("\tinf     = math.Inf(1)\n");
	printf("\tzero    = 0.0\n");
	printf(")\n");
	printf("\n");
	printf("var tests = []struct {\n");
	printf("\tf, g complex128\n");
	printf("\tout  complex128\n");
	printf("}{\n");

	for(i=0; i<nelem(f); i++)
	for(j=0; j<nelem(f); j++)
	for(k=0; k<nelem(f); k++)
	for(l=0; l<nelem(f); l++) {
		n = f[i] + f[j]*I;
		d = f[k] + f[l]*I;
		q = n/d;

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

package cmplx

// Polar returns the absolute value r and phase θ of x,
// such that x = r * e**θi.
// The phase is in the range [-Pi, Pi].
func Polar(x complex128) (r, θ float64) {
	return Abs(x), Phase(x)

package main

func g[P any](...P) P { var zero P; return zero }

var (
	_ int        = g(1, 2)
	_ rune       = g(1, 'a')
	_ float64    = g(1, 'a', 2.3)
	_ float64    = g('a', 2.3)
	_ complex128 = g(2.3, 'a', 1i)
)

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

// This file contains declarations to test the assembly in asm1.s.

package testdata

func arg1(x int8, y uint8)

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
}

package p

var (
	_ [10]int
	_ [10.0]int
	_ [float64(10)]int                // ERROR "invalid array bound|must be integer"
	_ [10 + 0i]int
	_ [complex(10, 0)]int
	_ [complex128(complex(10, 0))]int // ERROR "invalid array bound|must be integer"
	_ ['a']int
	_ [rune(65)]int

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

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

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

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

package cmplx

import "math"

// Phase returns the phase (also called the argument) of x.
// The returned value is in the range [-Pi, Pi].