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

package strconv

// FormatComplex converts the complex number c to a string of the
// form (a+bi) where a and b are the real and imaginary parts,
// formatted according to the format fmt and precision prec.
//
// The format fmt and precision prec have the same meaning as in [FormatFloat].

     * intended to return a value which is greater or equal to the real size (pessimistic). The typical use
     * case is creating a hash set or hash map of a collection without knowing the number of elements it
     * will contain. With this method we can properly size it and avoid resizes. The reason we use an
     * estimate size instead of the real size is that sometimes the real size is too expensive to compute.

func cAlike(a, b complex128) bool {
	var realAlike, imagAlike bool
	if isExact(real(b)) {
		realAlike = alike(real(a), real(b))
	} else {
		// Allow non-exact special cases to have errors in ULP.
		realAlike = veryclose(real(a), real(b))
	}
	if isExact(imag(b)) {
		imagAlike = alike(imag(a), imag(b))
	} else {
		// Allow non-exact special cases to have errors in ULP.

					{
						IP:       "1.1.1.1",
						Port:     80,
						Protocol: "udp",
					}: {}, // udp real server deleted immediately
				},
			},
			err: nil,
		},
		{
			name: "graceful delete, real server mismatch should be no-op",
			vs: &utilipvs.VirtualServer{
				Address:  netutils.ParseIPSloppy("1.1.1.1"),
				Protocol: "tcp",
				Port:     uint16(80),

	EvUserLog           = 48 // trace.Log [timestamp, internal id, key string id, stack, value string]
	EvCPUSample         = 49 // CPU profiling sample [timestamp, real timestamp, real P id (-1 when absent), goroutine id, stack]
	EvCount             = 50

            proxy_set_header Host $http_host;
            proxy_set_header X-Real-IP $remote_addr;
            proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
            proxy_set_header X-Forwarded-Proto $scheme;
            proxy_set_header X-NginX-Proxy true;

            # This is necessary to pass the correct IP to be hashed
            real_ip_header X-Real-IP;

            proxy_connect_timeout 300;
            

For details, refer to the following guidelines.

## Key scripts

* [`verify-all.sh`](verify-all.sh): This script is a vestigial redirection, Please do not add "real" logic. It is equivalent to `make verify`.
* [`update-all.sh`](update-all.sh): This script is a vestigial redirection, Please do not add "real" logic. 
The `true` target of this makerule is `hack/make-rules/update.sh`.It is equivalent to `make update`.

## Attention

        Did you *actually* encounter the need for this feature in a real-world scenario, or is it
        just a feature that seems like a sensible addition to Guava?


        Before new features get added to Guava, we really want to be sure that it's for a use case
        that actually comes up in the real world. We want to hear the real-world use case so the

	switch z := x.(type) {
	case complex64:
		re = float64(real(z))
		im = float64(imag(z))
	case complex128:
		re = real(z)
		im = imag(z)
	default:
		panic("unknown complex type")
	}
	return
}

func ComplexAbs[T Complex](a T) T {
	// TODO use direct conversion instead of realimag once #50937 is fixed
	r, i := realimag(a)
	// r := float64(real(a))
	// i := float64(imag(a))
	d := math.Sqrt(r*r + i*i)

	switch z := x.(type) {
	case complex64:
		re = float64(real(z))
		im = float64(imag(z))
	case complex128:
		re = real(z)
		im = imag(z)
	default:
		panic("unknown complex type")
	}
	return
}

func (a complexAbs[T]) Abs() T {
	// TODO use direct conversion instead of realimag once #50937 is fixed
	r, i := realimag(a.Value_)
	// r := float64(real(a.Value))
	// i := float64(imag(a.Value))