boost_distributions 0.1.0

data/ext/boost_distributions/extconf.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+require "mkmf"
+cflags = " -Wall"
+$CFLAGS += cflags
+$CPPFLAGS += cflags if RUBY_VERSION >= "2.0.0"
+$LOCAL_LIBS += " -lstdc++ "
+
+IO_TARGETS = [
+  [Kernel, :instance_eval],
+  [(class << File; self; end), :class_eval], # https://github.com/ruby/ruby/commit/19beb028
+]
+def IO_TARGETS.mod(&b)
+  self.each{|class_, func| class_.send(func, &b)}
+end
+
+IO_TARGETS.mod{
+  alias_method(:open_orig, :open)
+}
+
+Dir::glob(File::join(File::dirname(__FILE__), "*/")).each{|dir|
+  mod_name = File::basename(dir)
+  
+  dst = File::join(Dir.getwd, mod_name)
+  FileUtils::mkdir_p(dst) if dir != dst
+  
+  $stderr.puts "For #{mod_name} ..."
+
+  # @see https://stackoverflow.com/a/35842162/15992898
+  $srcs = Dir::glob(File::join(dir, '*.cxx')).collect{|path|
+    File::join(mod_name, File::basename(path))
+  }
+  $objs = $srcs.collect{|path|
+    path.sub(/\.[^\.]+$/, '.o')
+  }
+
+  IO_TARGETS.mod{
+    # rename Makefile to Makefile.#{mod_name}
+    define_method(:open){|*args, &b|
+      args[0] += ".#{mod_name}" if (args[0] && (args[0] == "Makefile"))
+      open_orig(*args, &b)
+    }
+  }
+  create_makefile("boost_distributions/#{mod_name}")
+}
+
+IO_TARGETS.mod{
+  alias_method(:open, :open_orig)
+}
+
+# manual generation of top-level Makefile
+# @see https://yorickpeterse.com/articles/hacking-extconf-rb/
+open("Makefile", 'w'){|io|
+  # @see https://stackoverflow.com/a/17845120/15992898
+  io.write(<<-__TOPLEVEL_MAKEFILE__)
+TOPTARGETS := all clean distclean realclean install site-install
+
+SUBMFS := $(wildcard Makefile.*)
+
+$(TOPTARGETS): $(SUBMFS)
+$(SUBMFS):
+#{"\t"}$(MAKE) -f $@ $(MAKECMDGOALS)
+
+.PHONY: $(TOPTARGETS) $(SUBMFS)
+  __TOPLEVEL_MAKEFILE__
+}
+
+require 'fileutils'
+FileUtils::touch("boost_distributions.so") # dummy

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

