vdsp 1.1.0 → 1.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 50e5afc6c77efe02018bb00ac5230314720a0acfaf05b16f11d1a6c433e217bb
-  data.tar.gz: a57db55e31965d2537063e2908199b081fe9e8a9c6550e497167ef79105e5690
+  metadata.gz: 3025c810d13e2fe874cdba89cecf0a4fb8dd1c9415ddd3c45fd5871ef5d42843
+  data.tar.gz: 8db6933119c952074264f242c734d5b61b9573bd82625c42bab2b4f4af275eb9
 SHA512:
-  metadata.gz: 3621a0a8bf3ac34d55da048cf72700b366e80f61015c067c566391fa39c123b96fccbb349504db068f530c9053576615e9afe0ed33d52749926a0e48f594ce06
-  data.tar.gz: fa30615c21d524d158ff89bf242494da3d72d04bff1030cbd3fa7ea74ac61b6ec4865c2a9930584c038e7eeb475ffb112a0bfcd95feea3cce896c2a4efe66d86
+  metadata.gz: 8f0e386529e000782c005582ce7829cb5ca6ac57856a5c7053e3cac18b3dc87c2258c36f935a16d11de2c1539597ca5d2a6eab7b633f6079b43340fc46bb1b3d
+  data.tar.gz: b3ab73efc0f4f4df4c090c656f826f9bbfb693bcb04c0ecdbb548ef8307ecee111107cc4246d4230a26accaa5bb697bca460bdcbeeeadfd0022f138b1d4ab041

data/ext/vdsp/vdsp.c

@@ -467,6 +467,134 @@ VALUE rb_double_array_hann_window(int argc, VALUE *argv, VALUE cls)
   return c;
 }
 
+VALUE rb_double_array_vclr(VALUE self)
+{
+  VdspArrayNativeResource *p = get_vdsp_array_native_resource(self);
+  vDSP_vclrD(p->v.d, 1, p->length);
+  return self;
+}
+
+VALUE rb_double_array_vfill(VALUE self, VALUE a)
+{
+  double _a = NUM2DBL(a);
+  VdspArrayNativeResource *p = get_vdsp_array_native_resource(self);
+  vDSP_vfillD(&_a, p->v.d, 1, p->length);
+  return self;
+}
+
+VALUE rb_double_array_maxv(VALUE self)
+{
+  VdspArrayNativeResource *p = get_vdsp_array_native_resource(self);
+  double _c;
+  vDSP_maxvD(p->v.d, 1, &_c, p->length);
+  return DBL2NUM(_c);
+}
+
+VALUE rb_double_array_maxmgv(VALUE self)
+{
+  VdspArrayNativeResource *p = get_vdsp_array_native_resource(self);
+  double _c;
+  vDSP_maxmgvD(p->v.d, 1, &_c, p->length);
+  return DBL2NUM(_c);
+}
+
+VALUE rb_double_array_minv(VALUE self)
+{
+  VdspArrayNativeResource *p = get_vdsp_array_native_resource(self);
+  double _c;
+  vDSP_minvD(p->v.d, 1, &_c, p->length);
+  return DBL2NUM(_c);
+}
+
+VALUE rb_double_array_minmgv(VALUE self)
+{
+  VdspArrayNativeResource *p = get_vdsp_array_native_resource(self);
+  double _c;
+  vDSP_minmgvD(p->v.d, 1, &_c, p->length);
+  return DBL2NUM(_c);
+}
+
+VALUE rb_double_array_meanv(VALUE self)
+{
+  VdspArrayNativeResource *p = get_vdsp_array_native_resource(self);
+  double _c;
+  vDSP_meanvD(p->v.d, 1, &_c, p->length);
+  return DBL2NUM(_c);
+}
+
+VALUE rb_double_array_meamgv(VALUE self)
+{
+  VdspArrayNativeResource *p = get_vdsp_array_native_resource(self);
+  double _c;
+  vDSP_meamgvD(p->v.d, 1, &_c, p->length);
+  return DBL2NUM(_c);
+}
+
+VALUE rb_double_array_measqv(VALUE self)
+{
+  VdspArrayNativeResource *p = get_vdsp_array_native_resource(self);
+  double _c;
+  vDSP_measqvD(p->v.d, 1, &_c, p->length);
+  return DBL2NUM(_c);
+}
+
+VALUE rb_double_array_mvessq(VALUE self)
+{
+  VdspArrayNativeResource *p = get_vdsp_array_native_resource(self);
+  double _c;
+  vDSP_mvessqD(p->v.d, 1, &_c, p->length);
+  return DBL2NUM(_c);
+}
+
+VALUE rb_double_array_rmsqv(VALUE self)
+{
+  VdspArrayNativeResource *p = get_vdsp_array_native_resource(self);
+  double _c;
+  vDSP_rmsqvD(p->v.d, 1, &_c, p->length);
+  return DBL2NUM(_c);
+}
+
+VALUE rb_double_array_sve(VALUE self)
+{
+  VdspArrayNativeResource *p = get_vdsp_array_native_resource(self);
+  double _c;
+  vDSP_sveD(p->v.d, 1, &_c, p->length);
+  return DBL2NUM(_c);
+}
+
+VALUE rb_double_array_svemg(VALUE self)
+{
+  VdspArrayNativeResource *p = get_vdsp_array_native_resource(self);
+  double _c;
+  vDSP_svemgD(p->v.d, 1, &_c, p->length);
+  return DBL2NUM(_c);
+}
+
+VALUE rb_double_array_svesq(VALUE self)
+{
+  VdspArrayNativeResource *p = get_vdsp_array_native_resource(self);
+  double _c;
+  vDSP_svesqD(p->v.d, 1, &_c, p->length);
+  return DBL2NUM(_c);
+}
+
+VALUE rb_double_array_sve_svesq(VALUE self)
+{
+  VdspArrayNativeResource *p = get_vdsp_array_native_resource(self);
+  double _sum;
+  double _sum_of_squares;
+  vDSP_sve_svesqD(p->v.d, 1, &_sum, &_sum_of_squares, p->length);
+  return rb_assoc_new(DBL2NUM(_sum), DBL2NUM(_sum_of_squares));
+}
+
+VALUE rb_double_array_svs(VALUE self)
+{
+  VdspArrayNativeResource *p = get_vdsp_array_native_resource(self);
+  double _c;
+  vDSP_svsD(p->v.d, 1, &_c, p->length);
+  return DBL2NUM(_c);
+}
+
 
 // Vdsp static method
 
