Exemple #1
0
 def test_invalid_mean_with_no_entry_sized_timeseries(self):
     """ Sized Timeseries should throw when calling mean and len == 0. """
     for i, ts_class in SIZED_CONCRETE_CLASSES:
         ts = TimeSeries([], [])
         with self.assertRaises(Exception):
             ts.mean()
         scores.append(('#ts', '%s throws on mean() when len == 0' % i, 1))
def test_unary():
    a = TimeSeries([1, 1.5, 2, 2.5, 10], [0, 2, -1, 0.5, 0])
    assert abs(a) == 2.29128784747792
    assert bool(a) == True
    assert -a == TimeSeries([1.0, 1.5, 2.0, 2.5, 10.0],
                            [-0.0, -2.0, 1.0, -0.5, -0.0])
    assert +a == TimeSeries([1, 1.5, 2, 2.5, 10], [0, 2, -1, 0.5, 0])
Exemple #3
0
def test_iteritems():
    data = [0, 1, 2, 3, 4]
    time = [5, 6, 7, 8, 9]
    ts = TimeSeries(data, time)
    l = ts.iteritems()
    next(l)
    assert next(l) == (6, 1)
Exemple #4
0
def test_itertimes():
    data = [0, 1, 2, 3, 4]  #range(0,5)
    time = [5, 6, 7, 8, 9]  #range(5,10)
    ts = TimeSeries(data, time)
    l = ts.itertimes()
    next(l)
    assert next(l) == 6
Exemple #5
0
def test_invalid_input_eq():
    ts_1 = TimeSeries([1, 2], [3, 4])
    ts_2 = TimeSeries([1, 2, 3], [3, 4, 5])
    with raises(TypeError):
        ts_1 == ([3, 1], [4, 2])
    with raises(ValueError):
        ts_1 == ts_2
Exemple #6
0
def test_setitem():
    data = [4, 5, 6]
    time = [1, 2, 3]
    ts = TimeSeries(data, time)
    index = 0
    val = 0
    ts[index] = val
    assert ts == TimeSeries([0, 5, 6], [1, 2, 3])
Exemple #7
0
def test_interpolation():
    # Simple cases
    c = TimeSeries([1.], [1.2])
    d = ts3.interpolate([1.])
    assert c == d
    assert ts3.interpolate(ts4.times()) == TimeSeries([2.5, 7.5], [1.5, 2.5])
    # Boundary conditions
    assert ts3.interpolate([-100, 100]) == TimeSeries([-100, 100], [1, 3])
Exemple #8
0
 def test_interpolation_against_boundarys(self):
     for i, ts_class in SIZED_CONCRETE_CLASSES:
         ts = TimeSeries([0, 5, 10], [1, 2, 3])
         # Boundary conditions
         ares = ts.interpolate([-100, 100])
         self.assertEqual(list(ares.values()), [1, 3])
         self.assertEqual(list(ares.times()), [-100, 100])
         scores.append(('#ts', '%s interpolate against boundaaryts' % i, 1))
def test_itervalues():
    ten = TimeSeries(range(0, 11), range(0, 11))
    i = ten.itervalues()
    n = next(i)
    assert n == 0
    assert n.dtype == np.int64
    n = next(i)
    assert n == 1
    assert n.dtype == np.int64
def test_contains():
    a = TimeSeries([1, 1.5, 2, 2.5, 10], [0, 2, -1, 0.5, 0])
    assert a.__contains__(1.5) == True
    e3 = ''
    try:
        a.__contains__('monkeys')
    except Exception as e:
        e3 = e
    assert type(e3).__name__ == 'str'
def test_itervalues():
    ten = TimeSeries(range(0,11), range(0,11))  
    i = ten.itervalues()
    n = next(i)
    assert n == 0
    assert n.dtype == np.int64
    n = next(i)
    assert n == 1
    assert n.dtype == np.int64
def test_sub():
    a = TimeSeries([1, 1.5, 2, 2.5, 10], [0, 2, -1, 0.5, 0])
    b = TimeSeries([1, 1.5, 2, 2.5, 10], [1, 2, 3, 4, 5])
    assert a - b == TimeSeries([1.0, 1.5, 2.0, 2.5, 10.0],
                               [-1.0, 0.0, -4.0, -3.5, -5.0])
    assert 3 - a == TimeSeries([1.0, 1.5, 2.0, 2.5, 10.0],
                               [3.0, 1.0, 4.0, 2.5, 3.0])
    assert a - 3 == TimeSeries([1.0, 1.5, 2.0, 2.5, 10.0],
                               [-3.0, -1.0, -4.0, -2.5, -3.0])
