diff --git a/include/rosa/agent/State.hpp b/include/rosa/agent/State.hpp
index 4bed255..ad47872 100644
--- a/include/rosa/agent/State.hpp
+++ b/include/rosa/agent/State.hpp
@@ -1,268 +1,312 @@
 //===-- rosa/agent/State.hpp ----------------------------*- C++ -*-===//
 //
 //                                 The RoSA Framework
 //
 //===----------------------------------------------------------------------===//
 ///
 /// \file rosa/agent/State.hpp
 ///
 /// \author Maximilian Götzinger (maximilian.goetzinger@tuwien.ac.at)
 ///
 /// \date 2019
 ///
 /// \brief Definition of *state* *functionality*.
 ///
 //===----------------------------------------------------------------------===//
 
 #ifndef ROSA_AGENT_STATE_HPP
 #define ROSA_AGENT_STATE_HPP
 
 #include "rosa/agent/FunctionAbstractions.hpp"
 #include "rosa/agent/Functionality.h"
 #include "rosa/agent/History.hpp"
 
+#include <cstdarg>
+
 namespace rosa {
 namespace agent {
 
 /// State conditions defining how the condition of a \c rosa::agent::State is
 /// saved in \c rosa::agent::StateInformation.
 enum class VariableStateCondition {
   STABLE,   ///< The state is stable
   DRIFTING, ///< The state is drifting
   UNKNOWN   ///< The state is unknown
 };
 
 template <typename CONFDATATYPE> struct StateInformation {
   // Make sure the actual type arguments are matching our expectations.
   STATIC_ASSERT((std::is_arithmetic<CONFDATATYPE>::value),
                 "confidence type is not to arithmetic");
 
   /// The state ID saved as an unsigned integer number
   unsigned int StateID;
   /// The StateConfidence shows the overall confidence value of the state.
   CONFDATATYPE StateConfidence;
   /// The VariableStateCondition shows the condition of a state (stable or
   /// drifting)
   VariableStateCondition VariableStateCondition;
   /// The StateIsValid shows whether a state is valid or invalid. In this
   /// context, valid means that enough samples which are in close proximitry
   /// have been inserted into the state.
   bool StateIsValid;
   /// The StateJustGotValid shows whether a state got valid (toggled from
   /// invalid to valid) during the current inserted sample.
   bool StateJustGotValid;
   /// The StateIsValidAfterReentrance shows whether a state is valid after the
   /// variable changed back to it again.
   bool StateIsValidAfterReentrance;
 };
 
 // @Benedikt: now there are 4 datatypes. Do you think we can merge DISTDATATYPE
 // and DABDATATYPE somehow?
 /// \tparam INDATATYPE type of input data, \tparam CONFDATATYPE type of
 /// data in that the confidence values are given, \param DISTDATATYPE type of
 /// the relative distance, \tparam DABDATATYPE type of data in which DABs are
 /// saved.
 template <typename INDATATYPE, typename CONFDATATYPE, typename DISTDATATYPE,
           typename DABDATATYPE>
 class State : public Functionality {
 
   // Make sure the actual type arguments are matching our expectations.
   STATIC_ASSERT((std::is_arithmetic<INDATATYPE>::value),
                 "input data type not arithmetic");
   STATIC_ASSERT((std::is_arithmetic<CONFDATATYPE>::value),
                 "DAB storage type is not to arithmetic");
 
 private:
   // For the convinience to write a shorter data type name
   using PartFuncPointer =
       std::shared_ptr<PartialFunction<INDATATYPE, CONFDATATYPE>>;
   using StepFuncPointer =
       std::shared_ptr<StepFunction<INDATATYPE, CONFDATATYPE>>;
   using StateInfoPtr = std::shared_ptr<StateInformation<CONFDATATYPE>>;
 
   /// StateInfo is a struct StateInformation that contains information about the
   /// current state.
   StateInfoPtr StateInfo;
 
   /// The FuzzyFunctionSampleMatches is the fuzzy function that gives the
   /// confidence how good the new sample matches another sample in the sample
   /// history.
   PartFuncPointer FuzzyFunctionSampleMatches;
   /// The FuzzyFunctionSampleMatches is the fuzzy function that gives the
   /// confidence how bad the new sample matches another sample in the sample
   /// history.
   PartFuncPointer FuzzyFunctionSampleMismatches;
   /// The FuzzyFunctionSampleMatches is the fuzzy function that gives the
   /// confidence how many samples from the sampe history match the new sample.
   StepFuncPointer FuzzyFunctionNumOfSamplesMatches;
   /// The FuzzyFunctionSampleMatches is the fuzzy function that gives the
   /// confidence how many samples from the sampe history mismatch the new
   /// sample.
   StepFuncPointer FuzzyFunctionNumOfSamplesMismatches;
 
   /// The FuzzyFunctionSignalIsDrifting is the fuzzy function that gives the
   /// confidence how likely it is that the signal (resp. the state of a signal)
   /// is drifting.
   PartFuncPointer FuzzyFunctionSignalIsDrifting;
   /// The FuzzyFunctionSignalIsStable is the fuzzy function that gives the
   /// confidence how likely it is that the signal (resp. the state of a signal)
   /// is stable (not drifting).
   PartFuncPointer FuzzyFunctionSignalIsStable;
 
-  /// XXX - explain
+  /// SampleHistory is a history in that the last sample values are stored.
   DynamicLengthHistory<INDATATYPE, HistoryPolicy::FIFO> SampleHistory;
-  /// XXX - explain
+  /// DAB is a (usually) small history of the last sample values of which a
+  /// average is calculated if the DAB is full.
   DynamicLengthHistory<INDATATYPE, HistoryPolicy::SRWF> DAB;
-  /// XXX - explain
+  /// DABHistory is a history in that the last DABs (to be exact, the averages
+  /// of the last DABs) are stored.
   DynamicLengthHistory<DABDATATYPE, HistoryPolicy::LIFO> DABHistory;
 
   /// The StateIsValid shows whether a state is valid or invalid. In this
   /// context, valid means that enough samples which are in close proximitry
   /// have been inserted into the state.
   bool StateIsValid;
   /// The StateIsValidAfterReentrance shows whether a state is valid after the
   /// variable changed back to it again.
   bool StateIsValidAfterReentrance;
 
 public:
   /// Creates an instance by setting all parameters
   State(unsigned int StateID, PartFuncPointer FuzzyFunctionSampleMatches,
         PartFuncPointer FuzzyFunctionSampleMismatches,
         StepFuncPointer FuzzyFunctionNumOfSamplesMatches,
         StepFuncPointer FuzzyFunctionNumOfSamplesMismatches,
         PartFuncPointer FuzzyFunctionSignalIsDrifting,
         PartFuncPointer FuzzyFunctionSignalIsStable,
         unsigned int sampleHistorySize, unsigned int DABSize,
         unsigned int DABHistorySize) noexcept
       : StateInfo(StateID, 0, VariableStateCondition::UNKNOWN, false, false),
         SampleHistory(sampleHistorySize), DAB(DABSize),
         DABHistory(DABHistorySize),
         FuzzyFunctionSampleMatches(FuzzyFunctionSampleMatches),
         FuzzyFunctionSampleMismatches(FuzzyFunctionSampleMismatches),
         FuzzyFunctionNumOfSamplesMatches(FuzzyFunctionNumOfSamplesMatches),
         FuzzyFunctionNumOfSamplesMismatches(
             FuzzyFunctionNumOfSamplesMismatches),
         FuzzyFunctionSignalIsDrifting(FuzzyFunctionSignalIsDrifting),
         FuzzyFunctionSignalIsStable(FuzzyFunctionSignalIsStable) {}
 
   /// Destroys \p this object.
   ~State(void) = default;
 
   void leaveState(void) {
     DAB.clear();
     StateIsValidAfterReentrance = false;
   }
 
   void insertSample(INDATATYPE Sample) {
     SampleHistory.addEntry(Sample);
 
     DAB.addEntry(Sample);
     if (DAB.full()) {
       DABDATATYPE AvgOfDAB = DAB.template average<DABDATATYPE>();
       DABHistory.addEntry(AvgOfDAB);
       DAB.clear();
     }
 
     // TODO @Benedikt: stepfunction auch andere richtung
     FuzzyFunctionNumOfSamplesMatches->setRightLimit(
         SampleHistory->numberOfEntries());
     FuzzyFunctionNumOfSamplesMismatches->setRightLimit(
         SampleHistory->numberOfEntries());
 
     // TODO: calculate whether state is valid and properly set StateIsValid,
     // StateJustGotValid, StateIsValidAfterReentrance
 
     // TODO: check actual state whether it drifts
 
     // TODO: write in StateInfo
   }
 
   // TODO: check this function again
   CONFDATATYPE
   confSampleMatchesState(INDATATYPE sample) {
 
     DISTDATATYPE RelDist;
     CONFDATATYPE HighestConf = 0;
 
     // QUESTION: should I also use a history (array) for that?
     std::vector<DISTDATATYPE> RelDistHistValuesAndSampleValue;
 
     for (auto &hs : SampleHistory) {
       RelDist = relativeDistance(sample, hs);
       RelDistHistValuesAndSampleValue.push_back(RelDist);
     }
 
     sort(begin(RelDistHistValuesAndSampleValue),
          end(RelDistHistValuesAndSampleValue));
 
-    // TODO (future): to accelerate -> don't start with 1
+    // TODO (future): to accelerate -> don't start with 1 start with some higher
+    // number because a low number (i guess lower than 5) will definetely lead
+    // to a low confidence. except the history is not full.
     for (unsigned int numOfHistSamplesIncluded = 1;
          numOfHistSamplesIncluded <= RelDistHistValuesAndSampleValue.size();
          numOfHistSamplesIncluded++) {
 
       CONFDATATYPE LowestConfOfSamplesIncluded = 1;
       unsigned int HistSampleCounter = 0;
 
       for (auto &D : RelDistHistValuesAndSampleValue) {
         if (HistSampleCounter >= numOfHistSamplesIncluded)
           break;
 
         CONFDATATYPE confRelDist;
 
-        // TODO: check if infinity check is needed here?
         if (std::isinf(D) == false) {
           confRelDist = FuzzyFunctionSampleMatches(D);
         } else {
           confRelDist = 0;
         }
 
         // std::min is equal to Fuzzy AND -> maybe using
         LowestConfOfSamplesIncluded =
-            std::min(LowestConfOfSamplesIncluded, confRelDist);
+            fuzzyAND(LowestConfOfSamplesIncluded, confRelDist);
         HistSampleCounter++;
       }
 
-      // std::max is equal to Fuzzy OR
-      // TODO: change old-style cast to one of these reinterpret_cast,
+      // @benedikt: do you think my fuzzyOR function does the same as the next
+      // out-commented lines?
+      // HighestConf = std::max(HighestConf,
+      // std::max(LowestConfOfSamplesIncluded,
+      // FuzzyFunctionNumOfSamplesMatches((CONFDATATYPE)HistSampleCounter)));
+      // @benedikt: TODO: change old-style cast to one of these
+      // reinterpret_cast,
       // static_cast, dynamic_cast or const_cast. Which should I use? Or should
       // the HistSampleCounter variable already be CONFDATATYPE type?
-      HighestConf =
-          std::max(HighestConf, std::max(LowestConfOfSamplesIncluded,
-                                         FuzzyFunctionNumOfSamplesMatches(
-                                             (CONFDATATYPE)HistSampleCounter)));
+      fuzzyOR(
+          HighestConf, LowestConfOfSamplesIncluded,
+          FuzzyFunctionNumOfSamplesMatches((CONFDATATYPE)HistSampleCounter));
     }
   }
 
   CONFDATATYPE
   confSampleMismatchesState(INDATATYPE sample) {
     // TODO: do it in the same way as confSampleMatchesState(INDATATYPE sample)
   }
 
   /// Gives information about the current state.
   ///
   /// \return a struct StateInformation that contains information about the
   /// current state.
   StateInfoPtr stateInformation(void) { return StateInfo; }
 
 private:
+  // copied from the internet and adapted
+  // (https://stackoverflow.com/questions/1657883/variable-number-of-arguments-in-c)
+  CONFDATATYPE fuzzyAND(CONFDATATYPE n_args, ...) {
+    va_list ap;
+    va_start(ap, n_args);
+    CONFDATATYPE min = va_arg(ap, CONFDATATYPE);
+    for (CONFDATATYPE i = 2; i <= n_args; i++) {
+      CONFDATATYPE a = va_arg(ap, CONFDATATYPE);
+      //@benedikt: instead of the if, I could use "std::min"
+      if (a < min)
+        min = a;
+    }
+    va_end(ap);
+    return min;
+  }
+
+  // copied from the internet
+  // (https://stackoverflow.com/questions/1657883/variable-number-of-arguments-in-c)
+  CONFDATATYPE fuzzyOR(CONFDATATYPE n_args, ...) {
+    va_list ap;
+    va_start(ap, n_args);
+    CONFDATATYPE max = va_arg(ap, CONFDATATYPE);
+    for (CONFDATATYPE i = 2; i <= n_args; i++) {
+      CONFDATATYPE a = va_arg(ap, CONFDATATYPE);
+      //@benedikt: instead of the if, I could use "std::max"
+      if (a > max)
+        max = a;
+    }
+    va_end(ap);
+    return max;
+  }
+
   // TODO: Ask David where to move that function (or if it should stay here).
   DISTDATATYPE relativeDistance(INDATATYPE SampleValue,
                                 INDATATYPE HistoryValue) {
     DISTDATATYPE Dist = HistoryValue - SampleValue;
 
     if (Dist == 0) {
       return 0;
     } else {
       Dist = Dist / SampleValue;
       if (Dist < 0) {
+        //@benedikt: I guess this multiplication here should not be done because
+        // it could be that the distance fuzzy functions are not symetrical
+        //(negative and positive side)
         Dist = Dist * (-1);
       }
       return (Dist);
     }
   }
 };
 
 } // End namespace agent
 } // End namespace rosa
 
 #endif // ROSA_AGENT_STATE_HPP