ryeppp 0.0.1 → 0.0.2

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: ryeppp
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.0.2
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-09-21 00:00:00.000000000 Z
+date: 2013-09-24 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -75,6 +75,38 @@ dependencies:
     - - ! '>='
       - !ruby/object:Gem::Version
         version: 2.13.0
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 2.13.0
+  prerelease: false
+  type: :development
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 2.13.0
+- !ruby/object:Gem::Dependency
+  name: RubyInline
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 3.12.2
+  prerelease: false
+  type: :development
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 3.12.2
 description: This gem provides bindings to the Yeppp! library. According to the documentation,
   "Yeppp! is a high-performance SIMD-optimized mathematical library for x86, ARM,
   and MIPS processors on Windows, Android, Mac OS X, and GNU/Linux systems."
@@ -85,19 +117,7 @@ extensions:
 - ext/ryeppp/extconf.rb
 extra_rdoc_files: []
 files:
-- .gitignore
-- .rspec
-- Gemfile
-- LICENSE.txt
-- README.md
-- Rakefile
 - ext/ryeppp/extconf.rb
-- ext/templates/ryeppp.c.rb
-- lib/ryeppp.rb
-- lib/ryeppp/version.rb
-- ryeppp.gemspec
-- spec/ryeppp_spec.rb
-- spec/spec_helper.rb
 homepage: https://github.com/bradcater/ruby-yeppp
 licenses:
 - MIT
@@ -123,6 +143,4 @@ rubygems_version: 1.8.25
 signing_key: 
 specification_version: 3
 summary: This gem provides bindings to the Yeppp! library.
-test_files:
-- spec/ryeppp_spec.rb
-- spec/spec_helper.rb
+test_files: []

data/.gitignore

@@ -1,20 +0,0 @@
-*.gem
-*.rbc
-*.so
-*.swp
-.bundle
-.config
-.yardoc
-Gemfile.lock
-InstalledFiles
-_yardoc
-coverage
-doc/
-lib/bundler/man
-pkg
-rdoc
-spec/reports
-test/tmp
-test/version_tmp
-tmp
-ext/ryeppp/ryeppp.c

data/.rspec

@@ -1,2 +0,0 @@
---color
---format progress

data/Gemfile

@@ -1,4 +0,0 @@
-source 'https://rubygems.org'
-
-# Specify your gem's dependencies in ryeppp.gemspec
-gemspec

data/LICENSE.txt

@@ -1,22 +0,0 @@
-Copyright (c) 2013 TODO: Write your name
-
-MIT License
-
-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/README.md

