gps_pvt 0.10.4 → 0.10.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 60413c3add439fa66e0ff908f43f0049ad306fcefca50e2c485bc28790597143
-  data.tar.gz: 788f430151ca35a95abd4f96e4f30239e9f53768014af9ddc5897305b25b7fb9
+  metadata.gz: d4d4d0a34845282d8481d0ddcf5da043e19c89c24890140aaee66e98affea715
+  data.tar.gz: 5af5e9575ad0d7afb5de4e52df3a8f9523cb3ccb9942d43500de8317afc37049
 SHA512:
-  metadata.gz: 9c0ddc7d6a4f589cf3b3692eacde62405c78890f20cadf5abde07d189ae35bda83fd0b9e905728e4fecaf111aeee14bfb615166ef72d355fcac1a3368330ee89
-  data.tar.gz: 457d23f7e4032549961e499638403b3d01d681a8051231616ee2dde5183967c119028bd2a4475f2fe1c1e3ae2ffda61729162ced5d30b33113bfe21c161c188e
+  metadata.gz: 465e94432458b50d61c3e42102f2e138b7dadcb3c6ee1de2cae02288f73b44de8fcfec17c5b195ad4da4ef3d9387d1855ebad483f71943f23638981b6bf891a8
+  data.tar.gz: 935b4bb0ef7abce6836aa1fd046ad43ccc0e7586f7cd585b7df36ff9069c6c58c1c87fa77386f1e7112f4e019034ceaed71ab58c63eafea01154c928ac602b2e

data/Rakefile

@@ -98,7 +98,8 @@ task :swig do
     Dir::chdir(swig_dir){
       Dir::glob("*.i"){|src|
         mod_name = File::basename(src, '.*')
-        out_dir = File::join(out_base_dir, mod_name)
+        out_dir_orig = File::join(out_base_dir, mod_name)
+        out_dir = "#{out_dir_orig}.new"
         sh "mkdir -p #{out_dir}"
         wrapper = File::join(out_dir, "#{mod_name}_wrap.cxx")
         sh [:make, :clean, wrapper,
@@ -113,6 +114,15 @@ task :swig do
           io.rewind
           io.write(lines.join)
         }
+        FileUtils.instance_eval{
+          wrapper_orig = File::join(out_dir_orig, "#{mod_name}_wrap.cxx")
+          if File::exist?(wrapper_orig) and cmp(wrapper, wrapper_orig) then
+            rm_rf(out_dir)
+          else
+            rm_rf(out_dir_orig)
+            mv(out_dir, out_dir_orig)
+          end
+        }
       }
     }
   }
@@ -146,4 +156,5 @@ GitHubChangelogGenerator::RakeTask.new :changelog do |config|
   config.project = $2
 end if (begin; require 'github_changelog_generator/task'; rescue Exception; false; end)
 
+task :build => "ext/ninja-scan-light/tool"
 task :default => ["ext/ninja-scan-light/tool", :compile, :spec]

data/ext/gps_pvt/Coordinate/Coordinate_wrap.cxx

