Ruby Vector Benchmarks (matrix vs nmatrix vs numo/narray)

results.txt

Warming up --------------------------------------
   V * F         (2)   112.620k i/100ms
   V.dot(V)      (2)    99.728k i/100ms
   NA * F        (2)    37.539k i/100ms
   NA * NA       (2)    58.776k i/100ms
   NM(C) * F     (2)    17.457k i/100ms
   NM(C) * NM(C) (2)    17.103k i/100ms
   NM(R) * F     (2)    17.334k i/100ms
   NM(R) * NM(R) (2)    16.528k i/100ms
   NM(A) * F     (2)    17.521k i/100ms
   NM(A) * NM(A) (2)    17.157k i/100ms
Calculating -------------------------------------
   V * F         (2)      1.535M (± 3.0%) i/s -      7.771M in   5.067611s
   V.dot(V)      (2)      1.282M (± 6.1%) i/s -      6.383M in   5.001888s
   NA * F        (2)    411.410k (± 3.7%) i/s -      2.065M in   5.025496s
   NA * NA       (2)    651.403k (± 5.5%) i/s -      3.291M in   5.069871s
   NM(C) * F     (2)    171.255k (±10.3%) i/s -    855.393k in   5.073985s
   NM(C) * NM(C) (2)    169.694k (± 9.6%) i/s -    838.047k in   5.012810s
   NM(R) * F     (2)    177.680k (± 5.0%) i/s -    901.368k in   5.086147s
   NM(R) * NM(R) (2)    172.652k (± 5.1%) i/s -    875.984k in   5.086181s
   NM(A) * F     (2)    179.729k (± 5.7%) i/s -    911.092k in   5.084696s
   NM(A) * NM(A) (2)    172.339k (± 4.7%) i/s -    875.007k in   5.087616s

Comparison:
   V * F         (2):  1534858.4 i/s
   V.dot(V)      (2):  1281867.2 i/s - 1.20x  slower
   NA * NA       (2):   651402.5 i/s - 2.36x  slower
   NA * F        (2):   411410.4 i/s - 3.73x  slower
   NM(A) * F     (2):   179729.3 i/s - 8.54x  slower
   NM(R) * F     (2):   177680.0 i/s - 8.64x  slower
   NM(R) * NM(R) (2):   172651.6 i/s - 8.89x  slower
   NM(A) * NM(A) (2):   172339.1 i/s - 8.91x  slower
   NM(C) * F     (2):   171255.3 i/s - 8.96x  slower
   NM(C) * NM(C) (2):   169694.0 i/s - 9.04x  slower

Warming up --------------------------------------
  V * F         (20)    45.304k i/100ms
  V.dot(V)      (20)    27.304k i/100ms
  NA * F        (20)    37.133k i/100ms
  NA * NA       (20)    55.407k i/100ms
  NM(C) * F     (20)    12.166k i/100ms
  NM(C) * NM(C) (20)    11.909k i/100ms
  NM(R) * F     (20)    12.380k i/100ms
  NM(R) * NM(R) (20)    11.773k i/100ms
  NM(A) * F     (20)    12.591k i/100ms
  NM(A) * NM(A) (20)    11.827k i/100ms
Calculating -------------------------------------
  V * F         (20)    534.303k (± 3.2%) i/s -      2.673M in   5.007635s
  V.dot(V)      (20)    287.494k (± 4.1%) i/s -      1.447M in   5.041948s
  NA * F        (20)    389.949k (± 4.0%) i/s -      1.968M in   5.054994s
  NA * NA       (20)    662.167k (± 3.9%) i/s -      3.324M in   5.028028s
  NM(C) * F     (20)    123.074k (± 8.8%) i/s -    608.300k in   5.007538s
  NM(C) * NM(C) (20)    117.916k (± 3.6%) i/s -    595.450k in   5.056031s
  NM(R) * F     (20)    126.506k (± 8.9%) i/s -    631.380k in   5.069207s
  NM(R) * NM(R) (20)    118.494k (± 8.0%) i/s -    588.650k in   5.014769s
  NM(A) * F     (20)    131.749k (± 4.6%) i/s -    667.323k in   5.076231s
  NM(A) * NM(A) (20)    123.141k (± 4.0%) i/s -    615.004k in   5.001738s

