eitt
elles
honom
hjå
ho
hoe
henne
hennar
hennes
hoss
hossen
ikkje
ingi
inkje
korleis
korso
kva
kvar
kvarhelst
kven
kvi
kvifor
me
medan
mi
mine
mykje
no
nokon
noka
nokor
noko
nokre
si
sia
sidan
so
somt
somme
um
upp
vere
vore
verte
vort
varte

  snprintf(buf, kBufSize, "Mean with %2.0f%% trimmed:", trim_ratio * 100);
  std::string label_trimmed(buf);
  snprintf(buf, kBufSize, "Mean of %2.0f%% best:", best_ratio * 100);
  std::string label_best(buf);
  std::vector<std::pair<std::string, double>> groups = {
      {"Best:", sorted_us.front()},
      {"Worst:", sorted_us.back()},
      {"Median:", sorted_us[count_us / 2]},
      {"Mean:", sum_us / count_us},

)

type Data []float64

func (d Data) Min() float64 {
	return d.sorted().min()
}

func (d Data) Max() float64 {
	return d.sorted().max()
}

func (d Data) Median() float64 {
	return d.Quantile(0.5)
}

func (d Data) Mean() float64 {
	total := float64(0)
	for _, v := range d {
		total += v
	}
	return total / float64(len(d))
}

func (d Data) Quantile(phi float64) float64 {

        return myTime && myTime.median < otherTime.median && differenceSignificantCheck.test(myTime, otherTime)
    }

    boolean significantlySlowerThan(MeasuredOperationList other, double minConfidence = MINIMUM_CONFIDENCE) {
        def myTime = results.totalTime
        def otherTime = other.totalTime
        myTime && myTime.median > otherTime.median && differenceIsSignificant(myTime, otherTime, minConfidence)
    }

// CHECK-SAME: %[[X:[^:[:space:]]+]]
// CHECK-SAME: %[[SCALE:[^:[:space:]]+]]
// CHECK-SAME: %[[OFFSET:[^:[:space:]]+]]
// CHECK-SAME: %[[MEAN:[^:[:space:]]+]]
// CHECK-SAME: %[[VARIANCE:[^:[:space:]]+]]
func.func @unfuse_batch_norm(
    %x: tensor<4x256xf32>, %scale: tensor<256xf32>, %offset: tensor<256xf32>,
    %mean: tensor<256xf32>, %variance: tensor<256xf32>)
    -> (tensor<4x256xf32>) {

import java.util.stream.Collectors;

/**
 * A collection of measurements of some given units.
 */
public class DataSeries<Q> extends ArrayList<Amount<Q>> {
    private final Amount<Q> average;
    private final Amount<Q> median;
    private final Amount<Q> max;
    private final Amount<Q> min;
    // https://en.wikipedia.org/wiki/Standard_error
    private final Amount<Q> standardError;

    }

    String getSpeedStats() {
        format(totalTime)
    }

    private String format(DataSeries<?> measurement) {
        """  ${name} median: ${measurement.median.format()} min: ${measurement.min.format()}, max: ${measurement.max.format()}, se: ${measurement.standardError.format()}}
  > ${measurement.collect { it.format() }}
"""

    }

  // CHECK: %[[RED_IDX:.*]] = "tf.Const"() <{value = dense<[2, 3]> : tensor<2xi32>}>
  // CHECK: %[[MEAN:[0-9]*]] = "tf.Mean"(%arg0, %[[RED_IDX]])
  // CHECK-SAME: (tensor<1x64x112x112xf32>, tensor<2xi32>) -> tensor<1x64xf32>
  // CHECK: return %[[MEAN]]

  // NOFOLD: %[[CST:.*]] = "tf.Const"() <{value = dense<[0, 2, 3, 1]> : tensor<4xi32>}>

  // Reduce spatial dimensions
  %16 = "tf.Mean"(%15, %1) : (tensor<?x256x56x56xf32>, tensor<2xi32>) -> tensor<?x256xf32>

  // Mean should compute reduction over NHWC spatial dimensions.
  // CHECK: %[[MEAN_DIMS:.*]] = "tf.Const"() <{value = dense<[1, 2]> : tensor<2xi32>}>
  // CHECK: %[[MEAN:[0-9]*]] = "tf.Mean"(%[[RELU]], %[[MEAN_DIMS]])

        def v2 = DataAmount.kbytes(20)
        def v3 = DataAmount.kbytes(30)
        def series = new DataSeries([v1, v2, v3])

        expect:
        series.average == v2
        series.median == v2
        series.min == v1
        series.max == v3
        series.standardError == DataAmount.bytes(8360.92)
    }

    def "ignores null values"() {
        def v1 = DataAmount.kbytes(10)