@@ -1447,6 +1575,327 @@ VALUE rb_double_hann_window(VALUE cls, VALUE c, VALUE n, VALUE flag)
   return c;
 }
 
+VALUE rb_double_vclr(
+  VALUE cls,
+  VALUE c, VALUE c_offset, VALUE c_stride,
+  VALUE n)
+{
+  VdspArrayParam _c;
+
+  array_param(&_c, c, c_offset, c_stride);
+  vDSP_Stride _n = NUM2LONG(n);
+
+  vDSP_vclrD(
+    _c.res0->v.d+_c.offset, _c.stride,
+    _n
+  );
+
+  return c;
+}
+
+VALUE rb_double_vfill(
+  VALUE cls,
+  VALUE a,
+  VALUE c, VALUE c_offset, VALUE c_stride,
+  VALUE n)
+{
+  VdspArrayParam _c;
+
+  double _a = NUM2DBL(a);
+  array_param(&_c, c, c_offset, c_stride);
+  vDSP_Stride _n = NUM2LONG(n);
+
+  vDSP_vfillD(
+    &_a,
+    _c.res0->v.d+_c.offset, _c.stride,
+    _n
+  );
+
+  return c;
+}
+
+VALUE rb_double_maxv(
+  VALUE cls,
+  VALUE a, VALUE a_offset, VALUE a_stride,
+  VALUE n)
+{
+  VdspArrayParam _a;
+  double _c;
+
+  array_param(&_a, a, a_offset, a_stride);
+  vDSP_Stride _n = NUM2LONG(n);
+
+  vDSP_maxvD(
+    _a.res0->v.d+_a.offset, _a.stride,
+    &_c,
+    _n
+  );
+
+  return DBL2NUM(_c);
+}
+
+VALUE rb_double_maxmgv(
+  VALUE cls,
+  VALUE a, VALUE a_offset, VALUE a_stride,
+  VALUE n)
+{
+  VdspArrayParam _a;
+  double _c;
+
+  array_param(&_a, a, a_offset, a_stride);
+  vDSP_Stride _n = NUM2LONG(n);
+
+  vDSP_maxmgvD(
+    _a.res0->v.d+_a.offset, _a.stride,
+    &_c,
+    _n
+  );
+
+  return DBL2NUM(_c);
+}
+
+VALUE rb_double_minv(
+  VALUE cls,
+  VALUE a, VALUE a_offset, VALUE a_stride,
+  VALUE n)
+{
+  VdspArrayParam _a;
+  double _c;
+
+  array_param(&_a, a, a_offset, a_stride);
+  vDSP_Stride _n = NUM2LONG(n);
+
+  vDSP_minvD(
+    _a.res0->v.d+_a.offset, _a.stride,
+    &_c,
+    _n
+  );
+
+  return DBL2NUM(_c);
+}
+
+VALUE rb_double_minmgv(
+  VALUE cls,
+  VALUE a, VALUE a_offset, VALUE a_stride,
+  VALUE n)
+{
+  VdspArrayParam _a;
+  double _c;
+
+  array_param(&_a, a, a_offset, a_stride);
+  vDSP_Stride _n = NUM2LONG(n);
+
+  vDSP_minmgvD(
+    _a.res0->v.d+_a.offset, _a.stride,
+    &_c,
+    _n
+  );
+
+  return DBL2NUM(_c);
+}
+
+VALUE rb_double_meanv(
+  VALUE cls,
+  VALUE a, VALUE a_offset, VALUE a_stride,
+  VALUE n)
+{
+  VdspArrayParam _a;
+  double _c;
+
+  array_param(&_a, a, a_offset, a_stride);
+  vDSP_Stride _n = NUM2LONG(n);
+
+  vDSP_meanvD(
+    _a.res0->v.d+_a.offset, _a.stride,
+    &_c,
+    _n
+  );
+
+  return DBL2NUM(_c);
+}
+
+VALUE rb_double_meamgv(
+  VALUE cls,
+  VALUE a, VALUE a_offset, VALUE a_stride,
+  VALUE n)
+{
+  VdspArrayParam _a;
+  double _c;
+
+  array_param(&_a, a, a_offset, a_stride);
+  vDSP_Stride _n = NUM2LONG(n);
+
+  vDSP_meamgvD(
+    _a.res0->v.d+_a.offset, _a.stride,
+    &_c,
+    _n
+  );
+
+  return DBL2NUM(_c);
+}
+
+VALUE rb_double_measqv(
+  VALUE cls,
+  VALUE a, VALUE a_offset, VALUE a_stride,
+  VALUE n)
+{
+  VdspArrayParam _a;
+  double _c;
+
+  array_param(&_a, a, a_offset, a_stride);
+  vDSP_Stride _n = NUM2LONG(n);
+
+  vDSP_measqvD(
+    _a.res0->v.d+_a.offset, _a.stride,
+    &_c,
+    _n
+  );
+
+  return DBL2NUM(_c);
+}
+
+VALUE rb_double_mvessq(
+  VALUE cls,
+  VALUE a, VALUE a_offset, VALUE a_stride,
+  VALUE n)
+{
+  VdspArrayParam _a;
+  double _c;
+
+  array_param(&_a, a, a_offset, a_stride);
+  vDSP_Stride _n = NUM2LONG(n);
+
+  vDSP_mvessqD(
+    _a.res0->v.d+_a.offset, _a.stride,
+    &_c,
+    _n
+  );
+
+  return DBL2NUM(_c);
+}
+
+VALUE rb_double_rmsqv(
+  VALUE cls,
+  VALUE a, VALUE a_offset, VALUE a_stride,
+  VALUE n)
+{
+  VdspArrayParam _a;
+  double _c;
+
+  array_param(&_a, a, a_offset, a_stride);
+  vDSP_Stride _n = NUM2LONG(n);
+
+  vDSP_rmsqvD(
+    _a.res0->v.d+_a.offset, _a.stride,
+    &_c,
+    _n
+  );
+
+  return DBL2NUM(_c);
+}
+
+VALUE rb_double_sve(
+  VALUE cls,
+  VALUE a, VALUE a_offset, VALUE a_stride,
+  VALUE n)
+{
+  VdspArrayParam _a;
+  double _c;
+
+  array_param(&_a, a, a_offset, a_stride);
+  vDSP_Stride _n = NUM2LONG(n);
+
+  vDSP_sveD(
+    _a.res0->v.d+_a.offset, _a.stride,
+    &_c,
+    _n
+  );
+
+  return DBL2NUM(_c);
+}
+
+VALUE rb_double_svemg(
+  VALUE cls,
+  VALUE a, VALUE a_offset, VALUE a_stride,
+  VALUE n)
+{
+  VdspArrayParam _a;
+  double _c;
+
+  array_param(&_a, a, a_offset, a_stride);
+  vDSP_Stride _n = NUM2LONG(n);
+
+  vDSP_svemgD(
+    _a.res0->v.d+_a.offset, _a.stride,
+    &_c,
+    _n
+  );
+
+  return DBL2NUM(_c);
+}
+
+VALUE rb_double_svesq(
+  VALUE cls,
+  VALUE a, VALUE a_offset, VALUE a_stride,
+  VALUE n)
+{
+  VdspArrayParam _a;
+  double _c;
+
+  array_param(&_a, a, a_offset, a_stride);
+  vDSP_Stride _n = NUM2LONG(n);
+
+  vDSP_svesqD(
+    _a.res0->v.d+_a.offset, _a.stride,
+    &_c,
+    _n
+  );
+
+  return DBL2NUM(_c);
+}
+
+VALUE rb_double_sve_svesq(
+  VALUE cls,
+  VALUE a, VALUE a_offset, VALUE a_stride,
+  VALUE n)
+{
+  VdspArrayParam _a;
+  double _sum;
+  double _sum_of_squares;
+
+  array_param(&_a, a, a_offset, a_stride);
+  vDSP_Stride _n = NUM2LONG(n);
+
+  vDSP_sve_svesqD(
+    _a.res0->v.d+_a.offset, _a.stride,
+    &_sum,
+    &_sum_of_squares,
+    _n
+  );
+
+  return rb_assoc_new(DBL2NUM(_sum), DBL2NUM(_sum_of_squares));
+}
+
+VALUE rb_double_svs(
+  VALUE cls,
+  VALUE a, VALUE a_offset, VALUE a_stride,
+  VALUE n)
+{
+  VdspArrayParam _a;
+  double _c;
+
+  array_param(&_a, a, a_offset, a_stride);
+  vDSP_Stride _n = NUM2LONG(n);
+
+  vDSP_svsD(
+    _a.res0->v.d+_a.offset, _a.stride,
+    &_c,
+    _n
+  );
+
+  return DBL2NUM(_c);
+}
+
 
 // Init
 
