daru 0.0.4 → 0.0.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: dc60c1a59b4c112dface4bdd6d0a40cf1bcc499c
-  data.tar.gz: aec8fd874e2e74ded4eeb2cebe8503b5a3cbefbc
+  metadata.gz: fd2dec0795f15ca1e45bdad5238fb7dbe33e1089
+  data.tar.gz: 634ff6e6b533cad019893a6e248706c824933e1d
 SHA512:
-  metadata.gz: 091f1ce3e0da8b9083dc6f53a9977550def5d10a4f759797ec56cb6b90788aa8d6a7fb8ad1a0e4105c640b5987e0b200877a12441cc8cd6b2614f26141554d9e
-  data.tar.gz: d189373c2196a3ddc10856f4800fee908d9361f83921e68078c971402a3996b02d82c13bb275a26d070518e90626d4e654556d970d91b69179f2899065b31685
+  metadata.gz: 2c4aed326afacb2fe2324dd720e302564ab973b7fe69e17daf8f4902fecf7a2bbe34a26b0681dc42eaef14bd511a439a2717a115a7f577f700212d0d605d6dee
+  data.tar.gz: be1bc452b188d233a6c668a008ed9f9e4cd77cf9b24a574559bf27c8c28ab34b0c23d51cc4321ab49c1416a53b0b74571afca698cdf2106d407f744204191362

data/Gemfile

@@ -1,4 +1,3 @@
 source 'https://rubygems.org'
 
-# Specify your gem's dependencies in daru.gemspec
 gemspec

data/History.txt

@@ -41,3 +41,38 @@
 * #uniq for Vector.
 * #max for Vector can return a Vector object with the index set to the index of the max value.
 * Tonnes of documentation for most methods.
+
+== 0.0.5
+
+* Easy accessors for some methods
+* Faster CSV loading.
+* Changed vector #is\_valid? to #exists?
+* Revamped dtype specifiers for Vector. Now specify :array/:nmatrix for changing underlying data implementation. Specigfy nm\_dtype for specifying the data type of the NMatrix object.
+* #sort for Vector. Quick sort algorithm with preservation of original indexes.
+* Removed #re\_index and #to\_index from Daru::Index.
+* Ability to change the index of Vector and DataFrame with #reindex/#reindex!.
+* Multi-level #sort! and #sort for DataFrames. Preserves indexing.
+* All vector statistics now work with NMatrix as the underlying data type.
+* Vectors keep a record of all positions with nils with #nil\_positions.
+* Know whether a position has nils or not with #is_nil?
+* Added #clone_structure to Vector for cloning only the index and structure or a vector.
+* Figure out the type of data using #type. Running thru the data to determine its type is delayed till the last possible moment.
+* Added arithmetic operations between data frame and scalars or other data frames.
+* Added #map_vectors!.
+* Create a DataFrame from Array of Arrays and Array of Vectors.
+* Refactored DataFrame.rows and the  DataFrame constructor.
+* Added hierarchial indexing to Vector and DataFrame with MultiIndex.
+* Convert DataFrame to ruby Matrix or NMatrix with #to\_matrix and #to\_nmatrix.
+* Added #group_by to DataFrame for grouping rows according to elements in a given column. Works similar to SQL GROUP BY, only much simpler.
+* Added new class Daru::Core::GroupBy for supporting various grouping methods like #head, #tail, #get_group, #size, #count, #mean, #std, #min, #max.
+* Tranpose indexed/multi-indexed DataFrame with #transpose.
+* Convert Daru::Vector to horizontal or vertical Ruby Matrix with #to_matrix.
+* Added shortcut to DataFrame to allow access of vectors by using only #[] instead of calling #vector or *[vector_names, :vector]*.
+* Added DSL for Vector and DataFrame plotting with nyaplot. Can now grab the underlying Nyaplot::Plot and Nyaplot::Diagram object for performing different operations. Only need to supply parameters for the initial creation of the diagram.
+* Added #pivot_table to DataFrame for reducing and aggregating data to generate a quick summary.
+* Added #shape to DataFrame for knowing the numbers of rows and columns in a DataFrame.
+* Added statistics methods #mean, #std, #max, #min, #count, #product, #sum to DataFrame.
+* Added #describe to DataFrame for producing multiple statistics data of numerical vectors in one shot.
+* Monkey patched Ruby Matrix to include #elementwise_division.
+* Added #covariance to calculate the covariance between numbers of a DataFrame and #correlation to calculate correlation. 
+* Enumerators return Enumerator objects if there is no block.

data/README.md

@@ -7,30 +7,35 @@ Data Analysis in RUby
 
 ## Introduction
 
-daru (Data Analysis in RUby) is a library for storage, analysis and manipulation of data.
-
-Development of daru was started to address the fragmentation of Dataframe-like classes which were created in many ruby gems as per their own needs. daru offers a uniform interface for all sorts of data analysis and manipulation operations and aims to be compatible with all ruby gems involved in any way with data.
+daru (Data Analysis in RUby) is a library for storage, analysis, manipulation and visualization of data.
 
 daru is inspired by `Statsample::Dataset` and pandas, a very mature solution in Python.
 
-daru works with CRuby (1.9.3+) and JRuby.
+Written in pure Ruby so should work with all ruby implementations.
 
 ## Features
 
 * Data structures:
     - Vector - A basic 1-D vector.
-    - DataFrame - A 2-D matrix-like structure which is internally composed of named `Vector` classes.
-* Compatible with IRuby notebook.
-* Indexed and named data structures.
+    - DataFrame - A 2-D table-like structure which is internally composed of named `Vectors`.
+* Compatible with [IRuby notebook](https://github.com/minad/iruby) and [statsample](https://github.com/clbustos/statsample).
+* Singly and hierarchially indexed data structures.
 * Flexible and intuitive API for manipulation and analysis of data.
+* Easy plotting, statistics and arithmetic.
+* Plentiful iterators.
+* Optional speed and space optimization on MRI with [NMatrix](https://github.com/SciRuby/nmatrix).
+* Easy splitting, aggregation and grouping of data.
+* Quickly reducing data with pivot tables for quick data summary.
 
 ## Notebooks
 
-* [Analysis and plotting of a data set comprising of music listening habits of a last.fm user(iruby notebook)](http://nbviewer.ipython.org/github/v0dro/daru/blob/master/notebooks/intro_with_music_data_.ipynb)
+* [Analysis and plotting of a data set comprising of music listening habits of a last.fm user](http://nbviewer.ipython.org/github/v0dro/daru/blob/master/notebooks/intro_with_music_data_.ipynb)
+* [Basic splitting, grouping and aggregating of data](http://nbviewer.ipython.org/github/v0dro/daru/blob/master/notebooks/grouping_splitting_pivots.ipynb)
 
 ## Blog Posts
 
 * [Data Analysis in RUby: Basic data manipulation and plotting](http://v0dro.github.io/blog/2014/11/25/data-analysis-in-ruby-basic-data-manipulation-and-plotting/)
+* [Data Analysis in RUby: Splitting, sorting, aggregating data and data types](http://v0dro.github.io/blog/2015/02/24/data-analysis-in-ruby-part-2/)
 
 ## Documentation
 
@@ -38,34 +43,23 @@ Docs can be found [here](https://rubygems.org/gems/daru).
 
 ## Basic Usage
 
-daru has been created with keeping extreme ease of use in mind.
-
-The gem consists of two data structures, Vector and DataFrame. Any data in a serial format is a Vector and a table is a DataFrame.
-
 #### Initialization of DataFrame
 
-A data frame can be initialized from the following sources:
-* Hash of indexed order: `{ b: Daru::Vector.new(:b, [11,12,13,14,15], [:two, :one, :four, :five, :three]), a: Daru::Vector.new(:a, [1,2,3,4,5], [:two,:one,:three, :four, :five])}`.
-* Array of hashes: `[{a: 1, b: 11}, {a: 2, b: 12}, {a: 3, b: 13},{a: 4, b: 14}, {a: 5, b: 15}]`.
-* Hash of names and Arrays: `{b: [11,12,13,14,15], a: [1,2,3,4,5]}`
-
-The DataFrame constructor takes 4 arguments: source, vectors, indexes and name in that order. The last 3 are optional while the first is mandatory.
-
 A basic DataFrame can be initialized like this:
 
 ```ruby
 
-    df = Daru::DataFrame.new({b: [11,12,13,14,15], a: [1,2,3,4,5]}, order: [:a, :b], index: [:one, :two, :three, :four, :five])
-    df
-    # => 
-    # # <Daru::DataFrame:87274040 @name = 7308c587-4073-4e7d-b3ca-3679d1dcc946 # @size = 5>
-    #           a     b 
-    #   one     1    11 
-    #   two     2    12 
-    # three     3    13 
-    #  four     4    14 
-    #  five     5    15 
+df = Daru::DataFrame.new({b: [11,12,13,14,15], a: [1,2,3,4,5]}, order: [:a, :b], index: [:one, :two, :three, :four, :five])
+df
 
+# => 
+# # <Daru::DataFrame:87274040 @name = 7308c587-4073-4e7d-b3ca-3679d1dcc946 # @size = 5>
+#           a     b 
+#   one     1    11 
+#   two     2    12 
+# three     3    13 
+#  four     4    14 
+#  five     5    15
 ```
 Daru will automatically align the vectors correctly according to the specified index and then create the DataFrame. Thus, elements having the same index will show up in the same row. The indexes will be arranged alphabetically if vectors with unaligned indexes are supplied.
 
@@ -73,69 +67,63 @@ The vectors of the DataFrame will be arranged according to the array specified i
 
 ```ruby
 
-    df = Daru::DataFrame.new({
-        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])
-      }, 
-        order: [:a, :b]
-      )
-    df
-
-    # => 
-    # #<Daru::DataFrame:87363700 @name = 75ba0a14-8291-48ac-ac30-35017e4d6c5f # @size = 5>
-    #           a     b 
-    #  five     5    14 
-    #  four     4    13 
-    #   one     2    12 
-    # three     3    15 
-    #   two     1    11
+df = Daru::DataFrame.new({
+    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])
+  }, order: [:a, :b]
+)
+df
 
+# => 
+# #<Daru::DataFrame:87363700 @name = 75ba0a14-8291-48ac-ac30-35017e4d6c5f # @size = 5>
+#           a     b 
+#  five     5    14 
+#  four     4    13 
+#   one     2    12 
+# three     3    15 
+#   two     1    11
 ```
 
 If an index for the DataFrame is supplied (third argument), then the indexes of the individual vectors will be matched to the DataFrame index. If any of the indexes do not match, nils will be inserted instead:
 
 ```ruby
 
-    df = Daru::DataFrame.new({
-        b: [11]                .dv(nil, [:one]), 
-        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])
-      }, order: [:a, :b, :c, :d], index: [:one, :two, :three, :four, :five, :six])
-    df
-    # => 
-    # #<Daru::DataFrame:87523270 @name = bda4eb68-afdd-4404-9981-708edab14201  #@size = 6>
-    #           a     b     c     d 
-    #   one     1    11    11    49 
-    #   two     2   nil    22    69 
-    # three     3   nil    33    89 
-    #  four   nil   nil    44    99 
-    #  five   nil   nil    55   108 
-    #   six   nil   nil   nil    44 
-
+df = Daru::DataFrame.new({
+    b: [11]                .dv(nil, [:one]), 
+    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])
+  }, order: [:a, :b, :c, :d], index: [:one, :two, :three, :four, :five, :six])
+df
+# => 
+# #<Daru::DataFrame:87523270 @name = bda4eb68-afdd-4404-9981-708edab14201  #@size = 6>
+#           a     b     c     d 
+#   one     1    11    11    49 
+#   two     2   nil    22    69 
+# three     3   nil    33    89 
+#  four   nil   nil    44    99 
+#  five   nil   nil    55   108 
+#   six   nil   nil   nil    44 
 ```
 
 If some of the supplied vectors do not contain certain indexes that are contained in other vectors, they are added to those vectors and the correspoding elements are set to `nil`.
 
 ```ruby
 
-    df = Daru::DataFrame.new({
-             b: [11,12,13,14,15].dv(:b, [:two, :one, :four, :five, :three]), 
-             a: [1,2,3]         .dv(:a, [:two,:one,:three])
-           }, 
-           order: [:a, :b]
-         )
-    df
-
-    #  => 
-    # #<Daru::DataFrame:87612510 @name = 1e904c15-e095-4dce-bfdf-c07ee4d6e4a4 # @size = 5>
-    #           a     b 
-    #  five   nil    14 
-    #  four   nil    13 
-    #   one     2    12 
-    # three     3    15 
-    #   two     1    11 
-
+df = Daru::DataFrame.new({
+  b: [11,12,13,14,15].dv(:b, [:two, :one, :four, :five, :three]), 
+  a: [1,2,3]         .dv(:a, [:two,:one,:three])
+}, order: [:a, :b])
+df
+
+#  => 
+# #<Daru::DataFrame:87612510 @name = 1e904c15-e095-4dce-bfdf-c07ee4d6e4a4 # @size = 5>
+#           a     b 
+#  five   nil    14 
+#  four   nil    13 
+#   one     2    12 
+# three     3    15 
+#   two     1    11 
 ```
 
 #### Initialization of Vector
@@ -146,36 +134,32 @@ In the simplest case it can be constructed like this:
 
 ```ruby
 
-    dv = Daru::Vector.new [1,2,3,4,5], name: ravan, index: [:ek, :don, :teen, :char, :pach]
-    dv
-
-    #  => 
-    # #<Daru::Vector:87630270 @name = ravan @size = 5 >
-    #     ravan
-    #   ek    1
-    #  don    2
-    # teen    3
-    # char    4
-    # pach    5 
-
+dv = Daru::Vector.new [1,2,3,4,5], name: ravan, index: [:ek, :don, :teen, :char, :pach]
+dv
+#  => 
+# #<Daru::Vector:87630270 @name = ravan @size = 5 >
+#     ravan
+#   ek    1
+#  don    2
+# teen    3
+# char    4
+# pach    5 
 ```
 
 Initializing a vector with indexes will insert nils in places where elements dont exist:
 
 ```ruby
 
-    dv = Daru::Vector.new [1,2,3], name: yoga, index: [0,1,2,3,4]
-    dv
-    #  => 
-    # #<Daru::Vector:87890840 @name = yoga @size = 5 >
-    #   y
-    # 0 1
-    # 1 2
-    # 2 3
-    # 3 nil 
-    # 4 nil 
-
-
+dv = Daru::Vector.new [1,2,3], name: yoga, index: [0,1,2,3,4]
+dv
+#  => 
+# #<Daru::Vector:87890840 @name = yoga @size = 5 >
+#   y
+# 0 1
+# 1 2
+# 2 3
+# 3 nil 
+# 4 nil
 ```
 
 #### Basic Selection Operations
@@ -184,34 +168,32 @@ Initialize a dataframe:
 
 ```ruby
 
-    df = Daru::DataFrame.new({
-        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])
-      }, 
-        order: [:a, :b]
-      )
-
-    #  => 
-    # #<Daru::DataFrame:87455010 @name = b3d14e23-98c2-4741-a563-92e8f1fd0f13 # @size = 5>
-    #           a     b 
-    #  five     5    14 
-    #  four     4    13 
-    #   one     2    12 
-    # three     3    15 
-    #   two     1    11 
+df = Daru::DataFrame.new({
+  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])
+}, order: [:a, :b])
+
+#  => 
+# #<Daru::DataFrame:87455010 @name = b3d14e23-98c2-4741-a563-92e8f1fd0f13 # @size = 5>
+#           a     b 
+#  five     5    14 
+#  four     4    13 
+#   one     2    12 
+# three     3    15 
+#   two     1    11 
 
 ```
 Select a row from a DataFrame:
 
 ```ruby
     
-    df.row[:one]
+df.row[:one]
 
-    #  => 
-    # #<Daru::Vector:87432070 @name = one @size = 2 >
-    #    one
-    #  a  2
-    #  b 12 
+#  => 
+# #<Daru::Vector:87432070 @name = one @size = 2 >
+#    one
+#  a  2
+#  b 12 
 ```
 A row or a vector is returned as a `Daru::Vector` object, so any manipulations supported by `Daru::Vector` can be performed on the chosen row as well.
 
@@ -233,101 +215,92 @@ Select a single vector:
 
 ```ruby
     
-    df.vector[:a] # or simply df.a
-
-    #  => 
-    # #<Daru::Vector:87454270 @name = a @size = 5 >
-    #           a
-    #  five     5
-    #  four     4
-    #   one     2
-    # three     3
-    #   two     1
-
+df.vector[:a] # or simply df.a
+
+#  => 
+# #<Daru::Vector:87454270 @name = a @size = 5 >
+#           a
+#  five     5
+#  four     4
+#   one     2
+# three     3
+#   two     1
 ```
 
 Select multiple vectors and return a DataFrame in the specified order:
 
 ```ruby
 
-    df.vector[:b, :a]
-    #  =>
-    # #<Daru::DataFrame:87835960 @name = e80902cc-cff9-4b23-9eca-5da36ebc88a8 #   @size = 5>
-    #           b     a 
-    #  five    14     5 
-    #  four    13     4 
-    #   one    12     2 
-    # three    15     3 
-    #   two    11     1 
-
+df.vector[:b, :a]
+#  =>
+# #<Daru::DataFrame:87835960 @name = e80902cc-cff9-4b23-9eca-5da36ebc88a8 #   @size = 5>
+#           b     a 
+#  five    14     5 
+#  four    13     4 
+#   one    12     2 
+# three    15     3 
+#   two    11     1 
 ```
 
 Keep/remove row according to a specified condition:
 
 ```ruby
 
-    df = df.filter_rows do |row|
-        row[:a] == 5
-    end
-
-    df
-    #  => 
-    # #<Daru::DataFrame:87455010 @name = b3d14e23-98c2-4741-a563-92e8f1fd0f13 # @size = 1>
-    #         a    b 
-    # five    5   14 
-
+df = df.filter_rows do |row|
+  row[:a] == 5
+end
+df
+#  => 
+# #<Daru::DataFrame:87455010 @name = b3d14e23-98c2-4741-a563-92e8f1fd0f13 # @size = 1>
+#         a    b 
+# five    5   14 
 ```
 The same can be applied to vectors using `filter_vectors`.
 
-To iterate over a DataFrame and perform operations on rows or vectors, use `#each_row` or `#each_vector`.
-
 To change the values of a row/vector while iterating through the DataFrame, use `map_rows` or `map_vectors`:
 
 ```ruby
 
-    df.map_rows do |row|
-        row = row * row
-    end
-
-    df
-
-    #  => 
-    # #<Daru::DataFrame:86826830 @name = b092ca5b-7b83-4dbe-a469-124f7f25a568 # @size = 5>
-    #           a     b 
-    #  five    25   196 
-    #  four    16   169 
-    #   one     4   144 
-    # three     9   225 
-    #   two     1   121 
-
+df.map_rows do |row|
+  row = row * row
+end
+
+df
+#  => 
+# #<Daru::DataFrame:86826830 @name = b092ca5b-7b83-4dbe-a469-124f7f25a568 # @size = 5>
+#           a     b 
+#  five    25   196 
+#  four    16   169 
+#   one     4   144 
+# three     9   225 
+#   two     1   121 
 ```
 
-Rows/vectors can be deleted using `delete_row` or `delete_vector`.
-
 #### Basic Maths Operations
 
 Performing a binary arithmetic operation on two `Daru::Vector` objects will return a `Vector` object in which the operation will be performed on elements of the same index.
 
 ```ruby
 
-    dv1 = Daru::Vector.new [1,2,3,4], name: :boozy, index: [:a, :b, :c, :d]
-
-    dv2 = Daru::Vector.new [1,2,3,4], name: :mayer, index: [:e, :f, :b, :d]
+dv1 = Daru::Vector.new [1,2,3,4], name: :boozy, index: [:a, :b, :c, :d]
+dv2 = Daru::Vector.new [1,2,3,4], name: :mayer, index: [:e, :f, :b, :d]
+dv1 * dv2
 
-    dv1 * dv2
-
-    # #<Daru::Vector:80924700 @name = boozy @size = 2 >
-    #         boozy
-    #      b      6
-    #      d     16
- 
+# #<Daru::Vector:80924700 @name = boozy @size = 2 >
+#         boozy
+#      b      6
+#      d     16
 ```
 
 Arithmetic operators applied on a single Numeric will perform the operation with that number against the entire vector.
 
-#### Statistics Operations
+Same applies to DataFrame as well.
+
+#### Splitting and aggregation of data
 
-Daru::Vector has a whole lot of statistics operations to maintain compatibility with Statsample::Vector. Check the docs for details.
+`Daru::DataFrame` provides the `#group_by` method to split or aggregate data. Its very similar to SQL GROUP BY. Check the [blog post]() for details.
+
+You can also generate Excel-style pivot tables with `#pivot_table`.
 
 #### Plotting
 
@@ -335,35 +308,42 @@ daru uses [Nyaplot](https://github.com/domitry/nyaplot) for plotting and an exam
 
 Head over to the tutorials and notebooks listed above for more examples.
 
+#### Working with missing data
+
+Missing data is an integral part of any data analysis operation and [this blog post](http://v0dro.github.io/blog/2015/02/24/data-analysis-in-ruby-part-2/) provides details on dealing with missing data.
+
 ## Roadmap
 
 * Automate testing for both MRI and JRuby.
 * Enable creation of DataFrame by only specifying an NMatrix/MDArray in initialize. Vector naming happens automatically (alphabetic) or is specified in an Array.
 * Destructive map iterators for DataFrame.
-* Completely test all functionality for NMatrix and MDArray.
+* Completely test all functionality for MDArray.
 * Basic Data manipulation and analysis operations: 
     - Different kinds of join operations
-    - Dataframe/vector merge
-    - Creation of correlation, covariance matrices
+    - Dataframe/vector merge (left, right, inner, outer)
     - Verification of data in a vector
-* Transpose a dataframe.
+    - DF concat
 * Option to express a DataFrame as an NMatrix or MDArray so as to use more efficient storage techniques.
 * Assignment of a column to a single number should set the entire column to that number.
 * == between daru_vector and string/number.
 * Multiple column assignment with []=
-* Creation of DataFrame from Array of Arrays.
 * Multiple value assignment for vectors with []=.
 * Load DataFrame from multiple sources (excel, SQL, etc.).
 * Deletion of elements from Vector should only modify the index and leave the vector as it is so that compacting is not needed and things are faster.
-* Add a #sync method which will sync the modified index with the unmodified vector.
-* Ability to reorder the index of a dataframe.
-* head/tail for DV.
 * #find\_max function which will evaluate a block and return the row for the value of the block is max.
 * Function to check if a value of a row/vector is within a specified range.
 * Create a new vector in map_rows if any of the already present rows dont match the one assigned in the block.
-* Direct functions to answer something like 'number of something per thousand of something else'.
-* Tests for checking NMatrix resizing
-* Sort while preserving index.
+* Sort by index.
+* Statistics on DataFrame over rows and columns.
+* Cumulative sum.
+* Time series support.
+* Calculate percentage change.
+* Working with missing data - drop\_missing\_data, dropping rows with missing data.
+* Have some sample data sets for users to play around with. Should be able to load these from the code itself.
+* Sorting with missing data present.
+* Make vectors aware of the data frame that they are a part of.
+* re_index should re establish previous index values in the newly supplied index.
+* Reset index.
 
 ## Contributing
 
@@ -373,5 +353,5 @@ Pick a feature from the Roadmap above or think of your own and send me a Pull Re
 
 * Thank you [last.fm](http://www.last.fm/) for making user data accessible to the public.
 
-Copyright (c) 2014, Sameer Deshmukh
+Copyright (c) 2015, Sameer Deshmukh
 All rights reserved