@@ -1,88 +0,0 @@
-# Ryeppp
-
-This gem provides bindings to the [Yeppp!](http://www.yeppp.info/) library.
-According to the documentation, "Yeppp! is a high-performance SIMD-optimized
-mathematical library for x86, ARM, and MIPS processors on Windows, Android, Mac
-OS X, and GNU/Linux systems."
-
-## Installation
-
-Add this line to your application's Gemfile:
-
-    gem 'ryeppp'
-
-And then execute:
-
-    $ bundle
-
-Or install it yourself as:
-
-    $ gem install ryeppp
-
-You'll also need to [download](http://www.yeppp.info/downloads.html) the Yeppp!
-library and unpack it in $HOME.
-
-## Usage
-
-The Ryeppp gem provides a single class `Ryeppp` with the following methods:
-
-* `add_v64fv64f_v64f` - pairwise add 2 vectors of floats
-* `add_v64sv64s_v64s` - pairwise add 2 vectors of integers
-
-* `subtract_v64fv64f_v64f` - pairwise subtract 2 vectors of floats
-* `subtract_v64sv64s_v64s` - pairwise subtract 2 vectors of integers
-
-* `multiply_v64fs64f_v64f` - multiply a vector of floats by a float
-* `multiply_v64sv64s_v64s` - multiply a vector of integers by an integer
-* `multiply_v64fv64f_v64f` - pairwise multiply 2 vectors of floats
-* `multiply_v64ss64s_v64s` - pairwise multiply 2 vectors of integers
-
-* `dotproduct_v64fv64f_s64f` - compute the dot product of 2 vectors of floats
-
-* `min_v64f_s64f` - find the minimum in a vector of floats
-* `min_v64s_s64s` - find the minimum in a vector of integers
-
-* `max_v64f_s64f` - find the maximum in a vector of floats
-* `max_v64s_s64s` - find the maximum in a vector of integers
-
-* `min_v64fv64f_v64f` - find the pairwise minimum in 2 vectors of floats
-
-* `max_v64fv64f_v64f` - find the pairwise maximum in 2 vectors of floats
-
-* `min_v64fs64f_v64f` - find the pairwise minimum of a vector of floats and a
-  constant
-
-* `max_v64fs64f_v64f` - find the pairwise maximum of a vector of floats and a
-  constant
-
-* `negate_v64f_s64f` - negate a vector of floats
-* `negate_v64s_s64s` - negate a vector of integers
-
-* `sum_v64f_s64f` - compute the sum of a vector of floats
-* `sumabs_v64f_s64f` - compute the sum of the absolute values of a vector of
-  floats
-* `sumsquares_v64f_s64f` - compute the sum of the squares of the values of a
-  vector of floats
-
-* `log_v64f_v64f` - compute the natural logarithm of the values of a vector of
-  floats
-* `exp_v64f_v64f` - compute the base-_e_ exponent of the values of a vector of
-  floats
-* `sin_v64f_v64f` - compute the sine of the values of a vector of floats
-* `cos_v64f_v64f` - compute the cosine of the values of a vector of floats
-* `tan_v64f_v64f` - compute the tangent of the values of a vector of floats
-
-* `evaluatepolynomial_v64fv64f_v64f` - evaluate the polynomial with the given
-  float coefficients in standard form at the given _x_-values
-
-## TODO
-
-Add benchmarks.
-
-## Contributing
-
-1. Fork it
-2. Create your feature branch (`git checkout -b my-new-feature`)
-3. Commit your changes (`git commit -am 'Add some feature'`)
-4. Push to the branch (`git push origin my-new-feature`)
-5. Create new Pull Request

data/Rakefile

@@ -1,39 +0,0 @@
-require "bundler/gem_tasks"
-require "rake/extensiontask"
-require "rspec/core/rake_task"
-
-spec = Gem::Specification.load('ryeppp.gemspec')
-Rake::ExtensionTask.new('ryeppp', spec)
-
-desc "Ryeppp unit tests"
-RSpec::Core::RakeTask.new(:spec) do |t|
-  t.pattern = "spec/*_spec.rb"
-  t.verbose = true
-end
-
-desc "Ryeppp c generation"
-task :c_generation do
-  current_dir = __FILE__.split(/\//)[0..-2].join('/')
-  require File.join(current_dir, 'ext/templates/ryeppp.c.rb')
-  c_code = [
-    HEADERS,
-    PRIMARY,
-    FUNCS.call('Add'),
-    FUNCS.call('Subtract'),
-    FUNCS.call('Multiply'),
-    DOT_PRODUCT,
-    MIN_MAX,
-    PAIRWISE_MIN_MAX,
-    CONSTANT_MIN_MAX,
-    NEGATE,
-    SUMS,
-    MATHS,
-    POLYNOMIAL,
-    INITIALIZER
-  ].join("\n\n")
-  File.open(File.join(current_dir, 'ext/ryeppp/ryeppp.c'), 'w') do |f|
-    f.write(c_code)
-  end
-end
-
-task :default => [:c_generation, :compile, :spec]

data/ext/templates/ryeppp.c.rb

@@ -1,496 +0,0 @@
-def allocate_yep64_typed_array_and_assert(var_names, len_var_name, opts={})
-  var_names = Array(var_names)
-  type = opts[:type] || '{{type}}'
-  assert = opts[:assert].nil? ? true : opts[:assert]
-  %{#{var_names.map{|vn| %{Yep64#{type} *yep_#{vn} = (Yep64#{type}*)calloc(#{len_var_name}, sizeof(Yep64#{type}));}}.join("\n")}
-    #{assert ? var_names.map{|vn| %{assert(yep_#{vn} != NULL);}}.join("\n") : nil}}
-end
-
-def deinitialize_yeppp
-  %{/* Deinitialize the Yeppp! library */
-    status = yepLibrary_Release();
-    assert(status == YepStatusOk);}
-end
-
-def initialize_yeppp
-  %{/* Initialize the Yeppp! library */
-    status = yepLibrary_Init();
-    assert(status == YepStatusOk);}
-end
-
-def load_ruby_array_from_yeppp_array(var_name, iteration_var_name, len_var_name, type)
-  %{/* Load the Ruby Array */
-    new_ary = rb_ary_new2(#{len_var_name});
-    for (#{iteration_var_name}=0; #{iteration_var_name}<#{len_var_name}; #{iteration_var_name}++) {
-      rb_ary_push(new_ary, #{type == 'f' ? 'DBL' : 'INT'}2NUM((#{type == 'f' ? 'double' : 'long'})yep_#{var_name}[#{iteration_var_name}]));
-    }}
-end
-def load_ruby_array_from_yeppp_array_parameterized(var_name, iteration_var_name, len_var_name)
-  %{/* Load the Ruby Array */
-    new_ary = rb_ary_new2(#{len_var_name});
-    for (#{iteration_var_name}=0; #{iteration_var_name}<#{len_var_name}; #{iteration_var_name}++) {
-      rb_ary_push(new_ary, {{ruby_type}}2NUM(({{c_type}})yep_#{var_name}[#{iteration_var_name}]));
-    }}
-end
-def load_ruby_array_into_yeppp_array(var_name, iteration_var_name, len_var_name, type, permitted_types)
-  pt = permitted_types.map do |t|
-    case t
-      when :float
-        "TYPE(#{var_name}_a[#{iteration_var_name}]) != T_FLOAT"
-      when :integer
-        "TYPE(#{var_name}_a[#{iteration_var_name}]) != T_FIXNUM"
-      else
-        raise "Invalid permitted_type: #{t}."
-    end
-  end.join(' && ')
-  %{/* Load #{var_name}_a into yep_#{var_name}. */
-    for (#{iteration_var_name}=0; #{iteration_var_name}<#{len_var_name}; #{iteration_var_name}++) {
-      if (#{pt}) {
-        rb_raise(rb_eTypeError, "input was not all #{permitted_types.map(&:to_s).join(' and ')}");
-      }
-      yep_#{var_name}[#{iteration_var_name}] = (Yep64#{type})NUM2#{type == 'f' ? 'DBL' : 'INT'}(#{var_name}_a[#{iteration_var_name}]);
-    }}
-end
-def load_ruby_array_into_yeppp_array_parameterized(var_name, iteration_var_name, len_var_name)
-  %{/* Load #{var_name}_a into yep_#{var_name}. */
-    for (#{iteration_var_name}=0; #{iteration_var_name}<#{len_var_name}; #{iteration_var_name}++) {
-      if (TYPE(#{var_name}_a[#{iteration_var_name}]) != {{ruby_klass}}) {
-        rb_raise(rb_eTypeError, "input was not all {{ruby_klass_human}}");
-      }
-      yep_#{var_name}[#{iteration_var_name}] = (Yep64{{type}})NUM2{{ruby_type}}(#{var_name}_a[#{iteration_var_name}]);
-    }}
-end
-
-def release_array_memory(var_names)
-  var_names = Array(var_names)
-  %{/* Release the memory allocated for array#{var_names.size == 1 ? nil : 's'} */
-    #{var_names.map{|vn| %{free(yep_#{vn});}}.join("\n")}}
-end
-
-def typed_variants(s, opts={})
-  [
-    ['s', 'long', 'INT', 'T_FIXNUM', 'integers'],
-    ['f', 'double', 'DBL', 'T_FLOAT', 'floats']
-  ].map do |(type, c_type, ruby_type, ruby_klass, ruby_klass_human)|
-    if !opts[:only_type] || opts[:only_type] == type
-      s.gsub(/{{type}}/, type)
-       .gsub(/{{c_type}}/, c_type)
-       .gsub(/{{ruby_type}}/, ruby_type)
-       .gsub(/{{ruby_klass}}/, ruby_klass)
-       .gsub(/{{ruby_klass_human}}/, ruby_klass_human)
-    else
-      ''
-    end
-  end.map(&:strip).join("\n\n")
-end
-
-HEADERS = %{
-// Include the Ruby headers and goodies
-#include "ruby.h"
-
-#include "stdio.h"
-#include "assert.h"
-
-#include "yepCore.h"
-#include "yepLibrary.h"
-#include "yepMath.h"
-}.strip.freeze
-
-PRIMARY = %{
-// Defining a space for information and references about the module to be stored
-// internally
-VALUE cRyeppp;
-}.strip.freeze
-
-# verb_name is in [Add, Subtract, Multiply]
-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) {
-          enum YepStatus status;
-          long i;
-          VALUE new_ary;
-          VALUE *x_a = RARRAY_PTR(x);
-          long l = RARRAY_LEN(x);
-          Yep64{{type}} mult_by = (Yep64{{type}})NUM2DBL(multiply_by);
-        
-          /* Allocate arrays of inputs and outputs */
-          #{allocate_yep64_typed_array_and_assert(%w{x y}, 'l')}
-        
-          #{initialize_yeppp}
-        
-          #{load_ruby_array_into_yeppp_array_parameterized('x', 'i', 'l')}
-        
-          /* Perform the operation */
-          status = yepCore_Multiply_V64{{type}}S64{{type}}_V64{{type}}(yep_x, mult_by, yep_y, (YepSize)l);
-          assert(status == YepStatusOk);
-
-          #{load_ruby_array_from_yeppp_array_parameterized('y', 'i', 'l')}
-        
-          #{deinitialize_yeppp}
-          
-          #{release_array_memory(%w{x y})}
-          
-          return new_ary;
-        }
-      }).strip.freeze
-    end
-  }
-
-  #{typed_variants(%{
-    // #{verb_name} Arrays of Fixnums.
-    static VALUE #{verb_name.downcase}_v64{{type}}v64{{type}}_v64{{type}}(VALUE self, VALUE x, VALUE y) {
-      enum YepStatus status;
-      VALUE new_ary;
-      long i;
-      VALUE *x_a = RARRAY_PTR(x);
-      VALUE *y_a = RARRAY_PTR(y);
-      long l = RARRAY_LEN(x);
-    
-      /* Allocate arrays of inputs and outputs */
-      #{allocate_yep64_typed_array_and_assert(%w{x y z}, 'l')}
-
-      #{initialize_yeppp}
-    
-      #{load_ruby_array_into_yeppp_array_parameterized('x', 'i', 'l')}
-      #{load_ruby_array_into_yeppp_array_parameterized('y', 'i', 'l')}
-    
-      /* Perform the addition */
-      status = yepCore_#{verb_name}_V64{{type}}V64{{type}}_V64{{type}}(yep_x, yep_y, yep_z, (YepSize)l);
-      assert(status == YepStatusOk);
-
-      #{load_ruby_array_from_yeppp_array_parameterized('z', 'i', 'l')}
-    
-      #{deinitialize_yeppp}
-    
-      #{release_array_memory(%w{x y z})}
-
-      return new_ary;
-    }
-  })}
-}
-end
-
-DOT_PRODUCT = %{
-  // Get the dot product of 2 Arrays.
-  static VALUE dotproduct_v64fv64f_s64f(VALUE self, VALUE x, VALUE y) {
-    enum YepStatus status;
-    long i;
-    Yep64f dp;
-    VALUE *x_a = RARRAY_PTR(x);
-    VALUE *y_a = RARRAY_PTR(y);
-    long l = RARRAY_LEN(x);
-  
-    /* Allocate arrays of inputs and outputs */
-    #{allocate_yep64_typed_array_and_assert(%w{x y}, 'l', :type => 'f')}
-
-    #{initialize_yeppp}
-  
-    #{load_ruby_array_into_yeppp_array('x', 'i', 'l', 'f', [:integer, :float])}
-    #{load_ruby_array_into_yeppp_array('y', 'i', 'l', 'f', [:integer, :float])}
-  
-    /* Perform the operation */
-    status = yepCore_DotProduct_V64fV64f_S64f(yep_x, yep_y, &dp, (YepSize)l);
-    assert(status == YepStatusOk);
-
-    #{deinitialize_yeppp}
-  
-    #{release_array_memory(%w{x y})}
-  
-    return DBL2NUM((double)dp);
-  }
-}.strip
-
-MIN_MAX = typed_variants(%w{Min Max}.map do |kind|
-  %{
-    // Get the #{kind.downcase} value from an Array.
-    static VALUE #{kind.downcase}_v64{{type}}_s64{{type}}(VALUE self, VALUE x) {
-      enum YepStatus status;
-      long i;
-      Yep64{{type}} #{kind.downcase};
-      VALUE *x_a = RARRAY_PTR(x);
-      long l = RARRAY_LEN(x);
-  
-      /* Allocate arrays of inputs and outputs */
-      #{allocate_yep64_typed_array_and_assert('x', 'l')}
-
-      #{initialize_yeppp}
-  
-      #{load_ruby_array_into_yeppp_array_parameterized('x', 'i', 'l')}
-  
-      /* Perform the operation */
-      status = yepCore_#{kind}_V64{{type}}_S64{{type}}(yep_x, &#{kind.downcase}, (YepSize)l);
-      assert(status == YepStatusOk);
-
-      #{deinitialize_yeppp}
-  
-      #{release_array_memory(%w{x})}
-   
-      return {{ruby_type}}2NUM(({{c_type}})#{kind.downcase});
-    }
-  }.strip
-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) {
-      enum YepStatus status;
-      long i;
-      VALUE new_ary;
-      VALUE *x_a = RARRAY_PTR(x);
-      VALUE *y_a = RARRAY_PTR(y);
-      long l = RARRAY_LEN(x);
-  
-      /* Allocate arrays of inputs and outputs */
-      #{allocate_yep64_typed_array_and_assert(%w{x y z}, 'l')}
-
-      #{initialize_yeppp}
-  
-      #{load_ruby_array_into_yeppp_array_parameterized('x', 'i', 'l')}
-      #{load_ruby_array_into_yeppp_array_parameterized('y', 'i', 'l')}
-  
-      /* Perform the operation */
-      status = yepCore_#{kind}_V64{{type}}V64{{type}}_V64{{type}}(yep_x, yep_y, yep_z, (YepSize)l);
-      assert(status == YepStatusOk);
-
-      #{load_ruby_array_from_yeppp_array_parameterized('z', 'i', 'l')}
-
-      #{deinitialize_yeppp}
-  
-      #{release_array_memory(%w{x y z})}
-   
-      return new_ary;
-    }
-  }.strip
-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) {
-      enum YepStatus status;
-      long i;
-      VALUE new_ary;
-      VALUE *x_a = RARRAY_PTR(x);
-      long l = RARRAY_LEN(x);
-      Yep64f konst = (Yep64f)NUM2{{ruby_type}}(c);
-  
-      /* Allocate arrays of inputs and outputs */
-      #{allocate_yep64_typed_array_and_assert(%w{x y}, 'l')}
-
-      #{initialize_yeppp}
-  
-      #{load_ruby_array_into_yeppp_array_parameterized('x', 'i', 'l')}
-  
-      /* Perform the operation */
-      status = yepCore_#{kind}_V64{{type}}S64{{type}}_V64{{type}}(yep_x, konst, yep_y, (YepSize)l);
-      assert(status == YepStatusOk);
-
-      #{load_ruby_array_from_yeppp_array_parameterized('y', 'i', 'l')}
-
-      #{deinitialize_yeppp}
-  
-      #{release_array_memory(%w{x y})}
-   
-      return new_ary;
-    }
-  }.strip
-end.join("\n\n"), :only_type => 'f')
-
-NEGATE = typed_variants(%{
-  // Negate an Array.
-  static VALUE negate_v64{{type}}_s64{{type}}(VALUE self, VALUE x) {
-    enum YepStatus status;
-    long i;
-    VALUE new_ary;
-    VALUE *x_a = RARRAY_PTR(x);
-    long l = RARRAY_LEN(x);
-  
-    /* Allocate arrays of inputs and outputs */
-    #{allocate_yep64_typed_array_and_assert(%w{x y}, 'l')}
-  
-    #{initialize_yeppp}
-  
-    #{load_ruby_array_into_yeppp_array_parameterized('x', 'i', 'l')}
-  
-    /* Perform the negation */
-    status = yepCore_Negate_V64{{type}}_V64{{type}}(yep_x, yep_y, (YepSize)l);
-    assert(status == YepStatusOk);
-  
-    #{load_ruby_array_from_yeppp_array_parameterized('y', 'i', 'l')}
-  
-    #{deinitialize_yeppp}
-  
-    #{release_array_memory(%w{x y})}
-   
-    return new_ary;
-  }
-}).freeze
-
-SUMS = %w{Sum SumAbs SumSquares}.map do |kind|
-  %{
-    static VALUE #{kind.downcase}_v64f_s64f(VALUE self, VALUE x) {
-      enum YepStatus status;
-      long i;
-      Yep64f sum;
-      long l = RARRAY_LEN(x);
-      VALUE *x_a = RARRAY_PTR(x);
-
-      /* Allocate arrays of inputs and outputs */
-      #{allocate_yep64_typed_array_and_assert('x', 'l', :type => 'f')}
-
-      #{initialize_yeppp}
-
-      #{load_ruby_array_into_yeppp_array('x', 'i', 'l', 'f', [:integer, :float])}
-
-      /* Perform the operation */
-      status = yepCore_#{kind}_V64f_S64f(yep_x, &sum, (YepSize)l);
-      assert(status == YepStatusOk);
-
-      #{deinitialize_yeppp}
-    
-      #{release_array_memory(%w{x})}
-
-      return DBL2NUM((double)sum);
-    }
-  }.strip
-end.join("\n\n").freeze
-
-MATHS_KINDS = %w{Log Exp Sin Cos Tan}.freeze
-MATHS = MATHS_KINDS.map do |kind|
-  %{
-    static VALUE #{kind.downcase}_v64f_v64f(VALUE self, VALUE x) {
-      enum YepStatus status;
-      long i;
-      VALUE new_ary;
-      long l = RARRAY_LEN(x);
-      VALUE *x_a = RARRAY_PTR(x);
-
-      /* Allocate arrays of inputs and outputs */
-      #{allocate_yep64_typed_array_and_assert(%w{x y}, 'l', :type => 'f')}
-
-      #{initialize_yeppp}
-
-      #{load_ruby_array_into_yeppp_array('x', 'i', 'l', 'f', [:integer, :float])}
-
-      /* Perform the operation */
-      status = yepMath_#{kind}_V64f_V64f(yep_x, yep_y, (YepSize)l);
-      assert(status == YepStatusOk);
-
-      #{load_ruby_array_from_yeppp_array('y', 'i', 'l', 'f')}
-
-      #{deinitialize_yeppp}
-    
-      #{release_array_memory(%w{x y})}
-
-      return new_ary;
-    }
-  }.strip
-end.join("\n\n").freeze
-
-POLYNOMIAL = %{
-  // x is the coefficients
-  // where is the set of points at which to evaluate x
-  static VALUE evaluatepolynomial_v64fv64f_v64f(VALUE self, VALUE x, VALUE where) {
-    enum YepStatus status;
-    long i;
-    VALUE new_ary;
-    long x_l = RARRAY_LEN(x);
-    long y_l = RARRAY_LEN(where);
-    VALUE *x_a = RARRAY_PTR(x);
-    VALUE *y_a = RARRAY_PTR(where);
-
-    /* Allocate arrays of inputs and outputs */
-    #{allocate_yep64_typed_array_and_assert(%w{x}, 'x_l', :assert => false, :type => 'f')}
-    #{allocate_yep64_typed_array_and_assert(%w{y z}, 'y_l', :assert => false, :type => 'f')}
-    assert(yep_x != NULL);
-    assert(yep_y != NULL);
-    assert(yep_z != NULL);
-
-    #{initialize_yeppp}
-
-    #{load_ruby_array_into_yeppp_array('x', 'i', 'x_l', 'f', [:integer, :float])}
-    #{load_ruby_array_into_yeppp_array('y', 'i', 'y_l', 'f', [:integer, :float])}
-
-    /* Perform the operation */
-    status = yepMath_EvaluatePolynomial_V64fV64f_V64f(yep_x, yep_y, yep_z, (YepSize)x_l, (YepSize)y_l);
-    assert(status == YepStatusOk);
-
-    #{load_ruby_array_from_yeppp_array('z', 'i', 'y_l', 'f')}
-
-    #{deinitialize_yeppp}
-  
-    #{release_array_memory(%w{x y z})}
-    
-    return new_ary;
-  }
-}.strip.freeze
-
-INITIALIZER = %{
-// The initialization method for this module
-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);
-
-  /* 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);
-
-  /* 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);
-
-  /* Dot Product */
-  rb_define_singleton_method(cRyeppp, "dotproduct_v64fv64f_s64f", dotproduct_v64fv64f_s64f, 2);
-
-  /* Minimum */
-  rb_define_singleton_method(cRyeppp, "min_v64f_s64f", min_v64f_s64f, 1);
-  rb_define_singleton_method(cRyeppp, "min_v64s_s64s", min_v64s_s64s, 1);
-
-  /* Maximum */
-  rb_define_singleton_method(cRyeppp, "max_v64f_s64f", max_v64f_s64f, 1);
-  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);
-  // Pairwise signed min is not available.
-
-  /* Pairwise Maxima */
-  rb_define_singleton_method(cRyeppp, "max_v64fv64f_v64f", max_v64fv64f_v64f, 2);
-  // Pairwise signed max is not available.
-
-  /* Constant Minima */
-  rb_define_singleton_method(cRyeppp, "min_v64fs64f_v64f", min_v64fs64f_v64f, 2);
-  // Constant signed min is not available.
-
-  /* Constant Maxima */
-  rb_define_singleton_method(cRyeppp, "max_v64fs64f_v64f", max_v64fs64f_v64f, 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);
-
-  /* Sums */
-  rb_define_singleton_method(cRyeppp, "sum_v64f_s64f", sum_v64f_s64f, 1);
-  // Signed sum is not available.
-  rb_define_singleton_method(cRyeppp, "sumabs_v64f_s64f", sumabs_v64f_s64f, 1);
-  // Signed abs sum is not available.
-  rb_define_singleton_method(cRyeppp, "sumsquares_v64f_s64f", sumsquares_v64f_s64f, 1);
-  // Signed squares sum is not available.
-
-  /* Maths */
-  #{MATHS_KINDS.map do |kind|
-    %{rb_define_singleton_method(cRyeppp, "#{kind.downcase}_v64f_v64f", #{kind.downcase}_v64f_v64f, 1);}
-  end.join("\n")}
-
-  /* Polynomial */
-  rb_define_singleton_method(cRyeppp, "evaluatepolynomial_v64fv64f_v64f", evaluatepolynomial_v64fv64f_v64f, 2);
-}
-}.strip.freeze

