nmatrix 0.0.1 → 0.0.2

metadata

@@ -1,112 +1,156 @@
 --- !ruby/object:Gem::Specification
 name: nmatrix
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.0.2
   prerelease: 
 platform: ruby
 authors:
 - John Woods
+- Chris Wailes
+- Aleksey Timin
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-04-10 00:00:00.000000000 Z
+date: 2012-09-21 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
-  name: rdoc
-  requirement: &81217480 !ruby/object:Gem::Requirement
+  name: rake
+  requirement: &75615060 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
-        version: '3.10'
+        version: '0.9'
   type: :development
   prerelease: false
-  version_requirements: *81217480
+  version_requirements: *75615060
 - !ruby/object:Gem::Dependency
-  name: rake-compiler
-  requirement: &81217250 !ruby/object:Gem::Requirement
+  name: bundler
+  requirement: &75614870 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *75614870
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: &75614590 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
-        version: '0.7'
+        version: 2.9.0
   type: :development
   prerelease: false
-  version_requirements: *81217250
+  version_requirements: *75614590
 - !ruby/object:Gem::Dependency
-  name: hoe
-  requirement: &81217030 !ruby/object:Gem::Requirement
+  name: pry
+  requirement: &75614320 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
-        version: '3.0'
+        version: 0.9.9
   type: :development
   prerelease: false
