gaussian-filter 0.0.3

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 4c2cb44500e80f6377d833cc23256bedb85095047ab8fd07fc8458b45bf3fe43
+  data.tar.gz: bd3a28adacfd224cc7ed01a58378c78efdfafdefcf335f17cac7bdcfd206c641
+SHA512:
+  metadata.gz: d50458962ef63ae61fa574e8af8b0e86a747400e59927ef875d7df66030f2d916ef9a60ae1bf483b91a2cb83a920ec8e976b8d64012e93d5f0b1fe00623dcf0f
+  data.tar.gz: a9b6e98adcbfe4af1273a71b9229f7ac611e79ef7a446faeb2bec532dacc0817833fd6781132de68b448dbe1c85893cd07292564dff5becf8fdf267528f2a883

data/.github/workflows/build.yml

@@ -0,0 +1,24 @@
+name: build
+
+on: 
+  push:
+
+jobs:
+  release-versions:
+    name: Build ruby-filter-gaussian
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v2
+      - name: Set up Ruby
+        uses: actions/setup-ruby@v1
+        with:
+          ruby-version : 2.7
+      - name: Build
+        run: | 
+          gem install --no-document bundler
+          gem build gaussian-filter.gemspec
+          gem install gaussian-filter-*.gem
+          bundle install
+      - name: Test
+        run: rake test
+      

data/.gitignore

@@ -0,0 +1,9 @@
+/.bundle/
+/.yardoc
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+*.so

data/.vscode/c_cpp_properties.json

@@ -0,0 +1,19 @@
+{
+    "configurations": [
+        {
+            "name": "Linux",
+            "includePath": [
+                "${workspaceFolder}/**",
+                "/usr/include/ruby-2.7.0",
+                "/usr/include/x86_64-linux-gnu/ruby-2.7.0",
+                "/usr/lib/x86_64-linux-gnu/ruby/vendor_ruby/2.7.0"
+            ],
+            "defines": [],
+            "compilerPath": "/usr/bin/gcc",
+            "cStandard": "gnu17",
+            "cppStandard": "gnu++14",
+            "intelliSenseMode": "linux-gcc-x64"
+        }
+    ],
+    "version": 4
+}

data/.vscode/settings.json

@@ -0,0 +1,13 @@
+{
+    "files.associations": {
+        "numo-gaussian.h": "c",
+        "narray.h": "c",
+        "template.h": "c",
+        "stdio.h": "c",
+        "ruby.h": "c",
+        "intern.h": "c",
+        "types.h": "c",
+        "narray_config.h": "c",
+        "stdlib.h": "c"
+    }
+}

data/Gemfile

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+source "https://rubygems.org"
+
+# Specify your gem's dependencies in gaussian-filter.gemspec
+gemspec
+
+gem "rake", "~> 13.0"
+gem "numo-narray"
+gem "rake-compiler"

data/Gemfile.lock

@@ -0,0 +1,25 @@
+PATH
+  remote: .
+  specs:
+    gaussian-filter (0.0.1)
+      numo-narray
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    numo-narray (0.9.1.9)
+    rake (13.0.3)
+    rake-compiler (1.1.1)
+      rake
+
+PLATFORMS
+  x86_64-linux
+
+DEPENDENCIES
+  gaussian-filter!
+  numo-narray
+  rake (~> 13.0)
+  rake-compiler
+
+BUNDLED WITH
+   2.2.24

data/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2021 MURATA Mitsuharu
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/NUMO.md

@@ -0,0 +1,21 @@
+
+
+```sh
+mkdir -p /usr/local/share
+git clone --depth 1 https://github.com/ruby-numo/numo-narray.git /tmp/numo-narray
+cd /tmp/numo-narray/ext/numo/narray
+ruby extconf.rb
+make -j
+sudo mkdir -p /usr/local/include
+sudo cp narray.so /usr/lib/libnarray.so
+sudo cp -r numo /usr/local/include/
+cd -
+
+```
+
+```sh
+sudo rm -rf /usr/local/include/numo/
+sudo rm /usr/lib/libnarray.so
+rm -rf /tmp/numo-narray/
+
+```

