gps_pvt 0.1.7 → 0.2.3

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

@@ -238,6 +238,23 @@ INSTANTIATE_COMPLEX(double, D);
 
 #undef INSTANTIATE_COMPLEX
 
+#if defined(SWIGRUBY)
+/* Work around of miss detection of negative value on Windows Ruby (devkit). 
+ * This results from SWIG_AsVal(unsigned int) depends on SWIG_AsVal(unsigned long), 
+ * and sizeof(long) == sizeof(int).
+ */
+%fragment("check_value"{unsigned int}, "header"){
+  inline bool is_lt_zero_after_asval(const unsigned int &i){
+    return ((sizeof(unsigned int) == sizeof(unsigned long)) && ((UINT_MAX >> 1) <= i));
+  }
+  void raise_if_lt_zero_after_asval(const unsigned int &i){
+    if(is_lt_zero_after_asval(i)){
+      SWIG_exception(SWIG_ValueError, "Expected positive value.");
+    }
+  } 
+}
+#endif
+
 #define DO_NOT_INSTANTIATE_SCALAR_MATRIX
 #define USE_MATRIX_VIEW_FILTER
 
@@ -949,6 +966,7 @@ MAKE_TO_S(Matrix_Frozen)
   }
 #if defined(SWIGRUBY)
   %fragment(SWIG_AsVal_frag(unsigned int));
