def test_stream(self):
     stream = range(10)
     std_computation = algo.StdDevComputation()
     for value in stream:
         std_computation.add(value)
     mean = float(sum(stream)) / len(stream)
     excepted_std = math.sqrt(
         sum((x - mean)**2 for x in stream) / (len(stream) - 1))
     self.assertEqual(excepted_std, std_computation.result())
Exemplo n.º 2
0
 def __init__(self, criterion_value):
     super(Outliers, self).__init__(criterion_value)
     self.max_outliers = self.criterion_value.get("max", 0)
     # NOTE(msdubov): Having 3 as default is reasonable (need enough data).
     self.min_iterations = self.criterion_value.get("min_iterations", 3)
     self.sigmas = self.criterion_value.get("sigmas", 3.0)
     self.iterations = 0
     self.outliers = 0
     self.threshold = None
     self.mean_comp = streaming_algorithms.MeanComputation()
     self.std_comp = streaming_algorithms.StdDevComputation()
    def test_merge(self):
        single_std = algo.StdDevComputation()

        for val in six.moves.range(100):
            single_std.add(val)

        stds = [algo.StdDevComputation() for _ in six.moves.range(10)]

        for idx, std in enumerate(stds):
            for val in six.moves.range(idx * 10, (idx + 1) * 10):
                std.add(val)

        merged_std = stds[0]
        for std in stds[1:]:
            merged_std.merge(std)

        self.assertEqual(single_std.count, merged_std.count)
        self.assertEqual(single_std.mean, merged_std.mean)
        self.assertEqual(single_std.dev_sum, merged_std.dev_sum)
        self.assertEqual(single_std.result(), merged_std.result())
 def test_two_values(self):
     std_computation = algo.StdDevComputation()
     std_computation.add(10.0)
     std_computation.add(10.0)
     self.assertEqual(0.0, std_computation.result())
 def test_one_value(self):
     std_computation = algo.StdDevComputation()
     std_computation.add(10.0)
     self.assertIsNone(std_computation.result())
 def test_empty_stream(self):
     std_computation = algo.StdDevComputation()
     self.assertIsNone(std_computation.result())
 def test_one_value(self):
     std_computation = algo.StdDevComputation()
     std_computation.add(10.0)
     self.assertRaises(exceptions.RallyException, std_computation.result)
 def test_empty_stream(self):
     std_computation = algo.StdDevComputation()
     self.assertRaises(exceptions.RallyException, std_computation.result)