daru 0.0.3 → 0.0.3.1

data/lib/daru/{io.rb → io/io.rb}

@@ -16,7 +16,7 @@ module Daru
 
         csv.each_with_index do |row, index|
           if first
-            df    = Daru::DataFrame.new({}, csv.headers)
+            df    = Daru::DataFrame.new({}, vectors: csv.headers)
             first = false
           end
 

data/lib/daru/math/arithmetic/dataframe.rb

@@ -0,0 +1,28 @@
+module Daru
+  module Math
+    module Arithmetic
+      module DataFrame
+        
+        def + other
+          
+        end
+
+        def - other
+          
+        end
+
+        def * other
+          
+        end
+
+        def / other
+          
+        end
+
+        def % other
+          
+        end
+      end
+    end
+  end
+end

data/lib/daru/math/arithmetic/vector.rb

@@ -0,0 +1,71 @@
+module Daru
+  module Math
+    module Arithmetic
+      module Vector
+        def + other
+          case other
+          when Daru::Vector
+            v2v_binary :+, other
+          else
+            Daru::Vector.new self.map { |e| e + other }, name: @name, index: @index
+          end
+        end
+
+        def - other
+          case other
+          when Daru::Vector
+            v2v_binary :-, other
+          else
+            Daru::Vector.new self.map { |e| e - other }, name: @name, index: @index
+          end
+        end
+
+        def * other
+          case other
+          when Daru::Vector
+            v2v_binary :*, other
+          else
+            Daru::Vector.new self.map { |e| e * other }, name: @name, index: @index
+          end
+        end
+
+        def / other
+          case other
+          when Daru::Vector
+            v2v_binary :/, other
+          else
+            Daru::Vector.new self.map { |e| e / other }, name: @name, index: @index
+          end
+        end
+
+        def % other
+          case other
+          when Daru::Vector
+            v2v_binary :%, other
+          else
+            Daru::Vector.new self.map { |e| e % other }, name: @name, index: @index
+          end
+        end
+
+       private
+
+        def v2v_binary operation, other
+          common_idxs = []
+          elements    = []
+
+          @index.each do |idx|
+            this = self[idx]
+            that = other[idx]
+
+            if this and that
+              elements << this.send(operation ,that)
+              common_idxs << idx
+            end
+          end
+
+          Daru::Vector.new(elements, name: @name, index: common_idxs)
+        end
+      end
+    end
+  end
+end

data/lib/daru/math/statistics/dataframe.rb

@@ -0,0 +1,10 @@
+module Daru
+  module Math
+    module Statistics
+      module DataFrame
+        
+        
+      end
+    end
+  end
+end

data/lib/daru/math/statistics/vector.rb

@@ -0,0 +1,9 @@
+module Daru
+  module Math
+    module Statistics
+      module Vector
+        
+      end
+    end
+  end
+end

data/lib/daru/monkeys.rb

@@ -1,6 +1,6 @@
 class Array
   def daru_vector name=nil, index=nil
-    Daru::Vector.new name, self, index
+    Daru::Vector.new self, name: name, index: index
   end
 
   alias_method :dv, :daru_vector
@@ -12,7 +12,7 @@ end
 
 class Range
   def daru_vector name=nil, index=nil
-    Daru::Vector.new name, self, index
+    Daru::Vector.new self, name: name, index: index
   end
 
   alias_method :dv, :daru_vector
@@ -24,7 +24,7 @@ end
 
 class Hash
   def daru_vector index=nil
-    Daru::Vector.new self.values[0], self.keys[0], index
+    Daru::Vector.new self.values[0], name: self.keys[0], index: index
   end
 
   alias_method :dv, :daru_vector
@@ -32,7 +32,7 @@ end
 
 class NMatrix
   def daru_vector name=nil, index=nil
-    Daru::Vector.new name, self, index
+    Daru::Vector.new self, name: name, index: index
   end
 
   alias_method :dv, :daru_vector
@@ -40,7 +40,7 @@ end
 
 class MDArray
   def daru_vector name=nil, index=nil
-    Daru::Vector.new name, self, index
+    Daru::Vector.new self, name: name, index: index
   end
 
   alias_method :dv, :daru_vector

data/lib/daru/vector.rb

