gps_pvt 0.9.3 → 0.9.4

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

@@ -380,6 +380,32 @@ struct MatrixBuilder_Dependency<
             (MatrixViewProperty<ViewType_R>::transposed ? nR_R : nC_R)>,
           ViewType> > {};
 
+template <
+    class T, class T_op,
+    class T2, class T3, class T4, class T5,
+    class ViewType,
+    int nR_L, int nC_L, class ViewType_L,
+    int nR_R, int nC_R, class ViewType_R,
+    bool horizontal_R>
+struct MatrixBuilder_Dependency<
+    Matrix_Frozen<
+        T,
+        Array2D_Operator<T_op, Array2D_Operator_Stack<
+          Matrix_Frozen<T2, Array2D_Fixed<T3, nR_L, nC_L>, ViewType_L>,
+          Matrix_Frozen<T4, Array2D_Fixed<T5, nR_R, nC_R>, ViewType_R>,
+          horizontal_R> >,
+        ViewType> >
+    : public MatrixBuilder_Dependency<
+        Matrix_Frozen<
+          T,
+          Array2D_Fixed<
+            T,
+            (MatrixViewProperty<ViewType_L>::transposed ? nC_L : nR_L)
+              + (horizontal_R ? 0 : (MatrixViewProperty<ViewType_R>::transposed ? nC_R : nR_R)),
+            (MatrixViewProperty<ViewType_L>::transposed ? nR_L : nC_L)
+              + (horizontal_R ? (MatrixViewProperty<ViewType_R>::transposed ? nR_R : nC_R) : 0)>,
+          ViewType> > {};
+
 // For optimization of local temporary matrix
 template <
     template <class, class, class> class MatrixT,

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

@@ -1094,18 +1094,18 @@ struct GPS_User_PVT
                       .append(inspect_str(v_key_value)).append("}").c_str());
               }
               rb_hash_foreach(v_key_value,
-#if RUBY_API_VERSION < 20700
+%#if RUBY_API_VERSION_CODE < 20700
                   // @see https://docs.ruby-lang.org/ja/latest/doc/news=2f2_7_0.html
                   (int (*)(ANYARGS))
-#endif
+%#endif
                   arg_t::iter2, v_arg);
               return ST_CONTINUE;
             }
           } arg = {val};
           rb_hash_foreach(obj,
-#if RUBY_API_VERSION < 20700
+%#if RUBY_API_VERSION_CODE < 20700
               (int (*)(ANYARGS))
-#endif
+%#endif
               arg_t::iter1, reinterpret_cast<VALUE>(&arg));
           return SWIG_OK;
         }