data/lib/ryeppp.rb

@@ -1,6 +0,0 @@
-require "ryeppp/version"
-require File.join(File.expand_path(File.dirname(__FILE__)), 'ryeppp.so')
-
-#module Carray
-#  # Your code goes here...
-#end

data/lib/ryeppp/version.rb

@@ -1,3 +0,0 @@
-class Ryeppp
-  VERSION = "0.0.1"
-end

data/ryeppp.gemspec

@@ -1,27 +0,0 @@
-# coding: utf-8
-lib = File.expand_path('../lib', __FILE__)
-$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
-require 'ryeppp/version'
-
-Gem::Specification.new do |spec|
-  spec.name          = "ryeppp"
-  spec.version       = Ryeppp::VERSION
-  spec.authors       = ["Brad Cater"]
-  spec.email         = ["bradcater@gmail.com"]
-  spec.description   = %q{This gem provides bindings to the Yeppp! library. According to the documentation, "Yeppp! is a high-performance SIMD-optimized mathematical library for x86, ARM, and MIPS processors on Windows, Android, Mac OS X, and GNU/Linux systems."}
-  spec.summary       = %q{This gem provides bindings to the Yeppp! library.}
-  spec.homepage      = "https://github.com/bradcater/ruby-yeppp"
-  spec.license       = "MIT"
-
-  spec.files         = `git ls-files`.split($/)
-  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
-  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
-  spec.require_paths = ["lib"]
-
-  spec.extensions << "ext/ryeppp/extconf.rb"
-
-  spec.add_development_dependency "bundler", "~> 1.3"
-  spec.add_development_dependency "rake-compiler"
-  spec.add_development_dependency "rake", ">= 1.9.1"
-  spec.add_development_dependency "rspec", ">= 2.13.0"
-end