@@ -1488,16 +1937,42 @@ void Init_vdsp()
   rb_define_method(rb_cDoubleArray, "[]=", rb_double_array_aset, 2);
   rb_define_method(rb_cDoubleArray, "to_a", rb_double_array_get_values, 0);
   rb_define_method(rb_cDoubleArray, "coerce", rb_double_array_coerce, 1);
+
+  // Vdsp::DoubleArray Vector Generation
   rb_define_singleton_method(rb_cDoubleArray, "vramp", rb_double_array_vramp, 3);
   rb_define_singleton_method(rb_cDoubleArray, "vgen", rb_double_array_vgen, 3);
   rb_define_singleton_method(rb_cDoubleArray, "blkman_window", rb_double_array_blkman_window, -1);
   rb_define_singleton_method(rb_cDoubleArray, "hamm_window", rb_double_array_hamm_window, -1);
   rb_define_singleton_method(rb_cDoubleArray, "hann_window", rb_double_array_hann_window, -1);
 
+  // Vdsp::DoubleArray Vector Clear and Fill Functions
+  rb_define_method(rb_cDoubleArray, "vclr", rb_double_array_vclr, 0);
+  rb_define_method(rb_cDoubleArray, "vfill", rb_double_array_vfill, 1);
+
+  // Vdsp::DoubleArray Vector Extrema Calculation
+  rb_define_method(rb_cDoubleArray, "maxv", rb_double_array_maxv, 0);
+  rb_define_method(rb_cDoubleArray, "maxmgv", rb_double_array_maxmgv, 0);
+  rb_define_method(rb_cDoubleArray, "minv", rb_double_array_minv, 0);
+  rb_define_method(rb_cDoubleArray, "minmgv", rb_double_array_minmgv, 0);
+
+  // Vdsp::DoubleArray Vector Average Calculation
+  rb_define_method(rb_cDoubleArray, "meanv", rb_double_array_meanv, 0);
+  rb_define_method(rb_cDoubleArray, "meamgv", rb_double_array_meamgv, 0);
+  rb_define_method(rb_cDoubleArray, "measqv", rb_double_array_measqv, 0);
+  rb_define_method(rb_cDoubleArray, "mvessq", rb_double_array_mvessq, 0);
+  rb_define_method(rb_cDoubleArray, "rmsqv", rb_double_array_rmsqv, 0);
+
+  // Vdsp::DoubleArray Vector Summation
+  rb_define_method(rb_cDoubleArray, "sve", rb_double_array_sve, 0);
+  rb_define_method(rb_cDoubleArray, "svemg", rb_double_array_svemg, 0);
+  rb_define_method(rb_cDoubleArray, "svesq", rb_double_array_svesq, 0);
+  rb_define_method(rb_cDoubleArray, "sve_svesq", rb_double_array_sve_svesq, 0);
+  rb_define_method(rb_cDoubleArray, "svs", rb_double_array_svs, 0);
+
   // Vdsp::UnsafeDouble
   rb_mUnsafeDouble = rb_define_module_under(rb_mVdsp, "UnsafeDouble");
 
