def initialization_test(self):
"""Testing BaseForecastingMethod initialization."""
class FM1(BaseForecastingMethod):
def __init__(self):
super(FM1, self).__init__(["valuesToForecast"])
def _get_parameter_intervals(self):
return {}
class FM2(BaseForecastingMethod):
def __init__(self):
super(FM2, self).__init__([])
def _get_parameter_intervals(self):
return {}
FM1()
FM2()
BaseForecastingMethod(valuesToForecast=4,
hasToBeNormalized=False,
hasToBeSorted=True,
requiredParameters=[])
BaseForecastingMethod(valuesToForecast=4,
hasToBeNormalized=False,
hasToBeSorted=True)
BaseForecastingMethod(["valuesToForecast"])
BaseForecastingMethod(["valuesToForecast"], valuesToForecast=1)
BaseForecastingMethod([], hasToBeNormalized=True)
def forecast_until_test(self):
"""Testing the forecast_until function."""
for validts in (range(1, 100)):
BaseForecastingMethod(["valuesToForecast"
]).forecast_until(validts, tsformat=None)
BaseForecastingMethod(["valuesToForecast"
]).forecast_until("2012", tsformat="%Y")
def setUp(self):
"""Initializes self.forecastingMethod."""
bfm = BaseForecastingMethod(["parameter_one", "parameter_two"])
bfm._parameterIntervals = {}
bfm._parameterIntervals["parameter_one"] = [0.0, 1.0, False, False]
bfm._parameterIntervals["parameter_two"] = [0.0, 2.0, True, True]
self.bfm = bfm
data = [[0.0, 0.0], [1.1, 0.2], [2.2, 0.6], [3.3, 0.2], [4.4, 0.3], [5.5, 0.5]]
self.timeSeries = TimeSeries.from_twodim_list(data)
self.timeSeries.normalize("second")
def initialization_exception_test(self):
"""Test BaseForecastingMethod initialization for ValueError."""
for valuesToForecast in range(-10, 0):
try:
BaseForecastingMethod(valuesToForecast=valuesToForecast)
except ValueError:
pass
else:
assert False # pragma: no cover
def get_optimizable_parameters_test(self):
"""Test get optimizable parameters."""
# Initialize parameter lists
parameters = ["param1", "param2", "param3", "param4", "param5"]
intervals = {
"param3": [0.0, 1.0, True, True],
"param4": [0.0, 1.0, True, True],
"param5": [0.0, 1.0, True, True],
"param6": [0.0, 1.0, True, True]
}
# initialize BaseForecastingMethod and set some parameter intervals
bfm = BaseForecastingMethod(parameters, valuesToForecast=4, hasToBeNormalized=False, hasToBeSorted=True)
bfm._parameterIntervals = intervals
# check, if the BaseForecastingMethod returns the correct parameters
correctResult = ["param3", "param4", "param5"]
result = sorted(bfm.get_optimizable_parameters())
assert correctResult == result
def get_optimizable_parameters_test(self):
"""Test get optimizable parameters."""
# Initialize parameter lists
parameters = ["param1", "param2", "param3", "param4", "param5"]
intervals = {
"param3": [0.0, 1.0, True, True],
"param4": [0.0, 1.0, True, True],
"param5": [0.0, 1.0, True, True],
"param6": [0.0, 1.0, True, True]
}
# initialize BaseForecastingMethod and set some parameter intervals
bfm = BaseForecastingMethod(parameters,
valuesToForecast=4,
hasToBeNormalized=False,
hasToBeSorted=True)
bfm._parameterIntervals = intervals
# check, if the BaseForecastingMethod returns the correct parameters
correctResult = ["param3", "param4", "param5"]
result = sorted(bfm.get_optimizable_parameters())
assert correctResult == result
def number_of_values_to_forecast_test(self):
"""Test the valid calculation of values to forecast."""
data = [[1.5, 152.0], [2.5, 172.8], [3.5, 195.07200000000003],
[4.5, 218.30528000000004]]
ts = TimeSeries.from_twodim_list(data)
ts.normalize("second")
bfm = BaseForecastingMethod()
bfm.forecast_until(100)
bfm._calculate_values_to_forecast(ts)
assert bfm.get_parameter("valuesToForecast") == 96
def number_of_values_to_forecast_test(self):
"""Test the valid calculation of values to forecast."""
data = [[1.5, 152.0],[2.5, 172.8],[3.5, 195.07200000000003],[4.5, 218.30528000000004]]
ts = TimeSeries.from_twodim_list(data)
ts.normalize("second")
bfm = BaseForecastingMethod()
bfm.forecast_until(100)
bfm._calculate_values_to_forecast(ts)
assert bfm.get_parameter("valuesToForecast") == 96
def calculate_values_to_forecast_exception_test(self):
"""Test for correct handling of illegal TimeSeries instances.
@todo remove NotImplementedError Catch."""
data = [[1.5, 152.0], [2.5, 172.8], [3.5, 195.07200000000003],
[4.5, 218.30528000000004]]
ts = TimeSeries.from_twodim_list(data)
ts.add_entry(3, 1343)
bfm = BaseForecastingMethod()
# nothing has to be done, because forecast_until was never called
bfm._calculate_values_to_forecast(ts)
bfm.forecast_until(134)
try:
bfm._calculate_values_to_forecast(ts)
except ValueError:
pass
else:
assert False # pragma: no cover
ts.sort_timeseries()
try:
bfm._calculate_values_to_forecast(ts)
except ValueError:
pass
else:
assert False # pragma: no cover
ts.normalize("second")
bfm._calculate_values_to_forecast(ts)
def calculate_values_to_forecast_exception_test(self):
"""Test for correct handling of illegal TimeSeries instances.
@todo remove NotImplementedError Catch."""
data = [[1.5, 152.0],[2.5, 172.8],[3.5, 195.07200000000003],[4.5, 218.30528000000004]]
ts = TimeSeries.from_twodim_list(data)
ts.add_entry(3, 1343)
bfm = BaseForecastingMethod()
# nothing has to be done, because forecast_until was never called
bfm._calculate_values_to_forecast(ts)
bfm.forecast_until(134)
try:
bfm._calculate_values_to_forecast(ts)
except ValueError:
pass
else:
assert False # pragma: no cover
ts.sort_timeseries()
try:
bfm._calculate_values_to_forecast(ts)
except ValueError:
pass
else:
assert False # pragma: no cover
ts.normalize("second")
bfm._calculate_values_to_forecast(ts)