@@ -1,5 +1,10 @@
+require_relative 'math/arithmetic/vector.rb'
+require_relative 'math/statistics/vector.rb'
+
 module Daru
   class Vector
+    include Daru::Math::Arithmetic::Vector
+    include Daru::Math::Statistics::Vector
     include Enumerable
 
     def each(&block)
@@ -11,10 +16,10 @@ module Daru
     attr_reader :size
 
     # Pass it name, source and index
-    def initialize *args
-      name   = args.shift
-      source = args.shift || []
-      index  = args.shift
+    def initialize source, opts={}
+      source = source || []
+      name   = opts[:name]
+      index  = opts[:index]
 
       set_name name
 
@@ -50,12 +55,13 @@ module Daru
         elsif index.is_a?(Numeric)
           @vector[index]
         else
-          raise IndexError, "Specified index #{index} does not exist."
+          return nil
         end
       else
         indexes.unshift index
 
-        Daru::Vector.new @name, indexes.map { |index| @vector[@index[index]] }, indexes
+        Daru::Vector.new indexes.map { |index| @vector[@index[index]] },name: @name, 
+          index: indexes
       end
     end
 
@@ -130,6 +136,10 @@ module Daru
       end
     end
 
+    def to_a
+      @vector.to_a
+    end
+
     def to_json *args 
       self.to_hash.to_json
     end
@@ -158,7 +168,8 @@ module Daru
     end
 
     def inspect spacing=10, threshold=15
-      longest = [@index.to_a.map(&:to_s).map(&:size).max, 
+      longest = [@name.to_s.size,
+                 @index.to_a.map(&:to_s).map(&:size).max, 
                  @vector    .map(&:to_s).map(&:size).max].max
 
       content   = ""
@@ -170,7 +181,7 @@ module Daru
 
       content += sprintf formatter, "", name
       @index.each_with_index do |index, num|
-        content += sprintf formatter, index.to_s, self[index]
+        content += sprintf formatter, index.to_s, (self[index] || 'nil').to_s
 
         if num > threshold
           content += sprintf formatter, '...', '...'
@@ -194,7 +205,7 @@ module Daru
     end
 
     def dup 
-      Daru::Vector.new @name, @vector.dup, @index.dup
+      Daru::Vector.new @vector.dup, name: @name, index: @index.dup
     end
 
     def daru_vector *name

data/lib/version.rb

@@ -1,3 +1,3 @@
 module Daru
-  VERSION = "0.0.3"
+  VERSION = "0.0.3.1"
 end

data/spec/dataframe_spec.rb

@@ -3,12 +3,14 @@ require 'spec_helper.rb'
 describe Daru::DataFrame do
   before :each do
     @data_frame = Daru::DataFrame.new({b: [11,12,13,14,15], a: [1,2,3,4,5], 
-      c: [11,22,33,44,55]}, [:a, :b, :c], [:one, :two, :three, :four, :five])
+      c: [11,22,33,44,55]}, 
+      vectors: [:a, :b, :c], 
+      index: [:one, :two, :three, :four, :five])
   end
 
   context "#initialize" do
     it "initializes an empty DataFrame" do
-      df = Daru::DataFrame.new({}, [:a, :b])
+      df = Daru::DataFrame.new({}, vectors: [:a, :b])
 
       expect(df.vectors).to eq(Daru::Index.new [:a, :b])
       expect(df.a.class).to eq(Daru::Vector)
@@ -16,8 +18,8 @@ describe Daru::DataFrame do
     end
 
     it "initializes from a Hash" do
-      df = Daru::DataFrame.new({b: [11,12,13,14,15], a: [1,2,3,4,5]}, [:a, :b],
-        [:one, :two, :three, :four, :five])
+      df = Daru::DataFrame.new({b: [11,12,13,14,15], a: [1,2,3,4,5]}, vectors: [:a, :b],
+        index: [:one, :two, :three, :four, :five])
 
       expect(df.index)  .to eq(Daru::Index.new [:one, :two, :three, :four, :five])
       expect(df.vectors).to eq(Daru::Index.new [:a, :b])