-  // Vector-based Arithmetic
+  // Vdsp::UnsafeDouble Vector-based Arithmetic
   rb_define_singleton_method(rb_mUnsafeDouble, "vsadd", rb_double_vsadd, 8);
   rb_define_singleton_method(rb_mUnsafeDouble, "vadd", rb_double_vadd, 10);
   rb_define_singleton_method(rb_mUnsafeDouble, "vsub", rb_double_vsub, 10);
@@ -1521,7 +1996,7 @@ void Init_vdsp()
   rb_define_singleton_method(rb_mUnsafeDouble, "vsbsbm", rb_double_vsbsbm, -1);
   rb_define_singleton_method(rb_mUnsafeDouble, "vasbm", rb_double_vasbm, -1);
 
-  // Vector Generation
+  // Vdsp::UnsafeDouble Vector Generation
   rb_define_singleton_method(rb_mUnsafeDouble, "vramp", rb_double_vramp, 6);
   rb_define_singleton_method(rb_mUnsafeDouble, "vgen", rb_double_vgen, 6);
   rb_define_singleton_method(rb_mUnsafeDouble, "vrampmul", rb_double_vrampmul, 9);
@@ -1533,4 +2008,28 @@ void Init_vdsp()
   rb_define_singleton_method(rb_mUnsafeDouble, "blkman_window", rb_double_blkman_window, 3);
   rb_define_singleton_method(rb_mUnsafeDouble, "hamm_window", rb_double_hamm_window, 3);
   rb_define_singleton_method(rb_mUnsafeDouble, "hann_window", rb_double_hann_window, 3);
