daru_lite 0.1

data/benchmarks/TradeoffData.csv

@@ -0,0 +1,65 @@
+"Group","Treatment","Replicate","RelativeFitness"
+"BKB","Tube",1,0.869962555792838
+"BKB","Tube",2,1.00036299125423
+"BKB","Tube",3,0.982935090384188
+"BAC","Tube",1,0.810391635206191
+"BAC","Tube",2,0.795106571577928
+"JDK","Tube",1,0.849203581734814
+"JDK","Tube",2,0.917636977577209
+"JDK","Tube",3,0.905323024195181
+"ETH","Tube",1,0.930820887284085
+"ETH","Tube",2,0.958183317853959
+"ETH","Tube",3,0.91428823286218
+"SWI","Tube",1,0.918513532826773
+"SWI","Tube",2,0.909023164202865
+"SWI","Tube",3,0.928404818223812
+"PPP","Tube",1,0.990500457882474
+"PPP","Tube",2,0.97156464183624
+"PPP","Tube",3,0.948766905642272
+"ECO","Tube",1,0.996870763277447
+"ECO","Tube",2,0.976750424056972
+"ECO","Tube",3,0.939479247244218
+"DOS","Tube",1,0.9461642789306
+"DOS","Tube",2,0.951056617451754
+"DOS","Tube",3,0.939563175900147
+"FIT","Tube",1,0.942215594296048
+"FIT","Tube",2,0.926698027408171
+"FIT","Tube",3,1.00031750759377
+"HHE","Tube",1,0.944414164259624
+"HHE","Tube",2,0.95194592074032
+"HHE","Tube",3,0.922485751593779
+"H2W","Tube",1,0.915304498822462
+"H2W","Tube",2,0.853906227834699
+"H2W","Tube",3,0.938698147417512
+"BKB","Dish",1,1.15254427639376
+"BKB","Dish",2,1.28708514998039
+"BKB","Dish",3,1.50741545998468
+"BAC","Dish",2,1.65223419104399
+"BAC","Dish",3,1.61502230247434
+"JDK","Dish",1,1.5102682623396
+"JDK","Dish",2,1.58270078151532
+"JDK","Dish",3,1.54715152852448
+"ETH","Dish",1,1.61281555981988
+"ETH","Dish",2,1.36445572541848
+"ETH","Dish",3,1.47155233724852
+"SWI","Dish",1,1.36255560722945
+"SWI","Dish",2,1.51569228710501
+"SWI","Dish",3,1.47714121664773
+"PPP","Dish",1,1.50896917413568
+"PPP","Dish",2,1.58138592886817
+"PPP","Dish",3,1.55356839081014
+"ECO","Dish",1,1.69927564777656
+"ECO","Dish",2,1.45605668065038
+"ECO","Dish",3,1.52825762511041
+"DOS","Dish",1,1.59453120031454
+"DOS","Dish",2,1.58132511409296
+"DOS","Dish",3,1.58558683941181
+"FIT","Dish",1,1.01468578343171
+"FIT","Dish",2,0.955220815085047
+"FIT","Dish",3,1.03597298511451
+"HHE","Dish",1,1.49399422139513
+"HHE","Dish",2,1.32980278545457
+"HHE","Dish",3,1.4505220676174
+"H2W","Dish",1,1.52460143511286
+"H2W","Dish",2,1.53958247554139
+"H2W","Dish",3,1.51149897493835

data/benchmarks/csv_reading.rb

@@ -0,0 +1,22 @@
+# Date - 28 june 2016. daru version - 0.1.3.1
+# Compare speed of Ruby stdlib CSV and DataFrame.from_csv.
+
+require 'benchmark'
+require 'csv'
+require 'daru_lite'
+
+Benchmark.bm do |x|
+  x.report("Ruby CSV") do
+    CSV.read("TradeoffData.csv")
+  end
+
+  x.report("DataFrame.from_csv") do
+    DaruLite::DataFrame.from_csv("TradeoffData.csv")
+  end
+end
+
+# FIXME: Improve this. It's 4 times slower than Ruby CSV reading!!
+
+#        user     system      total        real
+# Ruby CSV  0.010000   0.000000   0.010000 (  0.002385)
+# DataFrame.from_csv  0.000000   0.000000   0.000000 (  0.008225)