Comparison:
  NA * NA       (20):   662167.0 i/s
  V * F         (20):   534303.5 i/s - 1.24x  slower
  NA * F        (20):   389948.8 i/s - 1.70x  slower
  V.dot(V)      (20):   287494.0 i/s - 2.30x  slower
  NM(A) * F     (20):   131748.6 i/s - 5.03x  slower
  NM(R) * F     (20):   126506.2 i/s - 5.23x  slower
  NM(A) * NM(A) (20):   123141.0 i/s - 5.38x  slower
  NM(C) * F     (20):   123073.5 i/s - 5.38x  slower
  NM(R) * NM(R) (20):   118494.3 i/s - 5.59x  slower
  NM(C) * NM(C) (20):   117915.5 i/s - 5.62x  slower

Warming up --------------------------------------
 V * F         (200)     7.358k i/100ms
 V.dot(V)      (200)     3.311k i/100ms
 NA * F        (200)    33.183k i/100ms
 NA * NA       (200)    50.734k i/100ms
 NM(C) * F     (200)     3.264k i/100ms
 NM(C) * NM(C) (200)     2.930k i/100ms
 NM(R) * F     (200)     3.296k i/100ms
 NM(R) * NM(R) (200)     2.991k i/100ms
 NM(A) * F     (200)     3.448k i/100ms
 NM(A) * NM(A) (200)     3.165k i/100ms
Calculating -------------------------------------
 V * F         (200)     80.879k (± 5.7%) i/s -    404.690k in   5.020758s
 V.dot(V)      (200)     33.270k (± 4.0%) i/s -    168.861k in   5.083636s
 NA * F        (200)    364.513k (± 3.7%) i/s -      1.825M in   5.013985s
 NA * NA       (200)    581.384k (± 4.7%) i/s -      2.943M in   5.072927s
 NM(C) * F     (200)     33.208k (± 4.0%) i/s -    166.464k in   5.020659s
 NM(C) * NM(C) (200)     30.066k (± 4.2%) i/s -    152.360k in   5.076518s
 NM(R) * F     (200)     33.548k (± 4.0%) i/s -    168.096k in   5.018571s
 NM(R) * NM(R) (200)     29.703k (± 9.0%) i/s -    149.550k in   5.099781s
 NM(A) * F     (200)     35.107k (± 4.6%) i/s -    175.848k in   5.019811s
 NM(A) * NM(A) (200)     31.376k (± 4.7%) i/s -    158.250k in   5.055585s

Comparison:
 NA * NA       (200):   581384.1 i/s
 NA * F        (200):   364512.9 i/s - 1.59x  slower
 V * F         (200):    80878.6 i/s - 7.19x  slower
 NM(A) * F     (200):    35107.2 i/s - 16.56x  slower
 NM(R) * F     (200):    33548.5 i/s - 17.33x  slower
 V.dot(V)      (200):    33270.2 i/s - 17.47x  slower
 NM(C) * F     (200):    33208.2 i/s - 17.51x  slower
 NM(A) * NM(A) (200):    31375.5 i/s - 18.53x  slower
 NM(C) * NM(C) (200):    30065.5 i/s - 19.34x  slower
 NM(R) * NM(R) (200):    29703.3 i/s - 19.57x  slower

vector-bench.rb

#! /usr/bin/env ruby
# -*- ruby -*-

require 'benchmark/ips'
require 'matrix'
require 'nmatrix'
require 'numo/narray'

F = rand

[2, 20, 200].each do |n|
  a = n.times.map { rand }
  Benchmark.ips do |b|
    nmc = ::NMatrix.new([n, 1], [*a], dtype: :float64)
    nmr = ::NMatrix.new([1, n], [*a], dtype: :float64)
    nma = ::N[*a]
    v  = ::Vector[*a]
    na = ::Numo::Float64[*a]
    b.report("V * F         (#{n})") { v * F     }
    b.report("V.dot(V)      (#{n})") { v.dot(v)  }
    b.report("NA * F        (#{n})") { na * F    }
    b.report("NA * NA       (#{n})") { na * na   }
    b.report("NM(C) * F     (#{n})") { nmc * F   }
    b.report("NM(C) * NM(C) (#{n})") { nmc * nmc }
    b.report("NM(R) * F     (#{n})") { nmr * F   }
    b.report("NM(R) * NM(R) (#{n})") { nmr * nmr }
    b.report("NM(A) * F     (#{n})") { nma * F   }
    b.report("NM(A) * NM(A) (#{n})") { nma * nma }

    b.compare!
  end
end