def test_contains():
    a = TimeSeries([1, 1.5, 2, 2.5, 10], [0, 2, -1, 0.5, 0])
    assert a.__contains__(1.5) == True
    e3 = ''
    try:
        a.__contains__('monkeys')
    except Exception as e: 
        e3 = e
    assert type(e3).__name__ == 'str'
Exemple #14
0
def test_sub():
    a = TimeSeries([0, 5, 10], [1, 2, 3])
    b = TimeSeries([0, 5, 10], [10, 20, 30])
    c = 100
    d = TimeSeries([0, 1, 2], [1, 2, 3])
    assert b - a == TimeSeries([0, 5, 10], [9, 18, 27])
    assert a - c == TimeSeries([0, 5, 10], [-99, -98, -97])
    with raises(ValueError):
        a - d
Exemple #15
0
 def test_bool_operator_with_nonempty_sized_timeseries(self):
     """ Sized Timeseries with any length > 0 should return True when l2 norm is non-zero. """
     for i, ts_class in SIZED_CONCRETE_CLASSES:
         tsa = TimeSeries([1, 2, 3, 4, 5], [0.1, 0.2, 0.3, 0.4, 0.5])
         tsb = TimeSeries([1], [0.1])
         self.assertTrue(bool(tsa))
         self.assertTrue(bool(tsb))
         scores.append(
             ('#ts', '%s bool should return true for lengths > 0' % i, 1))
Exemple #16
0
 def test_interpolation_with_simple_input(self):
     for i, ts_class in SIZED_CONCRETE_CLASSES:
         ts = TimeSeries([0, 5, 10], [1, 2, 3])
         ares = ts.interpolate([1])
         self.assertEqual(ares.values()[0], 1.2)
         self.assertEqual(ares.times()[0], 1)
         ares = ts.interpolate([2.5, 7.5])
         self.assertEqual(list(ares.values()), [1.5, 2.5])
         self.assertEqual(list(ares.times()), [2.5, 7.5])
         scores.append(('#ts', 'test interpol base', 3))
def test_iteritems():
    ten = TimeSeries(range(0, 11), range(0, 11))
    i = ten.iteritems()
    n = next(i)
    assert n == (0, 0)
    assert len(n) == 2
    assert n[0] == 0
    assert n[1] == 0
    n = next(i)
    assert n == (1, 1)
def test_iteritems():
    ten = TimeSeries(range(0,11), range(0,11))  
    i = ten.iteritems()
    n = next(i)
    assert n == (0, 0)
    assert len(n) == 2
    assert n[0] == 0
    assert n[1] == 0
    n = next(i)
    assert n == (1, 1)
Exemple #19
0
def smoke_test():
    threes = TimeSeries(range(0, 1000, 3))
    fives = TimeSeries(range(0, 1000, 5))

    s = 0
    for i in range(0, 1000):
        if i in threes or i in fives:
            s += i

    print("sum", s)
Exemple #20
0
def test_invalid_input():
    with raises(ValueError):
        TimeSeries([1, 2], [3, 4, 5])
    with raises(TypeError):
        TimeSeries(1, 2)
    with raises(TypeError):
        TimeSeries(1, [1])
    with raises(TypeError):
        TimeSeries([1, 2], 3)
    with raises(ValueError):
        TimeSeries([1, 2], [2, 2])
Exemple #21
0
def test_invalid_input_add():
    ts_1 = TimeSeries([1, 2], [3, 4])
    ts_2 = TimeSeries([1, 2, 3], [3, 4, 5])
    ts_3 = TimeSeries([2, 3], [5, 6])
    arry = [1, 2]
    with raises(ValueError):
        ts_sum = ts_1 + ts_2
    with raises(TypeError):
        ts_sum = ts_1 + arry
    with raises(ValueError):
        ts_sum = ts_1 + ts_3
Exemple #22
0
def test_add():
    c = 100
    d = TimeSeries([0, 1, 2], [1, 2, 3])
    assert ts1 + ts2 == TimeSeries(range(0, 4), [11, 22, 33, 44, 55])
    assert ts1 + c == TimeSeries(range(0, 4), [101, 102, 103, 104, 105])
    with raises(ValueError):
        ts1 + d
    assert ts1 + ts2 == ts2 + ts1
    assert c + ts1 == ts1 + c
    with raises(ValueError):
        d + ts1
Exemple #23
0
def test_mul():
    a = TimeSeries([0, 5, 10], [1, 2, 3])
    b = TimeSeries([0, 5, 10], [10, 20, 30])
    c = 100
    d = TimeSeries([0, 1, 2], [1, 2, 3])
    assert a * b == TimeSeries([0, 5, 10], [10, 40, 90])
    assert a * c == TimeSeries([0, 5, 10], [100, 200, 300])
    with raises(ValueError):
        a * d
    assert a * b == b * a
    assert c * a == a * c
    with raises(ValueError):
        d * a
Exemple #24
0
def test_pype4():
    time = []
    values = []

    for x in range(100):
        time.append(x)
        values.append(x - 50)
    a = TimeSeries(time, values)

    ast = parser.parse(input1, lexer=lexer)

    # Semantic analysis
    ast.walk(CheckSingleAssignment())
    ast.walk(CheckSingleIOExpression())
    syms = ast.walk(SymbolTableVisitor())
    ast.walk(CheckUndefinedVariables(syms))

    # Translation
    ir = ast.mod_walk(LoweringVisitor(syms))

    ir.flowgraph_pass(AssignmentEllision())
    ir.flowgraph_pass(DeadCodeElimination())
    ir.topological_flowgraph_pass(InlineComponents())

    # PCode Generation
    pcodegen = PCodeGenerator()
    ir.flowgraph_pass(pcodegen)
    pcodes = pcodegen.pcodes
    standardized_TS = pcodes['standardize'].run(a)

    assert (round(standardized_TS.mean(), 7) == 0)
    assert (round(standardized_TS.std() - 1, 7) == 0)
Exemple #25
0
 def test_invalid_multiplication_with_inconsistent_sizes(self):
     """ Sized Timeseries should throw when multiplying a differently-sized time-series. """
     for i, ts_class in SIZED_CONCRETE_CLASSES:
         tsa = TimeSeries([1, 2, 3, 4, 5], [0.1, 0.2, 0.3, 0.4, 0.5])
         tsb = TimeSeries([1, 2, 3], [0.5, 0.2, 0.9])
         tsc = TimeSeries([], [])
         with self.assertRaises(ValueError):
             tsa * tsb
         with self.assertRaises(ValueError):
             tsa * tsc
         with self.assertRaises(ValueError):
             tsb * tsc
         scores.append((
             '#ts',
             '%s class should throw when multiplying two differently-sized timeseries'
             % i, 1))
Exemple #26
0
def test_setitem_index_error():
    data = [4, 5, 6]
    time = [1, 2, 3]
    ts = TimeSeries(data, time)
    index = 5
    val = 0
    with raises(IndexError):
        ts[index] = val
Exemple #27
0
 def test_invalid_equality_check_with_different_length_sized_timeseries(
         self):
     """ Sized Timeseries with the different sizes should throw error. """
     for i, ts_class in SIZED_CONCRETE_CLASSES:
         tsa = TimeSeries([1, 2, 3, 4], [0.1, 0.2, 0.3, 0.4])
         tsb = TimeSeries([1, 2, 3], [0.5, 0.2, 0.9])
         tsc = TimeSeries([], [])
         with self.assertRaises(ValueError):
             tsa == tsb
         with self.assertRaises(ValueError):
             tsa == tsc
         with self.assertRaises(ValueError):
             tsb == tsc
         scores.append((
             '#ts',
             '%s class equality check should throw when ts classes have different sizes'
             % i, 1))
Exemple #28
0
 def test_bool_operator_with_nonempty_sized_timeseries(self):
     """ Sized Timeseries with any length > 0 should return False when l2 norm is zero. """
     for i, ts_class in SIZED_CONCRETE_CLASSES:
         ts = TimeSeries([0, 1, 2, 3], [0, 0, 0, 0])
         self.assertFalse(bool(ts))
         scores.append(
             ('#ts', '%s bool should return false when l2 norm is 0' % i,
              1))
Exemple #29
0
 def test_valid_init(self):
     """ All the sized timeseries __init__ constructors should take
         any sequence-like thing. Unsized should take a generator.
     """
     # NOTE: Depending on intepretation, this might be safe
     ts = TimeSeries([0], [0])
     ats = ArrayTimeSeries([0], [0])
     sts = SimulatedTimeSeries(zero_generator)
     scores.append(('#ts', 'init valid ts, ats, sts', 3))
