ruby-band 0.1.11

data/lib/ruby-band/apache/stat/inference.rb

@@ -0,0 +1,151 @@
+require 'java'
+
+module Apache
+  module Stat
+    module Inference
+
+      java_import 'org.apache.commons.math3.stat.inference.ChiSquareTest'
+      java_import 'org.apache.commons.math3.stat.inference.MannWhitneyUTest'
+      java_import 'org.apache.commons.math3.stat.inference.OneWayAnova'
+      java_import 'org.apache.commons.math3.stat.inference.TTest'
+      java_import 'org.apache.commons.math3.stat.inference.WilcoxonSignedRankTest'
+      java_import 'org.apache.commons.math3.stat.StatUtils'
+      java_import 'java.util.ArrayList'
+      
+      # An implementation of the Wilcoxon signed-rank test
+      # * *Args*    :
+      #   - +Array1+ -> must be a RubyArray.
+      #   - +Array2+ -> must be a RubyArray.
+      def self.wilcoxon_test(array_1,array_2)
+        obj = WilcoxonSignedRankTest.new
+        first = Core::Utils::double_to_a(array_1)
+        second = Core::Utils::double_to_a(array_2)
+        val = obj.wilcoxonSignedRank first, second
+        p_val = obj.wilcoxonSignedRankTest first, second, true.to_java(:boolean) 
+        return val,p_val
+      end
+
+      # Utility class called by 'chi_square' method in this same package
+      class Chi_square
+        def self.chi_square_2d(array_2d)
+          obj = ChiSquareTest.new
+          val = obj.chi_square(array_2d.to_java(Java::long[]))
+          p_value =  obj.chi_square_test(array_2d.to_java(Java::long[]))
+          return val,p_value
+        end
+        
+        def self.chi_square_two_arrays(expected,observed)
+          obj = ChiSquareTest.new
+          val = obj.chi_square(expected.to_java(:double),observed.to_java(:long))
+          p_value = obj.chi_square_test(expected.to_java(:double),observed.to_java(:long))
+          return val,p_value
+        end
+      end
+
+      # 1) Computes the Chi-Square statistic comparing observed and expected frequency counts.
+      # * *Args*    :
+      #   - +Array+ -> must be a bidimensional RubyArray.
+      # 2) Computes the Chi-Square statistic associated with a chi-square test of independence
+      #   based on the input counts array, viewed as a two-way table.
+      # * *Args*    :
+      #   - +Array1+ -> must be a RubyArray.
+      #   - +Array2+ -> must be a RubyArray.
+      def self.chi_square(*args)
+        if args.length == 2
+          Chi_square.chi_square_two_arrays(*args)
+        elsif args.length == 1
+          raise ArgumentError,"RubyArray must be bidimensional" unless args[0].is_2d?
+          Chi_square.chi_square_2d(*args)
+        else
+          raise ArgumentError, 'Function *args should be two RubyArrays or a bidimensional RubyArray'
+        end
+      end    
+
+      # Compare two datasets stored in Ruby Arrays
+      def self.chi_square_dataset_compare(observed1,observed2)
+        obj = ChiSquareTest.new
+        val = obj.chiSquareDataSetsComparison(observed1.to_java(:long),observed2.to_java(:long)) 
+        p_value = obj.chiSquareTestDataSetsComparison(observed1.to_java(:long),observed2.to_java(:long))
+        return val,p_value          
+      end
+
+      # An implementation of the Mann-Whitney U test 
+      # (also called Wilcoxon rank-sum test)
+      # * *Args*    :
+      #   - +Array1+ -> must be a RubyArray.
+      #   - +Array2+ -> must be a RubyArray.
+      def self.mann_whitney_u(array1,array2)
+        obj = MannWhitneyUTest.new
+        first = array1.to_java :double
+        second = array2.to_java :double 
+        value = obj.mannWhitneyU first,second
+        p_value = obj.mannWhitneyUTest first,second
+        return value,p_value
+      end
+
+      #Utility class called by 't_test' method in this same package
+      class T_test
+  
+        def self.homoscedastic(array_1,array_2)
+          obj = TTest.new
+          first = array_1.to_java :double
+          second = array_2.to_java :double
+          value = obj.homoscedasticT(first,second)
+          p_value = obj.homoscedasticTTest(first,second)
+          return value, p_value
+        end
+  
+        def self.paired(array_1,array_2)
+          obj = TTest.new
+          first = array_1.to_java :double
+          second =array_2.to_java :double
+          value = obj.pairedT(first,second)
+          p_value = obj.pairedTTest(first,second)
+          return value,p_value
+        end
+
+        def self.t(array_1,array_2)
+          obj = TTest.new
+          first = array_1.to_java :double
+          second =array_2.to_java :double
+          value = obj.t(first,second)
+          p_value =obj.tTest(first,second)
+          return value,p_value
+        end
+      end
+
+      # An implementation for Student's t-tests
+      # * *Args*    :
+      #   - +sample_1+ -> an array of numeric values representing a sample
+      #   - +sample_2+ -> an array of numeric values representing a sample
+      #   - +homoscedastic+ -> set to true for equal variance assumption
+      #   - +paired+ -> set to true if you want to perform a 'paired' t test
+      def self.t_test(sample_1,sample_2,homoscedastic=false,paired=false)
+        if homoscedastic == true
+          T_test.homoscedastic(sample_1,sample_2)
+        elsif paired == true
+          T_test.paired(sample_1,sample_2)
+        else
+          T_test.t(sample_1,sample_2)
+        end 
+      end
+
+      # Implements one-way ANOVA (analysis of variance) statistics.
+      # Tests for differences between two or more categories of univariate data (for example,
+      # the body mass index of accountants, lawyers, doctors and computer programmers). When 
+      # two categories are given, this is equivalent to the TTest.
+      # * *Args*    :
+      #   - +bidimensional_array+ -> a 2d RubyArray
+      def self.one_way_anova(bidimensional_array)
+        collection = ArrayList.new 
+        bidimensional_array.each do |array|
+          collection.add(array.to_java :double)
+        end
+        obj = OneWayAnova.new
+        f_value = obj.anovaFValue(collection)
+        p_value = obj.anovaPValue(collection)
+        return f_value,p_value
+      end
+    end
+  end
+end