-  version_requirements: *81217030
-description: ! 'NMatrix is an experimental linear algebra library for Ruby, written
-  mostly in C. It can be used with or without SciRuby, but is part of the SciRuby
-  project.
-
-
-  NMatrix was inspired by and based heavily upon {NArray}[http://narray.rubyforge.org],
-  by Masahiro Tanaka.
-
-
-  {<img src=https://www.pledgie.com/campaigns/15783.png?skin_name=chrome>}[http://www.pledgie.com/campaigns/15783]'
+  version_requirements: *75614320
+- !ruby/object:Gem::Dependency
+  name: guard-rspec
+  requirement: &75614020 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.7.0
+  type: :development
+  prerelease: false
+  version_requirements: *75614020
+- !ruby/object:Gem::Dependency
+  name: rake-compiler
+  requirement: &75613790 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.8.1
+  type: :development
+  prerelease: false
+  version_requirements: *75613790
+description: NMatrix is an experimental linear algebra library for Ruby, written mostly
+  in C.
 email:
 - john.o.woods@gmail.com
 executables: []
 extensions:
 - ext/nmatrix/extconf.rb
-extra_rdoc_files:
-- History.txt
-- Manifest.txt
-- README.rdoc
-- LICENSE.txt
+extra_rdoc_files: []
 files:
-- .autotest
+- .gitignore
+- .rspec
+- Gemfile
+- Guardfile
 - History.txt
+- LICENSE.txt
 - Manifest.txt
 - README.rdoc
-- LICENSE.txt
 - Rakefile
-- Gemfile
+- ext/nmatrix/data/complex.h
+- ext/nmatrix/data/data.cpp
+- ext/nmatrix/data/data.h
+- ext/nmatrix/data/rational.h
+- ext/nmatrix/data/ruby_object.h
+- ext/nmatrix/extconf.rb
+- ext/nmatrix/new_extconf.rb
+- ext/nmatrix/nmatrix.cpp
+- ext/nmatrix/nmatrix.h
+- ext/nmatrix/ruby_constants.cpp
+- ext/nmatrix/ruby_constants.h
+- ext/nmatrix/storage/common.cpp
+- ext/nmatrix/storage/common.h
+- ext/nmatrix/storage/dense.cpp
+- ext/nmatrix/storage/dense.h
+- ext/nmatrix/storage/list.cpp
+- ext/nmatrix/storage/list.h
+- ext/nmatrix/storage/storage.cpp
+- ext/nmatrix/storage/storage.h
+- ext/nmatrix/storage/yale.cpp
+- ext/nmatrix/storage/yale.h
+- ext/nmatrix/ttable_helper.rb
+- ext/nmatrix/types.h
+- ext/nmatrix/util/io.cpp
+- ext/nmatrix/util/io.h
+- ext/nmatrix/util/lapack.h
+- ext/nmatrix/util/math.cpp
+- ext/nmatrix/util/math.h
+- ext/nmatrix/util/sl_list.cpp
+- ext/nmatrix/util/sl_list.h
+- ext/nmatrix/util/util.h
+- lib/nmatrix.rb
+- lib/nmatrix/blas.rb
+- lib/nmatrix/io/mat5_reader.rb
+- lib/nmatrix/io/mat_reader.rb
+- lib/nmatrix/monkeys.rb
+- lib/nmatrix/nmatrix.rb
+- lib/nmatrix/nvector.rb
+- lib/nmatrix/version.rb
+- nmatrix.gemspec
+- scripts/mac-brew-gcc.sh
+- spec/4x4_sparse.mat
+- spec/4x5_dense.mat
+- spec/blas_spec.rb
+- spec/elementwise_spec.rb
+- spec/io_spec.rb
+- spec/lapack_spec.rb
+- spec/math_spec.rb
 - spec/nmatrix_spec.rb
 - spec/nmatrix_yale_spec.rb
 - spec/nvector_spec.rb
-- spec/syntax_tree_spec.rb
-- lib/array.rb
-- lib/nmatrix.rb
-- lib/string.rb
-- ext/nmatrix/cblas.c
-- ext/nmatrix/dense.c
-- ext/nmatrix/depend
-- ext/nmatrix/extconf.rb
-- ext/nmatrix/generator.rb
-- ext/nmatrix/list.c
-- ext/nmatrix/nmatrix.c
-- ext/nmatrix/nmatrix.h
-- ext/nmatrix/rational.c
-- ext/nmatrix/yale.c
-- ext/nmatrix/generator/syntax_tree.rb
-- ext/nmatrix/dense/blas_header.template.c
-- ext/nmatrix/dense/elementwise.template.c
-- ext/nmatrix/dense/gemm.template.c
-- ext/nmatrix/dense/gemv.template.c
-- ext/nmatrix/dense/rationalmath.template.c
-- ext/nmatrix/yale/smmp1.template.c
-- ext/nmatrix/yale/smmp2.template.c
-- ext/nmatrix/yale/smmp1_header.template.c
-- ext/nmatrix/yale/smmp2_header.template.c
-- ext/nmatrix/yale/sort_columns.template.c
-- ext/nmatrix/yale/symbmm.template.c
-- ext/nmatrix/yale/numbmm.template.c
-- ext/nmatrix/yale/transp.template.c
-- ext/nmatrix/yale/complexmath.template.c
-- ext/nmatrix/yale/elementwise.template.c
-- ext/nmatrix/yale/elementwise_op.template.c
-- .gemtest
+- spec/slice_spec.rb
+- spec/spec_helper.rb
+- spec/utm5940.mtx
 homepage: http://sciruby.com
 licenses: []
 post_install_message: ! "***********************************************************\nWelcome
@@ -120,9 +164,7 @@ post_install_message: ! "*******************************************************
   explicit instructions for NMatrix and SciRuby should\nbe available on the SciRuby
   website, sciruby.com, or\nthrough our mailing list (which can be found on our web-\nsite).\n\nThanks
   for trying out NMatrix! Happy coding!\n\n***********************************************************\n"
-rdoc_options:
-- --main
-- README.rdoc
+rdoc_options: []
 require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
@@ -130,7 +172,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ! '>='
     - !ruby/object:Gem::Version
-      version: '1.9'
+      version: 1.9.2
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements:
@@ -139,12 +181,12 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: -102996319
+      hash: -1003602253
 requirements: []
-rubyforge_project: nmatrix
+rubyforge_project: 
 rubygems_version: 1.8.10
 signing_key: 
 specification_version: 3
 summary: NMatrix is an experimental linear algebra library for Ruby, written mostly
-  in C
+  in C.
 test_files: []

data/.autotest

@@ -1,23 +0,0 @@
-# -*- ruby -*-
-
-require 'autotest/restart'
-
-# Autotest.add_hook :initialize do |at|
-#   at.extra_files << "../some/external/dependency.rb"
-#
-#   at.libs << ":../some/external"
-#
-#   at.add_exception 'vendor'
-#
-#   at.add_mapping(/dependency.rb/) do |f, _|
-#     at.files_matching(/test_.*rb$/)
-#   end
-#
-#   %w(TestA TestB).each do |klass|
-#     at.extra_class_map[klass] = "test/test_misc.rb"
-#   end
-# end
-
-# Autotest.add_hook :run_command do |at|
-#   system "rake build"
-# end

data/ext/nmatrix/cblas.c

@@ -1,150 +0,0 @@
-/////////////////////////////////////////////////////////////////////
-// = NMatrix
-//
-// A linear algebra library for scientific computation in Ruby.
-// NMatrix is part of SciRuby.
-//
-// NMatrix was originally inspired by and derived from NArray, by
-// Masahiro Tanaka: http://narray.rubyforge.org
-//
-// == Copyright Information
-//
-// SciRuby is Copyright (c) 2010 - 2012, Ruby Science Foundation
-// NMatrix is Copyright (c) 2012, Ruby Science Foundation
-//
-// Please see LICENSE.txt for additional copyright notices.
-//
-// == Contributing
-//
-// By contributing source code to SciRuby, you agree to be bound by
-// our Contributor Agreement:
-//
-// * https://github.com/SciRuby/sciruby/wiki/Contributor-Agreement
-//
-// == cblas.c
-//
-// Functions in this file allow us to call CBLAS functions using
-// arrays of function pointers, by ensuring that each has the same
-// signature.
-
-#ifndef CBLAS_C
-# define CBLAS_C
-
-#include <cblas.h>
-#include "nmatrix.h"
-
-//extern const enum CBLAS_ORDER;
-//extern const enum CBLAS_TRANSPOSE;
-
-
-inline void cblas_r32gemm_(const enum CBLAS_ORDER Order, const enum CBLAS_TRANSPOSE TransA, const enum CBLAS_TRANSPOSE TransB, DENSE_PARAM p) {
-  if (Order == CblasColMajor) r32gemm(TransA, TransB, p.M, p.N, p.K, p.alpha.r[0], p.A, p.lda, p.B, p.ldb, p.beta.r[0], p.C, p.ldc);
-  else                        r32gemm(TransB, TransA, p.N, p.M, p.K, p.alpha.r[0], p.B, p.ldb, p.A, p.lda, p.beta.r[0], p.C, p.ldc);
-}
-
-inline void cblas_r32gemv_(const enum CBLAS_ORDER Order, const enum CBLAS_TRANSPOSE TransA, DENSE_PARAM p) {
-  r32gemv(TransA, p.M, p.N, p.alpha.r[0], p.A, p.lda, p.B, p.ldb, p.beta.r[0], p.C, p.ldc);
-}
-
-inline void cblas_r64gemm_(const enum CBLAS_ORDER Order, const enum CBLAS_TRANSPOSE TransA, const enum CBLAS_TRANSPOSE TransB, DENSE_PARAM p) {
-  if (Order == CblasColMajor) r64gemm(TransA, TransB, p.M, p.N, p.K, p.alpha.ra[0], p.A, p.lda, p.B, p.ldb, p.beta.ra[0], p.C, p.ldc);
-  else                        r64gemm(TransB, TransA, p.N, p.M, p.K, p.alpha.ra[0], p.B, p.ldb, p.A, p.lda, p.beta.ra[0], p.C, p.ldc);
-}
-
-inline void cblas_r64gemv_(const enum CBLAS_ORDER Order, const enum CBLAS_TRANSPOSE TransA, DENSE_PARAM p) {
-  r64gemv(TransA, p.M, p.N, p.alpha.ra[0], p.A, p.lda, p.B, p.ldb, p.beta.ra[0], p.C, p.ldc);
-}
-
-inline void cblas_r128gemm_(const enum CBLAS_ORDER Order, const enum CBLAS_TRANSPOSE TransA, const enum CBLAS_TRANSPOSE TransB, DENSE_PARAM p) {
-  if (Order == CblasColMajor) r128gemm(TransA, TransB, p.M, p.N, p.K, p.alpha.rat, p.A, p.lda, p.B, p.ldb, p.beta.rat, p.C, p.ldc);
-  else                        r128gemm(TransB, TransA, p.N, p.M, p.K, p.alpha.rat, p.B, p.ldb, p.A, p.lda, p.beta.rat, p.C, p.ldc);
-}
-
-inline void cblas_r128gemv_(const enum CBLAS_ORDER Order, const enum CBLAS_TRANSPOSE TransA, DENSE_PARAM p) {
-  r128gemv(TransA, p.M, p.N, p.alpha.rat, p.A, p.lda, p.B, p.ldb, p.beta.rat, p.C, p.ldc);
-}
-
-inline void cblas_bgemv_(const enum CBLAS_ORDER Order, const enum CBLAS_TRANSPOSE TransA, DENSE_PARAM p) {
-  bgemv(TransA, p.M, p.N, p.alpha.b[0], p.A, p.lda, p.B, p.ldb, p.beta.b[0], p.C, p.ldc);
-}
-
-inline void cblas_bgemm_(const enum CBLAS_ORDER Order, const enum CBLAS_TRANSPOSE TransA, const enum CBLAS_TRANSPOSE TransB, DENSE_PARAM p) {
-  if (Order == CblasColMajor) bgemm(TransA, TransB, p.M, p.N, p.K, p.alpha.b[0], p.A, p.lda, p.B, p.ldb, p.beta.b[0], p.C, p.ldc);
-  else                        bgemm(TransB, TransA, p.N, p.M, p.K, p.alpha.b[0], p.B, p.ldb, p.A, p.lda, p.beta.b[0], p.C, p.ldc);
-}
-
-inline void cblas_i8gemv_(const enum CBLAS_ORDER Order, const enum CBLAS_TRANSPOSE TransA, DENSE_PARAM p) {
-  i8gemv(TransA, p.M, p.N, p.alpha.i[0], p.A, p.lda, p.B, p.ldb, p.beta.i[0], p.C, p.ldc);
-}
-
-inline void cblas_i8gemm_(const enum CBLAS_ORDER Order, const enum CBLAS_TRANSPOSE TransA, const enum CBLAS_TRANSPOSE TransB, DENSE_PARAM p) {
-  if (Order == CblasColMajor) i8gemm(TransA, TransB, p.M, p.N, p.K, p.alpha.i[0], p.A, p.lda, p.B, p.ldb, p.beta.i[0], p.C, p.ldc);
-  else                        i8gemm(TransB, TransA, p.N, p.M, p.K, p.alpha.i[0], p.B, p.ldb, p.A, p.lda, p.beta.i[0], p.C, p.ldc);
-}
-
-inline void cblas_i16gemv_(const enum CBLAS_ORDER Order, const enum CBLAS_TRANSPOSE TransA, DENSE_PARAM p) {
-  i16gemv(TransA, p.M, p.N, p.alpha.i[0], p.A, p.lda, p.B, p.ldb, p.beta.i[0], p.C, p.ldc);
-}
-
-inline void cblas_i16gemm_(const enum CBLAS_ORDER Order, const enum CBLAS_TRANSPOSE TransA, const enum CBLAS_TRANSPOSE TransB, DENSE_PARAM p) {
-  if (Order == CblasColMajor) i16gemm(TransA, TransB, p.M, p.N, p.K, p.alpha.i[0], p.A, p.lda, p.B, p.ldb, p.beta.i[0], p.C, p.ldc);
-  else                        i16gemm(TransB, TransA, p.N, p.M, p.K, p.alpha.i[0], p.B, p.ldb, p.A, p.lda, p.beta.i[0], p.C, p.ldc);
-}
-
-inline void cblas_i32gemv_(const enum CBLAS_ORDER Order, const enum CBLAS_TRANSPOSE TransA, DENSE_PARAM p) {
-  i32gemv(TransA, p.M, p.N, p.alpha.i[0], p.A, p.lda, p.B, p.ldb, p.beta.i[0], p.C, p.ldc);
-}
-
-inline void cblas_i32gemm_(const enum CBLAS_ORDER Order, const enum CBLAS_TRANSPOSE TransA, const enum CBLAS_TRANSPOSE TransB, DENSE_PARAM p) {
-  if (Order == CblasColMajor) i32gemm(TransA, TransB, p.M, p.N, p.K, p.alpha.i[0], p.A, p.lda, p.B, p.ldb, p.beta.i[0], p.C, p.ldc);
-  else                        i32gemm(TransB, TransA, p.N, p.M, p.K, p.alpha.i[0], p.B, p.ldb, p.A, p.lda, p.beta.i[0], p.C, p.ldc);
-}
-
-inline void cblas_i64gemv_(const enum CBLAS_ORDER Order, const enum CBLAS_TRANSPOSE TransA, DENSE_PARAM p) {
-  i64gemv(TransA, p.M, p.N, p.alpha.i[0], p.A, p.lda, p.B, p.ldb, p.beta.i[0], p.C, p.ldc);
-}
-
-inline void cblas_i64gemm_(const enum CBLAS_ORDER Order, const enum CBLAS_TRANSPOSE TransA, const enum CBLAS_TRANSPOSE TransB, DENSE_PARAM p) {
-  if (Order == CblasColMajor) i64gemm(TransA, TransB, p.M, p.N, p.K, p.alpha.i[0], p.A, p.lda, p.B, p.ldb, p.beta.i[0], p.C, p.ldc);
-  else                        i64gemm(TransB, TransA, p.N, p.M, p.K, p.alpha.i[0], p.B, p.ldb, p.A, p.lda, p.beta.i[0], p.C, p.ldc);
-}
-
-inline void cblas_vgemm_(const enum CBLAS_ORDER Order, const enum CBLAS_TRANSPOSE TransA, const enum CBLAS_TRANSPOSE TransB, DENSE_PARAM p) {
-  if (Order == CblasColMajor) vgemm(TransA, TransB, p.M, p.N, p.K, p.alpha.v[0], p.A, p.lda, p.B, p.ldb, p.beta.v[0], p.C, p.ldc);
-  else                        vgemm(TransB, TransA, p.N, p.M, p.K, p.alpha.v[0], p.B, p.ldb, p.A, p.lda, p.beta.v[0], p.C, p.ldc);
-}
-
-inline void cblas_sgemv_(const enum CBLAS_ORDER Order, const enum CBLAS_TRANSPOSE TransA, DENSE_PARAM p) {
-  cblas_sgemv(Order, TransA, p.M, p.N, p.alpha.d[0], p.A, p.lda, p.B, p.ldb, p.beta.d[0], p.C, p.ldc);
-}
-
-inline void cblas_sgemm_(const enum CBLAS_ORDER Order, const enum CBLAS_TRANSPOSE TransA, const enum CBLAS_TRANSPOSE TransB, DENSE_PARAM p) {
-  cblas_sgemm(Order, TransA, TransB, p.M, p.N, p.K, p.alpha.d[0], p.A, p.lda, p.B, p.ldb, p.beta.d[0], p.C, p.ldc);
-}
-
-inline void cblas_dgemv_(const enum CBLAS_ORDER Order, const enum CBLAS_TRANSPOSE TransA, DENSE_PARAM p) {
-  cblas_dgemv(Order, TransA, p.M, p.N, p.alpha.d[0], p.A, p.lda, p.B, p.ldb, p.beta.d[0], p.C, p.ldc);
-}
-
-inline void cblas_dgemm_(const enum CBLAS_ORDER Order, const enum CBLAS_TRANSPOSE TransA, const enum CBLAS_TRANSPOSE TransB, DENSE_PARAM p) {
-  cblas_dgemm(Order, TransA, TransB, p.M, p.N, p.K, p.alpha.d[0], p.A, p.lda, p.B, p.ldb, p.beta.d[0], p.C, p.ldc);
-}
-
-inline void cblas_cgemv_(const enum CBLAS_ORDER Order, const enum CBLAS_TRANSPOSE TransA, DENSE_PARAM p) {
-  cblas_cgemv(Order, TransA, p.M, p.N, &(p.alpha.c), p.A, p.lda, p.B, p.ldb, &(p.beta.c), p.C, p.ldc);
-}
-
-inline void cblas_cgemm_(const enum CBLAS_ORDER Order, const enum CBLAS_TRANSPOSE TransA, const enum CBLAS_TRANSPOSE TransB, DENSE_PARAM p) {
-  cblas_cgemm(Order, TransA, TransB, p.M, p.N, p.K, &(p.alpha.c), p.A, p.lda, p.B, p.ldb, &(p.beta.c), p.C, p.ldc);
-}
-
-inline void cblas_zgemv_(const enum CBLAS_ORDER Order, const enum CBLAS_TRANSPOSE TransA, DENSE_PARAM p) {
-  cblas_zgemv(Order, TransA, p.M, p.N, &(p.alpha.z), p.A, p.lda, p.B, p.ldb, &(p.beta.z), p.C, p.ldc);
-}
-
-inline void cblas_zgemm_(const enum CBLAS_ORDER Order, const enum CBLAS_TRANSPOSE TransA, const enum CBLAS_TRANSPOSE TransB, DENSE_PARAM p) {
-  cblas_zgemm(Order, TransA, TransB, p.M, p.N, p.K, &(p.alpha.z), p.A, p.lda, p.B, p.ldb, &(p.beta.z), p.C, p.ldc);
-}
-
-
-#endif

data/ext/nmatrix/dense/blas_header.template.c

@@ -1,52 +0,0 @@
-/////////////////////////////////////////////////////////////////////
-// = NMatrix
-//
-// A linear algebra library for scientific computation in Ruby.
-// NMatrix is part of SciRuby.
-//
-// NMatrix was originally inspired by and derived from NArray, by
-// Masahiro Tanaka: http://narray.rubyforge.org
-//
-// == Copyright Information
-//
-// SciRuby is Copyright (c) 2010 - 2012, Ruby Science Foundation
-// NMatrix is Copyright (c) 2012, Ruby Science Foundation
-//
-// Please see LICENSE.txt for additional copyright notices.
-//
-// == Contributing
-//
-// By contributing source code to SciRuby, you agree to be bound by
-// our Contributor Agreement:
-//
-// * https://github.com/SciRuby/sciruby/wiki/Contributor-Agreement
-//
-// == blas.c
-//
-// blas.c is automatically generated by generator.rb. Do not modify
-// it directly!
-//
-// This file contains C ports of BLAS functions that work on integer
-// types and eventually rationals. You can find the original template
-// in ext/nmatrix/blas/igemm.template.c.
-//
-// The port was accomplished using f2c (on dgemm.f) and a magnifying
-// glass.
-//
-// Note that this is in no way comparable to ATLAS. Why?
-// * We didn't test any options other than CblasNoTrans (for A and B)
-// * It doesn't use any of that cool cross-over crap (e.g.,
-//   Strassen's algorithm)
-// * It really hasn't been tested exhaustively in any way, shape, or
-//   form.
-//
-// This file also contains rational math helper functions so that the
-// aforementioned port will work with rationals too. These are in
-// ext/nmatrix/blas/rationalmath.template.c. They are derived from
-// rational.c in Ruby 1.9.3.
-
-#include "nmatrix.h"
-
-
-
-

data/ext/nmatrix/dense/elementwise.template.c

@@ -1,107 +0,0 @@
-
-int nm_d_%%TYPE_ABBREV%%_elementwise(const %%TYPE%%* A, const %%TYPE%%* B, %%TYPE%%* C, size_t n, enum NMatrix_Ops op)
-{
-  size_t i;
-  //fprintf(stderr, "elementwise: n=%d, op=%c\n", n, op);
-
-  switch (op) {
-  case '+':
-    for (i = 0; i < n; ++i) {
-      %%TYPE C[i] = A[i] + B[i]%%
-    }
-    break;
-  case '-':
-    for (i = 0; i < n; ++i) {
-      %%TYPE C[i] = A[i] - B[i]%%
-    }
-    break;
-  case '*':
-    for (i = 0; i < n; ++i) {
-      %%TYPE C[i] = A[i] * B[i]%%
-    }
-    break;
-  case '/':
-    for (i = 0; i < n; ++i) {
-      %%TYPE C[i] = A[i] / B[i]%%
-    }
-    break;
-  case '%':
-    for (i = 0; i < n; ++i) {
-      %%TYPE C[i] = A[i] % B[i]%%
-    }
-    break;
-  case '!':
-    for (i = 0; i < n; ++i) {
-      %%TYPE C[i] = !A[i]%%
-    }
-    break;
-  case NM_OP_NEG:
-    for (i = 0; i < n; ++i) {
-      %%TYPE C[i] = -A[i]%%
-    }
-    break;
-  case NM_OP_EQEQ:
-    for (i = 0; i < n; ++i) {
-      %%TYPE C[i] = A[i] == B[i]%%
-    }
-    break;
-  case NM_OP_NEQ:
-    for (i = 0; i < n; ++i) {
-      %%TYPE C[i] = A[i] != B[i]%%
-    }
-    break;
-  case '>':
-    for (i = 0; i < n; ++i) {
-      %%TYPE C[i] = A[i] > B[i]%%
-    }
-    break;
-  case '<':
-    for (i = 0; i < n; ++i) {
-      %%TYPE C[i] = A[i] < B[i]%%
-    }
-    break;
-  case NM_OP_GTE:
-    for (i = 0; i < n; ++i) {
-      %%TYPE C[i] = A[i] >= B[i]%%
-    }
-    break;
-  case NM_OP_LTE:
-    for (i = 0; i < n; ++i) {
-      %%TYPE C[i] = A[i] <= B[i]%%
-    }
-    break;
-  case '~':
-    for (i = 0; i < n; ++i) {
-      %%TYPE C[i] = ~A[i]%%
-    }
-    break;
-  case '&':
-    for (i = 0; i < n; ++i) {
-      %%TYPE C[i] = A[i] & B[i]%%
-    }
-    break;
-  case '|':
-    for (i = 0; i < n; ++i) {
-      %%TYPE C[i] = A[i] | B[i]%%
-    }
-    break;
-  case '^':
-    for (i = 0; i < n; ++i) {
-      %%TYPE C[i] = A[i] ^ B[i]%%
-    }
-    break;
-  case NM_OP_LSH:
-    for (i = 0; i < n; ++i) {
-      %%TYPE C[i] = A[i] << B[i]%%
-    }
-    break;
-  case NM_OP_RSH:
-    for (i = 0; i < n; ++i) {
-      %%TYPE C[i] = A[i] >> B[i]%%
-    }
-    break;
-  default:
-    rb_raise(rb_eNotImpError, "Unrecognized element-wise operator");
-  }
-  return 0;
-}