data/benchmarks/dataframe_creation.rb

@@ -0,0 +1,39 @@
+$:.unshift File.expand_path("../../lib", __FILE__)
+
+require 'benchmark'
+require 'daru_lite'
+
+Benchmark.bm do |x|
+  x.report("Create with Arrays and clone") do
+    df = DaruLite::DataFrame.new({
+      a: 100000.times.map { rand },
+      b: 100000.times.map { rand },
+      c: 100000.times.map { rand }
+    })
+  end
+
+  x.report("Create with Vectors and clone") do
+    df = DaruLite::DataFrame.new({
+      a: DaruLite::Vector.new(100000.times.map { rand }),
+      b: DaruLite::Vector.new(100000.times.map { rand }),
+      c: DaruLite::Vector.new(100000.times.map { rand })
+    })
+  end
+
+  x.report("Create with Vector and dont clone") do
+    df = DaruLite::DataFrame.new({
+      a: DaruLite::Vector.new(100000.times.map { rand }),
+      b: DaruLite::Vector.new(100000.times.map { rand }),
+      c: DaruLite::Vector.new(100000.times.map { rand })
+    }, clone: false)
+  end
+
+  x.report("Create by row from Arrays") do
+  end
+end
+
+#                           ===== Benchmarks =====
+#                                       user     system      total        real
+# Create with Arrays and clone       0.940000   0.010000   0.950000 (  0.959851)
+# Create with Vectors and clone      1.950000   0.020000   1.970000 (  1.966835)
+# Create with Vector and dont clone  1.170000   0.000000   1.170000 (  1.177132)

data/benchmarks/db_loading.rb

