fix some compiler warnings

setup.py

@@ -32,6 +32,9 @@ def cxxflags(platform):
 
   if platform == "unix":
     return [
+      "-Wall",
+      "-Werror",
+      "-pedantic",
       "-pthread",
       "-Wsign-compare",
       "-fstack-protector-strong",

src/DataFrame.cpp

@@ -84,10 +84,10 @@ void no::df::transition(no::Model& model, py::array_t<int64_t> categories, py::a
   }
 
   // reverse catgory lookup
-  std::map<int64_t, int> lookup;
+  std::map<int64_t, int64_t> lookup;
   for (py::ssize_t i = 0; i < m; ++i)
   {
-    lookup[no::at<int64_t>(categories, Index_t<1>{i})] = (int64_t)i;
+    lookup[no::at<int64_t>(categories, Index_t<1>{i})] = i;
   }
 
   py::ssize_t n = col.size();

src/Error.cpp

@@ -4,18 +4,18 @@
 const char* no::NotImplementedError::what() const noexcept
 {
   return m_msg.c_str();
-} 
+}
 
 
 // map error types defined here to python exceptions
-void no::exception_translator(std::exception_ptr p) 
+void no::exception_translator(std::exception_ptr p)
 {
-  try 
+  try
   {
     if (p) std::rethrow_exception(p);
-  } 
-  catch (const no::NotImplementedError& e) 
+  }
+  catch (const no::NotImplementedError& e)
   {
     PyErr_SetString(PyExc_NotImplementedError, e.what());
   }
-};
+}

src/Model.cpp

@@ -68,7 +68,7 @@ bool no::Model::run(py::object& model_subclass)
   {
     base.timeline().next();
     double t = base.timeline().time();
-    int timeindex = base.timeline().index();
+    size_t timeindex = base.timeline().index();
 
     no::log("t=%%(%%) %%.step()"s % t % timeindex % subclass_name);
     model_subclass.attr("step")();

src/MonteCarlo.cpp

@@ -38,24 +38,24 @@ void validate_lambda(const py::array_t<double>& lambda)
 
 
 // helper functions for basic seeding strategies
-int64_t no::MonteCarlo::deterministic_independent_stream(int r)
+int32_t no::MonteCarlo::deterministic_independent_stream(int r)
 {
   return 19937 + r;
 }
 
-int64_t no::MonteCarlo::deterministic_identical_stream(int)
+int32_t no::MonteCarlo::deterministic_identical_stream(int)
 {
   return 19937;
 }
 
-int64_t no::MonteCarlo::nondeterministic_stream(int)
+int32_t no::MonteCarlo::nondeterministic_stream(int)
 {
   std::random_device rand;
-  return (static_cast<int64_t>(rand()) << 32) + rand();
+  return rand();
 }
 
 //
-no::MonteCarlo::MonteCarlo(int64_t seed)
+no::MonteCarlo::MonteCarlo(int32_t seed)
   : m_seed(seed), m_prng(m_seed) { }
 
 

src/MonteCarlo.h

@@ -19,14 +19,14 @@ class NEWORDER_EXPORT MonteCarlo
 public:
 
   // some basic seeding strategies
-  static int64_t deterministic_independent_stream(int r);
+  static int32_t deterministic_independent_stream(int r);
 
-  static int64_t deterministic_identical_stream(int);
+  static int32_t deterministic_identical_stream(int);
 
-  static int64_t nondeterministic_stream(int);
+  static int32_t nondeterministic_stream(int);
 
   // constructs given a seed
-  MonteCarlo(int64_t seed);
+  MonteCarlo(int32_t seed);
 
   int64_t seed() const;
 
@@ -44,19 +44,19 @@ class NEWORDER_EXPORT MonteCarlo
   // raw unsigned 64-bit ints, can be used to (un)deterministically seed another generator (e.g. np.random)
   uint64_t raw();
 
-  // randomly sample categories with weights 
+  // randomly sample categories with weights
   py::array_t<int64_t> sample(py::ssize_t n, const py::array_t<double>& cat_weights);
 
-  // single-prob hazard 
+  // single-prob hazard
   py::array_t<double> hazard(double prob, py::ssize_t n);
 
-  // vector hazard 
+  // vector hazard
   py::array_t<double> hazard(const py::array_t<double>& prob);
 
-  // compute stopping times 
+  // compute stopping times
   py::array_t<double> stopping(double prob, py::ssize_t n);
 
-  // vector stopping 
+  // vector stopping
   py::array_t<double> stopping(const py::array_t<double>& prob);
 
   // multiple-arrival (0+) process (requires that final hazard rate is zero)

src/Timeline.h

@@ -8,7 +8,7 @@
 
 namespace no {
 
-class Timeline final
+class NEWORDER_EXPORT Timeline final
 {
 public:
 
@@ -44,16 +44,16 @@ class Timeline final
   std::string repr() const;
 
 private:
-  double m_start; 
+  double m_start;
   double m_end;
 
   size_t m_index; // index of current time
-  
+
   std::vector<size_t> m_checkpoints;
 };
 
 namespace time {
-  
+
   // returns a floating point number that compares unequal (and unordered) to any other number
   // thus the following all evaluate to true: never() != never(), !(x < never()), !(x >= never()) (so be careful!)
   double never();