Unit tests

sunny.py

@@ -23,12 +23,13 @@
 
 
 class Generative:
-    def __init__(self, my_generator, seed=42):
+    def __init__(self, my_generator, seed=42, initial_value=-20):
         self.my_generator = my_generator
         self.step = 0
-        self.cur_val = -20
+        self.cur_val = initial_value
         self.randomness = np.random.RandomState(seed)
         self.seed = seed
+        self.initial_value = initial_value
 
     def next(self):
         self.step += 1
@@ -39,7 +40,7 @@ def next(self):
     def reset(self):
         self.randomness = np.random.RandomState(self.seed)
         self.step = 0
-        self.cur_val = 0
+        self.cur_val = self.initial_value
 
 
 def ar(p, base_value, noise_maker, to_add=10000):
@@ -142,7 +143,7 @@ def mFFTe(arr, norm=-1, ep1=29, radius1=3, ep2=183, radius2=2, silent=True):
     """
     Parameters:
         arr : list
-            Массив, для которого считается Фурье и энергия в тояках ep1 и ep2
+            Массив, для которого считается Фурье и энергия в точках ep1 и ep2
         norm : double
             Число для нормировки, стандартное - длина массива
         ep1: double
@@ -218,7 +219,7 @@ def in_delta(x, center, d):
     """
     Проверяет, находится ли точка x на расстоянии не более d от center
     """
-    return np.abs(x - center) < d
+    return np.abs(x - center) <= d
 
 
 def in_spring_delta(x, d):

test_sunny.py

@@ -0,0 +1,87 @@
+from unittest import TestCase
+
+import numpy
+import matplotlib.pyplot as plt
+
+import sunny
+
+
+class Test(TestCase):
+
+    def test_in_spring_delta(self):
+        self.assertFalse(sunny.in_spring_delta(1, 5))
+        self.assertTrue(sunny.in_spring_delta(79, 0))
+        self.assertFalse(sunny.in_spring_delta(70, 5))
+
+    def test_in_autumn_delta(self):
+        self.assertFalse(sunny.in_autumn_delta(260, 2))
+        self.assertTrue(sunny.in_autumn_delta(260, 10))
+        self.assertTrue(sunny.in_autumn_delta(265, 1))
+
+
+class TestGenerative(TestCase):
+
+    def test1(self):
+        def foo1(step, prev, gen):
+            return prev * 2 + 10
+
+        generator = sunny.Generative(foo1)
+        self.assertEqual(-30, generator.next())
+        self.assertEqual(-50, generator.next())
+        generator.reset()
+        self.assertEqual(-30, generator.next())
+
+    def test2(self):
+        def foo(step, prev, gen):
+            return step * prev
+
+        generator = sunny.Generative(foo)
+        self.assertEqual(-20, generator.next())
+        self.assertEqual(-40, generator.next())
+        self.assertEqual(-120, generator.next())
+
+    def test3(self):
+        def foo(step, prev, gen):
+            return gen.normal(3, 0.5)
+
+        generator = sunny.Generative(foo)
+        summ = 0
+        n = 1000000
+        for i in range(n):
+            summ += generator.next()
+        mean = summ / n
+        self.assertAlmostEqual(abs(3.0 - mean), 0, delta=1e-3)
+
+
+class Test(TestCase):
+    def test_m_fft(self):
+        freq = 2 * numpy.pi / 123
+        n = 100000
+        amp_expected = 13
+        arr = [5 + numpy.sin(freq * i) * amp_expected * 2 for i in range(n)]
+        amps, n1 = sunny.mFFT(arr, draw=False, return_pair=True)
+        eps = 1e-2
+        amp_actual = amps[(n1 - 123) < eps].max()
+        self.assertAlmostEqual(amp_expected, amp_actual, delta=eps)
+
+    def test_m_ffte(self):
+        freq1 = 2 * numpy.pi / 27
+        freq2 = 2 * numpy.pi / 183
+        n = 108 * 183
+        arr = [numpy.sin(freq1 * i) + numpy.sin(freq2 * i) for i in range(n)]
+        amps, en1, en2, relations = sunny.mFFTe(arr, ep1=27, ep2=183, radius1=1, radius2=2)
+        self.assertAlmostEqual(0.5, en1, delta=1e-2)
+        self.assertAlmostEqual(0.5, en2, delta=1e-2)
+
+
+class Test(TestCase):
+    def test_imitate_dst_new(self):
+        def foo(prev, step, gen):
+            return step + prev
+        generator = sunny.Generative(foo, initial_value=0)
+        res = sunny.imitate_Dst_new(generator, 10)
+        self.assertEqual(1, res[0])
+        self.assertEqual(3, res[1])
+        self.assertEqual(6, res[2])
+        self.assertEqual(10, res[3])
+        self.assertEqual(15, res[4])