data/lib/ruby-band/apache/stat/regression.rb

@@ -0,0 +1,22 @@
+require 'java'
+
+module Apache
+  module Stat
+    module Regression
+      java_import "org.apache.commons.math3.stat.regression.SimpleRegression"
+
+      # Create a simple regression model on the input data 
+      # * *Args*    :
+      #   - +vector+ -> must be a multidimensional array
+      def self.simple_regression(vector)
+        data = Core::Utils.bidimensional_to_double vector
+        obj = SimpleRegression.new
+        obj.addData(data)
+        return obj
+        # add Jruby methods for regression analysis
+      end
+
+
+    end
+  end
+end

data/lib/ruby-band/core.rb

@@ -0,0 +1,6 @@
+require 'ruby-band/core/type/instances'
+require 'ruby-band/core/type/instance'
+require 'ruby-band/core/parser/parser'
+require 'ruby-band/core/type/utils'
+require 'ruby-band/core/type/attribute'
+require 'ruby-band/core/type/apache_matrices'

data/lib/ruby-band/core/parser/parser.rb

@@ -0,0 +1,27 @@
+require 'java'
+java_import 'weka.core.converters.CSVLoader'
+java_import 'weka.core.converters.ArffLoader'
+
+module Core
+  module Parser
+    # Parse an ARFF file and create an Instances object
+    def Parser.parse_ARFF(arff_file)
+      java_import 'java.io.File'
+      loader = ArffLoader.new
+      file = File.new arff_file 
+      loader.setSource(file)
+      data_instance = loader.getDataSet
+      return data_instance
+    end
+
+    # Parse an CSV file and create an Instances object
+    def Parser.parse_CSV(csv_file) 
+      java_import 'java.io.File'
+      loader = CSVLoader.new
+      file = File.new csv_file 
+      loader.setSource(file)
+      data_instance = loader.getDataSet
+      return data_instance
+    end
+  end
+end

data/lib/ruby-band/core/type/apache_matrices.rb

@@ -0,0 +1,35 @@
+require 'java'
+
+module Core
+  module Type
+
+  	java_import 'org.apache.commons.math3.linear.BlockRealMatrix'
+  	java_import 'org.apache.commons.math3.linear.Array2DRowRealMatrix'
+
+  	#Define variables to use ruby-like names instead of Java's
+  	Apache_matrix = Array2DRowRealMatrix
+  	Apache_matrix_block = BlockRealMatrix
+
+  	#* *Description*    :  	
+		#Linear algebra support in commons-math provides operations on real matrices (both dense 
+		#and sparse matrices are supported) and vectors. It features basic operations (addition, subtraction ...) 
+		#and decomposition algorithms that can be used to solve linear systems either in exact sense and 
+		#in least squares sense.
+		#The 'Apache_matrix' class represents a matrix with real numbers as entries. 
+		#The following basic matrix operations are supported:
+		#- Matrix addition, subtraction, multiplication
+ 		#- Scalar addition and multiplication
+ 		#- Transpose
+ 		#- Norm and trace
+ 		#- Operation on a vector
+		class Apache_matrix 
+
+		end
+
+		# Apache matrix implementation suited to dimensions above 50 or 100
+		class Apache_matrix_block
+
+		end
+
+	end
+end

data/lib/ruby-band/core/type/attribute.rb

@@ -0,0 +1,53 @@
+require 'java'
+
+module Core
+  module Type
+    
+    java_import "weka.core.Attribute"
+    java_import "weka.core.FastVector"
+
+    class Attribute
+
+    end
+
+    # Return an Numeric Attribute class object
+    # * *Args*    :
+    #   - +name_of_attr+ -> a String, the name of the attribute 
+    def self.create_numeric_attr(name_of_attr)
+    	numeric = Attribute.new name_of_attr
+    	return numeric
+    end
+
+    # Return an Date Attribute class object
+    # * *Args*    :
+    #   - +name_of_attr+ -> a String, the name of the attribute 
+    #   - +format+ -> The format of the attribute 
+    def self.create_date_attr(name_of_attr,format)
+    	date = Attribute.new(name_of_attr,format)
+    	return date
+    end
+
+    # Return a Nominal Attribute class object
+    # * *Args*    :
+    #   - +name_of_attr+ -> a String, the name of the attribute 
+    #   - +values_list+ -> An array, the list of nominal values
+    def self.create_nominal_attr(name_of_attr,values_list)
+    	labels = FastVector.new
+    	values_list.each {|value| labels.addElement(value)}
+    	nominal = Attribute.new(name_of_attr,labels)  
+    	return nominal
+    end
+
+    # Return a String Attribute class object
+    # * *Args*    :
+    #   - +name_of_attr+ -> a String, the name of the attribute 
+    def self.create_string_attr(name_of_attr)
+        construct = Attribute.java_class.constructor(Java::java.lang.String,Java::weka.core.FastVector)
+        string = construct.new_instance(name_of_attr,nil).to_java
+    	return string
+    end
+  end
+
+end    
+
+

data/lib/ruby-band/core/type/instance.rb

@@ -0,0 +1,10 @@
+module Core
+  module Type
+
+    java_import "weka.core.FastVector"
+    java_import "weka.core.Instance"
+
+  	class Instance
+  	end
+  end
+end

data/lib/ruby-band/core/type/instances.rb

@@ -0,0 +1,361 @@
+require 'java'
+require 'ruport'
+require 'json'
+
+module Core
+
+  java_import "weka.core.SerializationHelper"
+  module Type
+    
+    java_import "weka.core.Instances"
+    java_import 'java.io.File'
+    java_import 'weka.core.converters.CSVSaver'
+    java_import 'weka.core.converters.ArffSaver'
+    java_import "weka.core.FastVector"
+    java_import "weka.core.Instance"
+
+    #
+    # * *Description*    :
+    # This is the main class from the Weka package for data handling. It is essentially a matrix: each row
+    # is an instance of the 'Instance' class, while each column is an instance of the 'Attribute' class
+    # The class 'Instances' is here extended to add custom functionalities 
+    class Instances
+
+      # Convert an Instances object to a bidimensional Ruby array
+      # where each row corresponds to an Instance object
+      def to_a2d
+        matrix = Array.new
+        att = Array.new
+        self.enumerateAttributes.each_with_index do |a,idx|
+          if a.isNumeric  
+            enumerate_instances.each {|s| att << s.value(s.attribute(idx))}
+            matrix << att
+            att = Array.new
+          else
+            enumerateInstances.each do |inst|
+              att << inst.string_value(idx)
+            end
+            matrix << att
+            att = Array.new
+          end
+        end
+        return matrix.transpose
+      end
+
+      # Return the number of rows (Instance objects) in the dataset
+      def n_rows
+        return numInstances
+      end
+
+      # Return the number of columns (Attribute objects) in the dataset
+      def n_col
+        return numAttributes
+      end
+
+      # Return the dimensions of the dataset (for the current Instances class object)
+      def dim
+        puts "Rows number:\t#{numInstances}\nColumns number:\t #{numAttributes}"
+      end
+
+      def each_row
+        enumerate_instances.each {|inst| yield(inst)}
+      end
+
+      def each_row_with_index
+        enumerate_instances.each_with_index {|inst,id| yield(inst,id)}
+      end
+
+      def each_column
+        enumerate_attributes.each {|attribute| yield(attribute)}
+      end
+
+      def each_column_with_index
+        enumerate_attributes.each_with_index {|attribute,id| yield(attribute,id)}
+      end
+
+      # Check if this instance's attributes are all Numeric
+      def check_numeric_instance
+        enumerateAttributes.each do |att|
+          unless att.isNumeric
+            raise ArgumentError, "Sorry, attribute '#{att.name}' is not numeric!"
+          end
+        end
+      end
+
+      # Convert the present Instances object to an Apache matrix if every Instances attribute
+      # is Numeric 
+      def to_Apache_matrix
+        check_numeric_instance
+        ruby_array = to_a
+        java_double_array = Core::Utils::bidimensional_to_double(ruby_array)
+        return Core::Type::Apache_matrix.new(java_double_array)
+      end
+
+      # Convert the present Instances object to an Apache matrix (block) if every Instances attribute
+      # is Numeric 
+      def to_Apache_matrix_block
+        check_numeric_instance
+        ruby_array = to_a
+        java_double_array = Core::Utils::bidimensional_to_double(ruby_array)
+        return Core::Type::Apache_matrix_block.new(java_double_array)
+      end
+
+      # Return data for a single attribute (a column from the Instances object)
+      # * *Args*    :
+      #   - +att+ -> a String, the name of the attribute
+      def return_attr_data(att)
+        attr_values = Array.new
+        if attribute(att).isNumeric
+          enumerateInstances.each do |i|
+            attr_values << i.value(attribute(att))
+          end
+        else
+          attr_index = attribute(att).index
+          enumerateInstances.each do |inst|
+            attr_values << inst.string_value(attr_index)
+          end
+        end
+        return attr_values
+      end
+
+      # Return the mean value of a single attribute (a column from the Instances object)
+      # * *Args*    :
+      #   - +attribute_name+ -> a String, the name of the attribute      
+      def mean(attribute_name) 
+        sum = enumerateInstances.inject(0) do |s,x|
+          s+=x.value(attribute(attribute_name))
+        end
+        return sum/(numInstances*1.0)
+      end
+
+      # Return the variance of a single attribute (a column from the Instances object)
+      # * *Args*    :
+      #   - +attribute_name+ -> a String, the name of the attribute    
+      def variance(attribute_name) 
+        enumerateAttributes.each_with_idx do |att,idx|
+          return variance(idx) if att.name==attribute_name
+        end
+      end      
+
+      # Write the content of the current Instances object to a .csv file
+      # * *Args*    :
+      #   - +out_file+ -> a String, the name of the output file  
+      def to_CSV(out_file)
+        saver = CSVSaver.new
+        saver.setInstances(self)
+        out_file = File.new out_file
+        saver.setFile(out_file);
+        saver.writeBatch();
+      end
+
+      # Write the content of the current Instances object to a .arff file
+      # * *Args*    :
+      #   - +out_file+ -> a String, the name of the output file 
+      def to_ARFF(out_file)
+        saver = ArffSaver.new
+        saver.setInstances(self)
+        out_file = File.new out_file
+        saver.setFile(out_file);
+        saver.writeBatch();
+      end
+
+      def insert_attribute(attribute_value,position)
+        att=attribute_value
+        if self.attribute(position).isNumeric
+          return attribute_value
+        elsif self.attribute(position).isNominal
+          idx = self.attribute(position).indexOfValue(attribute_value)
+          return idx
+        elsif self.attribute(position).isDate
+          date = self.attribute(position).ParseDate(attribute_value)
+          return date
+        else
+          puts 'Attribute type is unknown!'
+        end
+      end
+      private :insert_attribute
+
+      # (check function): should check that the array is bidimensional and that
+      # the lengths are equal
+      def check_array(data)
+        return true # still to be done
+      end
+
+      # An entire dataset is inserted 'by row' into the current Instances object 
+      # i.e. one Instance object is inserted at the time
+      # * *Args*    :
+      #   - +data+ -> a bidimensional array 
+      def populate_by_row(data)
+        unless check_array(data) == false
+          data.each do |row|
+            add_instance(row)
+          end
+        end
+      end
+
+      # An Instance instance object (one row) is inserted into the current Instances object 
+      # * *Args*    :
+      #   - +instance+ -> an array of values of the correct data type (:nominal,:numeric,etc...)
+      def add_instance(instance)
+        data_ref=Array.new
+        instance.each_with_index do |attribute,idx|
+          data_ref << insert_attribute(attribute,idx)
+        end
+        double_array = data_ref.to_java :double
+        single_row = Instance.new(1.0, double_array)
+        self.add(single_row)
+      end
+
+      # An Attribute instance object is inserted into the current Instances object  
+      # * *Args*    :
+      #   - +attribute_name+ -> A name for the new attribute
+      # * *WARNING*    :
+      # This method only creates an empty attribute field
+      def add_numeric_attribute(attribute_name)
+        insertAttributeAt(Attribute.new(attribute_name), self.numAttributes)
+      end
+
+      # An Attribute instance object is inserted into the current Instances object  
+      # * *Args*    :
+      #   - +attribute_name+ -> A name for the new attribute
+      #   - +values+ -> RubyArray with nominal values 
+      # * *WARNING*    :
+      # This method only creates an empty attribute field
+      def add_nominal_attribute(attribute,list_values)
+        values = FastVector.new
+        list_values.each do |val|
+          values.addElement(val)         
+        end
+        insertAttributeAt(Attribute.new(attribute, values), self.numAttributes)
+      end      
+
+      #Print to STDOUT the list of the Instances's attributes (with the corresponding types)
+      def summary
+        summary = Ruport::Data::Table::new
+        summary.add_column 'Attributes'
+        enumerateAttributes.each_with_index do |att,idx| 
+          summary.add_column idx
+        end
+ 
+        att_names = ['Names']
+        enumerateAttributes.each do |att| 
+          att_names << "'#{att.name}'"
+        end
+        summary << att_names
+
+        att_types = ['Types']
+        enumerateAttributes.each do |att|
+          att_types << "Numeric" if att.isNumeric 
+          att_types << "Nominal" if att.isNominal
+          att_types << "Date" if att.isDate
+          att_types << "String" if att.isString
+        end
+        summary << att_types
+
+        display = []
+        display << summary
+
+        unless enumerate_instances.nil?
+          count=0
+          enumerateInstances.each {|inst| count=count+1}
+          display << "\nNumber of rows: #{count}"
+        end
+        display 
+      end
+
+      # Merges two sets of Instances together. The resulting set will have all the
+      # attributes of the first set plus all the attributes of the second set. The
+      # number of instances in both sets must be the same.
+      # * *Args*    :
+      #   - +instances+ -> An Instances class object
+      def merge_with(instances)
+        return Instances.mergeInstances(self,instances)
+      end
+
+      # This method creates an Instances object (see Cucumber documentation for further details)
+     # def self.create
+     #   name = 'Instances'
+     #   instances = Core::Type.create_instances(name,@@positions)
+     #   return instances
+     # end
+
+      # This method is used for attributes definition in uninitialized Instances-derived classes
+      def att(attr_type,name,*values)
+        att = Core::Type.create_numeric_attr(name.to_java(:string)) if attr_type == :numeric
+        att = Core::Type.create_nominal_attr(name.to_java(:string),values[0]) if attr_type == :nominal
+        att = Core::Type.create_date_attr(name.to_java(:string),values[0]) if attr_type == :date
+        att = att = Core::Type.create_string_attr(name.to_java(:string)) if attr_type == :string      
+        @positions << att
+      end
+
+      # This method is used for Nominal attributes definition in uninitialized Instances-derived classes
+      # * *Args*    :
+      #   - +name+ -> Attribute name, a String
+      #   - +values+ -> An array of values for the nominal attribute
+      def nominal(name,values)
+        att :nominal, name, values
+      end
+
+      # This method is used for Numeric attributes definition in uninitialized Instances-derived classes
+      # * *Args*    :
+      #   - +name+ -> Attribute name, a String
+      def numeric(name)
+        att :numeric, name
+      end
+
+      # This method is used for Date attributes definition in uninitialized Instances-derived classes
+      # * *Args*    :
+      #   - +name+ -> Attribute name, a String
+      def date(name)
+        att :date, name
+      end
+
+      # This method is used for String attributes definition in uninitialized Instances-derived classes
+      # * *Args*    :
+      #   - +name+ -> Attribute name, a String
+      def string(name)
+        att :string, name
+      end
+
+      # Class used for the creation of a new dataset (Instances class)
+      class Base < Instances
+        def initialize(&block)
+          attributes_vector = FastVector.new
+          @positions = []
+          self.instance_eval(&block) if block
+          @positions.each {|value| attributes_vector.addElement(value)}
+          super('Instances',attributes_vector,0)
+        end
+      end
+
+      # Return a json String for the current Instances object
+      # The output is modeled on the 'datatable' Google charts APIs 
+      # More details at: 'https://developers.google.com/chart/interactive/docs/reference#DataTable'
+      def to_json_format
+        dataset_hash = Hash.new
+        dataset_hash[:cols] = enumerateAttributes.collect {|attribute| attribute.name}
+        dataset_hash[:rows] = enumerateInstances.collect {|instance| instance.toString} 
+        return JSON.pretty_generate(dataset_hash)
+      end
+    end #Instances class
+
+    # Create an Instances object
+    # * *Args*    :
+    #   - +name+ -> A name for the Instances object
+    #   - +attributes+ -> An array containing Attribute objects
+    def Type.create_instances(name,attributes)
+      attributes_vector = FastVector.new
+      attributes.each {|value| attributes_vector.addElement(value)}
+      return Instances.new(name,attributes_vector,0)
+    end
+
+  end
+  # Helper class for serialization
+  # Works with classifiers, filters, clusterers...
+  class SerializationHelper
+  end
+  
+end
+
+
+