data/README.md

@@ -0,0 +1,60 @@
+# ruby-filter-gaussian
+[![build](https://github.com/Himeyama/ruby-filter-gaussian/actions/workflows/build.yml/badge.svg)](https://github.com/Himeyama/ruby-filter-gaussian/actions/workflows/build.yml)
+
+## 概要
+ガウシアンフィルターの Ruby 拡張。データが複数の場合は並列計算を行うため高速に計算されます。
+
+基本的には、 https://docs.scipy.org/doc/scipy/reference/generated/scipy.ndimage.gaussian_filter1d.html 
+と同じです。
+
+- フィルターの標準偏差に対してデータが小さい場合は計算できません。
+- 実装が異なるためか Python のライブラリと比較すると丸目誤差が存在する場合があります。誤差の大きさは 10^(-15) 程度です。
+
+## インストール
+
+GitHub から、`ruby-filter-gaussian` をインストールするには以下のコマンドを実行します。
+```sh
+gem install specific_install
+gem specific_install -l himeyama/ruby-filter-gaussian
+```
+
+
+**Gemfile** に記述する場合は以下のようにして `bundle`。
+
+```rb
+gem "gaussian-filter", github: "himeyama/ruby-filter-gaussian.git", branch: :main
+```
+
+## 使用法
+<dt><code>Gaussian.filter1d(ary, sd) -> Array</code></dt>
+<dd>
+    <p>データへガウシアンフィルター処理を行います。
+    `ary` の大きさが1の場合、1次元配列が返ります。
+    `ary` の大きさが2以上で `sd` が数値の場合は全てのデーターで `sd` が適応され、
+    `sd` が配列の場合は各データのインデックスに対応します。
+    </p>
+    <dl>
+        <dt>[PARAM] ary:</dt>
+        <dd>一次元のデータ</dd>
+        <dt>[PARAM] sd:</dt>
+        <dd>ガウシアンフィルターの標準偏差。</dd>
+    </dl>
+
+```rb
+require "Gaussian"
+
+Gaussian.filter1d [1, 2, 3, 4, 5], 1
+#=> [1.4270409503911738, 2.0678220347792573, 3.0, 3.932177965220743, 4.572959049608826]
+
+Gaussian.filter1d [[1, 2, 3, 4, 5], [3, 2, 3, 4, 1]], 1
+# => 
+# [[1.4270409503911738, 2.0678220347792573, 3.0, 3.932177965220743, 4.572959049608826],
+#  [2.708335457918112, 2.641484411955284, 2.8831540219185285, 2.757459057400815, 2.0095670508072625]]
+
+Gaussian.filter1d [[1, 2, 3, 4, 5], [1, 2, 3, 4, 5]], [1, 0.5]
+#=> 
+# [[1.4270409503911738, 2.0678220347792573, 3.0, 3.932177965220743, 4.572959049608826],
+#  [1.1072423672218035, 2.0002638650827373, 2.9999999999999996, 3.999736134917262, 4.892757632778196]]
+```   
+
+</dd>

data/Rakefile

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+require "bundler/gem_tasks"
+task default: %i[]
+
+require "rake/extensiontask"
+
+Rake::ExtensionTask.new "Gaussian" do |ext|
+    ext.lib_dir = "ext"
+end
+
+task :default => :compile

data/bin/console

@@ -0,0 +1,15 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require "bundler/setup"
+require "numo/narray"
+require "Gaussian"
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require "irb"
+IRB.start(__FILE__)

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/ext/Gaussian/.gitignore

@@ -0,0 +1,3 @@
+Makefile
+*.o
+*.out

data/ext/Gaussian/Gaussian.c

@@ -0,0 +1,139 @@
+/*
+ *  (c) 2021 Murata Mitsuharu
+ *  Licensed under the MIT License.
+ */
+
+#include <stdio.h>
+#include <ruby.h>
+#include <ruby/intern.h>
+#include <numo/narray.h>
+#include <stdlib.h>
+#include <pthread.h>
+#include "numo-gaussian.h"
+#include "gaussian.h"
+
+extern VALUE numo_cDFloat;
+VALUE cGaussian;
+
+VALUE gaussian_filter1d_ary(VALUE self, VALUE ary, VALUE sd){
+    Vector filtered[16];
+    VALUE a;
+    Vector v[16]; 
+    long size[16];
+    pthread_t th[16];
+    if(TYPE(ary) != T_ARRAY) return Qfalse;
+    VALUE datas = rb_ary_new();
+    if(TYPE(rb_ary_entry(ary, 0)) != T_ARRAY)
+        rb_ary_store(datas, 0, ary); 
+    else
+        datas = ary;
+    long data_size = RARRAY_LEN(datas);
+    if(data_size > 16) return Qfalse;    
+    GaussianArgsRet ga[16]; ga;
+    a = rb_ary_new();
+    for(int i = 0; i < data_size; i++){
+        VALUE data = rb_ary_entry(datas, i);
+        size[i] = RARRAY_LEN(data);
+        v[i] = Vector_zeros(size[i]);
+        rb_ary_store(a, i, rb_ary_new_capa(size[i]));
+        for(long j = 0; j < size[i]; j++)
+            v[i].data[j] = NUM2DBL(rb_ary_entry(data, j)); 
+        ga[i].src_data = v[i];
+        ga[i].dst_data = filtered + i;
+        ga[i].truncate = 4.0;
+        if(TYPE(sd) == T_FLOAT || TYPE(sd) == T_FIXNUM){
+            ga[i].sd = NUM2DBL(sd);
+        }else if(TYPE(sd) == T_ARRAY){
+            if(RARRAY_LEN(sd) != data_size) return Qfalse;
+            ga[i].sd = NUM2DBL(rb_ary_entry(sd, i));
+        }else
+            return Qfalse;
+        void* (*gfunc[2])() = {gaussian, narray_gaussian};
+        if(pthread_create(&th[i], NULL, gfunc[0], (void*)&ga[i]))
+            exit(EXIT_FAILURE);
+    }
+    for(int i = 0; i < data_size; i++)
+        if(pthread_join(th[i], NULL))
+            exit(EXIT_FAILURE);
+    for(int i = 0; i < data_size; i++){   
+        for(long j = 0; j < size[i]; j++){
+            rb_ary_store(rb_ary_entry(a, i), j, DBL2NUM(filtered[i].data[j]));
+        }
+        Vector_destroy(v[i]);
+        Vector_destroy(filtered[i]);
+    }
+    if(data_size == 1) return rb_ary_entry(a, 0);
+    return a;
+}
+
+VALUE gaussian_filter1d_dfloat(VALUE self, VALUE ary, VALUE sd){    
+    VALUE shape = rb_funcall(ary, rb_intern("shape"), 0);
+    VALUE r = rb_funcall(ary, rb_intern("clone"), 0);
+    u64 row = 1, size;
+    u64 dim = NUM2INT(rb_funcall(shape, rb_intern("size"), 0));
+
+    if(dim == 1){
+        size = NUM2LONG(rb_ary_entry(shape, 0));
+    }else if(dim == 2){
+        row = NUM2LONG(rb_ary_entry(shape, 0));
+        size = NUM2LONG(rb_ary_entry(shape, 1));
+    }
+    if(TYPE(sd) == T_FLOAT || TYPE(sd) == T_FIXNUM){
+        VALUE tmp = rb_ary_new();
+        sd = rb_funcall(sd, rb_intern("to_f"), 0);
+        for(u64 i = 0; i < row; i++)
+            rb_ary_store(tmp, i, sd);
+        sd = tmp;
+    }
+    sd = rb_funcall(sd, rb_intern("to_a"), 0);
+
+    u64 sd_size = RARRAY_LEN(sd);
+    if(!(sd_size == 1 || sd_size == row)) return Qfalse;
+
+    if(dim == 1){
+        VALUE sp = rb_ary_new();
+        rb_ary_store(sp, 0, INT2NUM(1));
+        rb_ary_store(sp, 1, LONG2NUM(size));
+        VALUE a = rb_funcall(numo_cDFloat, rb_intern("zeros"), 1, sp);
+        rb_funcall(a, rb_intern("[]="), 2, Qtrue, ary);
+        return rb_funcall(gaussian_filter1d_dfloat(self, a, sd), rb_intern("[]"), 1, Qtrue);
+    }else if(dim == 2){
+        pthread_t th[row];
+        GaussianArgsRetRb ga[row];
+        for(u64 i = 0; i < row; i++){
+            ga[i].dst = (f64*)na_get_pointer_for_read(r);
+            ga[i].src = (f64*)na_get_pointer_for_read(ary); 
+            ga[i].size = size; 
+            ga[i].i = i;
+            ga[i].sd = NUM2DBL(rb_ary_entry(sd, i));
+            ga[i].truncate = 4.0;
+            if(pthread_create(th + i, NULL, (void*)_gaussian_filter1d_dfloat, (void*)(ga + i)))
+                exit(EXIT_FAILURE);
+        }
+        for(u64 i = 0; i < row; i++)
+            if(pthread_join(th[i], NULL))
+                exit(EXIT_FAILURE);
+        return r;
+    }
+    return Qfalse;
+}
+
+static VALUE gaussian_filter1d(VALUE self, VALUE ary, VALUE sd){
+    VALUE ary_class = rb_funcall(ary, rb_intern("class"), 0);
+    
+    // rb_p(na_cast_object(ary, NA_DFLOAT));
+    
+    if(rb_funcall(ary_class, rb_intern("=="), 1, numo_cDFloat) == Qtrue){
+        return gaussian_filter1d_dfloat(self, ary, sd);
+    }else if(TYPE(ary) == T_ARRAY){
+        return gaussian_filter1d_ary(self, ary, sd);
+    }
+
+    // rb_funcall(rb_stderr, rb_intern("puts"), 1, );
+    return Qfalse;
+}
+
+void Init_Gaussian(void){
+    cGaussian = rb_define_module("Gaussian");
+    rb_define_singleton_method(cGaussian, "filter1d", gaussian_filter1d, 2);
+}

data/ext/Gaussian/cgaussian.c

@@ -0,0 +1,171 @@
+/*
+ *  (c) 2021 Murata Mitsuharu
+ *  Licensed under the MIT License.
+ *  source: https://github.com/Himeyama/C-Gaussian-Filter
+ */
+
+
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+#include <math.h>
+#include <time.h>
+#include <ruby.h>
+#include <numo/narray.h>
+#include "gaussian.h"
+
+
+void Vector_p(Vector vec){
+    double* data = vec.data;
+    char* str = (char*)malloc(100000000); // 100MB
+    char d[16];
+    for(int i = 0; i < vec.size; i++){
+        sprintf(d, i == vec.size - 1 ? "%f" : "%f, ", data[i]);
+        // ＼(^o^)／
+        strcat(str, d);
+    }
+    printf("[%s]\n", str);
+}
+
+void Vector_txt(Vector vec){
+    double* data = vec.data;
+    char* str = (char*)malloc(100000000); // 100MB
+    char d[16];
+    for(int i = 0; i < vec.size; i++){
+        sprintf(d, "%f\n", data[i]);
+        // ＼(^o^)／
+        strcat(str, d);
+    }
+    printf("%s", str);
+}
+
+void Vector_destroy(Vector vec){
+    free(vec.data);
+}
+
+Vector Vector_initialize(long size){
+    Vector vec;
+    vec.size = size;
+    vec.data = (double*)malloc(sizeof(double) * size);
+    return vec;
+}
+
+Vector Vector_initializeP(long size, Vector* vec){
+    vec->size = size;
+    vec->data = (double*)malloc(sizeof(double) * size);
+    return *vec;
+}
+
+Vector Vector_zeros(long size){
+    Vector vec = Vector_initialize(size);
+    for(int i = 0; i < size; i++)
+        vec.data[i] = 0;
+    return vec;
+}
+
+double Vector_dot(Vector vec1, Vector vec2){
+    if(vec1.size != vec2.size){
+        fprintf(stderr, "ベクトルのサイズが異なります\n");
+        exit(EXIT_FAILURE);
+    }
+    double dot = 0;
+    for(int i = 0; i < vec1.size; i++){
+        dot += vec1.data[i] * vec2.data[i];
+    }
+    return dot;
+}
+
+Vector Vector_arange(int start, int stop){
+    int size = stop - start;
+    Vector vec = Vector_initialize(size);
+    for(int i = 0; i < size; i++){
+        vec.data[i] = start + i;
+    }
+    return vec;
+}
+
+double Vector_sum(Vector vec){
+    double sum = 0;
+    for(int i = 0; i < vec.size; i++)
+        sum += vec.data[i];
+    return sum;
+}
+
+// 破壊的関数
+void Vector_div(Vector vec, double n){
+    for(int i = 0; i < vec.size; i++){
+        vec.data[i] /= n;
+    }
+}
+
+// 正規分布 (0, 1) に従う乱数
+Vector Vector_normal(long size){
+    Vector vec = Vector_initialize(size);
+    for(int i = 0; i < size; i++){
+        double u1 = drand48();
+        double u2 = drand48();
+        vec.data[i] = sqrt(-2 * log(u1)) * sin(2 * M_PI * u2);
+    }
+    return vec;
+}
+
+Vector Vector_clone(Vector vec){
+    Vector c = Vector_initialize(vec.size);
+    for(int i = 0; i < vec.size; i++)
+        c.data[i] = vec.data[i];
+    return c;
+}
+
+void* gaussian(GaussianArgsRet* ga){
+    Vector src_data = ga->src_data;
+    double sd = ga->sd;
+    double truncate = ga->truncate;
+    
+    // printf("sd: %lf\n", sd);
+    // printf("truncate: %lf\n", truncate);
+    // Vector_p(src_data);
+
+    int r = (int)(truncate * sd + 0.5);
+    
+    if(r > src_data.size){
+        fprintf(stderr, "データが小さすぎます\n");
+        exit(EXIT_FAILURE);
+    }
+    
+    Vector data = Vector_initialize(src_data.size + 2 * r);
+    for(int i = 0; i < r; i++)
+        data.data[i] = src_data.data[r-i-1];
+    for(int i = r; i < src_data.size + r; i++)
+        data.data[i] = src_data.data[i-r];
+    for(int i = 0; i < r; i++)
+        data.data[i+r+src_data.size] = src_data.data[src_data.size-i-1];
+
+    Vector f = Vector_initialize(data.size);
+
+    Vector x = Vector_arange(-r, r+1);
+    Vector gauss = Vector_zeros(2*r+1);
+    for(int i = 0; i < x.size; i++){
+        gauss.data[i] = exp(-0.5 * x.data[i] * x.data[i] / (sd * sd));
+    }
+    Vector_div(gauss, Vector_sum(gauss));
+
+    for(int i = r; i < data.size - r; i++){
+        Vector d;
+        d.size = 2 * r + 1;
+        d.data = data.data + i - r;
+        f.data[i] = Vector_dot(gauss, d);
+    }
+
+    Vector *filtered = ga->dst_data;
+    Vector_initializeP(src_data.size, filtered);
+    for(int i = 0; i < filtered->size; i++){
+        filtered->data[i] = f.data[i + r];
+    }
+
+    Vector_destroy(data);
+    Vector_destroy(f);
+    Vector_destroy(x);
+    Vector_destroy(gauss);
+
+    return NULL;
+}

data/ext/Gaussian/extconf.rb

@@ -0,0 +1,7 @@
+require 'mkmf'
+
+narray_dir = Gem.find_files("numo").map{|e| e.include?("narray") ? e : false}.select{|e| e}.to_a[0]
+$INCFLAGS += " -I#{narray_dir}"
+$libs += " #{narray_dir}/narray.so"
+
+create_makefile "Gaussian"

data/ext/Gaussian/funcp.c

@@ -0,0 +1,17 @@
+#include <stdio.h>
+
+void* func1(void){
+    puts("Hello, world!");
+    return NULL;
+}
+
+void* func2(void){
+    puts("こんにちは世界");
+    return NULL;
+}
+
+int main(void){
+    void* (*a[2])() = {func1, func2};
+    a[1]();
+    return 0;
+}

data/ext/Gaussian/gaussian.h

@@ -0,0 +1,38 @@
+/*
+ *  (c) 2021 Murata Mitsuharu
+ *  Licensed under the MIT License.
+ *  source: https://github.com/Himeyama/C-Gaussian-Filter
+ */
+
+
+#ifndef GAUSSIAN_H
+#define GAUSSIAN_H
+ 
+struct vector{
+    long size;
+    double* data;
+};
+
+typedef struct vector Vector;
+
+typedef struct{
+    Vector src_data;
+    Vector* dst_data;
+    double sd;
+    double truncate;
+} GaussianArgsRet;
+
+void Vector_p(Vector vec);
+void Vector_txt(Vector vec);
+void Vector_destroy(Vector vec);
+Vector Vector_initialize(long size);
+Vector Vector_zeros(long size);
+double Vector_dot(Vector vec1, Vector vec2);
+Vector Vector_arange(int start, int stop);
+double Vector_sum(Vector vec);
+void Vector_div(Vector vec, double n);
+Vector Vector_normal(long size);
+Vector Vector_clone(Vector vec);
+void* gaussian(GaussianArgsRet* ga);
+
+#endif

data/ext/Gaussian/numo-gaussian.c

@@ -0,0 +1,148 @@
+/*
+ *  (c) 2021 Murata Mitsuharu
+ *  Licensed under the MIT License.
+ */
+
+#include <ruby/ruby.h>
+#include <numo/narray.h>
+#include "numo-gaussian.h"
+
+f64 getData(f64* data, u64 idx){
+    return 0;
+}
+
+f64 conv1(f64* data, f64 idx, u32 r){
+    for(i64 i = idx - r; i <= idx + r; i++){
+        printf("%ld\n", i);
+    }
+    return 0;
+}
+
+// index 取得
+i64 get_at(i64 i, i64 n){
+    i64 idx;
+    if(i >= -n && i < 2 * n){
+        idx = i < 0 ? - i - 1 : (n <= i ? 2 * n - i - 1 : i);
+        // printf("INDEX: %ld\n",idx);
+        return idx;
+    }
+    return -1;
+}
+
+// 数値のポインタを返す
+f64* get_mat_at(f64* x, i64 n, i64 i){
+    i64 idx = get_at(i, n);
+    if(idx == -1) return NULL;
+    return x + idx;
+}
+
+f64 n_dot(i64 n, i64 r, i64 size, f64 *x, i64 i, f64 *gk){
+    f64 sum = 0;
+    f64* tmp;
+    for(i64 j = 0; j < n; j++){
+        tmp = get_mat_at(x, size, j+i-r);
+        // printf("%f * %f\n", gk[j], *tmp);
+        if(tmp == NULL) return NAN;
+        sum += gk[j] * *tmp;
+    }
+    // puts("OK");
+    return sum;
+}
+
+// ガウシアンフィルターの重み配列生成
+// sd: 標準偏差
+// n: カーネルの大きさ (n * 2 + 1)
+f64* gaussian_kernel(f64 sd, i64 n){
+    f64* w = (f64*)malloc(sizeof(f64) * (2 * n + 1));
+    f64 sum = 0;
+    for(i64 i = -n; i <= n; i++)
+        sum += (w[i+n] = exp(-0.5 * i * i / (sd * sd)));
+    for(i64 i = -n; i <= n; i++)
+        w[i+n] /= sum;
+    return w;
+}
+
+
+f64* n_gauss_func(i64 r, f64 sd){
+    f64* g = (f64*)malloc(sizeof(f64)*(2*r+1));
+    f64 sum = 0;
+    for(i64 i = -r; i <= r; i++){
+        g[i+r] = exp(-0.5 * i * i / (sd * sd));
+        sum += g[i+r];
+    }
+    for(i64 i = -r; i <= r; i++)
+        g[i+r] /= sum;
+    return g;
+}
+
+
+// データの両端部分を補完
+// v: 配列
+// n: 配列の大きさ
+// len: 片端補完サイズ
+f64* dreflect(f64 *v, i64 n, i64 len){
+    if(n < len){
+        fprintf(stderr, "エラー: 両端の大きさが元の配列より大きいため、補完できません。\n");
+        return NULL;
+    };
+    i64 r_size = n + 2 * len;
+    f64* r = (f64*)malloc(sizeof(f64) * r_size);
+    for(i64 i = 0; i < n; i++){
+        r[len + i] = v[i];
+    }
+    for(i64 i = 0; i < len; i++){
+        r[len - i - 1] = v[i];
+        r[len + n + i] = v[n - i - 1];
+    }
+    return r;
+}
+
+f64* correlate1d(f64* input, i64 input_size, f64* weights, i64 weights_size, f64* dst){
+    i64 n = input_size - weights_size;
+    f64* r = dst;
+    for(i64 i = 0; i <= n; i++){
+        f64 sum = 0;
+        for(i64 j = 0; j < weights_size; j++)
+            sum += weights[weights_size - j - 1] * input[i + j];
+        r[i] = sum;
+    }
+    return r;
+}
+
+
+// 反転したベクトルを返します
+// v: 配列
+// size: 配列の大きさ
+f64* dreverse(f64 v[], i64 size){
+    f64* r = malloc(sizeof(f64) * size);
+    for(i64 i = 0; i < size; i++)
+        r[i] = v[size-i-1];
+    return r;
+}
+
+
+void* _gaussian_filter1d_dfloat(GaussianArgsRetRb* ga){
+    f64* dst = ga->dst;
+    f64* src = ga->src;
+    i64 size = ga->size;
+    dst += size * ga->i;
+    src += size * ga->i;
+    f64 sd = ga->sd;
+    f64 truncate = ga->truncate;
+    i64 t = (i64)(truncate * sd + 0.5);
+    if(t > size){
+        fprintf(stderr, "データが小さすぎます\n");
+        exit(EXIT_FAILURE);
+    }
+    // i64 gs = 2 * t + 1;
+    f64* tmp = gaussian_kernel(sd, t);
+    f64* weights = dreverse(tmp, 2 * t + 1);
+    f64* s = dreflect(src, size, t);
+    correlate1d(s, 2 * t + size, weights, 2 * t + 1, dst);
+
+    free(tmp);
+    free(weights);
+    free(s);
+
+    return NULL;
+}

data/ext/Gaussian/numo-gaussian.h

@@ -0,0 +1,34 @@
+#ifndef NUMO_GAUSSIAN_H
+#define NUMO_GAUSSIAN_H
+
+// typedef narray_t* NArray;
+typedef size_t SIZE;
+typedef unsigned char u8;
+typedef __int64_t i64;
+typedef __uint32_t u32;
+typedef __uint64_t u64;
+typedef double f64;
+typedef u64 VALUE;
+
+typedef struct{
+    VALUE src_data;
+    VALUE dst_data;
+    f64 sd;
+    f64 truncate;
+} GaussianNArrayArgsRet;
+
+typedef struct{
+    f64* src;
+    f64* dst;
+    VALUE size;
+    f64 sd;
+    f64 truncate;
+    u64 i;
+} GaussianArgsRetRb;
+
+f64 getData(f64* data, u64 idx);
+f64 conv1(f64* data, f64 idx, u32 r);
+void* narray_gaussian(GaussianNArrayArgsRet* ga);
+void* _gaussian_filter1d_dfloat(GaussianArgsRetRb* ga);
+
+#endif

data/ext/Gaussian/rmf.sh

@@ -0,0 +1 @@
+rm *.o *.so Makefile

data/gaussian-filter.gemspec

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+# require_relative "lib/gaussian/filter/version"
+
+Gem::Specification.new do |spec|
+  spec.name          = "gaussian-filter"
+  spec.version       = "0.0.3"
+  spec.authors       = ["Murata Mitsuharu"]
+  spec.email         = ["hikari.photon+dev@gmail.com"]
+  spec.summary       = "Gaussian Filter"
+  spec.homepage      = "https://himeyama.github.io"
+  spec.required_ruby_version = ">= 2.4.0"
+  spec.files = Dir.chdir(File.expand_path(__dir__)) do
+    `git ls-files -z`.split("\x0").reject { |f| f.match(%r{\A(?:test|spec|features)/}) }
+  end
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{\Aexe/}) { |f| File.basename(f) }
+  spec.require_paths = ["ext"]
+  spec.extensions = %w[ext/Gaussian/extconf.rb]
+
+  spec.add_dependency "numo-narray"
+end

data/install-libnarray.sh

@@ -0,0 +1,12 @@
+#!/usr/bin/env ruby
+
+mkdir -p /usr/local/share
+git clone --depth 1 https://github.com/ruby-numo/numo-narray.git /tmp/numo-narray
+cd /tmp/numo-narray/ext/numo/narray
+ruby extconf.rb
+make -j
+sudo mkdir -p /usr/local/include
+sudo cp narray.so /usr/lib/libnarray.so
+sudo cp -r numo /usr/local/include/
+rm -rf /tmp/numo-narray/
+cd -

data/test.rb

@@ -0,0 +1 @@
+require "gem"

metadata

@@ -0,0 +1,81 @@
+--- !ruby/object:Gem::Specification
+name: gaussian-filter
+version: !ruby/object:Gem::Version
+  version: 0.0.3
+platform: ruby
+authors:
+- Murata Mitsuharu
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2021-09-09 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: numo-narray
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: 
+email:
+- hikari.photon+dev@gmail.com
+executables: []
+extensions:
+- ext/Gaussian/extconf.rb
+extra_rdoc_files: []
+files:
+- ".github/workflows/build.yml"
+- ".gitignore"
+- ".vscode/c_cpp_properties.json"
+- ".vscode/settings.json"
+- Gemfile
+- Gemfile.lock
+- LICENSE
+- NUMO.md
+- README.md
+- Rakefile
+- bin/console
+- bin/setup
+- ext/Gaussian/.gitignore
+- ext/Gaussian/Gaussian.c
+- ext/Gaussian/cgaussian.c
+- ext/Gaussian/extconf.rb
+- ext/Gaussian/funcp.c
+- ext/Gaussian/gaussian.h
+- ext/Gaussian/numo-gaussian.c
+- ext/Gaussian/numo-gaussian.h
+- ext/Gaussian/rmf.sh
+- gaussian-filter.gemspec
+- install-libnarray.sh
+- test.rb
+homepage: https://himeyama.github.io
+licenses: []
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- ext
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.4.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.2.1
+signing_key: 
+specification_version: 4
+summary: Gaussian Filter
+test_files: []