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

// issue 4264: reject int division by const 0

package main

func main() {
	var x int
	var y float64
	var z complex128

	println(x/0) // ERROR "division by zero"
	println(y/0)
	println(z/0)

// Annex G IEC 60559-compatible complex arithmetic.
package cmplx

import "math"

// Abs returns the absolute value (also called the modulus) of x.

		m[nz] = "-0"
		if m[pz] != "-0" {
			panic(fmt.Sprintln("complex128 map does not treat -0 and +0 as equal for write"))
		}
		if _, ok := m[nana]; ok {
			panic(fmt.Sprintln("complex128 map allows NaN lookup (a)"))
		}
		if _, ok := m[nanb]; ok {
			panic(fmt.Sprintln("complex128 map allows NaN lookup (b)"))
		}
		if len(m) != 3 {
			panic(fmt.Sprintln("complex128 map should have 3 entries:", m))
		}
		m[nana] = "NaN"

// Test trivial, bootstrap-level complex numbers, including printing.

package main

const (
	R = 5
	I = 6i

	C1 = R + I // ADD(5,6)
)

func doprint(c complex128) { println(c) }

func main() {

	// constants
	println(C1)
	doprint(C1)

	// variables
	c1 := C1
	println(c1)
	doprint(c1)

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
}

//    DEC       -10,+10      8700       3.7e-17     1.1e-17
//    IEEE      -10,+10     30000       3.0e-16     8.7e-17

// Exp returns e**x, the base-e exponential of x.
func Exp(x complex128) complex128 {
	switch re, im := real(x), imag(x); {
	case math.IsInf(re, 0):
		switch {
		case re > 0 && im == 0:
			return x
		case math.IsInf(im, 0) || math.IsNaN(im):
			if re < 0 {

		panic("fail")
	}
	
	r32 := real(complex64(ce))
	if r32 != float32(real(Ce)) {
		println("real(complex64(ce))", r32, real(Ce))
		panic("fail")
	}
	
	r64 := real(complex128(ce))
	if r64 != real(Ce) {
		println("real(complex128(ce))", r64, real(Ce))
		panic("fail")
	}

	dup("42"),
	dup("3.1415"),
	dup("2.71828i"),
	dup(`'a'`),
	dup(`"foo"`),
	dup("`bar`"),
	dup("any"),

	// func and composite literals
	{"func(){}", "(func() literal)"},
	{"func(x int) complex128 {}", "(func(x int) complex128 literal)"},
	{"[]int{1, 2, 3}", "[]int{…}"},

	// type expressions
	dup("[1 << 10]byte"),
	dup("[]int"),
	dup("*int"),
	dup("struct{x int}"),
	dup("func()"),
	dup("func(int, float32) string"),

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

package p

func _[
        T0 any,
        T1 []int,
        T2 ~float64 | ~complex128 | chan int,
]() {
        _ = T0(nil /* ERROR "cannot convert nil to type T0" */ )
        _ = T1(1 /* ERRORx `cannot convert 1 .* to type T1` */ )
        _ = T2(2 /* ERRORx `cannot convert 2 .* to type T2` */ )
}

package main

var p0exp = S1{
	F1: complex(float64(2.3640607624715027), float64(-0.2717825524109192)),
	F2: S2{F1: 9},
	F3: 103050709,
}

type S1 struct {
	F1 complex128
	F2 S2
	F3 uint64
}

type S2 struct {
	F1 uint64
	F2 empty
}

type empty struct {
}

//go:noinline
//go:registerparams
func callee(p0 S1) {
	if p0 != p0exp {
		panic("bad p0")