+
+  // Vdsp::UnsafeDouble Vector Clear and Fill Functions
+  rb_define_singleton_method(rb_mUnsafeDouble, "vclr", rb_double_vclr, 4);
+  rb_define_singleton_method(rb_mUnsafeDouble, "vfill", rb_double_vfill, 5);
+
+  // Vdsp::UnsafeDouble Vector Extrema Calculation
+  rb_define_singleton_method(rb_mUnsafeDouble, "maxv", rb_double_maxv, 4);
+  rb_define_singleton_method(rb_mUnsafeDouble, "maxmgv", rb_double_maxmgv, 4);
+  rb_define_singleton_method(rb_mUnsafeDouble, "minv", rb_double_minv, 4);
+  rb_define_singleton_method(rb_mUnsafeDouble, "minmgv", rb_double_minmgv, 4);
+
+  // Vdsp::UnsafeDouble Vector Average Calculation
+  rb_define_singleton_method(rb_mUnsafeDouble, "meanv", rb_double_meanv, 4);
+  rb_define_singleton_method(rb_mUnsafeDouble, "meamgv", rb_double_meamgv, 4);
+  rb_define_singleton_method(rb_mUnsafeDouble, "measqv", rb_double_measqv, 4);
+  rb_define_singleton_method(rb_mUnsafeDouble, "mvessq", rb_double_mvessq, 4);
+  rb_define_singleton_method(rb_mUnsafeDouble, "rmsqv", rb_double_rmsqv, 4);
+
+  // Vdsp::UnsafeDouble Vector Summation
+  rb_define_singleton_method(rb_mUnsafeDouble, "sve", rb_double_sve, 4);
+  rb_define_singleton_method(rb_mUnsafeDouble, "svemg", rb_double_svemg, 4);
+  rb_define_singleton_method(rb_mUnsafeDouble, "svesq", rb_double_svesq, 4);
+  rb_define_singleton_method(rb_mUnsafeDouble, "sve_svesq", rb_double_sve_svesq, 4);
+  rb_define_singleton_method(rb_mUnsafeDouble, "svs", rb_double_svs, 4);
 }

data/lib/vdsp/version.rb

@@ -1,3 +1,3 @@
 module Vdsp
-  VERSION = "1.1.0"
+  VERSION = "1.2.0"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: vdsp
 version: !ruby/object:Gem::Version
-  version: 1.1.0
+  version: 1.2.0
 platform: ruby
 authors:
 - yoshida