Rename time types used in C++ schedulablity analysis

integral_t   == integral time units
fractional_t == fractions of integral time units

This is hopefully less of an eyesore than mpq_class and mpz_class.

22 files changed, 178 insertions, 169 deletions

diff --git a/native/include/edf/baker.h b/native/include/edf/baker.h
index c3716df..44493e5 100644
--- a/native/include/edf/baker.h
+++ b/native/include/edf/baker.h
@@ -8,8 +8,8 @@ class BakerGedf : public SchedulabilityTest
     unsigned int m;
 
  private:
-    void beta(const Task &t_i, const Task &t_k, const mpq_class &lambda_k,
-              mpq_class &beta_i);
+    void beta(const Task &t_i, const Task &t_k, const fractional_t &lambda_k,
+              fractional_t &beta_i);
     bool is_task_schedulable(unsigned int k, const TaskSet &ts);
 
  public:
diff --git a/native/include/edf/baruah.h b/native/include/edf/baruah.h
index c79b49d..f6f9217 100644
--- a/native/include/edf/baruah.h
+++ b/native/include/edf/baruah.h
@@ -9,14 +9,14 @@ private:
 
     bool is_task_schedulable(unsigned int k,
                              const TaskSet &ts,
-                             const mpz_class &ilen,
-                             mpz_class &i1,
-                             mpz_class &sum,
-                             mpz_class *idiff,
-                             mpz_class **ptr);
-
-    void get_max_test_points(const TaskSet &ts, mpq_class& m_minus_u,
-                             mpz_class* maxp);
+                             const integral_t &ilen,
+                             integral_t &i1,
+                             integral_t &sum,
+                             integral_t *idiff,
+                             integral_t **ptr);
+
+    void get_max_test_points(const TaskSet &ts, fractional_t& m_minus_u,
+                             integral_t* maxp);
 
 public:
     BaruahGedf(unsigned int num_processors) : m(num_processors) {};
diff --git a/native/include/edf/bcl.h b/native/include/edf/bcl.h
index 31bf1e3..aa4d818 100644
--- a/native/include/edf/bcl.h
+++ b/native/include/edf/bcl.h
@@ -9,7 +9,7 @@ class BCLGedf : public SchedulabilityTest
 
  private:
     unsigned long max_jobs_contained(const Task &t_i, const Task &t_k);
-    void beta(const Task &t_i, const Task &t_k, mpq_class &beta_i);
+    void beta(const Task &t_i, const Task &t_k, fractional_t &beta_i);
     bool is_task_schedulable(unsigned int k, const TaskSet &ts);
 
  public:
diff --git a/native/include/edf/ffdbf.h b/native/include/edf/ffdbf.h
index 7e3dac6..a5fb834 100644
--- a/native/include/edf/ffdbf.h
+++ b/native/include/edf/ffdbf.h
@@ -6,12 +6,12 @@ class FFDBFGedf : public SchedulabilityTest
   private:
     const unsigned int m;
     const unsigned long epsilon_denom;