@@ -0,0 +1,420 @@
+/**
+ * @file SWIG interface file for boost::math::distributions
+ *
+ */
+
+%module BoostDistributions
+
+%include std_common.i
+%include std_except.i
+
+%{
+#include <sstream>
+#include <stdexcept>
+
+#include <boost/version.hpp>
+#define BOOST_VERSION_LESS_THAN(ver) (BOOST_VERSION < ver)
+
+#include <boost/math/distributions.hpp>
+namespace boost { namespace math {
+template <int RequiredVersion, bool check_passed = !BOOST_VERSION_LESS_THAN(RequiredVersion)>
+struct distribution_shim_t {
+#define GEN_FUNC(func_name) \
+template <class DistT, class ValueT> \
+inline static typename DistT::value_type func_name(const DistT &dist, const ValueT &x){ \
+  return boost::math::func_name(dist, x); \
+}
+  GEN_FUNC(pdf);
+  GEN_FUNC(hazard);
+  GEN_FUNC(chf);
+#undef GEN_FUNC
+#define GEN_FUNC(func_name) \
+template <class DistT, class ValueT> \
+inline static typename DistT::value_type func_name( \
+    const DistT &dist, const ValueT &x, const bool &is_complement = false){ \
+  return is_complement \
+      ? boost::math::func_name(complement(dist, x)) \
+      : boost::math::func_name(dist, x); \
+}
+  GEN_FUNC(cdf);
+  GEN_FUNC(quantile);
+#undef GEN_FUNC
+#define GEN_FUNC(func_name) \
+template <class DistT> \
+inline static typename DistT::value_type func_name(const DistT &dist){ \
+  return boost::math::func_name(dist); \
+}
+  GEN_FUNC(mean);
+  GEN_FUNC(median);
+  GEN_FUNC(mode);
+  GEN_FUNC(standard_deviation);
+  GEN_FUNC(variance);
+  GEN_FUNC(skewness);
+  GEN_FUNC(kurtosis);
+  GEN_FUNC(kurtosis_excess);
+#undef GEN_FUNC
+#define GEN_FUNC(func_name) \
+template <class DistT> \
+inline static std::pair<typename DistT::value_type, typename DistT::value_type> \
+    func_name(const DistT &dist){ \
+  return boost::math::func_name(dist); \
+}
+  GEN_FUNC(range);
+  GEN_FUNC(support);
+#undef GEN_FUNC
+};
+template <int RequiredVersion>
+struct distribution_shim_t<RequiredVersion, false> { // dummy
+  static const std::string err_msg(){
+    std::stringstream ss;
+    ss << "BOOST_VERSION(" << BOOST_VERSION 
+        << ") should be >= " << RequiredVersion;
+    return ss.str();
+  }
+#define GEN_FUNC(func_name) \
+template <class DistT, class ValueT> \
+inline static typename DistT::value_type func_name(const DistT &dist, const ValueT &x){ \
+  throw std::logic_error(err_msg()); \
+}
+  GEN_FUNC(pdf);
+  GEN_FUNC(hazard);
+  GEN_FUNC(chf);
+#undef GEN_FUNC
+#define GEN_FUNC(func_name) \
+template <class DistT, class ValueT> \
+inline static typename DistT::value_type func_name( \
+    const DistT &dist, const ValueT &x, const bool &is_complement = false){ \
+  throw std::logic_error(err_msg()); \
+}
+  GEN_FUNC(cdf);
+  GEN_FUNC(quantile);
+#undef GEN_FUNC
+#define GEN_FUNC(func_name) \
+template <class DistT> \
+inline static typename DistT::value_type func_name(const DistT &dist){ \
+  throw std::logic_error(err_msg()); \
+}
+  GEN_FUNC(mean);
+  GEN_FUNC(median);
+  GEN_FUNC(mode);
+  GEN_FUNC(standard_deviation);
+  GEN_FUNC(variance);
+  GEN_FUNC(skewness);
+  GEN_FUNC(kurtosis);
+  GEN_FUNC(kurtosis_excess);
+#undef GEN_FUNC
+#define GEN_FUNC(func_name) \
+template <class DistT> \
+inline static std::pair<typename DistT::value_type, typename DistT::value_type> \
+    func_name(const DistT &dist){ \
+  throw std::logic_error(err_msg()); \
+}
+  GEN_FUNC(range);
+  GEN_FUNC(support);
+#undef GEN_FUNC
+};
+template <class RealType, int RequiredVersion>
+struct distribution_dummy_t {
+  typedef RealType value_type;
+  static const std::string err_msg(){
+    return distribution_shim_t<RequiredVersion, false>::err_msg();
+  }
+  distribution_dummy_t(){throw std::logic_error(err_msg());}
+  
+  // static/member functions
+#define GEN_FUNC_m(ret_type, fun_name) \
+ret_type fun_name(...) const {throw std::logic_error(err_msg());}
+#define GEN_FUNC_s(ret_type, fun_name) \
+static ret_type fun_name(...){throw std::logic_error(err_msg());}
+
+  GEN_FUNC_m(RealType, x_max); // arcsine
+  GEN_FUNC_m(RealType, x_min); // arcsine
+  GEN_FUNC_m(RealType, success_fraction);
+      // bernoulli, binomial, geometric, negative_binomial
+  GEN_FUNC_m(RealType, alpha); // beta, non_central_beta
+  GEN_FUNC_m(RealType, beta); // beta, non_central_beta
+  GEN_FUNC_s(RealType, find_alpha); // beta
+  GEN_FUNC_s(RealType, find_beta); // beta
+  GEN_FUNC_s(RealType, find_lower_bound_on_p);
+      // binomial, geometric, negative_binomial
+  GEN_FUNC_s(RealType, find_maximum_number_of_trials);
+      // binomial, geometric, negative_binomial
+  GEN_FUNC_s(RealType, find_minimum_number_of_trials);
+      // binomial, geometric, negative_binomial
+  GEN_FUNC_s(RealType, find_upper_bound_on_p);
+      // binomial, geometric, negative_binomial
+  GEN_FUNC_m(RealType, trails); // binomial
+  GEN_FUNC_m(RealType, location);
+      // cauchy, extreme_value, inverse_gaussian, 
+      // laplace, logistic, lognormal, normal, skew_normal
+  GEN_FUNC_m(RealType, scale);
+      // cauchy, extreme_value, gamma, inverse_chi_squared,
+      // inverse_gamma, inverse_gaussian, laplace, logistic,
+      // lognormal, normal, pareto, skew_normal, weibull
+  GEN_FUNC_s(RealType, find_degrees_of_freedom);
+      // chi_squared, non_central_chi_squared, students_t
+  GEN_FUNC_m(RealType, degrees_of_freedom);
+      // chi_squared, inverse_chi_squared, non_central_chi_squared,
+      // non_central_t, students_t
+  GEN_FUNC_m(RealType, lambda); // exponential
+  GEN_FUNC_m(RealType, degrees_of_freedom1); // fisher_f, non_central_f
+  GEN_FUNC_m(RealType, degrees_of_freedom2); // fisher_f, non_central_f
+  GEN_FUNC_m(RealType, shape);
+      // gamma, inverse_gamma, inverse_gaussian, pareto,
+      // skew_normal, weibull
+  GEN_FUNC_m(RealType, successes); // geometric, negative_binomial
+  GEN_FUNC_m(std::vector<RealType>, probabilities); // hyperexponential
+  GEN_FUNC_m(std::vector<RealType>, rates); // hyperexponential
+  GEN_FUNC_m(std::size_t, num_phases); // hyperexponential
+  GEN_FUNC_m(bool, check_params); // hypergeometric
+  GEN_FUNC_m(bool, check_x); // hypergeometric
+  GEN_FUNC_m(unsigned, defective); // hypergeometric
+  GEN_FUNC_m(unsigned, sample_count); // hypergeometric
+  GEN_FUNC_m(unsigned, total); // hypergeometric
+  GEN_FUNC_m(RealType, mean); // inverse_gaussian, poisson
+  GEN_FUNC_m(RealType, number_of_observations); // kolmogorov_smirnov
+  GEN_FUNC_m(RealType, non_centrality);
+      // non_central_beta, non_central_chi_squared, non_central_f,
+      // non_central_t
+  GEN_FUNC_s(RealType, find_non_centrality);
+      // non_central_chi_squared
+  GEN_FUNC_m(RealType, standard_deviation); // normal
+  GEN_FUNC_m(RealType, sigma); // rayleigh
+  GEN_FUNC_m(RealType, lower); // triangular, uniform
+  GEN_FUNC_m(RealType, mode); // triangular
+  GEN_FUNC_m(RealType, upper); // triangular, uniform
+
+#undef GEN_FUNC_s
+#undef GEN_FUNC_m
+};
+} }
+using namespace boost::math;
+%}
+%include boost/version.hpp
+
+%define INSTANTIATE(dist_name, type, class_name, min_ver)
+%{
+#if BOOST_VERSION_LESS_THAN(min_ver)
+namespace boost{ namespace math{
+template <class RealType = double, class Policy = policies::policy<> >
+struct dist_name ## _distribution : public distribution_dummy_t<RealType, min_ver> { // dummy
+  dist_name ## _distribution(...) : distribution_dummy_t<RealType, min_ver>() {}
+};
+} }
+#endif
+%}
+#if BOOST_VERSION >= min_ver
+%include boost/math/distributions/ ## dist_name ## .hpp
+#else
+namespace boost{ namespace math{
+template <class RealType = double, class Policy = policies::policy<> >
+struct dist_name ## _distribution { // dummy
+  typedef RealType value_type;
+  dist_name ## _distribution();
+};
+} }
+#endif
+%typemap(out, fragment=SWIG_Traits_frag(type)) std::pair<type, type> {
+  %append_output(swig::from($1.first));
+  %append_output(swig::from($1.second));
+}
+%extend boost::math::dist_name ## _distribution {
+  %catches(std::logic_error) dist_name ## _distribution; // for ctor
+  %catches(std::logic_error, std::runtime_error); // for the following member functions
+#define shim_t boost::math::distribution_shim_t<min_ver>
+  value_type pdf(const value_type &x) const {
+    return shim_t::pdf(*$self, x);
+  }
+  value_type cdf(const value_type &x, const bool &is_complement = false) const {
+    return shim_t::cdf(*$self, x, is_complement);
+  }
+  value_type quantile(const value_type &p, const bool &is_complement = false) const {
+    return shim_t::quantile(*$self, p, is_complement);
+  }
+  value_type hazard(const value_type &x) const {
+    return shim_t::hazard(*$self, x);
+  }
+  value_type chf(const value_type &x) const {
+    return shim_t::chf(*$self, x);
+  }
+  value_type mean() const {return shim_t::mean(*$self);}
+  value_type median() const {return shim_t::median(*$self);}
+  value_type mode() const {return shim_t::mode(*$self);}
+  value_type standard_deviation() const {return shim_t::standard_deviation(*$self);}
+  value_type variance() const {return shim_t::variance(*$self);}
+  value_type skewness() const {return shim_t::skewness(*$self);}
+  value_type kurtosis() const {return shim_t::kurtosis(*$self);}
+  value_type kurtosis_excess() const {return shim_t::kurtosis_excess(*$self);}
+  std::pair<value_type, value_type> range() const {return shim_t::range(*$self);}
+  std::pair<value_type, value_type> support() const {return shim_t::support(*$self);}
+#undef shim_t
+};
+%template(class_name) boost::math:: ## dist_name ## _distribution<type, policies::policy<> >;
+%enddef
+
+%extend boost::math::cauchy_distribution {
+  %ignore mean;
+  %ignore standard_deviation;
+  %ignore variance;
+  %ignore skewness;
+  %ignore kurtosis;
+  %ignore kurtosis_excess;
+};
+%extend boost::math::non_central_beta_distribution {
+  %ignore skewness;
+  %ignore kurtosis;
+  %ignore kurtosis_excess;
+};
+
+// workaround for hyperexponential having RealT template parameter instead of RealType
+%extend boost::math::hyperexponential_distribution {
+  %ignore hyperexponential_distribution(std::initializer_list<RealT>, std::initializer_list<RealT>);
+  %ignore hyperexponential_distribution(std::initializer_list<RealT>);
+  %typemap(out, fragment=SWIG_Traits_frag(RealT)) std::vector<RealT> {
+    for(typename $1_type::const_iterator it($1.begin()), it_end($1.end());
+        it != it_end; ++it){
+      %append_output(swig::from(*it));
+    }
+  }
+  %typemap(in, fragment=SWIG_Traits_frag(RealT)) const std::vector<RealT> & (std::vector<RealT> temp) {
+#if defined(SWIGRUBY)
+    if(RB_TYPE_P($input, T_ARRAY)){
+      RealT v;
+      for(unsigned int i(0), i_end((unsigned int)RARRAY_LEN($input)); i < i_end; ++i){
+        VALUE val(RARRAY_AREF($input, i));
+        if(!SWIG_IsOK(swig::asval(val, &v))){break;}
+        temp.push_back(v);
+      }
+    }
+#endif
+    $1 = &temp;
+  }
+#if BOOST_VERSION >= 105700
+  hyperexponential_distribution(
+      const std::vector<RealT> &prob, const std::vector<RealT> &range){
+    return new hyperexponential_distribution(
+        prob.begin(), prob.end(), range.begin(), range.end());
+  }
+  hyperexponential_distribution(
+      const std::vector<RealT> &range){
+    return new hyperexponential_distribution(range.begin(), range.end());
+  }
+#endif
+};
+
+// workaround for swig parse error of hyperexponential::is_iterator (>=1.77.0)
+#if BOOST_VERSION >= 107700
+namespace boost{ namespace math{
+template <typename RealT = double, typename PolicyT = policies::policy<> >
+class hyperexponential_distribution { /* extracted from ver 1.81.0 */
+  public:
+    typedef RealT value_type;
+    typedef PolicyT policy_type;
+    
+    hyperexponential_distribution();
+
+    // Four arg constructor: no ambiguity here, the arguments must be two pairs of iterators:
+    template <typename ProbIterT, typename RateIterT>
+    hyperexponential_distribution(
+        ProbIterT prob_first, ProbIterT prob_last,
+        RateIterT rate_first, RateIterT rate_last);
+
+    // Two arg constructor from 2 ranges, we SFINAE this out of existence if
+    // either argument type is incrementable as in that case the type is
+    // probably an iterator:
+    template <
+        typename ProbRangeT, typename RateRangeT, 
+        typename std::enable_if<!is_iterator<ProbRangeT>::value && 
+          !is_iterator<RateRangeT>::value, bool>::type = true>
+    hyperexponential_distribution(
+        ProbRangeT const& prob_range, RateRangeT const& rate_range);
+
+    // Two arg constructor for a pair of iterators: we SFINAE this out of
+    // existence if neither argument types are incrementable.
+    // Note that we allow different argument types here to allow for
+    // construction from an array plus a pointer into that array.
+    template <
+        typename RateIterT, typename RateIterT2,
+        typename std::enable_if<
+          is_iterator<RateIterT>::value || is_iterator<RateIterT2>::value, bool>::type = true>
+    hyperexponential_distribution(
+        RateIterT const& rate_first, RateIterT2 const& rate_last);
+
+    // Initializer list constructor: allows for construction from array literals:
+    hyperexponential_distribution(std::initializer_list<RealT> l1, std::initializer_list<RealT> l2);
+
+    hyperexponential_distribution(std::initializer_list<RealT> l1);
+
+    // Single argument constructor: argument must be a range.
+    template <typename RateRangeT>
+    hyperexponential_distribution(RateRangeT const& rate_range);
+
+    std::vector<RealT> probabilities() const;
+    std::vector<RealT> rates() const;
+    std::size_t num_phases() const;
+};
+} }
+#define BOOST_MATH_DISTRIBUTIONS_HYPEREXPONENTIAL_HPP
+#endif
+
+%define CTACH_LOGIC_ERROR(dist_name, func_name)
+%extend boost::math::dist_name ## _distribution {
+  %catches(std::logic_error) func_name;
+};
+%enddef
+
+%define CTACH_LOGIC_ERROR_FOR_FIND_METHODS(dist_name)
+CTACH_LOGIC_ERROR(dist_name, find_lower_bound_on_p);
+CTACH_LOGIC_ERROR(dist_name, find_upper_bound_on_p);
+CTACH_LOGIC_ERROR(dist_name, find_minimum_number_of_trials);
+CTACH_LOGIC_ERROR(dist_name, find_maximum_number_of_trials);
+%enddef
+CTACH_LOGIC_ERROR_FOR_FIND_METHODS(binomial);
+CTACH_LOGIC_ERROR_FOR_FIND_METHODS(geometric);
+CTACH_LOGIC_ERROR_FOR_FIND_METHODS(negative_binomial);
+#undef CTACH_LOGIC_ERROR_FOR_FIND_METHODS
+
+CTACH_LOGIC_ERROR(chi_squared, find_degrees_of_freedom);
+CTACH_LOGIC_ERROR(non_central_chi_squared, find_degrees_of_freedom);
+CTACH_LOGIC_ERROR(students_t, find_degrees_of_freedom);
+
+#undef CTACH_LOGIC_ERROR
+
+%feature("autodoc", "1");
+
+INSTANTIATE(arcsine, double, Arcsine, 105800);
+INSTANTIATE(bernoulli, double, Bernoulli, 103500);
+INSTANTIATE(beta, double, Beta, 103500);
+INSTANTIATE(binomial, double, Binomial, 103500);
+INSTANTIATE(cauchy, double, Cauchy, 103500);
+INSTANTIATE(chi_squared, double, ChiSquared, 103500);
+INSTANTIATE(exponential, double, Exponential, 103500);
+INSTANTIATE(extreme_value, double, ExtremeValue, 103500);
+INSTANTIATE(fisher_f, double, FisherF, 103500);
+INSTANTIATE(gamma, double, Gamma, 103500);
+INSTANTIATE(geometric, double, Geometric, 104600);
+INSTANTIATE(hyperexponential, double, Hyperexponential, 105700);
+INSTANTIATE(hypergeometric, double, Hypergeometric, 104000);
+INSTANTIATE(inverse_chi_squared, double, InverseChiSquared, 104500);
+INSTANTIATE(inverse_gamma, double, InverseGamma, 104500);
+INSTANTIATE(inverse_gaussian, double, InverseGaussian, 104600);
+INSTANTIATE(kolmogorov_smirnov, double, KolmogorovSmirnov, 107500);
+INSTANTIATE(laplace, double, Laplace, 104000);
+INSTANTIATE(logistic, double, Logistic, 104000);
+INSTANTIATE(lognormal, double, Lognormal, 103500);
+INSTANTIATE(negative_binomial, double, NegativeBinomial, 103500);
+INSTANTIATE(non_central_beta, double, NonCentralBeta, 103600);
+INSTANTIATE(non_central_chi_squared, double, NonCentralChiSquared, 103600);
+INSTANTIATE(non_central_f, double, NonCentralF, 103600);
+INSTANTIATE(non_central_t, double, NonCentralT, 103600);
+INSTANTIATE(normal, double, Normal, 103500);
+INSTANTIATE(pareto, double, Pareto, 103500);
+INSTANTIATE(poisson, double, Poisson, 103500);
+INSTANTIATE(rayleigh, double, Rayleigh, 103500);
+INSTANTIATE(skew_normal, double, SkewNormal, 105000);
+INSTANTIATE(students_t, double, StudentsT, 103500);
+INSTANTIATE(triangular, double, Triangular, 103500);
+INSTANTIATE(uniform, double, Uniform, 103500);
+INSTANTIATE(weibull, double, Weibull, 103500);
+
+#undef INSTANTIATE

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

