type TimeHistogram struct {
	Count                int
	Buckets              []int
	MinBucket, MaxBucket int
}

// Five buckets for every power of 10.
var logDiv = math.Log(math.Pow(10, 1.0/5))

// Add adds a single sample to the histogram.
func (h *TimeHistogram) Add(d time.Duration) {
	var bucket int
	if d > 0 {
		bucket = int(math.Log(float64(d)) / logDiv)
	}
	if len(h.Buckets) <= bucket {

inline float CalculateBinWidth(const float min_value, const float max_value,
                               const int32_t num_bins) {
  const float raw_bin_width = (max_value - min_value) / num_bins;
  return std::pow(2, std::ceil(std::log2(raw_bin_width)));
}

// Calculates the lower bound of the histogram. The lower bound is in form of
// `N * bin_width`.
inline float CalculateLowerBound(const float min_value, const float bin_width) {

// million).
// TODO(amedee) dup of gc_test.go
func aeq(x, y float64) bool {
	if x < 0 && y < 0 {
		x, y = -x, -y
	}
	const digits = 8
	factor := 1 - math.Pow(10, -digits+1)
	return x*factor <= y && y*factor <= x

   * infinite {@code double} values are considered infinitely far away. For example, 2^2000 is not
   * representable as a double, but {@code roundToDouble(BigDecimal.valueOf(2).pow(2000), HALF_UP)}
   * will return {@code Double.MAX_VALUE}, not {@code Double.POSITIVE_INFINITY}.
   *
   * <p>For the case of {@link RoundingMode#HALF_EVEN}, this implementation uses the IEEE 754

			}
		}
		if n > 1e6 {
			return nil, false // avoid excessively large exponents
		}
		pow5 := z.b.abs.expNN(natFive, nat(nil).setWord(Word(n)), nil, false) // use underlying array of z.b.abs
		if exp5 > 0 {
			z.a.abs = z.a.abs.mul(z.a.abs, pow5)
			z.b.abs = z.b.abs.setWord(1)
		} else {
			z.b.abs = pow5
		}
	} else {
		z.b.abs = z.b.abs.setWord(1)
	}

	// apply exp2 contributions

	c := math.Ceil(1.49)
	fmt.Printf("%.1f", c)
	// Output: 2.0
}

func ExampleFloor() {
	c := math.Floor(1.51)
	fmt.Printf("%.1f", c)
	// Output: 1.0
}

func ExamplePow() {
	c := math.Pow(2, 3)
	fmt.Printf("%.1f", c)
	// Output: 8.0
}

func ExamplePow10() {
	c := math.Pow10(2)
	fmt.Printf("%.1f", c)
	// Output: 100.0
}

func ExampleRound() {
	p := math.Round(10.5)

   * infinite {@code double} values are considered infinitely far away. For example, 2^2000 is not
   * representable as a double, but {@code roundToDouble(BigDecimal.valueOf(2).pow(2000), HALF_UP)}
   * will return {@code Double.MAX_VALUE}, not {@code Double.POSITIVE_INFINITY}.
   *
   * <p>For the case of {@link RoundingMode#HALF_EVEN}, this implementation uses the IEEE 754

	conn := value.(*WeightedConnection)

	weight := float64(conn.Weight)
	if lb.activeRequestBias >= 1.0 {
		weight /= float64(conn.ActiveRequests() + 1)
	} else if lb.activeRequestBias > 0.0 {
		weight /= math.Pow(float64(conn.ActiveRequests()+1), lb.activeRequestBias)
	}
	return weight

    }

    private static int amount(int count, int level) {
        if (level == 0) {
            return 0
        }
        Math.pow(count, level) + amount(count, level - 1)
    }

	return n.serviceTime + qLatency
}

func (n *Node) calcQLatency(qlen int) time.Duration {
	if !n.qLatencyEnabled {
		return 0
	}

	// Compute the queue latency in milliseconds.
	latency := math.Pow(1.2, float64(qlen+1))

	// Clip the latency at the maximum value.
	clippedLatency := math.Min(latency, float64(maxQLatency.Milliseconds()))

	// Return the latency as milliseconds.