@@ -27,8 +29,8 @@ describe Daru::DataFrame do
 
     it "initializes from a Hash of Vectors", :focus => true do
       df = Daru::DataFrame.new({b: [11,12,13,14,15].dv(:b, [:one, :two, :three, :four, :five]), 
-        a: [1,2,3,4,5].dv(:a, [:one, :two, :three, :four, :five])}, [:a, :b],
-        [:one, :two, :three, :four, :five])
+        a: [1,2,3,4,5].dv(:a, [:one, :two, :three, :four, :five])}, vectors: [:a, :b],
+        index: [:one, :two, :three, :four, :five])
 
       expect(df.index)  .to eq(Daru::Index.new [:one, :two, :three, :four, :five])
       expect(df.vectors).to eq(Daru::Index.new [:a, :b])
@@ -38,7 +40,7 @@ describe Daru::DataFrame do
 
     it "initializes from an Array of Hashes" do
       df = Daru::DataFrame.new([{a: 1, b: 11}, {a: 2, b: 12}, {a: 3, b: 13},
-        {a: 4, b: 14}, {a: 5, b: 15}], [:b, :a], [:one, :two, :three, :four, :five])
+        {a: 4, b: 14}, {a: 5, b: 15}], vectors: [:b, :a], index: [:one, :two, :three, :four, :five])
 
       expect(df.index)  .to eq(Daru::Index.new [:one, :two, :three, :four, :five])
       expect(df.vectors).to eq(Daru::Index.new [:b, :a])
@@ -50,10 +52,11 @@ describe Daru::DataFrame do
       rows = Daru::Index.new [:one, :two, :three, :four, :five]
       cols = Daru::Index.new [:a, :b]
 
-      df  = Daru::DataFrame.new({b: [11,12,13,14,15], a: [1,2,3,4,5]}, cols, rows)
+      df  = Daru::DataFrame.new({b: [11,12,13,14,15], a: [1,2,3,4,5]}, vectors: cols, 
+        index: rows)
 
-      expect(df.a)      .to eq(Daru::Vector.new(:a, [1,2,3,4,5]     , rows))
-      expect(df.b)      .to eq(Daru::Vector.new(:b, [11,12,13,14,15], rows))
+      expect(df.a)      .to eq(Daru::Vector.new([1,2,3,4,5], vectors: [:a], index: rows))
+      expect(df.b)      .to eq(Daru::Vector.new([11,12,13,14,15], name: :b, index: rows))
       expect(df.index)  .to eq(Daru::Index.new [:one, :two, :three, :four, :five])
       expect(df.vectors).to eq(Daru::Index.new [:a, :b])
     end
@@ -70,13 +73,13 @@ describe Daru::DataFrame do
           b: [11,12,13,14,15].dv(:b, [:two, :one, :four, :five, :three]), 
           a:      [1,2,3,4,5].dv(:a, [:two,:one,:three, :four, :five])
         }, 
-          [:a, :b]
+          vectors: [:a, :b]
         )
 
       expect(df).to eq(Daru::DataFrame.new({
           b: [14,13,12,15,11].dv(:b, [:five, :four, :one, :three, :two]), 
           a:      [5,4,2,3,1].dv(:a, [:five, :four, :one, :three, :two])
-        }, [:a, :b])
+        }, vectors: [:a, :b])
       )
     end
 
@@ -85,14 +88,14 @@ describe Daru::DataFrame do
                b: [11,12,13,14,15].dv(:b, [:two, :one, :four, :five, :three]), 
                a: [1,2,3]         .dv(:a, [:two,:one,:three])
              }, 
-             [:a, :b]
+             vectors: [:a, :b]
            )
 
       expect(df).to eq(Daru::DataFrame.new({
           b: [14,13,12,15,11].dv(:b, [:five, :four, :one, :three, :two]), 
           a:  [nil,nil,2,3,1].dv(:a, [:five, :four, :one, :three, :two])
         }, 
-        [:a, :b])
+        vectors: [:a, :b])
       )
     end
 
@@ -102,14 +105,14 @@ describe Daru::DataFrame do
           a: [1,2,3]             .dv(nil, [:one, :two, :three]), 
           c: [11,22,33,44,55]    .dv(nil, [:one, :two, :three, :four, :five]),
           d: [49,69,89,99,108,44].dv(nil, [:one, :two, :three, :four, :five, :six])