data/spec/ryeppp_spec.rb

@@ -1,152 +0,0 @@
-require 'spec_helper'
-
-describe Ryeppp do
-  # Addition
-  it 'should add vectors of Fixnums' do
-    Ryeppp.add_v64sv64s_v64s([1], [2]).should eq([3])
-    expect{Ryeppp.add_v64sv64s_v64s([1, 'a'], [2, 'b'])}.to raise_error(TypeError)
-  end
-  it 'should add vectors of Floats' do
-    Ryeppp.add_v64fv64f_v64f([1.1], [1.1]).should eq([2.2])
-    expect{Ryeppp.add_v64fv64f_v64f([1.1, 'a'], [2.2, 'b'])}.to raise_error(TypeError)
-  end
-
-  # Subtraction
-  it 'should subtract vectors of Fixnums' do
-    Ryeppp.subtract_v64sv64s_v64s([1], [2]).should eq([-1])
-    expect{Ryeppp.subtract_v64sv64s_v64s([1, 'a'], [2, 'b'])}.to raise_error(TypeError)
-  end
-  it 'should subtract vectors of Floats' do
-    Ryeppp.subtract_v64fv64f_v64f([1.1], [1.1]).should eq([0])
-    expect{Ryeppp.subtract_v64fv64f_v64f([1.1, 'a'], [2.2, 'b'])}.to raise_error(TypeError)
-  end
-
-  # Multiplication
-  it 'should multiply a vector of Fixnums by a constant' do
-    Ryeppp.multiply_v64ss64s_v64s([1, 2, 3], 2).should eq([2, 4, 6])
-    expect{Ryeppp.multiply_v64ss64s_v64s([1, 'a'], 2)}.to raise_error(TypeError)
-  end
-  it 'should multiply a vector of Floats by a constant' do
-    Ryeppp.multiply_v64fs64f_v64f([1.0, 2.0, 3.0], 2.0).should eq([2.0, 4.0, 6.0])
-    expect{Ryeppp.multiply_v64fs64f_v64f([1, 'a'], 2)}.to raise_error(TypeError)
-  end
-  it 'should multiply vectors of Fixnums' do
-    Ryeppp.multiply_v64sv64s_v64s([2], [3]).should eq([6])
-    expect{Ryeppp.multiply_v64sv64s_v64s([1, 'a'], [2, 'b'])}.to raise_error(TypeError)
-  end
-  it 'should multiply vectors of Floats' do
-    Ryeppp.multiply_v64fv64f_v64f([2.5], [3.5]).should eq([8.75])
-    expect{Ryeppp.multiply_v64fv64f_v64f([1.1, 'a'], [2.2, 'b'])}.to raise_error(TypeError)
-  end
-
-  # Dot Product
-  it 'should do the dot product of vectors' do
-    Ryeppp.dotproduct_v64fv64f_s64f([1, 2, 3], [4, 5, 6]).should eq(32.0)
-    expect{Ryeppp.dotproduct_v64fv64f_s64f([1, 2, 'a'], [4, 5, 'b'])}.to raise_error(TypeError)
-  end
-
-  # Minimum
-  it 'should find the minimum in a vector of Fixnums' do
-    Ryeppp.min_v64s_s64s([3, 2, 1]).should eq(1)
-    expect{Ryeppp.min_v64s_s64s([1, 'a'])}.to raise_error(TypeError)
-  end
-  it 'should find the minimum in a vector of Floats' do
-    Ryeppp.min_v64f_s64f([1.0, 2.0, 3.0]).should eq(1.0)
-    expect{Ryeppp.min_v64f_s64f([1.0, 'a'])}.to raise_error(TypeError)
-  end
-
-  # Maximum
-  it 'should find the maximum in a vector of Fixnums' do
-    Ryeppp.max_v64s_s64s([3, 2, 1]).should eq(3)
-    expect{Ryeppp.max_v64s_s64s([1, 'a'])}.to raise_error(TypeError)
-  end
-  it 'should find the maximum in a vector of Floats' do
-    Ryeppp.max_v64f_s64f([1.0, 2.0, 3.0]).should eq(3.0)
-    expect{Ryeppp.max_v64f_s64f([1.0, 'a'])}.to raise_error(TypeError)
-  end
-
-  # Pairwise Minima
-  it 'should find the pairwise minima in vectors of Floats' do
-    Ryeppp.min_v64fv64f_v64f([1.0, 2.0, 3.0], [3.0, 2.0, 1.0]).should eq([1.0, 2.0, 1.0])
-    expect{Ryeppp.min_v64fv64f_v64f([1.0, 'a'], [2.0, 'b'])}.to raise_error(TypeError)
-  end
-  # Pairwise Maxima
-  it 'should find the pairwise maxima in vectors of Floats' do
-    Ryeppp.max_v64fv64f_v64f([1.0, 2.0, 3.0], [3.0, 2.0, 1.0]).should eq([3.0, 2.0, 3.0])
-    expect{Ryeppp.max_v64fv64f_v64f([1.0, 'a'], [2.0, 'b'])}.to raise_error(TypeError)
-  end
-
-  # Constant Minima
-  it 'should find the minima in a vector of Floats and a constant' do
-    Ryeppp.min_v64fs64f_v64f([1.0, 2.0, 3.0], 2.0).should eq([1.0, 2.0, 2.0])
-    expect{Ryeppp.min_v64fs64f_v64f([1.0, 'a'], 2.0)}.to raise_error(TypeError)
-  end
-  # Constant Maxima
-  it 'should find the maxima in a vector of Floats and a constant' do
-    Ryeppp.max_v64fs64f_v64f([1.0, 2.0, 3.0], 2.5).should eq([2.5, 2.5, 3.0])
-    expect{Ryeppp.max_v64fs64f_v64f([1.0, 'a'], 2.5)}.to raise_error(TypeError)
-  end
-
-  # Negation
-  it 'should negate vectors of Fixnums' do
-    Ryeppp.negate_v64s_s64s([1]).should eq([-1])
-    expect{Ryeppp.negate_v64s_s64s([1, 'a'])}.to raise_error(TypeError)
-  end
-  it 'should negate vectors of Floats' do
-    Ryeppp.negate_v64f_s64f([1.1]).should eq([-1.1])
-    expect{Ryeppp.negate_v64f_s64f([1.1, 'a'])}.to raise_error(TypeError)
-  end
-
-  # Sum
-  it 'should sum a vector' do
-    Ryeppp.sum_v64f_s64f([1, 2, 3]).should eq(6.0)
-    expect{Ryeppp.sum_v64f_s64f([1, 'a'])}.to raise_error(TypeError)
-  end
-  # Sum Absolute Values
-  it 'should sum absolute values of a vector' do
-    Ryeppp.sumabs_v64f_s64f([1.0, -1.0, 2.0]).should eq(4.0)
-    expect{Ryeppp.sumabs_v64f_s64f([1.0, -1.0, 'a'])}.to raise_error(TypeError)
-  end
-  # Sum Square Values
-  it 'should sum square values of a vector' do
-    Ryeppp.sumsquares_v64f_s64f([1.0, -1.0, 2.0]).should eq(6.0)
-    expect{Ryeppp.sumsquares_v64f_s64f([1.0, -1.0, 'a'])}.to raise_error(TypeError)
-  end
-
-  # Log
-  it 'should find the natural logarithm of elements of a vector' do
-    Ryeppp.log_v64f_v64f([1.0, 2.0, 3.0]).map{|o| o.round(5)}.should eq([0.0, 0.69315, 1.09861])
-    expect{Ryeppp.log_v64f_v64f([1.0, 'a'])}.to raise_error(TypeError)
-  end
-  # Exp
-  it 'should find the base e exponent of elements of a vector' do
-    Ryeppp.exp_v64f_v64f([1.0, 2.0, 3.0]).map{|o| o.round(5)}.should eq([2.71828, 7.38906, 20.08554])
-    expect{Ryeppp.exp_v64f_v64f([1.0, 'a'])}.to raise_error(TypeError)
-  end
-  # Sin
-  it 'should find the sine of elements of a vector' do
-    Ryeppp.sin_v64f_v64f([1.0, 2.0, 3.0]).map{|o| o.round(5)}.should eq([0.84147, 0.9093, 0.14112])
-    expect{Ryeppp.sin_v64f_v64f([1.0, 'a'])}.to raise_error(TypeError)
-  end
-  # Cos
-  it 'should find the cosine of elements of a vector' do
-    Ryeppp.cos_v64f_v64f([1.0, 2.0, 3.0]).map{|o| o.round(5)}.should eq([0.5403, -0.41615, -0.98999])
-    expect{Ryeppp.cos_v64f_v64f([1.0, 'a'])}.to raise_error(TypeError)
-  end
-  # Tan
-  it 'should find the tangent of elements of a vector' do
-    Ryeppp.tan_v64f_v64f([1.0, 2.0, 3.0]).map{|o| o.round(5)}.should eq([1.55741, -2.18504, -0.14255])
-    expect{Ryeppp.tan_v64f_v64f([1.0, 'a'])}.to raise_error(TypeError)
-  end
-
-  # Polynomial
-  it 'should evaluate a polynomial for a vector' do
-    # x^2 + x + 1
-    # evaluated at x=1.
-    Ryeppp.evaluatepolynomial_v64fv64f_v64f([1.0, 1.0, 1.0], [1.0]).should eq([3.0])
-    # -5x^3 - 4x^2 + 2x + 1
-    # evaluated at x=0, x=1, and x=2.
-    Ryeppp.evaluatepolynomial_v64fv64f_v64f([-5, -4, 2, 1], [0, 1, 2]).should eq([-5.0, -6.0, 3.0])
-    expect{Ryeppp.evaluatepolynomial_v64fv64f_v64f([1, 'a'], [0, 1])}.to raise_error(TypeError)
-  end
-end

data/spec/spec_helper.rb

@@ -1,7 +0,0 @@
-require 'bundler/setup'
-
-require 'ryeppp'
-
-RSpec.configure do |config|
-  # some (optional) config here
-end