diff --git a/src/automata_operation.hh b/src/automata_operation.hh
index 2862afa..f573196 100644
--- a/src/automata_operation.hh
+++ b/src/automata_operation.hh
@@ -3,6 +3,7 @@
 #include "automaton.hh"
 #include "common_types.hh"
 #include "parametric_timing_constraint.hh"
+#include "timing_constraint.hh"
 #include <ostream>
 #include <ppl.hh>
 
@@ -261,7 +262,7 @@ concatenate(TimedAutomaton<StringConstraint, NumberConstraint, TimingConstraint,
     for (auto &[label, transitions]: sourceState->next) {
       for (auto &transition: transitions) {
         // Update the guard to include the new clock variable
-        if constexpr (std::is_same_v<TimingConstraint, std::vector<::TimingConstraint>>) {
+        if constexpr (is_vector_of_timingconstraint_v<TimingConstraint>) {
           transition.guard = adjustDimension(transition.guard, left.clockVariableSize);
         } else if constexpr (std::is_same_v<TimingConstraint, ParametricTimingConstraint>) {
           transition.guard = adjustDimension(transition.guard, left.clockVariableSize + left.parameterSize);
@@ -358,8 +359,9 @@ timeRestriction(TimedAutomaton<StringConstraint, NumberConstraint, TimingConstra
 
   bool acceptEmpty = acceptsEmptyWord(given);
 
-  if constexpr (std::is_same_v<TimingConstraint, std::vector<::TimingConstraint>>) {
-    TimingValuation clockValuation(given.clockVariableSize, 0);
+  if constexpr (is_vector_of_timingconstraint_v<TimingConstraint>) {
+    using TimeStamp = timingconstraint_timestamp_t<TimingConstraint>;
+    TimingValuation<TimeStamp> clockValuation(given.clockVariableSize, 0);
     acceptEmpty = acceptEmpty && eval(clockValuation, guard);
   }
   if constexpr (std::is_same_v<TimingConstraint, ParametricTimingConstraint>) {
@@ -375,7 +377,7 @@ timeRestriction(TimedAutomaton<StringConstraint, NumberConstraint, TimingConstra
   auto newFinalState =
       std::make_shared<AutomatonState<StringConstraint, NumberConstraint, TimingConstraint, Update>>(true);
   given.states.push_back(newFinalState);
-  if constexpr (std::is_same_v<TimingConstraint, std::vector<::TimingConstraint>>) {
+  if constexpr (is_vector_of_timingconstraint_v<TimingConstraint>) {
     guard = adjustDimension(guard, given.clockVariableSize); // Adjust the guard to include the new clock variable
   }
   if constexpr (std::is_same_v<TimingConstraint, ParametricTimingConstraint>) {
@@ -389,7 +391,7 @@ timeRestriction(TimedAutomaton<StringConstraint, NumberConstraint, TimingConstra
       std::vector<AutomatonTransition<StringConstraint, NumberConstraint, TimingConstraint, Update>> newTransitions;
       for (auto it = transitions.begin(); it != transitions.end();) {
         // Update the guard to include the new clock variable
-        if constexpr (std::is_same_v<TimingConstraint, std::vector<::TimingConstraint>>) {
+        if constexpr (is_vector_of_timingconstraint_v<TimingConstraint>) {
           it->guard = adjustDimension(it->guard, given.clockVariableSize);
         }
         if constexpr (std::is_same_v<TimingConstraint, ParametricTimingConstraint>) {
@@ -480,7 +482,7 @@ addConstraintToAllTransitions(TimedAutomaton<StringConstraint, NumberConstraint,
 
   TimingConstraint adjustedConstraint = constraint;
   // Ensure the constraint has the correct dimension for the automaton
-  if constexpr (std::is_same_v<TimingConstraint, std::vector<::TimingConstraint>>) {
+  if constexpr (is_vector_of_timingconstraint_v<TimingConstraint>) {
     adjustedConstraint = adjustDimension(constraint, automaton.clockVariableSize);
   } else if constexpr (std::is_same_v<TimingConstraint, ParametricTimingConstraint>) {
     adjustedConstraint = adjustDimension(constraint, automaton.parameterSize + automaton.clockVariableSize);
@@ -529,4 +531,4 @@ adjustAllDimensions(TimedAutomaton<StringConstraint, NumberConstraint, TimingCon
   }
 
   return automaton;
-}
\ No newline at end of file
+}
diff --git a/src/automaton.hh b/src/automaton.hh
index f350d51..1db254f 100644
--- a/src/automaton.hh
+++ b/src/automaton.hh
@@ -137,21 +137,23 @@ struct TimedAutomaton<StringConstraint, NumberConstraint, ParametricTimingConstr
 #include "non_symbolic_string_constraint.hh"
 #include "non_symbolic_update.hh"
 
-template <typename Number>
+template <typename Number, typename Timestamp>
 using NonParametricTA = TimedAutomaton<NonSymbolic::StringConstraint, NonSymbolic::NumberConstraint<Number>,
-                                       std::vector<TimingConstraint>, NonSymbolic::Update<Number>>;
-template <typename Number>
+                                       std::vector<TimingConstraint<Timestamp>>, NonSymbolic::Update<Number>>;
+template <typename Number, typename Timestamp>
 using NonParametricTAState = AutomatonState<NonSymbolic::StringConstraint, NonSymbolic::NumberConstraint<Number>,
-                                            std::vector<TimingConstraint>, NonSymbolic::Update<Number>>;
+                                            std::vector<TimingConstraint<Timestamp>>, NonSymbolic::Update<Number>>;
 
 #include "symbolic_number_constraint.hh"
 #include "symbolic_string_constraint.hh"
 #include "symbolic_update.hh"
 
+template<typename Timestamp>
 using DataParametricTA = TimedAutomaton<Symbolic::StringConstraint, Symbolic::NumberConstraint,
-                                        std::vector<TimingConstraint>, Symbolic::Update>;
+                                        std::vector<TimingConstraint<Timestamp>>, Symbolic::Update>;
+template<typename Timestamp>
 using DataParametricTAState = AutomatonState<Symbolic::StringConstraint, Symbolic::NumberConstraint,
-                                             std::vector<TimingConstraint>, Symbolic::Update>;
+                                             std::vector<TimingConstraint<Timestamp>>, Symbolic::Update>;
 
 #include "parametric_timing_constraint.hh"
 
diff --git a/src/automaton_parser.hh b/src/automaton_parser.hh
index d3507e0..c60eb05 100644
--- a/src/automaton_parser.hh
+++ b/src/automaton_parser.hh
@@ -9,6 +9,7 @@
 #include "io_operators.hh"
 
 #include "parametric_timing_constraint_helper.hh"
+#include "timing_constraint.hh"
 
 namespace boost {
   using ::operator>>;
@@ -55,33 +56,35 @@ namespace boost {
   BOOST_INSTALL_PROPERTY(edge, guard);
 } // namespace boost
 
-static inline std::ostream &operator<<(std::ostream &os, const TimingConstraint::Order &odr) {
+static inline std::ostream &operator<<(std::ostream &os, const TimingConstraintOrder &odr) {
   switch (odr) {
-    case TimingConstraint::Order::lt:
+    case TimingConstraintOrder::lt:
       os << "<";
       break;
-    case TimingConstraint::Order::le:
+    case TimingConstraintOrder::le:
       os << "<=";
       break;
-    case TimingConstraint::Order::ge:
+    case TimingConstraintOrder::ge:
       os << ">=";
       break;
-    case TimingConstraint::Order::gt:
+    case TimingConstraintOrder::gt:
       os << ">";
       break;
-    case TimingConstraint::Order::eq:
+    case TimingConstraintOrder::eq:
       os << "==";
       break;
   }
   return os;
 }
 
-static inline std::ostream &operator<<(std::ostream &os, const TimingConstraint &p) {
+template <typename Timestamp>
+static inline std::ostream &operator<<(std::ostream &os, const TimingConstraint<Timestamp> &p) {
   os << "x" << int(p.x) << " " << p.odr << " " << p.c;
   return os;
 }
 
-static inline std::istream &operator>>(std::istream &is, TimingConstraint &p) {
+template <typename Timestamp>
+static inline std::istream &operator>>(std::istream &is, TimingConstraint<Timestamp> &p) {
   if (is.get() != 'x') {
     is.setstate(std::ios_base::failbit);
     return is;
@@ -105,13 +108,13 @@ static inline std::istream &operator>>(std::istream &is, TimingConstraint &p) {
   switch (odr[0]) {
     case '>':
       if (odr[1] == '=') {
-        p.odr = TimingConstraint::Order::ge;
+        p.odr = TimingConstraintOrder::ge;
         if (is.get() != ' ') {
           is.setstate(std::ios_base::failbit);
           return is;
         }
       } else if (odr[1] == ' ') {
-        p.odr = TimingConstraint::Order::gt;
+        p.odr = TimingConstraintOrder::gt;
       } else {
         is.setstate(std::ios_base::failbit);
         return is;
@@ -119,13 +122,13 @@ static inline std::istream &operator>>(std::istream &is, TimingConstraint &p) {
       break;
     case '<':
       if (odr[1] == '=') {
-        p.odr = TimingConstraint::Order::le;
+        p.odr = TimingConstraintOrder::le;
         if (is.get() != ' ') {
           is.setstate(std::ios_base::failbit);
           return is;
         }
       } else if (odr[1] == ' ') {
-        p.odr = TimingConstraint::Order::lt;
+        p.odr = TimingConstraintOrder::lt;
       } else {
         is.setstate(std::ios_base::failbit);
         return is;
@@ -133,7 +136,7 @@ static inline std::istream &operator>>(std::istream &is, TimingConstraint &p) {
       break;
     case '=':
       if (odr[1] == '=') {
-        p.odr = TimingConstraint::Order::eq;
+        p.odr = TimingConstraintOrder::eq;
         if (is.get() != ' ') {
           is.setstate(std::ios_base::failbit);
           return is;
@@ -299,11 +302,13 @@ using BoostTimedAutomaton = boost::adjacency_list<
                     boost::property<boost::graph_string_variable_size_t, std::size_t,
                                     boost::property<boost::graph_number_variable_size_t, std::size_t>>>>;
 
-template <typename Number>
+template <typename Number, typename Timestamp>
 using NonParametricBoostTA = BoostTimedAutomaton<NonSymbolic::StringConstraint, NonSymbolic::NumberConstraint<Number>,
-                                                 TimingConstraint, NonSymbolic::Update<Number>>;
+                                                 TimingConstraint<Timestamp>, NonSymbolic::Update<Number>>;
+
+template <typename Timestamp>
 using DataParametricBoostTA =
-    BoostTimedAutomaton<Symbolic::StringConstraint, Symbolic::NumberConstraint, TimingConstraint, Symbolic::Update>;
+    BoostTimedAutomaton<Symbolic::StringConstraint, Symbolic::NumberConstraint, TimingConstraint<Timestamp>, Symbolic::Update>;
 using BoostPTA = boost::adjacency_list<
     boost::listS, boost::vecS, boost::directedS, BoostTAState,
     BoostTATransition<Symbolic::StringConstraint, Symbolic::NumberConstraint, ParametricTimingConstraintHelper,
diff --git a/src/boolean_monitor.hh b/src/boolean_monitor.hh
index a8d26ef..6de634c 100644
--- a/src/boolean_monitor.hh
+++ b/src/boolean_monitor.hh
@@ -9,22 +9,22 @@
 #include "timed_word_subject.hh"
 #include <boost/unordered_set.hpp>
 
-template <class Number> struct BooleanMonitorResult {
+template <class Number, typename Timestamp> struct BooleanMonitorResult {
   std::size_t index;
-  double timestamp;
+  Timestamp timestamp;
   NonSymbolic::NumberValuation<Number> numberValuation;
   NonSymbolic::StringValuation stringValuation;
 };
 
 namespace NonSymbolic {
-  template <typename Number>
-  class BooleanMonitor : public SingleSubject<BooleanMonitorResult<Number>>, public Observer<TimedWordEvent<Number>> {
+  template <typename Number, typename Timestamp>
+  class BooleanMonitor : public SingleSubject<BooleanMonitorResult<Number, Timestamp>>, public Observer<TimedWordEvent<Number, Timestamp>> {
   public:
     static const constexpr std::size_t unobservableActionID = 127;
-    BooleanMonitor(const NonParametricTA<Number> &automaton) : automaton(automaton) {
+    BooleanMonitor(const NonParametricTA<Number, Timestamp> &automaton) : automaton(automaton) {
       configurations.clear();
       // configurations.reserve(automaton.initialStates.size());
-      std::vector<double> initCVal(automaton.clockVariableSize);
+      std::vector<Timestamp> initCVal(automaton.clockVariableSize);
       // by default, initSEnv is no violating set (variant)
       StringValuation initSEnv(automaton.stringVariableSize);
       // by default, initNEnv is unset (optional)
@@ -36,11 +36,11 @@ namespace NonSymbolic {
     virtual ~BooleanMonitor() {
       epsilonTransition(configurations);
     }
-    void notify(const TimedWordEvent<Number> &event) {
+    void notify(const TimedWordEvent<Number, Timestamp> &event) {
       const Action actionId = event.actionId;
       const std::vector<std::string> &strings = event.strings;
       const std::vector<Number> &numbers = event.numbers;
-      const double timestamp = event.timestamp;
+      const Timestamp timestamp = event.timestamp;
 
       boost::unordered_set<Configuration> nextConfigurations;
       configurations.merge(epsilonTransition(configurations));
@@ -52,7 +52,7 @@ namespace NonSymbolic {
         if (timestamp < absTime) {
           continue;
         }
-        for (double &d: clockValuation) {
+        for (Timestamp &d: clockValuation) {
           d += timestamp - absTime;
         }
         auto stringEnv = std::get<2>(conf); // conf.stringEnv;
@@ -94,12 +94,12 @@ namespace NonSymbolic {
     }
 
   private:
-    const NonParametricTA<Number> automaton;
-    using Configuration = std::tuple<std::shared_ptr<NonParametricTAState<Number>>, std::vector<double>,
+    const NonParametricTA<Number, Timestamp> automaton;
+    using Configuration = std::tuple<std::shared_ptr<NonParametricTAState<Number, Timestamp>>, std::vector<Timestamp>,
                                      StringValuation, NumberValuation<Number>, double>;
     // struct Configuration {
     //   std::shared_ptr<AutomatonState<Number>> state;
-    //   std::vector<double> clockValuation;
+    //   std::vector<Timestamp> clockValuation;
     //   StringValuation stringEnv;
     //   NumberValuation<Number> numberEnv;
     //   bool operator==(const Configuration x) const {
diff --git a/src/data_parametric_monitor.hh b/src/data_parametric_monitor.hh
index 79be6a2..e5563dd 100644
--- a/src/data_parametric_monitor.hh
+++ b/src/data_parametric_monitor.hh
@@ -7,6 +7,7 @@
 #include "symbolic_number_constraint.hh"
 #include "symbolic_string_constraint.hh"
 #include "symbolic_update.hh"
+#include "timed_word_parser.hh"
 #include "timed_word_subject.hh"
 
 namespace Parma_Polyhedra_Library {
@@ -17,21 +18,23 @@ namespace Parma_Polyhedra_Library {
 
 #include <boost/unordered_set.hpp>
 
+template <typename Timestamp>
 struct DataParametricMonitorResult {
   std::size_t index;
-  double timestamp;
+  Timestamp timestamp;
   Symbolic::NumberValuation numberValuation;
   Symbolic::StringValuation stringValuation;
 };
 
-class DataParametricMonitor : public SingleSubject<DataParametricMonitorResult>,
-                              public Observer<TimedWordEvent<PPLRational>> {
+template<typename Timestamp>
+class DataParametricMonitor : public SingleSubject<DataParametricMonitorResult<Timestamp>>,
+                              public Observer<TimedWordEvent<PPLRational, Timestamp>> {
 public:
   static const constexpr std::size_t unobservableActionID = 127;
-  explicit DataParametricMonitor(const DataParametricTA &automaton) : automaton(automaton) {
+  explicit DataParametricMonitor(const DataParametricTA<Timestamp> &automaton) : automaton(automaton) {
     configurations.clear();
     // configurations.reserve(automaton.initialStates.size());
-    std::vector<double> initCVal(automaton.clockVariableSize);
+    std::vector<Timestamp> initCVal(automaton.clockVariableSize);
     // by default, initSEnv is no violating set (variant)
     Symbolic::StringValuation initSEnv(automaton.stringVariableSize);
     // by default, initNEnv is the universe of dimension automaton.numberVariableSize
@@ -45,11 +48,11 @@ public:
     epsilonTransition(configurations);
   }
 
-  void notify(const TimedWordEvent<PPLRational> &event) override {
+  void notify(const TimedWordEvent<PPLRational, Timestamp> &event) override {
     const Action actionId = event.actionId;
     const std::vector<std::string> &strings = event.strings;
     const std::vector<PPLRational> &numbers = event.numbers;
-    const double timestamp = event.timestamp;
+    const Timestamp timestamp = event.timestamp;
 
     boost::unordered_set<Configuration> nextConfigurations;
     configurations.merge(epsilonTransition(configurations));
@@ -61,7 +64,7 @@ public:
       if (timestamp < absTime) {
         continue;
       }
-      for (double &d: clockValuation) {
+      for (Timestamp &d: clockValuation) {
         d += timestamp - absTime;
       }
       auto stringEnv = std::get<2>(conf); //.stringEnv;
@@ -93,7 +96,7 @@ public:
           nextNEnv.remove_higher_space_dimensions(automaton.numberVariableSize);
           nextConfigurations.insert({transition.target.lock(), std::move(nextCVal), nextSEnv, nextNEnv, timestamp});
           if (transition.target.lock()->isMatch) {
-            notifyObservers({index, timestamp, nextNEnv, nextSEnv});
+            this->notifyObservers({index, timestamp, nextNEnv, nextSEnv});
           }
         }
       }
@@ -103,13 +106,13 @@ public:
   }
 
 private:
-  const DataParametricTA automaton;
-  using Configuration = std::tuple<std::shared_ptr<DataParametricTAState>, std::vector<double>,
+  const DataParametricTA<Timestamp> automaton;
+  using Configuration = std::tuple<std::shared_ptr<DataParametricTAState<Timestamp>>, std::vector<Timestamp>,
                                    Symbolic::StringValuation, Symbolic::NumberValuation, double>;
   // Symbolic::NumberValuation>;
   /*  struct Configuration {
       std::shared_ptr<DataParametricTAState> state;
-      std::vector<double> clockValuation;
+      std::vector<Timestamp> clockValuation;
       NonSymbolic::StringValuation stringEnv;
       Symbolic::NumberValuation numberEnv;
     };*/
diff --git a/src/main.cc b/src/main.cc
index b3af369..bb84b0f 100644
--- a/src/main.cc
+++ b/src/main.cc
@@ -109,6 +109,7 @@ int execute(const std::string &timedAutomatonFileName, const std::string &signat
 
 int main(int argc, char *argv[]) {
   using Number = double;
+  using Timestamp = double;
 #ifdef NDEBUG
   const auto programName = "SyMon (relase build)";
 #else
@@ -169,15 +170,15 @@ int main(int argc, char *argv[]) {
                      Symbolic::Update>(timedAutomatonFileName, signatureFileName, timedWordFileName, true);
     } else if (vm.count("dataparametric")) {
       // data parametric with new syntax
-      return execute<DataParametricTA, DataParametricBoostTA, PPLRational, double, DataParametricMonitor,
-                     DataParametricPrinter, Symbolic::StringConstraint, Symbolic::NumberConstraint,
-                     std::vector<TimingConstraint>, Symbolic::Update>(timedAutomatonFileName, signatureFileName,
+      return execute<DataParametricTA<Timestamp>, DataParametricBoostTA<Number>, PPLRational, Timestamp, DataParametricMonitor<Timestamp>,
+                     DataParametricPrinter<Timestamp>, Symbolic::StringConstraint, Symbolic::NumberConstraint,
+                     std::vector<TimingConstraint<Timestamp>>, Symbolic::Update>(timedAutomatonFileName, signatureFileName,
                                                                       timedWordFileName, true);
     } else {
       // boolean with new syntax
-      return execute<NonParametricTA<Number>, NonParametricBoostTA<Number>, Number, double, BooleanMonitor<Number>,
-                     BooleanPrinter<Number>, NonSymbolic::StringConstraint, NonSymbolic::NumberConstraint<Number>,
-                     std::vector<TimingConstraint>, NonSymbolic::Update<Number>>(timedAutomatonFileName, signatureFileName,
+      return execute<NonParametricTA<Number, Timestamp>, NonParametricBoostTA<Number, Timestamp>, Number, Timestamp, BooleanMonitor<Number, Timestamp>,
+                     BooleanPrinter<Number, Timestamp>, NonSymbolic::StringConstraint, NonSymbolic::NumberConstraint<Number>,
+                     std::vector<TimingConstraint<Timestamp>>, NonSymbolic::Update<Number>>(timedAutomatonFileName, signatureFileName,
                                                                          timedWordFileName, true);
     }
   } else if (vm.count("parametric")) {
@@ -187,15 +188,15 @@ int main(int argc, char *argv[]) {
                    Symbolic::Update>(timedAutomatonFileName, signatureFileName, timedWordFileName, false);
   } else if (vm.count("dataparametric")) {
     // data parametric
-    return execute<DataParametricTA, DataParametricBoostTA, PPLRational, double, DataParametricMonitor,
-                   DataParametricPrinter, Symbolic::StringConstraint, Symbolic::NumberConstraint,
-                   std::vector<TimingConstraint>, Symbolic::Update>(timedAutomatonFileName, signatureFileName,
+    return execute<DataParametricTA<Timestamp>, DataParametricBoostTA<Number>, PPLRational, Timestamp, DataParametricMonitor<Timestamp>,
+                   DataParametricPrinter<Timestamp>, Symbolic::StringConstraint, Symbolic::NumberConstraint,
+                   std::vector<TimingConstraint<Timestamp>>, Symbolic::Update>(timedAutomatonFileName, signatureFileName,
                                                                     timedWordFileName, false);
   } else {
     // boolean
-    return execute<NonParametricTA<Number>, NonParametricBoostTA<Number>, Number, double, BooleanMonitor<Number>,
-                   BooleanPrinter<Number>, NonSymbolic::StringConstraint, NonSymbolic::NumberConstraint<Number>,
-                   std::vector<TimingConstraint>, NonSymbolic::Update<Number>>(timedAutomatonFileName, signatureFileName,
+    return execute<NonParametricTA<Number, Timestamp>, NonParametricBoostTA<Number, Timestamp>, Number, Timestamp, BooleanMonitor<Number, Timestamp>,
+                   BooleanPrinter<Number, Timestamp>, NonSymbolic::StringConstraint, NonSymbolic::NumberConstraint<Number>,
+                   std::vector<TimingConstraint<Timestamp>>, NonSymbolic::Update<Number>>(timedAutomatonFileName, signatureFileName,
                                                                        timedWordFileName, false);
   }
   return 0;
diff --git a/src/parametric_timing_constraint_helper.hh b/src/parametric_timing_constraint_helper.hh
index b9cb4fb..e56fb7c 100644
--- a/src/parametric_timing_constraint_helper.hh
+++ b/src/parametric_timing_constraint_helper.hh
@@ -32,6 +32,7 @@ public:
   std::array<std::vector<std::pair<op_t, atom_t>>, 2> tail;
   //! @brief comparison in the constraint
   comparison_t comparison = comparison_t::EQ;
+  // (head[0] tail[0][0].first tail[0][0].second ...) comparison (head[1] tail[1][0].first tail[1][0].second ...)
 
   static auto toExpr(const std::size_t parameterSize, const atom_t &atom) {
     std::pair<Parma_Polyhedra_Library::Linear_Expression, Parma_Polyhedra_Library::Coefficient> expr;
diff --git a/src/printer.hh b/src/printer.hh
index beba899..0592dac 100644
--- a/src/printer.hh
+++ b/src/printer.hh
@@ -2,12 +2,13 @@
 
 #include "boolean_monitor.hh"
 
-template <class Number> struct BooleanPrinter : public Observer<BooleanMonitorResult<Number>> {
+template <class Number, typename Timestamp> struct BooleanPrinter
+    : public Observer<BooleanMonitorResult<Number, Timestamp>> {
   BooleanPrinter() = default;
 
   virtual ~BooleanPrinter() = default;
 
-  void notify(const BooleanMonitorResult<Number> &result) override {
+  void notify(const BooleanMonitorResult<Number, Timestamp> &result) override {
     std::cout << "@" << std::fixed << result.timestamp << std::defaultfloat << ".\t(time-point " << result.index << ")\t";
     for (std::size_t i = 0; i < result.stringValuation.size(); i++) {
       if (result.stringValuation[i]) {
@@ -24,12 +25,13 @@ template <class Number> struct BooleanPrinter : public Observer<BooleanMonitorRe
 
 #include "data_parametric_monitor.hh"
 
-struct DataParametricPrinter : public Observer<DataParametricMonitorResult> {
+template <typename Timestamp>
+struct DataParametricPrinter : public Observer<DataParametricMonitorResult<Timestamp>> {
   DataParametricPrinter() = default;
 
   virtual ~DataParametricPrinter() = default;
 
-  void notify(const DataParametricMonitorResult &result) override {
+  void notify(const DataParametricMonitorResult<Timestamp> &result) override {
     using Parma_Polyhedra_Library::IO_Operators::operator<<;
     std::cout << "@" << std::fixed << result.timestamp << ".\t(time-point " << result.index << ")\t";
     for (std::size_t i = 0; i < result.stringValuation.size(); i++) {
diff --git a/src/symon_parser.hh b/src/symon_parser.hh
index ec63c9e..1236e2e 100644
--- a/src/symon_parser.hh
+++ b/src/symon_parser.hh
@@ -196,13 +196,14 @@ public:
 
 public:
   // Helper function to extract the upper bound from a non-parametric timing constraint
-  static std::vector<::TimingConstraint> extractUpperBound(const std::vector<::TimingConstraint> &guard) {
-    std::vector<::TimingConstraint> upperBound;
+  template <typename Timestamp>
+  static std::vector<::TimingConstraint<Timestamp>> extractUpperBound(const std::vector<::TimingConstraint<Timestamp>> &guard) {
+    std::vector<::TimingConstraint<Timestamp>> upperBound;
 
     // Check each constraint in the guard
     for (const auto &constraint: guard) {
       // If the constraint is an upper bound (lt or le), add it to the result
-      if (constraint.odr == ::TimingConstraint::Order::lt || constraint.odr == ::TimingConstraint::Order::le) {
+      if (constraint.odr == ::TimingConstraintOrder::le) {
         upperBound.push_back(constraint);
       }
     }
@@ -597,9 +598,11 @@ private:
           throw err;
         }
       } else {
-        return {boost::lexical_cast<::TimingConstraint>("x" + std::to_string(clockIndex) + " " +
+        //TC = ::TimingConstraint<Timestamp>
+        using TC = timingconstraint_t<TimingConstraint>;
+        return {boost::lexical_cast<TC>("x" + std::to_string(clockIndex) + " " +
                                                         (isLowerInclusive ? ">=" : ">") + " " + lowerBound),
-                boost::lexical_cast<::TimingConstraint>("x" + std::to_string(clockIndex) + " " +
+                boost::lexical_cast<TC>("x" + std::to_string(clockIndex) + " " +
                                                         (isUpperInclusive ? "<=" : "<") + " " + upperBound)};
       }
     }
@@ -628,8 +631,9 @@ private:
         result.add_constraint(constraint);
         return result;
       } else {
+        using TC = timingconstraint_t<TimingConstraint>;
         return {
-            boost::lexical_cast<::TimingConstraint>("x" + std::to_string(clockIndex) + " " + comparator + " " + expr)};
+            boost::lexical_cast<TC>("x" + std::to_string(clockIndex) + " " + comparator + " " + expr)};
       }
     }
     throw std::runtime_error(makeErrorMessage(
@@ -837,7 +841,7 @@ private:
       TSNode rhsNode = nextNonCommentChild(child, p);
       Automaton lhs = this->parseExpr(content, lhsNode);
       Automaton rhs = this->parseExpr(content, rhsNode);
-      return concatenate(std::move(lhs), std::move(rhs));
+      return concatenate<StringConstraint, NumberConstraint, TimingConstraint, Update>(std::move(lhs), std::move(rhs));
     } else if (kind == "conjunction") {
       uint32_t p = 0;
       TSNode lhsNode = nextNonCommentChild(child, p);
@@ -991,7 +995,7 @@ private:
       TimingConstraint guard = this->parseTimingConstraint(content, intervalNode, innerExpr.clockVariableSize);
 
       // Apply the time restriction operation
-      Automaton result = timeRestriction(std::move(innerExpr), guard);
+      Automaton result = timeRestriction<StringConstraint, NumberConstraint, TimingConstraint, Update>(std::move(innerExpr), guard);
 
       if constexpr (std::is_same_v<TimingConstraint, ParametricTimingConstraint>) {
         assert(std::all_of(result.states.begin(), result.states.end(), [&](const auto &state) {
@@ -1005,17 +1009,17 @@ private:
       }
 
       // Extract the upper bound from the timing constraint and add it to all transitions
-      if constexpr (std::is_same_v<TimingConstraint, std::vector<::TimingConstraint>>) {
+      if constexpr (is_vector_of_timingconstraint_v<TimingConstraint>) {
         // For non-parametric timing constraints
         auto upperBound = extractUpperBound(guard);
         if (!upperBound.empty()) {
           // It has an upper bound, add it to all transitions
-          addConstraintToAllTransitions(result, upperBound);
+          addConstraintToAllTransitions<StringConstraint, NumberConstraint, TimingConstraint, Update>(result, upperBound);
         }
       } else if constexpr (std::is_same_v<TimingConstraint, ParametricTimingConstraint>) {
         // For parametric timing constraints
         auto upperBound = extractUpperBound(guard, this->parameters.size() + innerExpr.clockVariableSize - 1);
-        addConstraintToAllTransitions(result, upperBound);
+        addConstraintToAllTransitions<StringConstraint, NumberConstraint, TimingConstraint, Update>(result, upperBound);
       }
 
       if constexpr (std::is_same_v<TimingConstraint, ParametricTimingConstraint>) {
diff --git a/src/timing_constraint.hh b/src/timing_constraint.hh
index 0d9dc90..6804ff9 100644
--- a/src/timing_constraint.hh
+++ b/src/timing_constraint.hh
@@ -15,26 +15,26 @@ inline bool toBool(Order odr) {
   return odr == Order::EQ;
 }
 
+enum class TimingConstraintOrder { lt, le, ge, gt, eq };
+
 //! @brief A constraint in a guard of transitions
+template <typename Timestamp>
 struct TimingConstraint {
-  enum class Order { lt, le, ge, gt, eq };
-  using Timestamp = double;
-
   ClockVariables x;
-  Order odr;
+  TimingConstraintOrder odr;
   Timestamp c;
 
   [[nodiscard]] bool satisfy(Timestamp d) const {
     switch (odr) {
-      case Order::lt:
+      case TimingConstraintOrder::lt:
         return d < c;
-      case Order::le:
+      case TimingConstraintOrder::le:
         return d <= c;
-      case Order::gt:
+      case TimingConstraintOrder::gt:
         return d > c;
-      case Order::ge:
+      case TimingConstraintOrder::ge:
         return d >= c;
-      case Order::eq:
+      case TimingConstraintOrder::eq:
         return d == c;
     }
     return false;
@@ -45,7 +45,7 @@ struct TimingConstraint {
   ::Order operator()(Interpretation val) const {
     if (satisfy(val.at(x))) {
       return ::Order::EQ;
-    } else if (odr == Order::lt || odr == Order::le) {
+    } else if (odr == TimingConstraintOrder::lt || odr == TimingConstraintOrder::le) {
       return ::Order::GT;
     } else {
       return ::Order::LT;
@@ -69,31 +69,35 @@ struct TimingConstraint {
 
 // An interface to write an inequality constrait easily
 class ConstraintMaker {
-  using Timestamp = TimingConstraint::Timestamp;
   ClockVariables x;
 
 public:
   explicit ConstraintMaker(ClockVariables x) : x(x) {
   }
 
-  TimingConstraint operator<(Timestamp c) {
-    return TimingConstraint{x, TimingConstraint::Order::lt, c};
+  template<typename Timestamp = double>
+  TimingConstraint<Timestamp> operator<(Timestamp c) {
+    return TimingConstraint<Timestamp>{x, TimingConstraintOrder::lt, c};
   }
 
-  TimingConstraint operator<=(Timestamp c) {
-    return TimingConstraint{x, TimingConstraint::Order::le, c};
+  template<typename Timestamp = double>
+  TimingConstraint<Timestamp> operator<=(Timestamp c) {
+    return TimingConstraint<Timestamp>{x, TimingConstraintOrder::le, c};
   }
 
-  TimingConstraint operator>(Timestamp c) {
-    return TimingConstraint{x, TimingConstraint::Order::gt, c};
+  template<typename Timestamp = double>
+  TimingConstraint<Timestamp> operator>(Timestamp c) {
+    return TimingConstraint<Timestamp>{x, TimingConstraintOrder::gt, c};
   }
 
-  TimingConstraint operator>=(Timestamp c) {
-    return TimingConstraint{x, TimingConstraint::Order::ge, c};
+  template<typename Timestamp = double>
+  TimingConstraint<Timestamp> operator>=(Timestamp c) {
+    return TimingConstraint<Timestamp>{x, TimingConstraintOrder::ge, c};
   }
 
-  TimingConstraint operator==(Timestamp c) {
-    return TimingConstraint{x, TimingConstraint::Order::eq, c};
+  template<typename Timestamp = double>
+  TimingConstraint<Timestamp> operator==(Timestamp c) {
+    return TimingConstraint<Timestamp>{x, TimingConstraintOrder::eq, c};
   }
 };
 
@@ -105,12 +109,13 @@ public:
 //         return g.odr == TimingConstraint::Order::ge || g.odr == TimingConstraint::Order::gt;
 //     }), guard.end());
 // }
+template <typename Timestamp>
+using TimingValuation = std::vector<Timestamp>;
 
-using TimingValuation = std::vector<TimingConstraint::Timestamp>;
-
-static bool eval(const TimingValuation &clockValuation, const std::vector<TimingConstraint> &guard) {
+template<typename Timestamp>
+static bool eval(const TimingValuation<Timestamp> &clockValuation, const std::vector<TimingConstraint<Timestamp>> &guard) {
   return std::all_of(guard.begin(), guard.end(),
-                     [&clockValuation](const TimingConstraint &g) { return g.satisfy(clockValuation.at(g.x)); });
+                     [&clockValuation](const TimingConstraint<Timestamp> &g) { return g.satisfy(clockValuation.at(g.x)); });
 }
 
 /*!
@@ -122,10 +127,11 @@ static bool eval(const TimingValuation &clockValuation, const std::vector<Timing
   and throws if any non-equality constraint is present.
 
 */
-static std::optional<double> diff(const TimingValuation &clockValuation, const std::vector<TimingConstraint> &guard) {
+template<typename Timestamp>
+static std::optional<double> diff(const TimingValuation<Timestamp> &clockValuation, const std::vector<TimingConstraint<Timestamp>> &guard) {
   std::optional<double> result = std::nullopt;
   for (auto&& g: guard) {
-    if(g.odr != TimingConstraint::Order::eq) {
+    if(g.odr != TimingConstraintOrder::eq) {
       throw std::runtime_error("TimingConstraint: unsupported guard with inequality constraints on unobservable transition");
     }
     auto timeDiff = g.c - clockValuation.at(g.x);
@@ -148,8 +154,9 @@ static std::optional<double> diff(const TimingValuation &clockValuation, const s
  * @param width the width to shift the clock variable id
  * @return a new vector of TimingConstraint with the clock variables shifted
  */
-static std::vector<TimingConstraint> shift(const std::vector<TimingConstraint> &guard, const ClockVariables width) {
-  std::vector<TimingConstraint> shiftedGuard;
+template<typename Timestamp>
+static std::vector<TimingConstraint<Timestamp>> shift(const std::vector<TimingConstraint<Timestamp>> &guard, const ClockVariables width) {
+  std::vector<TimingConstraint<Timestamp>> shiftedGuard;
   shiftedGuard.reserve(guard.size());
   for (const auto &g: guard) {
     shiftedGuard.push_back(g.shift(width));
@@ -165,9 +172,10 @@ static std::vector<TimingConstraint> shift(const std::vector<TimingConstraint> &
  * @param right the second vector of TimingConstraint
  * @return a new vector containing all TimingConstraints from both vectors
  */
-static std::vector<TimingConstraint> operator&&(const std::vector<TimingConstraint> &left,
-                                                const std::vector<TimingConstraint> &right) {
-  std::vector<TimingConstraint> result = left;
+ template<typename Timestamp>
+static std::vector<TimingConstraint<Timestamp>> operator&&(const std::vector<TimingConstraint<Timestamp>> &left,
+                                                const std::vector<TimingConstraint<Timestamp>> &right) {
+  std::vector<TimingConstraint<Timestamp>> result = left;
   result.reserve(left.size() + right.size());
   std::copy_if(right.begin(), right.end(), std::back_inserter(result),
                [&left](const auto &guard) { return std::find(left.begin(), left.end(), guard) == left.end(); });
@@ -181,7 +189,42 @@ static std::vector<TimingConstraint> operator&&(const std::vector<TimingConstrai
  * @param size the size to adjust the guard to
  * @return a new vector of TimingConstraint with the clock variables adjusted
  */
-static std::vector<TimingConstraint> adjustDimension(const std::vector<TimingConstraint> &guard,
+template<typename Timestamp>
+static std::vector<TimingConstraint<Timestamp>> adjustDimension(const std::vector<TimingConstraint<Timestamp>> &guard,
                                                      const ClockVariables size) {
   return guard;
 }
+
+
+// T の参照/const/volatile を除去
+template<typename T>
+using remove_cvref_t = std::remove_cv_t<std::remove_reference_t<T>>;
+
+template<typename T>
+struct is_vector_of_timingconstraint_impl : std::false_type {};
+
+template<typename Timestamp>
+struct is_vector_of_timingconstraint_impl<std::vector<TimingConstraint<Timestamp>>> : std::true_type {};
+
+// T が std::vector<TimingConstraint<Timestamp>> の形かどうか
+template<typename T>
+constexpr bool is_vector_of_timingconstraint_v =
+    is_vector_of_timingconstraint_impl< remove_cvref_t<T> >::value;
+
+template<typename T>
+struct timingconstraint_timestamp_impl;
+
+template<typename Timestamp>
+struct timingconstraint_timestamp_impl<std::vector<TimingConstraint<Timestamp>>> {
+  using type = Timestamp;
+  using timingconstraint_type = TimingConstraint<Timestamp>;
+};
+
+// std::vector<TimingConstraint<Timestamp>> の Timestamp 型を取得
+template<typename T>
+using timingconstraint_timestamp_t =
+    typename timingconstraint_timestamp_impl< remove_cvref_t<T> >::type;
+
+template<typename T>
+using timingconstraint_t =
+    typename timingconstraint_timestamp_impl< remove_cvref_t<T> >::timingconstraint_type;
diff --git a/test/automaton_operation_test.cc b/test/automaton_operation_test.cc
index 965d355..4368f4a 100644
--- a/test/automaton_operation_test.cc
+++ b/test/automaton_operation_test.cc
@@ -255,8 +255,8 @@ BOOST_AUTO_TEST_SUITE(AutomatonOperationTest)
             auto originalFinalState = automaton_copy.states[1];
 
             // Create a timing constraint for the time restriction
-            std::vector<TimingConstraint> timeGuard;
-            timeGuard.push_back(ConstraintMaker(0) <= 10);
+            std::vector<TimingConstraint<double>> timeGuard;
+            timeGuard.push_back(ConstraintMaker(0) <= 10.);
 
             // Apply the time restriction operation
             auto result = timeRestriction(std::move(automaton_copy), timeGuard);
@@ -353,8 +353,8 @@ BOOST_AUTO_TEST_SUITE(AutomatonOperationTest)
             BOOST_CHECK_EQUAL(automaton_copy.states.size(), 4);
 
             // Create a timing constraint to add to all transitions
-            std::vector<TimingConstraint> constraint;
-            constraint.push_back(ConstraintMaker(0) <= 5);
+            std::vector<TimingConstraint<double>> constraint;
+            constraint.push_back(ConstraintMaker(0) <= 5.);
 
             // Count the number of transitions before adding the constraint
             size_t transitionCount = 0;
@@ -375,7 +375,7 @@ BOOST_AUTO_TEST_SUITE(AutomatonOperationTest)
                         // Check that the constraint is applied to the transition
                         bool hasConstraint = false;
                         for (const auto &guard : transition.guard) {
-                            if (guard.x == 0 && guard.odr == TimingConstraint::Order::le && guard.c == 5) {
+                            if (guard.x == 0 && guard.odr == TimingConstraintOrder::le && guard.c == 5) {
                                 hasConstraint = true;
                                 break;
                             }
@@ -640,8 +640,8 @@ BOOST_AUTO_TEST_SUITE(AutomatonOperationTest)
             // Create a timing constraint for the time restriction
             using namespace Parma_Polyhedra_Library;
             using namespace Symbolic;
-            std::vector<TimingConstraint> timeGuard;
-            timeGuard.push_back(ConstraintMaker(0) <= 10);
+            std::vector<TimingConstraint<double>> timeGuard;
+            timeGuard.push_back(ConstraintMaker(0) <= 10.);
 
             // Apply the time restriction operation
             auto result = timeRestriction(std::move(automaton_copy), timeGuard);
@@ -738,8 +738,8 @@ BOOST_AUTO_TEST_SUITE(AutomatonOperationTest)
             BOOST_CHECK_EQUAL(automaton_copy.states.size(), 4);
 
             // Create a timing constraint to add to all transitions
-            std::vector<TimingConstraint> constraint;
-            constraint.push_back(ConstraintMaker(0) <= 5);
+            std::vector<TimingConstraint<double>> constraint;
+            constraint.push_back(ConstraintMaker(0) <= 5.);
 
             // Count the number of transitions before adding the constraint
             size_t transitionCount = 0;
@@ -760,7 +760,7 @@ BOOST_AUTO_TEST_SUITE(AutomatonOperationTest)
                         // Check that the constraint is applied to the transition
                         bool hasConstraint = false;
                         for (const auto &guard : transition.guard) {
-                            if (guard.x == 0 && guard.odr == TimingConstraint::Order::le && guard.c == 5) {
+                            if (guard.x == 0 && guard.odr == TimingConstraintOrder::le && guard.c == 5) {
                                 hasConstraint = true;
                                 break;
                             }
diff --git a/test/automaton_parser_test.cc b/test/automaton_parser_test.cc
index fdff97d..7080eeb 100644
--- a/test/automaton_parser_test.cc
+++ b/test/automaton_parser_test.cc
@@ -178,7 +178,7 @@ BOOST_AUTO_TEST_SUITE(AutomatonParserTests)
     BOOST_AUTO_TEST_SUITE(NonParametricTimedAutomaton)
 
       BOOST_AUTO_TEST_CASE(Copy) {
-        NonParametricBoostTA<int> BoostTA;
+        NonParametricBoostTA<int, double> BoostTA;
         std::ifstream file(PROJECT_ROOT "/example/copy/copy.dot");
         parseBoostTA(file, BoostTA);
 
@@ -214,7 +214,7 @@ BOOST_AUTO_TEST_SUITE(AutomatonParserTests)
     BOOST_AUTO_TEST_SUITE(DataParametricTimedAutomaton)
 
       BOOST_AUTO_TEST_CASE(Copy) {
-        DataParametricBoostTA BoostTA;
+        DataParametricBoostTA<double> BoostTA;
         std::ifstream file(PROJECT_ROOT "/example/copy/copy_data_parametric.dot");
         parseBoostTA(file, BoostTA);
 
@@ -252,8 +252,8 @@ BOOST_AUTO_TEST_SUITE(AutomatonParserTests)
     BOOST_AUTO_TEST_SUITE(NonParametricTimedAutomaton)
 
       BOOST_AUTO_TEST_CASE(Copy) {
-        NonParametricBoostTA<int> BoostTA;
-        NonParametricTA<int> TA;
+        NonParametricBoostTA<int, double> BoostTA;
+        NonParametricTA<int, double> TA;
         // NonParametricTA<int> TA;
         std::ifstream file(PROJECT_ROOT "/example/copy/copy.dot");
         parseBoostTA(file, BoostTA);
@@ -331,7 +331,7 @@ BOOST_AUTO_TEST_SUITE(AutomatonParserTests)
         BOOST_CHECK_EQUAL(TA.states[1]->next.at(0).at(0).update.numberUpdate.size(), 0);
         BOOST_CHECK_EQUAL(TA.states[1]->next.at(0).at(0).guard.size(), 1);
         BOOST_CHECK_EQUAL(TA.states[1]->next.at(0).at(0).guard.front().x, 0);
-        BOOST_CHECK_EQUAL(TA.states[1]->next.at(0).at(0).guard.front().odr, TimingConstraint::Order::lt);
+        BOOST_CHECK_EQUAL(TA.states[1]->next.at(0).at(0).guard.front().odr, TimingConstraintOrder::lt);
         BOOST_CHECK_EQUAL(TA.states[1]->next.at(0).at(0).guard.front().c, 3);
         BOOST_CHECK_EQUAL(TA.states[1]->next.at(0).at(0).target.lock(), TA.states[1]);
 
@@ -355,8 +355,8 @@ BOOST_AUTO_TEST_SUITE(AutomatonParserTests)
 
       BOOST_AUTO_TEST_CASE(Copy) {
         using namespace Parma_Polyhedra_Library;
-        DataParametricBoostTA BoostTA;
-        DataParametricTA TA;
+        DataParametricBoostTA<double> BoostTA;
+        DataParametricTA<double> TA;
         std::ifstream file(PROJECT_ROOT "/example/copy/copy_data_parametric.dot");
         parseBoostTA(file, BoostTA);
         convBoostTA(BoostTA, TA);
@@ -416,7 +416,7 @@ BOOST_AUTO_TEST_SUITE(AutomatonParserTests)
         BOOST_CHECK_EQUAL(TA.states[1]->next.at(0).at(0).update.numberUpdate.size(), 0);
         BOOST_CHECK_EQUAL(TA.states[1]->next.at(0).at(0).guard.size(), 1);
         BOOST_CHECK_EQUAL(TA.states[1]->next.at(0).at(0).guard.front().x, 0);
-        BOOST_CHECK_EQUAL(TA.states[1]->next.at(0).at(0).guard.front().odr, ::TimingConstraint::Order::lt);
+        BOOST_CHECK_EQUAL(TA.states[1]->next.at(0).at(0).guard.front().odr, ::TimingConstraintOrder::lt);
         BOOST_CHECK_EQUAL(TA.states[1]->next.at(0).at(0).guard.front().c, 3);
         BOOST_CHECK_EQUAL(TA.states[1]->next.at(0).at(0).target.lock(), TA.states[1]);
 
@@ -441,8 +441,8 @@ BOOST_AUTO_TEST_SUITE(AutomatonParserTests)
 
       BOOST_AUTO_TEST_CASE(withdraw) {
         using namespace Parma_Polyhedra_Library;
-        DataParametricBoostTA BoostTA;
-        DataParametricTA TA;
+        DataParametricBoostTA<double> BoostTA;
+        DataParametricTA<double> TA;
         std::ifstream file(PROJECT_ROOT "/example/withdraw/withdraw.dot");
         parseBoostTA(file, BoostTA);
         convBoostTA(BoostTA, TA);
@@ -495,7 +495,7 @@ BOOST_AUTO_TEST_SUITE(AutomatonParserTests)
         BOOST_CHECK_EQUAL(TA.states[1]->next.at(0).at(0).update.numberUpdate.size(), 0);
         BOOST_CHECK_EQUAL(TA.states[1]->next.at(0).at(0).guard.size(), 1);
         BOOST_CHECK_EQUAL(TA.states[1]->next.at(0).at(0).guard.front().x, 0);
-        BOOST_CHECK_EQUAL(TA.states[1]->next.at(0).at(0).guard.front().odr, ::TimingConstraint::Order::le);
+        BOOST_CHECK_EQUAL(TA.states[1]->next.at(0).at(0).guard.front().odr, ::TimingConstraintOrder::le);
         BOOST_CHECK_EQUAL(TA.states[1]->next.at(0).at(0).guard.front().c, 30);
         BOOST_CHECK_EQUAL(TA.states[1]->next.at(0).at(0).target.lock(), TA.states[1]);
 
@@ -516,7 +516,7 @@ BOOST_AUTO_TEST_SUITE(AutomatonParserTests)
                 Variable(0) + Variable(1)));
         BOOST_CHECK_EQUAL(TA.states[1]->next.at(0).at(1).guard.size(), 1);
         BOOST_CHECK_EQUAL(TA.states[1]->next.at(0).at(1).guard.front().x, 0);
-        BOOST_CHECK_EQUAL(TA.states[1]->next.at(0).at(1).guard.front().odr, ::TimingConstraint::Order::le);
+        BOOST_CHECK_EQUAL(TA.states[1]->next.at(0).at(1).guard.front().odr, ::TimingConstraintOrder::le);
         BOOST_CHECK_EQUAL(TA.states[1]->next.at(0).at(1).guard.front().c, 30);
         BOOST_CHECK_EQUAL(TA.states[1]->next.at(0).at(1).target.lock(), TA.states[1]);
 
@@ -528,7 +528,7 @@ BOOST_AUTO_TEST_SUITE(AutomatonParserTests)
         BOOST_CHECK_EQUAL(TA.states[1]->next.at(0).at(2).update.numberUpdate.size(), 0);
         BOOST_CHECK_EQUAL(TA.states[1]->next.at(0).at(2).guard.size(), 1);
         BOOST_CHECK_EQUAL(TA.states[1]->next.at(0).at(2).guard.front().x, 0);
-        BOOST_CHECK_EQUAL(TA.states[1]->next.at(0).at(2).guard.front().odr, ::TimingConstraint::Order::gt);
+        BOOST_CHECK_EQUAL(TA.states[1]->next.at(0).at(2).guard.front().odr, ::TimingConstraintOrder::gt);
         BOOST_CHECK_EQUAL(TA.states[1]->next.at(0).at(2).guard.front().c, 30);
         BOOST_CHECK_EQUAL(TA.states[1]->next.at(0).at(2).target.lock(), TA.states[2]);
 
diff --git a/test/boolean_monitor_test.cc b/test/boolean_monitor_test.cc
index b42da39..97ddf2a 100644
--- a/test/boolean_monitor_test.cc
+++ b/test/boolean_monitor_test.cc
@@ -22,23 +22,23 @@ struct DummyTimedWordSubject : public SingleSubject<TimedWordEvent> {
   std::vector<TimedWordEvent> vec;
 };
 
-template<typename Number>
-struct DummyBooleanMonitorObserver : public Observer<BooleanMonitorResult<Number>> {
+template<typename Number, typename Timestamp>
+struct DummyBooleanMonitorObserver : public Observer<BooleanMonitorResult<Number, Timestamp>> {
   DummyBooleanMonitorObserver() {
   }
   virtual ~DummyBooleanMonitorObserver() {
   }
-  void notify(const BooleanMonitorResult<Number> &result) {
+  void notify(const BooleanMonitorResult<Number, Timestamp> &result) {
     resultVec.push_back(result);
   }
-  std::vector<BooleanMonitorResult<Number>> resultVec;
+  std::vector<BooleanMonitorResult<Number, Timestamp>> resultVec;
 };
 
-template<typename Number, typename TimedWordEvent>
+template<typename Number, typename Timestamp, typename TimedWordEvent>
 struct BooleanMonitorFixture {
-  void feed(const NonParametricTA<Number> &automaton, std::vector<TimedWordEvent> &&vec) {
-    auto monitor = std::make_shared<NonSymbolic::BooleanMonitor<Number>>(automaton);
-    std::shared_ptr<DummyBooleanMonitorObserver<Number>> observer = std::make_shared<DummyBooleanMonitorObserver<Number>>();
+  void feed(const NonParametricTA<Number, Timestamp> &automaton, std::vector<TimedWordEvent> &&vec) {
+    auto monitor = std::make_shared<NonSymbolic::BooleanMonitor<Number, Timestamp>>(automaton);
+    std::shared_ptr<DummyBooleanMonitorObserver<Number, Timestamp>> observer = std::make_shared<DummyBooleanMonitorObserver<Number, Timestamp>>();
     monitor->addObserver(observer);
     DummyTimedWordSubject<TimedWordEvent> subject{std::move(vec)};
     subject.addObserver(monitor);
@@ -48,13 +48,14 @@ struct BooleanMonitorFixture {
     monitor.reset();            // release local ownership
     resultVec = std::move(observer->resultVec);
   }
-  std::vector<BooleanMonitorResult<Number>> resultVec;
+  std::vector<BooleanMonitorResult<Number, Timestamp>> resultVec;
 };
 
 namespace IntTest {
   using Number = int;
-  using TimedWordEvent = TimedWordEvent<Number, double>;
-  using BooleanMonitorFixture = BooleanMonitorFixture<Number, TimedWordEvent>;
+  using Timestamp = double;
+  using TimedWordEvent = TimedWordEvent<Number, Timestamp>;
+  using BooleanMonitorFixture = BooleanMonitorFixture<Number, Timestamp, TimedWordEvent>;
 
   BOOST_AUTO_TEST_SUITE(BooleanMonitorTest)
     BOOST_FIXTURE_TEST_CASE(test1, BooleanMonitorFixture)
@@ -167,8 +168,9 @@ namespace IntTest {
 
 namespace DoubleTest {
   using Number = double;
-  using TimedWordEvent = TimedWordEvent<Number, double>;
-  using BooleanMonitorFixture = BooleanMonitorFixture<Number, TimedWordEvent>;
+  using Timestamp = double;
+  using TimedWordEvent = TimedWordEvent<Number, Timestamp>;
+  using BooleanMonitorFixture = BooleanMonitorFixture<Number, Timestamp, TimedWordEvent>;
 
   BOOST_AUTO_TEST_SUITE(BooleanMonitorTest)
     BOOST_FIXTURE_TEST_CASE(non_integer_timestamp_test, BooleanMonitorFixture) {
diff --git a/test/data_parametric_monitor_test.cc b/test/data_parametric_monitor_test.cc
index cb60dab..5387747 100644
--- a/test/data_parametric_monitor_test.cc
+++ b/test/data_parametric_monitor_test.cc
@@ -6,6 +6,7 @@
 #include "../test/fixture/epsilon_transition_automaton_fixture.hh"
 
 using TWEvent = TimedWordEvent<PPLRational>;
+using Timestamp = double;
 
 struct DummyDataTimedWordSubject : public SingleSubject<TWEvent> {
   DummyDataTimedWordSubject(std::vector<TWEvent> &&vec) :vec(std::move(vec)) {}
@@ -19,18 +20,18 @@ struct DummyDataTimedWordSubject : public SingleSubject<TWEvent> {
   std::vector<TWEvent> vec;
 };
 
-struct DummyDataParametricMonitorObserver : public Observer<DataParametricMonitorResult> {
+struct DummyDataParametricMonitorObserver : public Observer<DataParametricMonitorResult<double>> {
   DummyDataParametricMonitorObserver() {}
   virtual ~DummyDataParametricMonitorObserver() {}
-  void notify(const DataParametricMonitorResult& result) {
+  void notify(const DataParametricMonitorResult<double>& result) {
     resultVec.push_back(result);
   }
-  std::vector<DataParametricMonitorResult> resultVec;
+  std::vector<DataParametricMonitorResult<double>> resultVec;
 };
 
 struct DataParametricMonitorFixture {
-  void feed(DataParametricTA automaton, std::vector<TWEvent> &&vec) {
-    auto monitor = std::make_shared<DataParametricMonitor>(automaton);
+  void feed(DataParametricTA<Timestamp> automaton, std::vector<TWEvent> &&vec) {
+    auto monitor = std::make_shared<DataParametricMonitor<Timestamp>>(automaton);
     std::shared_ptr<DummyDataParametricMonitorObserver> observer = std::make_shared<DummyDataParametricMonitorObserver>();
     monitor->addObserver(observer);
     DummyDataTimedWordSubject subject{std::move(vec)};
@@ -41,7 +42,7 @@ struct DataParametricMonitorFixture {
     monitor.reset();            // release local ownership
     resultVec = std::move(observer->resultVec);
   }
-  std::vector<DataParametricMonitorResult> resultVec;
+  std::vector<DataParametricMonitorResult<double>> resultVec;
 };
 
 BOOST_AUTO_TEST_SUITE(DataParametricMonitorTest)
diff --git a/test/fixture/copy_automaton_fixture.hh b/test/fixture/copy_automaton_fixture.hh
index 46d7fd3..a5b89d9 100644
--- a/test/fixture/copy_automaton_fixture.hh
+++ b/test/fixture/copy_automaton_fixture.hh
@@ -18,7 +18,7 @@ struct CopyFixture {
         // Construct automaton
         automaton.states.resize(4);
         for (auto &state: automaton.states) {
-            state = std::make_shared<NonParametricTAState<int> >(false);
+            state = std::make_shared<NonParametricTAState<int, double> >(false);
         }
         automaton.initialStates = {automaton.states.front()};
         automaton.states[0]->isMatch = false;
@@ -86,8 +86,8 @@ struct CopyFixture {
             NonSymbolic::Update<int> update;
             std::vector<VariableID> resetVars;
 
-            std::vector<TimingConstraint> guard;
-            guard.push_back(ConstraintMaker(0) < 3);
+            std::vector<TimingConstraint<double>> guard;
+            guard.push_back(ConstraintMaker(0) < 3.);
 
             automaton.states[1]->next[0][0] = {
                 std::move(stringConstraints),
@@ -108,8 +108,8 @@ struct CopyFixture {
             NonSymbolic::Update<int> update;
             std::vector<VariableID> resetVars;
 
-            std::vector<TimingConstraint> guard;
-            guard.push_back(ConstraintMaker(0) < 3);
+            std::vector<TimingConstraint<double>> guard;
+            guard.push_back(ConstraintMaker(0) < 3.);
 
             automaton.states[1]->next[0][1] = {
                 std::move(stringConstraints),
@@ -132,8 +132,8 @@ struct CopyFixture {
             NonSymbolic::Update<int> update;
             std::vector<VariableID> resetVars;
 
-            std::vector<TimingConstraint> guard;
-            guard.push_back(ConstraintMaker(0) < 3);
+            std::vector<TimingConstraint<double>> guard;
+            guard.push_back(ConstraintMaker(0) < 3.);
 
             automaton.states[1]->next[0][2] = {
                 std::move(stringConstraints),
@@ -159,8 +159,8 @@ struct CopyFixture {
             NonSymbolic::Update<int> update;
             std::vector<VariableID> resetVars;
 
-            std::vector<TimingConstraint> guard;
-            guard.push_back(ConstraintMaker(0) <= 5);
+            std::vector<TimingConstraint<double>> guard;
+            guard.push_back(ConstraintMaker(0) <= 5.);
 
             automaton.states[2]->next[0][0] = {
                 std::move(stringConstraints),
@@ -181,8 +181,8 @@ struct CopyFixture {
             NonSymbolic::Update<int> update;
             std::vector<VariableID> resetVars;
 
-            std::vector<TimingConstraint> guard;
-            guard.push_back(ConstraintMaker(0) <= 5);
+            std::vector<TimingConstraint<double>> guard;
+            guard.push_back(ConstraintMaker(0) <= 5.);
 
             automaton.states[2]->next[0][1] = {
                 std::move(stringConstraints),
@@ -205,8 +205,8 @@ struct CopyFixture {
             NonSymbolic::Update<int> update;
             std::vector<VariableID> resetVars;
 
-            std::vector<TimingConstraint> guard;
-            guard.push_back(ConstraintMaker(0) < 3);
+            std::vector<TimingConstraint<double>> guard;
+            guard.push_back(ConstraintMaker(0) < 3.);
 
             automaton.states[2]->next[0][2] = {
                 std::move(stringConstraints),
@@ -225,8 +225,8 @@ struct CopyFixture {
             NonSymbolic::Update<int> update;
             std::vector<VariableID> resetVars;
 
-            std::vector<TimingConstraint> guard;
-            guard.push_back(ConstraintMaker(0) > 5);
+            std::vector<TimingConstraint<double>> guard;
+            guard.push_back(ConstraintMaker(0) > 5.);
 
             automaton.states[2]->next[0][3] = {
                 std::move(stringConstraints),
@@ -239,13 +239,13 @@ struct CopyFixture {
         }
     }
 
-    NonParametricTA<int> automaton;
+    NonParametricTA<int, double> automaton;
     std::unique_ptr<Signature> signature;
 };
 
 
 struct DataParametricCopy {
-    DataParametricTA automaton;
+    DataParametricTA<double> automaton;
     std::unique_ptr<Signature> signature;
 
     DataParametricCopy() {
@@ -257,7 +257,7 @@ struct DataParametricCopy {
         // Construct automaton
         automaton.states.resize(4);
         for (auto &state: automaton.states) {
-            state = std::make_shared<DataParametricTAState>(false);
+            state = std::make_shared<DataParametricTAState<double>>(false);
         }
         automaton.initialStates = {automaton.states.front()};
         automaton.states[0]->isMatch = false;
@@ -312,8 +312,8 @@ struct DataParametricCopy {
             std::vector<NumberConstraint> numConstraints;
             numConstraints.push_back(Variable(0) > Variable(1));
 
-            std::vector<TimingConstraint> guard;
-            guard.push_back(ConstraintMaker(0) < 3);
+            std::vector<TimingConstraint<double>> guard;
+            guard.push_back(ConstraintMaker(0) < 3.);
 
             automaton.states[1]->next[0][0] = {
                 std::move(stringConstraints),
@@ -336,8 +336,8 @@ struct DataParametricCopy {
             std::vector<NumberConstraint> numConstraints;
             numConstraints.push_back(Variable(0) < Variable(1));
 
-            std::vector<TimingConstraint> guard;
-            guard.push_back(ConstraintMaker(0) < 3);
+            std::vector<TimingConstraint<double>> guard;
+            guard.push_back(ConstraintMaker(0) < 3.);
 
             automaton.states[1]->next[0][1] = {
                 std::move(stringConstraints),
@@ -358,8 +358,8 @@ struct DataParametricCopy {
 
             std::vector<NumberConstraint> numConstraints;
 
-            std::vector<TimingConstraint> guard;
-            guard.push_back(ConstraintMaker(0) < 3);
+            std::vector<TimingConstraint<double>> guard;
+            guard.push_back(ConstraintMaker(0) < 3.);
 
             automaton.states[1]->next[0][2] = {
                 std::move(stringConstraints),
@@ -382,8 +382,8 @@ struct DataParametricCopy {
             std::vector<NumberConstraint> numConstraints;
             numConstraints.push_back(Variable(0) == Variable(1));
 
-            std::vector<TimingConstraint> guard;
-            guard.push_back(ConstraintMaker(0) < 3);
+            std::vector<TimingConstraint<double>> guard;
+            guard.push_back(ConstraintMaker(0) < 3.);
 
             automaton.states[1]->next[0][3] = {
                 std::move(stringConstraints),
@@ -409,8 +409,8 @@ struct DataParametricCopy {
             std::vector<NumberConstraint> numConstraints;
             numConstraints.push_back(Variable(0) == Variable(1));
 
-            std::vector<TimingConstraint> guard;
-            guard.push_back(ConstraintMaker(0) < 5);
+            std::vector<TimingConstraint<double>> guard;
+            guard.push_back(ConstraintMaker(0) < 5.);
 
             automaton.states[2]->next[0][0] = {
                 std::move(stringConstraints),
@@ -431,8 +431,8 @@ struct DataParametricCopy {
 
             std::vector<NumberConstraint> numConstraints;
 
-            std::vector<TimingConstraint> guard;
-            guard.push_back(ConstraintMaker(0) < 5);
+            std::vector<TimingConstraint<double>> guard;
+            guard.push_back(ConstraintMaker(0) < 5.);
 
             automaton.states[2]->next[0][1] = {
                 std::move(stringConstraints),
@@ -455,8 +455,8 @@ struct DataParametricCopy {
             std::vector<NumberConstraint> numConstraints;
             numConstraints.push_back(Variable(0) > Variable(1));
 
-            std::vector<TimingConstraint> guard;
-            guard.push_back(ConstraintMaker(0) < 3);
+            std::vector<TimingConstraint<double>> guard;
+            guard.push_back(ConstraintMaker(0) < 3.);
 
             automaton.states[2]->next[0][2] = {
                 std::move(stringConstraints),
@@ -479,8 +479,8 @@ struct DataParametricCopy {
             std::vector<NumberConstraint> numConstraints;
             numConstraints.push_back(Variable(0) < Variable(1));
 
-            std::vector<TimingConstraint> guard;
-            guard.push_back(ConstraintMaker(0) < 3);
+            std::vector<TimingConstraint<double>> guard;
+            guard.push_back(ConstraintMaker(0) < 3.);
 
             automaton.states[2]->next[0][3] = {
                 std::move(stringConstraints),
@@ -499,8 +499,8 @@ struct DataParametricCopy {
             std::vector<StringConstraint> stringConstraints;
             std::vector<NumberConstraint> numConstraints;
 
-            std::vector<TimingConstraint> guard;
-            guard.push_back(ConstraintMaker(0) > 5);
+            std::vector<TimingConstraint<double>> guard;
+            guard.push_back(ConstraintMaker(0) > 5.);
 
             automaton.states[2]->next[0][4] = {
                 std::move(stringConstraints),
diff --git a/test/fixture/epsilon_transition_automaton_fixture.hh b/test/fixture/epsilon_transition_automaton_fixture.hh
index 4f5a82c..9c205c3 100644
--- a/test/fixture/epsilon_transition_automaton_fixture.hh
+++ b/test/fixture/epsilon_transition_automaton_fixture.hh
@@ -25,14 +25,14 @@ class AutomatonFixture {
         AutomatonFixture(std::string dotStr):dotString(dotStr) {}
 
         auto makeBooleanTA() const {
-            using TAType = NonParametricTA<int>;
-            using BoostTAType = NonParametricBoostTA<int>;
+            using TAType = NonParametricTA<int, double>;
+            using BoostTAType = NonParametricBoostTA<int, double>;
             return parseDotTA<TAType, BoostTAType>(dotString);
         }
 
         auto makeDataParametricTA() const {
-            using TAType = DataParametricTA;
-            using BoostTAType = DataParametricBoostTA;
+            using TAType = DataParametricTA<double>;
+            using BoostTAType = DataParametricBoostTA<double>;
             return parseDotTA<TAType, BoostTAType>(dotString);
         }
 };
diff --git a/test/fixture/non_integer_timestamp_fixture.hh b/test/fixture/non_integer_timestamp_fixture.hh
index 973d0ca..fd31e06 100644
--- a/test/fixture/non_integer_timestamp_fixture.hh
+++ b/test/fixture/non_integer_timestamp_fixture.hh
@@ -12,7 +12,7 @@ namespace NonParametric {
     @brief Automaton with a guard restricting time to non-integer values.
     */
     struct NonIntegerTimestampFixture {
-        NonParametricTA<double> automaton;
+        NonParametricTA<double, double> automaton;
         std::unique_ptr<Signature> signature;
         NonIntegerTimestampFixture() {
             // Construct signature
@@ -23,7 +23,7 @@ namespace NonParametric {
             // Construct automaton with 2 states
             automaton.states.resize(2);
             for (auto &state: automaton.states) {
-                state = std::make_shared<NonParametricTAState<double> >(false);
+                state = std::make_shared<NonParametricTAState<double, double> >(false);
             }
             automaton.initialStates = {automaton.states[0]};
             automaton.states[0]->isMatch = false;  // Initial state is not final
@@ -56,7 +56,7 @@ namespace NonParametric {
                 std::vector<NonSymbolic::NumberConstraint<double> > numConstraints;
                 NonSymbolic::Update<double> update;
                 std::vector<VariableID> resetVars;
-                std::vector<TimingConstraint> guard;
+                std::vector<TimingConstraint<double>> guard;
                 guard.push_back(ConstraintMaker(0) >= 1.1);
                 guard.push_back(ConstraintMaker(0) < 1.2);
                 
@@ -79,7 +79,7 @@ namespace Parametric {
     @brief Data parametric version of the non-integer timestamp automaton fixture.
     */
     struct DataParametricNonIntegerTimestampFixture {
-        DataParametricTA automaton;
+        DataParametricTA<double> automaton;
         std::unique_ptr<Signature> signature;
         DataParametricNonIntegerTimestampFixture() {
             using namespace Symbolic;
@@ -93,7 +93,7 @@ namespace Parametric {
             // Construct automaton with 2 states
             automaton.states.resize(2);
             for (auto &state: automaton.states) {
-                state = std::make_shared<DataParametricTAState>(false);
+                state = std::make_shared<DataParametricTAState<double>>(false);
             }
             automaton.initialStates = {automaton.states[0]};
             automaton.states[0]->isMatch = false;  // Initial state is not final
@@ -126,7 +126,7 @@ namespace Parametric {
                 std::vector<NumberConstraint> numConstraints;
                 Update update;
                 std::vector<VariableID> resetVars;
-                std::vector<TimingConstraint> guard;
+                std::vector<TimingConstraint<double>> guard;
                 guard.push_back(ConstraintMaker(0) >= 1.1);
                 guard.push_back(ConstraintMaker(0) < 1.2);
                 
diff --git a/test/fixture/star_automaton_fixture.hh b/test/fixture/star_automaton_fixture.hh
index b487c4d..d2c28a7 100644
--- a/test/fixture/star_automaton_fixture.hh
+++ b/test/fixture/star_automaton_fixture.hh
@@ -21,7 +21,7 @@ struct StarAutomatonFixture {
         // Construct automaton with 3 states
         automaton.states.resize(3);
         for (auto &state: automaton.states) {
-            state = std::make_shared<NonParametricTAState<int> >(false);
+            state = std::make_shared<NonParametricTAState<int, int> >(false);
         }
         automaton.initialStates = {automaton.states[0]};
         automaton.states[0]->isMatch = false;  // Initial state is not final
@@ -73,7 +73,7 @@ struct StarAutomatonFixture {
         }
     }
 
-    NonParametricTA<int> automaton;
+    NonParametricTA<int, int> automaton;
     std::unique_ptr<Signature> signature;
 };
 
@@ -96,7 +96,7 @@ struct DataParametricStarAutomaton {
         // Construct automaton with 3 states
         automaton.states.resize(3);
         for (auto &state: automaton.states) {
-            state = std::make_shared<DataParametricTAState>(false);
+            state = std::make_shared<DataParametricTAState<int>>(false);
         }
         automaton.initialStates = {automaton.states[0]};
         automaton.states[0]->isMatch = false;  // Initial state is not final
@@ -148,7 +148,7 @@ struct DataParametricStarAutomaton {
         }
     }
 
-    DataParametricTA automaton;
+    DataParametricTA<int> automaton;
     std::unique_ptr<Signature> signature;
 };
 
diff --git a/test/fixture/time_restriction_automaton_fixture.hh b/test/fixture/time_restriction_automaton_fixture.hh
index 66ee572..be213d0 100644
--- a/test/fixture/time_restriction_automaton_fixture.hh
+++ b/test/fixture/time_restriction_automaton_fixture.hh
@@ -21,7 +21,7 @@ struct TimeRestrictionFixture {
         // Construct automaton with 2 states
         automaton.states.resize(2);
         for (auto &state: automaton.states) {
-            state = std::make_shared<NonParametricTAState<int> >(false);
+            state = std::make_shared<NonParametricTAState<int, double> >(false);
         }
         automaton.initialStates = {automaton.states[0]};
         automaton.states[0]->isMatch = false;  // Initial state is not final
@@ -52,7 +52,7 @@ struct TimeRestrictionFixture {
         }
     }
 
-    NonParametricTA<int> automaton;
+    NonParametricTA<int, double> automaton;
     std::unique_ptr<Signature> signature;
 };
 
@@ -75,7 +75,7 @@ struct DataParametricTimeRestrictionFixture {
         // Construct automaton with 2 states
         automaton.states.resize(2);
         for (auto &state: automaton.states) {
-            state = std::make_shared<DataParametricTAState>(false);
+            state = std::make_shared<DataParametricTAState<double>>(false);
         }
         automaton.initialStates = {automaton.states[0]};
         automaton.states[0]->isMatch = false;  // Initial state is not final
@@ -106,7 +106,7 @@ struct DataParametricTimeRestrictionFixture {
         }
     }
 
-    DataParametricTA automaton;
+    DataParametricTA<double> automaton;
     std::unique_ptr<Signature> signature;
 };
 
diff --git a/test/fixture/withdraw_automaton_fixture.hh b/test/fixture/withdraw_automaton_fixture.hh
index 3b3f69e..bde4d79 100644
--- a/test/fixture/withdraw_automaton_fixture.hh
+++ b/test/fixture/withdraw_automaton_fixture.hh
@@ -22,7 +22,7 @@ struct WithdrawFixture {
         // Construct automaton
         automaton.states.resize(3);
         for (auto &state: automaton.states) {
-            state = std::make_shared<NonParametricTAState<int> >(false);
+            state = std::make_shared<NonParametricTAState<int, double> >(false);
         }
         automaton.initialStates = {automaton.states.front()};
         automaton.states[0]->isMatch = false;
@@ -34,11 +34,11 @@ struct WithdrawFixture {
         automaton.numberVariableSize = 1;
 
         // Create timing constraints
-        std::vector<TimingConstraint> lessThanEqual30;
-        lessThanEqual30.push_back(ConstraintMaker(0) <= 30);
+        std::vector<TimingConstraint<double>> lessThanEqual30;
+        lessThanEqual30.push_back(ConstraintMaker(0) <= 30.);
 
-        std::vector<TimingConstraint> greaterThan30;
-        greaterThan30.push_back(ConstraintMaker(0) > 30);
+        std::vector<TimingConstraint<double>> greaterThan30;
+        greaterThan30.push_back(ConstraintMaker(0) > 30.);
 
         // #### FROM STATE 0 ####
         automaton.states[0]->next[0].resize(2);
@@ -146,7 +146,7 @@ struct WithdrawFixture {
         }
     }
 
-    NonParametricTA<int> automaton;
+    NonParametricTA<int, double> automaton;
     std::unique_ptr<Signature> signature;
 };
 
@@ -164,7 +164,7 @@ struct DataParametricWithdrawFixture {
         // Construct automaton
         automaton.states.resize(3);
         for (auto &state: automaton.states) {
-            state = std::make_shared<DataParametricTAState>(false);
+            state = std::make_shared<DataParametricTAState<double>>(false);
         }
         automaton.initialStates = {automaton.states.front()};
         automaton.states[0]->isMatch = false;
@@ -176,11 +176,11 @@ struct DataParametricWithdrawFixture {
         automaton.numberVariableSize = 1;
 
         // Create timing constraints
-        std::vector<TimingConstraint> lessThanEqual30;
-        lessThanEqual30.push_back(ConstraintMaker(0) <= 30);
+        std::vector<TimingConstraint<double>> lessThanEqual30;
+        lessThanEqual30.push_back(ConstraintMaker(0) <= 30.);
 
-        std::vector<TimingConstraint> greaterThan30;
-        greaterThan30.push_back(ConstraintMaker(0) > 30);
+        std::vector<TimingConstraint<double>> greaterThan30;
+        greaterThan30.push_back(ConstraintMaker(0) > 30.);
 
         // #### FROM STATE 0 ####
         automaton.states[0]->next[0].resize(2);
@@ -288,7 +288,7 @@ struct DataParametricWithdrawFixture {
         }
     }
 
-    DataParametricTA automaton;
+    DataParametricTA<double> automaton;
     std::unique_ptr<Signature> signature;
 };
 
diff --git a/test/symon_parser_test.cc b/test/symon_parser_test.cc
index ea21f3e..a0afced 100644
--- a/test/symon_parser_test.cc
+++ b/test/symon_parser_test.cc
@@ -26,7 +26,7 @@ BOOST_AUTO_TEST_SUITE(SymonParserTests)
     using Update = Update<int>;
 
         struct CopyParserFixture {
-            SymonParser<StringConstraint, NumberConstraint<int>, std::vector<TimingConstraint>, Update> parser;
+            SymonParser<StringConstraint, NumberConstraint<int>, std::vector<TimingConstraint<double>>, Update> parser;
             const std::string path = PROJECT_ROOT "/example/copy/copy.symon";
 
             CopyParserFixture() {
@@ -44,18 +44,18 @@ BOOST_AUTO_TEST_SUITE(SymonParserTests)
         }
 
         BOOST_FIXTURE_TEST_CASE(declarations, CopyParserFixture) {
-            const NonParametricTA<int> automaton = parser.getAutomaton();
+            const NonParametricTA<int, double> automaton = parser.getAutomaton();
             BOOST_CHECK_EQUAL(automaton.numberVariableSize, 1);
             BOOST_CHECK_EQUAL(automaton.stringVariableSize, 0);
             BOOST_CHECK_EQUAL(automaton.clockVariableSize, 1);
         }
 
         BOOST_AUTO_TEST_CASE(atomic) {
-            SymonParser<StringConstraint, NumberConstraint<int>, std::vector<TimingConstraint>, Update> parser;
+            SymonParser<StringConstraint, NumberConstraint<int>, std::vector<TimingConstraint<double>>, Update> parser;
             const std::string content = "signature update {id: string;value: number;} update(id, value)";
             parser.parse(content);
 
-            const NonParametricTA<int> automaton = parser.getAutomaton();
+            const NonParametricTA<int, double> automaton = parser.getAutomaton();
             BOOST_CHECK_EQUAL(automaton.numberVariableSize, 0);
             BOOST_CHECK_EQUAL(automaton.stringVariableSize, 0);
             BOOST_CHECK_EQUAL(automaton.clockVariableSize, 0);
@@ -81,11 +81,11 @@ BOOST_AUTO_TEST_SUITE(SymonParserTests)
         }
 
         BOOST_AUTO_TEST_CASE(stringConstraint) {
-            SymonParser<StringConstraint, NumberConstraint<int>, std::vector<TimingConstraint>, Update> parser;
+            SymonParser<StringConstraint, NumberConstraint<int>, std::vector<TimingConstraint<double>>, Update> parser;
             const std::string content = "signature update {id: string;value: number;} update(id, value | id == \"y\")";
             parser.parse(content);
 
-            const NonParametricTA<int> automaton = parser.getAutomaton();
+            const NonParametricTA<int, double> automaton = parser.getAutomaton();
             BOOST_CHECK_EQUAL(automaton.numberVariableSize, 0);
             BOOST_CHECK_EQUAL(automaton.stringVariableSize, 0);
             BOOST_CHECK_EQUAL(automaton.clockVariableSize, 0);
@@ -114,11 +114,11 @@ BOOST_AUTO_TEST_SUITE(SymonParserTests)
         }
 
         BOOST_AUTO_TEST_CASE(timingConstraint) {
-            SymonParser<StringConstraint, NumberConstraint<int>, std::vector<TimingConstraint>, Update> parser;
+            SymonParser<StringConstraint, NumberConstraint<int>, std::vector<TimingConstraint<double>>, Update> parser;
             const std::string content = "signature update {id: string;value: number;} (update(id, value))%(< 5)";
             parser.parse(content);
 
-            const NonParametricTA<int> automaton = parser.getAutomaton();
+            const NonParametricTA<int, double> automaton = parser.getAutomaton();
             BOOST_CHECK_EQUAL(automaton.numberVariableSize, 0);
             BOOST_CHECK_EQUAL(automaton.stringVariableSize, 0);
             BOOST_CHECK_EQUAL(automaton.clockVariableSize, 1);
@@ -139,18 +139,18 @@ BOOST_AUTO_TEST_SUITE(SymonParserTests)
             BOOST_CHECK_EQUAL(automaton.states[0]->next[0].front().numConstraints.size(), 0);
             BOOST_CHECK_EQUAL(automaton.states[0]->next[0].front().guard.size(), 1);
             BOOST_CHECK_EQUAL(automaton.states[0]->next[0].front().guard.front().x, VariableID{0});
-            BOOST_CHECK_EQUAL(automaton.states[0]->next[0].front().guard.front().odr, TimingConstraint::Order::lt);
+            BOOST_CHECK_EQUAL(automaton.states[0]->next[0].front().guard.front().odr, TimingConstraintOrder::lt);
             BOOST_CHECK_EQUAL(automaton.states[0]->next[0].front().guard.front().c, 5);
             BOOST_CHECK_EQUAL(automaton.states[0]->next[0].front().update.stringUpdate.size(), 0);
             BOOST_CHECK_EQUAL(automaton.states[0]->next[0].front().update.numberUpdate.size(), 0);
         }
 
         BOOST_AUTO_TEST_CASE(concat) {
-            SymonParser<StringConstraint, NumberConstraint<int>, std::vector<TimingConstraint>, Update> parser;
+            SymonParser<StringConstraint, NumberConstraint<int>, std::vector<TimingConstraint<double>>, Update> parser;
             const std::string content = "signature update {id: string;value: number;} update(id, value); update(id, value)";
             parser.parse(content);
 
-            const NonParametricTA<int> automaton = parser.getAutomaton();
+            const NonParametricTA<int, double> automaton = parser.getAutomaton();
             BOOST_CHECK_EQUAL(automaton.numberVariableSize, 0);
             BOOST_CHECK_EQUAL(automaton.stringVariableSize, 0);
             BOOST_CHECK_EQUAL(automaton.clockVariableSize, 0);
@@ -194,11 +194,11 @@ BOOST_AUTO_TEST_SUITE(SymonParserTests)
         }
 
         BOOST_AUTO_TEST_CASE(orEmpty) {
-            SymonParser<StringConstraint, NumberConstraint<int>, std::vector<TimingConstraint>, Update> parser;
+            SymonParser<StringConstraint, NumberConstraint<int>, std::vector<TimingConstraint<double>>, Update> parser;
             const std::string content = "signature update {id: string;value: number;} (update(id, value))?";
             parser.parse(content);
 
-            const NonParametricTA<int> automaton = parser.getAutomaton();
+            const NonParametricTA<int, double> automaton = parser.getAutomaton();
             BOOST_CHECK_EQUAL(automaton.numberVariableSize, 0);
             BOOST_CHECK_EQUAL(automaton.stringVariableSize, 0);
             BOOST_CHECK_EQUAL(automaton.clockVariableSize, 0);
@@ -234,11 +234,11 @@ BOOST_AUTO_TEST_SUITE(SymonParserTests)
         }
 
         BOOST_AUTO_TEST_CASE(plus) {
-            SymonParser<StringConstraint, NumberConstraint<int>, std::vector<TimingConstraint>, Update> parser;
+            SymonParser<StringConstraint, NumberConstraint<int>, std::vector<TimingConstraint<double>>, Update> parser;
             const std::string content = "signature update {id: string;value: number;} (update(id, value))+";
             parser.parse(content);
 
-            const NonParametricTA<int> automaton = parser.getAutomaton();
+            const NonParametricTA<int, double> automaton = parser.getAutomaton();
             BOOST_CHECK_EQUAL(automaton.numberVariableSize, 0);
             BOOST_CHECK_EQUAL(automaton.stringVariableSize, 0);
             BOOST_CHECK_EQUAL(automaton.clockVariableSize, 0);
@@ -278,11 +278,11 @@ BOOST_AUTO_TEST_SUITE(SymonParserTests)
         }
 
         BOOST_AUTO_TEST_CASE(one_or_more) {
-            SymonParser<StringConstraint, NumberConstraint<int>, std::vector<TimingConstraint>, Update> parser;
+            SymonParser<StringConstraint, NumberConstraint<int>, std::vector<TimingConstraint<double>>, Update> parser;
             const std::string content = "signature update {id: string;value: number;} one_or_more {update(id, value)}";
             parser.parse(content);
 
-            const NonParametricTA<int> automaton = parser.getAutomaton();
+            const NonParametricTA<int, double> automaton = parser.getAutomaton();
             BOOST_CHECK_EQUAL(automaton.numberVariableSize, 0);
             BOOST_CHECK_EQUAL(automaton.stringVariableSize, 0);
             BOOST_CHECK_EQUAL(automaton.clockVariableSize, 0);
@@ -322,11 +322,11 @@ BOOST_AUTO_TEST_SUITE(SymonParserTests)
         }
 
         BOOST_AUTO_TEST_CASE(star) {
-            SymonParser<StringConstraint, NumberConstraint<int>, std::vector<TimingConstraint>, Update> parser;
+            SymonParser<StringConstraint, NumberConstraint<int>, std::vector<TimingConstraint<double>>, Update> parser;
             const std::string content = "signature update {id: string;value: number;} (update(id, value))*";
             parser.parse(content);
 
-            const NonParametricTA<int> automaton = parser.getAutomaton();
+            const NonParametricTA<int, double> automaton = parser.getAutomaton();
             BOOST_CHECK_EQUAL(automaton.numberVariableSize, 0);
             BOOST_CHECK_EQUAL(automaton.stringVariableSize, 0);
             BOOST_CHECK_EQUAL(automaton.clockVariableSize, 0);
@@ -372,11 +372,11 @@ BOOST_AUTO_TEST_SUITE(SymonParserTests)
         }
 
         BOOST_AUTO_TEST_CASE(zero_or_more) {
-            SymonParser<StringConstraint, NumberConstraint<int>, std::vector<TimingConstraint>, Update> parser;
+            SymonParser<StringConstraint, NumberConstraint<int>, std::vector<TimingConstraint<double>>, Update> parser;
             const std::string content = "signature update {id: string;value: number;} zero_or_more{update(id, value)}";
             parser.parse(content);
 
-            const NonParametricTA<int> automaton = parser.getAutomaton();
+            const NonParametricTA<int, double> automaton = parser.getAutomaton();
             BOOST_CHECK_EQUAL(automaton.numberVariableSize, 0);
             BOOST_CHECK_EQUAL(automaton.stringVariableSize, 0);
             BOOST_CHECK_EQUAL(automaton.clockVariableSize, 0);
@@ -422,11 +422,11 @@ BOOST_AUTO_TEST_SUITE(SymonParserTests)
         }
 
         BOOST_AUTO_TEST_CASE(orEmptyConcat) {
-            SymonParser<StringConstraint, NumberConstraint<int>, std::vector<TimingConstraint>, Update> parser;
+            SymonParser<StringConstraint, NumberConstraint<int>, std::vector<TimingConstraint<double>>, Update> parser;
             const std::string content = "signature update {id: string;value: number;} (update(id, value))?;update(id, value)";
             parser.parse(content);
 
-            const NonParametricTA<int> automaton = parser.getAutomaton();
+            const NonParametricTA<int, double> automaton = parser.getAutomaton();
             BOOST_CHECK_EQUAL(automaton.numberVariableSize, 0);
             BOOST_CHECK_EQUAL(automaton.stringVariableSize, 0);
             BOOST_CHECK_EQUAL(automaton.clockVariableSize, 0);
@@ -472,11 +472,11 @@ BOOST_AUTO_TEST_SUITE(SymonParserTests)
         }
 
         BOOST_AUTO_TEST_CASE(timingConstraintConcat) {
-            SymonParser<StringConstraint, NumberConstraint<int>, std::vector<TimingConstraint>, Update> parser;
+            SymonParser<StringConstraint, NumberConstraint<int>, std::vector<TimingConstraint<double>>, Update> parser;
             const std::string content = "signature update {id: string;value: number;} update(id, value); (update(id, value))%(> 5)";
             parser.parse(content);
 
-            const NonParametricTA<int> automaton = parser.getAutomaton();
+            const NonParametricTA<int, double> automaton = parser.getAutomaton();
             BOOST_CHECK_EQUAL(automaton.numberVariableSize, 0);
             BOOST_CHECK_EQUAL(automaton.stringVariableSize, 0);
             BOOST_CHECK_EQUAL(automaton.clockVariableSize, 1);
@@ -513,7 +513,7 @@ BOOST_AUTO_TEST_SUITE(SymonParserTests)
             BOOST_CHECK_EQUAL(automaton.states[1]->next[0].front().numConstraints.size(), 0);
             BOOST_CHECK_EQUAL(automaton.states[1]->next[0].front().guard.size(), 1);
             BOOST_CHECK_EQUAL(automaton.states[1]->next[0].front().guard.front().x, VariableID{0});
-            BOOST_CHECK_EQUAL(automaton.states[1]->next[0].front().guard.front().odr, TimingConstraint::Order::gt);
+            BOOST_CHECK_EQUAL(automaton.states[1]->next[0].front().guard.front().odr, TimingConstraintOrder::gt);
             BOOST_CHECK_EQUAL(automaton.states[1]->next[0].front().guard.front().c, 5);
             BOOST_CHECK_EQUAL(automaton.states[1]->next[0].front().update.stringUpdate.size(), 0);
             BOOST_CHECK_EQUAL(automaton.states[1]->next[0].front().update.numberUpdate.size(), 0);
@@ -522,11 +522,11 @@ BOOST_AUTO_TEST_SUITE(SymonParserTests)
         }
 
         BOOST_AUTO_TEST_CASE(optionalWithTimingConstraintLT) {
-            SymonParser<StringConstraint, NumberConstraint<int>, std::vector<TimingConstraint>, Update> parser;
+            SymonParser<StringConstraint, NumberConstraint<int>, std::vector<TimingConstraint<double>>, Update> parser;
             const std::string content = "signature update {id: string;value: number;} (update(id, value)?)%(< 3)";
             parser.parse(content);
 
-            const NonParametricTA<int> automaton = parser.getAutomaton();
+            const NonParametricTA<int, double> automaton = parser.getAutomaton();
             BOOST_CHECK_EQUAL(automaton.numberVariableSize, 0);
             BOOST_CHECK_EQUAL(automaton.stringVariableSize, 0);
             BOOST_CHECK_EQUAL(automaton.clockVariableSize, 1);
@@ -558,7 +558,7 @@ BOOST_AUTO_TEST_SUITE(SymonParserTests)
             // The transition should have the timing constraint < 3
             BOOST_CHECK_EQUAL(automaton.states[0]->next[0].front().guard.size(), 1);
             BOOST_CHECK_EQUAL(automaton.states[0]->next[0].front().guard.front().x, VariableID{0});
-            BOOST_CHECK_EQUAL(automaton.states[0]->next[0].front().guard.front().odr, TimingConstraint::Order::lt);
+            BOOST_CHECK_EQUAL(automaton.states[0]->next[0].front().guard.front().odr, TimingConstraintOrder::lt);
             BOOST_CHECK_EQUAL(automaton.states[0]->next[0].front().guard.front().c, 3);
             
             // The final states should have no transitions
@@ -567,11 +567,11 @@ BOOST_AUTO_TEST_SUITE(SymonParserTests)
         }
 
         BOOST_AUTO_TEST_CASE(optionalWithTimingConstraintGT) {
-            SymonParser<StringConstraint, NumberConstraint<int>, std::vector<TimingConstraint>, Update> parser;
+            SymonParser<StringConstraint, NumberConstraint<int>, std::vector<TimingConstraint<double>>, Update> parser;
             const std::string content = "signature update {id: string;value: number;} (update(id, value)?)%(> 3)";
             parser.parse(content);
 
-            const NonParametricTA<int> automaton = parser.getAutomaton();
+            const NonParametricTA<int, double> automaton = parser.getAutomaton();
             BOOST_CHECK_EQUAL(automaton.numberVariableSize, 0);
             BOOST_CHECK_EQUAL(automaton.stringVariableSize, 0);
             BOOST_CHECK_EQUAL(automaton.clockVariableSize, 1);
@@ -603,7 +603,7 @@ BOOST_AUTO_TEST_SUITE(SymonParserTests)
             // The transition should have timing constraint > 3
             BOOST_CHECK_EQUAL(automaton.states[0]->next[0].front().guard.size(), 1);
             BOOST_CHECK_EQUAL(automaton.states[0]->next[0].front().guard.front().x, VariableID{0});
-            BOOST_CHECK_EQUAL(automaton.states[0]->next[0].front().guard.front().odr, TimingConstraint::Order::gt);
+            BOOST_CHECK_EQUAL(automaton.states[0]->next[0].front().guard.front().odr, TimingConstraintOrder::gt);
             BOOST_CHECK_EQUAL(automaton.states[0]->next[0].front().guard.front().c, 3);
             
             // The intermediate state should have transitions for the update operation
@@ -611,11 +611,11 @@ BOOST_AUTO_TEST_SUITE(SymonParserTests)
         }
 
         BOOST_AUTO_TEST_CASE(concatOptionalWithTimingConstraint) {
-            SymonParser<StringConstraint, NumberConstraint<int>, std::vector<TimingConstraint>, Update> parser;
+            SymonParser<StringConstraint, NumberConstraint<int>, std::vector<TimingConstraint<double>>, Update> parser;
             const std::string content = "signature update {id: string;value: number;} update(id, value); (update(id, value)?)%(< 3)";
             parser.parse(content);
 
-            const NonParametricTA<int> automaton = parser.getAutomaton();
+            const NonParametricTA<int, double> automaton = parser.getAutomaton();
             BOOST_CHECK_EQUAL(automaton.numberVariableSize, 0);
             BOOST_CHECK_EQUAL(automaton.stringVariableSize, 0);
             BOOST_CHECK_EQUAL(automaton.clockVariableSize, 1);
@@ -661,7 +661,7 @@ BOOST_AUTO_TEST_SUITE(SymonParserTests)
             // The transition should have timing constraint < 3
             BOOST_CHECK_EQUAL(automaton.states[1]->next[0].front().guard.size(), 1);
             BOOST_CHECK_EQUAL(automaton.states[1]->next[0].front().guard.front().x, VariableID{0});
-            BOOST_CHECK_EQUAL(automaton.states[1]->next[0].front().guard.front().odr, TimingConstraint::Order::lt);
+            BOOST_CHECK_EQUAL(automaton.states[1]->next[0].front().guard.front().odr, TimingConstraintOrder::lt);
             BOOST_CHECK_EQUAL(automaton.states[1]->next[0].front().guard.front().c, 3);
             
             // The final state should have no transitions
@@ -673,7 +673,7 @@ BOOST_AUTO_TEST_SUITE(SymonParserTests)
             // only the upper bound is added to all transitions
             
             // Create a parser
-            SymonParser<StringConstraint, NumberConstraint<int>, std::vector<TimingConstraint>, Update> parser;
+            SymonParser<StringConstraint, NumberConstraint<int>, std::vector<TimingConstraint<double>>, Update> parser;
             
             // Parse a simple automaton with a timing constraint that has both upper and lower bounds
             std::string content = R"(
@@ -706,10 +706,10 @@ BOOST_AUTO_TEST_SUITE(SymonParserTests)
             bool hasUpperBound = false;
             
             for (const auto& constraint : automaton.states[0]->next[0].front().guard) {
-                if (constraint.odr == ::TimingConstraint::Order::ge && constraint.c == 2) {
+                if (constraint.odr == ::TimingConstraintOrder::ge && constraint.c == 2) {
                     // This is the original lower bound
                     hasLowerBound = true;
-                } else if (constraint.odr == ::TimingConstraint::Order::le && constraint.c == 5) {
+                } else if (constraint.odr == ::TimingConstraintOrder::le && constraint.c == 5) {
                     // This is the original upper bound
                     hasUpperBound = true;
                 }
@@ -723,7 +723,7 @@ BOOST_AUTO_TEST_SUITE(SymonParserTests)
         }
 
         BOOST_AUTO_TEST_CASE(inits) {
-            SymonParser<StringConstraint, NumberConstraint<int>, std::vector<TimingConstraint>, Update> parser;
+            SymonParser<StringConstraint, NumberConstraint<int>, std::vector<TimingConstraint<double>>, Update> parser;
             std::ifstream ifs(PROJECT_ROOT "/example/inits.symon");
             // This should throw an exception because initial constraints are not supported in non-symbolic automata
             BOOST_CHECK_THROW(parser.parse(ifs), std::runtime_error);
@@ -733,21 +733,21 @@ BOOST_AUTO_TEST_SUITE(SymonParserTests)
             // Test that the extractUpperBound function correctly extracts the upper bound from a timing constraint
             
             // Create a timing constraint with both upper and lower bounds
-            std::vector<TimingConstraint> guard;
+            std::vector<TimingConstraint<double>> guard;
             
             // Add a lower bound: x >= 2
-            guard.push_back(TimingConstraint{VariableID{0}, TimingConstraint::Order::ge, 2});
+            guard.push_back(TimingConstraint<double>{VariableID{0}, TimingConstraintOrder::ge, 2});
             
             // Add an upper bound: x <= 5
-            guard.push_back(TimingConstraint{VariableID{0}, TimingConstraint::Order::le, 5});
+            guard.push_back(TimingConstraint<double>{VariableID{0}, TimingConstraintOrder::le, 5});
             
             // Extract the upper bound
-            auto upperBound = SymonParser<StringConstraint, NumberConstraint<int>, std::vector<TimingConstraint>, Update>::extractUpperBound(guard);
+            auto upperBound = SymonParser<StringConstraint, NumberConstraint<int>, std::vector<TimingConstraint<double>>, Update>::extractUpperBound(guard);
             
             // Verify that only the upper bound was extracted
             BOOST_CHECK_EQUAL(upperBound.size(), 1);
             BOOST_CHECK_EQUAL(upperBound[0].x, VariableID{0});
-            BOOST_CHECK_EQUAL(upperBound[0].odr, TimingConstraint::Order::le);
+            BOOST_CHECK_EQUAL(upperBound[0].odr, TimingConstraintOrder::le);
             BOOST_CHECK_EQUAL(upperBound[0].c, 5);
         }
         
@@ -755,21 +755,21 @@ BOOST_AUTO_TEST_SUITE(SymonParserTests)
             // Test that extractUpperBound for parametric and non-parametric cases are equivalent
             
             // Create a non-parametric timing constraint with both upper and lower bounds
-            std::vector<TimingConstraint> nonParametricGuard;
+            std::vector<TimingConstraint<double>> nonParametricGuard;
             
             // Add a lower bound: x >= 2
-            nonParametricGuard.push_back(TimingConstraint{VariableID{0}, TimingConstraint::Order::ge, 2});
+            nonParametricGuard.push_back(TimingConstraint<double>{VariableID{0}, TimingConstraintOrder::ge, 2});
             
             // Add an upper bound: x <= 5
-            nonParametricGuard.push_back(TimingConstraint{VariableID{0}, TimingConstraint::Order::le, 5});
+            nonParametricGuard.push_back(TimingConstraint<double>{VariableID{0}, TimingConstraintOrder::le, 5});
             
             // Extract the upper bound from the non-parametric guard
-            auto nonParametricUpperBound = SymonParser<StringConstraint, NumberConstraint<int>, std::vector<TimingConstraint>, Update>::extractUpperBound(nonParametricGuard);
+            auto nonParametricUpperBound = SymonParser<StringConstraint, NumberConstraint<int>, std::vector<TimingConstraint<double>>, Update>::extractUpperBound(nonParametricGuard);
             
             // Verify that only the upper bound was extracted
             BOOST_CHECK_EQUAL(nonParametricUpperBound.size(), 1);
             BOOST_CHECK_EQUAL(nonParametricUpperBound[0].x, VariableID{0});
-            BOOST_CHECK_EQUAL(nonParametricUpperBound[0].odr, TimingConstraint::Order::le);
+            BOOST_CHECK_EQUAL(nonParametricUpperBound[0].odr, TimingConstraintOrder::le);
             BOOST_CHECK_EQUAL(nonParametricUpperBound[0].c, 5);
             
             // Create an equivalent parametric timing constraint
@@ -807,11 +807,11 @@ BOOST_AUTO_TEST_SUITE(SymonParserTests)
         }
 
         BOOST_AUTO_TEST_CASE(case20250703_1) {
-            SymonParser<StringConstraint, NumberConstraint<int>, std::vector<TimingConstraint>, Update> parser;
+            SymonParser<StringConstraint, NumberConstraint<int>, std::vector<TimingConstraint<double>>, Update> parser;
             const std::string content = "signature A {id: string;} signature B {id: string;} ((A( id | id != \"Bob\" ) || B( id | id != \"Bob\" ))%(<= 5);B (id | id == \"Bob\"))%(> 5)";
             parser.parse(content);
 
-            const NonParametricTA<int> automaton = parser.getAutomaton();
+            const NonParametricTA<int, double> automaton = parser.getAutomaton();
             BOOST_CHECK_EQUAL(automaton.numberVariableSize, 0);
             BOOST_CHECK_EQUAL(automaton.stringVariableSize, 0);
             BOOST_CHECK_EQUAL(automaton.clockVariableSize, 1);
@@ -841,7 +841,7 @@ BOOST_AUTO_TEST_SUITE(SymonParserTests)
             // The transition should have timing constraint <= 5
             BOOST_CHECK_EQUAL(automaton.states[0]->next[0].front().guard.size(), 1);
             BOOST_CHECK_EQUAL(automaton.states[0]->next[0].front().guard.front().x, VariableID{0});
-            BOOST_CHECK_EQUAL(automaton.states[0]->next[0].front().guard.front().odr, TimingConstraint::Order::le);
+            BOOST_CHECK_EQUAL(automaton.states[0]->next[0].front().guard.front().odr, TimingConstraintOrder::le);
             BOOST_CHECK_EQUAL(automaton.states[0]->next[0].front().guard.front().c, 5);
             
             // Transition for the first B
@@ -854,7 +854,7 @@ BOOST_AUTO_TEST_SUITE(SymonParserTests)
             // The transition should have timing constraint <= 5
             BOOST_CHECK_EQUAL(automaton.states[1]->next[1].front().guard.size(), 1);
             BOOST_CHECK_EQUAL(automaton.states[1]->next[1].front().guard.front().x, VariableID{0});
-            BOOST_CHECK_EQUAL(automaton.states[1]->next[1].front().guard.front().odr, TimingConstraint::Order::le);
+            BOOST_CHECK_EQUAL(automaton.states[1]->next[1].front().guard.front().odr, TimingConstraintOrder::le);
             BOOST_CHECK_EQUAL(automaton.states[1]->next[1].front().guard.front().c, 5);
 
             // Transition for the second B
@@ -867,7 +867,7 @@ BOOST_AUTO_TEST_SUITE(SymonParserTests)
             // The transition should have timing constraint > 5
             BOOST_CHECK_EQUAL(automaton.states[2]->next[1].front().guard.size(), 1);
             BOOST_CHECK_EQUAL(automaton.states[2]->next[1].front().guard.front().x, VariableID{0});
-            BOOST_CHECK_EQUAL(automaton.states[2]->next[1].front().guard.front().odr, TimingConstraint::Order::gt);
+            BOOST_CHECK_EQUAL(automaton.states[2]->next[1].front().guard.front().odr, TimingConstraintOrder::gt);
             BOOST_CHECK_EQUAL(automaton.states[2]->next[1].front().guard.front().c, 5);
         }
 
diff --git a/test/timing_constraint_test.cc b/test/timing_constraint_test.cc
index 3f62f9c..9b3a59a 100644
--- a/test/timing_constraint_test.cc
+++ b/test/timing_constraint_test.cc
@@ -5,22 +5,22 @@
 
 BOOST_AUTO_TEST_SUITE(TimingConstraintTest)
     BOOST_AUTO_TEST_CASE(Shift) {
-        constexpr TimingConstraint constraint{0, TimingConstraint::Order::lt, 10};
+        constexpr TimingConstraint<double> constraint{0, TimingConstraintOrder::lt, 10};
         auto [x, odr, c] = constraint.shift(1);
         BOOST_CHECK_EQUAL(x, 1);
-        BOOST_CHECK_EQUAL(odr, TimingConstraint::Order::lt);
+        BOOST_CHECK_EQUAL(odr, TimingConstraintOrder::lt);
         BOOST_CHECK_EQUAL(c, 10);
     }
 
     BOOST_AUTO_TEST_CASE(Satisfy) {
-        constexpr TimingConstraint constraint{0, TimingConstraint::Order::lt, 10};
+        constexpr TimingConstraint<double> constraint{0, TimingConstraintOrder::lt, 10};
         BOOST_CHECK(constraint.satisfy(5));
         BOOST_CHECK(!constraint.satisfy(10));
         BOOST_CHECK(!constraint.satisfy(15));
     }
 
     BOOST_AUTO_TEST_CASE(Decimal) {
-        constexpr TimingConstraint constraint{1, TimingConstraint::Order::ge, 0.5};
+        constexpr TimingConstraint<double> constraint{1, TimingConstraintOrder::ge, 0.5};
         BOOST_CHECK(!constraint.satisfy(0.4));
         BOOST_CHECK(constraint.satisfy(0.5));
         BOOST_CHECK(constraint.satisfy(0.6));