def test_constant_energy(self):
        """Test constant energy preprocessing on a more complicated matrix."""
        ts = [TimeSeries(), TimeSeries(), TimeSeries()]

        ts[0].array.resize(3)
        ts[0].array[0] = (np.uint32(1), np.float32(2.0))
        ts[0].array[1] = (np.uint32(2), np.float32(2.0))
        ts[0].array[2] = (np.uint32(3), np.float32(0.0))

        ts[1].array.resize(3)
        ts[1].array[0] = (np.uint32(1), np.float32(0.0))
        ts[1].array[1] = (np.uint32(2), np.float32(1.0))
        ts[1].array[2] = (np.uint32(3), np.float32(1.0))

        ts[2].array.resize(3)
        ts[2].array[0] = (np.uint32(1), np.float32(3.0))
        ts[2].array[1] = (np.uint32(2), np.float32(3.0))
        ts[2].array[2] = (np.uint32(3), np.float32(3.0))

        aggregated = ts[0] + ts[1] + ts[2]

        energies = solve_constant_energy(aggregated.powers,
                                         [t.indicators() for t in ts])

        energies_test = [np.float32(2.0), np.float32(1.0), np.float(3.0)]

        self.assertTrue(np.allclose(energies_test, energies[0],
                                    atol=np.float32(1e-3)))
def apply_preprocess(aggregated, devices, method, threshold=np.float32(0.0)):
    """
    Apply the given preprocessing method to the devices.
    """
    if method == 'raw':
        return

    indicators = [d.indicators(threshold) for d in devices]

    if method == 'constant':
        (energies, _) = solve_constant_energy(aggregated, indicators)

        for (e, d) in zip(energies, devices):
            log.info('Setting constant energy %s for device %s.' % (e, d.name))
            d.powers = e * d.indicators(np.float32(10))

    elif method == 'interval':
        energy_dict = confidence_estimator(aggregated, devices, sort_data,
                                           threshold)

        for d in devices:
            log.info('Setting constant energy %s for device %s.' %
                     (energy_dict[d.name], d.name))
            d.powers = energy_dict[d.name] * d.indicators(np.float32(10))

    elif method == 'edge':
        energy_dict = confidence_estimator(aggregated, devices,
                                           get_changed_data, threshold)

        for d in devices:
            log.info('Setting constant energy %s for device %s.' %
                     (energy_dict[d.name], d.name))
            d.powers = energy_dict[d.name] * d.indicators(np.float32(10))

    elif method == 'markov':
        agg = dict((time, power) for (time, power) in enumerate(aggregated))
        device = [i for i in xrange(len(devices))]
        active = {}
        for i, d in enumerate(devices):
            active[(i,0)] = 0
            for t, ind in enumerate(d.indicators(threshold)):
                active[(i,t+1)] = ind * 1

        for d in device:
            print devices[d].name
            try:
                p = fit_data(agg, d, active, 3, device)
                for (t, power) in p.iteritems():
                    devices[d].powers[t-1] = power
            except KeyError:
                devices[d].powers = np.zeros(len(devices[d].powers))