@@ -6610,6 +6610,11 @@ SWIGEXPORT void Init_Coordinate(void) {
   swig::SwigGCReferences::initialize();
   
   
+#ifdef HAVE_RB_EXT_RACTOR_SAFE
+  rb_ext_ractor_safe(true);
+#endif
+  
+  
   SwigClassBase.klass = rb_define_class_under(mCoordinate, "Base", rb_cObject);
   SWIG_TypeClientData(SWIGTYPE_p_System_3DT_double_t, (void *) &SwigClassBase);
   rb_include_module(SwigClassBase.klass, rb_eval_string("Enumerable"));

data/ext/gps_pvt/GPS/GPS_wrap.cxx

@@ -25782,6 +25782,11 @@ SWIGEXPORT void Init_GPS(void) {
   
   swig::SwigGCReferences::initialize();
   
+  
+#ifdef HAVE_RB_EXT_RACTOR_SAFE
+  rb_ext_ractor_safe(true);
+#endif
+  
   rb_require("gps_pvt/SylphideMath");
   rb_require("gps_pvt/Coordinate");
   rb_define_const(mGPS, "GPS_SC2RAD", SWIG_From_double(static_cast< double >(3.1415926535898)));

data/ext/gps_pvt/SylphideMath/SylphideMath_wrap.cxx

@@ -1892,31 +1892,12 @@ static VALUE mSylphideMath;
 #include <stdexcept>
 
 
-#include <limits.h>
-#if !defined(SWIG_NO_LLONG_MAX)
-# if !defined(LLONG_MAX) && defined(__GNUC__) && defined (__LONG_LONG_MAX__)
-#   define LLONG_MAX __LONG_LONG_MAX__
-#   define LLONG_MIN (-LLONG_MAX - 1LL)
-#   define ULLONG_MAX (LLONG_MAX * 2ULL + 1ULL)
-# endif
-#endif
-
-
-  #define SWIG_From_long   LONG2NUM 
-
-
-SWIGINTERNINLINE VALUE
-SWIG_From_int  (int value)
-{    
-  return SWIG_From_long  (value);
-}
-
-
 #include <string>
 #include <sstream>
 #include <vector>
 #include <exception>
 
+
 #if defined(SWIGRUBY) && defined(isfinite)
 #undef isfinite_
 #undef isfinite
@@ -1930,6 +1911,15 @@ SWIG_From_int  (int value)
 #define isfinite(x) finite(x)
 #endif
 
+#ifdef HAVE_RB_EXT_RACTOR_SAFE
+#include <atomic>
+template <class T>
+template <class U>
+struct Array2D_Dense<T>::property_t<T, U> {
+  typedef std::atomic<int> ref_cnt_t;
+};
+#endif
+
 
 #include <typeinfo>
 #include <stdexcept>
@@ -3075,6 +3065,19 @@ struct MatrixUtil {
 };
 
 
+#include <limits.h>
+#if !defined(SWIG_NO_LLONG_MAX)
+# if !defined(LLONG_MAX) && defined(__GNUC__) && defined (__LONG_LONG_MAX__)
+#   define LLONG_MAX __LONG_LONG_MAX__
+#   define LLONG_MIN (-LLONG_MAX - 1LL)
+#   define ULLONG_MAX (LLONG_MAX * 2ULL + 1ULL)
+# endif
+#endif
+
+
+  #define SWIG_From_long   LONG2NUM 
+
+
 SWIGINTERNINLINE VALUE
 SWIG_From_unsigned_SS_long  (unsigned long value)
 {
@@ -3353,6 +3356,19 @@ SWIGINTERN VALUE Matrix_Frozen_Sl_double_Sc_Array2D_Dense_Sl_double_Sg__Sc_MatVi
     }
     return res;
   }
+SWIGINTERN VALUE Matrix_Frozen_Sl_double_Sc_Array2D_Dense_Sl_double_Sg__Sc_MatViewBase_Sg__to_shareable(Matrix_Frozen< double,Array2D_Dense< double >,MatViewBase > const *self){
+    Matrix_Frozen<double, Array2D_Dense< double >, MatrixViewBase< > > *ptr(
+        new Matrix_Frozen<double, Array2D_Dense< double >, MatrixViewBase< > >(*self));
+    VALUE res(SWIG_NewPointerObj(
+        ptr,
+        SWIGTYPE_p_Matrix_FrozenT_double_Array2D_DenseT_double_t_MatrixViewBaseT_t_t,
+        SWIG_POINTER_OWN));
+    rb_obj_freeze(res);
+#if defined(HAVE_RB_EXT_RACTOR_SAFE)
+    RB_FL_SET(res, RUBY_FL_SHAREABLE);
+#endif
+    return res;
+  }
 SWIGINTERN std::string Matrix_Frozen_Sl_double_Sc_Array2D_Dense_Sl_double_Sg__Sc_MatViewBase_Sg____str__(Matrix_Frozen< double,Array2D_Dense< double >,MatViewBase > const *self){
     std::stringstream s;
     s << (*self);
@@ -3554,6 +3570,19 @@ SWIGINTERN VALUE Matrix_Frozen_Sl_double_Sc_Array2D_Dense_Sl_double_Sg__Sc_MatVi
     }
     return res;
   }
+SWIGINTERN VALUE Matrix_Frozen_Sl_double_Sc_Array2D_Dense_Sl_double_Sg__Sc_MatView_f_Sg__to_shareable(Matrix_Frozen< double,Array2D_Dense< double >,MatView_f > const *self){
+    Matrix_Frozen<double, Array2D_Dense< double >, MatrixViewFilter< MatrixViewBase< > > > *ptr(
+        new Matrix_Frozen<double, Array2D_Dense< double >, MatrixViewFilter< MatrixViewBase< > > >(*self));
+    VALUE res(SWIG_NewPointerObj(
+        ptr,
+        SWIGTYPE_p_Matrix_FrozenT_double_Array2D_DenseT_double_t_MatrixViewFilterT_MatrixViewBaseT_t_t_t,
+        SWIG_POINTER_OWN));
+    rb_obj_freeze(res);
+#if defined(HAVE_RB_EXT_RACTOR_SAFE)
+    RB_FL_SET(res, RUBY_FL_SHAREABLE);
+#endif
+    return res;
+  }
 SWIGINTERN std::string Matrix_Frozen_Sl_double_Sc_Array2D_Dense_Sl_double_Sg__Sc_MatView_f_Sg____str__(Matrix_Frozen< double,Array2D_Dense< double >,MatView_f > const *self){
     std::stringstream s;
     s << (*self);
@@ -3900,6 +3929,19 @@ SWIGINTERN VALUE Matrix_Frozen_Sl_Complex_Sl_double_Sg__Sc_Array2D_Dense_Sl_Comp
     }
     return res;
   }
+SWIGINTERN VALUE Matrix_Frozen_Sl_Complex_Sl_double_Sg__Sc_Array2D_Dense_Sl_Complex_Sl_double_Sg__Sg__Sc_MatViewBase_Sg__to_shareable(Matrix_Frozen< Complex< double >,Array2D_Dense< Complex< double > >,MatViewBase > const *self){
+    Matrix_Frozen<Complex< double >, Array2D_Dense< Complex< double > >, MatrixViewBase< > > *ptr(
+        new Matrix_Frozen<Complex< double >, Array2D_Dense< Complex< double > >, MatrixViewBase< > >(*self));
+    VALUE res(SWIG_NewPointerObj(
+        ptr,
+        SWIGTYPE_p_Matrix_FrozenT_ComplexT_double_t_Array2D_DenseT_ComplexT_double_t_t_MatrixViewBaseT_t_t,
+        SWIG_POINTER_OWN));
+    rb_obj_freeze(res);
+#if defined(HAVE_RB_EXT_RACTOR_SAFE)
+    RB_FL_SET(res, RUBY_FL_SHAREABLE);
+#endif
+    return res;
+  }
 SWIGINTERN std::string Matrix_Frozen_Sl_Complex_Sl_double_Sg__Sc_Array2D_Dense_Sl_Complex_Sl_double_Sg__Sg__Sc_MatViewBase_Sg____str__(Matrix_Frozen< Complex< double >,Array2D_Dense< Complex< double > >,MatViewBase > const *self){
     std::stringstream s;
     s << (*self);
@@ -4101,6 +4143,19 @@ SWIGINTERN VALUE Matrix_Frozen_Sl_Complex_Sl_double_Sg__Sc_Array2D_Dense_Sl_Comp
     }
     return res;
   }
+SWIGINTERN VALUE Matrix_Frozen_Sl_Complex_Sl_double_Sg__Sc_Array2D_Dense_Sl_Complex_Sl_double_Sg__Sg__Sc_MatView_f_Sg__to_shareable(Matrix_Frozen< Complex< double >,Array2D_Dense< Complex< double > >,MatView_f > const *self){
+    Matrix_Frozen<Complex< double >, Array2D_Dense< Complex< double > >, MatrixViewFilter< MatrixViewBase< > > > *ptr(
+        new Matrix_Frozen<Complex< double >, Array2D_Dense< Complex< double > >, MatrixViewFilter< MatrixViewBase< > > >(*self));
+    VALUE res(SWIG_NewPointerObj(
+        ptr,
+        SWIGTYPE_p_Matrix_FrozenT_ComplexT_double_t_Array2D_DenseT_ComplexT_double_t_t_MatrixViewFilterT_MatrixViewBaseT_t_t_t,
+        SWIG_POINTER_OWN));
+    rb_obj_freeze(res);
+#if defined(HAVE_RB_EXT_RACTOR_SAFE)
+    RB_FL_SET(res, RUBY_FL_SHAREABLE);
+#endif
+    return res;
+  }
 SWIGINTERN std::string Matrix_Frozen_Sl_Complex_Sl_double_Sg__Sc_Array2D_Dense_Sl_Complex_Sl_double_Sg__Sg__Sc_MatView_f_Sg____str__(Matrix_Frozen< Complex< double >,Array2D_Dense< Complex< double > >,MatView_f > const *self){
     std::stringstream s;
     s << (*self);
@@ -8971,6 +9026,39 @@ fail:
 }
 
 