@@ -0,0 +1,5 @@
+require "mkmf"
+cflags = " -Wall -I../../.."
+$CFLAGS += cflags
+$CPPFLAGS += cflags if RUBY_VERSION >= "2.0.0"
+$LOCAL_LIBS += " -lstdc++ "

data/ext/ninja-scan-light/tool/swig/makefile

@@ -0,0 +1,53 @@
+SWIG = swig
+SWIGFLAGS = -c++ -ruby $(shell if [ -n "$$MSYSTEM" ]; then echo -D__MINGW__; fi)
+INCLUDES = -I../
+BUILD_DIR = build_SWIG
+
+RUBY = ruby
+RUBY_CONF = extconf.rb
+
+SRCS = $(shell ls *.i)
+	
+PACKAGES = $(SRCS:.i=.so)
+
+all : $(BUILD_DIR) depend $(PACKAGES)
+
+depend : INCLUDES+=-I$(shell echo $${MSYSTEM_PREFIX:-/usr})/include/
+
+# �w�b�_�[�t�@�C���̈ˑ��֌W
+depend : $(SRCS)
+	if [ -f $(BUILD_DIR)/depend.inc ]; then rm -f $(BUILD_DIR)/depend.inc; fi
+	for i in $^; do\
+		$(SWIG) $(SWIGFLAGS) $(INCLUDES) -MM -MP $$i  | sed -e 's/[^\.]*\.cxx/$$\(BUILD_DIR\)\/&/g' >> $(BUILD_DIR)/depend.inc;\
+	done
+
+-include $(BUILD_DIR)/depend.inc
+
+$(PACKAGES) : $(patsubst %,$(BUILD_DIR)/%,$(PACKAGES))
+
+$(BUILD_DIR)/BoostDistributions_wrap.cxx : INCLUDES+=-I$(shell echo $${MSYSTEM_PREFIX:-/usr})/include/
+
+$(BUILD_DIR)/%_wrap.cxx : %.i
+	$(SWIG) $(SWIGFLAGS) $(INCLUDES) -o $@ $<
+
+$(BUILD_DIR)/%.so : PACKAGE = $(shell echo $@ | sed -e 's/^$(BUILD_DIR)\/\([^\.]*\)\.so/\1/g')
+$(BUILD_DIR)/%.so : $(BUILD_DIR)/%_wrap.cxx $(RUBY_CONF)
+	echo "building $(PACKAGE) ..."
+	if ! [ -d $(BUILD_DIR)/$(PACKAGE) ]; then mkdir $(BUILD_DIR)/$(PACKAGE); fi
+	cp $(RUBY_CONF) $(BUILD_DIR)/$(PACKAGE)/
+	cp $(BUILD_DIR)/$(PACKAGE)_wrap.cxx $(BUILD_DIR)/$(PACKAGE)/
+	cd $(BUILD_DIR)/$(PACKAGE); \
+	echo 'create_makefile("$(PACKAGE)")' >> $(RUBY_CONF); \
+	$(RUBY) $(RUBY_CONF); \
+	make; \
+	cp *.so ../
+
+$(BUILD_DIR) :
+	mkdir $@
+
+clean :
+	rm -rf $(BUILD_DIR)/*
+
+run : all
+
+.PHONY : clean all depend

data/lib/boost_distributions/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module BoostDistributions
+  VERSION = "0.1.0"
+end

data/lib/boost_distributions.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+require_relative "boost_distributions/version"
+
+require 'boost_distributions/BoostDistributions'
+
+module BoostDistributions
+  class Error < StandardError; end
+  # Your code goes here...
+end

data/sig/boost_distributions.rbs

@@ -0,0 +1,4 @@
+module BoostDistribution
+  VERSION: String
+  # See the writing guide of rbs: https://github.com/ruby/rbs#guides
+end

metadata

@@ -0,0 +1,106 @@
+--- !ruby/object:Gem::Specification
+name: boost_distributions
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- fenrir(M.Naruoka)
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2023-06-23 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13.0'
+- !ruby/object:Gem::Dependency
+  name: rake-compiler
+  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: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+description: This is a Ruby gem to calculate statistical properties of various distributions
+  by using boost::math::distributions.
+email:
+- fenrir.naru@gmail.com
+executables: []
+extensions:
+- ext/boost_distributions/extconf.rb
+extra_rdoc_files: []
+files:
+- ".rspec"
+- CHANGELOG.md
+- CODE_OF_CONDUCT.md
+- Gemfile
+- LICENSE
+- README.md
+- Rakefile
+- boost_distributions.gemspec
+- ext/boost_distributions/BoostDistributions/BoostDistributions_wrap.cxx
+- ext/boost_distributions/extconf.rb
+- ext/ninja-scan-light/tool/swig/BoostDistributions.i
+- ext/ninja-scan-light/tool/swig/extconf.rb
+- ext/ninja-scan-light/tool/swig/makefile
+- lib/boost_distributions.rb
+- lib/boost_distributions/version.rb
+- sig/boost_distributions.rbs
+homepage: https://github.com/fenrir-naru/ruby-boost_distributions
+licenses: []
+metadata:
+  homepage_uri: https://github.com/fenrir-naru/ruby-boost_distributions
+  source_code_uri: https://github.com/fenrir-naru/ruby-boost_distributions
+  changelog_uri: https://github.com/fenrir-naru/ruby-boost_distributions/blob/main/CHANGELOG.md
+post_install_message: 
+rdoc_options:
+- "--exclude=ext/ninja-scan-light"
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.6.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.3.5
+signing_key: 
+specification_version: 4
+summary: Interface to boost::math::distributions
+test_files: []