@@ -0,0 +1,34 @@
+$:.unshift File.expand_path("../../lib", __FILE__)
+
+require 'benchmark'
+require 'daru_lite'
+require 'sqlite3'
+require 'dbi'
+require 'active_record'
+
+db_name = 'daru_lite_test.sqlite'
+FileUtils.rm(db_name) if File.file?(db_name)
+
+SQLite3::Database.new(db_name).tap do |db|
+  db.execute "create table accounts(id integer, name varchar, age integer, primary key(id))"
+
+  values = 1.upto(100_000).map { |i| %!(#{i},"name_#{i}",#{rand(100)})! }.join(",")
+  db.execute "insert into accounts values #{values}"
+end
+
+ActiveRecord::Base.establish_connection("sqlite3:#{db_name}")
+ActiveRecord::Base.connection
+
+class Account < ActiveRecord::Base; end
+
+Benchmark.bm do |x|
+  x.report("DataFrame.from_sql") do
+    DaruLite::DataFrame.from_sql(ActiveRecord::Base.connection, "SELECT * FROM accounts")
+  end
+
+  x.report("DataFrame.from_activerecord") do
+    DaruLite::DataFrame.from_activerecord(Account.all)
+  end
+end
+
+FileUtils.rm(db_name)

data/benchmarks/duplicating.rb

@@ -0,0 +1,45 @@
+$:.unshift File.expand_path("../../lib", __FILE__)
+
+require 'benchmark'
+require 'daru_lite'
+
+# Check scaling
+base_n = 10000
+0.upto(2) do |iscale|
+  n = base_n * 2**iscale
+
+  df_h = ('a'..'z').map { |v| v.to_sym }.reduce({}) do |h, v|
+    h[v] = DaruLite::Vector.new(1.upto(n).to_a)
+    h
+  end
+
+  df = DaruLite::DataFrame.new(df_h)
+
+  Benchmark.bm do |bm|
+    bm.report("dupe (n=#{n})") do
+      df.dup
+    end
+  end
+end
+
+#                   ===== Benchmarks =====
+# System: iMac Late 2013 3.5GHz Core i7
+#
+#       user     system      total        real
+#dupe (n=10000)  0.590000   0.020000   0.610000 (  0.613648)
+#       user     system      total        real
+#dupe (n=20000)  1.170000   0.040000   1.210000 (  1.236629)
+#       user     system      total        real
+#dupe (n=40000)  2.390000   0.070000   2.460000 (  2.511199)
+
+
+
+
+#                   ===== Prior Benchmarks (Daru 0.1.2 - 2707559369c03894a8394714820aabf116b99b20 - 2016-04-25) =====
+# Note that the n here is 100x smaller than above
+#       user     system      total        real
+#dupe (n=100)  0.220000   0.000000   0.220000 (  0.227924)
+#       user     system      total        real
+#dupe (n=200)  0.850000   0.000000   0.850000 (  0.856591)
+#       user     system      total        real
+#dupe (n=400)  3.370000   0.020000   3.390000 (  3.428211)

data/benchmarks/group_by.rb

@@ -0,0 +1,32 @@
+$:.unshift File.expand_path("../../lib", __FILE__)
+
+require 'benchmark'
+require 'daru_lite'
+
+data = DaruLite::DataFrame.from_csv 'TradeoffData.csv'
+
+Benchmark.bm do |x|
+  x.report("Single column grouping") do
+    @single = data.group_by(['Treatment'])
+  end
+
+  x.report("Multi-column grouping") do
+    @multi = data.group_by(['Group', 'Treatment'])
+  end
+
+  x.report("Single mean") do
+    @single.mean
+  end
+
+  x.report("Multi mean") do
+    @multi.mean
+  end
+end
+
+#                    ===== Benchmarks =====
+#
+#                          user     system      total        real
+# Single column grouping  0.000000   0.000000   0.000000  (0.000340)
+# Multi-column grouping   0.000000   0.000000   0.000000  (0.000855)
+# Single mean             0.000000   0.000000   0.000000  (0.001208)
+# Multi mean              0.000000   0.000000   0.000000  (0.004892)

data/benchmarks/joining.rb

@@ -0,0 +1,52 @@
+$:.unshift File.expand_path("../../lib", __FILE__)
+
+require 'benchmark'
+require 'daru_lite'
+
+# Check scaling
+base_n = 10000
+0.upto(2) do |iscale|
+  n = base_n * 2**iscale
+  keys = (1..(n)).to_a
+  base_data = { idx: 1.upto(n).to_a, keys: 1.upto(n).map { |v| keys[Random.rand(n)]}}
+  lookup_hash = keys.map { |k| [k, k * 100]}.to_h
+
+  base_data_df = DaruLite::DataFrame.new(base_data)
+  lookup_df = DaruLite::DataFrame.new({ keys: lookup_hash.keys, values: lookup_hash.values })
+
+  Benchmark.bm do |bm|
+    bm.report("Inner join (n=#{n})") do
+      base_data_df.join(lookup_df, on: [:keys], how: :inner)
+    end
+
+    bm.report("Outer join (n=#{n})") do
+      base_data_df.join(lookup_df, on: [:keys], how: :outer)
+    end
+  end
+end
+
+#                   ===== Benchmarks =====
+# System: MacBook Pro Mid 2014 3GHz Core i7
+#
+#       user     system      total        real
+#Inner join (n=10000)  0.170000   0.000000   0.170000 (  0.182254)
+#Outer join (n=10000)  0.200000   0.000000   0.200000 (  0.203022)
+#       user     system      total        real
+#Inner join (n=20000)  0.380000   0.000000   0.380000 (  0.387600)
+#Outer join (n=20000)  0.410000   0.000000   0.410000 (  0.415644)
+#       user     system      total        real
+#Inner join (n=40000)  0.720000   0.010000   0.730000 (  0.743787)
+#Outer join (n=40000)  0.810000   0.010000   0.820000 (  0.840871)
+
+
+#                   ===== Prior Benchmarks (Daru 0.1.2 - prior to sorted merge algorithm) =====
+# Note that the n here is 10x smaller than above
+#       user     system      total        real
+#Inner join (n=1000)  0.170000   0.010000   0.180000 (  0.175585)
+#Outer join (n=1000)  0.990000   0.000000   0.990000 (  1.004305)
+#       user     system      total        real
+#Inner join (n=2000)  0.440000   0.010000   0.450000 (  0.446748)
+#Outer join (n=2000)  3.880000   0.010000   3.890000 (  3.926399)
+#       user     system      total        real
+#Inner join (n=4000)  1.670000   0.010000   1.680000 (  1.680742)
+#Outer join (n=4000) 15.640000   0.060000  15.700000 ( 15.855202)

data/benchmarks/row_access.rb

@@ -0,0 +1,41 @@
+$:.unshift File.expand_path("../../lib", __FILE__)
+
+require 'benchmark'
+require 'daru_lite'
+
+df = DaruLite::DataFrame.new({
+  a: 100000.times.map { rand },
+  b: 100000.times.map { rand },
+  c: 100000.times.map { rand }
+})
+
+Benchmark.bm do |x|
+  x.report("Access single row") do
+    df.row[50]
+  end
+
+  x.report("Access rows by comma") do
+    df.row[*(5..40000).to_a.shuffle]
+  end
+
+  x.report("Individual rows") do
+    rows = []
+    index = (5..40000).to_a.shuffle
+    index.each do |a|
+      rows << df.row[a].to_a
+    end
+
+    DaruLite::DataFrame.rows(rows, order: [:a,:b,:c], index: index)
+  end
+
+  x.report("Access rows by range") do
+    df.row[5..40000]
+  end
+end
+
+#                     ==== Benchmarks ====
+#                         user     system      total        real
+# Access single row     0.000000   0.000000   0.000000 (  0.000059)
+# Access rows by comma  1.410000   0.010000   1.420000 (  1.420426)
+# Individual rows       1.480000   0.000000   1.480000 (  1.488531)
+# Access rows by range  1.440000   0.010000   1.450000 (  1.436750)

data/benchmarks/row_assign.rb

@@ -0,0 +1,36 @@
+$:.unshift File.expand_path("../../lib", __FILE__)
+
+require 'benchmark'
+require 'daru_lite'
+
+df = DaruLite::DataFrame.new({
+  a: 100000.times.map { rand },
+  b: 100000.times.map { rand },
+  c: 100000.times.map { rand }
+})
+
+Benchmark.bm do |x|
+  x.report("Set a single row with Array") do
+    df.row[5] = [55,22,65]
+  end
+
+  x.report("Set a single row with DaruLite::Vector") do
+    df.row[3456] = DaruLite::Vector.new([3,54,11], index: [:b,:e,:a])
+  end
+
+  x.report("Create a new row with Array") do
+    df.row[100001] = [34,66,11]
+  end
+
+  x.report("Create a new row with DaruLite::Vector") do
+    df.row[100005] = DaruLite::Vector.new([34,66,11], index: [:a,:b,:t])
+  end
+end
+
+#                      ==== Benchmarks ====
+#
+#                                       user     system      total        real
+# Set a single row with Array         0.600000   0.000000   0.600000 (  0.604718)
+# Set a single row with DaruLite::Vector  0.600000   0.000000   0.600000 (  0.598599)
+# Create a new row with Array         0.840000   0.010000   0.850000 (  0.858349)
+# Create a new row with DaruLite::Vector  0.950000   0.000000   0.950000 (  0.950725)

data/benchmarks/sorting.rb

@@ -0,0 +1,51 @@
+$:.unshift File.expand_path("../../lib", __FILE__)
+
+require 'benchmark'
+require 'daru_lite'
+
+vector = DaruLite::Vector.new(10000.times.map.to_a.shuffle)
+df = DaruLite::DataFrame.new({
+  a: vector,
+  b: vector,
+  c: vector
+})
+Benchmark.bm do |x|
+  x.report("Sort a Vector without any args") do
+    vector.sort
+  end
+
+  x.report("Sort vector in descending order with custom <=> operator") do
+    vector.sort(ascending: false) { |a,b| a.to_s <=> b.to_s }
+  end
+
+  x.report("Sort single column of DataFrame") do
+    df.sort([:a])
+  end
+
+  x.report("Sort two columns of DataFrame") do
+    df.sort([:c,:a])
+  end
+
+  x.report("Sort two columns with custom operators in different orders of DataFrame") do
+    df.sort([:c,:a], ascending: [true, false], 
+      by: { c: lambda { |a| a.to_s },
+            a: lambda { |a| a+1 } })
+  end
+end
+
+# FIXME: MASSIVE SPEEDUP NECESSARY!
+
+#                                         ===== Benchamarks =====
+#                                                                             user      system      total      real
+# Sort a Vector without any args                                           0.130000    0.000000 0.130000    (  0.128006)
+# Sort vector in descending order with custom <=> operator                 0.190000    0.000000 0.190000    (  0.184604)
+# Sort single column of DataFrame                                          2502.450000 0.000000 2502.450000 (2503.808073)
+# Sort two columns of DataFrame                                            0.540000    0.000000 0.540000    (  0.537670)
+# Sort two columns with custom operators in different orders of DataFrame  2084.160000 7.260000 2091.420000 (2092.716603)
+
+#                                         ===== Current Benchamarks =====
+# Sort a Vector without any args                                           0.070000   0.000000   0.070000 (  0.070323)
+# Sort vector in descending order with custom <=> operator                 0.120000   0.000000   0.120000 (  0.119462)
+# Sort single column of DataFrame                                          0.940000   0.010000   0.950000 (  0.950349)
+# Sort two columns of DataFrame                                            1.490000   0.010000   1.500000 (  1.505680)
+# Sort two columns with custom operators in different orders of DataFrame  1.480000   0.000000   1.480000 (  1.495839)

data/benchmarks/statistics.rb

@@ -0,0 +1,28 @@
+require 'daru_lite'
+require 'benchmark'
+
+vector = DaruLite::Vector.new(
+  (10**6).times.map.to_a.shuffle,
+  missing_values: 100.times.map.to_a.shuffle
+  )
+
+vector = DaruLite::Vector.new(
+  10000.times.map.to_a.shuffle,
+  missing_values: 100.times.map.to_a.shuffle,
+  )
+
+Benchmark.bm do |x|
+  x.report("Mean of a vector") do
+    vector.mean
+  end
+
+  x.report("Minimum of a vector") do
+    vector.min
+  end
+end
+
+#                    ===== Benchmarks =====
+#
+#                                     user     system      total        real
+# Mean of a vector                 0.130000   0.010000   0.140000 (  0.145534)
+# Min of a vector                  0.150000   0.000000   0.150000 (  0.163623)

data/benchmarks/vector_access.rb

@@ -0,0 +1,31 @@
+$:.unshift File.expand_path("../../lib", __FILE__)
+
+require 'benchmark'
+require 'daru_lite'
+
+df = DaruLite::DataFrame.new({
+  a: 10000.times.map { rand },
+  b: 10000.times.map { rand },
+  c: 10000.times.map { rand }
+})
+
+Benchmark.bm do |x|
+  x.report("Single Vector access") do
+    df[:a]
+  end
+
+  x.report("Access as range") do
+    df[:a..:c]
+  end
+
+  x.report("Access with commas") do
+    df[:a, :c]
+  end
+end
+
+# ======== Benchmarks =======
+#
+#                         user     system      total        real
+# Single Vector access  0.000000   0.000000   0.000000 (  0.000012)
+# Access as range       0.090000   0.000000   0.090000 (  0.084584)
+# Access with commas    0.050000   0.000000   0.050000 (  0.051951)

data/benchmarks/vector_assign.rb

@@ -0,0 +1,42 @@
+$:.unshift File.expand_path("../../lib", __FILE__)
+
+require 'benchmark'
+require 'daru_lite'
+
+df = DaruLite::DataFrame.new({
+  a: 100000.times.map { rand },
+  b: 100000.times.map { rand },
+  c: 100000.times.map { rand }
+})
+
+index = DaruLite::Index.new((0...100000).to_a.shuffle)
+
+Benchmark.bm do |x|
+  x.report("Assign new vector as Array") do
+    df[:d] = 100000.times.map { rand }
+  end
+
+  x.report("Reassign same vector as Array") do
+    df[:a] = 100000.times.map { rand }
+  end
+
+  x.report("Assign new Vector as DaruLite::Vector") do
+    df[:e] = DaruLite::Vector.new(100000.times.map { rand })
+  end
+
+  x.report("Reassign same Vector as DaruLite::Vector") do
+    df[:b] = DaruLite::Vector.new(100000.times.map { rand })
+  end
+
+  x.report("Reassgin differently indexed DaruLite::Vector") do
+    df[:b] = DaruLite::Vector.new(100000.times.map { rand }, index: index)
+  end
+end
+
+#                           ===== Benchmarks =====
+#                                             user     system      total        real
+# Assign new vector as Array                0.370000   0.000000   0.370000 (0.364515)
+# Reassign same vector as Array             0.470000   0.000000   0.470000 (0.471408)
+# Assign new Vector as DaruLite::Vector         0.940000   0.000000   0.940000 (0.947879)
+# Reassign same Vector as DaruLite::Vector      0.760000   0.020000   0.780000 (0.769969)
+# Reassgin differently indexed DaruLite::Vector <Too embarassingly slow.>

data/benchmarks/where_clause.rb

@@ -0,0 +1,48 @@
+$:.unshift File.expand_path("../../lib", __FILE__)
+
+require 'benchmark'
+require 'daru_lite'
+
+df = DaruLite::DataFrame.new({
+  a: 100000.times.map { |i| i },
+  b: 100000.times.map { |i| i },
+  c: 100000.times.map { |i| i }
+}, index: DaruLite::Index.new(100000.times.map.to_a.shuffle))
+
+puts "Benchmarking DataFrame#where\n"
+Benchmark.bm do |x|
+  x.report("Basic one liner") do
+    df.where(df[:a].mt(2341))
+  end
+
+  x.report("Little complex statement") do
+    df.where(df[:a].lt(235) | df[:b].eq(2341) | df[:c].in([35,355,22]))
+  end
+end
+
+puts "Benchmarking Vector#where\n"
+v = DaruLite::Vector.new(
+  100000.times.map { |i| i }, index: 100000.times.map.to_a.shuffle)
+
+Benchmark.bm do |x|
+  x.report("Basic one liner") do
+    v.where(v.mteq(1000))
+  end
+
+  x.report("Little complex statement") do
+    v.where(v.lt(235) & v.eq(2341) | v.in([23,511,55]))
+  end
+end
+
+#                     ====== Benchmarks ======
+#
+# Benchmarking DataFrame#where
+#
+#                             user     system      total      real
+# Basic one liner           0.700000   0.000000   0.700000 (0.703532)
+# Little complex statement  0.120000   0.000000   0.120000 (0.121765)
+#
+# Benchmarking Vector#where
+#                             user     system      total      real
+# Basic one liner           0.240000   0.000000   0.240000 (0.245787)
+# Little complex statement  0.100000   0.000000   0.100000 (0.094423)

data/benchmarks/where_vs_filter.rb

@@ -0,0 +1,28 @@
+$:.unshift File.expand_path("../../lib", __FILE__)
+
+require 'benchmark'
+require 'daru_lite'
+
+df = DaruLite::DataFrame.new({
+  a: [1,2,3,4,5,6]*100,
+  b: ['a','b','c','d','e','f']*100,
+  c: [11,22,33,44,55,66]*100
+}, index: (1..600).to_a.shuffle)
+
+Benchmark.bm do |x|
+  x.report("where") do
+    df.where(df[:a].eq(2) | df[:c].eq(55))
+  end
+
+  x.report("filter_rows") do
+    df.filter(:row) do |r|
+      r[:a] == 2 or r[:c] == 55
+    end
+  end
+end
+
+#             ===== Benchmarks =====
+#
+#                user     system      total        real
+# where        0.000000   0.000000   0.000000 (  0.002575)
+# filter_rows  0.210000   0.000000   0.210000 (  0.205403)

data/daru_lite.gemspec

@@ -0,0 +1,55 @@
+# coding: utf-8
+$:.unshift File.expand_path("../lib", __FILE__)
+
+require 'daru_lite/version.rb'
+
+DaruLite::DESCRIPTION = <<MSG
+Daru (Data Analysis in RUby) is a library for analysis, manipulation and visualization
+of data. Daru works seamlessly accross interpreters and leverages interpreter-specific
+optimizations whenever they are available.
+
+It is the default data storage gem for all the statsample gems (glm, timeseries, etc.)
+and can be used with many others like mixed_models, gnuplotrb and iruby.
+
+Daru Lite is a fork of Daru that aims to focus on data manipulation and stability.
+MSG
+
+Gem::Specification.new do |spec|
+  spec.name          = 'daru_lite'
+  spec.version       = DaruLite::VERSION
+  spec.authors       = ['Thomas Naude-Filonnière', 'Maxime Lasserre', 'Julie Thomas', 'Amar Slaoua', 'Mourtada Belhantri']
+  spec.summary       = %q{Data Analysis in RUby, stripped down}
+  spec.description   = DaruLite::DESCRIPTION
+  spec.homepage      = "https://github.com/pollandroll/daru"
+  spec.license       = 'BSD-2-Clause'
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  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.add_development_dependency 'activerecord', '~> 6.0'
+  spec.add_development_dependency 'awesome_print', '~> 1.9.2'
+  spec.add_development_dependency 'bundler', '~> 2.1', '>= 2.1.4'
+  spec.add_development_dependency 'dbd-sqlite3', '~> 1.2.5'
+  spec.add_development_dependency 'dbi', '~> 0.4.5'
+  spec.add_development_dependency 'distribution', '~> 0.8'
+  spec.add_development_dependency 'matrix', '~> 0.4.2'
+  spec.add_development_dependency 'nokogiri', '~> 1.16.2'
+  spec.add_development_dependency 'prime', '~> 0.1.2'
+  spec.add_development_dependency 'pry', '~> 0.14'
+  spec.add_development_dependency 'pry-byebug', '~> 3.10.1'
+  spec.add_development_dependency 'rake', '~> 13.0'
+  spec.add_development_dependency 'rspec', '~> 3.11'
+  spec.add_development_dependency 'rspec-its', '~> 1.3.0'
+  spec.add_development_dependency 'rubocop', '~> 1.60'
+  spec.add_development_dependency 'rubocop-performance', '~> 1.20.2'
+  spec.add_development_dependency 'rubocop-rspec', '~> 2.25'
+  spec.add_development_dependency 'ruby-prof', '~> 1.7.0'
+  spec.add_development_dependency 'simplecov', '~> 0.22.0'
+  spec.add_development_dependency 'spreadsheet', '~> 1.3.0'
+  spec.add_development_dependency 'sqlite3', '~> 1.7.2'
+  # issue : https://github.com/SciRuby/daru/issues/493 occured
+  # with latest version of sqlite3
+  spec.add_development_dependency 'webmock', '~> 3.20.0'
+end

data/images/README.md

@@ -0,0 +1,5 @@
+# Images
+
+This folder contains images that are being used in the project README to display code examples.
+
+Do not change any names of files.