+  %fragment("check_value"{unsigned int});
   Matrix(const void *replacer){
     const SWIG_Object *value(static_cast<const SWIG_Object *>(replacer));
     static const ID id_r(rb_intern("row_size")), id_c(rb_intern("column_size"));
@@ -959,13 +977,10 @@ MAKE_TO_S(Matrix_Frozen)
       MatrixUtil::replace(res, replacer);
       return new Matrix<T, Array2D_Type, ViewType>(res);
     }else if(value && rb_respond_to(*value, id_r) && rb_respond_to(*value, id_c)){
-      /* "unsigned" is remove because SWIG_AsVal(unsigned int)
-       * can not detect less than zero in Windows Ruby devkit.
-       */
-      int r, c; 
+      unsigned int r, c; 
       VALUE v_r(rb_funcall(*value, id_r, 0, 0)), v_c(rb_funcall(*value, id_c, 0, 0));
-      if(!SWIG_IsOK(SWIG_AsVal(int)(v_r, &r)) || (r < 0)
-          || !SWIG_IsOK(SWIG_AsVal(int)(v_c, &c)) || (c < 0)){
+      if(!SWIG_IsOK(SWIG_AsVal(unsigned int)(v_r, &r)) || is_lt_zero_after_asval(r)
+          || !SWIG_IsOK(SWIG_AsVal(unsigned int)(v_c, &c)) || is_lt_zero_after_asval(c)){
         throw std::runtime_error(
             std::string("Unexpected length [")
               .append(inspect_str(v_r)).append(", ")
@@ -1147,6 +1162,8 @@ INSTANTIATE_MATRIX_EIGEN2(type, ctype, Array2D_Dense<type >, MatView_pt);
 #endif
 
 %define INSTANTIATE_MATRIX(type, suffix)
+%typemap(check, fragment="check_value"{unsigned int})
+    const unsigned int & "raise_if_lt_zero_after_asval(*$1);"
 #if !defined(DO_NOT_INSTANTIATE_SCALAR_MATRIX)
 %extend Matrix_Frozen<type, Array2D_ScaledUnit<type >, MatViewBase> {
   const Matrix_Frozen<type, Array2D_ScaledUnit<type >, MatViewBase> &transpose() const {
@@ -1200,6 +1217,35 @@ INSTANTIATE_MATRIX_PARTIAL(type, Array2D_Dense<type >, MatView_pt, MatView_pt);
 %template(Matrix_Frozen ## suffix ## _pt) Matrix_Frozen<type, Array2D_Dense<type >, MatView_pt>;
 #endif
 
+%extend Matrix<type, Array2D_Dense<type > > {
+#if defined(SWIGRUBY)
+  %bang resize;
+#endif
+  %typemap(in, fragment="check_value"{unsigned int}) 
+      unsigned int *r_p (unsigned int temp), unsigned int *c_p (unsigned int temp) {
+    if(SWIG_IsOK(SWIG_AsVal(unsigned int)($input, &temp))){
+#if defined(SWIGRUBY)
+      raise_if_lt_zero_after_asval(temp);
+#endif
+      $1 = &temp;
+    }
+#if defined(SWIGRUBY)
+    else if(NIL_P($input)){$1 = NULL;}
+#endif
+    else{SWIG_exception(SWIG_TypeError, "$*1_ltype is expected");}
+  }
+  Matrix<type, Array2D_Dense<type > > &resize(
+      const unsigned int *r_p, const unsigned int *c_p){
+    unsigned int r(r_p ? *r_p : $self->rows()), c(c_p ? *c_p : self->columns());
+    Matrix<type, Array2D_Dense<type > > mat_new(r, c);
+    unsigned int r_min(r), c_min(c);
+    if(r_min > $self->rows()){r_min = $self->rows();}
+    if(c_min > $self->columns()){c_min = $self->columns();}
+    mat_new.partial(r_min, c_min).replace($self->partial(r_min, c_min), false);
+    return (*($self) = mat_new);
+  }
+};
+
 %template(Matrix ## suffix) Matrix<type, Array2D_Dense<type > >;
 #if defined(SWIGRUBY)
 %fragment("init"{Matrix<type, Array2D_Dense<type > >}, "init") {
@@ -1212,6 +1258,7 @@ INSTANTIATE_MATRIX_PARTIAL(type, Array2D_Dense<type >, MatView_pt, MatView_pt);
 }
 %fragment("init"{Matrix<type, Array2D_Dense<type > >});
 #endif
+%typemap(check) const unsigned int &;
 %enddef
 
 INSTANTIATE_MATRIX(double, D);

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

@@ -221,7 +221,11 @@ __RINEX_OBS_TEXT__
       f.path
     },
   }}
-  let(:solver){GPS::Solver::new}
+  let(:solver){
+    res = GPS::Solver::new
+    res.correction = {:gps_ionospheric => :klobuchar, :gps_tropospheric => :hopfield}
+    res
+  }
   
   describe 'demo' do
     it 'calculates position without any error' do
@@ -255,7 +259,6 @@ __RINEX_OBS_TEXT__
       [:alpha, :beta].each{|k|
         puts "Iono #{k}: #{sn.iono_utc.send(k)}"
       }
-      puts solver.gps_options.ionospheric_models
       
       meas.each{|prn, k, v|
         eph = sn.ephemeris(prn)
@@ -336,11 +339,21 @@ __RINEX_OBS_TEXT__
     
     it 'can be modified through hooks' do
       sn = solver.gps_space_node
+      expect(solver.correction[:gps_ionospheric]).to include(:klobuchar)
+      expect(solver.correction[:gps_tropospheric]).to include(:hopfield)
+      expect{solver.correction = nil}.to raise_error(RuntimeError)
+      expect{solver.correction = {
+        :gps_ionospheric => [:klobuchar, :no_correction],
+        :options => {:f_10_7 => 10},
+      }}.not_to raise_error
+      expect(solver.correction[:gps_ionospheric]).to include(:no_correction)
+      expect(solver.correction[:options][:f_10_7]).to eq(10)
       sn.read(input[:rinex_nav])
       t_meas = GPS::Time::new(1849, 172413)
       sn.update_all_ephemeris(t_meas)
-      solver.hooks[:relative_property] = proc{|prn, rel_prop, rcv_e, t_arv, usr_pos, usr_vel|
+      solver.hooks[:relative_property] = proc{|prn, rel_prop, meas, rcv_e, t_arv, usr_pos, usr_vel|
         expect(input[:measurement]).to include(prn)
+        expect(meas).to be_a_kind_of(Hash)
         expect(t_arv).to be_a_kind_of(GPS::Time)
         expect(usr_pos).to be_a_kind_of(Coordinate::XYZ)
         expect(usr_vel).to be_a_kind_of(Coordinate::XYZ)
@@ -348,12 +361,30 @@ __RINEX_OBS_TEXT__
         weight = 1
         [weight, range_c, range_r, rate_rel_neg] + los_neg
       }
-      solver.hooks[:update_position_solution] = proc{|*mats|
-        mats.each{|mat|
+      solver.hooks[:update_position_solution] = proc{|mat_G, mat_W, mat_delta_r, temp_pvt|
+        expect(temp_pvt).to be_a_kind_of(GPS::PVT)
+        [mat_G, mat_W, mat_delta_r].each{|mat|
           expect(mat).to be_a_kind_of(SylphideMath::MatrixD)
+          expect(mat.rows).to be >= temp_pvt.used_satellites
+          expect(mat).to respond_to(:resize!)
         }
-        mat_G, mat_W, mat_delta_r = mats
       }
+      solver.hooks[:satellite_position] = proc{
+        i = 0
+        proc{|prn, time, pos|
+          expect(input[:measurement]).to include(prn)
+          expect(pos).to be_a_kind_of(Coordinate::XYZ).or eq(nil)
+          # System_XYZ or [x,y,z] or nil(= unknown position) are acceptable
+          case (i += 1) % 5
+          when 0
+            nil
+          when 1
+            pos.to_a
+          else
+            pos
+          end
+        }
+      }.call
       pvt = solver.solve(
           input[:measurement].collect{|prn, items|
             items.collect{|k, v| [prn, k, v]}

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

@@ -19,6 +19,12 @@ shared_examples 'Matrix' do
       expect( mat_type::new(*params[:rc]).rows ).to equal(params[:rc][0])
       expect( mat_type::new(*params[:rc]).columns ).to equal(params[:rc][1])
     end
+    it 'declines negative number argument' do
+      [[-1, 1], [1, -1]].each{|sf|
+        r, c = params[:rc].zip(sf).collect{|v1, v2| v1 * v2}
+        expect{ mat_type::new(r, c) }.to raise_error(ArgumentError)
+      }
+    end
     it 'accepts ([[]])' do
       expect{ mat_type::new(compare_with) }.not_to raise_error
       expect( mat_type::new(compare_with).rows ).to equal(params[:rc][0])
@@ -44,9 +50,11 @@ shared_examples 'Matrix' do
       a.define_singleton_method(:[]){|i, j| raise(IndexError) if i != j; 0}
       expect{ mat_type::new(a) }.to raise_error(IndexError)
 
-      a = a_gen.call
-      a.define_singleton_method(:row_size){-1}
-      expect{ mat_type::new(a) }.to raise_error(RuntimeError)
+      [:row_size, :column_size].each{|f|
+        a = a_gen.call
+        a.define_singleton_method(f){-1}
+        expect{ mat_type::new(a) }.to raise_error(RuntimeError)
+      }
     end
     it 'is invoked with I, identity, unit' do
       [:I, :identity, :unit].each{|f|
@@ -132,7 +140,7 @@ shared_examples 'Matrix' do
         expect(mat[:square].sum).to eq(Matrix[*mat[:square].to_a].sum)
         expect(mat[:not_square].sum).to eq(Matrix[*mat[:not_square].to_a].sum)
       end
-      it 'determinat, det' do
+      it 'determinant, det' do
         [:determinant, :det].each{|f|
           #expect(mat[:square].send(f)).to eq(Matrix[*mat[:square].to_a].det)
           expect{mat[:not_square].send(f)}.to raise_error(RuntimeError)
@@ -163,6 +171,15 @@ shared_examples 'Matrix' do
         }
       }
     end
+    it 'is inaccessible and unchangeable with negative number arguments' do
+      [[-1, 0], [0, -1]].each{|i, j|
+        [[:[], i, j], [:[]=, i, j, 0]].each{|args|
+          expect{ mat[0].send(*args) }.to raise_error{|err|
+            expect(err).to be_a(RangeError).or be_a(ArgumentError)
+          }
+        }
+      }
+    end
   end
   
   describe 'elements' do
@@ -394,6 +411,23 @@ shared_examples 'Matrix' do
       }
       expect{mat[2] / mat[3]}.to raise_error(RuntimeError)
     end
+    it 'have resize!' do
+      [-1, :sym].each{|arg|
+        [[arg, nil], [nil, arg]].each{|args|
+          expect{mat[0].resize!(*args)}.to raise_error{|err|
+            expect(err).to be_a(TypeError).or be_a(ArgumentError)
+          }
+        }
+      }
+      mat_orig = mat[0].to_a
+      r, c = [:rows, :columns].collect{|f| mat[0].send(f)}
+      expect(mat[0].resize!(r, c).to_a).to eq(mat_orig)
+      expect(mat[0].resize!(r, nil).to_a).to eq(mat_orig)
+      expect(mat[0].resize!(nil, c).to_a).to eq(mat_orig)
+      expect(mat[0].resize!(nil, nil).to_a).to eq(mat_orig)
+      expect(mat[0].resize!(r * 2, c * 2).to_a).to \
+          eq(Matrix::build(r * 2, c * 2){|i, j| (i < r && j < c) ? mat_orig[i][j] : 0}.to_a)
+    end
   end
   
   describe 'decomposition' do

data/gps_pvt.gemspec

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+require_relative "lib/gps_pvt/version"
+
+Gem::Specification.new do |spec|
+  spec.name = "gps_pvt"
+  spec.version = GPS_PVT::VERSION
+  spec.authors = ["fenrir(M.Naruoka)"]
+  spec.email = ["fenrir.naru@gmail.com"]
+
+  spec.summary = "GPS position, velocity, and time (PVT) solver"
+  spec.description = "This module calculate PVT by using raw observation obtained from a GPS receiver"
+  spec.homepage = "https://github.com/fenrir-naru/gps_pvt"
+  spec.required_ruby_version = ">= 2.3.0"
+
+  #spec.metadata["allowed_push_host"] = "TODO: Set to your gem server 'https://example.com'"
+
+  spec.metadata["homepage_uri"] = spec.homepage
+  spec.metadata["source_code_uri"] = spec.homepage
+  #spec.metadata["changelog_uri"] = "TODO: Put your gem's CHANGELOG.md URL here."
+    
+  spec.extensions = ["ext/gps_pvt/extconf.rb"]
+
+  # Specify which files should be added to the gem when it is released.
+  # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
+  spec.files = Dir.chdir(File.expand_path(__dir__)) do
+    `git ls-files -z`.split("\x0").reject do |f|
+      (f == __FILE__) || f.match(%r{\A(?:(?:test|spec|features)/|\.(?:git|travis|circleci)|appveyor)})
+    end
+  end
+  spec.bindir = "exe"
+  spec.executables = spec.files.grep(%r{\Aexe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+  
+  spec.files += proc{
+    require 'pathname'
+    base_dir = Pathname::new(File::absolute_path(File.dirname(__FILE__)))
+    # get an array of submodule dirs by executing 'pwd' inside each submodule
+    `git submodule --quiet foreach pwd`.split($/).collect{|dir|
+      # issue git ls-files in submodule's directory
+      `git -C #{dir} ls-files -v`.split($/).collect{|f|
+        next nil unless f =~ /^H */ # consider git sparse checkout
+        # get relative path
+        f = Pathname::new(File::join(dir, $'))
+        begin
+          (f.relative? ? f : f.relative_path_from(base_dir)).to_s
+        rescue
+          # Patch for Windows drive letter problem
+          base_dir = Pathname::new(base_dir.to_s.sub(/^([^\/])+:\//){"/#{$1}/"})
+          f.relative_path_from(base_dir).to_s
+        end
+      }.compact
+    }.flatten
+  }.call
+
+  # Uncomment to register a new dependency of your gem
+  # spec.add_dependency "example-gem", "~> 1.0"
+  spec.add_development_dependency "rake"
+  spec.add_development_dependency "rake-compiler"
+
+  # For more information and examples about making a new gem, checkout our
+  # guide at: https://bundler.io/guides/creating_gem.html
+end