@@ -1169,6 +1169,7 @@ struct GPS_Measurement {
     L1_RANGE_RATE_SIGMA,
     L1_SIGNAL_STRENGTH_dBHz,
     L1_LOCK_SEC,
+    L1_CARRIER_PHASE_AMBIGUITY_SCALE,
     L1_FREQUENCY,
 #define make_entry(key) L2CM_ ## key, L2CL_ ## key
 #define make_entry2(key) make_entry(key), make_entry(key ## _SIGMA)
@@ -1178,6 +1179,7 @@ struct GPS_Measurement {
     make_entry2(RANGE_RATE),
     make_entry(SIGNAL_STRENGTH_dBHz),
     make_entry(LOCK_SEC),
+    make_entry(CARRIER_PHASE_AMBIGUITY_SCALE),
 #undef make_entry2
 #undef make_entry
     ITEMS_PREDEFINED,

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

@@ -123,16 +123,16 @@ class Complex;
       typedef Complex<T> value_type;
       static int asval(VALUE obj, value_type *v) {
         if(RB_TYPE_P(obj, T_COMPLEX)){
-#if RUBY_API_VERSION_CODE < 20600
+%#if RUBY_API_VERSION_CODE < 20600
           static const ID id_r(rb_intern("real")), id_i(rb_intern("imag"));
           int res = swig::asval(rb_funcall(obj, id_r, 0), &(v->real()));
           if(!SWIG_IsOK(res)){return res;}
           return swig::asval(rb_funcall(obj, id_i, 0), &(v->imaginary()));
-#else
+%#else
           int res = swig::asval(rb_complex_real(obj), &(v->real()));
           if(!SWIG_IsOK(res)){return res;}
           return swig::asval(rb_complex_imag(obj), &(v->imaginary()));
-#endif 
+%#endif 
         }else{
           v->imaginary() = T(0);
           return swig::asval(obj, &(v->real()));
@@ -148,14 +148,14 @@ class Complex;
     template <class T> struct traits_check< Complex<T>, value_category> {
       static bool check(VALUE obj) {
         if(RB_TYPE_P(obj, T_COMPLEX)){
-#if RUBY_API_VERSION_CODE < 20600
+%#if RUBY_API_VERSION_CODE < 20600
           static const ID id_r(rb_intern("real")), id_i(rb_intern("imag"));
           return swig::check<T>(rb_funcall(obj, id_r, 0))
               && swig::check<T>(rb_funcall(obj, id_i, 0));
-#else
+%#else
           return swig::check<T>(rb_complex_real(obj))
               && swig::check<T>(rb_complex_imag(obj));
-#endif
+%#endif
         }else{
           return swig::check<T>(obj);
         }
@@ -345,12 +345,6 @@ struct MatrixViewFilter : public BaseView {
     res.view().partial(new_rows, new_columns, row_offset, column_offset);
     return res;
   }
-  template <class T, class Array2D_Type, class ViewType>
-  static Matrix_Frozen<T, Array2D_Type, self_t> partial(
-      const Matrix_Frozen<T, Array2D_Type, ViewType> &orig,
-      const unsigned int &new_rows, const unsigned int &new_columns) {
-    return partial(orig, new_rows, new_columns, 0, 0);
-  }
 
   template<class CharT, class Traits>
   friend std::basic_ostream<CharT, Traits> &operator<<(
@@ -412,17 +406,27 @@ class Matrix_Frozen {
     template <class T2, class Array2D_Type2, class ViewType2>
     bool operator==(const Matrix_Frozen<T2, Array2D_Type2, ViewType2> &matrix) const noexcept;
     // bool operator!= // automatically defined
-    
+
     bool isSquare() const noexcept;
     bool isDiagonal() const noexcept;
+    bool isLowerTriangular() const noexcept;
+    bool isUpperTriangular() const noexcept;
     bool isSymmetric() const noexcept;
+    bool isHermitian() const noexcept;
+    bool isSkewSymmetric() const noexcept;
+    bool isNormal() const noexcept;
+    bool isOrthogonal() const noexcept;
+    bool isUnitary() const noexcept;
     
-    T trace(const bool &do_check = true) const;
+    T trace() const;
     T sum() const noexcept;
     
     // bool isLU() const noexcept
     
-    T determinant(const bool &do_check = true) const;
+    T determinant() const;
+    unsigned int rank() const;
+    T cofactor(
+        const unsigned int &row, const unsigned int &column) const;
 };
 
 template <class T, class Array2D_Type, class ViewType = MatrixViewBase<> >
@@ -470,6 +474,11 @@ typedef MatrixViewTranspose<MatrixViewSizeVariable<MatrixViewOffset<MatrixViewBa
 
 %{
 struct MatrixUtil {
+  struct each_break_t {
+    unsigned int r, c;
+    each_break_t(const unsigned int &row, const unsigned int &column)
+        : r(row), c(column) {}
+  };
   enum each_which_t {
     EACH_ALL,
     EACH_DIAGONAL,
@@ -478,6 +487,7 @@ struct MatrixUtil {
     EACH_UPPER,
     EACH_STRICT_LOWER,
     EACH_STRICT_UPPER,
+    EACH_UNKNOWN,
   };
   template <class T, 
       class Array2D_Type, class ViewType,
@@ -488,7 +498,7 @@ struct MatrixUtil {
         const T &src_elm, T *dst_elm,
         const unsigned int &i, const unsigned int &j),
       const each_which_t &each_which = EACH_ALL,
-      Matrix<T, Array2D_Type2, ViewType2> *dst = NULL){
+      Matrix<T, Array2D_Type2, ViewType2> *dst = NULL) {
     unsigned int i_max(src.rows()), j_max(src.columns());
     switch(each_which){
       case EACH_DIAGONAL:
@@ -544,10 +554,8 @@ struct MatrixUtil {
     }
   }
 #if defined(SWIGRUBY)
-  static const each_which_t &sym2each_which(const VALUE &value){
-    if(!RB_TYPE_P(value, T_SYMBOL)){
-      std::invalid_argument("Symbol is required");
-    }
+  static each_which_t sym2each_which(const VALUE &value){
+    if(!RB_TYPE_P(value, T_SYMBOL)){return EACH_UNKNOWN;}
     static const struct {
       VALUE sym;
       each_which_t which;
@@ -564,9 +572,7 @@ struct MatrixUtil {
     while(value != cmp[i].sym){
       if(++i >= (sizeof(cmp) / sizeof(cmp[0]))){break;}
     }
-    if(i >= (sizeof(cmp) / sizeof(cmp[0]))){
-      std::invalid_argument("Unknown enumerate direction");
-    }
+    if(i >= (sizeof(cmp) / sizeof(cmp[0]))){return EACH_UNKNOWN;}
     return cmp[i].which;
   }
 #endif
@@ -671,6 +677,8 @@ struct MatrixUtil {
   %catches(std::out_of_range) rowVector;
   %catches(std::out_of_range) columnVector;
   %catches(std::logic_error, std::runtime_error) determinant;
+  %catches(std::logic_error) rank;
+  %catches(std::logic_error, std::runtime_error) cofactor;
 
   T __getitem__(const unsigned int &row, const unsigned int &column) const {
     return ($self)->operator()(row, column);
@@ -731,6 +739,17 @@ struct MatrixUtil {
     return (Matrix<T, Array2D_Dense<T> >)(($self)->operator-(scalar));
   }
   
+#ifdef SWIGRUBY
+  %alias entrywise_product "hadamard_product";
+#endif
+  %catches(std::invalid_argument) entrywise_product;
+  template <class T2, class Array2D_Type2, class ViewType2>
+  Matrix<T, Array2D_Dense<T> > entrywise_product(
+      const Matrix_Frozen<T2, Array2D_Type2, ViewType2> &matrix) const {
+    return (Matrix<T, Array2D_Dense<T> >)(($self)->entrywise_product(matrix));
+  }
+  INSTANTIATE_MATRIX_FUNC(entrywise_product, entrywise_product);
+  
   template <class T2, class Array2D_Type2, class ViewType2>
   Matrix<T, Array2D_Dense<T> > operator*(
       const Matrix_Frozen<T2, Array2D_Type2, ViewType2> &matrix)
@@ -738,6 +757,18 @@ struct MatrixUtil {
     return (Matrix<T, Array2D_Dense<T> >)(($self)->operator*(matrix));
   }
   INSTANTIATE_MATRIX_FUNC(operator*, __mul__);
+  
+  // TODO __pow__ for **
+  // TODO __pos__ for +@
+
+  Matrix<T, Array2D_Dense<T> > first_minor(
+      const unsigned int &row,
+      const unsigned int &column) const noexcept {
+    return (Matrix<T, Array2D_Dense<T> >)(($self)->matrix_for_minor(row, column));
+  }
+  Matrix<T, Array2D_Dense<T> > adjugate() const {
+    return (Matrix<T, Array2D_Dense<T> >)(($self)->adjugate());
+  }
 
   %typemap(in,numinputs=0)
       Matrix<T, Array2D_Dense<T> > &output_L (Matrix<T, Array2D_Dense<T> > temp),
@@ -816,16 +847,33 @@ struct MatrixUtil {
     s << $self->inspect();
     return s.str();
   }
+  
+  /* The followings are better to be implemented in Ruby
+   * combine, hstack, vstack (due to their arguments are variable)
+   */
 
 #ifdef SWIGRUBY
   %rename("square?") isSquare;
   %rename("diagonal?") isDiagonal;
+  %rename("lower_triangular?") isLowerTriangular;
+  %rename("upper_triangular?") isUpperTriangular;
   %rename("symmetric?") isSymmetric;
+  %rename("hermitian?") isHermitian;
+  %rename("skew_symmetric?") isSkewSymmetric;
+  %alias isSkewSymmetric "antisymmetric?"
+  %rename("normal?") isNormal;
+  %rename("orthogonal?") isOrthogonal;
+  %rename("unitary?") isUnitary;
   %rename("different_size?") isDifferentSize;
+  %alias __getitem__ "element,component";
+  // %alias __eq__ "eql?"; // Intentionally commented out because eql? is more strict than ==
+  %alias rows "row_size,row_count";
+  %alias columns "column_size,column_count";
   %alias trace "tr";
   %alias determinant "det";
   %alias inverse "inv";
   %alias transpose "t";
+  %alias conjugate "conj";
   %alias lup "lup_decomposition";
   %alias ud "ud_decomposition";
   %alias qr "qr_decomposition";
@@ -833,7 +881,7 @@ struct MatrixUtil {
   %fragment(SWIG_From_frag(Matrix_Frozen_Helper<T>), "header", 
       fragment=SWIG_Traits_frag(T)){
     template <bool with_index = false, bool assign = false>
-    static inline void matrix_yield_internal(
+    static inline VALUE matrix_yield_internal(
         const T &src, T *dst, const unsigned int &i, const unsigned int &j){
       SWIG_Object v;
       if(with_index){
@@ -848,6 +896,7 @@ struct MatrixUtil {
         s << "Unknown input (T expected) [" << i << "," << j << "]: ";
         throw std::invalid_argument(s.str().append(inspect_str(v)));
       }
+      return v;
     }
     static void matrix_yield(
         const T &src, T *dst, const unsigned int &i, const unsigned int &j){
@@ -865,11 +914,17 @@ struct MatrixUtil {
         const T &src, T *dst, const unsigned int &i, const unsigned int &j){
       matrix_yield_internal<true, true>(src, dst, i, j);
     }
+    
+    static void matrix_yield_check(
+        const T &src, T *dst, const unsigned int &i, const unsigned int &j){
+      VALUE res(matrix_yield_internal<false, false>(src, dst, i, j));
+      if(RTEST(res)){throw typename MatrixUtil::each_break_t(i, j);}
+    }
     static void (*matrix_each(const T *))
         (const T &, T *, const unsigned int &, const unsigned int &) {
       ID id_thisf(rb_frame_this_func()), id_callee(rb_frame_callee());
       static const ID 
-          id_map(rb_intern("map")), id_mapb(rb_intern("map!")), 
+          id_map(rb_intern("map")), id_mapb(rb_intern("map!")),
           id_eachwi(rb_intern("each_with_index"));
       if((id_thisf == id_map) || (id_thisf == id_mapb)){
         static const ID with_index[] = {
@@ -895,14 +950,14 @@ struct MatrixUtil {
     }
     $1 = matrix_each((const T *)0);
   }
-  %typemap(typecheck) const typename MatrixUtil::each_which_t &each_which {
-    $1 = RB_TYPE_P($input, T_SYMBOL);
+  %typemap(typecheck,precedence=SWIG_TYPECHECK_POINTER) const typename MatrixUtil::each_which_t each_which {
+    $1 = (MatrixUtil::sym2each_which($input) != MatrixUtil::EACH_UNKNOWN);
   }
-  %typemap(in) const typename MatrixUtil::each_which_t &each_which {
-    try{
-      $1 = &const_cast<typename MatrixUtil::each_which_t &>(MatrixUtil::sym2each_which($input));
-    }catch(std::invalid_argument &e){
-      SWIG_exception(SWIG_ValueError, e.what());
+  %typemap(in) const typename MatrixUtil::each_which_t each_which {
+    $1 = MatrixUtil::sym2each_which($input);
+    if($1 == MatrixUtil::EACH_UNKNOWN){
+      SWIG_exception(SWIG_ValueError,
+          std::string("Unknown enumerate direction: ").append(inspect_str($1)).c_str());
     }
   }
   %catches(native_exception) each;
@@ -910,7 +965,7 @@ struct MatrixUtil {
       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) const {
+      const typename MatrixUtil::each_which_t each_which = MatrixUtil::EACH_ALL) const {
     MatrixUtil::each(*$self, each_func, each_which);
     return *$self;
   }
@@ -921,13 +976,37 @@ struct MatrixUtil {
       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) const {
+      const typename MatrixUtil::each_which_t each_which = MatrixUtil::EACH_ALL) const {
     Matrix<T, Array2D_Dense<T> > res($self->operator Matrix<T, Array2D_Dense<T> >());
     MatrixUtil::each(*$self, each_func, each_which, &res);
     return res;
   }
   %alias map "collect,map_with_index,collect_with_index";
   
+  %catches(native_exception) index;
+  VALUE index(
+      const typename MatrixUtil::each_which_t each_which = MatrixUtil::EACH_ALL) const {
+    try{
+      MatrixUtil::each(*$self, matrix_yield_check, each_which);
+      return Qnil;
+    }catch(const typename MatrixUtil::each_break_t &each_break){
+      return rb_ary_new_from_args(2, UINT2NUM(each_break.r), UINT2NUM(each_break.c));
+    }
+  }
+  %typemap(check,noblock=1) VALUE idx_selector {
+    if(MatrixUtil::sym2each_which($1) == MatrixUtil::EACH_UNKNOWN){
+      SWIG_exception(SWIG_ValueError,
+          std::string("Unknown enumerate direction: ").append(inspect_str($1)).c_str());
+    }
+  }
+  VALUE index(VALUE value, VALUE idx_selector = Qnil) const {
+    return rb_block_call(
+        rb_current_receiver(), rb_frame_callee(),
+        (RTEST(idx_selector) ? 1 : 0), &idx_selector,
+        (rb_block_call_func_t)rb_equal, value);
+  }
+  %alias index "find_index";
+  
   SWIG_Object to_a() const {
     unsigned int i_max($self->rows()), j_max($self->columns());
     SWIG_Object res = rb_ary_new2(i_max);
@@ -1086,7 +1165,7 @@ MAKE_TO_S(Matrix_Frozen)
       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){
+      const typename MatrixUtil::each_which_t each_which = MatrixUtil::EACH_ALL){
     MatrixUtil::each(*$self, each_func, each_which, $self);
   }
   %rename("map!") map_bang;
@@ -1115,6 +1194,14 @@ MAKE_TO_S(Matrix_Frozen)
     return MatView_f::partial(*$self, new_rows, new_columns, row_offset, column_offset);
 #else
     return $self->partial(new_rows, new_columns, row_offset, column_offset);
+#endif
+  }
+  Matrix_Frozen<type, storage, view_to> partial(
+      const unsigned int &new_rows, const unsigned int &new_columns) const {
+#if defined(USE_MATRIX_VIEW_FILTER)
+    return MatView_f::partial(*$self, new_rows, new_columns, 0, 0);
+#else
+    return $self->partial(new_rows, new_columns, 0, 0);
 #endif
   }
   Matrix_Frozen<type, storage, view_to> row_vector(const unsigned int &row) const {
@@ -1132,6 +1219,9 @@ MAKE_TO_S(Matrix_Frozen)
 #endif
   }
 };
+/* Ruby #row, #column, #row_vectors, #column_vectors are not intentionally implemented 
+ * because a vector is treated as a (1*n) or (n*1) matrix in C++.
+ */
 %enddef
 
 %define INSTANTIATE_MATRIX_EIGEN2(type, ctype, storage, view)
@@ -1152,7 +1242,7 @@ MAKE_TO_S(Matrix_Frozen)
   void eigen(
       Matrix<ctype, Array2D_Dense<ctype > > &output_V, 
       Matrix<ctype, Array2D_Dense<ctype > > &output_D) const {
-    typedef typename Matrix_Frozen<type, storage, view >::complex_t::m_t cmat_t;
+    typedef Matrix<ctype, Array2D_Dense<ctype > > cmat_t;
     cmat_t VD($self->eigen());
     output_V = VD.partial($self->rows(), $self->rows()).copy();
     cmat_t D($self->rows(), $self->rows());
@@ -1308,6 +1398,19 @@ INSTANTIATE_MATRIX_EIGEN(double, Complex<double>);
 INSTANTIATE_MATRIX(Complex<double>, ComplexD);
 INSTANTIATE_MATRIX_EIGEN(Complex<double>, Complex<double>);
 
+%rename("tolerance=") set_tolerance;
+%rename("tolerance") get_tolerance;
+%inline %{
+double set_tolerance(const double &width){
+  MatrixValue<double>::zero = width;
+  MatrixValue<Complex<double> >::zero = width;
+  return width;
+}
+double get_tolerance(){
+  return set_tolerance(MatrixValue<double>::zero.width);
+}
+%}
+
 #undef INSTANTIATE_MATRIX_FUNC
 #undef INSTANTIATE_MATRIX_TRANSPOSE
 #undef INSTANTIATE_MATRIX_PARTIAL

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

@@ -6,6 +6,8 @@ require 'SylphideMath.so'
 require 'matrix'
 
 shared_examples 'Matrix' do
+  let!(:tolerance){SylphideMath::tolerance}
+  after{SylphideMath::tolerance = tolerance}
   let(:params){{
     :rc => [8, 8],
     :acceptable_delta => 1E-10,
@@ -92,17 +94,25 @@ shared_examples 'Matrix' do
   end
   
   describe 'property' do
-    let(:mat){{
-      :square => proc{
+    let(:mat_gen){{
+      :square => proc{|r| # example: [[1, 3, 6], [2, 5, 8], [4, 7, 9]]
         k = 0
-        mat_type::new(params[:rc][0], params[:rc][0]){|i, j| k += 1}
-      }.call,
+        res = mat_type::new(r, r)
+        (r * 2 - 1).times{|ij|
+          (([ij - r + 1, 0].max)..([ij, r - 1].min)).each{|i| res[ij - i, i] = (k += 1)}
+        }
+        res
+      }
+    }}
+    let(:mat){{
+      :square => mat_gen[:square].call(params[:rc][0]),
       :not_square => proc{
         k = 0
         mat_type::new(params[:rc][0], params[:rc][0] * 2){|i, j| k += 1}
       }.call,
       :diagonal => mat_type::new(params[:rc][0], params[:rc][0]){|i, j| i == j ? 1 : 0},
       :symmetric => mat_type::new(params[:rc][0], params[:rc][0]){|i, j| i + j},
+      :unit => mat_type::I(params[:rc][0]),
     }}
     describe 'is checked with' do
       it 'square?' do
@@ -117,12 +127,52 @@ shared_examples 'Matrix' do
         expect(mat[:diagonal].diagonal?)    .to eq(true)
         expect(mat[:symmetric].diagonal?)   .to eq(false)
       end
+      it 'lower_triangular?' do
+        expect(mat[:square].lower_triangular?)      .to eq(false)
+        expect(mat[:not_square].lower_triangular?)  .to eq(false)
+        expect(mat[:diagonal].lower_triangular?)    .to eq(true)
+        expect(mat[:symmetric].lower_triangular?)   .to eq(false)
+      end
+      it 'upper_triangular?' do
+        expect(mat[:square].upper_triangular?)      .to eq(false)
+        expect(mat[:not_square].upper_triangular?)  .to eq(false)
+        expect(mat[:diagonal].upper_triangular?)    .to eq(true)
+        expect(mat[:symmetric].upper_triangular?)   .to eq(false)
+      end
       it 'symmetric?' do
         expect(mat[:square].symmetric?)     .to eq(false)
         expect(mat[:not_square].symmetric?) .to eq(false)
         expect(mat[:diagonal].symmetric?)   .to eq(true)
         expect(mat[:symmetric].symmetric?)  .to eq(true)
       end
+      it 'hermitian?' do
+        expect(mat[:square].hermitian?)     .to eq(false)
+        expect(mat[:not_square].hermitian?) .to eq(false)
+        expect(mat[:diagonal].hermitian?)   .to eq(true)
+        expect(mat[:symmetric].hermitian?)  .to eq(true)
+      end
+      it 'skew_symmetric?' do
+        expect(mat[:square].skew_symmetric?)     .to eq(false)
+        expect(mat[:not_square].skew_symmetric?) .to eq(false)
+        expect(mat[:diagonal].skew_symmetric?)   .to eq(true)
+        expect(mat[:symmetric].skew_symmetric?)  .to eq(false)
+      end
+      it 'normal?' do
+        expect(mat[:square].normal?)     .to eq(false)
+        expect(mat[:not_square].normal?) .to eq(false)
+        expect(mat[:diagonal].normal?)   .to eq(true)
+        expect(mat[:symmetric].normal?)  .to eq(true)
+      end
+      it 'orthogonal?' do
+        expect(mat[:square].orthogonal?)    .to eq(false)
+        expect(mat[:not_square].orthogonal?).to eq(false)
+        expect(mat[:unit].orthogonal?)      .to eq(true)
+      end
+      it 'unitary?' do
+        expect(mat[:square].unitary?)     .to eq(false)
+        expect(mat[:not_square].unitary?) .to eq(false)
+        expect(mat[:unit].unitary?)       .to eq(true)
+      end
       it 'different_size?' do
         mat.keys.combination(2).each{|mat1, mat2|
           expect(mat[mat1].different_size?(mat[mat2])).to eq([mat1, mat2].include?(:not_square))
@@ -142,10 +192,40 @@ shared_examples 'Matrix' do
       end
       it 'determinant, det' do
         [:determinant, :det].each{|f|
-          #expect(mat[:square].send(f)).to eq(Matrix[*mat[:square].to_a].det)
+          expect(mat[:square].send(f)).to eq(Matrix[*mat[:square].to_a].det)
           expect{mat[:not_square].send(f)}.to raise_error(RuntimeError)
         }
       end
+      it 'rank' do
+        (5..8).each{|n|
+          orig = mat_gen[:square].call(n)
+          expect(orig.rank).to eq(Matrix[*orig.to_a].rank)
+        }
+        expect(mat[:symmetric].rank).to eq(Matrix[*mat[:symmetric].to_a].rank)
+        expect{mat[:not_square].rank}.to raise_error(RuntimeError)
+      end
+      it 'cofactor' do
+        SylphideMath::tolerance = 1E-10
+        (5..8).each{|n|
+          orig = mat_gen[:square].call(n)
+          cmp = Matrix[*orig.to_a]
+          orig.rows.times{|i|
+            orig.columns.times{|j|
+              a, b = [orig, cmp].collect{|item| item.cofactor(i, j)} #rescue next
+              expect((a - b).abs).to be < params[:acceptable_delta]
+            }
+          }
+        }
+      end
+      it 'adjugate' do
+        SylphideMath::tolerance = 1E-10
+        (5..8).each{|n|
+          orig = mat_gen[:square].call(n)
+          (Matrix[*orig.adjugate.to_a] - Matrix[*orig.to_a].adjugate).each{|v| 
+            expect(v.abs).to be < params[:acceptable_delta]
+          }
+        }
+      end
     end
   end
   
@@ -257,6 +337,8 @@ shared_examples 'Matrix' do
       expect(mat.adjoint.to_a).to eq(Matrix[*compare_with].conj.t.to_a)
     end
     it 'supports submatrix with partial' do
+      expect(mat.partial(params[:rc][0] - 1, params[:rc][1] - 1).to_a) \
+          .to eq(Matrix[*compare_with[0..-2].collect{|values| values[0..-2]}].to_a)
       expect(mat.partial(params[:rc][0] - 1, params[:rc][1] - 1, 1, 1).to_a) \
           .to eq(Matrix[*compare_with[1..-1].collect{|values| values[1..-1]}].to_a)
     end
@@ -280,6 +362,14 @@ shared_examples 'Matrix' do
         }
       }
     end
+    it 'generates minor matrix with first_minor' do
+      params[:rc][0].times{|i|
+        params[:rc][1].times{|j|
+          expect(mat.first_minor(i, j).to_a) \
+              .to eq(Matrix[*compare_with].first_minor(i, j).to_a)
+        }
+      }
+    end
   end
   
   describe 'iterator' do
@@ -310,6 +400,19 @@ shared_examples 'Matrix' do
         }
       }
     end
+    it 'supports index, find_index' do
+      cnd = proc{|v| v.abs >= 0.5}
+      [:index, :find_index].each{|func|
+        opt.each{|k, indices|
+          expect(mat.send(*[func, k].compact, &cnd)).to eq(
+              indices.select{|i, j| cnd.call(compare_with[i][j])}.first)
+          indices.each{|i, j|
+            expect(mat.send(*[func, compare_with[i][j], k].compact)).to eq([i, j])
+          }
+          expect(mat.send(*[func, 1, k].compact)).to be(nil)
+        }
+      }
+    end
     it 'supports map, collect, map_with_index, collect_with_index' do
       [:map, :collect, :map_with_index, :collect_with_index].each{|func|
         opt.each{|k, indices|
@@ -398,6 +501,13 @@ shared_examples 'Matrix' do
       expect{mat[2] * mat[3]}.to raise_error(ArgumentError)
       expect((mat[2] * mat[3].t).to_a).to eq((Matrix[*compare_with[2]] * Matrix[*compare_with[3]].t).to_a)
     end
+    it 'have entrywise_product(mat), a.k.a. .*(mat)' do
+      [:entrywise_product, :hadamard_product].each{|func|
+        [[0, 1], [2, 3]].each{|i, j|
+          expect((mat[i].send(func, mat[j])).to_a).to eq((Matrix[*compare_with[i]].send(func, Matrix[*compare_with[j]])).to_a)
+        }
+      } if Gem::Version::create(RUBY_VERSION) >= Gem::Version::create("2.5.0")
+    end
     it 'have /(scalar)' do
       expect((mat[0] / 2).to_a).to eq((Matrix[*compare_with[0]] / 2).to_a)
       expect((mat[2] / 2).to_a).to eq((Matrix[*compare_with[2]] / 2).to_a)

data/gps_pvt.gemspec

@@ -17,7 +17,7 @@ Gem::Specification.new do |spec|
 
   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.metadata["changelog_uri"] = "#{spec.homepage}/blob/main/CHANGELOG.md"
     
   spec.extensions = ["ext/gps_pvt/extconf.rb"]
 
@@ -63,6 +63,7 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency "rake-compiler"
   spec.add_development_dependency "rspec", "~> 3.0"
   spec.add_development_dependency "matrix" if GPS_PVT::version_compare(RUBY_VERSION, "3.1") >= 0
+  spec.add_development_dependency "github_changelog_generator"
 
   # For more information and examples about making a new gem, checkout our
   # guide at: https://bundler.io/guides/creating_gem.html

data/lib/gps_pvt/ntrip.rb

@@ -54,7 +54,7 @@ class Ntrip < Net::HTTP
       llh0 = Coordinate::LLH::new(D2R * lat_deg, D2R * lng_deg, 0)
       collect{|pt, prop|
         llh = Coordinate::LLH::new(*([:latitude, :longitude].collect{|k| D2R * prop[k].to_f} + [0]))
-        [llh0.xyz.dist(llh.xyz), prop]
+        [llh0.xyz.distance(llh.xyz), prop]
       }.sort{|a, b| a[0] <=> b[0]} # return [distance, property]
     end
   end