code: def initialize(self, originalTimeSeries, calculatedTimeSeries):
          
          # ErrorMeasure was already initialized.
          if 0 < len(self._errorValues):
              raise StandardError("An ErrorMeasure can only be initialized once.")
  
          # sort the TimeSeries to reduce the required comparison operations
          originalTimeSeries.sort_timeseries()
          calculatedTimeSeries.sort_timeseries()
  
          # Performance optimization
          append      = self._errorValues.append
          appendDate  = self._errorDates.append
          local_error = self.local_error
  
          minCalcIdx  = 0
  
          # calculate all valid local errors
          for orgPair in originalTimeSeries:
              for calcIdx in xrange(minCalcIdx, len(calculatedTimeSeries)):
                  calcPair = calculatedTimeSeries[calcIdx]
  
                  # Skip values that can not be compared
                  if calcPair[0] != orgPair[0]:
                      continue
  
                  append(local_error(orgPair[1:], calcPair[1:]))
                  appendDate(orgPair[0])
  
          # return False, if the error cannot be calculated
          calculatedErrors    = len(filter(lambda item: item is not None, self._errorValues))
          minCalculatedErrors = self._minimalErrorCalculationPercentage * len(originalTimeSeries)
  
          if  calculatedErrors < minCalculatedErrors:
              self._errorValues = []
              self._errorDates = []
              return False
  
          return True
docs: Initializes the ErrorMeasure.
  
          During initialization, all :py:meth:`BaseErrorMeasure.local_errors` are calculated.
  
          :param TimeSeries originalTimeSeries:    TimeSeries containing the original data.
          :param TimeSeries calculatedTimeSeries:    TimeSeries containing calculated data.
              Calculated data is smoothed or forecasted data.
  
          :return:    Return :py:const:`True` if the error could be calculated, :py:const:`False`
              otherwise based on the minimalErrorCalculationPercentage.
          :rtype: boolean
  
          :raise:    Raises a :py:exc:`StandardError` if the error measure is initialized multiple times.