-        }, [:a, :b, :c, :d], [:one, :two, :three, :four, :five, :six])
+        }, vectors: [:a, :b, :c, :d], index: [:one, :two, :three, :four, :five, :six])
 
       expect(df).to eq(Daru::DataFrame.new({
           b: [11,nil,nil,nil,nil,nil].dv(nil, [:one, :two, :three, :four, :five, :six]), 
           a: [1,2,3,nil,nil,nil]     .dv(nil, [:one, :two, :three, :four, :five, :six]), 
           c: [11,22,33,44,55,nil]    .dv(nil, [:one, :two, :three, :four, :five, :six]),
           d: [49,69,89,99,108,44]    .dv(nil, [:one, :two, :three, :four, :five, :six])
-        }, [:a, :b, :c, :d], [:one, :two, :three, :four, :five, :six])
+        }, vectors: [:a, :b, :c, :d], index: [:one, :two, :three, :four, :five, :six])
       )
     end
 
@@ -118,21 +121,21 @@ describe Daru::DataFrame do
           b: [11,12,13] .dv(nil, [:one, :bleh, :blah]), 
           a: [1,2,3,4,5].dv(nil, [:one, :two, :booh, :baah, :three]), 
           c: [11,22,33,44,55].dv(nil, [0,1,3,:three, :two])
-        }, [:a, :b, :c], [:one, :two, :three])
+        }, vectors: [:a, :b, :c], index: [:one, :two, :three])
 
       expect(df).to eq(Daru::DataFrame.new({
           b: [11,nil,nil].dv(nil, [:one, :two, :three]),
           a: [1,2,5]     .dv(nil, [:one, :two, :three]),
           c: [nil,55,44] .dv(nil, [:one, :two, :three]),
         },  
-        [:a, :b, :c], [:one, :two, :three]
+        vectors: [:a, :b, :c], index: [:one, :two, :three]
         )
       )
     end
 
     it "completes incomplete vectors" do
       df = Daru::DataFrame.new({b: [11,12,13,14,15], a: [1,2,3,4,5], 
-        c: [11,22,33,44,55]}, [:a, :c])
+        c: [11,22,33,44,55]}, vectors: [:a, :c])
 
       expect(df.vectors).to eq([:a,:c,:b].to_index)
     end
@@ -140,14 +143,14 @@ describe Daru::DataFrame do
     it "raises error for incomplete DataFrame index" do
       expect {
         df = Daru::DataFrame.new({b: [11,12,13,14,15], a: [1,2,3,4,5], 
-          c: [11,22,33,44,55]}, [:a, :b, :c], [:one, :two, :three])
+          c: [11,22,33,44,55]}, vectors: [:a, :b, :c], index: [:one, :two, :three])
       }.to raise_error
     end
 
     it "raises error for unequal sized vectors/arrays" do
       expect {
         df = Daru::DataFrame.new({b: [11,12,13], a: [1,2,3,4,5], 
-          c: [11,22,33,44,55]}, [:a, :b, :c], [:one, :two, :three])
+          c: [11,22,33,44,55]}, vectors: [:a, :b, :c], index: [:one, :two, :three])
       }.to raise_error
     end
   end
@@ -155,7 +158,7 @@ describe Daru::DataFrame do
   context "#[:vector]" do
     before :each do
       @df = Daru::DataFrame.new({b: [11,12,13,14,15], a: [1,2,3,4,5], 
-        c: [11,22,33,44,55]}, [:a, :b, :c], [:one, :two, :three, :four, :five])
+        c: [11,22,33,44,55]}, vectors: [:a, :b, :c], index: [:one, :two, :three, :four, :five])
     end
 
     it "returns a Vector" do
@@ -164,7 +167,7 @@ describe Daru::DataFrame do
 
     it "returns a DataFrame" do
       temp = Daru::DataFrame.new({b: [11,12,13,14,15], a: [1,2,3,4,5]}, 
-        [:a, :b], [:one, :two, :three, :four, :five])
+        vectors: [:a, :b], index: [:one, :two, :three, :four, :five])
 
       expect(@df[:a, :b, :vector]).to eq(temp)
     end
@@ -177,7 +180,9 @@ describe Daru::DataFrame do
   context "#[:row]" do
     before :each do
       @df = Daru::DataFrame.new({b: [11,12,13,14,15], a: [1,2,3,4,5], 
-        c: [11,22,33,44,55]}, [:a, :b, :c], [:one, :two, :three, :four, :five])
+        c: [11,22,33,44,55]}, 
+        vectors: [:a, :b, :c], 
+        index: [:one, :two, :three, :four, :five])
     end
 
     it "returns a row with the given index" do