+/*
+  Document-method: GPS_PVT::SylphideMath::Matrix_FrozenD.to_shareable
+
+  call-seq:
+    to_shareable -> VALUE
+
+An instance method.
+
+*/
+SWIGINTERN VALUE
+_wrap_Matrix_FrozenD_to_shareable(int argc, VALUE *argv, VALUE self) {
+  Matrix_Frozen< double,Array2D_Dense< double >,MatViewBase > *arg1 = (Matrix_Frozen< double,Array2D_Dense< double >,MatViewBase > *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  VALUE result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Matrix_FrozenT_double_Array2D_DenseT_double_t_MatrixViewBaseT_t_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Matrix_Frozen< double,Array2D_Dense< double >,MatViewBase > const *","to_shareable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< Matrix_Frozen< double,Array2D_Dense< double >,MatViewBase > * >(argp1);
+  result = (VALUE)Matrix_Frozen_Sl_double_Sc_Array2D_Dense_Sl_double_Sg__Sc_MatViewBase_Sg__to_shareable((Matrix_Frozen< double,Array2D_Dense< double >,MatrixViewBase< > > const *)arg1);
+  vresult = result;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
 /*
   Document-method: GPS_PVT::SylphideMath::Matrix_FrozenD.to_s
 
@@ -12416,6 +12504,39 @@ fail:
 }
 
 
+/*
+  Document-method: GPS_PVT::SylphideMath::Matrix_FrozenD_f.to_shareable
+
+  call-seq:
+    to_shareable -> VALUE
+
+An instance method.
+
+*/
+SWIGINTERN VALUE
+_wrap_Matrix_FrozenD_f_to_shareable(int argc, VALUE *argv, VALUE self) {
+  Matrix_Frozen< double,Array2D_Dense< double >,MatView_f > *arg1 = (Matrix_Frozen< double,Array2D_Dense< double >,MatView_f > *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  VALUE result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Matrix_FrozenT_double_Array2D_DenseT_double_t_MatrixViewFilterT_MatrixViewBaseT_t_t_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Matrix_Frozen< double,Array2D_Dense< double >,MatView_f > const *","to_shareable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< Matrix_Frozen< double,Array2D_Dense< double >,MatView_f > * >(argp1);
+  result = (VALUE)Matrix_Frozen_Sl_double_Sc_Array2D_Dense_Sl_double_Sg__Sc_MatView_f_Sg__to_shareable((Matrix_Frozen< double,Array2D_Dense< double >,MatrixViewFilter< MatrixViewBase< > > > const *)arg1);
+  vresult = result;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
 /*
   Document-method: GPS_PVT::SylphideMath::Matrix_FrozenD_f.to_s
 
@@ -16924,6 +17045,39 @@ fail:
 }
 
 
+/*
+  Document-method: GPS_PVT::SylphideMath::Matrix_FrozenComplexD.to_shareable
+
+  call-seq:
+    to_shareable -> VALUE
+
+An instance method.
+
+*/
+SWIGINTERN VALUE
+_wrap_Matrix_FrozenComplexD_to_shareable(int argc, VALUE *argv, VALUE self) {
+  Matrix_Frozen< Complex< double >,Array2D_Dense< Complex< double > >,MatViewBase > *arg1 = (Matrix_Frozen< Complex< double >,Array2D_Dense< Complex< double > >,MatViewBase > *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  VALUE result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Matrix_FrozenT_ComplexT_double_t_Array2D_DenseT_ComplexT_double_t_t_MatrixViewBaseT_t_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Matrix_Frozen< Complex< double >,Array2D_Dense< Complex< double > >,MatViewBase > const *","to_shareable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< Matrix_Frozen< Complex< double >,Array2D_Dense< Complex< double > >,MatViewBase > * >(argp1);
+  result = (VALUE)Matrix_Frozen_Sl_Complex_Sl_double_Sg__Sc_Array2D_Dense_Sl_Complex_Sl_double_Sg__Sg__Sc_MatViewBase_Sg__to_shareable((Matrix_Frozen< Complex< double >,Array2D_Dense< Complex< double > >,MatrixViewBase< > > const *)arg1);
+  vresult = result;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
 /*
   Document-method: GPS_PVT::SylphideMath::Matrix_FrozenComplexD.to_s
 
@@ -20367,6 +20521,39 @@ fail:
 }
 
 
+/*
+  Document-method: GPS_PVT::SylphideMath::Matrix_FrozenComplexD_f.to_shareable
+
+  call-seq:
+    to_shareable -> VALUE
+
+An instance method.
+
+*/
+SWIGINTERN VALUE
+_wrap_Matrix_FrozenComplexD_f_to_shareable(int argc, VALUE *argv, VALUE self) {
+  Matrix_Frozen< Complex< double >,Array2D_Dense< Complex< double > >,MatView_f > *arg1 = (Matrix_Frozen< Complex< double >,Array2D_Dense< Complex< double > >,MatView_f > *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  VALUE result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Matrix_FrozenT_ComplexT_double_t_Array2D_DenseT_ComplexT_double_t_t_MatrixViewFilterT_MatrixViewBaseT_t_t_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Matrix_Frozen< Complex< double >,Array2D_Dense< Complex< double > >,MatView_f > const *","to_shareable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< Matrix_Frozen< Complex< double >,Array2D_Dense< Complex< double > >,MatView_f > * >(argp1);
+  result = (VALUE)Matrix_Frozen_Sl_Complex_Sl_double_Sg__Sc_Array2D_Dense_Sl_Complex_Sl_double_Sg__Sg__Sc_MatView_f_Sg__to_shareable((Matrix_Frozen< Complex< double >,Array2D_Dense< Complex< double > >,MatrixViewFilter< MatrixViewBase< > > > const *)arg1);
+  vresult = result;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
 /*
   Document-method: GPS_PVT::SylphideMath::Matrix_FrozenComplexD_f.to_s
 
@@ -22321,7 +22508,6 @@ SWIGEXPORT void Init_SylphideMath(void) {
   }
   
   SWIG_RubyInitializeTrackings();
-  rb_define_const(mSylphideMath, "ENABLE_IOSTREAM", SWIG_From_int(static_cast< int >(1)));
   
   SwigClassGC_VALUE.klass = rb_define_class_under(mSylphideMath, "GC_VALUE", rb_cObject);
   SWIG_TypeClientData(SWIGTYPE_p_swig__GC_VALUE, (void *) &SwigClassGC_VALUE);
@@ -22334,6 +22520,11 @@ SWIGEXPORT void Init_SylphideMath(void) {
   swig::SwigGCReferences::initialize();
   
   
+#ifdef HAVE_RB_EXT_RACTOR_SAFE
+  rb_ext_ractor_safe(true);
+#endif
+  
+  
   SwigClassComplexD.klass = rb_define_class_under(mSylphideMath, "ComplexD", rb_cObject);
   SWIG_TypeClientData(SWIGTYPE_p_ComplexT_double_t, (void *) &SwigClassComplexD);
   rb_define_alloc_func(SwigClassComplexD.klass, _wrap_ComplexD_allocate);
@@ -22442,6 +22633,7 @@ SWIGEXPORT void Init_SylphideMath(void) {
   rb_define_method(SwigClassMatrix_FrozenD.klass, "index", VALUEFUNC(_wrap_Matrix_FrozenD_index), -1);
   rb_define_alias(SwigClassMatrix_FrozenD.klass, "find_index", "index");
   rb_define_method(SwigClassMatrix_FrozenD.klass, "to_a", VALUEFUNC(_wrap_Matrix_FrozenD_to_a), -1);
+  rb_define_method(SwigClassMatrix_FrozenD.klass, "to_shareable", VALUEFUNC(_wrap_Matrix_FrozenD_to_shareable), -1);
   rb_define_method(SwigClassMatrix_FrozenD.klass, "to_s", VALUEFUNC(_wrap_Matrix_FrozenD___str__), -1);
   rb_define_method(SwigClassMatrix_FrozenD.klass, "conjugate", VALUEFUNC(_wrap_Matrix_FrozenD_conjugate), -1);
   rb_define_alias(SwigClassMatrix_FrozenD.klass, "conj", "conjugate");
@@ -22518,6 +22710,7 @@ SWIGEXPORT void Init_SylphideMath(void) {
   rb_define_method(SwigClassMatrix_FrozenD_f.klass, "index", VALUEFUNC(_wrap_Matrix_FrozenD_f_index), -1);
   rb_define_alias(SwigClassMatrix_FrozenD_f.klass, "find_index", "index");
   rb_define_method(SwigClassMatrix_FrozenD_f.klass, "to_a", VALUEFUNC(_wrap_Matrix_FrozenD_f_to_a), -1);
+  rb_define_method(SwigClassMatrix_FrozenD_f.klass, "to_shareable", VALUEFUNC(_wrap_Matrix_FrozenD_f_to_shareable), -1);
   rb_define_method(SwigClassMatrix_FrozenD_f.klass, "to_s", VALUEFUNC(_wrap_Matrix_FrozenD_f___str__), -1);
   rb_define_method(SwigClassMatrix_FrozenD_f.klass, "conjugate", VALUEFUNC(_wrap_Matrix_FrozenD_f_conjugate), -1);
   rb_define_alias(SwigClassMatrix_FrozenD_f.klass, "conj", "conjugate");
@@ -22622,6 +22815,7 @@ SWIGEXPORT void Init_SylphideMath(void) {
   rb_define_method(SwigClassMatrix_FrozenComplexD.klass, "index", VALUEFUNC(_wrap_Matrix_FrozenComplexD_index), -1);
   rb_define_alias(SwigClassMatrix_FrozenComplexD.klass, "find_index", "index");
   rb_define_method(SwigClassMatrix_FrozenComplexD.klass, "to_a", VALUEFUNC(_wrap_Matrix_FrozenComplexD_to_a), -1);
+  rb_define_method(SwigClassMatrix_FrozenComplexD.klass, "to_shareable", VALUEFUNC(_wrap_Matrix_FrozenComplexD_to_shareable), -1);
   rb_define_method(SwigClassMatrix_FrozenComplexD.klass, "to_s", VALUEFUNC(_wrap_Matrix_FrozenComplexD___str__), -1);
   rb_define_method(SwigClassMatrix_FrozenComplexD.klass, "conjugate", VALUEFUNC(_wrap_Matrix_FrozenComplexD_conjugate), -1);
   rb_define_alias(SwigClassMatrix_FrozenComplexD.klass, "conj", "conjugate");
@@ -22698,6 +22892,7 @@ SWIGEXPORT void Init_SylphideMath(void) {
   rb_define_method(SwigClassMatrix_FrozenComplexD_f.klass, "index", VALUEFUNC(_wrap_Matrix_FrozenComplexD_f_index), -1);
   rb_define_alias(SwigClassMatrix_FrozenComplexD_f.klass, "find_index", "index");
   rb_define_method(SwigClassMatrix_FrozenComplexD_f.klass, "to_a", VALUEFUNC(_wrap_Matrix_FrozenComplexD_f_to_a), -1);
+  rb_define_method(SwigClassMatrix_FrozenComplexD_f.klass, "to_shareable", VALUEFUNC(_wrap_Matrix_FrozenComplexD_f_to_shareable), -1);
   rb_define_method(SwigClassMatrix_FrozenComplexD_f.klass, "to_s", VALUEFUNC(_wrap_Matrix_FrozenComplexD_f___str__), -1);
   rb_define_method(SwigClassMatrix_FrozenComplexD_f.klass, "conjugate", VALUEFUNC(_wrap_Matrix_FrozenComplexD_f_conjugate), -1);
   rb_define_alias(SwigClassMatrix_FrozenComplexD_f.klass, "conj", "conjugate");

data/ext/gps_pvt/extconf.rb

@@ -3,9 +3,14 @@ proc{|ninja_tool_dir|
   dir_config('ninja_tool', ninja_tool_dir, ninja_tool_dir)
 }.call(File::absolute_path(File::join(
     File::dirname(__FILE__), '..', 'ninja-scan-light', 'tool')))
-cflags = " -Wall"
-$CFLAGS += cflags
-$CPPFLAGS += cflags
+cflags = " -Wall -I../../.. -O3" # -march=native
+RE_optflags = /(?<=^|\s)-O(?:[0-3sgz]|fast)?/
+if RE_optflags =~ cflags then
+  $CFLAGS.gsub!(RE_optflags, '')
+  $CXXFLAGS.gsub!(RE_optflags, '')
+end
+$CFLAGS << cflags
+$CXXFLAGS << cflags
 $LOCAL_LIBS += " -lstdc++ "
 
 IO_TARGETS = [

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

@@ -235,8 +235,14 @@ class Array2D_Dense : public Array2D<T, Array2D_Dense<T> > {
     using super_t::columns;
 
   protected:
-    static const int offset = (sizeof(T) >= sizeof(int)) ? 1 : ((sizeof(int) + sizeof(T) - 1) / sizeof(T));
-    int *ref;  ///< reference counter TODO alignment?
+    template <class T2, class U = void>
+    struct property_t {
+      typedef int ref_cnt_t;
+    };
+    typedef typename property_t<T>::ref_cnt_t ref_cnt_t;
+
+    static const int offset = (sizeof(T) >= sizeof(ref_cnt_t)) ? 1 : ((sizeof(ref_cnt_t) + sizeof(T) - 1) / sizeof(T));
+    ref_cnt_t *ref_cnt;  ///< reference counter TODO alignment?
     T *values; ///< array for values
 
     template <class T2, bool do_memory_op = std::numeric_limits<T2>::is_specialized>
@@ -263,7 +269,7 @@ class Array2D_Dense : public Array2D<T, Array2D_Dense<T> > {
     };
 
   public:
-    Array2D_Dense() : super_t(0, 0), ref(NULL), values(NULL) {
+    Array2D_Dense() : super_t(0, 0), ref_cnt(NULL), values(NULL) {
     }
 
     /**
@@ -276,9 +282,9 @@ class Array2D_Dense : public Array2D<T, Array2D_Dense<T> > {
         const unsigned int &rows,
         const unsigned int &columns)
         : super_t(rows, columns),
-        ref(reinterpret_cast<int *>(new T[offset + (rows * columns)])),
-        values(reinterpret_cast<T *>(ref) + offset) {
-      *ref = 1;
+        ref_cnt(reinterpret_cast<ref_cnt_t *>(new T[offset + (rows * columns)])),
+        values(reinterpret_cast<T *>(ref_cnt) + offset) {
+      *ref_cnt = 1;
     }
     /**
      * Constructor with initializer
@@ -292,9 +298,9 @@ class Array2D_Dense : public Array2D<T, Array2D_Dense<T> > {
         const unsigned int &columns,
         const T *serialized)
         : super_t(rows, columns),
-        ref(reinterpret_cast<int *>(new T[offset + (rows * columns)])),
-        values(reinterpret_cast<T *>(ref) + offset) {
-      *ref = 1;
+        ref_cnt(reinterpret_cast<ref_cnt_t *>(new T[offset + (rows * columns)])),
+        values(reinterpret_cast<T *>(ref_cnt) + offset) {
+      *ref_cnt = 1;
       setup_t<T>::copy(*this, serialized);
     }
     /**
@@ -304,8 +310,8 @@ class Array2D_Dense : public Array2D<T, Array2D_Dense<T> > {
      */
     Array2D_Dense(const self_t &array)
         : super_t(array.m_rows, array.m_columns),
-          ref(array.ref), values(array.values){
-      if(ref){++(*ref);}
+          ref_cnt(array.ref_cnt), values(array.values){
+      if(ref_cnt){++(*ref_cnt);}
     }
     /**
      * Constructor based on another type array, which performs deep copy.
@@ -315,9 +321,9 @@ class Array2D_Dense : public Array2D<T, Array2D_Dense<T> > {
     template <class T2>
     Array2D_Dense(const Array2D_Frozen<T2> &array)
         : super_t(array.rows(), array.columns()),
-        ref(reinterpret_cast<int *>(new T[offset + (array.rows() * array.columns())])),
-        values(reinterpret_cast<T *>(ref) + offset) {
-      *ref = 1;
+        ref_cnt(reinterpret_cast<ref_cnt_t *>(new T[offset + (array.rows() * array.columns())])),
+        values(reinterpret_cast<T *>(ref_cnt) + offset) {
+      *ref_cnt = 1;
       T *buf(values);
       const unsigned int i_end(array.rows()), j_end(array.columns());
       for(unsigned int i(0); i < i_end; ++i){
@@ -333,8 +339,8 @@ class Array2D_Dense : public Array2D<T, Array2D_Dense<T> > {
      * allocated memory for elements will be deleted.
      */
     ~Array2D_Dense(){
-      if(ref && ((--(*ref)) <= 0)){
-        delete [] reinterpret_cast<T *>(ref);
+      if(ref_cnt && ((--(*ref_cnt)) <= 0)){
+        delete [] reinterpret_cast<T *>(ref_cnt);
       }
     }
 
@@ -346,10 +352,10 @@ class Array2D_Dense : public Array2D<T, Array2D_Dense<T> > {
      */
     self_t &operator=(const self_t &array){
       if(this != &array){
-        if(ref && ((--(*ref)) <= 0)){delete [] reinterpret_cast<T *>(ref);}
+        if(ref_cnt && ((--(*ref_cnt)) <= 0)){delete [] reinterpret_cast<T *>(ref_cnt);}
         super_t::m_rows = array.m_rows;
         super_t::m_columns = array.m_columns;
-        if((ref = array.ref)){++(*ref);}
+        if((ref_cnt = array.ref_cnt)){++(*ref_cnt);}
         values = array.values;
       }
       return *this;

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

@@ -22,6 +22,12 @@
 
 %feature("autodoc", "1");
 
+%init %{
+#ifdef HAVE_RB_EXT_RACTOR_SAFE
+  rb_ext_ractor_safe(true);
+#endif
+%}
+
 %define MAKE_SETTER(name, type)
 %rename(%str(name ## =)) set_ ## name;
 type set_ ## name (const type &v) {

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

@@ -50,6 +50,12 @@ inline std::string to_string(const T &value){
 %include exception.i
 %include std_except.i
 
+%init %{
+#ifdef HAVE_RB_EXT_RACTOR_SAFE
+  rb_ext_ractor_safe(true);
+#endif
+%}
+
 #if !defined(SWIGIMPORTED)
 %exceptionclass native_exception;
 %typemap(throws,noblock=1) native_exception {
@@ -112,6 +118,7 @@ static std::string inspect_str(const VALUE &v){
 %feature("autodoc", "1");
 
 %import "SylphideMath.i"
+%fragment("SylphideMath.i");
 %import "Coordinate.i"
 
 %typemap(in,numinputs=0) const void *check_block {

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

@@ -5,14 +5,14 @@
 
 %module SylphideMath
 
-#define ENABLE_IOSTREAM 1
-
 %{
 #include <string>
 #include <sstream>
 #include <vector>
 #include <exception>
+%}
 
+%fragment("SylphideMath.i", "header") %{
 #if defined(SWIGRUBY) && defined(isfinite)
 #undef isfinite_
 #undef isfinite
@@ -25,14 +25,31 @@
 #undef isfinite_
 #define isfinite(x) finite(x)
 #endif
+
+#ifdef HAVE_RB_EXT_RACTOR_SAFE
+#include <atomic>
+template <class T>
+template <class U>
+struct Array2D_Dense<T>::property_t<T, U> {
+  typedef std::atomic<int> ref_cnt_t;
+};
+#endif
 %}
 
+%fragment("SylphideMath.i");
+
 %include std_common.i
 %include std_string.i
 //%include std_vector.i
 %include exception.i
 %include std_except.i
 
+%init %{
+#ifdef HAVE_RB_EXT_RACTOR_SAFE
+  rb_ext_ractor_safe(true);
+#endif
+%}
+
 %ignore native_exception;
 #if !defined(SWIGIMPORTED)
 %exceptionclass native_exception;
@@ -1022,6 +1039,20 @@ struct MatrixUtil {
     }
     return res;
   }
+  
+  VALUE to_shareable() const {
+    Matrix_Frozen<T, Array2D_Type, ViewType > *ptr(
+        new Matrix_Frozen<T, Array2D_Type, ViewType >(*$self));
+    VALUE res(SWIG_NewPointerObj(
+        ptr,
+        $descriptor(Matrix_Frozen<T, Array2D_Type, ViewType > *),
+        SWIG_POINTER_OWN));
+    rb_obj_freeze(res);
+%#if defined(HAVE_RB_EXT_RACTOR_SAFE)
+    RB_FL_SET(res, RUBY_FL_SHAREABLE);
+%#endif
+    return res;
+  }
 #endif
   %typemap(in)
       Matrix<T, Array2D_Dense<T> > &output_L,

data/ext/ninja-scan-light/tool/swig/extconf.rb

@@ -1,5 +1,10 @@
 require "mkmf"
-cflags = " -Wall -I../../.."
-$CFLAGS += cflags
-$CPPFLAGS += cflags if RUBY_VERSION >= "2.0.0"
+cflags = " -Wall -I../../.. -O3" # -march=native
+RE_optflags = /(?<=^|\s)-O(?:[0-3sgz]|fast)?/
+if RE_optflags =~ cflags then
+  $CFLAGS.gsub!(RE_optflags, '')
+  $CXXFLAGS.gsub!(RE_optflags, '')
+end
+$CFLAGS << cflags
+$CXXFLAGS << cflags
 $LOCAL_LIBS += " -lstdc++ "

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

@@ -602,6 +602,37 @@ shared_examples 'Matrix' do
       }
     end
   end
+  describe 'parallelization with Ractor' do
+    it "supports instantiation in sub Ractor" do
+      expect{
+        rac = Ractor::new{
+          mat_type, r, c = receive
+          # @see https://docs.ruby-lang.org/en/master/ractor_md.html#label-Return+value+of+a+block+for+Ractor.new
+          # When the block return value is available, ...,
+          # so any values can be sent with this communication path 
+          # without any modification.
+          mat_type::new(r, c)
+        }
+        rac.send([mat_type, params[:rc]].flatten.freeze)
+        mat = rac.take
+        [:row_size, :column_size].zip(params[:rc]).each{|k, v|
+          expect(mat.send(k)).to eq(v)
+        }
+      }.not_to raise_error
+    end
+    it "supports messaging by using to_shareable between Ractors" do
+      expect{
+        rac = Ractor::new{
+          mat = receive
+        }
+        rac.send(mat_type::new(*params[:rc]).to_shareable)
+        mat = rac.take
+        [:row_size, :column_size].zip(params[:rc]).each{|k, v|
+          expect(mat.send(k)).to eq(v)
+        }
+      }.not_to raise_error
+    end
+  end if defined?(Ractor)
 end
 
 =begin

data/ext/ninja-scan-light/tool/util/bit_counter.h

@@ -74,11 +74,40 @@ struct BitCounter {
 
     /**
      * Count rightmost zeros before the first one (Number of trailing zeros)
+     * Be careful, if input equals to 0, then total number of corresponding type bits
+     * will be returned like (unsigned int)0 => 32.
      * @param bits results
      */
     static T ntz(const T &v) {
       return count((T)((~v) & (v - 1)));
     }
+
+  private:
+    template <int Shift, class U = void>
+    struct set_lower_bits_loop{
+      static inline T run(const T &bits){
+        return set_lower_bits_loop<(Shift << 1)>::run(bits | (bits >> Shift));
+      }
+    };
+
+    template <class U>
+    struct set_lower_bits_loop<num_of_bits, U>{
+      static inline T run(const T &bits){
+        return bits;
+      }
+    };
+  public:
+    static T set_lower_bits(const T &bits) {
+      return set_lower_bits_loop<1>::run(bits);
+    }
+
+    /**
+     * Count leftmost zeros before the first one (Number of leading zeros)
+     * @param bits results
+     */
+    static T nlz(const T &bits){
+      return num_of_bits - count(set_lower_bits(bits));
+    }
 };
 
 #endif /* __BIT_COUNTER__ */

data/gps_pvt.gemspec

@@ -35,10 +35,11 @@ Gem::Specification.new do |spec|
   spec.files += proc{
     require 'pathname'
     base_dir = Pathname::new(File::absolute_path(File.dirname(__FILE__)))
+    is_windows_git = `git --version` =~ /windows/i
     # 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|
+      `git -C #{is_windows_git ? dir.sub(/^\/([^\/]+)/, "\\1:") : 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, $'))

data/lib/gps_pvt/pvt.rb

@@ -10,7 +10,7 @@ class GPS::PVT_minimal
     @vsigma = 13.0 # 95%
     @pdop = 6.0 # 98% global
     @vel_sigma = 0.2 # 85%
-    @use_satellites = 0 # unknown
+    @used_satellites = 0 # unknown
   end
   def position_solved?; @xyz || @llh; end
   def velocity_solved?; @velocity; end
@@ -45,6 +45,9 @@ class GPS::PVT_minimal
         idx = header.find_index{|str| re === str}
         idx && [k, idx]
       }.compact
+      opt_keys = [:pdop, :hsigma, :vsigma, :vel_sigma, :used_satellites].select{|k|
+        idx_table.any?{|k2, idx| k == k2}
+      }
       enum = Enumerator::new{|y|
         io.each_line{|line|
           values = line.chomp.split(/ *, */)
@@ -52,7 +55,7 @@ class GPS::PVT_minimal
             v = values[idx]
             (v == '') ? nil : [k, (Integer(v) rescue Float(v))]
           }.compact.flatten(1))]
-          if items.include?(:week) then
+          if items[:week] then
             t = GPS::Time::new(items[:week], items[:tow])
           else
             # UTC assumption, thus leap seconds must be added.
@@ -60,19 +63,19 @@ class GPS::PVT_minimal
             t += GPS::Time::guess_leap_seconds(t)
           end
           pvt = GPS::PVT_minimal::new
-          if items.include?(:lat) then
+          if items[:lat] then
             pvt.llh = ([:lat, :lng].collect{|k| Math::PI / 180 * items[k]} + [items[:alt]])
-          elsif items.include?(:xyz) then
+          elsif items[:x] then
             pvt.xyz = [:x, :y, :z].collect{|k| items[k]}
           end
-          if items.include?(:vn) then
+          if items[:vn] then
             pvt.velocity = ([:vn, :ve].collect{|k| items[k]} + [items[:vu] || -items[:vd]])
-          elsif items.include?(:vx) then
+          elsif items[:vx] then
             pvt.velocity = Coordinate::ENU::relative_rel(
                 Coordinate::XYZ::new(*([:vx, :vy, :vz].collect{|k| items[k]})),
                 pvt.llh)
           end
-          [:pdop, :hsigma, :vsigma, :vel_sigma, :used_satellites].each{|k| pvt.send("#{k}=", items[k])}
+          opt_keys.each{|k| pvt.send("#{k}=", items[k]) if items[k]}
           y.yield(t, pvt)
         }
       }

data/lib/gps_pvt/supl.rb

@@ -1,8 +1,9 @@
 require_relative 'upl/upl'
-require_relative 'GPS'
+require 'gps_pvt/GPS' # in case GPS.so is generated under ext/gps_pvt
 
 require 'socket'
 require 'openssl'
+require 'resolv'
 
 module GPS_PVT
 class SUPL_Client
@@ -17,16 +18,30 @@ class SUPL_Client
       :debug => 0,
       :protocol => [:lpp, :rrlp],
       :req_data => [:ephemeris], # :almanac
+      :timeout => 60, # [sec]
     }.merge(opts)
   end
 
   def get_assisted_data
     begin
-      @socket = TCPSocket::new(@host, @opts[:port])
-      if @opts[:port] == 7275 then
+      timeout = @opts[:timeout]
+      host = timeout ? Resolv::getaddress(@host).to_s : @host  
+      @socket = TCPSocket::new(host, @opts[:port])
+      if @opts.include?(:ssl) ? @opts[:ssl] : (@opts[:port] == 7275) then
         @socket = OpenSSL::SSL::SSLSocket::new(@socket)
         @socket.connect
       end
+      @socket.define_singleton_method(:read){|bytes|
+        buf = String::new
+        while (rem = (bytes - buf.size)) > 0
+          begin
+            buf << read_nonblock(rem)
+          rescue IO::WaitReadable
+            break unless IO.select([self], nil, nil, timeout)
+          end
+        end
+        buf
+      } if timeout
       send_supl_start
       recv_supl_response
       send_supl_pos_init

data/lib/gps_pvt/util.rb

@@ -100,7 +100,10 @@ module Util
 
         Tempfile::open(File::basename($0, '.*')){|dst|
           dst.binmode
-          dst.write((compressed ? inflate(is_file ? src.path : src, compressed) : src).read)
+          dst.write((compressed ? inflate((case src
+              when File, TempFile; src.path
+              else; src
+              end), compressed) : src).read)
           dst.rewind
           dst.path
         }

data/lib/gps_pvt/version.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 module GPS_PVT
-  VERSION = "0.10.4"
+  VERSION = "0.10.5"
   
   def GPS_PVT.version_compare(a, b)
     Gem::Version::new(a) <=> Gem::Version::new(b)

metadata

@@ -1,14 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: gps_pvt
 version: !ruby/object:Gem::Version
-  version: 0.10.4
+  version: 0.10.5
 platform: ruby
 authors:
 - fenrir(M.Naruoka)
-autorequire: 
 bindir: exe
 cert_chain: []
-date: 2024-12-15 00:00:00.000000000 Z
+date: 1980-01-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rubyserial
@@ -66,6 +65,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: matrix
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: racc
   requirement: !ruby/object:Gem::Requirement
@@ -202,7 +215,6 @@ licenses: []
 metadata:
   homepage_uri: https://github.com/fenrir-naru/gps_pvt
   source_code_uri: https://github.com/fenrir-naru/gps_pvt
-post_install_message: 
 rdoc_options:
 - "--exclude=ext/ninja-scan-light"
 require_paths:
@@ -218,8 +230,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.3.5
-signing_key: 
+rubygems_version: 4.0.10
 specification_version: 4
 summary: GPS position, velocity, and time (PVT) solver
 test_files: []