-    const mpq_class sigma_step;
+    const fractional_t sigma_step;
 
   private:
     bool witness_condition(const TaskSet &ts,
-                           const mpz_class q[], const mpq_class r[],
-                           const mpq_class &time, const mpq_class &speed);
+                           const integral_t q[], const fractional_t r[],
+                           const fractional_t &time, const fractional_t &speed);
 
   public:
     FFDBFGedf(unsigned int num_processors,
diff --git a/native/include/edf/load.h b/native/include/edf/load.h
index 36c8f5a..50d7850 100644
--- a/native/include/edf/load.h
+++ b/native/include/edf/load.h
@@ -5,7 +5,7 @@ class LoadGedf : public SchedulabilityTest
 {
  private:
     unsigned int m;
-    mpq_class epsilon;
+    fractional_t epsilon;
 
  public:
     LoadGedf(unsigned int num_processors,
diff --git a/native/include/math-helper.h b/native/include/math-helper.h
index 10c42c2..063558c 100644
--- a/native/include/math-helper.h
+++ b/native/include/math-helper.h
@@ -1,12 +1,6 @@
 #ifndef MATH_HELPER_H
 #define MATH_HELPER_H
 
-static inline void mpq_truncate(mpq_class &val)
-{
-    val.get_num() -= val.get_num() % val.get_den();
-    val.canonicalize();
-}
-
 static inline unsigned long divide_with_ceil(unsigned long numer,
                                              unsigned long denom)
 {
diff --git a/native/include/tasks.h b/native/include/tasks.h
index 175206a..dbba8d1 100644
--- a/native/include/tasks.h
+++ b/native/include/tasks.h
@@ -6,10 +6,10 @@
 #include <vector>
 #include <algorithm>
 
-#include <gmpxx.h>
-
 #include <math.h>
 
+#include "time-types.h"
+
 #endif
 
 class Task
@@ -43,8 +43,8 @@ class Task
     bool is_feasible() const;
 
 
-    void get_utilization(mpq_class &util) const;
-    void get_density(mpq_class &density) const;
+    void get_utilization(fractional_t &util) const;
+    void get_density(fractional_t &density) const;
 
     // Demand bound function (DBF) and LOAD support.
     // This implements Fisher, Baker, and Baruah's PTAS
@@ -64,7 +64,7 @@ class Task
         }
     }
 
-    void bound_demand(const mpz_class &time, mpz_class &demand) const
+    void bound_demand(const integral_t &time, integral_t &demand) const
     {
         if (time <= deadline)
             demand = 0;
@@ -79,9 +79,9 @@ class Task
         }
     }
 
-    void bound_load(const mpz_class &time, mpq_class &load) const
+    void bound_load(const integral_t &time, fractional_t &load) const
     {
-        mpz_class demand;
+        integral_t demand;
 
         if (time > 0)
         {
@@ -107,14 +107,14 @@ class Task
         }
     }
 
-    void approx_demand(const mpz_class &time, mpz_class &demand,
+    void approx_demand(const integral_t &time, integral_t &demand,
                        unsigned int k) const
     {
         if (time < k * period + deadline)
             bound_demand(time, demand);
         else
         {
-            mpz_class approx;
+            integral_t approx;
 
             approx = time;
             approx -= deadline;
@@ -126,10 +126,10 @@ class Task
         }
     }
 
-    void approx_load(const mpz_class &time, mpq_class &load,
+    void approx_load(const integral_t &time, fractional_t &load,
                      unsigned int k) const
     {
-        mpz_class demand;
+        integral_t demand;
 
         if (time > 0)
         {
@@ -148,8 +148,8 @@ class TaskSet
 {
   private:
     Tasks tasks;
-  
-    unsigned long k_for_epsilon(unsigned int idx, const mpq_class &epsilon) const;
+
+    unsigned long k_for_epsilon(unsigned int idx, const fractional_t &epsilon) const;
 
   public:
     TaskSet();
@@ -172,11 +172,11 @@ class TaskSet
     bool has_only_feasible_tasks() const;
     bool is_not_overutilized(unsigned int num_processors) const;
 
-    void get_utilization(mpq_class &util) const;
-    void get_density(mpq_class &density) const;
-    void get_max_density(mpq_class &max_density) const;
+    void get_utilization(fractional_t &util) const;
+    void get_density(fractional_t &density) const;
+    void get_max_density(fractional_t &max_density) const;
 
-    void approx_load(mpq_class &load, const mpq_class &epsilon = 0.1) const;
+    void approx_load(fractional_t &load, const fractional_t &epsilon = 0.1) const;
 
     /* wrapper for Python access */
     unsigned long get_period(unsigned int idx) const
diff --git a/native/include/time-types.h b/native/include/time-types.h
new file mode 100644
index 0000000..a2250d3
--- /dev/null
+++ b/native/include/time-types.h
@@ -0,0 +1,15 @@
+#ifndef TIME_TYPES_H
+#define TIME_TYPES_H
+
+#include <gmpxx.h>
+
+typedef mpz_class integral_t;
+typedef mpq_class fractional_t;
+
+static inline void truncate_fraction(fractional_t &val)
+{
+    val.get_num() -= val.get_num() % val.get_den();
+    val.canonicalize();
+}
+
+#endif
diff --git a/native/interface/sched.i b/native/interface/sched.i
index e94b5ca..255531a 100644
--- a/native/interface/sched.i
+++ b/native/interface/sched.i
@@ -15,9 +15,9 @@
 #include "sharedres.h"
 %}
 
-%ignore Task::get_utilization(mpq_class &util) const;
-%ignore Task::get_density(mpq_class &density) const;
-%ignore Task::bound_demand(const mpz_class &time, mpz_class &demand) const;
+%ignore Task::get_utilization(fractional_t &util) const;
+%ignore Task::get_density(fractional_t &density) const;
+%ignore Task::bound_demand(const integral_t &time, integral_t &demand) const;
 %ignore Task::bound_load const;
 %ignore Task::approx_demand const;
 
diff --git a/native/interface/sim.i b/native/interface/sim.i
index 26eac5f..aeeb59e 100644
--- a/native/interface/sim.i
+++ b/native/interface/sim.i
@@ -5,9 +5,9 @@
 #include "edf/sim.h"
 %}
 
-%ignore Task::get_utilization(mpq_class &util) const;
-%ignore Task::get_density(mpq_class &density) const;
-%ignore Task::bound_demand(const mpz_class &time, mpz_class &demand) const;
+%ignore Task::get_utilization(fractional_t &util) const;
+%ignore Task::get_density(fractional_t &density) const;
+%ignore Task::bound_demand(const integral_t &time, integral_t &demand) const;
 %ignore Task::bound_load const;
 %ignore Task::approx_demand const;
 
diff --git a/native/src/edf/baker.cpp b/native/src/edf/baker.cpp
index ca2b8cc..3d13b2c 100644
--- a/native/src/edf/baker.cpp
+++ b/native/src/edf/baker.cpp
@@ -8,10 +8,10 @@
 using namespace std;
 
 void BakerGedf::beta(const Task &t_i, const Task &t_k,
-                     const mpq_class &lambda_k,
-                     mpq_class &beta_i)
+                     const fractional_t &lambda_k,
+                     fractional_t &beta_i)
 {
-    mpq_class u_i;
+    fractional_t u_i;
 
     // XXX: possible improvement would be to pre-compute u_i
     //      instead of incurring quadratic u_i computations.
@@ -24,7 +24,7 @@ void BakerGedf::beta(const Task &t_i, const Task &t_k,
 
     if (lambda_k < u_i)
     {
-        mpq_class tmp = t_i.get_wcet();
+        fractional_t tmp = t_i.get_wcet();
         tmp -= lambda_k * t_i.get_period();
         tmp /= t_k.get_deadline();
         beta_i += tmp;
@@ -33,8 +33,8 @@ void BakerGedf::beta(const Task &t_i, const Task &t_k,
 
 bool BakerGedf::is_task_schedulable(unsigned int k, const TaskSet &ts)
 {
-    mpq_class lambda, bound, beta_i, beta_sum = 0;
-    mpq_class one = 1;
+    fractional_t lambda, bound, beta_i, beta_sum = 0;
+    fractional_t one = 1;
 
     ts[k].get_density(lambda);
 
diff --git a/native/src/edf/baruah.cpp b/native/src/edf/baruah.cpp
index 1b82baa..d2699e5 100644
--- a/native/src/edf/baruah.cpp
+++ b/native/src/edf/baruah.cpp
@@ -18,8 +18,8 @@ const double BaruahGedf::MAX_RUNTIME = 5.0; /* seconds */
 
 
 static void demand_bound_function(const Task &tsk,
-                                  const mpz_class &t,
-                                  mpz_class &db)
+                                  const integral_t &t,
+                                  integral_t &db)
 {
     db = t;
     db -= tsk.get_deadline();
@@ -36,7 +36,7 @@ static void demand_bound_function(const Task &tsk,
 class DBFPointsOfChange
 {
 private:
-    mpz_class     cur;
+    integral_t     cur;
     unsigned long pi; // period
 
 public:
@@ -56,7 +56,7 @@ public:
             next();
     }
 
-    const mpz_class& get_cur() const
+    const integral_t& get_cur() const
     {
         return cur;
     }
@@ -84,11 +84,11 @@ class AllDBFPointsOfChange
 private:
     DBFPointsOfChange *dbf;
     DBFQueue           queue;
-    mpz_class          last;
-    mpz_class         *upper_bound;
+    integral_t          last;
+    integral_t         *upper_bound;
 
 public:
-    void init(const TaskSet &ts, int k, mpz_class* bound)
+    void init(const TaskSet &ts, int k, integral_t* bound)
     {
         last = -1;
         dbf = new DBFPointsOfChange[ts.get_task_count()];
@@ -105,7 +105,7 @@ public:
         delete[] dbf;
     }
 
-    bool get_next(mpz_class &t)
+    bool get_next(integral_t &t)
     {
         if (last > *upper_bound)
             return false;
@@ -127,49 +127,49 @@ public:
 
 static
 void interval1(unsigned int i, unsigned int k, const TaskSet &ts,
-               const mpz_class &ilen, mpz_class &i1)
+               const integral_t &ilen, integral_t &i1)
 {
-    mpz_class dbf, tmp;
+    integral_t dbf, tmp;
     tmp = ilen + ts[k].get_deadline();
     demand_bound_function(ts[i], tmp, dbf);
     if (i == k)
-        i1 = min(mpz_class(dbf - ts[k].get_wcet()), ilen);
+        i1 = min(integral_t(dbf - ts[k].get_wcet()), ilen);
     else
         i1 = min(dbf,
-                 mpz_class(ilen + ts[k].get_deadline() -
+                 integral_t(ilen + ts[k].get_deadline() -
                            (ts[k].get_wcet() - 1)));
 }
 
 
 static void demand_bound_function_prime(const Task &tsk,
-                                        const mpz_class &t,
-                                        mpz_class &db)
+                                        const integral_t &t,
+                                        integral_t &db)
 // carry-in scenario
 {
     db = t;
     db /= tsk.get_period();
     db *= tsk.get_wcet();
-    db += min(mpz_class(tsk.get_wcet()), mpz_class(t % tsk.get_period()));
+    db += min(integral_t(tsk.get_wcet()), integral_t(t % tsk.get_period()));
 }
 
 static void interval2(unsigned int i, unsigned int k, const TaskSet &ts,
-                       const mpz_class &ilen, mpz_class &i2)
+                       const integral_t &ilen, integral_t &i2)
 {
-    mpz_class dbf, tmp;
+    integral_t dbf, tmp;
 
     tmp = ilen + ts[k].get_deadline();
     demand_bound_function_prime(ts[i], tmp, dbf);
     if (i == k)
-        i2 = min(mpz_class(dbf - ts[k].get_wcet()), ilen);
+        i2 = min(integral_t(dbf - ts[k].get_wcet()), ilen);
     else
         i2 = min(dbf,
-                 mpz_class(ilen + ts[k].get_deadline() -
+                 integral_t(ilen + ts[k].get_deadline() -
                            (ts[k].get_wcet() - 1)));
 }
 
 class MPZComparator {
 public:
-    bool operator() (mpz_class *a, mpz_class *b)
+    bool operator() (integral_t *a, integral_t *b)
     {
         return *b < *a;
     }
@@ -177,13 +177,13 @@ public:
 
 bool BaruahGedf::is_task_schedulable(unsigned int k,
                                      const TaskSet &ts,
-                                     const mpz_class &ilen,
-                                     mpz_class &i1,
-                                     mpz_class &sum,
-                                     mpz_class *idiff,
-                                     mpz_class **ptr)
+                                     const integral_t &ilen,
+                                     integral_t &i1,
+                                     integral_t &sum,
+                                     integral_t *idiff,
+                                     integral_t **ptr)
 {
-    mpz_class bound;
+    integral_t bound;
     sum = 0;
 
     for (unsigned int i = 0; i < ts.get_task_count(); i++)
@@ -206,8 +206,8 @@ bool BaruahGedf::is_task_schedulable(unsigned int k,
 }
 
 void BaruahGedf::get_max_test_points(const TaskSet &ts,
-                                     mpq_class &m_minus_u,
-                                     mpz_class* maxp)
+                                     fractional_t &m_minus_u,
+                                     integral_t* maxp)
 {
     unsigned long* wcet = new unsigned long[ts.get_task_count()];
 
@@ -216,8 +216,8 @@ void BaruahGedf::get_max_test_points(const TaskSet &ts,
 
     sort(wcet, wcet + ts.get_task_count(), greater<unsigned long>());
 
-    mpq_class u, tdu_sum;
-    mpz_class csigma, mc;
+    fractional_t u, tdu_sum;
+    integral_t csigma, mc;
 
     csigma = 0;
     for (unsigned int i = 0; i < m - 1 && i < ts.get_task_count(); i++)
@@ -256,7 +256,7 @@ bool BaruahGedf::is_schedulable(const TaskSet &ts,
             return true;
     }
 
-    mpq_class m_minus_u;
+    fractional_t m_minus_u;
     ts.get_utilization(m_minus_u);
     m_minus_u *= -1;
     m_minus_u += m;
@@ -270,19 +270,19 @@ bool BaruahGedf::is_schedulable(const TaskSet &ts,
 
     double start_time = get_cpu_usage();
 
-    mpz_class i1, sum;
-    mpz_class *max_test_point, *idiff;
-    mpz_class** ptr; // indirect access to idiff
+    integral_t i1, sum;
+    integral_t *max_test_point, *idiff;
+    integral_t** ptr; // indirect access to idiff
 
-    idiff          = new mpz_class[ts.get_task_count()];
-    max_test_point = new mpz_class[ts.get_task_count()];
-    ptr            = new mpz_class*[ts.get_task_count()];
+    idiff          = new integral_t[ts.get_task_count()];
+    max_test_point = new integral_t[ts.get_task_count()];
+    ptr            = new integral_t*[ts.get_task_count()];
     for (unsigned int i = 0; i < ts.get_task_count(); i++)
         ptr[i] = idiff + i;
 
     get_max_test_points(ts, m_minus_u, max_test_point);
 
-    mpz_class ilen;
+    integral_t ilen;
     bool point_in_range = true;
     bool schedulable = true;
 
diff --git a/native/src/edf/bcl.cpp b/native/src/edf/bcl.cpp
index 8cc25d9..d7fa721 100644
--- a/native/src/edf/bcl.cpp
+++ b/native/src/edf/bcl.cpp
@@ -15,11 +15,11 @@ unsigned long BCLGedf::max_jobs_contained(const Task &t_i, const Task &t_k)
         return 1 + (t_k.get_deadline() - t_i.get_deadline()) / t_i.get_period();
 }
 
-void BCLGedf::beta(const Task &t_i, const Task &t_k, mpq_class &beta_i)
+void BCLGedf::beta(const Task &t_i, const Task &t_k, fractional_t &beta_i)
 {
     unsigned long n = max_jobs_contained(t_i, t_k);
 
-    mpz_class c_i, tmp;
+    integral_t c_i, tmp;
 
     c_i  = t_i.get_wcet();
     tmp  = t_i.get_period();
@@ -38,8 +38,8 @@ void BCLGedf::beta(const Task &t_i, const Task &t_k, mpq_class &beta_i)
 
 bool BCLGedf::is_task_schedulable(unsigned int k, const TaskSet &ts)
 {
-    mpq_class beta_i, beta_sum = 0;
-    mpq_class lambda_term;
+    fractional_t beta_i, beta_sum = 0;
+    fractional_t lambda_term;
     bool small_beta_exists = false;
 
     ts[k].get_density(lambda_term);
diff --git a/native/src/edf/bcl_iterative.cpp b/native/src/edf/bcl_iterative.cpp
index e70c0c4..b8e58ef 100644
--- a/native/src/edf/bcl_iterative.cpp
+++ b/native/src/edf/bcl_iterative.cpp
@@ -11,7 +11,7 @@ using namespace std;
 static void interfering_workload(const Task &t_i,
                                  const Task &t_k,
                                  unsigned long slack,
-                                 mpz_class &inf)
+                                 integral_t &inf)
 {
     unsigned long njobs = t_k.get_deadline() / t_i.get_period();
 
@@ -30,9 +30,9 @@ bool BCLIterativeGedf::slack_update(unsigned int k,
                                     unsigned long *slack,
                                     bool &has_slack)
 {
-    mpz_class other_work = 0;
-    mpz_class inf;
-    mpz_class inf_bound = ts[k].get_deadline() - ts[k].get_wcet() + 1;
+    integral_t other_work = 0;
+    integral_t inf;
+    integral_t inf_bound = ts[k].get_deadline() - ts[k].get_wcet() + 1;
 
     for (unsigned int i = 0; i < ts.get_task_count(); i++)
         if (k != i)
diff --git a/native/src/edf/ffdbf.cpp b/native/src/edf/ffdbf.cpp
index a28ea38..fa64b96 100644
--- a/native/src/edf/ffdbf.cpp
+++ b/native/src/edf/ffdbf.cpp
@@ -13,8 +13,8 @@
 
 using namespace std;
 
-static void get_q_r(const Task &t_i, const mpq_class &time,
-                    mpz_class &q_i, mpq_class &r_i)
+static void get_q_r(const Task &t_i, const fractional_t &time,
+                    integral_t &q_i, fractional_t &r_i)
 {
     // compute q_i -- floor(time / period)
     //         r_i -- time % period
@@ -26,18 +26,18 @@ static void get_q_r(const Task &t_i, const mpq_class &time,
     r_i -= q_i * t_i.get_period();
 }
 
-static void compute_q_r(const TaskSet &ts, const mpq_class &time,
-                        mpz_class q[], mpq_class r[])
+static void compute_q_r(const TaskSet &ts, const fractional_t &time,
+                        integral_t q[], fractional_t r[])
 {
     for (unsigned int i = 0; i < ts.get_task_count(); i++)
         get_q_r(ts[i], time, q[i], r[i]);
 }
 
 static void ffdbf(const Task &t_i,
-                  const mpq_class &time, const mpq_class &speed,
-                  const mpz_class &q_i, const mpq_class &r_i,
-                  mpq_class &demand,
-                  mpq_class &tmp)
+                  const fractional_t &time, const fractional_t &speed,
+                  const integral_t &q_i, const fractional_t &r_i,
+                  fractional_t &demand,
+                  fractional_t &tmp)
 {
     /* this is the cost in all three cases */
     demand += q_i * t_i.get_wcet();
@@ -64,9 +64,9 @@ static void ffdbf(const Task &t_i,
 }
 
 static void ffdbf_ts(const TaskSet &ts,
-                     const mpz_class q[], const mpq_class r[],
-                     const mpq_class &time, const mpq_class &speed,
-                     mpq_class &demand, mpq_class &tmp)
+                     const integral_t q[], const fractional_t r[],
+                     const fractional_t &time, const fractional_t &speed,
+                     fractional_t &demand, fractional_t &tmp)
 {
     demand = 0;
     for (unsigned int i = 0; i < ts.get_task_count(); i++)
@@ -77,15 +77,15 @@ static void ffdbf_ts(const TaskSet &ts,
 class TestPoints
 {
 private:
-    mpq_class     time;
-    mpq_class     with_offset;
+    fractional_t     time;
+    fractional_t     with_offset;
     unsigned long period;
     bool          first_point;
 
 public:
     void init(const Task& t_i,
-              const mpq_class& speed,
-              const mpq_class& min_time)
+              const fractional_t& speed,
+              const fractional_t& min_time)
     {
         period = t_i.get_period();
         with_offset = t_i.get_wcet() / speed;
@@ -96,7 +96,7 @@ public:
         time = min_time;
         time /= period;
         // round down, i.e., floor()
-        mpq_truncate(time);
+        truncate_fraction(time);
         time *= period;
         time += t_i.get_deadline();
 
@@ -107,7 +107,7 @@ public:
             next();
     }
 
-    const mpq_class& get_cur() const
+    const fractional_t& get_cur() const
     {
         if (first_point)
             return with_offset;
@@ -145,7 +145,7 @@ class AllTestPoints
 private:
     TestPoints *pts;
     TimeQueue   queue;
-    mpq_class   last;
+    fractional_t   last;
     TaskSet const &ts;
 
 public:
@@ -155,8 +155,8 @@ public:
         pts = new TestPoints[ts.get_task_count()];
     }
 
-    void init(const mpq_class &speed,
-              const mpq_class &min_time)
+    void init(const fractional_t &speed,
+              const fractional_t &min_time)
     {
         last = -1;
         // clean out queue
@@ -175,7 +175,7 @@ public:
         delete[] pts;
     }
 
-    void get_next(mpq_class &t)
+    void get_next(fractional_t &t)
     {
         TestPoints* pt;
         do // avoid duplicates
@@ -191,11 +191,11 @@ public:
 };
 
 bool FFDBFGedf::witness_condition(const TaskSet &ts,
-                                  const mpz_class q[], const mpq_class r[],
-                                  const mpq_class &time,
-                                  const mpq_class &speed)
+                                  const integral_t q[], const fractional_t r[],
+                                  const fractional_t &time,
+                                  const fractional_t &speed)
 {
-    mpq_class demand, bound;
+    fractional_t demand, bound;
 
     ffdbf_ts(ts, q, r, time, speed, demand, bound);
 
@@ -223,12 +223,12 @@ bool FFDBFGedf::is_schedulable(const TaskSet &ts,
 
     // allocate helpers
     AllTestPoints testing_set(ts);
-    mpz_class *q = new mpz_class[ts.get_task_count()];
-    mpq_class *r = new mpq_class[ts.get_task_count()];
+    integral_t *q = new integral_t[ts.get_task_count()];
+    fractional_t *r = new fractional_t[ts.get_task_count()];
 
-    mpq_class sigma_bound;
-    mpq_class time_bound;
-    mpq_class tmp(1, epsilon_denom);
+    fractional_t sigma_bound;
+    fractional_t time_bound;
+    fractional_t tmp(1, epsilon_denom);
 
     // compute sigma bound
     tmp = 1;
@@ -237,7 +237,7 @@ bool FFDBFGedf::is_schedulable(const TaskSet &ts,
     sigma_bound -= m;
     sigma_bound /= - ((int) (m - 1)); // neg. to flip sign
     sigma_bound -= tmp; // epsilon
-    sigma_bound = min(sigma_bound, mpq_class(1));
+    sigma_bound = min(sigma_bound, fractional_t(1));
 
     // compute time bound
     time_bound = 0;
@@ -245,8 +245,8 @@ bool FFDBFGedf::is_schedulable(const TaskSet &ts,
         time_bound += ts[i].get_wcet();
     time_bound /= tmp; // epsilon
 
-    mpq_class t_cur;
-    mpq_class sigma_cur, sigma_nxt;
+    fractional_t t_cur;
+    fractional_t sigma_cur, sigma_nxt;
     bool schedulable;
 
     t_cur = 0;
@@ -258,7 +258,7 @@ bool FFDBFGedf::is_schedulable(const TaskSet &ts,
 
     // setup brute force sigma value range
     sigma_nxt = sigma_cur / sigma_step;
-    mpq_truncate(sigma_nxt);
+    truncate_fraction(sigma_nxt);
     sigma_nxt += 1;
     sigma_nxt *= sigma_step;
 
diff --git a/native/src/edf/gedf.cpp b/native/src/edf/gedf.cpp
index 35f1847..e2a6bec 100644
--- a/native/src/edf/gedf.cpp
+++ b/native/src/edf/gedf.cpp
@@ -26,7 +26,7 @@ bool GlobalEDF::is_schedulable(const TaskSet &ts,
     // density bound on a uniprocessor.
     if (m == 1)
     {
-        mpq_class density;
+        fractional_t density;
         ts.get_density(density);
         if (density <= 1)
             return true;
diff --git a/native/src/edf/gfb.cpp b/native/src/edf/gfb.cpp
index 0aa90b8..822b97b 100644
--- a/native/src/edf/gfb.cpp
+++ b/native/src/edf/gfb.cpp
@@ -13,7 +13,7 @@ bool GFBGedf::is_schedulable(const TaskSet &ts, bool check_preconditions)
             return false;
     }
 
-    mpq_class total_density, max_density, bound;
+    fractional_t total_density, max_density, bound;
 
     ts.get_density(total_density);
     ts.get_max_density(max_density);
diff --git a/native/src/edf/load.cpp b/native/src/edf/load.cpp
index 38d3c55..db44d20 100644
--- a/native/src/edf/load.cpp
+++ b/native/src/edf/load.cpp
@@ -22,8 +22,8 @@ bool LoadGedf::is_schedulable(const TaskSet &ts, bool check_preconditions)
             return false;
     }
 
-    mpq_class load, max_density, mu, bound, cond1, cond2;
-    mpz_class mu_ceil;
+    fractional_t load, max_density, mu, bound, cond1, cond2;
+    integral_t mu_ceil;
 
     // get the load of the task set
     ts.approx_load(load, epsilon);
diff --git a/native/src/edf/rta.cpp b/native/src/edf/rta.cpp
index 68eafa6..4114467 100644
--- a/native/src/edf/rta.cpp
+++ b/native/src/edf/rta.cpp
@@ -15,8 +15,8 @@ using namespace std;
 static void rta_interfering_workload(const Task &t_i,
                                      unsigned long response_time,
                                      unsigned long slack_i,
-                                     mpz_class &inf,
-                                     mpz_class &interval)
+                                     integral_t &inf,
+                                     integral_t &interval)
 {
     interval = response_time;
     interval += t_i.get_deadline() - t_i.get_wcet();
@@ -36,7 +36,7 @@ static void rta_interfering_workload(const Task &t_i,
 static void edf_interfering_workload(const Task &t_i,
                                      const Task &t_k,
                                      unsigned long slack_i,
-                                     mpz_class &inf)
+                                     integral_t &inf)
 {
     /* implicit floor in integer division */
     unsigned long njobs = t_k.get_deadline() / t_i.get_period();
@@ -56,11 +56,11 @@ bool RTAGedf::response_estimate(unsigned int k,
                                 unsigned long response,
                                 unsigned long &new_response)
 {
-    mpz_class other_work = 0;
-    mpz_class inf_edf;
-    mpz_class inf_rta;
-    mpz_class inf_bound = response - ts[k].get_wcet() + 1;
-    mpz_class tmp;
+    integral_t other_work = 0;
+    integral_t inf_edf;
+    integral_t inf_rta;
+    integral_t inf_bound = response - ts[k].get_wcet() + 1;
+    integral_t tmp;
 
     for (unsigned int i = 0; i < ts.get_task_count(); i++)
         if (k != i)
diff --git a/native/src/sharedres.cpp b/native/src/sharedres.cpp
index 7b61fc3..a691ef9 100644
--- a/native/src/sharedres.cpp
+++ b/native/src/sharedres.cpp
@@ -7,7 +7,7 @@
 #include "sharedres.h"
 #include "res_io.h"
 
-#include <gmpxx.h>
+#include "time-types.h"
 #include "math-helper.h"
 
 #include "stl-helper.h"
diff --git a/native/src/tasks.cpp b/native/src/tasks.cpp
index 9875b65..1d784bf 100644
--- a/native/src/tasks.cpp
+++ b/native/src/tasks.cpp
@@ -37,14 +37,14 @@ bool Task::is_feasible() const
         && get_wcet() > 0;
 }
 
-void Task::get_utilization(mpq_class &util) const
+void Task::get_utilization(fractional_t &util) const
 {
     // assumes period != 0
     util  = get_wcet();
     util /= get_period();
 }
 
-void Task::get_density(mpq_class &density) const
+void Task::get_density(fractional_t &density) const
 {
     // assumes deadline != 0
     density  = get_wcet();
@@ -95,9 +95,9 @@ bool TaskSet::has_only_feasible_tasks() const
     FORALL(i, tasks[i].is_feasible());
 }
 
-void TaskSet::get_utilization(mpq_class &util) const
+void TaskSet::get_utilization(fractional_t &util) const
 {
-    mpq_class tmp;
+    fractional_t tmp;
     util = 0;
     for (unsigned int i = 0; i < tasks.size(); i++)
     {
@@ -106,9 +106,9 @@ void TaskSet::get_utilization(mpq_class &util) const
     }
 }
 
-void TaskSet::get_density(mpq_class &density) const
+void TaskSet::get_density(fractional_t &density) const
 {
-    mpq_class tmp;
+    fractional_t tmp;
     density = 0;
     for (unsigned int i = 0; i < tasks.size(); i++)
     {
@@ -117,9 +117,9 @@ void TaskSet::get_density(mpq_class &density) const
     }
 }
 
-void TaskSet::get_max_density(mpq_class &max_density) const
+void TaskSet::get_max_density(fractional_t &max_density) const
 {
-    mpq_class tmp;
+    fractional_t tmp;
     max_density = 0;
 
     for (unsigned int i = 0; i < tasks.size(); i++)
@@ -131,17 +131,17 @@ void TaskSet::get_max_density(mpq_class &max_density) const
 
 bool TaskSet::is_not_overutilized(unsigned int num_processors) const
 {
-    mpq_class util;
+    fractional_t util;
     get_utilization(util);
     return util <= num_processors;
 }
 
 // Lemma 7 in FBB:06.
 unsigned long TaskSet::k_for_epsilon(unsigned int idx,
-                                     const mpq_class &epsilon) const
+                                     const fractional_t &epsilon) const
 {
-    mpq_class bound;
-    mpq_class dp_ratio(tasks[idx].get_deadline(),
+    fractional_t bound;
+    fractional_t dp_ratio(tasks[idx].get_deadline(),
                        tasks[idx].get_period());
 
     tasks[idx].get_utilization(bound);
@@ -152,9 +152,9 @@ unsigned long TaskSet::k_for_epsilon(unsigned int idx,
     return (unsigned long) ceil(std::max(0.0, bound.get_d()));
 }
 
-void TaskSet::approx_load(mpq_class &load, const mpq_class &epsilon) const
+void TaskSet::approx_load(fractional_t &load, const fractional_t &epsilon) const
 {
-    mpq_class density;
+    fractional_t density;
 
     get_density(density);
     get_utilization(load);
@@ -177,13 +177,13 @@ void TaskSet::approx_load(mpq_class &load, const mpq_class &epsilon) const
 
         std::cout << "total_times = " << total_times << std::endl;
 
-        std::vector<mpz_class> times;
+        std::vector<integral_t> times;
         times.reserve(total_times);
 
         // determine all test points
         for (unsigned int i = 0; i < tasks.size(); i++)
         {
-            mpz_class time = tasks[i].get_deadline();
+            integral_t time = tasks[i].get_deadline();
 
             for (unsigned long j = 0; j <= k[i]; j++)
             {
@@ -196,15 +196,15 @@ void TaskSet::approx_load(mpq_class &load, const mpq_class &epsilon) const
         std::sort(times.begin(), times.end());
 
         // iterate through test points
-        mpz_class last = 0;
+        integral_t last = 0;
 
         for (unsigned int t = 0; t < total_times; t++)
         {
             // avoid redundant check
             if (times[t] > last)
             {
-                mpq_class load_at_point = 0;
-                mpq_class tmp;
+                fractional_t load_at_point = 0;
+                fractional_t tmp;
 
                 // compute approximate load at point
                 for (unsigned int i = 0; i < tasks.size(); i++)
diff --git a/native/src/testmain.cpp b/native/src/testmain.cpp
index eeeb96b..7401491 100644
--- a/native/src/testmain.cpp
+++ b/native/src/testmain.cpp
@@ -499,7 +499,7 @@ int xxxmain(int argc, char** argv)
 {
     cout << "GMP C++ test." << endl;
 
-    mpz_class a, b;
+    integral_t a, b;
 
     a = "123123123123";
     b = "456456456456";
@@ -508,12 +508,12 @@ int xxxmain(int argc, char** argv)
     cout << "b     : " << b << endl;
     cout << "a*b*10: " << a * b * 10 << endl;
 
-    mpq_class q = a;
+    fractional_t q = a;
 
     q /= b;
     cout << "a/b   :" << q << endl;
 
-    mpz_class fact;
+    integral_t fact;
     fact = 1;
     for (int n = 2; n < 101; n++) {
         fact *= n;
@@ -529,7 +529,7 @@ int xxxmain(int argc, char** argv)
          << " deadline: " << t.get_deadline() << endl;
 
 
-    mpq_class lambda, bound;
+    fractional_t lambda, bound;
     unsigned int m = 10;
 
     lambda = 3;
@@ -654,8 +654,8 @@ int yymain(int argc, char** argv)
 
 int main4(int argc, char** argv)
 {
-    mpq_class a, b;
-    mpz_class c;
+    fractional_t a, b;
+    integral_t c;
 
     a = 20;
     a /= 3;
@@ -668,7 +668,7 @@ int main4(int argc, char** argv)
 
     cout << c << endl;
 
-    mpq_truncate(b);
+    truncate_fraction(b);
     cout << b << endl;
 
     return 0;