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

//go:build amd64 || arm64 || riscv64 || s390x

package math

const haveArchMax = true

func archMax(x, y float64) float64

const haveArchMin = true

	2.32276469057162813669e+02, // 0x406D08D8D5A2DBD9
	1.17679373287147100768e+02, // 0x405D6B7ADA1884A9
	8.36463893371618283368e+00, // 0x4020BAB1F44E5192
}

func pone(x float64) float64 {
	var p *[6]float64
	var q *[5]float64
	if x >= 8 {
		p = &p1R8
		q = &p1S8
	} else if x >= 4.5454 {
		p = &p1R5
		q = &p1S5
	} else if x >= 2.8571 {
		p = &p1R3
		q = &p1S3
	} else if x >= 2 {

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

// Multiple inlined calls to a function that causes
// redundant address loads.

package main

func F(v [2]float64) [2]float64 {
	return [2]float64{v[0], v[1]}
}

func main() {
	a := F([2]float64{1, 2})
	b := F([2]float64{3, 4})
	println(a[0], a[1], b[0], b[1])

//
// Special cases are:
//
//	Modf(±Inf) = ±Inf, NaN
//	Modf(NaN) = NaN, NaN
func Modf(f float64) (int float64, frac float64) {
	if haveArchModf {
		return archModf(f)
	}
	return modf(f)
}

func modf(f float64) (int float64, frac float64) {
	if f < 1 {
		switch {
		case f < 0:
			int, frac = Modf(-f)
			return -int, -frac
		case f == 0:

	// These are produced by the simulation, so int64 and
	// float64 are more appropriate, so that we can check for
	// bad states in the simulation.
	heapScannable int64
	gcUtilization float64
}

func (r *gcCycleResult) goalRatio() float64 {
	return float64(r.heapPeak) / float64(r.heapGoal)
}

func (r *gcCycleResult) runway() float64 {
	return float64(r.heapGoal - r.heapTrigger)
}

)

//go:noinline
func fcmplt(a, b float64, x uint64) uint64 {
	if a < b {
		x = 0
	}
	return x
}

//go:noinline
func fcmple(a, b float64, x uint64) uint64 {
	if a <= b {
		x = 0
	}
	return x
}

//go:noinline
func fcmpgt(a, b float64, x uint64) uint64 {
	if a > b {
		x = 0
	}
	return x
}

//go:noinline
func fcmpge(a, b float64, x uint64) uint64 {
	if a >= b {
		x = 0

	float64(0.6047654075331631),  // Float64()
	float64(0.9278107175107462),  // Float64()
	float64(0.16387541502137226), // Float64()
	float64(0.7263900707339023),  // Float64()
	float64(0.6974917552729882),  // Float64()
	float64(0.7640946923790318),  // Float64()
	float64(0.7188183661358182),  // Float64()
	float64(0.5856191500346635),  // Float64()
	float64(0.9549597149363428),  // Float64()

//go:noinline
func (c C) X() C {
	cx := complex(imag(*c.x), real(*c.x))
	return C{&cx}
}

//go:noinline
func (d D) X() C {
	cx := complex(float64(imag(d.x)), -float64(real(d.x)))
	return C{&cx}
}

//go:noinline
func (a A) X() C {
	cx := complex(-float64(imag(*a[0])), float64(real(*a[0])))
	return C{&cx}
}

//go:noinline
func (i I) id() I {
	return i
}

//go:noinline
func (f F) id() F {
	return f

//
// Special cases are:
//
//	Ldexp(±0, exp) = ±0
//	Ldexp(±Inf, exp) = ±Inf
//	Ldexp(NaN, exp) = NaN
func Ldexp(frac float64, exp int) float64 {
	if haveArchLdexp {
		return archLdexp(frac, exp)
	}
	return ldexp(frac, exp)
}

func ldexp(frac float64, exp int) float64 {
	// special cases
	switch {
	case frac == 0:
		return frac // correctly return -0
	case IsInf(frac, 0) || IsNaN(frac):
		return frac

	if s.CPU == nil || s.CPU.UsageCoreNanoSeconds == nil {
		return
	}

	ch <- metrics.NewLazyMetricWithTimestamp(s.CPU.Time.Time,
		metrics.NewLazyConstMetric(nodeCPUUsageDesc, metrics.CounterValue, float64(*s.CPU.UsageCoreNanoSeconds)/float64(time.Second)))
}

func (rc *resourceMetricsCollector) collectNodeMemoryMetrics(ch chan<- metrics.Metric, s summary.NodeStats) {
	if s.Memory == nil || s.Memory.WorkingSetBytes == nil {
		return
	}