gps_pvt 0.3.0 → 0.3.3

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

@@ -339,10 +339,16 @@ struct GPS_Time {
     return t.operator<=(*this);
   }
   
+  /**
+   * Convert to std::tm struct
+   * @param leap_seconds If offset of GPS time relative to UTC is known,
+   * specify it by using this parameter.
+   * As of Jan. 1st, 2022, +18 seconds are specified.
+   */
   std::tm c_tm(const float_t &leap_seconds = 0) const {
     std::tm t;
     
-    GPS_Time mod_t((*this) + leap_seconds);
+    GPS_Time mod_t((*this) - leap_seconds);
     
     std::div_t min_sec(std::div((int)mod_t.seconds, 60));
     t.tm_sec = min_sec.rem;

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

@@ -153,6 +153,12 @@ static std::string inspect_str(const VALUE &v){
     $1 = (TYPE($input) == T_ARRAY) ? 1 : 0;
   }
 #endif
+  %ignore canonicalize();
+  %ignore GPS_Time(const int &_week, const float_t &_seconds);
+  %typemap(in, numinputs=0) void *dummy "";
+  GPS_Time(const int &week_, const float_t &seconds_, void *dummy){
+    return &((new GPS_Time<FloatT>(week_, seconds_))->canonicalize());
+  }
   %apply int *OUTPUT { int *week };
   %apply FloatT *OUTPUT { FloatT *seconds };
   void to_a(int *week, FloatT *seconds) const {

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

@@ -437,8 +437,6 @@ class Matrix : public Matrix_Frozen<T, Array2D_Type, ViewType> {
 #endif
 
     typedef Matrix<T, Array2D_Type, ViewType> self_t;
-    self_t &swapRows(const unsigned int &row1, const unsigned int &row2);
-    self_t &swapColumns(const unsigned int &column1, const unsigned int &column2);
 };
 
 %inline {
@@ -995,7 +993,23 @@ MAKE_TO_S(Matrix_Frozen)
   }
 #endif
 
-  %typemap(out) self_t & "$result = self;"
+  /*
+   * Returning (*this) requires special care;
+   * "self_t &func(){return (*this);}" in a C++ file may generate
+   * a new wrapped object deleted by GC in the target language
+   * unless the care.
+   * 
+   * Work around 1)
+   *   %typemap(in, numinputs=0) self_t *self_p "";
+   *   %typemap(argout) self_t *self_p "$result = self;";
+   *   void func(self_t *self_p){...}
+   *
+   * Work around 2) (useful without overwrite of the original source, but may overfit)
+   *   %typemap(out) self_t & "$result = self;"
+   *   self_t &func(){...; return *$self;}
+   */
+  %typemap(in, numinputs=0) self_t *self_p "";
+  %typemap(argout) self_t *self_p "$result = self;";
 
   T &__setitem__(const unsigned int &row, const unsigned int &column, const T &value) {
     return (($self)->operator()(row, column) = value);
@@ -1012,41 +1026,50 @@ MAKE_TO_S(Matrix_Frozen)
 #endif
   %rename("scalar") getScalar;
   %rename("I") getI;
-  %rename("swap_rows") swapRows;
-  %rename("swap_columns") swapColumns;
+
+  void swap_rows(
+      self_t *self_p,
+      const unsigned int &r1, const unsigned int &r2){
+    $self->swapRows(r1, r2);
+  }
+  void swap_columns(
+      self_t *self_p,
+      const unsigned int &c1, const unsigned int &c2){
+    $self->swapColumns(c1, c2);
+  }
 
   template <class T2, class Array2D_Type2, class ViewType2>
-  self_t &replace(const Matrix_Frozen<T2, Array2D_Type2, ViewType2> &matrix){
-    return $self->replace(matrix);
+  void replace(
+      self_t *self_p,
+      const Matrix_Frozen<T2, Array2D_Type2, ViewType2> &matrix){
+    $self->replace(matrix);
   }
   INSTANTIATE_MATRIX_FUNC(replace, replace);
 
-  self_t &replace(const void *replacer = NULL){
+  void replace(self_t *self_p, const void *replacer = NULL){
     if(!MatrixUtil::replace(*$self, replacer)){
       throw std::runtime_error("Unsupported replacement");
     }
-    return *$self;
   }
 
-  self_t &replace(const T *serialized){
+  void replace(self_t *self_p, const T *serialized){
     if(!MatrixUtil::replace(*$self, serialized)){
       throw std::runtime_error("Unsupported replacement");
     }
-    return *$self;
   }
   
 #ifdef SWIGRUBY
-  %bang swapRows(const unsigned int &, const unsigned int &);
-  %bang swapColumns(const unsigned int &, const unsigned int &);
+  %bang swap_rows;
+  %bang swap_columns;
   %rename("replace!") replace;
   
-  self_t &map_bang(
+  void map_bang(
+      self_t *self_p,
       void (*each_func)(
         const T &src, T *dst,
         const unsigned int &i, const unsigned int &j), 
       const typename MatrixUtil::each_which_t &each_which = MatrixUtil::EACH_ALL){
     MatrixUtil::each(*$self, each_func, each_which, $self);
-    return *$self;
   }
   %rename("map!") map_bang;
   %alias map_bang "collect!,map_with_index!,collect_with_index!";

data/ext/ninja-scan-light/tool/swig/spec/GPS_spec.rb

@@ -253,6 +253,7 @@ __RINEX_OBS_TEXT__
       t_meas = GPS::Time::new(1849, 172413)
       puts "Measurement time: #{t_meas.to_a} (a.k.a #{"%d/%d/%d %02d:%02d:%02d UTC"%[*t_meas.c_tm]})"
       expect(t_meas.c_tm).to eq([2015, 6, 15, 23, 53, 33])
+      expect(GPS::Time::new(0, t_meas.serialize)).to eq(t_meas)
       
       sn.update_all_ephemeris(t_meas)
       

data/ext/ninja-scan-light/tool/swig/spec/SylphideMath_spec.rb

@@ -214,9 +214,19 @@ shared_examples 'Matrix' do
     it 'is swappable with swap_rows! or swap_cloumns!' do
       mat_builtin = Matrix[*compare_with[0]]
       [:swap_rows!, :swap_columns!].each.with_index{|func, i|
-        params[:rc][i].times.to_a.combination(2).to_a{|a, b|
-          mat[0].send(func, a, b)
-          mat_builtin.send(func, a, b)
+        params[:rc][i].times.to_a.combination(2).to_a.each{|a, b|
+          mat_mod = mat[0].send(func, a, b)
+          case func
+          when :swap_rows!
+            idxs = mat_builtin.row_count.times.to_a
+            idxs[a], idxs[b] = [b, a]
+            mat_builtin = Matrix::rows(mat_builtin.row_vectors.values_at(*idxs))
+          when :swap_columns!
+            idxs = mat_builtin.column_count.times.to_a
+            idxs[a], idxs[b] = [b, a]
+            mat_builtin = Matrix::columns(mat_builtin.column_vectors.values_at(*idxs))
+          end
+          expect(mat_mod).to equal(mat[0])
           expect(mat[0].to_a).to eq(mat_builtin.to_a)
         }
       }

data/lib/gps_pvt/receiver.rb

@@ -7,15 +7,22 @@ require_relative 'GPS'
 
 module GPS_PVT
 class Receiver
+
+  GPS::Time.send(:define_method, :utc){ # send as work around of old Ruby
+    res = c_tm(GPS::Time::guess_leap_seconds(self))
+    res[-1] += (seconds % 1)
+    res
+  }
+
   def self.pvt_items(opt = {})
     opt = {
       :system => [[:GPS, 1..32]],
       :satellites => (1..32).to_a,
     }.merge(opt)
     [[
-      [:week, :itow_rcv, :year, :month, :mday, :hour, :min, :sec],
+      [:week, :itow_rcv, :year, :month, :mday, :hour, :min, :sec_rcv_UTC],
       proc{|pvt|
-        [:week, :seconds, :c_tm].collect{|f| pvt.receiver_time.send(f)}.flatten
+        [:week, :seconds, :utc].collect{|f| pvt.receiver_time.send(f)}.flatten
       }
     ]] + [[
       [:receiver_clock_error_meter, :longitude, :latitude, :height, :rel_E, :rel_N, :rel_U],
@@ -402,7 +409,7 @@ class Receiver
     ubx = UBX::new(open(ubx_fname))  
     ubx_kind = Hash::new(0)
     
-    after_run = b || proc{|pvt| puts pvt.to_s}
+    after_run = b || proc{|pvt| puts pvt.to_s if pvt}
     
     gnss_serial = proc{|svid, sys|
       if sys then # new numbering
@@ -526,7 +533,7 @@ class Receiver
   end
   
   def parse_rinex_obs(fname, &b)
-    after_run = b || proc{|pvt| puts pvt.to_s}
+    after_run = b || proc{|pvt| puts pvt.to_s if pvt}
     $stderr.print "Reading RINEX observation file (%s)"%[fname]
     types = nil
     count = 0

data/lib/gps_pvt/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module GPS_PVT
-  VERSION = "0.3.0"
+  VERSION = "0.3.3"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: gps_pvt
 version: !ruby/object:Gem::Version
-  version: 0.3.0
+  version: 0.3.3
 platform: ruby
 authors:
 - fenrir(M.Naruoka)
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2022-03-01 00:00:00.000000000 Z
+date: 2022-03-04 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake