}

const (
	fInf    = 0x7FF0000000000000
	fNegInf = 0xFFF0000000000000
)

func float64Inf() float64 {
	inf := uint64(fInf)
	return *(*float64)(unsafe.Pointer(&inf))
}

func float64NegInf() float64 {
	inf := uint64(fNegInf)
	return *(*float64)(unsafe.Pointer(&inf))
}

// timeHistogramMetricsBuckets generates a slice of boundaries for

	b2         = 2.0 << c    // b2 == 64 (untyped integer)
	_          = f(b2)       // verify b2 has type int
	c2 float64 = 2 << c      // c2 == 64.0 (type float64)
	d2         = f(2.0 << c) // == f(64)
	e2         = g(2.0 << c) // == g(int(64))
	f2         = h(2 << c)   // == h(float64(64.0))

	mallocs += memstats.Mallocs

	// Average the mallocs over the runs (not counting the warm-up).
	// We are forced to return a float64 because the API is silly, but do
	// the division as integers so we can ask if AllocsPerRun()==1
	// instead of AllocsPerRun()<2.
	return float64(mallocs / uint64(runs))

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

//go:build arm64 || ppc64 || ppc64le

package math

const haveArchModf = true

var rn, kn, wn, fn = GetNormalDistributionParameters()
var re, ke, we, fe = GetExponentialDistributionParameters()

type statsResults struct {
	mean        float64
	stddev      float64
	closeEnough float64
	maxError    float64
}

func nearEqual(a, b, closeEnough, maxError float64) bool {
	absDiff := math.Abs(a - b)
	if absDiff < closeEnough { // Necessary when one value is zero and one value is close to zero.
		return true
	}

			atomic.AddInt64(&userTime, int64(cmd.ProcessState.UserTime()))
			atomic.AddInt64(&systemTime, int64(cmd.ProcessState.SystemTime()))
		}
	})
	b.ReportMetric(float64(userTime)/float64(n), "user-ns/op")
	b.ReportMetric(float64(systemTime)/float64(n), "sys-ns/op")

package main

import "fmt"

func f0() string {
	const f = 3.141592;
	return fmt.Sprintf("%v", float64(f));
}


func f1() string {
	const f = 3.141592;
	x := float64(float32(f));  // appears to change the precision of f
	_ = x;
	return fmt.Sprintf("%v", float64(f));
}


func main() {
	r0 := f0();
	r1 := f1();
	if r0 != r1 {
		println("r0 =", r0);
		println("r1 =", r1);

		m.expMovingAvg = float64(bytesSinceLastWindow) / duration.Seconds()
		return
	}

	increment := float64(bytesSinceLastWindow) / duration.Seconds()
	m.expMovingAvg = exponentialMovingAverage(betaBucket, m.expMovingAvg, increment)
}

// exponentialMovingAverage calculates the exponential moving average
func exponentialMovingAverage(beta, previousAvg, incrementAvg float64) float64 {

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

//go:build !arm64 && !ppc64 && !ppc64le

package math

const haveArchModf = false

func archModf(f float64) (int float64, frac float64) {
	panic("not implemented")

// The polynomial is valid for 33 <= x <= 172; larger values are only used
// in reciprocal and produce denormalized floats. The lower precision there
// masks any imprecision in the polynomial.
func stirling(x float64) (float64, float64) {
	if x > 200 {
		return Inf(1), 1
	}
	const (
		SqrtTwoPi   = 2.506628274631000502417
		MaxStirling = 143.01608
	)
	w := 1 / x