Exemple #30
0
def tsmaker(m, s, j):
    "returns metadata and a time series in the shape of a jittered normal"
    meta = {}
    meta['order'] = int(
        np.random.choice([-5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5]))
    meta['blarg'] = int(np.random.choice([1, 2]))
    t = np.arange(0.0, 1.0, 0.01)
    v = norm.pdf(t, m, s) + j * np.random.randn(100)
    return meta, TimeSeries(t, v)
def test_divide():
    a = TimeSeries([1, 2, 3, 10], [5, 10, 15, 20])
    b = TimeSeries([1, 2, 3, 10], [15, 100, 150, 200])
    c = TimeSeries([1, 2, 3], [15, 100, 150])

    assert (a / 5) == TimeSeries([1, 2, 3, 10], [1.0, 2.0, 3.0, 4.0])
    assert (b / a) == TimeSeries([1, 2, 3, 10], [3.0, 10.0, 10.0, 10.0])

    e3 = ''
    try:
        test = c / a
    except Exception as e:
        e3 = e
    assert type(e3).__name__ == 'ValueError'

    e3 = ''
    try:
        test = c / complex(1)
    except Exception as e:
        e3 = e
    assert type(e3).__name__ == 'AttributeError'
Exemple #32
0
 def test_valid_nonempty_str_and_repr(self):
     """ All concrete classes should have a __str__() and __repr__(). Repeats are acceptable. """
     ts = TimeSeries([0], [0])
     ats = ArrayTimeSeries([0], [0])
     sts = SimulatedTimeSeries(zero_generator)
     for ts_class in [ts, ats, sts]:
         dunder_str = str(ts_class)
         dunder_repr = repr(ts_class)
         self.assertNotEqual(dunder_str, '')
         self.assertNotEqual(dunder_repr, '')
     scores.append(
         ('#ts', 'all concrete classes should have non-empty str and repr',
          1))
Exemple #33
0
 def test_valid_mean_with_two_entry_sized_timeseries(self):
     """ Sized Timeseries should return mean when len > 1. """
     for i, ts_class in SIZED_CONCRETE_CLASSES:
         tsa = TimeSeries([1, 2], [1, 2])
         tsb = TimeSeries([1, 2, 3, 4], [1, 2, 3, 4])
         self.assertEqual(tsa.mean(), 1.5)
         self.assertEqual(tsb.mean(), np.array([1, 2, 3, 4]).mean())
         scores.append(('#ts', '%s valid mean when len > 1' % i, 1))
def test_interpolate():
    a = TimeSeries([1, 1.5, 2, 2.5, 10], [0, 2, -1, 0.5, 0])
    assert a.interpolate([2]) == TimeSeries([2],[-1])
def test_iter():
    ten = TimeSeries(range(0,11), range(0,11))  
    i = ten.__iter__()
    n = next(i)
    assert n == 0
    assert n.dtype == np.int64
def test_median():
    median = TimeSeries(range(0,3), range(0,3))    
    assert median.median() == 1
def test_std():
    ten = TimeSeries([1, 2, 3, 4, 5], [600, 470, 170, 430, 300]) 
    print(ten.std())
    assert int(ten.std()) == 147
def test_mean():
    ten = TimeSeries(range(0,11), range(0,11))    
    assert ten.mean() == 5
def test_items():
    a = TimeSeries([1, 1.5, 2, 2.5, 10, 11], [0, 2, -1, 0.5, 0, 0]) 
    test = a.items()

    assert test == [(1.0, 0.0), (1.5, 2.0), (2.0, -1.0), (2.5, 0.5), (10.0, 0.0), (11.0, 0.0)]
def test_calling():
    a = TimeSeries([1, 1.5, 2, 2.5, 10], [0, 2, -1, 0.5, 0])
    assert a.times() == [1, 1.5, 2, 2.5, 10]
    assert a.values() == [0, 2, -1, 0.5, 0]
def test_interpolation():
    a = TimeSeries([0,5,10], [1,2,3])
    b = TimeSeries([2.5,7.5], [100, -100])
    assert (a.interpolate([1]) == TimeSeries([1],[1.2]))
    assert (a.interpolate(b.times()) == TimeSeries([2.5,7.5], [1.5, 2.5]))
    assert (a.interpolate([-100,100]) == TimeSeries([-100,100], [1,3]))