daru_lite 0.3.3 → 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 (150) 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/data_frame/duplicatable.rb +7 -1
  6. data/lib/daru_lite/data_frame/fetchable.rb +1 -1
  7. data/lib/daru_lite/data_frame/iterable.rb +5 -2
  8. data/lib/daru_lite/data_frame/sortable.rb +13 -5
  9. data/lib/daru_lite/dataframe.rb +52 -11
  10. data/lib/daru_lite/date_time/index.rb +2 -2
  11. data/lib/daru_lite/index/categorical_index.rb +62 -0
  12. data/lib/daru_lite/index/multi_index.rb +24 -6
  13. data/lib/daru_lite/maths/statistics/dataframe.rb +9 -5
  14. data/lib/daru_lite/maths/statistics/vector.rb +1 -1
  15. data/lib/daru_lite/version.rb +1 -1
  16. data/lib/daru_lite.rb +1 -0
  17. metadata +54 -284
  18. data/.github/ISSUE_TEMPLATE/bug_report.md +0 -38
  19. data/.github/ISSUE_TEMPLATE/feature_request.md +0 -20
  20. data/.github/dependabot.yml +0 -11
  21. data/.github/workflows/ci.yml +0 -33
  22. data/.gitignore +0 -10
  23. data/.rspec +0 -2
  24. data/.rubocop.yml +0 -27
  25. data/.rubocop_todo.yml +0 -139
  26. data/CONTRIBUTING.md +0 -47
  27. data/Gemfile +0 -2
  28. data/Rakefile +0 -69
  29. data/ReleasePolicy.md +0 -20
  30. data/benchmarks/TradeoffData.csv +0 -65
  31. data/benchmarks/csv_reading.rb +0 -22
  32. data/benchmarks/dataframe_creation.rb +0 -39
  33. data/benchmarks/db_loading.rb +0 -33
  34. data/benchmarks/duplicating.rb +0 -45
  35. data/benchmarks/group_by.rb +0 -32
  36. data/benchmarks/joining.rb +0 -52
  37. data/benchmarks/row_access.rb +0 -41
  38. data/benchmarks/row_assign.rb +0 -36
  39. data/benchmarks/sorting.rb +0 -51
  40. data/benchmarks/statistics.rb +0 -28
  41. data/benchmarks/vector_access.rb +0 -31
  42. data/benchmarks/vector_assign.rb +0 -42
  43. data/benchmarks/where_clause.rb +0 -48
  44. data/benchmarks/where_vs_filter.rb +0 -28
  45. data/daru_lite.gemspec +0 -54
  46. data/daru_lite_test-shm +0 -0
  47. data/daru_lite_test-wal +0 -0
  48. data/images/README.md +0 -5
  49. data/images/con0.png +0 -0
  50. data/images/con1.png +0 -0
  51. data/images/init0.png +0 -0
  52. data/images/init1.png +0 -0
  53. data/images/man0.png +0 -0
  54. data/images/man1.png +0 -0
  55. data/images/man2.png +0 -0
  56. data/images/man3.png +0 -0
  57. data/images/man4.png +0 -0
  58. data/images/man5.png +0 -0
  59. data/images/man6.png +0 -0
  60. data/profile/_base.rb +0 -23
  61. data/profile/df_to_a.rb +0 -10
  62. data/profile/filter.rb +0 -13
  63. data/profile/joining.rb +0 -13
  64. data/profile/sorting.rb +0 -12
  65. data/profile/vector_each_with_index.rb +0 -9
  66. data/profile/vector_new.rb +0 -9
  67. data/spec/accessors/array_wrapper_spec.rb +0 -3
  68. data/spec/category_spec.rb +0 -1741
  69. data/spec/core/group_by_spec.rb +0 -655
  70. data/spec/core/merge_spec.rb +0 -179
  71. data/spec/core/query_spec.rb +0 -347
  72. data/spec/daru_lite_spec.rb +0 -22
  73. data/spec/data_frame/aggregatable_example.rb +0 -65
  74. data/spec/data_frame/buildable_example.rb +0 -109
  75. data/spec/data_frame/calculatable_example.rb +0 -135
  76. data/spec/data_frame/convertible_example.rb +0 -180
  77. data/spec/data_frame/duplicatable_example.rb +0 -111
  78. data/spec/data_frame/fetchable_example.rb +0 -481
  79. data/spec/data_frame/filterable_example.rb +0 -456
  80. data/spec/data_frame/indexable_example.rb +0 -221
  81. data/spec/data_frame/iterable_example.rb +0 -465
  82. data/spec/data_frame/joinable_example.rb +0 -131
  83. data/spec/data_frame/missable_example.rb +0 -47
  84. data/spec/data_frame/pivotable_example.rb +0 -297
  85. data/spec/data_frame/queryable_example.rb +0 -92
  86. data/spec/data_frame/setable_example.rb +0 -482
  87. data/spec/data_frame/sortable_example.rb +0 -350
  88. data/spec/dataframe_spec.rb +0 -1306
  89. data/spec/date_time/data_spec.rb +0 -197
  90. data/spec/date_time/date_time_index_helper_spec.rb +0 -72
  91. data/spec/date_time/index_spec.rb +0 -588
  92. data/spec/date_time/offsets_spec.rb +0 -465
  93. data/spec/extensions/which_dsl_spec.rb +0 -38
  94. data/spec/fixtures/bank2.dat +0 -200
  95. data/spec/fixtures/boolean_converter_test.csv +0 -5
  96. data/spec/fixtures/countries.json +0 -7794
  97. data/spec/fixtures/duplicates.csv +0 -32
  98. data/spec/fixtures/eciresults.html +0 -394
  99. data/spec/fixtures/empties.dat +0 -2
  100. data/spec/fixtures/empty_rows_test.csv +0 -17
  101. data/spec/fixtures/macau.html +0 -3691
  102. data/spec/fixtures/macd_data.csv +0 -150
  103. data/spec/fixtures/matrix_test.csv +0 -100
  104. data/spec/fixtures/moneycontrol.html +0 -6812
  105. data/spec/fixtures/music_data.tsv +0 -2501
  106. data/spec/fixtures/repeated_fields.csv +0 -7
  107. data/spec/fixtures/sales-funnel.csv +0 -18
  108. data/spec/fixtures/scientific_notation.csv +0 -4
  109. data/spec/fixtures/string_converter_test.csv +0 -5
  110. data/spec/fixtures/strings.dat +0 -2
  111. data/spec/fixtures/test_xls.xls +0 -0
  112. data/spec/fixtures/test_xls_2.xls +0 -0
  113. data/spec/fixtures/url_test.txt~ +0 -0
  114. data/spec/fixtures/valid_markup.html +0 -62
  115. data/spec/fixtures/wiki_climate.html +0 -1243
  116. data/spec/fixtures/wiki_table_info.html +0 -631
  117. data/spec/formatters/table_formatter_spec.rb +0 -137
  118. data/spec/helpers_spec.rb +0 -8
  119. data/spec/index/categorical_index_spec.rb +0 -221
  120. data/spec/index/index_spec.rb +0 -438
  121. data/spec/index/multi_index_spec.rb +0 -713
  122. data/spec/io/io_spec.rb +0 -357
  123. data/spec/io/sql_data_source_spec.rb +0 -48
  124. data/spec/iruby/dataframe_spec.rb +0 -170
  125. data/spec/iruby/helpers_spec.rb +0 -49
  126. data/spec/iruby/multi_index_spec.rb +0 -37
  127. data/spec/iruby/vector_spec.rb +0 -105
  128. data/spec/maths/arithmetic/dataframe_spec.rb +0 -148
  129. data/spec/maths/arithmetic/vector_spec.rb +0 -165
  130. data/spec/maths/statistics/dataframe_spec.rb +0 -178
  131. data/spec/maths/statistics/vector_spec.rb +0 -756
  132. data/spec/monkeys_spec.rb +0 -42
  133. data/spec/shared/vector_display_spec.rb +0 -213
  134. data/spec/spec_helper.rb +0 -87
  135. data/spec/support/database_helper.rb +0 -29
  136. data/spec/support/matchers.rb +0 -5
  137. data/spec/vector/aggregatable_example.rb +0 -27
  138. data/spec/vector/calculatable_example.rb +0 -82
  139. data/spec/vector/convertible_example.rb +0 -126
  140. data/spec/vector/duplicatable_example.rb +0 -48
  141. data/spec/vector/fetchable_example.rb +0 -463
  142. data/spec/vector/filterable_example.rb +0 -165
  143. data/spec/vector/indexable_example.rb +0 -201
  144. data/spec/vector/iterable_example.rb +0 -111
  145. data/spec/vector/joinable_example.rb +0 -25
  146. data/spec/vector/missable_example.rb +0 -88
  147. data/spec/vector/queryable_example.rb +0 -91
  148. data/spec/vector/setable_example.rb +0 -300
  149. data/spec/vector/sortable_example.rb +0 -242
  150. data/spec/vector_spec.rb +0 -599
@@ -1,1306 +0,0 @@
1
- require 'data_frame/aggregatable_example'
2
- require 'data_frame/buildable_example'
3
- require 'data_frame/calculatable_example'
4
- require 'data_frame/convertible_example'
5
- require 'data_frame/duplicatable_example'
6
- require 'data_frame/fetchable_example'
7
- require 'data_frame/filterable_example'
8
- require 'data_frame/indexable_example'
9
- require 'data_frame/iterable_example'
10
- require 'data_frame/joinable_example'
11
- require 'data_frame/missable_example'
12
- require 'data_frame/pivotable_example'
13
- require 'data_frame/queryable_example'
14
- require 'data_frame/setable_example'
15
- require 'data_frame/sortable_example'
16
-
17
- describe DaruLite::DataFrame do
18
- let(:df) do
19
- DaruLite::DataFrame.new(
20
- { b: [11,12,13,14,15], a: [1,2,3,4,5], c: [11,22,33,44,55] },
21
- order: [:a, :b, :c],
22
- index: [:one, :two, :three, :four, :five]
23
- )
24
- end
25
- let(:df_mi) do
26
- DaruLite::DataFrame.new(
27
- [vector_arry1, vector_arry2, vector_arry1, vector_arry2],
28
- order: order_mi,
29
- index: multi_index
30
- )
31
- end
32
- let(:vector_arry1) { [11,12,13,14,11,12,13,14,11,12,13,14] }
33
- let(:vector_arry2) { [1,2,3,4,1,2,3,4,1,2,3,4] }
34
- let(:multi_index) do
35
- tuples = [
36
- [:a,:one,:bar],
37
- [:a,:one,:baz],
38
- [:a,:two,:bar],
39
- [:a,:two,:baz],
40
- [:b,:one,:bar],
41
- [:b,:two,:bar],
42
- [:b,:two,:baz],
43
- [:b,:one,:foo],
44
- [:c,:one,:bar],
45
- [:c,:one,:baz],
46
- [:c,:two,:foo],
47
- [:c,:two,:bar]
48
- ]
49
- DaruLite::MultiIndex.from_tuples(tuples)
50
- end
51
- let(:order_mi) do
52
- DaruLite::MultiIndex.from_tuples(
53
- [
54
- [:a,:one,:bar],
55
- [:a,:two,:baz],
56
- [:b,:two,:foo],
57
- [:b,:one,:foo]
58
- ]
59
- )
60
- end
61
-
62
- it_behaves_like 'an aggregatable DataFrame'
63
- it_behaves_like 'a buildable DataFrame'
64
- it_behaves_like 'a calculatable DataFrame'
65
- it_behaves_like 'a convertible DataFrame'
66
- it_behaves_like 'a duplicatable DataFrame'
67
- it_behaves_like 'a fetchable DataFrame'
68
- it_behaves_like 'a filterable DataFrame'
69
- it_behaves_like 'an indexable DataFrame'
70
- it_behaves_like 'an iterable DataFrame'
71
- it_behaves_like 'a joinable DataFrame'
72
- it_behaves_like 'a missable DataFrame'
73
- it_behaves_like 'a pivotable DataFrame'
74
- it_behaves_like 'a queryable DataFrame'
75
- it_behaves_like 'a setable DataFrame'
76
- it_behaves_like 'a sortable DataFrame'
77
-
78
- context "#initialize" do
79
- it "initializes an empty DataFrame with no arguments" do
80
- df = DaruLite::DataFrame.new
81
- expect(df.nrows).to eq(0)
82
- expect(df.ncols).to eq(0)
83
- end
84
-
85
- context DaruLite::Index do
86
- it "initializes an empty DataFrame with empty source arg" do
87
- df = DaruLite::DataFrame.new({}, order: [:a, :b])
88
-
89
- expect(df.vectors).to eq(DaruLite::Index.new [:a, :b])
90
- expect(df.a.class).to eq(DaruLite::Vector)
91
- expect(df.a) .to eq([].dv(:a))
92
- end
93
-
94
- it "initializes from a Hash" do
95
- df = DaruLite::DataFrame.new({b: [11,12,13,14,15], a: [1,2,3,4,5]}, order: [:a, :b],
96
- index: [:one, :two, :three, :four, :five])
97
-
98
- expect(df.index) .to eq(DaruLite::Index.new [:one, :two, :three, :four, :five])
99
- expect(df.vectors).to eq(DaruLite::Index.new [:a, :b])
100
- expect(df.a.class).to eq(DaruLite::Vector)
101
- expect(df.a) .to eq([1,2,3,4,5].dv(:a, df.index))
102
- end
103
-
104
- it "initializes from a Hash and preserves default order" do
105
- df = DaruLite::DataFrame.new({b: [11,12,13,14,15], a: [1,2,3,4,5]},
106
- index: [:one, :two, :three, :four, :five])
107
-
108
- expect(df.vectors).to eq(DaruLite::Index.new [:b, :a])
109
- end
110
-
111
- it "initializes from a Hash of Vectors" do
112
- va = DaruLite::Vector.new([1,2,3,4,5], index: [:one, :two, :three, :four, :five])
113
- vb = DaruLite::Vector.new([11,12,13,14,15], index: [:one, :two, :three, :four, :five])
114
-
115
- df = DaruLite::DataFrame.new({ b: vb, a: va }, order: [:a, :b], index: [:one, :two, :three, :four, :five])
116
-
117
- expect(df.index) .to eq(DaruLite::Index.new [:one, :two, :three, :four, :five])
118
- expect(df.vectors).to eq(DaruLite::Index.new [:a, :b])
119
- expect(df.a.class).to eq(DaruLite::Vector)
120
- expect(df.a) .to eq([1,2,3,4,5].dv(:a, [:one, :two, :three, :four, :five]))
121
- end
122
-
123
- it "initializes from an Array of Hashes" do
124
- df = DaruLite::DataFrame.new([{a: 1, b: 11}, {a: false, b: 12}, {a: 3, b: 13},
125
- {a: 4, b: 14}, {a: 5, b: 15}], order: [:b, :a],
126
- index: [:one, :two, :three, :four, :five])
127
-
128
- expect(df.index) .to eq(DaruLite::Index.new [:one, :two, :three, :four, :five])
129
- expect(df.vectors).to eq(DaruLite::Index.new [:b, :a])
130
- expect(df.a.class).to eq(DaruLite::Vector)
131
- expect(df.a) .to eq([1,false,3,4,5].dv(:a,[:one, :two, :three, :four, :five]))
132
- end
133
-
134
- it "initializes from Array of Arrays" do
135
- df = DaruLite::DataFrame.new([[1]*5, [2]*5, [3]*5], order: [:b, :a, :c])
136
-
137
- expect(df.index) .to eq(DaruLite::Index.new(5))
138
- expect(df.vectors).to eq(DaruLite::Index.new([:b, :a, :c]))
139
- expect(df.a) .to eq(DaruLite::Vector.new([2]*5))
140
- end
141
-
142
- it "initializes from Array of Vectors" do
143
- df = DaruLite::DataFrame.new([DaruLite::Vector.new([1]*5), DaruLite::Vector.new([2]*5),
144
- DaruLite::Vector.new([3]*5)], order: [:b, :a, :c])
145
-
146
- expect(df.index) .to eq(DaruLite::Index.new(5))
147
- expect(df.vectors).to eq(DaruLite::Index.new([:b, :a, :c]))
148
- expect(df.a) .to eq(DaruLite::Vector.new([2]*5))
149
- end
150
-
151
- it "accepts Index objects for row/col" do
152
- rows = DaruLite::Index.new [:one, :two, :three, :four, :five]
153
- cols = DaruLite::Index.new [:a, :b]
154
-
155
- df = DaruLite::DataFrame.new({b: [11,12,13,14,15], a: [1,2,3,4,5]}, order: cols,
156
- index: rows)
157
-
158
- expect(df.a) .to eq(DaruLite::Vector.new([1,2,3,4,5], order: [:a], index: rows))
159
- expect(df.b) .to eq(DaruLite::Vector.new([11,12,13,14,15], name: :b, index: rows))
160
- expect(df.index) .to eq(DaruLite::Index.new [:one, :two, :three, :four, :five])
161
- expect(df.vectors).to eq(DaruLite::Index.new [:a, :b])
162
- end
163
-
164
- it "initializes without specifying row/col index" do
165
- df = DaruLite::DataFrame.new({b: [11,12,13,14,15], a: [1,2,3,4,5]})
166
-
167
- expect(df.index) .to eq(DaruLite::Index.new [0,1,2,3,4])
168
- expect(df.vectors).to eq(DaruLite::Index.new [:b, :a])
169
- end
170
-
171
- it "aligns indexes properly" do
172
- df = DaruLite::DataFrame.new({
173
- b: [11,12,13,14,15].dv(:b, [:two, :one, :four, :five, :three]),
174
- a: [1,2,3,4,5].dv(:a, [:two,:one,:three, :four, :five])
175
- },
176
- order: [:a, :b]
177
- )
178
-
179
- expect(df).to eq(DaruLite::DataFrame.new({
180
- b: [14,13,12,15,11].dv(:b, [:five, :four, :one, :three, :two]),
181
- a: [5,4,2,3,1].dv(:a, [:five, :four, :one, :three, :two])
182
- }, order: [:a, :b])
183
- )
184
- end
185
-
186
- it "adds nil values for missing indexes and aligns by index" do
187
- df = DaruLite::DataFrame.new({
188
- b: [11,12,13,14,15].dv(:b, [:two, :one, :four, :five, :three]),
189
- a: [1,2,3] .dv(:a, [:two,:one,:three])
190
- },
191
- order: [:a, :b]
192
- )
193
-
194
- expect(df).to eq(DaruLite::DataFrame.new({
195
- b: [14,13,12,15,11].dv(:b, [:five, :four, :one, :three, :two]),
196
- a: [nil,nil,2,3,1].dv(:a, [:five, :four, :one, :three, :two])
197
- },
198
- order: [:a, :b])
199
- )
200
- end
201
-
202
- it "adds nils in first vector when other vectors have many extra indexes" do
203
- df = DaruLite::DataFrame.new({
204
- b: [11] .dv(nil, [:one]),
205
- a: [1,2,3] .dv(nil, [:one, :two, :three]),
206
- c: [11,22,33,44,55] .dv(nil, [:one, :two, :three, :four, :five]),
207
- d: [49,69,89,99,108,44].dv(nil, [:one, :two, :three, :four, :five, :six])
208
- }, order: [:a, :b, :c, :d],
209
- index: [:one, :two, :three, :four, :five, :six])
210
-
211
- expect(df).to eq(DaruLite::DataFrame.new({
212
- b: [11,nil,nil,nil,nil,nil].dv(nil, [:one, :two, :three, :four, :five, :six]),
213
- a: [1,2,3,nil,nil,nil] .dv(nil, [:one, :two, :three, :four, :five, :six]),
214
- c: [11,22,33,44,55,nil] .dv(nil, [:one, :two, :three, :four, :five, :six]),
215
- d: [49,69,89,99,108,44] .dv(nil, [:one, :two, :three, :four, :five, :six])
216
- }, order: [:a, :b, :c, :d],
217
- index: [:one, :two, :three, :four, :five, :six])
218
- )
219
- end
220
-
221
- it "correctly matches the supplied DataFrame index with the individual vector indexes" do
222
- df = DaruLite::DataFrame.new({
223
- b: [11,12,13] .dv(nil, [:one, :bleh, :blah]),
224
- a: [1,2,3,4,5].dv(nil, [:one, :two, :booh, :baah, :three]),
225
- c: [11,22,33,44,55].dv(nil, [0,1,3,:three, :two])
226
- }, order: [:a, :b, :c], index: [:one, :two, :three])
227
-
228
- expect(df).to eq(DaruLite::DataFrame.new({
229
- b: [11,nil,nil].dv(nil, [:one, :two, :three]),
230
- a: [1,2,5] .dv(nil, [:one, :two, :three]),
231
- c: [nil,55,44] .dv(nil, [:one, :two, :three]),
232
- },
233
- order: [:a, :b, :c], index: [:one, :two, :three]
234
- )
235
- )
236
- end
237
-
238
- it "completes incomplete vectors" do
239
- df = DaruLite::DataFrame.new({b: [11,12,13,14,15], a: [1,2,3,4,5],
240
- c: [11,22,33,44,55]}, order: [:a, :c])
241
-
242
- expect(df.vectors).to eq([:a,:c,:b].to_index)
243
- end
244
-
245
- it "does not copy vectors when clone: false" do
246
- a = DaruLite::Vector.new([1,2,3,4,5])
247
- b = DaruLite::Vector.new([1,2,3,4,5])
248
- c = DaruLite::Vector.new([1,2,3,4,5])
249
- df = DaruLite::DataFrame.new({a: a, b: b, c: c}, clone: false)
250
-
251
- expect(df[:a].object_id).to eq(a.object_id)
252
- expect(df[:b].object_id).to eq(b.object_id)
253
- expect(df[:c].object_id).to eq(c.object_id)
254
- end
255
-
256
- it "allows creation of empty dataframe with only order" do
257
- df = DaruLite::DataFrame.new({}, order: [:a, :b, :c])
258
- df[:a] = DaruLite::Vector.new([1,2,3,4,5,6])
259
-
260
- expect(df.size).to eq(6)
261
- expect(df[:a]).to eq(DaruLite::Vector.new([1,2,3,4,5,6]))
262
- expect(df[:b]).to eq(DaruLite::Vector.new([nil,nil,nil,nil,nil,nil]))
263
- expect(df[:c]).to eq(DaruLite::Vector.new([nil,nil,nil,nil,nil,nil]))
264
- end
265
-
266
- it "allows creation of dataframe without specifying order or index" do
267
- df = DaruLite::DataFrame.new({})
268
- df[:a] = DaruLite::Vector.new([1,2,3,4,5])
269
-
270
- expect(df.size) .to eq(5)
271
- expect(df.index.to_a) .to eq([0,1,2,3,4])
272
- expect(df.vectors.to_a).to eq([:a])
273
- expect(df[:a]) .to eq(DaruLite::Vector.new([1,2,3,4,5]))
274
- end
275
-
276
- it "allows creation of dataframe with a default order" do
277
- arr_of_arrs_df = DaruLite::DataFrame.new([[1,2,3], [4,5,6], [7,8,9]])
278
- arr_of_vectors_df = DaruLite::DataFrame.new([DaruLite::Vector.new([1,2,3]), DaruLite::Vector.new([4,5,6]), DaruLite::Vector.new([7,8,9])])
279
-
280
- expect(arr_of_arrs_df.vectors.to_a).to eq([0,1,2])
281
- expect(arr_of_vectors_df.vectors.to_a).to eq([0,1,2])
282
- end
283
-
284
- it "raises error for incomplete DataFrame index" do
285
- expect {
286
- df = DaruLite::DataFrame.new({b: [11,12,13,14,15], a: [1,2,3,4,5],
287
- c: [11,22,33,44,55]}, order: [:a, :b, :c],
288
- index: [:one, :two, :three])
289
- }.to raise_error
290
- end
291
-
292
- it "raises error for unequal sized vectors/arrays" do
293
- expect {
294
- df = DaruLite::DataFrame.new({b: [11,12,13], a: [1,2,3,4,5],
295
- c: [11,22,33,44,55]}, order: [:a, :b, :c],
296
- index: [:one, :two, :three])
297
- }.to raise_error
298
- end
299
- end
300
-
301
- context DaruLite::MultiIndex do
302
- it "creates empty DataFrame" do
303
- df = DaruLite::DataFrame.new({}, order: order_mi)
304
-
305
- expect(df.vectors).to eq(order_mi)
306
- expect(df[:a, :one, :bar]).to eq(DaruLite::Vector.new([]))
307
- end
308
-
309
- it "creates from Hash" do
310
- df = DaruLite::DataFrame.new({
311
- [:a,:one,:bar] => vector_arry1,
312
- [:a,:two,:baz] => vector_arry2,
313
- [:b,:one,:foo] => vector_arry1,
314
- [:b,:two,:foo] => vector_arry2
315
- }, order: order_mi, index: multi_index)
316
-
317
- expect(df.index) .to eq(multi_index)
318
- expect(df.vectors) .to eq(order_mi)
319
- expect(df[:a,:one,:bar]).to eq(DaruLite::Vector.new(vector_arry1,
320
- index: multi_index))
321
- end
322
-
323
- it "creates from Array of Hashes" do
324
- # TODO
325
- end
326
-
327
- it "creates from Array of Arrays" do
328
- df = DaruLite::DataFrame.new([vector_arry1, vector_arry2, vector_arry1,
329
- vector_arry2], index: multi_index, order: order_mi)
330
-
331
- expect(df.index) .to eq(multi_index)
332
- expect(df.vectors).to eq(order_mi)
333
- expect(df[:a, :one, :bar]).to eq(DaruLite::Vector.new(vector_arry1,
334
- index: multi_index))
335
- end
336
-
337
- it "raises error for order MultiIndex of different size than supplied Array" do
338
- expect {
339
- df = DaruLite::DataFrame.new([vector_arry1, vector_arry2], order: order_mi,
340
- index: multi_index)
341
- }.to raise_error
342
- end
343
-
344
- it "aligns MultiIndexes properly" do
345
- pending
346
- mi_a = order_mi
347
- mi_b = DaruLite::MultiIndex.from_tuples([
348
- [:b,:one,:foo],
349
- [:a,:one,:bar],
350
- [:b,:two,:foo],
351
- [:a,:one,:baz]
352
- ])
353
- mi_sorted = DaruLite::MultiIndex.from_tuples([
354
- [:a, :one, :bar],
355
- [:a, :one, :baz],
356
- [:b, :one, :foo],
357
- [:b, :two, :foo]
358
- ])
359
- order = DaruLite::MultiIndex.from_tuples([
360
- [:pee, :que],
361
- [:pee, :poo]
362
- ])
363
- a = DaruLite::Vector.new([1,2,3,4], index: mi_a)
364
- b = DaruLite::Vector.new([11,12,13,14], index: mi_b)
365
- df = DaruLite::DataFrame.new([b,a], order: order)
366
-
367
- expect(df).to eq(DaruLite::DataFrame.new({
368
- [:pee, :que] => DaruLite::Vector.new([1,2,4,3], index: mi_sorted),
369
- [:pee, :poo] => DaruLite::Vector.new([12,14,11,13], index: mi_sorted)
370
- }, order: order_mi))
371
- end
372
-
373
- it "adds nils in case of missing values" do
374
- # TODO
375
- end
376
-
377
- it "matches individual vector indexing with supplied DataFrame index" do
378
- # TODO
379
- end
380
- end
381
- end
382
-
383
- context '#method_missing' do
384
- let(:df) { DaruLite::DataFrame.new({
385
- :a => [1, 2, 3, 4, 5],
386
- 'b' => [5, 4, 3, 2, 1]
387
- }, index: 11..15)}
388
-
389
- context 'get vector' do
390
- context 'by string' do
391
- subject { df.b }
392
-
393
- it { is_expected.to be_a DaruLite::Vector }
394
- its(:to_a) { is_expected.to eq [5, 4, 3, 2, 1] }
395
- its(:'index.to_a') { is_expected.to eq [11, 12, 13, 14, 15] }
396
- end
397
-
398
- context 'by symbol' do
399
- subject { df.a }
400
-
401
- it { is_expected.to be_a DaruLite::Vector }
402
- its(:to_a) { is_expected.to eq [1, 2, 3, 4, 5] }
403
- its(:'index.to_a') { is_expected.to eq [11, 12, 13, 14, 15] }
404
- end
405
- end
406
-
407
- context 'set existing vector' do
408
- context 'by string' do
409
- before { df.b = [:a, :b, :c, :d, :e] }
410
- subject { df }
411
-
412
- it { is_expected.to be_a DaruLite::DataFrame }
413
- its(:'vectors.to_a') { is_expected.to eq [:a, 'b'] }
414
- its(:'b.to_a') { is_expected.to eq [:a, :b, :c, :d, :e] }
415
- its(:'index.to_a') { is_expected.to eq [11, 12, 13, 14, 15] }
416
- end
417
-
418
- context 'by symbol' do
419
- before { df.a = [:a, :b, :c, :d, :e] }
420
- subject { df }
421
-
422
- it { is_expected.to be_a DaruLite::DataFrame }
423
- its(:'vectors.to_a') { is_expected.to eq [:a, 'b'] }
424
- its(:'a.to_a') { is_expected.to eq [:a, :b, :c, :d, :e] }
425
- its(:'index.to_a') { is_expected.to eq [11, 12, 13, 14, 15] }
426
- end
427
- end
428
-
429
- context 'set new vector' do
430
- before { df.c = [5, 5, 5, 5, 5] }
431
- subject { df }
432
-
433
- it { is_expected.to be_a DaruLite::DataFrame }
434
- its(:'vectors.to_a') { is_expected.to eq [:a, 'b', :c] }
435
- its(:'c.to_a') { is_expected.to eq [5, 5, 5, 5, 5] }
436
- its(:'index.to_a') { is_expected.to eq [11, 12, 13, 14, 15] }
437
- end
438
-
439
- context 'reference invalid vector' do
440
- it { expect { df.d }.to raise_error NoMethodError }
441
- end
442
- end
443
-
444
- context "#row.at" do
445
- context DaruLite::Index do
446
- let(:idx) { DaruLite::Index.new [1, 0, :c] }
447
- let(:df) do
448
- DaruLite::DataFrame.new({
449
- a: 1..3,
450
- b: 'a'..'c'
451
- }, index: idx)
452
- end
453
-
454
- context "single position" do
455
- subject { df.row.at 1 }
456
-
457
- it { is_expected.to be_a DaruLite::Vector }
458
- its(:size) { is_expected.to eq 2 }
459
- its(:to_a) { is_expected.to eq [2, 'b'] }
460
- its(:'index.to_a') { is_expected.to eq [:a, :b] }
461
- end
462
-
463
- context "multiple positions" do
464
- subject { df.row.at 0, 2 }
465
-
466
- it { is_expected.to be_a DaruLite::DataFrame }
467
- its(:size) { is_expected.to eq 2 }
468
- its(:'index.to_a') { is_expected.to eq [1, :c] }
469
- its(:'a.to_a') { is_expected.to eq [1, 3] }
470
- its(:'b.to_a') { is_expected.to eq ['a', 'c'] }
471
- end
472
-
473
- context "invalid position" do
474
- it { expect { df.row.at 3 }.to raise_error IndexError }
475
- end
476
-
477
- context "invalid positions" do
478
- it { expect { df.row.at 2, 3 }.to raise_error IndexError }
479
- end
480
-
481
- context "range" do
482
- subject { df.row.at 0..1 }
483
-
484
- it { is_expected.to be_a DaruLite::DataFrame }
485
- its(:size) { is_expected.to eq 2 }
486
- its(:'index.to_a') { is_expected.to eq [1, 0] }
487
- its(:'a.to_a') { is_expected.to eq [1, 2] }
488
- its(:'b.to_a') { is_expected.to eq ['a', 'b'] }
489
- end
490
-
491
- context "range with negative end" do
492
- subject { df.row.at 0..-2 }
493
-
494
- it { is_expected.to be_a DaruLite::DataFrame }
495
- its(:size) { is_expected.to eq 2 }
496
- its(:'index.to_a') { is_expected.to eq [1, 0] }
497
- its(:'a.to_a') { is_expected.to eq [1, 2] }
498
- its(:'b.to_a') { is_expected.to eq ['a', 'b'] }
499
- end
500
-
501
- context "range with single element" do
502
- subject { df.row.at 0..0 }
503
-
504
- it { is_expected.to be_a DaruLite::DataFrame }
505
- its(:size) { is_expected.to eq 1 }
506
- its(:'index.to_a') { is_expected.to eq [1] }
507
- its(:'a.to_a') { is_expected.to eq [1] }
508
- its(:'b.to_a') { is_expected.to eq ['a'] }
509
- end
510
- end
511
-
512
- context DaruLite::MultiIndex do
513
- let (:idx) do
514
- DaruLite::MultiIndex.from_tuples [
515
- [:a,:one,:bar],
516
- [:a,:one,:baz],
517
- [:b,:two,:bar],
518
- [:a,:two,:baz],
519
- ]
520
- end
521
- let (:df) do
522
- DaruLite::DataFrame.new({
523
- a: 1..4,
524
- b: 'a'..'d'
525
- }, index: idx )
526
- end
527
-
528
- context "single position" do
529
- subject { df.row.at 1 }
530
-
531
- it { is_expected.to be_a DaruLite::Vector }
532
- its(:size) { is_expected.to eq 2 }
533
- its(:to_a) { is_expected.to eq [2, 'b'] }
534
- its(:'index.to_a') { is_expected.to eq [:a, :b] }
535
- end
536
-
537
- context "multiple positions" do
538
- subject { df.row.at 0, 2 }
539
-
540
- it { is_expected.to be_a DaruLite::DataFrame }
541
- its(:size) { is_expected.to eq 2 }
542
- its(:'index.to_a') { is_expected.to eq [[:a, :one, :bar],
543
- [:b, :two, :bar]] }
544
- its(:'a.to_a') { is_expected.to eq [1, 3] }
545
- its(:'a.index.to_a') { is_expected.to eq [[:a, :one, :bar],
546
- [:b, :two, :bar]] }
547
- its(:'b.to_a') { is_expected.to eq ['a', 'c'] }
548
- end
549
-
550
- context "invalid position" do
551
- it { expect { df.row.at 4 }.to raise_error IndexError }
552
- end
553
-
554
- context "invalid positions" do
555
- it { expect { df.row.at 3, 4 }.to raise_error IndexError }
556
- end
557
-
558
- context "range" do
559
- subject { df.row.at 0..1 }
560
-
561
- it { is_expected.to be_a DaruLite::DataFrame }
562
- its(:size) { is_expected.to eq 2 }
563
- its(:'index.to_a') { is_expected.to eq [[:a, :one, :bar],
564
- [:a, :one, :baz]] }
565
- its(:'a.to_a') { is_expected.to eq [1, 2] }
566
- its(:'a.index.to_a') { is_expected.to eq [[:a, :one, :bar],
567
- [:a, :one, :baz]] }
568
- its(:'b.to_a') { is_expected.to eq ['a', 'b'] }
569
- end
570
-
571
- context "range with negative end" do
572
- subject { df.row.at 0..-3 }
573
-
574
- it { is_expected.to be_a DaruLite::DataFrame }
575
- its(:size) { is_expected.to eq 2 }
576
- its(:'index.to_a') { is_expected.to eq [[:a, :one, :bar],
577
- [:a, :one, :baz]] }
578
- its(:'a.to_a') { is_expected.to eq [1, 2] }
579
- its(:'a.index.to_a') { is_expected.to eq [[:a, :one, :bar],
580
- [:a, :one, :baz]] }
581
- its(:'b.to_a') { is_expected.to eq ['a', 'b'] }
582
- end
583
-
584
- context " range with single element" do
585
- subject { df.row.at 0..0 }
586
-
587
- it { is_expected.to be_a DaruLite::DataFrame }
588
- its(:size) { is_expected.to eq 1 }
589
- its(:'index.to_a') { is_expected.to eq [[:a, :one, :bar]] }
590
- its(:'a.to_a') { is_expected.to eq [1] }
591
- its(:'a.index.to_a') { is_expected.to eq [[:a, :one, :bar]] }
592
- its(:'b.to_a') { is_expected.to eq ['a'] }
593
- end
594
- end
595
-
596
- context DaruLite::CategoricalIndex do
597
- let (:idx) { DaruLite::CategoricalIndex.new [:a, 1, 1, :a, :c] }
598
- let (:df) do
599
- DaruLite::DataFrame.new({
600
- a: 1..5,
601
- b: 'a'..'e'
602
- }, index: idx )
603
- end
604
-
605
- context "single positional index" do
606
- subject { df.row.at 1 }
607
-
608
- it { is_expected.to be_a DaruLite::Vector }
609
- its(:size) { is_expected.to eq 2 }
610
- its(:to_a) { is_expected.to eq [2, 'b'] }
611
- its(:'index.to_a') { is_expected.to eq [:a, :b] }
612
- end
613
-
614
- context "multiple positional indexes" do
615
- subject { df.row.at 0, 2 }
616
-
617
- it { is_expected.to be_a DaruLite::DataFrame }
618
- its(:size) { is_expected.to eq 2 }
619
- its(:'index.to_a') { is_expected.to eq [:a, 1] }
620
- its(:'a.to_a') { is_expected.to eq [1, 3] }
621
- its(:'a.index.to_a') { is_expected.to eq [:a, 1] }
622
- its(:'b.to_a') { is_expected.to eq ['a', 'c'] }
623
- its(:'b.index.to_a') { is_expected.to eq [:a, 1] }
624
- end
625
-
626
- context "invalid position" do
627
- it { expect { df.at 5 }.to raise_error IndexError }
628
- end
629
-
630
- context "invalid positions" do
631
- it { expect { df.at 4, 5 }.to raise_error IndexError }
632
- end
633
-
634
- context "range" do
635
- subject { df.row.at 0..1 }
636
-
637
- it { is_expected.to be_a DaruLite::DataFrame }
638
- its(:size) { is_expected.to eq 2 }
639
- its(:'index.to_a') { is_expected.to eq [:a, 1] }
640
- its(:'a.to_a') { is_expected.to eq [1, 2] }
641
- its(:'a.index.to_a') { is_expected.to eq [:a, 1] }
642
- its(:'b.to_a') { is_expected.to eq ['a', 'b'] }
643
- its(:'b.index.to_a') { is_expected.to eq [:a, 1] }
644
- end
645
-
646
- context "range with negative end" do
647
- subject { df.row.at 0..-4 }
648
-
649
- it { is_expected.to be_a DaruLite::DataFrame }
650
- its(:size) { is_expected.to eq 2 }
651
- its(:'index.to_a') { is_expected.to eq [:a, 1] }
652
- its(:'a.to_a') { is_expected.to eq [1, 2] }
653
- its(:'a.index.to_a') { is_expected.to eq [:a, 1] }
654
- its(:'b.to_a') { is_expected.to eq ['a', 'b'] }
655
- its(:'b.index.to_a') { is_expected.to eq [:a, 1] }
656
- end
657
-
658
- context " range with single element" do
659
- subject { df.row.at 0..0 }
660
-
661
- it { is_expected.to be_a DaruLite::DataFrame }
662
- its(:size) { is_expected.to eq 1 }
663
- its(:'index.to_a') { is_expected.to eq [:a] }
664
- its(:'a.to_a') { is_expected.to eq [1] }
665
- its(:'a.index.to_a') { is_expected.to eq [:a] }
666
- its(:'b.to_a') { is_expected.to eq ['a'] }
667
- its(:'b.index.to_a') { is_expected.to eq [:a] }
668
- end
669
- end
670
- end
671
-
672
- context "#row[]" do
673
- context DaruLite::Index do
674
- before :each do
675
- @df = DaruLite::DataFrame.new({b: [11,12,13,14,15], a: [1,2,3,4,5],
676
- c: [11,22,33,44,55]}, order: [:a, :b, :c],
677
- index: [:one, :two, :three, :four, :five])
678
- end
679
-
680
- it "creates an index for assignment if not already specified" do
681
- @df.row[:one] = [49, 99, 59]
682
-
683
- expect(@df[:one, :row]) .to eq([49, 99, 59].dv(:one, [:a, :b, :c]))
684
- expect(@df[:one, :row].index).to eq([:a, :b, :c].to_index)
685
- expect(@df[:one, :row].name) .to eq(:one)
686
- end
687
-
688
- it "returns a DataFrame when specifying numeric Range" do
689
- expect(@df.row[0..2]).to eq(
690
- DaruLite::DataFrame.new({b: [11,12,13], a: [1,2,3],
691
- c: [11,22,33]}, order: [:a, :b, :c],
692
- index: [:one, :two, :three])
693
- )
694
- end
695
-
696
- it "returns a DataFrame when specifying symbolic Range" do
697
- expect(@df.row[:one..:three]).to eq(
698
- DaruLite::DataFrame.new({b: [11,12,13], a: [1,2,3],
699
- c: [11,22,33]}, order: [:a, :b, :c],
700
- index: [:one, :two, :three])
701
- )
702
- end
703
-
704
- it "returns a row with the given index" do
705
- expect(@df.row[:one]).to eq([1,11,11].dv(:one, [:a, :b, :c]))
706
- end
707
-
708
- it "returns a row with given Integer index" do
709
- expect(@df.row[0]).to eq([1,11,11].dv(:one, [:a, :b, :c]))
710
- end
711
-
712
- it "returns a row with given Integer index for default index-less DataFrame" do
713
- df = DaruLite::DataFrame.new({b: [11,12,13,14,15], a: [1,2,3,4,5],
714
- c: [11,22,33,44,55]}, order: [:a, :b, :c])
715
-
716
- expect(df.row[0]).to eq([1,11,11].dv(nil, [:a, :b, :c]))
717
- expect(df.row[3]).to eq([4,14,44].dv(nil, [:a, :b, :c]))
718
- end
719
-
720
- it "returns a row with given Integer index for numerical index DataFrame" do
721
- df = DaruLite::DataFrame.new({b: [11,12,13,14,15], a: [1,2,3,4,5],
722
- c: [11,22,33,44,55]}, order: [:a, :b, :c], index: [1,2,3,4,5])
723
-
724
- expect(df.row[0]).to eq([1,11,11].dv(nil, [:a, :b, :c]))
725
- expect(df.row[3]).to eq([3,13,33].dv(nil, [:a, :b, :c]))
726
- end
727
- end
728
-
729
- context DaruLite::MultiIndex do
730
- it "returns a Vector when specifying integer index" do
731
- expect(df_mi.row[0]).to eq(DaruLite::Vector.new([11,1,11,1], index: order_mi))
732
- end
733
-
734
- it "returns a DataFrame whecn specifying numeric range" do
735
- sub_index = DaruLite::MultiIndex.from_tuples([
736
- [:a,:one,:bar],
737
- [:a,:one,:baz]
738
- ])
739
-
740
- expect(df_mi.row[0..1]).to eq(DaruLite::DataFrame.new([
741
- [11,12],
742
- [1,2],
743
- [11,12],
744
- [1,2]
745
- ], order: order_mi, index: sub_index, name: :numeric_range))
746
- end
747
-
748
- it "returns a Vector when specifying complete tuple" do
749
- expect(df_mi.row[:c,:two,:foo]).to eq(DaruLite::Vector.new([13,3,13,3], index: order_mi))
750
- end
751
-
752
- it "returns DataFrame when specifying first layer of MultiIndex" do
753
- sub_index = DaruLite::MultiIndex.from_tuples([
754
- [:one,:bar],
755
- [:one,:baz],
756
- [:two,:foo],
757
- [:two,:bar]
758
- ])
759
- expect(df_mi.row[:c]).to eq(DaruLite::DataFrame.new([
760
- [11,12,13,14],
761
- [1,2,3,4],
762
- [11,12,13,14],
763
- [1,2,3,4]
764
- ], index: sub_index, order: order_mi))
765
- end
766
-
767
- it "returns DataFrame when specifying first and second layer of MultiIndex" do
768
- sub_index = DaruLite::MultiIndex.from_tuples([
769
- [:bar],
770
- [:baz]
771
- ])
772
- expect(df_mi.row[:c,:one]).to eq(DaruLite::DataFrame.new([
773
- [11,12],
774
- [1,2],
775
- [11,12],
776
- [1,2]
777
- ], index: sub_index, order: order_mi))
778
- end
779
- end
780
-
781
- context DaruLite::CategoricalIndex do
782
- let(:idx) { DaruLite::CategoricalIndex.new [:a, 1, :a, 1, :c] }
783
- let(:df) do
784
- DaruLite::DataFrame.new({
785
- a: 'a'..'e',
786
- b: 1..5
787
- }, index: idx)
788
- end
789
-
790
- context "single category" do
791
- context "multiple instances" do
792
- subject { df.row[:a] }
793
-
794
- it { is_expected.to be_a DaruLite::DataFrame }
795
- its(:index) { is_expected.to eq DaruLite::CategoricalIndex.new [:a, :a] }
796
- its(:vectors) { is_expected.to eq DaruLite::Index.new [:a, :b] }
797
- its(:a) { DaruLite::Vector.new ['a', 'c'] }
798
- its(:b) { DaruLite::Vector.new [1, 3] }
799
- end
800
-
801
- context "single instance" do
802
- subject { df.row[:c] }
803
-
804
- it { is_expected.to be_a DaruLite::Vector }
805
- its(:index) { is_expected.to eq DaruLite::Index.new [:a, :b] }
806
- its(:to_a) { is_expected.to eq ['e', 5] }
807
- end
808
- end
809
-
810
- context "multiple categories" do
811
- subject { df.row[:a, 1] }
812
-
813
- it { is_expected.to be_a DaruLite::DataFrame }
814
- its(:index) { is_expected.to eq DaruLite::CategoricalIndex.new(
815
- [:a, 1, :a, 1 ]) }
816
- its(:vectors) { is_expected.to eq DaruLite::Index.new [:a, :b] }
817
- its(:a) { DaruLite::Vector.new ['a', 'c', 'b', 'd'] }
818
- its(:b) { DaruLite::Vector.new [1, 3, 2, 4] }
819
- end
820
-
821
- context "positional index" do
822
- subject { df.row[0] }
823
-
824
- it { is_expected.to be_a DaruLite::Vector }
825
- its(:index) { is_expected.to eq DaruLite::Index.new [:a, :b] }
826
- its(:to_a) { is_expected.to eq ['a', 1] }
827
- end
828
-
829
- context "invalid positional index" do
830
- it { expect { df.row[5] }.to raise_error IndexError }
831
- end
832
-
833
- context "invalid category" do
834
- it { expect { df.row[:d] }.to raise_error IndexError }
835
- end
836
- end
837
- end
838
-
839
- context "#==" do
840
- it "compares by vectors, index and values of a DataFrame (ignores name)" do
841
- a = DaruLite::DataFrame.new({b: [11,12,13,14,15], a: [1,2,3,4,5]},
842
- order: [:a, :b], index: [:one, :two, :three, :four, :five])
843
-
844
- b = DaruLite::DataFrame.new({b: [11,12,13,14,15], a: [1,2,3,4,5]},
845
- order: [:a, :b], index: [:one, :two, :three, :four, :five])
846
-
847
- expect(a).to eq(b)
848
- end
849
- end
850
-
851
- context '#rename' do
852
- subject { df.rename 'other' }
853
-
854
- it { is_expected.to be_a DaruLite::DataFrame }
855
- its(:name) { is_expected.to eq 'other' }
856
- end
857
-
858
- context "#delete_vector" do
859
- context DaruLite::Index do
860
- it "deletes the specified vector" do
861
- df.delete_vector :a
862
-
863
- expect(df).to eq(DaruLite::DataFrame.new({b: [11,12,13,14,15],
864
- c: [11,22,33,44,55]}, order: [:b, :c],
865
- index: [:one, :two, :three, :four, :five]))
866
- end
867
- end
868
- end
869
-
870
- context "#delete_vectors" do
871
- context DaruLite::Index do
872
- it "deletes the specified vectors" do
873
- df.delete_vectors :a, :b
874
-
875
- expect(df).to eq(DaruLite::DataFrame.new({
876
- c: [11,22,33,44,55]}, order: [:c],
877
- index: [:one, :two, :three, :four, :five]))
878
- end
879
- end
880
- end
881
-
882
- context "#delete_row" do
883
- it "deletes the specified row" do
884
- df.delete_row :three
885
-
886
- expect(df).to eq(DaruLite::DataFrame.new({b: [11,12,14,15], a: [1,2,4,5],
887
- c: [11,22,44,55]}, order: [:a, :b, :c], index: [:one, :two, :four, :five]))
888
- end
889
-
890
- context "when the data frame has a CategoricalIndex" do
891
- let(:categorical_df) do
892
- frame = DaruLite::DataFrame.new(
893
- { a: [1, 2, 3], b: [11, 22, 33] },
894
- order: [:a, :b],
895
- index: [:base, :one, :two]
896
- )
897
- frame.index = DaruLite::CategoricalIndex.new([:base, :one, :two])
898
- frame
899
- end
900
-
901
- it "deletes the specified row without raising" do
902
- expect { categorical_df.delete_row :base }.not_to raise_error
903
- expect(categorical_df.index.to_a).to eq [:one, :two]
904
- end
905
- end
906
- end
907
-
908
- context "#rename_vectors!" do
909
- before do
910
- @df = DaruLite::DataFrame.new({
911
- a: [1,2,3,4,5],
912
- b: [11,22,33,44,55],
913
- c: %w(a b c d e)
914
- })
915
- end
916
-
917
- it "returns self as modified dataframe" do
918
- expect(@df.rename_vectors!(:a => :alpha)).to eq(@df)
919
- end
920
-
921
- it "re-uses rename_vectors method" do
922
- name_map = { :a => :alpha, :c => :gamma }
923
- expect(@df).to receive(:rename_vectors).with(name_map)
924
- @df.rename_vectors! name_map
925
- end
926
- end
927
-
928
- context "#rename_vectors" do
929
- before do
930
- @df = DaruLite::DataFrame.new({
931
- a: [1,2,3,4,5],
932
- b: [11,22,33,44,55],
933
- c: %w(a b c d e)
934
- })
935
- end
936
-
937
- it "returns DaruLite::Index" do
938
- expect(@df.rename_vectors(:a => :alpha)).to be_kind_of(DaruLite::Index)
939
- end
940
-
941
- it "renames vectors using a hash map" do
942
- @df.rename_vectors :a => :alpha, :c => :gamma
943
- expect(@df.vectors.to_a).to eq([:alpha, :b, :gamma])
944
- end
945
-
946
- it "overwrites vectors if the new name already exists" do
947
- saved_vector = @df[:a].dup
948
-
949
- @df.rename_vectors :a => :b
950
- expect(@df.vectors.to_a).to eq([:b, :c])
951
- expect(@df[:b]).to eq saved_vector
952
- end
953
-
954
- it "makes no changes if the old and new names are the same" do
955
- saved_vector = @df[:a].dup
956
-
957
- @df.rename_vectors :a => :a
958
- expect(@df.vectors.to_a).to eq([:a, :b, :c])
959
- expect(@df[:a]).to eq saved_vector
960
- end
961
- end
962
-
963
- context "#add_level_to_vectors" do
964
- subject { df.add_level_to_vectors(top_level_label) }
965
-
966
- let(:df) do
967
- DaruLite::DataFrame.new({
968
- a: [1, 2, 3, 4, 5],
969
- b: [11, 22, 33, 44, 55],
970
- c: %w(a b c d e)
971
- })
972
- end
973
- let(:top_level_label) { :percentages }
974
- let(:expected_index) do
975
- DaruLite::MultiIndex.from_tuples([
976
- [:percentages, :a], [:percentages, :b],[:percentages, :c],
977
- ])
978
- end
979
-
980
- it 'returns expected Multi::Index' do
981
- expect(subject).to eq(expected_index)
982
- end
983
-
984
- it 'updates dataframe vectors to the expected Multi::Index' do
985
- expect { subject }.to change { df.vectors }.to(expected_index)
986
- end
987
- end
988
-
989
- context "#transpose" do
990
- context DaruLite::Index do
991
- it "transposes a DataFrame including row and column indexing" do
992
- expect(df.transpose).to eq(DaruLite::DataFrame.new({
993
- one: [1,11,11],
994
- two: [2,12,22],
995
- three: [3,13,33],
996
- four: [4,14,44],
997
- five: [5,15,55]
998
- }, index: [:a, :b, :c],
999
- order: [:one, :two, :three, :four, :five])
1000
- )
1001
- end
1002
- end
1003
-
1004
- context DaruLite::MultiIndex do
1005
- it "transposes a DataFrame including row and column indexing" do
1006
- expect(df_mi.transpose).to eq(DaruLite::DataFrame.new([
1007
- vector_arry1,
1008
- vector_arry2,
1009
- vector_arry1,
1010
- vector_arry2].transpose, index: order_mi, order: multi_index))
1011
- end
1012
- end
1013
- end
1014
-
1015
- context "#shape" do
1016
- it "returns an array containing number of rows and columns" do
1017
- expect(df.shape).to eq([5,3])
1018
- end
1019
- end
1020
-
1021
- context "#nest" do
1022
- it "nests in a hash" do
1023
- df = DaruLite::DataFrame.new({
1024
- :a => DaruLite::Vector.new(%w(a a a b b b)),
1025
- :b => DaruLite::Vector.new(%w(c c d d e e)),
1026
- :c => DaruLite::Vector.new(%w(f g h i j k))
1027
- })
1028
- nest = df.nest :a, :b
1029
- expect(nest['a']['c']).to eq([{ :c => 'f' }, { :c => 'g' }])
1030
- expect(nest['a']['d']).to eq([{ :c => 'h' }])
1031
- expect(nest['b']['e']).to eq([{ :c => 'j' }, { :c => 'k' }])
1032
- end
1033
- end
1034
-
1035
- context "#add_vectors_by_split_recode" do
1036
- before do
1037
- @ds = DaruLite::DataFrame.new({
1038
- :id => DaruLite::Vector.new([1, 2, 3, 4, 5]),
1039
- :name => DaruLite::Vector.new(%w(Alex Claude Peter Franz George)),
1040
- :age => DaruLite::Vector.new([20, 23, 25, 27, 5]),
1041
- :city => DaruLite::Vector.new(['New York', 'London', 'London', 'Paris', 'Tome']),
1042
- :a1 => DaruLite::Vector.new(['a,b', 'b,c', 'a', nil, 'a,b,c']) },
1043
- order: [:id, :name, :age, :city, :a1])
1044
- end
1045
-
1046
- it "" do
1047
- @ds.add_vectors_by_split_recode(:a1, '_')
1048
- expect(@ds.vectors.to_a) .to eq([:id, :name, :age, :city ,:a1, :a1_1, :a1_2, :a1_3])
1049
- expect(@ds[:a1_1].to_a).to eq([1, 0, 1, nil, 1])
1050
- expect(@ds[:a1_2].to_a).to eq([1, 1, 0, nil, 1])
1051
- expect(@ds[:a1_3].to_a).to eq([0, 1, 0, nil, 1])
1052
- end
1053
- end
1054
-
1055
- context "#add_vectors_by_split" do
1056
- before do
1057
- @ds = DaruLite::DataFrame.new({
1058
- :id => DaruLite::Vector.new([1, 2, 3, 4, 5]),
1059
- :name => DaruLite::Vector.new(%w(Alex Claude Peter Franz George)),
1060
- :age => DaruLite::Vector.new([20, 23, 25, 27, 5]),
1061
- :city => DaruLite::Vector.new(['New York', 'London', 'London', 'Paris', 'Tome']),
1062
- :a1 => DaruLite::Vector.new(['a,b', 'b,c', 'a', nil, 'a,b,c'])
1063
- }, order: [:id, :name, :age, :city, :a1])
1064
- end
1065
-
1066
- it "" do
1067
- @ds.add_vectors_by_split(:a1, '_')
1068
- expect(@ds.vectors.to_a).to eq([:id, :name, :age, :city, :a1, :a1_a, :a1_b, :a1_c])
1069
- expect(@ds[:a1_a].to_a).to eq([1, 0, 1, nil, 1])
1070
- expect(@ds[:a1_b].to_a).to eq([1, 1, 0, nil, 1])
1071
- expect(@ds[:a1_c].to_a).to eq([0, 1, 0, nil, 1])
1072
- end
1073
- end
1074
-
1075
- context ".crosstab_by_assignation" do
1076
- it "" do
1077
- v1 = DaruLite::Vector.new %w(a a a b b b c c c)
1078
- v2 = DaruLite::Vector.new %w(a b c a b c a b c)
1079
- v3 = DaruLite::Vector.new [0, 1, 0, 0, 1, 1, 0, 0, 1]
1080
- df = DaruLite::DataFrame.crosstab_by_assignation(v1, v2, v3)
1081
-
1082
- expect(df[:_id].type).to eq(:object)
1083
- expect(df['a'].type).to eq(:numeric)
1084
- expect(df['b'].type).to eq(:numeric)
1085
-
1086
- ev_id = DaruLite::Vector.new %w(a b c)
1087
- ev_a = DaruLite::Vector.new [0, 0, 0]
1088
- ev_b = DaruLite::Vector.new [1, 1, 0]
1089
- ev_c = DaruLite::Vector.new [0, 1, 1]
1090
- df2 = DaruLite::DataFrame.new({
1091
- :_id => ev_id, 'a' => ev_a, 'b' => ev_b, 'c' => ev_c },
1092
- order: ['a', 'b', 'c', :_id])
1093
-
1094
- expect(df2).to eq(df)
1095
- end
1096
-
1097
- it 'handles nil values in the rows vector' do
1098
- v1 = DaruLite::Vector.new [nil, 'a', nil, 'a']
1099
- v2 = DaruLite::Vector.new %w[x x y y]
1100
- v3 = DaruLite::Vector.new [1, 2, 3, 4]
1101
- df = DaruLite::DataFrame.crosstab_by_assignation(v1, v2, v3)
1102
-
1103
- expect(df[:_id].to_a).to eq([nil, 'a'])
1104
- expect(df['x'].to_a).to eq([1, 2])
1105
- expect(df['y'].to_a).to eq([3, 4])
1106
- end
1107
-
1108
- it 'raises IndexError when given duplicate (row, column) pairs' do
1109
- rows = DaruLite::Vector.new(%w[a a b])
1110
- columns = DaruLite::Vector.new(%w[x x y])
1111
- values = DaruLite::Vector.new([1, 2, 3])
1112
-
1113
- expect {
1114
- described_class.crosstab_by_assignation(rows, columns, values)
1115
- }.to raise_error(IndexError, /Duplicate/)
1116
- end
1117
- end
1118
-
1119
- context '#inspect' do
1120
- subject { df.inspect }
1121
-
1122
- context 'empty' do
1123
- let(:df) { DaruLite::DataFrame.new({}, order: %w[a b c])}
1124
- it { is_expected.to eq %Q{
1125
- |#<DaruLite::DataFrame(0x3)>
1126
- | a b c
1127
- }.unindent}
1128
- end
1129
-
1130
- context 'simple' do
1131
- let(:df) { DaruLite::DataFrame.new({a: [1,2,3], b: [3,4,5], c: [6,7,8]}, name: 'test')}
1132
- it { should == %Q{
1133
- |#<DaruLite::DataFrame: test (3x3)>
1134
- | a b c
1135
- | 0 1 3 6
1136
- | 1 2 4 7
1137
- | 2 3 5 8
1138
- }.unindent}
1139
- end
1140
-
1141
- context 'if index name is set' do
1142
- context 'single index with name' do
1143
- let(:df) { DaruLite::DataFrame.new({a: [1,2,3], b: [3,4,5], c: [6,7,8]},
1144
- name: 'test')}
1145
- before { df.index.name = 'index_name' }
1146
- it { should == %Q{
1147
- |#<DaruLite::DataFrame: test (3x3)>
1148
- | index_name a b c
1149
- | 0 1 3 6
1150
- | 1 2 4 7
1151
- | 2 3 5 8
1152
- }.unindent}
1153
- end
1154
-
1155
- context 'MultiIndex with name' do
1156
- let(:mi) { DaruLite::MultiIndex.new(
1157
- levels: [[:a,:b,:c], [:one, :two]],
1158
- labels: [[0,0,1,1,2,2], [0,1,0,1,0,1]], name: ['s1', 's2']) }
1159
- let(:df) { DaruLite::DataFrame.new({
1160
- a: [11, 12, 13, 14, 15, 16], b: [21, 22, 23, 24, 25, 26]},
1161
- name: 'test', index: mi)}
1162
- it { should == %Q{
1163
- |#<DaruLite::DataFrame: test (6x2)>
1164
- | s1 s2 a b
1165
- | a one 11 21
1166
- | two 12 22
1167
- | b one 13 23
1168
- | two 14 24
1169
- | c one 15 25
1170
- | two 16 26
1171
- }.unindent}
1172
- end
1173
-
1174
- end
1175
-
1176
- context 'no name' do
1177
- let(:df) { DaruLite::DataFrame.new({a: [1,2,3], b: [3,4,5], c: [6,7,8]})}
1178
- it { should == %Q{
1179
- |#<DaruLite::DataFrame(3x3)>
1180
- | a b c
1181
- | 0 1 3 6
1182
- | 1 2 4 7
1183
- | 2 3 5 8
1184
- }.unindent}
1185
- end
1186
-
1187
- context 'with nils' do
1188
- let(:df) { DaruLite::DataFrame.new({a: [1,nil,3], b: [3,4,5], c: [6,7,nil]}, name: 'test')}
1189
- it { is_expected.to eq %Q{
1190
- |#<DaruLite::DataFrame: test (3x3)>
1191
- | a b c
1192
- | 0 1 3 6
1193
- | 1 nil 4 7
1194
- | 2 3 5 nil
1195
- }.unindent}
1196
- end
1197
-
1198
- context 'with integers as vectors names' do
1199
- let(:df) { DaruLite::DataFrame.new({ 1 => [1,2,3], b: [3,4,5], c: [6,7,8] }, name: 'test')}
1200
-
1201
- it { is_expected.to eq %Q{
1202
- |#<DaruLite::DataFrame: test (3x3)>
1203
- | 1 b c
1204
- | 0 1 3 6
1205
- | 1 2 4 7
1206
- | 2 3 5 8
1207
- }.unindent}
1208
- end
1209
-
1210
- context 'very long' do
1211
- let(:df) { DaruLite::DataFrame.new({a: [1,1,1]*20, b: [1,1,1]*20, c: [1,1,1]*20}, name: 'test')}
1212
- it { is_expected.to eq %Q{
1213
- |#<DaruLite::DataFrame: test (60x3)>
1214
- | a b c
1215
- | 0 1 1 1
1216
- | 1 1 1 1
1217
- | 2 1 1 1
1218
- | 3 1 1 1
1219
- | 4 1 1 1
1220
- | 5 1 1 1
1221
- | 6 1 1 1
1222
- | 7 1 1 1
1223
- | 8 1 1 1
1224
- | 9 1 1 1
1225
- | 10 1 1 1
1226
- | 11 1 1 1
1227
- | 12 1 1 1
1228
- | 13 1 1 1
1229
- | 14 1 1 1
1230
- | 15 1 1 1
1231
- | 16 1 1 1
1232
- | 17 1 1 1
1233
- | 18 1 1 1
1234
- | 19 1 1 1
1235
- | 20 1 1 1
1236
- | 21 1 1 1
1237
- | 22 1 1 1
1238
- | 23 1 1 1
1239
- | 24 1 1 1
1240
- | 25 1 1 1
1241
- | 26 1 1 1
1242
- | 27 1 1 1
1243
- | 28 1 1 1
1244
- | 29 1 1 1
1245
- | ... ... ... ...
1246
- }.unindent}
1247
- end
1248
-
1249
- context 'long data lines' do
1250
- let(:df) { DaruLite::DataFrame.new({a: [1,2,3], b: [4,5,6], c: ['this is ridiculously long',nil,nil]}, name: 'test')}
1251
- it { is_expected.to eq %Q{
1252
- |#<DaruLite::DataFrame: test (3x3)>
1253
- | a b c
1254
- | 0 1 4 this is ri
1255
- | 1 2 5 nil
1256
- | 2 3 6 nil
1257
- }.unindent}
1258
- end
1259
-
1260
- context 'index is a MultiIndex' do
1261
- let(:df) {
1262
- DaruLite::DataFrame.new(
1263
- {
1264
- a: [1,2,3,4,5,6,7],
1265
- b: %w[a b c d e f g]
1266
- }, index: DaruLite::MultiIndex.from_tuples([
1267
- %w[foo one],
1268
- %w[foo two],
1269
- %w[foo three],
1270
- %w[bar one],
1271
- %w[bar two],
1272
- %w[bar three],
1273
- %w[baz one],
1274
- ]),
1275
- name: 'test'
1276
- )
1277
- }
1278
-
1279
- it { is_expected.to eq %Q{
1280
- |#<DaruLite::DataFrame: test (7x2)>
1281
- | a b
1282
- | foo one 1 a
1283
- | two 2 b
1284
- | three 3 c
1285
- | bar one 4 d
1286
- | two 5 e
1287
- | three 6 f
1288
- | baz one 7 g
1289
- }.unindent}
1290
- end
1291
-
1292
- context 'vectors is a MultiIndex' do
1293
- end
1294
-
1295
- context 'spacing and threshold settings' do
1296
- end
1297
- end
1298
-
1299
- context "#by_single_key" do
1300
- let(:df) { DaruLite::DataFrame.new(a: [1, 2, 3], b: [4, 5, 6] ) }
1301
-
1302
- it 'raise error when vector is missing from dataframe' do
1303
- expect { df[:c] }.to raise_error(IndexError, /Specified vector c does not exist/)
1304
- end
1305
- end
1306
- end if mri?