def performAction(self, action):
     """ perform an action on the world that changes it's internal state (maybe stochastically) 
         @param action: an action that should be executed in the Environment, by an agent. 
         @type action: tuple: (agentID, action value)
         @note: This function is abstract and has to be implemented.
     """
     abstractMethod()

 def performAction(self, action):
     """ perform an action on the world that changes it's internal state (maybe stochastically) 
         @param action: an action that should be executed in the Environment. 
         @type action: by default, this is assumed to be a numpy array of doubles
         @note: This function is abstract and has to be implemented.
     """
     abstractMethod()

 def getSensors(self):
     """ the currently visible state of the world (the observation may be 
         stochastic - repeated calls returning different values)
         @rtype: by default, this is assumed to be a numpy array of doubles
         @note: This function is abstract and has to be implemented.
     """
     abstractMethod()

 def _getCombinedDistribution(self, distributionMatrix, numClassifiers):
     abstractMethod()

 def combine(self, classifiers, input):
     """Receives list of trained classifers """
     abstractMethod()

 def color(self):                                #Tuple of r, g, b
     abstractMethod()

 def _learnStep(self):
     """ The core method to be implemented by all subclasses. """
     abstractMethod()        

 def getAction(self):
     """ Return a chosen action.
         :rtype: by default, this is assumed to ba a numpy array of doubles.
         :note: This method is abstract and needs to be implemented.
     """
     abstractMethod()

 def updateState(self, env, dt):                 #dt in seconds
     abstractMethod()        

 def f(self, x):
     """ The function itself, to be defined by subclasses """
     abstractMethod()

 def distributionLength(self):
     abstractMethod()

 def updater(self, pos, neg, poshb, neghb, posvb, negvb):
     abstractMethod()

 def _forwardImplementation(self, inbuf, outbuf):
     """Actual forward transformation function. To be overwritten in
     subclasses."""
     abstractMethod()

 def sampler(self, probabilities):
     abstractMethod()

 def removeFromEnv(self, env):                   #Called upon removing
     abstractMethod()    

 def draw(self, env):
     abstractMethod()

 def _build(self, dataset):
     abstractMethod()

 def initPopulation(self):
     """ initialize the population """
     abstractMethod()

 def getDistribution(self, input):
     """Returns NumPy array of posterior distributions for each class."""
     abstractMethod()

 def position(self):
     abstractMethod()