@@ -190,7 +195,7 @@ describe Daru::DataFrame do
 
     it "returns a row with given Integer index for default index-less DataFrame" do
       df = Daru::DataFrame.new({b: [11,12,13,14,15], a: [1,2,3,4,5], 
-        c: [11,22,33,44,55]}, [:a, :b, :c])
+        c: [11,22,33,44,55]}, vectors: [:a, :b, :c])
 
       expect(df[0, :row]).to eq([1,11,11].dv(nil, [:a, :b, :c]))
     end
@@ -199,7 +204,7 @@ describe Daru::DataFrame do
   context "#[:vector]=" do
     before :each do
       @df = Daru::DataFrame.new({b: [11,12,13,14,15], a: [1,2,3,4,5], 
-        c: [11,22,33,44,55]}, [:a, :b, :c], [:one, :two, :three, :four, :five])
+        c: [11,22,33,44,55]}, vectors: [:a, :b, :c], index: [:one, :two, :three, :four, :five])
     end
 
     it "appends an Array as a Daru::Vector" do
@@ -258,7 +263,7 @@ describe Daru::DataFrame do
   context "#[:row]=" do
     before :each do
       @df = Daru::DataFrame.new({b: [11,12,13,14,15], a: [1,2,3,4,5], 
-        c: [11,22,33,44,55]}, [:a, :b, :c], [:one, :two, :three, :four, :five])
+        c: [11,22,33,44,55]}, vectors: [:a, :b, :c], index: [:one, :two, :three, :four, :five])
     end
 
     it "assigns specified row when Array" do
@@ -327,7 +332,7 @@ describe Daru::DataFrame do
   context "#row" do
     before :each do
       @df = Daru::DataFrame.new({b: [11,12,13,14,15], a: [1,2,3,4,5], 
-        c: [11,22,33,44,55]}, [:a, :b, :c], [:one, :two, :three, :four, :five])
+        c: [11,22,33,44,55]}, vectors: [:a, :b, :c], index: [:one, :two, :three, :four, :five])
     end
 
     it "creates an index for assignment if not already specified" do
@@ -350,10 +355,10 @@ describe Daru::DataFrame do
   context "#==" do
     it "compares by vectors, index and values of a DataFrame (ignores name)" do
       a = Daru::DataFrame.new({b: [11,12,13,14,15], a: [1,2,3,4,5]}, 
-        [:a, :b], [:one, :two, :three, :four, :five])
+        vectors: [:a, :b], index: [:one, :two, :three, :four, :five])
 
       b = Daru::DataFrame.new({b: [11,12,13,14,15], a: [1,2,3,4,5]}, 
-        [:a, :b], [:one, :two, :three, :four, :five])
+        vectors: [:a, :b], index: [:one, :two, :three, :four, :five])
 
       expect(a).to eq(b)
     end
@@ -427,7 +432,7 @@ describe Daru::DataFrame do
   context "#map_vectors" do
     it "iterates over vectors and returns a modified DataFrame" do
       ans = Daru::DataFrame.new({b: [21,22,23,24,25], a: [11,12,13,14,15], 
-      c: [21,32,43,54,65]}, [:a, :b, :c], [:one, :two, :three, :four, :five])
+      c: [21,32,43,54,65]}, vectors: [:a, :b, :c], index: [:one, :two, :three, :four, :five])
 
       ret = @data_frame.map_vectors do |vector|
         vector = vector.map { |e| e += 10}
@@ -441,7 +446,7 @@ describe Daru::DataFrame do
   context "#map_vectors_with_index" do
     it "iterates over vectors with index and returns a modified DataFrame" do
       ans = Daru::DataFrame.new({b: [21,22,23,24,25], a: [11,12,13,14,15], 
-      c: [21,32,43,54,65]}, [:a, :b, :c], [:one, :two, :three, :four, :five])
+      c: [21,32,43,54,65]}, vectors: [:a, :b, :c], index: [:one, :two, :three, :four, :five])
 
       idx = []
       ret = @data_frame.map_vectors_with_index do |vector, index|
