ryeppp 0.0.5 → 0.0.6

data/ext/templates/ryeppp.c.rb

@@ -142,14 +142,14 @@ VALUE cRyeppp;
 FUNCS = Proc.new do |verb_name|
 %{#{if verb_name == 'Multiply'
       typed_variants(%{
-        static VALUE multiply_v64{{type}}s64{{type}}_v64{{type}}(VALUE self, VALUE x, VALUE multiply_by) {
+        static VALUE multiply_iv64{{type}}s64{{type}}_iv64{{type}}(VALUE self, VALUE x, VALUE multiply_by) {
           enum YepStatus status;
           long i;
           VALUE new_ary;
           VALUE *x_a;
           long l;
           Yep64{{type}} mult_by;
-          #{declare_yep64_typed_array(%w{x y})}
+          #{declare_yep64_typed_array(%w{x})}
         
           #{ensure_array_argument('x', 'first')}
           if (TYPE(multiply_by) != T_FIXNUM && TYPE(multiply_by) != T_BIGNUM && TYPE(multiply_by) != T_FLOAT) {
@@ -161,21 +161,21 @@ FUNCS = Proc.new do |verb_name|
           mult_by = (Yep64{{type}})NUM2DBL(multiply_by);
 
           /* Allocate arrays of inputs and outputs */
-          #{allocate_yep64_typed_array(%w{x y}, 'l')}
+          #{allocate_yep64_typed_array(%w{x}, 'l')}
           
           #{initialize_yeppp}
         
-          #{load_ruby_array_into_yeppp_array_parameterized('x', 'i', 'l', :allocated_arrays => %w{x y})}
+          #{load_ruby_array_into_yeppp_array_parameterized('x', 'i', 'l', :allocated_arrays => %w{x})}
         
           /* Perform the operation */
-          status = yepCore_Multiply_V64{{type}}S64{{type}}_V64{{type}}(yep_x, mult_by, yep_y, (YepSize)l);
+          status = yepCore_Multiply_IV64{{type}}S64{{type}}_IV64{{type}}(yep_x, mult_by, (YepSize)l);
           assert(status == YepStatusOk);
 
-          #{load_ruby_array_from_yeppp_array_parameterized('y', 'i', 'l')}
+          #{load_ruby_array_from_yeppp_array_parameterized('x', 'i', 'l')}
         
           #{deinitialize_yeppp}
           
-          #{release_array_memory(%w{x y})}
+          #{release_array_memory(%w{x})}
           
           return new_ary;
         }
@@ -185,14 +185,14 @@ FUNCS = Proc.new do |verb_name|
 
   #{typed_variants(%{
     // #{verb_name} Arrays of Fixnums.
-    static VALUE #{verb_name.downcase}_v64{{type}}v64{{type}}_v64{{type}}(VALUE self, VALUE x, VALUE y) {
+    static VALUE #{verb_name.downcase}_iv64{{type}}v64{{type}}_iv64{{type}}(VALUE self, VALUE x, VALUE y) {
       enum YepStatus status;
       VALUE new_ary;
       long i;
       VALUE *x_a;
       VALUE *y_a;
       long l;
-      #{declare_yep64_typed_array(%w{x y z})}
+      #{declare_yep64_typed_array(%w{x y})}
     
       #{ensure_array_argument('x', 'first')}
       #{ensure_array_argument('y', 'second')}
@@ -202,22 +202,22 @@ FUNCS = Proc.new do |verb_name|
       l = RARRAY_LEN(x);
 
       /* Allocate arrays of inputs and outputs */
-      #{allocate_yep64_typed_array(%w{x y z}, 'l')}
+      #{allocate_yep64_typed_array(%w{x y}, 'l')}
 
       #{initialize_yeppp}
     
-      #{load_ruby_array_into_yeppp_array_parameterized('x', 'i', 'l', :allocated_arrays => %w{x y z})}
-      #{load_ruby_array_into_yeppp_array_parameterized('y', 'i', 'l', :allocated_arrays => %w{x y z})}
+      #{load_ruby_array_into_yeppp_array_parameterized('x', 'i', 'l', :allocated_arrays => %w{x y})}
+      #{load_ruby_array_into_yeppp_array_parameterized('y', 'i', 'l', :allocated_arrays => %w{x y})}
     
       /* Perform the #{verb_name} */
-      status = yepCore_#{verb_name}_V64{{type}}V64{{type}}_V64{{type}}(yep_x, yep_y, yep_z, (YepSize)l);
+      status = yepCore_#{verb_name}_IV64{{type}}V64{{type}}_IV64{{type}}(yep_x, yep_y, (YepSize)l);
       assert(status == YepStatusOk);
 
-      #{load_ruby_array_from_yeppp_array_parameterized('z', 'i', 'l')}
+      #{load_ruby_array_from_yeppp_array_parameterized('x', 'i', 'l')}
     
       #{deinitialize_yeppp}
     
-      #{release_array_memory(%w{x y z})}
+      #{release_array_memory(%w{x y})}
 
       return new_ary;
     }
@@ -302,14 +302,14 @@ end.join("\n\n"))
 PAIRWISE_MIN_MAX = typed_variants(%w{Min Max}.map do |kind|
   %{
     // Get the pairwise #{kind.downcase}ima from Arrays.
-    static VALUE #{kind.downcase}_v64{{type}}v64{{type}}_v64{{type}}(VALUE self, VALUE x, VALUE y) {
+    static VALUE #{kind.downcase}_iv64{{type}}v64{{type}}_iv64{{type}}(VALUE self, VALUE x, VALUE y) {
       enum YepStatus status;
       long i;
       VALUE new_ary;
       VALUE *x_a;
       VALUE *y_a;
       long l;
-      #{declare_yep64_typed_array(%w{x y z})}
+      #{declare_yep64_typed_array(%w{x y})}
       
       #{ensure_array_argument('x', 'first')}
       #{ensure_array_argument('y', 'second')}
@@ -319,22 +319,22 @@ PAIRWISE_MIN_MAX = typed_variants(%w{Min Max}.map do |kind|
       l = RARRAY_LEN(x);
 
       /* Allocate arrays of inputs and outputs */
-      #{allocate_yep64_typed_array(%w{x y z}, 'l')}
+      #{allocate_yep64_typed_array(%w{x y}, 'l')}
 
       #{initialize_yeppp}
   
-      #{load_ruby_array_into_yeppp_array_parameterized('x', 'i', 'l', :allocated_arrays => %w{x y z})}
-      #{load_ruby_array_into_yeppp_array_parameterized('y', 'i', 'l', :allocated_arrays => %w{x y z})}
+      #{load_ruby_array_into_yeppp_array_parameterized('x', 'i', 'l', :allocated_arrays => %w{x y})}
+      #{load_ruby_array_into_yeppp_array_parameterized('y', 'i', 'l', :allocated_arrays => %w{x y})}
   
       /* Perform the operation */
-      status = yepCore_#{kind}_V64{{type}}V64{{type}}_V64{{type}}(yep_x, yep_y, yep_z, (YepSize)l);
+      status = yepCore_#{kind}_IV64{{type}}V64{{type}}_IV64{{type}}(yep_x, yep_y, (YepSize)l);
       assert(status == YepStatusOk);
 
-      #{load_ruby_array_from_yeppp_array_parameterized('z', 'i', 'l')}
+      #{load_ruby_array_from_yeppp_array_parameterized('x', 'i', 'l')}
 
       #{deinitialize_yeppp}
   
-      #{release_array_memory(%w{x y z})}
+      #{release_array_memory(%w{x y})}
    
       return new_ary;
     }
@@ -344,14 +344,14 @@ end.join("\n\n"), :only_type => 'f')
 CONSTANT_MIN_MAX = typed_variants(%w{Min Max}.map do |kind|
   %{
     // Get the #{kind.downcase}ima from an Array and a constant.
-    static VALUE #{kind.downcase}_v64{{type}}s64{{type}}_v64{{type}}(VALUE self, VALUE x, VALUE c) {
+    static VALUE #{kind.downcase}_iv64{{type}}s64{{type}}_iv64{{type}}(VALUE self, VALUE x, VALUE c) {
       enum YepStatus status;
       long i;
       VALUE new_ary;
       VALUE *x_a;
       long l;
       Yep64f konst;
-      #{declare_yep64_typed_array(%w{x y})}
+      #{declare_yep64_typed_array(%w{x})}
   
       #{ensure_array_argument('x', 'first')}
       if (TYPE(c) != T_FIXNUM && TYPE(c) != T_BIGNUM && TYPE(c) != T_FLOAT) {
@@ -363,21 +363,21 @@ CONSTANT_MIN_MAX = typed_variants(%w{Min Max}.map do |kind|
       konst = (Yep64f)NUM2{{ruby_type}}(c);
 
       /* Allocate arrays of inputs and outputs */
-      #{allocate_yep64_typed_array(%w{x y}, 'l')}
+      #{allocate_yep64_typed_array(%w{x}, 'l')}
 
       #{initialize_yeppp}
   
-      #{load_ruby_array_into_yeppp_array_parameterized('x', 'i', 'l', :allocated_arrays => %w{x y})}
+      #{load_ruby_array_into_yeppp_array_parameterized('x', 'i', 'l', :allocated_arrays => %w{x})}
   
       /* Perform the operation */
-      status = yepCore_#{kind}_V64{{type}}S64{{type}}_V64{{type}}(yep_x, konst, yep_y, (YepSize)l);
+      status = yepCore_#{kind}_IV64{{type}}S64{{type}}_IV64{{type}}(yep_x, konst, (YepSize)l);
       assert(status == YepStatusOk);
 
-      #{load_ruby_array_from_yeppp_array_parameterized('y', 'i', 'l')}
+      #{load_ruby_array_from_yeppp_array_parameterized('x', 'i', 'l')}
 
       #{deinitialize_yeppp}
   
-      #{release_array_memory(%w{x y})}
+      #{release_array_memory(%w{x})}
    
       return new_ary;
     }
@@ -386,13 +386,13 @@ end.join("\n\n"), :only_type => 'f')
 
 NEGATE = typed_variants(%{
   // Negate an Array.
-  static VALUE negate_v64{{type}}_s64{{type}}(VALUE self, VALUE x) {
+  static VALUE negate_iv64{{type}}_is64{{type}}(VALUE self, VALUE x) {
     enum YepStatus status;
     long i;
     VALUE new_ary;
     VALUE *x_a;
     long l;
-    #{declare_yep64_typed_array(%w{x y})}
+    #{declare_yep64_typed_array(%w{x})}
 
     #{ensure_array_argument('x', 'first')}
 
@@ -400,21 +400,21 @@ NEGATE = typed_variants(%{
     l = RARRAY_LEN(x);
 
     /* Allocate arrays of inputs and outputs */
-    #{allocate_yep64_typed_array(%w{x y}, 'l')}
+    #{allocate_yep64_typed_array(%w{x}, 'l')}
   
     #{initialize_yeppp}
   
-    #{load_ruby_array_into_yeppp_array_parameterized('x', 'i', 'l', :allocated_arrays => %w{x y})}
+    #{load_ruby_array_into_yeppp_array_parameterized('x', 'i', 'l', :allocated_arrays => %w{x})}
   
     /* Perform the negation */
-    status = yepCore_Negate_V64{{type}}_V64{{type}}(yep_x, yep_y, (YepSize)l);
+    status = yepCore_Negate_IV64{{type}}_IV64{{type}}(yep_x, (YepSize)l);
     assert(status == YepStatusOk);
   
-    #{load_ruby_array_from_yeppp_array_parameterized('y', 'i', 'l')}
+    #{load_ruby_array_from_yeppp_array_parameterized('x', 'i', 'l')}
   
     #{deinitialize_yeppp}
   
-    #{release_array_memory(%w{x y})}
+    #{release_array_memory(%w{x})}
    
     return new_ary;
   }
@@ -545,18 +545,18 @@ void Init_ryeppp() {
   cRyeppp = rb_define_class("Ryeppp", rb_cObject);
 
   /* Addition */
-  rb_define_singleton_method(cRyeppp, "add_v64fv64f_v64f", add_v64fv64f_v64f, 2);
-  rb_define_singleton_method(cRyeppp, "add_v64sv64s_v64s", add_v64sv64s_v64s, 2);
+  rb_define_singleton_method(cRyeppp, "add_v64fv64f_v64f", add_iv64fv64f_iv64f, 2);
+  rb_define_singleton_method(cRyeppp, "add_v64sv64s_v64s", add_iv64sv64s_iv64s, 2);
 
   /* Subtraction */
-  rb_define_singleton_method(cRyeppp, "subtract_v64fv64f_v64f", subtract_v64fv64f_v64f, 2);
-  rb_define_singleton_method(cRyeppp, "subtract_v64sv64s_v64s", subtract_v64sv64s_v64s, 2);
+  rb_define_singleton_method(cRyeppp, "subtract_v64fv64f_v64f", subtract_iv64fv64f_iv64f, 2);
+  rb_define_singleton_method(cRyeppp, "subtract_v64sv64s_v64s", subtract_iv64sv64s_iv64s, 2);
 
   /* Multiplication */
-  rb_define_singleton_method(cRyeppp, "multiply_v64fs64f_v64f", multiply_v64fs64f_v64f, 2);
-  rb_define_singleton_method(cRyeppp, "multiply_v64sv64s_v64s", multiply_v64sv64s_v64s, 2);
-  rb_define_singleton_method(cRyeppp, "multiply_v64fv64f_v64f", multiply_v64fv64f_v64f, 2);
-  rb_define_singleton_method(cRyeppp, "multiply_v64ss64s_v64s", multiply_v64ss64s_v64s, 2);
+  rb_define_singleton_method(cRyeppp, "multiply_v64fs64f_v64f", multiply_iv64fs64f_iv64f, 2);
+  rb_define_singleton_method(cRyeppp, "multiply_v64sv64s_v64s", multiply_iv64sv64s_iv64s, 2);
+  rb_define_singleton_method(cRyeppp, "multiply_v64fv64f_v64f", multiply_iv64fv64f_iv64f, 2);
+  rb_define_singleton_method(cRyeppp, "multiply_v64ss64s_v64s", multiply_iv64ss64s_iv64s, 2);
 
   /* Dot Product */
   rb_define_singleton_method(cRyeppp, "dotproduct_v64fv64f_s64f", dotproduct_v64fv64f_s64f, 2);
@@ -570,24 +570,24 @@ void Init_ryeppp() {
   rb_define_singleton_method(cRyeppp, "max_v64s_s64s", max_v64s_s64s, 1);
 
   /* Pairwise Minima */
-  rb_define_singleton_method(cRyeppp, "min_v64fv64f_v64f", min_v64fv64f_v64f, 2);
+  rb_define_singleton_method(cRyeppp, "min_v64fv64f_v64f", min_iv64fv64f_iv64f, 2);
   // Pairwise signed min is not available.
 
   /* Pairwise Maxima */
-  rb_define_singleton_method(cRyeppp, "max_v64fv64f_v64f", max_v64fv64f_v64f, 2);
+  rb_define_singleton_method(cRyeppp, "max_v64fv64f_v64f", max_iv64fv64f_iv64f, 2);
   // Pairwise signed max is not available.
 
   /* Constant Minima */
-  rb_define_singleton_method(cRyeppp, "min_v64fs64f_v64f", min_v64fs64f_v64f, 2);
+  rb_define_singleton_method(cRyeppp, "min_v64fs64f_v64f", min_iv64fs64f_iv64f, 2);
   // Constant signed min is not available.
 
   /* Constant Maxima */
-  rb_define_singleton_method(cRyeppp, "max_v64fs64f_v64f", max_v64fs64f_v64f, 2);
+  rb_define_singleton_method(cRyeppp, "max_v64fs64f_v64f", max_iv64fs64f_iv64f, 2);
   // Constant signed max is not available.
 
   /* Negation */
-  rb_define_singleton_method(cRyeppp, "negate_v64f_s64f", negate_v64f_s64f, 1);
-  rb_define_singleton_method(cRyeppp, "negate_v64s_s64s", negate_v64s_s64s, 1);
+  rb_define_singleton_method(cRyeppp, "negate_v64f_s64f", negate_iv64f_is64f, 1);
+  rb_define_singleton_method(cRyeppp, "negate_v64s_s64s", negate_iv64s_is64s, 1);
 
   /* Sums */
   rb_define_singleton_method(cRyeppp, "sum_v64f_s64f", sum_v64f_s64f, 1);

data/lib/ryeppp/bench.rb

@@ -11,6 +11,260 @@ def puts_with_pounds(s)
 end
 
 class Array
+  def min_v64f_s64f
+    self.inject(self[0]){|minimum, o| o < minimum ? o : minimum}
+  end
+  alias_method :min_v64s_s64s, :min_v64f_s64f
+  def max_v64f_s64f
+    self.inject(self[0]){|maximum, o| o > maximum ? o : maximum}
+  end
+  alias_method :max_v64s_s64s, :max_v64f_s64f
+  inline do |builder|
+    builder.c %{
+      static VALUE c_min_v64f_s64f() {
+        long n = RARRAY_LEN(self);
+        VALUE *x_a = RARRAY_PTR(self);
+        double minimum = x_a[0];
+      
+        long i;
+        for (i=1; i<n; i++) {
+          if (TYPE(x_a[i]) != T_FIXNUM && TYPE(x_a[i]) != T_BIGNUM && TYPE(x_a[i]) != T_FLOAT) {
+            rb_raise(rb_eTypeError, "input was not all integers and floats");
+          }
+          if (NUM2DBL(x_a[i]) < minimum) {
+            minimum = NUM2DBL(x_a[i]);
+          }
+        }
+        return DBL2NUM(minimum);
+      }
+    }
+    inline do |builder|
+      builder.c %{
+        static VALUE c_min_v64s_s64s() {
+          long n = RARRAY_LEN(self);
+          VALUE *x_a = RARRAY_PTR(self);
+          long minimum = x_a[0];
+        
+          long i;
+          for (i=1; i<n; i++) {
+            if (TYPE(x_a[i]) != T_FIXNUM && TYPE(x_a[i]) != T_BIGNUM && TYPE(x_a[i]) != T_FLOAT) {
+              rb_raise(rb_eTypeError, "input was not all integers and floats");
+            }
+            if (NUM2LONG(x_a[i]) < minimum) {
+              minimum = NUM2LONG(x_a[i]);
+            }
+          }
+          return LONG2NUM(minimum);
+        }
+      }
+    end
+    builder.c %{
+      static VALUE c_max_v64f_s64f() {
+        long n = RARRAY_LEN(self);
+        VALUE *x_a = RARRAY_PTR(self);
+        double maximum = x_a[0];
+      
+        long i;
+        for (i=1; i<n; i++) {
+          if (TYPE(x_a[i]) != T_FIXNUM && TYPE(x_a[i]) != T_BIGNUM && TYPE(x_a[i]) != T_FLOAT) {
+            rb_raise(rb_eTypeError, "input was not all integers and floats");
+          }
+          if (NUM2DBL(x_a[i]) > maximum) {
+            maximum = NUM2DBL(x_a[i]);
+          }
+        }
+        return DBL2NUM(maximum);
+      }
+    }
+    inline do |builder|
+      builder.c %{
+        static VALUE c_max_v64s_s64s() {
+          long n = RARRAY_LEN(self);
+          VALUE *x_a = RARRAY_PTR(self);
+          long maximum = x_a[0];
+        
+          long i;
+          for (i=1; i<n; i++) {
+            if (TYPE(x_a[i]) != T_FIXNUM && TYPE(x_a[i]) != T_BIGNUM && TYPE(x_a[i]) != T_FLOAT) {
+              rb_raise(rb_eTypeError, "input was not all integers and floats");
+            }
+            if (NUM2LONG(x_a[i]) > maximum) {
+              maximum = NUM2LONG(x_a[i]);
+            }
+          }
+          return LONG2NUM(maximum);
+        }
+      }
+    end
+  end
+
+  def min_v64fv64f_v64f(b)
+    raise "Invalid sizes: #{self.size}, #{b.size}" unless self.size == b.size
+    self.zip(b).map(&:min)
+  end
+  def max_v64fv64f_v64f(b)
+    raise "Invalid sizes: #{self.size}, #{b.size}" unless self.size == b.size
+    self.zip(b).map(&:max)
+  end
+  inline do |builder|
+    builder.c %{
+      static VALUE c_min_v64fv64f_v64f(VALUE b) {
+        long n = RARRAY_LEN(self);
+        VALUE *x_a = RARRAY_PTR(self);
+        VALUE *x_b = RARRAY_PTR(b);
+        VALUE new_ary = rb_ary_new2(n);
+      
+        long i;
+
+        if (n != RARRAY_LEN(b)) {
+          rb_raise(rb_eArgError, "mismatched Array sizes");
+        }
+        for (i=0; i<n; i++) {
+          rb_ary_push(new_ary, (NUM2DBL(x_a[i]) < NUM2DBL(x_b[i])) ? x_a[i] : x_b[i]);
+        }
+        return new_ary;
+      }
+    }
+    builder.c %{
+      static VALUE c_max_v64fv64f_v64f(VALUE b) {
+        long n = RARRAY_LEN(self);
+        VALUE *x_a = RARRAY_PTR(self);
+        VALUE *x_b = RARRAY_PTR(b);
+        VALUE new_ary = rb_ary_new2(n);
+      
+        long i;
+
+        if (n != RARRAY_LEN(b)) {
+          rb_raise(rb_eArgError, "mismatched Array sizes");
+        }
+        for (i=0; i<n; i++) {
+          rb_ary_push(new_ary, (NUM2DBL(x_a[i]) > NUM2DBL(x_b[i])) ? x_a[i] : x_b[i]);
+        }
+        return new_ary;
+      }
+    }
+  end
+  def min_v64fs64f_v64f(c)
+    self.map{|o| o < c ? o : c}
+  end
+  def max_v64fs64f_v64f(c)
+    self.map{|o| o > c ? o : c}
+  end
+  inline do |builder|
+    builder.c %{
+      static VALUE c_min_v64fs64f_v64f(VALUE c) {
+        long n = RARRAY_LEN(self);
+        VALUE *x_a = RARRAY_PTR(self);
+        double konst = NUM2DBL(c);
+        VALUE new_ary = rb_ary_new2(n);
+      
+        long i;
+        for (i=0; i<n; i++) {
+          rb_ary_push(new_ary, (NUM2DBL(x_a[i]) < konst) ? x_a[i] : c);
+        }
+        return new_ary;
+      }
+    }
+    builder.c %{
+      static VALUE c_max_v64fs64f_v64f(VALUE c) {
+        long n = RARRAY_LEN(self);
+        VALUE *x_a = RARRAY_PTR(self);
+        double konst = NUM2DBL(c);
+        VALUE new_ary = rb_ary_new2(n);
+      
+        long i;
+        for (i=0; i<n; i++) {
+          rb_ary_push(new_ary, (NUM2DBL(x_a[i]) > konst) ? x_a[i] : c);
+        }
+        return new_ary;
+      }
+    }
+  end
+
+  def log
+    self.map{|o| Math.log(o)}
+  end
+  def exp
+    self.map{|o| Math::E ** o}
+  end
+  def sin
+    self.map{|o| Math.sin(o)}
+  end
+  def cos
+    self.map{|o| Math.cos(o)}
+  end
+  def tan
+    self.map{|o| Math.tan(o)}
+  end
+  inline do |builder|
+    builder.include('<math.h>')
+    builder.c %{
+      static VALUE c_log() {
+        long n = RARRAY_LEN(self);
+        VALUE *x_a = RARRAY_PTR(self);
+        VALUE new_ary = rb_ary_new2(n);
+      
+        long i;
+        for (i=0; i<n; i++) {
+          rb_ary_push(new_ary, DBL2NUM(log(NUM2DBL(x_a[i]))));
+        }
+        return new_ary;
+      }
+    }
+    builder.c %{
+      static VALUE c_exp() {
+        long n = RARRAY_LEN(self);
+        VALUE *x_a = RARRAY_PTR(self);
+        VALUE new_ary = rb_ary_new2(n);
+      
+        long i;
+        for (i=0; i<n; i++) {
+          rb_ary_push(new_ary, DBL2NUM(pow(2.717, NUM2DBL(x_a[i]))));
+        }
+        return new_ary;
+      }
+    }
+    builder.c %{
+      static VALUE c_sin() {
+        long n = RARRAY_LEN(self);
+        VALUE *x_a = RARRAY_PTR(self);
+        VALUE new_ary = rb_ary_new2(n);
+      
+        long i;
+        for (i=0; i<n; i++) {
+          rb_ary_push(new_ary, DBL2NUM(sin(NUM2DBL(x_a[i]))));
+        }
+        return new_ary;
+      }
+    }
+    builder.c %{
+      static VALUE c_cos() {
+        long n = RARRAY_LEN(self);
+        VALUE *x_a = RARRAY_PTR(self);
+        VALUE new_ary = rb_ary_new2(n);
+      
+        long i;
+        for (i=0; i<n; i++) {
+          rb_ary_push(new_ary, DBL2NUM(cos(NUM2DBL(x_a[i]))));
+        }
+        return new_ary;
+      }
+    }
+    builder.c %{
+      static VALUE c_tan() {
+        long n = RARRAY_LEN(self);
+        VALUE *x_a = RARRAY_PTR(self);
+        VALUE new_ary = rb_ary_new2(n);
+      
+        long i;
+        for (i=0; i<n; i++) {
+          rb_ary_push(new_ary, DBL2NUM(tan(NUM2DBL(x_a[i]))));
+        }
+        return new_ary;
+      }
+    }
+  end
+
   def sum
     self.inject(0){|sum, o| sum + o}
   end
@@ -191,8 +445,10 @@ class Array
   end
 end
 
+K = Random.rand
 WIDTH = 40
 V_f = (0..1_024*1_024).to_a.map{Random.rand}
+V_s = (0..1_024*1_024).to_a.map{Random.rand(1_024)}
 
 # Dot Product
 puts_with_pounds "Dot Product"
@@ -208,6 +464,32 @@ Benchmark.bm(WIDTH) do |x|
   x.report("Ryeppp.dotproduct_v64fv64f_s64f:") { n.times { Ryeppp.dotproduct_v64fv64f_s64f(V_f, V_f) } }
 end
 
+# Min and Max
+puts_with_pounds "Min and Max"
+Benchmark.bm(WIDTH) do |x|
+  %w{min max}.each do |prefix|
+    x.report("#{prefix}_v64f_s64f:")        { n.times { V_f.send("#{prefix}_v64f_s64f") } }
+    x.report("#{prefix}_v64s_s64s:")        { n.times { V_s.send("#{prefix}_v64s_s64s") } }
+    x.report("c_#{prefix}_v64f_s64f:")      { n.times { V_f.send("c_#{prefix}_v64f_s64f") } }
+    x.report("c_#{prefix}_v64s_s64s:")      { n.times { V_s.send("c_#{prefix}_v64s_s64s") } }
+    x.report("Ryeppp.#{prefix}_v64f_s64f:") { n.times { Ryeppp.send("#{prefix}_v64f_s64f", V_f) } }
+    x.report("Ryeppp.#{prefix}_v64s_s64s:") { n.times { Ryeppp.send("#{prefix}_v64s_s64s", V_s) } }
+  end
+end
+
+# Pairwise Min and Max
+puts_with_pounds "Pairwise Min and Max"
+Benchmark.bm(WIDTH) do |x|
+  %w{min max}.each do |prefix|
+    x.report("#{prefix}_v64fv64f_v64f:")          { n.times { V_f.send("#{prefix}_v64fv64f_v64f", V_f) } }
+    x.report("c_#{prefix}_v64fv64f_v64f:")        { n.times { V_f.send("c_#{prefix}_v64fv64f_v64f", V_f) } }
+    x.report("Ryeppp.#{prefix}_v64fv64f_v64f:")   { n.times { Ryeppp.send("#{prefix}_v64fv64f_v64f", V_f, V_f) } }
+    x.report("#{prefix}_v64fs64f_v64f:")          { n.times { V_f.send("#{prefix}_v64fs64f_v64f", K) } }
+    x.report("c_#{prefix}_v64fs64f_v64f:")        { n.times { V_f.send("c_#{prefix}_v64fs64f_v64f", K) } }
+    x.report("Ryeppp.#{prefix}_v64fs64f_v64f:")   { n.times { Ryeppp.send("#{prefix}_v64fs64f_v64f", V_f, K) } }
+  end
+end
+
 # Sums
 puts_with_pounds "Sums"
 n = 1
@@ -224,7 +506,8 @@ puts_with_pounds "Math Functions"
 n = 1
 Benchmark.bm(WIDTH) do |x|
   %w{log exp sin cos tan}.each do |f|
-    x.report("#{f}:")                  { n.times { V_f.each{|o| Math.send(f, o)} } }
+    x.report("#{f}:")                  { n.times { V_f.send(f) } }
+    x.report("c_#{f}:")                { n.times { V_f.send("c_#{f}") } }
     x.report("Ryeppp.#{f}_v64f_v64f:") { n.times { Ryeppp.send("#{f}_v64f_v64f", V_f) } }
   end
 end

data/lib/ryeppp/version.rb

@@ -1,3 +1,3 @@
 class Ryeppp
-  VERSION = "0.0.5"
+  VERSION = "0.0.6"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: ryeppp
 version: !ruby/object:Gem::Version
-  version: 0.0.5
+  version: 0.0.6
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-09-25 00:00:00.000000000 Z
+date: 2013-10-06 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler