daru_lite 0.3.4 → 0.3.5

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (142) hide show
  1. checksums.yaml +4 -4
  2. data/History.md +60 -0
  3. data/README.md +1 -1
  4. data/lib/daru_lite/category.rb +1 -1
  5. data/lib/daru_lite/date_time/index.rb +2 -2
  6. data/lib/daru_lite/maths/statistics/vector.rb +1 -1
  7. data/lib/daru_lite/version.rb +1 -1
  8. data/lib/daru_lite.rb +1 -0
  9. metadata +54 -284
  10. data/.github/ISSUE_TEMPLATE/bug_report.md +0 -38
  11. data/.github/ISSUE_TEMPLATE/feature_request.md +0 -20
  12. data/.github/dependabot.yml +0 -11
  13. data/.github/workflows/ci.yml +0 -33
  14. data/.gitignore +0 -10
  15. data/.rspec +0 -2
  16. data/.rubocop.yml +0 -27
  17. data/.rubocop_todo.yml +0 -139
  18. data/CONTRIBUTING.md +0 -47
  19. data/Gemfile +0 -2
  20. data/Rakefile +0 -69
  21. data/ReleasePolicy.md +0 -20
  22. data/benchmarks/TradeoffData.csv +0 -65
  23. data/benchmarks/csv_reading.rb +0 -22
  24. data/benchmarks/dataframe_creation.rb +0 -39
  25. data/benchmarks/db_loading.rb +0 -33
  26. data/benchmarks/duplicating.rb +0 -45
  27. data/benchmarks/group_by.rb +0 -32
  28. data/benchmarks/joining.rb +0 -52
  29. data/benchmarks/row_access.rb +0 -41
  30. data/benchmarks/row_assign.rb +0 -36
  31. data/benchmarks/sorting.rb +0 -51
  32. data/benchmarks/statistics.rb +0 -28
  33. data/benchmarks/vector_access.rb +0 -31
  34. data/benchmarks/vector_assign.rb +0 -42
  35. data/benchmarks/where_clause.rb +0 -48
  36. data/benchmarks/where_vs_filter.rb +0 -28
  37. data/daru_lite.gemspec +0 -54
  38. data/daru_lite_test-shm +0 -0
  39. data/daru_lite_test-wal +0 -0
  40. data/images/README.md +0 -5
  41. data/images/con0.png +0 -0
  42. data/images/con1.png +0 -0
  43. data/images/init0.png +0 -0
  44. data/images/init1.png +0 -0
  45. data/images/man0.png +0 -0
  46. data/images/man1.png +0 -0
  47. data/images/man2.png +0 -0
  48. data/images/man3.png +0 -0
  49. data/images/man4.png +0 -0
  50. data/images/man5.png +0 -0
  51. data/images/man6.png +0 -0
  52. data/profile/_base.rb +0 -23
  53. data/profile/df_to_a.rb +0 -10
  54. data/profile/filter.rb +0 -13
  55. data/profile/joining.rb +0 -13
  56. data/profile/sorting.rb +0 -12
  57. data/profile/vector_each_with_index.rb +0 -9
  58. data/profile/vector_new.rb +0 -9
  59. data/spec/accessors/array_wrapper_spec.rb +0 -3
  60. data/spec/category_spec.rb +0 -1767
  61. data/spec/core/group_by_spec.rb +0 -655
  62. data/spec/core/merge_spec.rb +0 -179
  63. data/spec/core/query_spec.rb +0 -347
  64. data/spec/daru_lite_spec.rb +0 -22
  65. data/spec/data_frame/aggregatable_example.rb +0 -65
  66. data/spec/data_frame/buildable_example.rb +0 -109
  67. data/spec/data_frame/calculatable_example.rb +0 -135
  68. data/spec/data_frame/convertible_example.rb +0 -180
  69. data/spec/data_frame/duplicatable_example.rb +0 -134
  70. data/spec/data_frame/fetchable_example.rb +0 -510
  71. data/spec/data_frame/filterable_example.rb +0 -456
  72. data/spec/data_frame/indexable_example.rb +0 -221
  73. data/spec/data_frame/iterable_example.rb +0 -481
  74. data/spec/data_frame/joinable_example.rb +0 -131
  75. data/spec/data_frame/missable_example.rb +0 -47
  76. data/spec/data_frame/pivotable_example.rb +0 -297
  77. data/spec/data_frame/queryable_example.rb +0 -92
  78. data/spec/data_frame/setable_example.rb +0 -513
  79. data/spec/data_frame/sortable_example.rb +0 -368
  80. data/spec/dataframe_spec.rb +0 -1342
  81. data/spec/date_time/data_spec.rb +0 -197
  82. data/spec/date_time/date_time_index_helper_spec.rb +0 -72
  83. data/spec/date_time/index_spec.rb +0 -588
  84. data/spec/date_time/offsets_spec.rb +0 -465
  85. data/spec/extensions/which_dsl_spec.rb +0 -38
  86. data/spec/fixtures/bank2.dat +0 -200
  87. data/spec/fixtures/boolean_converter_test.csv +0 -5
  88. data/spec/fixtures/countries.json +0 -7794
  89. data/spec/fixtures/duplicates.csv +0 -32
  90. data/spec/fixtures/eciresults.html +0 -394
  91. data/spec/fixtures/empties.dat +0 -2
  92. data/spec/fixtures/empty_rows_test.csv +0 -17
  93. data/spec/fixtures/macau.html +0 -3691
  94. data/spec/fixtures/macd_data.csv +0 -150
  95. data/spec/fixtures/matrix_test.csv +0 -100
  96. data/spec/fixtures/moneycontrol.html +0 -6812
  97. data/spec/fixtures/music_data.tsv +0 -2501
  98. data/spec/fixtures/repeated_fields.csv +0 -7
  99. data/spec/fixtures/sales-funnel.csv +0 -18
  100. data/spec/fixtures/scientific_notation.csv +0 -4
  101. data/spec/fixtures/string_converter_test.csv +0 -5
  102. data/spec/fixtures/strings.dat +0 -2
  103. data/spec/fixtures/test_xls.xls +0 -0
  104. data/spec/fixtures/test_xls_2.xls +0 -0
  105. data/spec/fixtures/url_test.txt~ +0 -0
  106. data/spec/fixtures/valid_markup.html +0 -62
  107. data/spec/fixtures/wiki_climate.html +0 -1243
  108. data/spec/fixtures/wiki_table_info.html +0 -631
  109. data/spec/formatters/table_formatter_spec.rb +0 -137
  110. data/spec/helpers_spec.rb +0 -8
  111. data/spec/index/categorical_index_spec.rb +0 -289
  112. data/spec/index/index_spec.rb +0 -438
  113. data/spec/index/multi_index_spec.rb +0 -752
  114. data/spec/io/io_spec.rb +0 -357
  115. data/spec/io/sql_data_source_spec.rb +0 -48
  116. data/spec/iruby/dataframe_spec.rb +0 -170
  117. data/spec/iruby/helpers_spec.rb +0 -49
  118. data/spec/iruby/multi_index_spec.rb +0 -37
  119. data/spec/iruby/vector_spec.rb +0 -105
  120. data/spec/maths/arithmetic/dataframe_spec.rb +0 -148
  121. data/spec/maths/arithmetic/vector_spec.rb +0 -165
  122. data/spec/maths/statistics/dataframe_spec.rb +0 -191
  123. data/spec/maths/statistics/vector_spec.rb +0 -756
  124. data/spec/monkeys_spec.rb +0 -42
  125. data/spec/shared/vector_display_spec.rb +0 -213
  126. data/spec/spec_helper.rb +0 -87
  127. data/spec/support/database_helper.rb +0 -29
  128. data/spec/support/matchers.rb +0 -5
  129. data/spec/vector/aggregatable_example.rb +0 -27
  130. data/spec/vector/calculatable_example.rb +0 -82
  131. data/spec/vector/convertible_example.rb +0 -126
  132. data/spec/vector/duplicatable_example.rb +0 -48
  133. data/spec/vector/fetchable_example.rb +0 -463
  134. data/spec/vector/filterable_example.rb +0 -165
  135. data/spec/vector/indexable_example.rb +0 -201
  136. data/spec/vector/iterable_example.rb +0 -111
  137. data/spec/vector/joinable_example.rb +0 -25
  138. data/spec/vector/missable_example.rb +0 -88
  139. data/spec/vector/queryable_example.rb +0 -91
  140. data/spec/vector/setable_example.rb +0 -300
  141. data/spec/vector/sortable_example.rb +0 -242
  142. data/spec/vector_spec.rb +0 -599
data/spec/vector_spec.rb DELETED
@@ -1,599 +0,0 @@
1
- require 'spec_helper.rb'
2
- require 'vector/aggregatable_example'
3
- require 'vector/calculatable_example'
4
- require 'vector/convertible_example'
5
- require 'vector/duplicatable_example'
6
- require 'vector/fetchable_example'
7
- require 'vector/filterable_example'
8
- require 'vector/indexable_example'
9
- require 'vector/iterable_example'
10
- require 'vector/joinable_example'
11
- require 'vector/missable_example'
12
- require 'vector/queryable_example'
13
- require 'vector/setable_example'
14
- require 'vector/sortable_example'
15
-
16
- describe DaruLite::Vector do
17
- ALL_DTYPES.each do |dtype|
18
- describe dtype.to_s do
19
- describe "#initialize" do
20
- let(:multi_index) do
21
- tuples = [
22
- [:a, :one, :foo],
23
- [:a, :two, :bar],
24
- [:b, :one, :bar],
25
- [:b, :two, :baz]
26
- ]
27
- DaruLite::MultiIndex.from_tuples(tuples)
28
- end
29
-
30
- it "initializes from an Array" do
31
- dv = DaruLite::Vector.new(
32
- [1, 2, 3, 4, 5],
33
- name: :ravan,
34
- index: [:ek, :don, :teen, :char, :pach],
35
- dtype:
36
- )
37
-
38
- expect(dv.name) .to eq(:ravan)
39
- expect(dv.index).to eq(DaruLite::Index.new([:ek, :don, :teen, :char, :pach]))
40
- end
41
-
42
- it "accepts Index object" do
43
- idx = DaruLite::Index.new [:yoda, :anakin, :obi, :padme, :r2d2]
44
- dv = DaruLite::Vector.new([1,2,3,4,5], name: :yoga, index: idx, dtype:)
45
-
46
- expect(dv.name) .to eq(:yoga)
47
- expect(dv.index).to eq(idx)
48
- end
49
-
50
- it "accepts a MultiIndex object" do
51
- dv = DaruLite::Vector.new([1,2,3,4], name: :mi, index: multi_index, dtype:)
52
-
53
- expect(dv.name).to eq(:mi)
54
- expect(dv.index).to eq(multi_index)
55
- end
56
-
57
- it "raises error for improper Index" do
58
- expect {
59
- dv = DaruLite::Vector.new [1, 2, 3, 4, 5], name: :yoga, index: [:i, :j, :k]
60
- }.to raise_error
61
-
62
- expect {
63
- idx = DaruLite::Index.new([:i, :j, :k])
64
- dv = DaruLite::Vector.new([1, 2, 3, 4, 5], name: :yoda, index: idx, dtype:)
65
- }.to raise_error
66
- end
67
-
68
- it "raises error for improper MultiIndex" do
69
- expect {
70
- dv = DaruLite::Vector.new([1, 2, 3, 4, 5], name: :mi, index: multi_index)
71
- }.to raise_error
72
- end
73
-
74
- it "initializes without specifying an index" do
75
- dv = DaruLite::Vector.new([1, 2, 3, 4, 5], name: :vishnu, dtype:)
76
-
77
- expect(dv.index).to eq(DaruLite::Index.new([0, 1, 2, 3, 4]))
78
- end
79
-
80
- it "inserts nils for extra indices" do
81
- dv = DaruLite::Vector.new([1, 2, 3], name: :yoga, index: [0, 1, 2, 3, 4], dtype:)
82
-
83
- expect(dv).to eq([1, 2, 3, nil, nil].dv(:yoga,nil, :array))
84
- end
85
-
86
- it "inserts nils for extra indices (MultiIndex)" do
87
- dv = DaruLite::Vector.new [1, 2], name: :mi, index: multi_index, dtype: :array
88
- expect(dv).to eq(DaruLite::Vector.new([1, 2, nil, nil], name: :mi, index: multi_index, dtype: :array))
89
- end
90
-
91
- it "accepts all sorts of objects for indexing" do
92
- dv = DaruLite::Vector.new([1, 2, 3, 4], index: ['a', 'b', :r, 0])
93
- expect(dv.to_a).to eq([1, 2, 3, 4])
94
- expect(dv.index.to_a).to eq(['a', 'b', :r, 0])
95
- end
96
- end
97
-
98
- describe ".new_with_size" do
99
- it "creates new vector from only size" do
100
- v1 = DaruLite::Vector.new(10.times.map { nil }, dtype:)
101
- v2 = DaruLite::Vector.new_with_size(10, dtype:)
102
- expect(v2).to eq(v1)
103
- end if dtype == :array
104
-
105
- it "creates new vector from only size and value" do
106
- a = rand
107
- v1 = DaruLite::Vector.new(10.times.map { a }, dtype:)
108
- v2 = DaruLite::Vector.new_with_size(10, value: a, dtype:)
109
- expect(v2).to eq(v1)
110
- end
111
-
112
- it "accepts block" do
113
- v1 = DaruLite::Vector.new 10.times.map {|i| i * 2 }
114
- v2 = DaruLite::Vector.new_with_size(10, dtype:) { |i| i * 2 }
115
- expect(v2).to eq(v1)
116
- end
117
- end
118
-
119
- describe ".[]" do
120
- it "returns same results as R-c()" do
121
- reference = DaruLite::Vector.new([0, 4, 5, 6, 10])
122
- expect(DaruLite::Vector[0, 4, 5, 6, 10]) .to eq(reference)
123
- expect(DaruLite::Vector[0, 4..6, 10]) .to eq(reference)
124
- expect(DaruLite::Vector[[0], [4, 5, 6], [10]]) .to eq(reference)
125
- expect(DaruLite::Vector[[0], [4, [5, [6]]], [10]]).to eq(reference)
126
-
127
- expect(DaruLite::Vector[[0], DaruLite::Vector.new([4, 5, 6]), [10]])
128
- .to eq(reference)
129
- end
130
- end
131
-
132
- context "#==" do
133
- subject { vector == other_vector }
134
-
135
- let(:vector) { DaruLite::Vector.new(data, name:, index:, dtype:) }
136
- let(:data) { [1, 2, 3, 4, 5] }
137
- let(:index) { [:yoda, :anakin, :obi, :padme, :r2d2] }
138
- let(:name) { :yoga }
139
- let(:other_vector) { DaruLite::Vector.new(other_data, name: other_name, index: other_index, dtype:) }
140
- let(:other_data) { data }
141
- let(:other_index) { index }
142
- let(:other_name) { name }
143
-
144
- context DaruLite::Index do
145
-
146
- context 'vectors are identical' do
147
- it { is_expected.to eq(true) }
148
- end
149
-
150
- context 'name is different' do
151
- let(:other_name) { :yogi }
152
-
153
- it { is_expected.to eq(true) }
154
- end
155
-
156
- context 'data is different' do
157
- let(:other_data) { [2, 1, 3, 4, 5] }
158
-
159
- it { is_expected.to eq(false) }
160
- end
161
-
162
- context 'data size is different' do
163
- let(:other_data) { [1, 2, 3, 4, 5, 6] }
164
- let(:other_index) { [:yoda, :anakin, :obi, :padme, :r2d2, :darth_vader] }
165
-
166
- it { is_expected.to eq(false) }
167
- end
168
-
169
- context 'vector index is different' do
170
- let(:other_index) { [:anakin, :yoda, :darth_vader, :padme, :r2d2] }
171
-
172
- it { is_expected.to eq(false) }
173
- end
174
- end
175
-
176
- context DaruLite::MultiIndex do
177
- let(:tuples) do
178
- [
179
- [:a,:one,:bar],
180
- [:a,:one,:baz],
181
- [:a,:two,:bar],
182
- [:a,:two,:baz],
183
- [:b,:one,:bar],
184
- [:b,:two,:bar],
185
- [:b,:two,:baz],
186
- [:b,:one,:foo],
187
- [:c,:one,:bar],
188
- [:c,:one,:baz],
189
- [:c,:two,:foo],
190
- [:c,:two,:bar]
191
- ]
192
- end
193
- let(:data) { Array.new(12) { |i| i } }
194
- let(:index) { DaruLite::MultiIndex.from_tuples(tuples) }
195
-
196
- context 'vectors are identical' do
197
- it { is_expected.to eq(true) }
198
- end
199
-
200
- context 'name is different' do
201
- let(:other_name) { :yogi }
202
-
203
- it { is_expected.to eq(true) }
204
- end
205
-
206
- context 'data is different' do
207
- let(:other_data) { Array.new(12) { |i| i * i } }
208
-
209
- it { is_expected.to eq(false) }
210
- end
211
-
212
- context 'data size is different' do
213
- let(:other_data) { Array.new(10) { |i| i * i } }
214
-
215
- it { is_expected.to eq(false) }
216
- end
217
-
218
- context 'vector index is different' do
219
- let(:other_tuples) do
220
- [
221
- [:a,:two,:bar],
222
- [:a,:one,:baz],
223
- [:a,:two,:bar],
224
- [:a,:two,:baz],
225
- [:b,:one,:bar],
226
- [:b,:two,:bar],
227
- [:b,:two,:baz],
228
- [:b,:one,:foo],
229
- [:c,:one,:bar],
230
- [:c,:one,:baz],
231
- [:c,:two,:foo],
232
- [:c,:two,:bar]
233
- ]
234
- end
235
- let(:other_index) { DaruLite::MultiIndex.from_tuples(other_tuples) }
236
-
237
- it { is_expected.to eq(false) }
238
- end
239
- end
240
-
241
- context DaruLite::CategoricalIndex do
242
- let(:index) { DaruLite::CategoricalIndex.new([:yoda, :r2d2, :obi, :padme, :r2d2]) }
243
-
244
- context 'vectors are identical' do
245
- it { is_expected.to eq(true) }
246
- end
247
-
248
- context 'name is different' do
249
- let(:other_name) { :yogi }
250
-
251
- it { is_expected.to eq(true) }
252
- end
253
-
254
- context 'data is different' do
255
- let(:other_data) { [2, 1, 3, 4, 5] }
256
-
257
- it { is_expected.to eq(false) }
258
- end
259
-
260
- context 'data size is different' do
261
- let(:other_data) { [1, 2, 3, 4, 5, 6] }
262
- let(:other_index) { [:yoda, :anakin, :obi, :padme, :r2d2, :darth_vader] }
263
-
264
- it { is_expected.to eq(false) }
265
- end
266
-
267
- context 'vector index is different' do
268
- let(:other_index) { DaruLite::CategoricalIndex.new([:r2d2, :yoda, :obi, :padme, :r2d2]) }
269
-
270
- it { is_expected.to eq(false) }
271
- end
272
- end
273
- end
274
-
275
- context "#delete" do
276
- context DaruLite::Index do
277
- it "deletes specified value in the vector" do
278
- dv = DaruLite::Vector.new [1,2,3,4,5], name: :a, dtype: dtype
279
-
280
- dv.delete 3
281
- expect(dv).to eq(
282
- DaruLite::Vector.new [1,2,4,5], name: :a, index: [0,1,3,4])
283
- end
284
- end
285
- end
286
-
287
- context "#delete_at" do
288
- context DaruLite::Index do
289
- before :each do
290
- @dv = DaruLite::Vector.new [1,2,3,4,5], name: :a,
291
- index: [:one, :two, :three, :four, :five], dtype: dtype
292
- end
293
-
294
- it "deletes element of specified index" do
295
- @dv.delete_at :one
296
-
297
- expect(@dv).to eq(DaruLite::Vector.new [2,3,4,5], name: :a,
298
- index: [:two, :three, :four, :five], dtype: dtype)
299
- end
300
-
301
- it "deletes element of specified integer index" do
302
- pending
303
- @dv.delete_at 2
304
-
305
- expect(@dv).to eq(DaruLite::Vector.new [1,2,4,5], name: :a,
306
- index: [:one, :two, :four, :five], dtype: dtype)
307
- end
308
- end
309
- end
310
-
311
- context "#cast" do
312
- ALL_DTYPES.each do |new_dtype|
313
- it "casts from #{dtype} to #{new_dtype}" do
314
- v = DaruLite::Vector.new [1,2,3,4], dtype: dtype
315
- v.cast(dtype: new_dtype)
316
- expect(v.dtype).to eq(new_dtype)
317
- end
318
- end
319
- end
320
-
321
- context "#bootstrap" do
322
- it "returns a vector with mean=mu and sd=se" do
323
- rng = Distribution::Normal.rng(0, 1)
324
- vector =DaruLite::Vector.new_with_size(100, dtype:) { rng.call}
325
-
326
- df = vector.bootstrap([:mean, :sd], 200)
327
- se = 1 / Math.sqrt(vector.size)
328
- expect(df[:mean].mean).to be_within(0.3).of(0)
329
- expect(df[:mean].sd).to be_within(0.02).of(se)
330
- end
331
- end
332
-
333
- it_behaves_like 'a calculatable Vector', dtype
334
- it_behaves_like 'a convertible Vector', dtype
335
- it_behaves_like 'a fetchable Vector', dtype
336
- it_behaves_like 'a filterable Vector', dtype
337
- it_behaves_like 'an indexable Vector', dtype
338
- it_behaves_like 'an iterable Vector', dtype
339
- it_behaves_like 'a joinable Vector', dtype
340
- it_behaves_like 'a setable Vector', dtype
341
- it_behaves_like 'a sortable Vector', dtype
342
- end
343
- end # describe ALL_DTYPES.each
344
-
345
- # -----------------------------------------------------------------------
346
- # works with arrays only
347
-
348
- it_behaves_like 'an aggregatable Vector'
349
- it_behaves_like 'a duplicatable Vector'
350
- it_behaves_like 'a missable Vector'
351
- it_behaves_like 'a queryable Vector'
352
-
353
- context "#splitted" do
354
- it "splits correctly" do
355
- a = DaruLite::Vector.new ['a', 'a,b', 'c,d', 'a,d', 'd', 10, nil]
356
- expect(a.splitted).to eq([%w(a), %w(a b), %w(c d), %w(a d), %w(d), [10], nil])
357
- end
358
- end
359
-
360
- context '#is_values' do
361
- let(:dv) { DaruLite::Vector.new [10, 11, 10, nil, nil] }
362
-
363
- context 'single value' do
364
- subject { dv.is_values 10 }
365
- it { is_expected.to be_a DaruLite::Vector }
366
- its(:to_a) { is_expected.to eq [true, false, true, false, false] }
367
- end
368
-
369
- context 'multiple values' do
370
- subject { dv.is_values 10, nil }
371
- it { is_expected.to be_a DaruLite::Vector }
372
- its(:to_a) { is_expected.to eq [true, false, true, true, true] }
373
- end
374
- end
375
-
376
- describe "#type" do
377
- before(:each) do
378
- @numeric = DaruLite::Vector.new([1,2,3,4,5])
379
- @multi = DaruLite::Vector.new([1,2,3,'sameer','d'])
380
- @with_nils = DaruLite::Vector.new([1,2,3,4,nil])
381
- end
382
-
383
- it "checks numeric data correctly" do
384
- expect(@numeric.type).to eq(:numeric)
385
- end
386
-
387
- it "checks for multiple types of data" do
388
- expect(@multi.type).to eq(:object)
389
- end
390
-
391
- it "changes type to object as per assignment" do
392
- expect(@numeric.type).to eq(:numeric)
393
- @numeric[2] = 'my string'
394
- expect(@numeric.type).to eq(:object)
395
- end
396
-
397
- it "changes type to numeric as per assignment" do
398
- expect(@multi.type).to eq(:object)
399
- @multi[3] = 45
400
- @multi[4] = 54
401
- expect(@multi.type).to eq(:numeric)
402
- end
403
-
404
- it "reports numeric if nils with number data" do
405
- expect(@with_nils.type).to eq(:numeric)
406
- end
407
-
408
- it "stays numeric when nil is reassigned to a number" do
409
- @with_nils[4] = 66
410
- expect(@with_nils.type).to eq(:numeric)
411
- end
412
-
413
- it "changes to :object when nil is reassigned to anything but a number" do
414
- @with_nils[4] = 'string'
415
- expect(@with_nils.type).to eq(:object)
416
- end
417
- end
418
-
419
- describe "#split_by_separator" do
420
- subject { vector.split_by_separator(separator) }
421
-
422
- let(:vector) { DaruLite::Vector.new ['a', 'a,b', 'c,d', 'a,d', 10, nil] }
423
- let(:separator) { ',' }
424
-
425
- def expect_correct_tokens(hash)
426
- expect(hash['a'].to_a).to eq([1, 1, 0, 1, 0, nil])
427
- expect(hash['b'].to_a).to eq([0, 1, 0, 0, 0, nil])
428
- expect(hash['c'].to_a).to eq([0, 0, 1, 0, 0, nil])
429
- expect(hash['d'].to_a).to eq([0, 0, 1, 1, 0, nil])
430
- expect(hash[10].to_a).to eq([0, 0, 0, 0, 1, nil])
431
- end
432
-
433
- it "returns a Hash" do
434
- expect(subject.class).to eq(Hash)
435
- end
436
-
437
- it "returned Hash has keys with with different values of a" do
438
- expect(subject.keys).to eq(['a', 'b', 'c', 'd', 10])
439
- end
440
-
441
- it "returns a Hash, whose values are DaruLite::Vector" do
442
- subject.each_key do |key|
443
- expect(subject[key].class).to eq(DaruLite::Vector)
444
- end
445
- end
446
-
447
- it "ensures that hash values are n times the tokens appears" do
448
- expect_correct_tokens subject
449
- end
450
-
451
- context 'when using a different separator' do
452
- let(:vector) { DaruLite::Vector.new ['a', 'a*b', 'c*d', 'a*d', 10, nil] }
453
- let(:separator) { '*' }
454
-
455
- it "gives the same values using a different separator" do
456
- expect_correct_tokens subject
457
- end
458
- end
459
- end
460
-
461
- describe "#split_by_separator_freq" do
462
- subject { vector.split_by_separator_freq }
463
-
464
- let(:vector) { DaruLite::Vector.new ['a', 'a,b', 'c,d', 'a,d', 10, nil] }
465
-
466
- it "returns the number of ocurrences of tokens" do
467
- expect(subject).to eq(
468
- { 'a' => 3, 'b' => 1, 'c' => 1, 'd' => 2, 10 => 1 }
469
- )
470
- end
471
- end
472
-
473
- describe "#rename" do
474
- let(:vector) { DaruLite::Vector.new [1, 2, 3, 4, 5, 5], name: :this_vector }
475
-
476
- it "assings name" do
477
- vector.rename :that_vector
478
- expect(vector.name).to eq(:that_vector)
479
- end
480
-
481
- it "stores name as a symbol" do
482
- vector.rename "This is a vector"
483
- expect(vector.name).to eq("This is a vector")
484
- end
485
-
486
- it "returns vector" do
487
- expect(vector.rename 'hello').to be_a DaruLite::Vector
488
- end
489
- end
490
-
491
- describe '#lag' do
492
- let(:source) { DaruLite::Vector.new(1..5) }
493
-
494
- context 'by default' do
495
- subject { source.lag }
496
- it { is_expected.to eq DaruLite::Vector.new([nil, 1, 2, 3, 4]) }
497
- end
498
-
499
- subject { source.lag(amount) }
500
-
501
- context '0' do
502
- let(:amount) { 0 }
503
- it { is_expected.to eq DaruLite::Vector.new([1, 2, 3, 4, 5]) }
504
- end
505
-
506
- context 'same as vector size' do
507
- let(:amount) { source.size }
508
- it { is_expected.to eq DaruLite::Vector.new([nil]*source.size) }
509
- end
510
-
511
- context 'same as vector -ve size' do
512
- let(:amount) { -source.size }
513
- it { is_expected.to eq DaruLite::Vector.new([nil]*source.size) }
514
- end
515
-
516
- context 'positive' do
517
- let(:amount) { 2 }
518
- it { is_expected.to eq DaruLite::Vector.new([nil, nil, 1, 2, 3]) }
519
- end
520
-
521
- context 'negative' do
522
- let(:amount) { -1 }
523
- it { is_expected.to eq DaruLite::Vector.new([2, 3, 4, 5, nil]) }
524
- end
525
-
526
- context 'large positive' do
527
- let(:amount) { source.size + 100 }
528
- it { is_expected.to eq DaruLite::Vector.new([nil]*source.size) }
529
- end
530
-
531
- context 'large negative' do
532
- let(:amount) { -(source.size + 100) }
533
- it { is_expected.to eq DaruLite::Vector.new([nil]*source.size) }
534
- end
535
- end
536
-
537
- describe '#method_missing' do
538
- context 'getting' do
539
- subject(:vector) { DaruLite::Vector.new [1,2,3], index: [:a, :b, :c] }
540
-
541
- it 'returns value for existing index' do
542
- expect(vector.a).to eq 1
543
- end
544
-
545
- it 'raises on getting non-existent index' do
546
- expect { vector.d }.to raise_error NoMethodError
547
- end
548
-
549
- it 'sets existing index' do
550
- vector.a = 5
551
- expect(vector[:a]).to eq 5
552
- end
553
-
554
- it 'raises on non-existent index setting' do
555
- # FIXME: inconsistency between IndexError here and NoMethodError on getting - zverok
556
- expect { vector.d = 5 }.to raise_error IndexError
557
- end
558
- end
559
- end
560
-
561
- describe '#db_type' do
562
- it 'is DATE for vector with any date in it' do
563
- # FIXME: is it sane?.. - zverok
564
- expect(DaruLite::Vector.new(['2016-03-01', 'foo', 4]).db_type).to eq 'DATE'
565
- end
566
-
567
- it 'is INTEGER for digits-only values' do
568
- expect(DaruLite::Vector.new(['123', 456, 789]).db_type).to eq 'INTEGER'
569
- end
570
-
571
- it 'is DOUBLE for digits-and-point values' do
572
- expect(DaruLite::Vector.new(['123.4', 456, 789e-10]).db_type).to eq 'DOUBLE'
573
- end
574
-
575
- it 'is VARCHAR for everyting else' do
576
- expect(DaruLite::Vector.new(['123 and stuff', 456, 789e-10]).db_type).to eq 'VARCHAR (255)'
577
- end
578
- end
579
-
580
- context 'on wrong dtypes' do
581
- it 'should not accept mdarray' do
582
- expect { DaruLite::Vector.new([], dtype: :mdarray) }.to raise_error(NotImplementedError)
583
- end
584
-
585
- it 'should not accept anything else' do
586
- expect { DaruLite::Vector.new([], dtype: :kittens) }.to raise_error(ArgumentError)
587
- end
588
- end
589
-
590
- context '#where clause when Nan, nil data value is present' do
591
- let(:v) { DaruLite::Vector.new([1,2,3,Float::NAN, nil]) }
592
-
593
- it 'missing/undefined data in Vector/DataFrame' do
594
- expect(v.where(v.lt(4))).to eq(DaruLite::Vector.new([1,2,3]))
595
- expect(v.where(v.lt(3))).to eq(DaruLite::Vector.new([1,2]))
596
- expect(v.where(v.lt(2))).to eq(DaruLite::Vector.new([1]))
597
- end
598
- end
599
- end if mri?