@@ -457,7 +462,8 @@ describe Daru::DataFrame do
   context "#map_rows" do
     it "iterates over rows and returns a modified DataFrame" do
       ans = Daru::DataFrame.new({b: [121, 144, 169, 196, 225], a: [1,4,9,16,25], 
-        c: [121, 484, 1089, 1936, 3025]}, [:a, :b, :c], [:one, :two, :three, :four, :five])
+        c: [121, 484, 1089, 1936, 3025]}, vectors: [:a, :b, :c], 
+        index: [:one, :two, :three, :four, :five])
 
       ret = @data_frame.map_rows do |row|
         expect(row.class).to eq(Daru::Vector)
@@ -471,7 +477,7 @@ describe Daru::DataFrame do
   context "#map_rows_with_index" do
     it "iterates over rows with index and returns a modified DataFrame" do
       ans = Daru::DataFrame.new({b: [121, 144, 169, 196, 225], a: [1,4,9,16,25], 
-        c: [121, 484, 1089, 1936, 3025]}, [:a, :b, :c], [:one, :two, :three, :four, :five])
+        c: [121, 484, 1089, 1936, 3025]},vectors: [:a, :b, :c], index: [:one, :two, :three, :four, :five])
 
       idx = []
       ret = @data_frame.map_rows_with_index do |row, index|
@@ -490,7 +496,8 @@ describe Daru::DataFrame do
       @data_frame.delete_vector :a
 
       expect(@data_frame).to eq(Daru::DataFrame.new({b: [11,12,13,14,15], 
-              c: [11,22,33,44,55]}, [:b, :c], [:one, :two, :three, :four, :five]))    
+              c: [11,22,33,44,55]}, vectors: [:b, :c], 
+              index: [:one, :two, :three, :four, :five]))    
     end
   end
 
@@ -499,21 +506,19 @@ describe Daru::DataFrame do
       @data_frame.delete_row :one
 
       expect(@data_frame).to eq(Daru::DataFrame.new({b: [12,13,14,15], a: [2,3,4,5], 
-      c: [22,33,44,55]}, [:a, :b, :c], [:two, :three, :four, :five]))
+      c: [22,33,44,55]}, vectors: [:a, :b, :c], index: [:two, :three, :four, :five]))
     end
   end
 
-  context "#keep_row_if" do
+  context "#keep_row_if", :focus => true do
     it "keeps row if block evaluates to true" do
       df = Daru::DataFrame.new({b: [10,12,20,23,30], a: [50,30,30,1,5], 
-        c: [10,20,30,40,50]}, [:a, :b, :c], [:one, :two, :three, :four, :five])
+        c: [10,20,30,40,50]}, vectors: [:a, :b, :c], index: [:one, :two, :three, :four, :five])
 
       df.keep_row_if do |row|
-        row.all? {|a| a % 5 == 0 }
+        row[:a] % 10 == 0
       end
-
-      expect(df).to eq(Daru::DataFrame.new({b: [10,20,30], a: [50, 30, 5],
-        c: [10,30,50]}, [:a, :b, :c], [:one, :three, :five]))
+      # TODO: write expectation
     end
   end
 
@@ -523,8 +528,32 @@ describe Daru::DataFrame do
         vector == [1,2,3,4,5].dv(nil, [:one, :two, :three, :four, :five])
       end
 
-      expect(@data_frame).to eq(Daru::DataFrame.new({a: [1,2,3,4,5]}, [:a], 
-        [:one, :two, :three, :four, :five]))
+      expect(@data_frame).to eq(Daru::DataFrame.new({a: [1,2,3,4,5]}, vectors: [:a], 
+        index: [:one, :two, :three, :four, :five]))
+    end
+  end
+
+  context "#filter_rows" do
+    it "filters rows" do
+      df = Daru::DataFrame.new({a: [1,2,3], b: [2,3,4]})
+
+      a = df.filter_rows do |row|
+        row[:a] % 2 == 0
+      end
+
+      expect(a).to eq(Daru::DataFrame.new({a: [2], b: [3]}, vectors: [:a, :b], index: [1]))
+    end
+  end
+
+  context "#filter_vectors" do
+    it "filters vectors" do
+      df = Daru::DataFrame.new({a: [1,2,3], b: [2,3,4]})
+
+      a = df.filter_vectors do |vector|
+        vector[0] == 1
+      end
+
+      expect(a).to eq(Daru::DataFrame.new({a: [1,2,3]}))
     end
   end