gps_pvt 0.6.4 → 0.7.2

data/ext/ninja-scan-light/tool/navigation/SBAS_Solver.h

@@ -126,11 +126,15 @@ class SBAS_SinglePositioning : public SolverBaseT {
           static float_t clock_error_dot(const void *ptr, const gps_time_t &t_tx) {
             return sat(ptr).ephemeris().clock_error_dot(t_tx);
           }
+          static float_t range_sigma(const void *ptr, const gps_time_t &t_tx) {
+            return sat(ptr).ephemeris().URA;
+          }
         };
         satellite_t res = {
-            &(it_sat->second),
+            &(it_sat->second), &(it_sat->second), // position, time
             impl_t::position, impl_t::velocity,
-            impl_t::clock_error, impl_t::clock_error_dot};
+            impl_t::clock_error, impl_t::clock_error_dot,
+            &(it_sat->second), impl_t::range_sigma, NULL}; // error model
         return res;
       }
       satellites_t(const space_node_t &sn)
@@ -245,7 +249,7 @@ class SBAS_SinglePositioning : public SolverBaseT {
       float_t range;
       range_error_t range_error;
       if(!this->range(measurement, range, &range_error)){
-        return res; // If no range entry, return with weight = 0
+        return res; // If no range entry, return with sigma = 0
       }
 
       satellite_t sat(select_satellite(prn, time_arrival));
@@ -297,21 +301,29 @@ class SBAS_SinglePositioning : public SolverBaseT {
 
       // TODO Fast corrections (2.1.1.4.12)
 
-      // TODO Setup weight
-      if(std::abs(res.range_residual) > _options.residual_mask){
-        // If residual is too big, gently exclude it by decreasing its weight.
-        res.weight = 1E-8;
-      }else{
+      // Setup weight
+      res.range_sigma = 1E+4; // sufficiently big value, 1E4 [m]
+      do{
+        // If residual is too big, gently exclude it.
+        if(std::abs(res.range_residual) > _options.residual_mask){break;}
 
         float_t elv(relative_pos.elevation());
         if(elv < _options.elevation_mask){
-          res.weight = 0; // exclude it when elevation is less than threshold
-        }else{
-          // elevation weight based on "GPS���p�v���O���~���O" @see GPS_Solver.h
-          res.weight = std::pow(sin(elv)/0.8, 2);
-          if(res.weight < 1E-3){res.weight = 1E-3;}
+          res.range_sigma = 0; // exclude it when elevation is less than threshold
+          break;
         }
-      }
+
+        res.range_sigma = sat.range_sigma(t_tx);
+
+        /* elevation weight based on "GPS���p�v���O���~���O"
+         * elevation[deg] :   90    53    45    30    15    10    5
+         * sf_sigma(k)    :   0.80  1.00  1.13  1.60  3.09  4.61  9.18
+         * weight(k^-2)   :   1.56  1.00  0.78  0.39  0.10  0.05  0.01
+         */
+        static const float_t max_sf(10);
+        static const float_t elv_limit(std::asin(0.8/max_sf)); // limit
+        res.range_sigma *= (elv > elv_limit) ? (0.8 / sin(elv)) : max_sf;
+      }while(false);
 
       res.range_corrected = range;
 

data/ext/ninja-scan-light/tool/navigation/SP3.h

@@ -185,9 +185,10 @@ struct SP3_Product {
         }
       };
       typename GPS_Solver_Base<FloatT>::satellite_t res = {
-        this,
+        this, this, // position, time
         impl_t::position, impl_t::velocity,
-        impl_t::clock_error, impl_t::clock_error_dot
+        impl_t::clock_error, impl_t::clock_error_dot,
+        NULL, NULL, NULL, // TODO error model
       };
       return res;
     }
@@ -248,29 +249,33 @@ struct SP3_Product {
   }
 
   enum system_t {
-    SYSTEM_GPS      = (int)'\0' << 8,
-    SYSTEM_SBAS     = SYSTEM_GPS,
-    SYSTEM_QZSS     = SYSTEM_GPS,
-    SYSTEM_GLONASS  = (int)'R' << 8,
-    SYSTEM_LEO      = (int)'L' << 8,
-    SYSTEM_GALILEO  = (int)'E' << 8,
-    SYSTEM_BEIDOU   = (int)'C' << 8,
-    SYSTEM_IRNSS    = (int)'I' << 8,
+    SYSTEM_GPS,
+    SYSTEM_SBAS,
+    SYSTEM_QZSS,
+    SYSTEM_GLONASS,
+    SYSTEM_LEO,
+    SYSTEM_GALILEO,
+    SYSTEM_BEIDOU,
+    SYSTEM_IRNSS,
+    NUM_OF_SYSTEMS,
   };
 
-#define gen_func(sys) \
-static typename GPS_Solver_Base<FloatT>::satellite_t select_ ## sys( \
-    const void *ptr, const int &prn, const GPS_Time<FloatT> &receiver_time){ \
-  return reinterpret_cast<const SP3_Product<FloatT> *>(ptr) \
-      ->select(prn + SYSTEM_ ## sys, receiver_time); \
-}
-  gen_func(GPS);
-  gen_func(GLONASS);
-  gen_func(LEO);
-  gen_func(GALILEO);
-  gen_func(BEIDOU);
-  gen_func(IRNSS);
-#undef gen_fun
+  static const int offset_list[NUM_OF_SYSTEMS];
+
+  protected:
+
+  mutable struct per_system_t {
+    const SP3_Product<FloatT> *product;
+    system_t sys;
+  } per_system[NUM_OF_SYSTEMS];
+
+  static typename GPS_Solver_Base<FloatT>::satellite_t select(
+      const void *ptr, const int &prn, const GPS_Time<FloatT> &receiver_time){
+    const per_system_t *ptr_impl(reinterpret_cast<const per_system_t *>(ptr));
+    return ptr_impl->product->select((prn & 0xFF) + offset_list[ptr_impl->sys], receiver_time);
+  }
+
+  public:
 
   /**
    * push SP3 product to satellite selector
@@ -281,19 +286,11 @@ static typename GPS_Solver_Base<FloatT>::satellite_t select_ ## sys( \
    */
   template <class SelectorT>
   bool push(SelectorT &slct, const system_t &sys = SYSTEM_GPS) const {
-    switch(sys){
-      case SYSTEM_GPS: // SBAS and QZSS are identically treated as GPS.
-      //case SYSTEM_SBAS:
-      //case SYSTEM_QZSS:
-        slct.impl_select = select_GPS; break;
-      case SYSTEM_GLONASS:  slct.impl_select = select_GLONASS;  break;
-      case SYSTEM_LEO:      slct.impl_select = select_LEO;      break;
-      case SYSTEM_GALILEO:  slct.impl_select = select_GALILEO;  break;
-      case SYSTEM_BEIDOU:   slct.impl_select = select_BEIDOU;   break;
-      case SYSTEM_IRNSS:    slct.impl_select = select_IRNSS;    break;
-      default: return false;
-    }
-    slct.impl = this;
+    if(sys >= NUM_OF_SYSTEMS){return false;}
+    per_system[sys].product = this;
+    per_system[sys].sys = sys;
+    slct.impl_select = select;
+    slct.impl = &per_system[sys];
     return true;
   }
 
@@ -305,19 +302,19 @@ static typename GPS_Solver_Base<FloatT>::satellite_t select_ ## sys( \
     for(typename satellites_t::const_iterator
           it(satellites.begin()), it_end(satellites.end());
         it != it_end; ++it){
-      switch(it->first & 0xFF00){
-        case SYSTEM_GPS: {
+      switch((char)(it->first >> 8)){
+        case '\0': {
           int id(it->first & 0xFF);
           if(id < 100){++res.gps;}
           else if(id < 192){++res.sbas;}
           else{++res.qzss;}
           break;
         }
-        case SYSTEM_GLONASS:  ++res.glonass;  break;
-        case SYSTEM_LEO:      ++res.leo;      break;
-        case SYSTEM_GALILEO:  ++res.galileo;  break;
-        case SYSTEM_BEIDOU:   ++res.beidou;   break;
-        case SYSTEM_IRNSS:    ++res.irnss;    break;
+        case 'R': ++res.glonass;  break;
+        case 'L': ++res.leo;      break;
+        case 'E': ++res.galileo;  break;
+        case 'C': ++res.beidou;   break;
+        case 'I': ++res.irnss;    break;
         default: ++res.unknown; break;
       }
     }
@@ -335,6 +332,17 @@ const typename SP3_Product<FloatT>::per_satellite_t::interpolate_cnd_t
   60 * 60 * 2,
 };
 
+template <class FloatT>
+const int SP3_Product<FloatT>::offset_list[NUM_OF_SYSTEMS] = {
+  0, 0, 0, // GPS, SBAS, QZSS
+  ((int)'R' << 8), // GLONASS
+  ((int)'L' << 8), // LEO
+  ((int)'E' << 8), // GALILEO
+  ((int)'C' << 8), // BEIDOU
+  ((int)'I' << 8), // IRNSS
+};
+
+
 template <class FloatT>
 class SP3_Reader {
   protected:

data/ext/ninja-scan-light/tool/param/bit_array.h

@@ -125,9 +125,9 @@ struct BitArray {
       return (unsigned int)res;
     }
   }
-  std::vector<int> indices_one() const {
+  std::vector<int> indices_one(const int &offset = 0) const {
     std::vector<int> res;
-    int idx(0);
+    int idx(offset);
     static const const_div_t<bits_per_addr> qr(MAX_SIZE);
     int rem(qr.rem), i(0);
     for(; i < qr.quot; ++i, idx += bits_per_addr){

data/ext/ninja-scan-light/tool/param/quaternion.h

@@ -130,7 +130,7 @@ class QuaternionData : public QuaternionDataProperty<FloatT> {
      * @param q �R�s�[��
      */
     QuaternionData(const self_t &q){
-      if(storage = q.storage){(storage->ref)++;}
+      if((storage = q.storage)){(storage->ref)++;}
     }
     
     /**
@@ -143,7 +143,7 @@ class QuaternionData : public QuaternionDataProperty<FloatT> {
     self_t &operator=(const self_t &q){
       if(this == &q){return *this;}
       if(storage && ((--(storage->ref)) <= 0)){delete storage;}
-      if(storage = q.storage){(storage->ref)++;}
+      if((storage = q.storage)){(storage->ref)++;}
       return *this;
     }
     

data/ext/ninja-scan-light/tool/param/vector3.h

@@ -133,7 +133,7 @@ class Vector3Data : public Vector3DataProperty<FloatT> {
      * @param v �R�s�[��
      */
     Vector3Data(const self_t &v){
-      if(storage = v.storage){(storage->ref)++;}
+      if((storage = v.storage)){(storage->ref)++;}
     }
     
     /**
@@ -146,7 +146,7 @@ class Vector3Data : public Vector3DataProperty<FloatT> {
     self_t &operator=(const self_t &v){
       if(this == &v){return *this;}
       if(storage && ((--(storage->ref)) <= 0)){delete storage;}
-      if(storage = v.storage){(storage->ref)++;}
+      if((storage = v.storage)){(storage->ref)++;}
       return *this;
     }
     

data/ext/ninja-scan-light/tool/swig/GPS.i

@@ -22,6 +22,7 @@
 #include "navigation/QZSS.h"
 #include "navigation/GLONASS.h"
 #include "navigation/RINEX.h"
+#include "navigation/RINEX_Clock.h"
 #include "navigation/SP3.h"
 #include "navigation/ANTEX.h"
 
@@ -228,12 +229,10 @@ struct GPS_Ionospheric_UTC_Parameters : public GPS_SpaceNode<FloatT>::Ionospheri
 %}
 %extend GPS_Ionospheric_UTC_Parameters {
   %fragment(SWIG_Traits_frag(FloatT));
-  %typemap(in,numinputs=0) FloatT values[4] (FloatT temp[4]) %{
-    $1 = temp;
-  %}
-  %typemap(argout) FloatT values[4] {
+  %typemap(in,numinputs=0) const FloatT *values[4] (FloatT *temp) "$1 = &temp;"
+  %typemap(argout) const FloatT *values[4] {
     for(int i(0); i < 4; ++i){
-      %append_output(swig::from($1[i]));
+      %append_output(swig::from((*$1)[i]));
     }
   }
   MAKE_ARRAY_INPUT(const FloatT, values, swig::asval);
@@ -245,11 +244,7 @@ struct GPS_Ionospheric_UTC_Parameters : public GPS_SpaceNode<FloatT>::Ionospheri
     } 
   }
   %rename("alpha") get_alpha;
-  void get_alpha(FloatT values[4]) const {
-    for(int i(0); i < 4; ++i){
-      values[i] = self->alpha[i];
-    }
-  }
+  void get_alpha(const FloatT *values[4]) const {*values = self->alpha;}
   %rename("beta=") set_beta;
   void set_beta(const FloatT values[4]){
     for(int i(0); i < 4; ++i){
@@ -257,11 +252,7 @@ struct GPS_Ionospheric_UTC_Parameters : public GPS_SpaceNode<FloatT>::Ionospheri
     }
   }
   %rename("beta") get_beta;
-  void get_beta(FloatT values[4]) const {
-    for(int i(0); i < 4; ++i){
-      values[i] = self->beta[i];
-    }
-  }
+  void get_beta(const FloatT *values[4]) const {*values = self->beta;}
   MAKE_ACCESSOR(A1, FloatT);
   MAKE_ACCESSOR(A0, FloatT);
   MAKE_ACCESSOR(t_ot, unsigned int);
@@ -1006,6 +997,7 @@ const type &get_ ## name () const {
 %inline %{
 template <class FloatT>
 struct GPS_SolverOptions_Common {
+  virtual ~GPS_SolverOptions_Common() {}
   virtual GPS_Solver_GeneralOptions<FloatT> *cast_general() = 0;
   virtual const GPS_Solver_GeneralOptions<FloatT> *cast_general() const = 0;
 };
@@ -1132,10 +1124,13 @@ struct GPS_RangeCorrector
         static const int prop_items(sizeof(res.values) / sizeof(res.values[0]));
         VALUE hook(rb_hash_lookup(hooks, key));
         if(NIL_P(hook)){break;}
+        FloatT weight((res.prop.range_sigma > 0) 
+            ? (1. / std::pow(res.prop.range_sigma, 2)) // weight=1/(sigma^2)
+            : res.prop.range_sigma);
         VALUE values[] = {
             SWIG_From(int)(prn), // prn
             rb_ary_new_from_args(prop_items, // relative_property
-              swig::from(res.prop.weight),
+              swig::from(weight),
               swig::from(res.prop.range_corrected),
               swig::from(res.prop.range_residual),
               swig::from(res.prop.rate_relative_neg),
@@ -1167,6 +1162,9 @@ struct GPS_RangeCorrector
                   .append(" @ [").append(std::to_string(i)).append("]"));
           }
         }
+        if(res.values[0] > 0){
+          res.values[0] = std::pow(1. / res.values[0], 0.5); // sigma=(1/weight)^0.5
+        }
       }while(false);
 #endif
       return res.prop;
@@ -1206,7 +1204,10 @@ struct GPS_RangeCorrector
       if(!res.is_available()){
         static const VALUE key(ID2SYM(rb_intern("relative_property")));
         VALUE hook(rb_hash_lookup(hooks, key));
-        if(!NIL_P(hook)){res.impl = this;}
+        if(!NIL_P(hook)){
+          if(!res.impl_xyz){res.impl_xyz = this;}
+          if(!res.impl_t){res.impl_t = this;}
+        }
       }
 #endif
       return res;
@@ -1361,6 +1362,28 @@ struct GPS_RangeCorrector
     return self->update_correction(true, hash);
   }
 #endif
+#ifdef SWIGRUBY
+  %typemap(out) typename super_t::options_t {
+    VALUE res(rb_hash_new());
+    rb_hash_aset(res, ID2SYM(rb_intern("skip_exclusion")), SWIG_From(bool)($1.skip_exclusion));
+    %set_output(res);
+  }
+#endif
+  %rename("options") get_options;
+  typename super_t::options_t get_options() const {
+    return self->available_options();
+  }
+  %rename("options=") set_options;
+  typename super_t::options_t set_options(SWIG_Object obj) {
+    GPS_Solver<FloatT>::super_t::options_t opt(self->available_options());
+#ifdef SWIGRUBY
+    if(!RB_TYPE_P(obj, T_HASH)){SWIG_exception(SWIG_TypeError, "Hash is expected");}
+    SWIG_AsVal(bool)(
+        rb_hash_lookup(obj, ID2SYM(rb_intern("skip_exclusion"))),
+        &opt.skip_exclusion);
+#endif
+    return self->update_options(opt);
+  }
 }
 %inline {
 template <class FloatT>
@@ -1653,31 +1676,8 @@ template <class FloatT>
 struct RINEX_Observation {};
 }
 
-%extend SP3 {
-  %typemap(in,numinputs=0) int count[ANY] (int temp[$1_dim0]) "$1 = temp;"
-  %typemap(argout) int count[ANY] {
-    for(int i(0); i < $1_dim0; ++i){
-      %append_output(SWIG_From(int)($1[i]));
-    }
-  }
-  void satellites(int count[SP3::SYS_SYSTEMS]) const {
-    typename SP3_Product<FloatT>::satellite_count_t x(self->satellite_count());
-    count[SP3<FloatT>::SYS_GPS] = x.gps;
-    count[SP3<FloatT>::SYS_SBAS] = x.sbas;
-    count[SP3<FloatT>::SYS_QZSS] = x.qzss;
-    count[SP3<FloatT>::SYS_GLONASS] = x.glonass;
-    count[SP3<FloatT>::SYS_GALILEO] = x.galileo;
-    count[SP3<FloatT>::SYS_BEIDOU] = x.beidou;
-  }
-
-} 
 %inline {
-template <class FloatT>
-struct SP3 : public SP3_Product<FloatT> {
-  int read(const char *fname) {
-    std::fstream fin(fname, std::ios::in | std::ios::binary);
-    return SP3_Reader<FloatT>::read_all(fin, *this);
-  }
+struct PushableData {
   enum system_t {
     SYS_GPS,
     SYS_SBAS,
@@ -1687,20 +1687,21 @@ struct SP3 : public SP3_Product<FloatT> {
     SYS_BEIDOU,
     SYS_SYSTEMS,
   };
-  bool push(GPS_Solver<FloatT> &solver, const system_t &sys) const {
+  template <class DataT, class FloatT>
+  static bool push(DataT &data, GPS_Solver<FloatT> &solver, const system_t &sys){
     switch(sys){
       case SYS_GPS:
-        return SP3_Product<FloatT>::push(
-            solver.gps.ephemeris_proxy.gps, SP3_Product<FloatT>::SYSTEM_GPS);
+        return data.push(
+            solver.gps.ephemeris_proxy.gps, DataT::SYSTEM_GPS);
       case SYS_SBAS:
-        return SP3_Product<FloatT>::push(
-            solver.sbas.solver.satellites, SP3_Product<FloatT>::SYSTEM_SBAS);
+        return data.push(
+            solver.sbas.solver.satellites, DataT::SYSTEM_SBAS);
       case SYS_QZSS:
-        return SP3_Product<FloatT>::push(
-            solver.gps.ephemeris_proxy.qzss, SP3_Product<FloatT>::SYSTEM_QZSS);
+        return data.push(
+            solver.gps.ephemeris_proxy.qzss, DataT::SYSTEM_QZSS);
       case SYS_GLONASS:
-        return SP3_Product<FloatT>::push(
-            solver.glonass.solver.satellites, SP3_Product<FloatT>::SYSTEM_GLONASS);
+        return data.push(
+            solver.glonass.solver.satellites, DataT::SYSTEM_GLONASS);
       case SYS_GALILEO:
       case SYS_BEIDOU:
       default:
@@ -1708,7 +1709,8 @@ struct SP3 : public SP3_Product<FloatT> {
     }
     return false;
   }
-  bool push(GPS_Solver<FloatT> &solver) const {
+  template <class DataT, class FloatT>
+  static bool push(DataT &data, GPS_Solver<FloatT> &solver){
     system_t target[] = {
       SYS_GPS,
       SYS_SBAS,
@@ -1718,10 +1720,39 @@ struct SP3 : public SP3_Product<FloatT> {
       //SYS_BEIDOU,
     };
     for(std::size_t i(0); i < sizeof(target) / sizeof(target[0]); ++i){
-      if(!push(solver, target[i])){return false;}
+      if(!push(data, solver, target[i])){return false;}
     }
     return true;
   }
+};
+}
+
+%extend SP3 {
+  %typemap(out) typename SP3_Product<FloatT>::satellite_count_t {
+    %append_output(SWIG_From(int)($1.gps));
+    %append_output(SWIG_From(int)($1.sbas));
+    %append_output(SWIG_From(int)($1.qzss));
+    %append_output(SWIG_From(int)($1.glonass));
+    %append_output(SWIG_From(int)($1.galileo));
+    %append_output(SWIG_From(int)($1.beidou));
+  }
+}
+%inline {
+template <class FloatT>
+struct SP3 : public SP3_Product<FloatT>, PushableData {
+  int read(const char *fname) {
+    std::fstream fin(fname, std::ios::in | std::ios::binary);
+    return SP3_Reader<FloatT>::read_all(fin, *this);
+  }
+  typename SP3_Product<FloatT>::satellite_count_t satellites() const {
+    return SP3_Product<FloatT>::satellite_count();
+  }
+  bool push(GPS_Solver<FloatT> &solver, const PushableData::system_t &sys) const {
+    return PushableData::push((SP3_Product<FloatT> &)*this, solver, sys);
+  }
+  bool push(GPS_Solver<FloatT> &solver) const {
+    return PushableData::push((SP3_Product<FloatT> &)*this, solver);
+  }
   System_XYZ<FloatT, WGS84> position(
       const int &sat_id, const GPS_Time<FloatT> &t) const {
     return SP3_Product<FloatT>::select(sat_id, t).position(t);
@@ -1748,6 +1779,46 @@ struct SP3 : public SP3_Product<FloatT> {
 };
 }
 
+%extend RINEX_Clock {
+  %typemap(out) typename RINEX_CLK<FloatT>::satellites_t::count_t {
+    %append_output(SWIG_From(int)($1.gps));
+    %append_output(SWIG_From(int)($1.sbas));
+    %append_output(SWIG_From(int)($1.qzss));
+    %append_output(SWIG_From(int)($1.glonass));
+    %append_output(SWIG_From(int)($1.galileo));
+    %append_output(SWIG_From(int)($1.beidou));
+  }
+}
+%inline {
+template <class FloatT>
+struct RINEX_Clock : public RINEX_CLK<FloatT>::satellites_t, PushableData {
+  typedef typename RINEX_CLK<FloatT>::satellites_t super_t;
+  int read(const char *fname) {
+    std::fstream fin(fname, std::ios::in | std::ios::binary);
+    return RINEX_CLK_Reader<FloatT>::read_all(fin, *this);
+  }
+  typename RINEX_CLK<FloatT>::satellites_t::count_t satellites() const {
+    return RINEX_CLK<FloatT>::satellites_t::count();
+  }
+  bool push(GPS_Solver<FloatT> &solver, const PushableData::system_t &sys) const {
+    return PushableData::push((typename RINEX_CLK<FloatT>::satellites_t &)*this, solver, sys);
+  }
+  bool push(GPS_Solver<FloatT> &solver) const {
+    return PushableData::push((typename RINEX_CLK<FloatT>::satellites_t &)*this, solver);
+  }
+  FloatT clock_error(const int &sat_id, const GPS_Time<FloatT> &t) const {
+    typename super_t::buf_t::const_iterator it(this->buf.find(sat_id));
+    if(it == this->buf.end()){return super_t::sat_t::unavailable().clock_error(t);}
+    return it->second.clock_error(t);
+  }
+  FloatT clock_error_dot(const int &sat_id, const GPS_Time<FloatT> &t) const {
+    typename super_t::buf_t::const_iterator it(this->buf.find(sat_id));
+    if(it == this->buf.end()){return super_t::sat_t::unavailable().clock_error(t);}
+    return it->second.clock_error_dot(t);
+  }
+};
+}
+
 #undef MAKE_ACCESSOR
 #undef MAKE_VECTOR2ARRAY
 #undef MAKE_ARRAY_INPUT
@@ -1776,6 +1847,7 @@ struct SP3 : public SP3_Product<FloatT> {
 
 %template(RINEX_Observation) RINEX_Observation<type>;
 %template(SP3) SP3<type>;
+%template(RINEX_Clock) RINEX_Clock<type>;
 %enddef
 
 CONCRETIZE(double);

data/ext/ninja-scan-light/tool/swig/SylphideMath.i

@@ -592,7 +592,6 @@ struct MatrixUtil {
       }
       static VALUE read(
           const VALUE &v, const unsigned int &row = 0, const unsigned int &column = 0) {
-        int state;
         VALUE values[3] = {v, UINT2NUM(row), UINT2NUM(column)};
         return funcall_throw_if_error(run, reinterpret_cast<VALUE>(values));
       }
@@ -865,7 +864,7 @@ struct MatrixUtil {
         static const ID with_index[] = {
             rb_intern("map_with_index"), rb_intern("map_with_index!"), 
             rb_intern("collect_with_index"), rb_intern("collect_with_index!")};
-        for(int i(0); i < sizeof(with_index) / sizeof(with_index[0]); ++i){
+        for(std::size_t i(0); i < sizeof(with_index) / sizeof(with_index[0]); ++i){
           if(id_callee == with_index[i]){
             return matrix_yield_get_with_index;
           }