weka 0.4.0-java → 0.5.0-java

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: 24673716e3c980b803c2c77172efbed98a8d7de6
-  data.tar.gz: 9c611dba1492b943ceaea2ca9c375bbbe95ada85
+SHA256:
+  metadata.gz: 07d0cbed2d245de34e10101d0597017194804735e3b5ea6bc972201282c60d5d
+  data.tar.gz: b304c03a4552b766f56e60e52b765068fdb0de0350d1e5c541882f085e90824b
 SHA512:
-  metadata.gz: 54236c07fa7110a5260a587cd2a1e57016705275ea6eba8b624ad7a5bc8ed58c7e878cf4b61913368f27c9286ccdde777323e34278917d0b05ed185b87fbdbb2
-  data.tar.gz: 245cc55a7abf2751ddea7a2f4dda479eab73b3aff2852fe915705944a2a0290a26b4bb1d8188e97009168c72c12775bf464d724ca84473a359685a9df7f13ae9
+  metadata.gz: 942621fa83a7670384adccb717610ac19dc5d961fd9de5ab579a331c40119ef8e0e73cb0b0962aaff9fe937628335ee453be2ef1ed0669edf5421dadc075acdc
+  data.tar.gz: ee68c277c9a40f6349fdea303897d44fd93ded9311d11ffba8c1cd3909764ea51d22638cc7240bb375570615a9acaa4d98ba591b8de3102c41c3dcabf550283b

data/.rubocop.yml

@@ -0,0 +1,30 @@
+AllCops:
+  TargetRubyVersion: 2.4
+  Exclude:
+    - 'bin/**/*'
+    - '*.gemspec'
+    - 'Gemfile'
+    - 'Gemfile.lock'
+
+Style/Copyright:
+  Enabled: false
+
+Style/Documentation:
+  Enabled: false
+
+Metrics/LineLength:
+  Max: 80
+
+Layout/MultilineMethodCallIndentation:
+  EnforcedStyle: indented
+
+Style/FrozenStringLiteralComment:
+  Enabled: false
+
+Metrics/ModuleLength:
+  Exclude:
+    - "**/*_spec.rb"
+
+Metrics/BlockLength:
+  Exclude:
+    - "**/*_spec.rb"

data/README.md

@@ -2,6 +2,7 @@
 
 [![Gem Version](https://badge.fury.io/rb/weka.svg)](http://badge.fury.io/rb/weka)
 [![Travis Build](https://travis-ci.org/paulgoetze/weka-jruby.svg)](https://travis-ci.org/paulgoetze/weka-jruby)
+[![Codacy Badge](https://api.codacy.com/project/badge/Grade/9634a6709ef545198e079a8daddff100)](https://www.codacy.com/app/paul-christoph-goetze/weka-jruby?utm_source=github.com&utm_medium=referral&utm_content=paulgoetze/weka-jruby&utm_campaign=Badge_Grade)
 
 Machine Learning & Data Mining with JRuby based on the [Weka](http://www.cs.waikato.ac.nz/~ml/weka/index.html) Java library.
 
@@ -60,7 +61,7 @@ Here’s how to contribute:
 Please try to add RSpec tests along with your new features. This will ensure that your code does not break existing functionality and that your feature is working as expected.
 
 We use [Rubocop](https://github.com/bbatsov/rubocop) for code style recommendations.
-Please make sure your contributions comply with the default config of Rubocop.
+Please make sure your contributions comply with the project’s Rubocop config.
 
 ## Acknowledgement
 

data/lib/weka/class_builder.rb

@@ -7,14 +7,24 @@ module Weka
     end
 
     module ClassMethods
-      def build_class(class_name, weka_module: nil, include_concerns: true)
+      def build_class(class_name, weka_module: nil, include_concerns: true, additional_includes: [])
         java_import java_class_path(class_name, weka_module)
-        define_class(class_name, weka_module, include_concerns: include_concerns)
+        define_class(
+          class_name,
+          weka_module,
+          include_concerns: include_concerns,
+          additional_includes: additional_includes
+        )
       end
 
-      def build_classes(*class_names, weka_module: nil, include_concerns: true)
+      def build_classes(*class_names, weka_module: nil, include_concerns: true, additional_includes: [])
         class_names.each do |name|
-          build_class(name, weka_module: weka_module, include_concerns: include_concerns)
+          build_class(
+            name,
+            weka_module: weka_module,
+            include_concerns: include_concerns,
+            additional_includes: additional_includes
+          )
         end
       end
 
@@ -58,12 +68,13 @@ module Weka
         name.scan('::').count == 1
       end
 
-      def define_class(class_name, weka_module, include_concerns: true)
+      def define_class(class_name, weka_module, include_concerns: true, additional_includes: [])
         module_eval <<-CLASS_DEFINITION, __FILE__, __LINE__ + 1
           class #{class_name}
             #{'include Concerns' if include_concerns}
             #{include_serializable_for(class_name, weka_module)}
             #{include_utils}
+            #{include_additionals(additional_includes)}
           end
         CLASS_DEFINITION
       end
@@ -84,6 +95,13 @@ module Weka
         constantize(utils_super_modules).const_defined?(:Utils)
       end
 
+      def include_additionals(modules)
+        modules = Array(modules)
+        return if modules.empty?
+
+        modules.map { |name| "include #{name}" }.join("\n")
+      end
+
       def constantize(module_names)
         Object.module_eval("::#{module_names}")
       end

data/lib/weka/classifiers/evaluation.rb

@@ -1,8 +1,12 @@
+require 'weka/class_builder'
+
 module Weka
   module Classifiers
     java_import 'weka.classifiers.Evaluation'
 
     class Evaluation
+      include ClassBuilder
+
       # Use both nomenclatures f_measure and fmeasure for consistency
       # due to jruby's auto method generation of 'fMeasure' to 'f_measure' and
       # 'weightedFMeasure' to 'weighted_fmeasure'.
@@ -29,8 +33,20 @@ module Weka
       alias average_cost            avg_cost
 
       alias cumulative_margin_distribution to_cumulative_margin_distribution_string
-    end
 
-    Java::WekaClassifiers::Evaluation.__persistent__ = true
+      module Curve
+        def self.included(base)
+          base.class_eval do
+            alias_method :curve, :get_curve
+          end
+        end
+      end
+
+      build_classes :CostCurve,
+                    :MarginCurve,
+                    :ThresholdCurve,
+                    weka_module: 'weka.classifiers.evaluation',
+                    additional_includes: Curve
+    end
   end
 end

data/lib/weka/classifiers/utils.rb

@@ -5,128 +5,154 @@ module Weka
   module Classifiers
     module Utils
       def self.included(base)
-        base.class_eval do
-          java_import 'java.util.Random'
+        base.include Buildable     if base.instance_methods.include?(:build_classifier)
+        base.include Classifiable  if base.instance_methods.include?(:classify_instance)
+        base.include Updatable     if base.instance_methods.include?(:update_classifier)
+        base.include Distributable if base.instance_methods.include?(:distribution_for_instance)
+      end
 
-          if instance_methods.include?(:build_classifier)
-            attr_reader :training_instances
+      module Checks
+        private
 
-            def train_with_instances(instances)
-              ensure_class_attribute_assigned!(instances)
+        def ensure_class_attribute_assigned!(instances)
+          return if instances.class_attribute_defined?
 
-              @training_instances = instances
-              build_classifier(instances)
+          error   = 'Class attribute is not assigned for Instances.'
+          hint    = 'You can assign a class attribute with #class_attribute=.'
+          message = "#{error} #{hint}"
 
-              self
-            end
+          raise UnassignedClassError, message
+        end
 
-            def cross_validate(folds: 3)
-              ensure_trained_with_instances!
+        def ensure_trained_with_instances!
+          return unless training_instances.nil?
 
-              evaluation = Evaluation.new(training_instances)
-              random     = Java::JavaUtil::Random.new(1)
+          error   = 'Classifier is not trained with Instances.'
+          hint    = 'You can set the training instances with #train_with_instances.'
+          message = "#{error} #{hint}"
 
-              evaluation.cross_validate_model(self, training_instances, folds.to_i, random)
-              evaluation
-            end
+          raise UnassignedTrainingInstancesError, message
+        end
+      end
 
-            def evaluate(test_instances)
-              ensure_trained_with_instances!
-              ensure_class_attribute_assigned!(test_instances)
+      module Transformers
+        private
 
-              evaluation = Evaluation.new(training_instances)
-              evaluation.evaluate_model(self, test_instances)
-              evaluation
-            end
-          end
+        def classifiable_instance_from(instance_or_values)
+          attributes = training_instances.attributes
+          instances  = Weka::Core::Instances.new(attributes: attributes)
 
-          if instance_methods.include?(:classify_instance)
-            def classify(instance_or_values)
-              ensure_trained_with_instances!
+          class_attribute = training_instances.class_attribute
+          class_index     = training_instances.class_index
+          instances.insert_attribute_at(class_attribute, class_index)
 
-              instance = classifiable_instance_from(instance_or_values)
-              index    = classify_instance(instance)
+          instances.class_index = training_instances.class_index
+          instances.add_instance(instance_or_values)
 
-              class_value_of_index(index)
-            end
-          end
+          instance = instances.first
+          instance.set_class_missing
+          instance
+        end
+      end
 
-          if instance_methods.include?(:update_classifier)
-            def add_training_instance(instance)
-              training_instances.add(instance)
-              update_classifier(instance)
+      module Buildable
+        java_import 'java.util.Random'
+        include Checks
 
-              self
-            end
+        attr_reader :training_instances
 
-            def add_training_data(data)
-              values   = training_instances.internal_values_of(data)
-              instance = Weka::Core::DenseInstance.new(values)
-              add_training_instance(instance)
-            end
-          end
+        def train_with_instances(instances)
+          ensure_class_attribute_assigned!(instances)
 
-          if instance_methods.include?(:distribution_for_instance)
-            def distribution_for(instance_or_values)
-              ensure_trained_with_instances!
+          @training_instances = instances
+          build_classifier(instances)
 
-              instance      = classifiable_instance_from(instance_or_values)
-              distributions = distribution_for_instance(instance)
+          self
+        end
 
-              class_distributions_from(distributions)
-            end
-          end
+        def cross_validate(folds: 3)
+          ensure_trained_with_instances!
 
-          private
+          evaluation = Evaluation.new(training_instances)
+          random     = Java::JavaUtil::Random.new(1)
 
-          def ensure_class_attribute_assigned!(instances)
-            return if instances.class_attribute_defined?
+          evaluation.cross_validate_model(
+            self,
+            training_instances,
+            folds.to_i,
+            random
+          )
 
-            error   = 'Class attribute is not assigned for Instances.'
-            hint    = 'You can assign a class attribute with #class_attribute=.'
-            message = "#{error} #{hint}"
+          evaluation
+        end
 
-            raise UnassignedClassError, message
-          end
+        def evaluate(test_instances)
+          ensure_trained_with_instances!
+          ensure_class_attribute_assigned!(test_instances)
 
-          def ensure_trained_with_instances!
-            return unless training_instances.nil?
+          evaluation = Evaluation.new(training_instances)
+          evaluation.evaluate_model(self, test_instances)
+          evaluation
+        end
+      end
 
-            error   = 'Classifier is not trained with Instances.'
-            hint    = 'You can set the training instances with #train_with_instances.'
-            message = "#{error} #{hint}"
+      module Classifiable
+        include Checks
+        include Transformers
 
-            raise UnassignedTrainingInstancesError, message
-          end
+        def classify(instance_or_values)
+          ensure_trained_with_instances!
 
-          def classifiable_instance_from(instance_or_values)
-            attributes = training_instances.attributes
-            instances  = Weka::Core::Instances.new(attributes: attributes)
+          instance = classifiable_instance_from(instance_or_values)
+          index    = classify_instance(instance)
 
-            class_attribute = training_instances.class_attribute
-            class_index     = training_instances.class_index
-            instances.insert_attribute_at(class_attribute, class_index)
+          class_value_of_index(index)
+        end
 
-            instances.class_index = training_instances.class_index
-            instances.add_instance(instance_or_values)
+        private
 
-            instance = instances.first
-            instance.set_class_missing
-            instance
-          end
+        def class_value_of_index(index)
+          training_instances.class_attribute.value(index)
+        end
+      end
 
-          def class_value_of_index(index)
-            training_instances.class_attribute.value(index)
-          end
+      module Updatable
+        def add_training_instance(instance)
+          training_instances.add(instance)
+          update_classifier(instance)
+
+          self
+        end
+
+        def add_training_data(data)
+          values   = training_instances.internal_values_of(data)
+          instance = Weka::Core::DenseInstance.new(values)
+          add_training_instance(instance)
+        end
+      end
+
+      module Distributable
+        include Checks
+        include Transformers
+
+        def distribution_for(instance_or_values)
+          ensure_trained_with_instances!
+
+          instance      = classifiable_instance_from(instance_or_values)
+          distributions = distribution_for_instance(instance)
+
+          class_distributions_from(distributions)
+        end
+
+        private
 
-          def class_distributions_from(distributions)
-            class_values = training_instances.class_attribute.values
+        def class_distributions_from(distributions)
+          class_values = training_instances.class_attribute.values
 
-            distributions.each_with_index.reduce({}) do |result, (distribution, index)|
-              class_value = class_values[index]
-              result[class_value] = distribution
-              result
-            end
+          distributions.each_with_object({}).with_index do |(distribution, result), index|
+            class_value = class_values[index]
+            result[class_value] = distribution
+            result
           end
         end
       end

data/lib/weka/clusterers/utils.rb

@@ -5,96 +5,122 @@ module Weka
   module Clusterers
     module Utils
       def self.included(base)
-        base.class_eval do
-          java_import 'java.util.Random'
-
-          if instance_methods.include?(:build_clusterer)
-            attr_reader :training_instances
-
-            def train_with_instances(instances)
-              @training_instances = instances
-              build_clusterer(instances)
-
-              self
-            end
-
-            if ancestors.include?(Java::WekaClusterers::DensityBasedClusterer)
-              def cross_validate(folds: 3)
-                ensure_trained_with_instances!
-
-                ClusterEvaluation.cross_validate_model(
-                  self,
-                  training_instances,
-                  folds.to_i,
-                  Java::JavaUtil::Random.new(1)
-                )
-              end
-            end
-
-            def evaluate(test_instances)
-              ensure_trained_with_instances!
-
-              ClusterEvaluation.new.tap do |evaluation|
-                evaluation.clusterer = self
-                evaluation.evaluate_clusterer(test_instances)
-              end
-            end
-          end
+        if base.instance_methods.include?(:build_clusterer)
+          base.include Buildable
+          base.include CrossValidatable if density_based?(base)
+        end
 
-          if instance_methods.include?(:cluster_instance)
-            def cluster(instance_or_values)
-              ensure_trained_with_instances!
+        base.include Clusterable   if base.instance_methods.include?(:cluster_instance)
+        base.include Updatable     if base.instance_methods.include?(:update_clusterer)
+        base.include Distributable if base.instance_methods.include?(:distribution_for_instance)
+      end
 
-              instance = clusterable_instance_from(instance_or_values)
-              cluster_instance(instance)
-            end
-          end
+      def self.density_based?(base)
+        base.ancestors.include?(Java::WekaClusterers::DensityBasedClusterer)
+      end
 
-          if instance_methods.include?(:update_clusterer)
-            def add_training_instance(instance)
-              training_instances.add(instance)
-              update_clusterer(instance)
+      module Checks
+        private
 
-              self
-            end
+        def ensure_trained_with_instances!
+          return unless training_instances.nil?
 
-            def add_training_data(data)
-              values   = training_instances.internal_values_of(data)
-              instance = Weka::Core::DenseInstance.new(values)
-              add_training_instance(instance)
-            end
-          end
+          error   = 'Clusterer is not trained with Instances.'
+          hint    = 'You can set the training instances with #train_with_instances.'
+          message = "#{error} #{hint}"
 
-          if instance_methods.include?(:distribution_for_instance)
-            def distribution_for(instance_or_values)
-              ensure_trained_with_instances!
+          raise UnassignedTrainingInstancesError, message
+        end
+      end
 
-              instance = clusterable_instance_from(instance_or_values)
-              distribution_for_instance(instance).to_a
-            end
-          end
+      module Transformers
+        private
 
-          private
+        def clusterable_instance_from(instance_or_values)
+          attributes = training_instances.attributes
+          instances  = Weka::Core::Instances.new(attributes: attributes)
 
-          def ensure_trained_with_instances!
-            return unless training_instances.nil?
+          instances.add_instance(instance_or_values)
+          instances.first
+        end
+      end
 
-            error   = 'Clusterer is not trained with Instances.'
-            hint    = 'You can set the training instances with #train_with_instances.'
-            message = "#{error} #{hint}"
+      module Buildable
+        include Checks
 
-            raise UnassignedTrainingInstancesError, message
-          end
+        attr_reader :training_instances
 
-          def clusterable_instance_from(instance_or_values)
-            attributes = training_instances.attributes
-            instances  = Weka::Core::Instances.new(attributes: attributes)
+        def train_with_instances(instances)
+          @training_instances = instances
+          build_clusterer(instances)
+
+          self
+        end
 
-            instances.add_instance(instance_or_values)
-            instances.first
+        def evaluate(test_instances)
+          ensure_trained_with_instances!
+
+          ClusterEvaluation.new.tap do |evaluation|
+            evaluation.clusterer = self
+            evaluation.evaluate_clusterer(test_instances)
           end
         end
       end
+
+      module CrossValidatable
+        java_import 'java.util.Random'
+        include Checks
+
+        def cross_validate(folds: 3)
+          ensure_trained_with_instances!
+
+          ClusterEvaluation.cross_validate_model(
+            self,
+            training_instances,
+            folds.to_i,
+            Java::JavaUtil::Random.new(1)
+          )
+        end
+      end
+
+      module Clusterable
+        include Checks
+        include Transformers
+
+        def cluster(instance_or_values)
+          ensure_trained_with_instances!
+
+          instance = clusterable_instance_from(instance_or_values)
+          cluster_instance(instance)
+        end
+      end
+
+      module Updatable
+        def add_training_instance(instance)
+          training_instances.add(instance)
+          update_clusterer(instance)
+
+          self
+        end
+
+        def add_training_data(data)
+          values   = training_instances.internal_values_of(data)
+          instance = Weka::Core::DenseInstance.new(values)
+          add_training_instance(instance)
+        end
+      end
+
+      module Distributable
+        include Checks
+        include Transformers
+
+        def distribution_for(instance_or_values)
+          ensure_trained_with_instances!
+
+          instance = clusterable_instance_from(instance_or_values)
+          distribution_for_instance(instance).to_a
+        end
+      end
     end
   end
 end

data/lib/weka/concerns/optionizable.rb

@@ -2,45 +2,46 @@ module Weka
   module Concerns
     module Optionizable
       def self.included(base)
-        base.extend(ClassMethods)
+        base.extend ClassMethods
+        base.include InstanceMethods
+      end
 
-        base.class_eval do
-          java_import 'weka.core.Utils'
+      module ClassMethods
+        def default_options
+          new.get_options.to_a.join(' ')
+        end
+      end
 
-          def use_options(*single_options, **hash_options)
-            joined_options = join_options(single_options, hash_options)
-            options        = Java::WekaCore::Utils.split_options(joined_options)
+      module InstanceMethods
+        java_import 'weka.core.Utils'
 
-            set_options(options)
-            @options = joined_options
-          end
+        def use_options(*single_options, **hash_options)
+          joined_options = join_options(single_options, hash_options)
+          options        = Java::WekaCore::Utils.split_options(joined_options)
 
-          def options
-            @options || self.class.default_options
-          end
+          set_options(options)
+          @options = joined_options
+        end
 
-          private
+        def options
+          @options || self.class.default_options
+        end
 
-          def join_options(*single_options, **hash_options)
-            [
-              join_single_options(*single_options),
-              join_hash_options(**hash_options)
-            ].reject(&:empty?).join(' ')
-          end
+        private
 
-          def join_single_options(options)
-            options.map { |option| "-#{option.to_s.sub(/^-/, '')}" }.join(' ')
-          end
+        def join_options(*single_options, **hash_options)
+          [
+            join_single_options(*single_options),
+            join_hash_options(**hash_options)
+          ].reject(&:empty?).join(' ')
+        end
 
-          def join_hash_options(options)
-            options.map { |key, value| "-#{key} #{value}" }.join(' ')
-          end
+        def join_single_options(options)
+          options.map { |option| "-#{option.to_s.sub(/^-/, '')}" }.join(' ')
         end
-      end
 
-      module ClassMethods
-        def default_options
-          new.get_options.to_a.join(' ')
+        def join_hash_options(options)
+          options.map { |key, value| "-#{key} #{value}" }.join(' ')
         end
       end
     end

data/lib/weka/concerns/serializable.rb

@@ -3,12 +3,8 @@ require 'weka/core/serialization_helper'
 module Weka
   module Concerns
     module Serializable
-      def self.included(base)
-        base.class_eval do
-          def serialize(filename)
-            Weka::Core::SerializationHelper.write(filename, self)
-          end
-        end
+      def serialize(filename)
+        Weka::Core::SerializationHelper.write(filename, self)
       end
     end
   end

data/lib/weka/core/attribute.rb

@@ -7,7 +7,7 @@ module Weka
     class Attribute
       include Weka::Concerns::Persistent
 
-      TYPES = %i(numeric nominal string date).freeze
+      TYPES = %i[numeric nominal string date].freeze
 
       class << self
         def new_numeric(name)

data/lib/weka/core/dense_instance.rb

@@ -57,25 +57,17 @@ module Weka
 
         attribute = attribute_at(index)
 
-        if attribute.date?
-          format_date(value, attribute.date_format)
-        elsif attribute.numeric?
-          value
-        elsif attribute.nominal? || attribute.string?
-          attribute.value(value)
-        end
+        return format_date(value, attribute.date_format) if attribute.date?
+        return value if attribute.numeric?
+        return attribute.value(value) if attribute.nominal? || attribute.string?
       end
 
       def attribute_at(index)
-        return attributes[index] unless dataset.class_attribute_defined?
+        return attributes[index]     unless dataset.class_attribute_defined?
+        return class_attribute       if dataset.class_index == index
+        return attributes[index - 1] if index > dataset.class_index
 
-        if dataset.class_index == index
-          class_attribute
-        elsif index > dataset.class_index
-          attributes[index - 1]
-        else
-          attributes[index]
-        end
+        attributes[index]
       end
 
       def format_date(value, format)

data/lib/weka/core/instances.rb

@@ -1,3 +1,4 @@
+require 'matrix'
 require 'weka/core/converters'
 require 'weka/core/loader'
 require 'weka/core/saver'
@@ -10,6 +11,7 @@ module Weka
     java_import 'weka.core.FastVector'
 
     class Instances
+      include Weka::Concerns::Persistent
       include Weka::Concerns::Serializable
 
       DEFAULT_RELATION_NAME = 'Instances'.freeze
@@ -38,7 +40,7 @@ module Weka
         end
       end
 
-      def initialize(relation_name: DEFAULT_RELATION_NAME, attributes: [], &block)
+      def initialize(relation_name: DEFAULT_RELATION_NAME, attributes: [])
         attribute_list = FastVector.new
         attributes.each { |attribute| attribute_list.add_element(attribute) }
 
@@ -49,12 +51,18 @@ module Weka
         enumerate_instances.to_a
       end
 
-      def attributes
-        enumerate_attributes.to_a
+      def attributes(include_class_attribute: false)
+        attrs = enumerate_attributes.to_a
+
+        if include_class_attribute && class_attribute_defined?
+          attrs.insert(class_index, class_attribute)
+        end
+
+        attrs
       end
 
-      def attribute_names
-        attributes.map(&:name)
+      def attribute_names(include_class_attribute: false)
+        attributes(include_class_attribute: include_class_attribute).map(&:name)
       end
 
       def add_attributes(&block)
@@ -67,7 +75,7 @@ module Weka
       alias attributes_count      num_attributes
       alias has_string_attribute? check_for_string_attributes
 
-      ## Check if the instances has any attribute of the given type
+      # Check if the instances has any attribute of the given type
       # @param [String, Symbol, Integer] type type of the attribute to check
       #   String and Symbol argument are converted to corresponding type
       #   defined in Weka::Core::Attribute
@@ -189,6 +197,24 @@ module Weka
         class_index >= 0
       end
 
+      # Add new instance
+      # @param [Instance, Array, Hash] instance_or_values the attribute values
+      #   of the instance to be added. If passing an array, the attribute values
+      #   must be in the same order as the attributes defined in Instances.
+      #   If passing a hash, The keys are the names of the attributes and their
+      #   values are corresponding attributes values.
+      #
+      # @example Passing Instance
+      #   instances.add_instance(instance)
+      #
+      # @example Passing an array of attribute values
+      #   attr_values = [attr1_value, attr2_value, attr3_value]
+      #   instances.add_instance(attr_values)
+      #
+      # @example Passing a hash of attribute values.
+      #   attr_values = { attr1_name: attr1_value, attr2_name: attr2_value }
+      #   instances.add_instance(attr_values)
+      #
       def add_instance(instance_or_values, weight: 1.0)
         instance = instance_from(instance_or_values, weight: weight)
         add(instance)
@@ -198,10 +224,24 @@ module Weka
         data.each { |values| add_instance(values, weight: weight) }
       end
 
+      # Retrieve the internal floating point values used to represent
+      #   the attributes.
+      #
+      # @param [Array, Hash] values the attribute values whose floating
+      #   point representation should be retrieved.
+      #
+      # @return [Array, Hash] an array of the internal floating point
+      #   representation if the input is an Array. Hash otherwise.
       def internal_values_of(values)
-        values.each_with_index.map do |value, index|
+        use_hash = values.is_a?(Hash)
+        values = attribute_values_from_hash(values) if use_hash
+
+        values = values.map.with_index do |value, index|
           attribute(index).internal_value_of(value)
         end
+
+        values = attribute_values_to_hash(values) if use_hash
+        values
       end
 
       def apply_filter(filter)
@@ -220,6 +260,13 @@ module Weka
         end
       end
 
+      # Get the all instances's values as Matrix.
+      #
+      # @return [Matrix] a Matrix holding the instance's values as rows.
+      def to_m
+        Matrix[*instances.map(&:values)]
+      end
+
       private
 
       def add_attribute(attribute)
@@ -227,7 +274,9 @@ module Weka
       end
 
       def ensure_attribute_defined!(name)
-        return if attribute_names.include?(name.to_s)
+        if attribute_names(include_class_attribute: true).include?(name.to_s)
+          return
+        end
 
         error   = "\"#{name}\" is not defined."
         hint    = 'Only defined attributes can be used as class attribute!'
@@ -237,25 +286,36 @@ module Weka
       end
 
       def attribute_with_name(name)
-        attributes.select { |attribute| attribute.name == name.to_s }.first
+        attributes(include_class_attribute: true).find do |attribute|
+          attribute.name == name.to_s
+        end
       end
 
+      # Wrap the attribute values for the instance to be added with
+      #   an Instance object, if needed. The Instance object is
+      #   assigned with the given weight.
+      #
+      # @param [Instance, Array, Hash] instance_or_values either the
+      #   instance object to be added or the attribute values for it.
+      #   For the latter case, it accepts an array or a hash.
+      #
+      # @param [Float] weight the weight for the Instance to be added
+      #
+      # @return [Instance] the object that contains the given
+      #   attribute values.
       def instance_from(instance_or_values, weight:)
         if instance_or_values.is_a?(Java::WekaCore::Instance)
           instance_or_values.weight = weight
           instance_or_values
         else
+          if instance_or_values.is_a?(Hash)
+            instance_or_values = attribute_values_from_hash(instance_or_values)
+          end
+
           data = internal_values_of(instance_or_values)
 
-          # string attribute has unlimited range of possible values.
-          # Check the return index, if it is -1 then add the value to
-          # the attribute before creating the instance
-          data.map!.with_index do |value, index|
-            if value == -1 && attribute(index).string?
-              attribute(index).add_string_value(instance_or_values[index].to_s)
-            else
-              value
-            end
+          if has_string_attribute?
+            data = check_string_attributes(data, instance_or_values)
           end
 
           DenseInstance.new(data, weight: weight)
@@ -266,8 +326,48 @@ module Weka
         return -1 unless Attribute::TYPES.include?(type.downcase.to_sym)
         Attribute.const_get(type.upcase)
       end
-    end
 
-    Java::WekaCore::Instances.__persistent__ = true
+      # Convert a hash whose keys are attribute names and values are attribute
+      #   values into an array containing attribute values in the order
+      #   of the Instances attributes.
+      #
+      # @param [Hash] hash a hash whose keys are attribute names and
+      #   values are attribute values.
+      #
+      # @return [Array] an array containing attribute values in the
+      #   correct order
+      def attribute_values_from_hash(hash)
+        names = attribute_names(include_class_attribute: true).map(&:to_sym)
+        hash.values_at(*names)
+      end
+
+      # Convert an array of attribute values in the same order as Instances
+      #   attributes into a hash whose keys are attribute names and values
+      #   are corresponding attribute values.
+      #
+      # @param [Array] values an array containing the attribute values
+      #
+      # @return [Hash] a hash as described above
+      def attribute_values_to_hash(values)
+        names = attribute_names(include_class_attribute: true).map(&:to_sym)
+
+        names.each_with_index.inject({}) do |hash, (name, index)|
+          hash.update(name => values[index])
+        end
+      end
+
+      def check_string_attributes(internal_values, attribute_values)
+        # string attribute has unlimited range of possible values.
+        # Check the return index, if it is -1 then add the value to
+        # the attribute before creating the instance
+        internal_values.map.with_index do |value, index|
+          if value == -1 && attribute(index).string?
+            attribute(index).add_string_value(attribute_values[index])
+          else
+            value
+          end
+        end
+      end
+    end
   end
 end

data/lib/weka/filters/utils.rb

@@ -1,13 +1,9 @@
 module Weka
   module Filters
     module Utils
-      def self.included(base)
-        base.class_eval do
-          def filter(instances)
-            set_input_format(instances)
-            Filter.use_filter(instances, self)
-          end
-        end
+      def filter(instances)
+        set_input_format(instances)
+        Filter.use_filter(instances, self)
       end
     end
   end

data/lib/weka/version.rb

@@ -1,3 +1,3 @@
 module Weka
-  VERSION = '0.4.0'.freeze
+  VERSION = '0.5.0'.freeze
 end

data/weka.gemspec

@@ -1,4 +1,5 @@
 # coding: utf-8
+
 lib = File.expand_path('../lib', __FILE__)
 $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
 require 'weka/version'

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: weka
 version: !ruby/object:Gem::Version
-  version: 0.4.0
+  version: 0.5.0
 platform: java
 authors:
 - Paul Götze
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2016-12-22 00:00:00.000000000 Z
+date: 2017-06-17 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   requirement: !ruby/object:Gem::Requirement
@@ -91,6 +91,7 @@ extra_rdoc_files: []
 files:
 - ".gitignore"
 - ".rspec"
+- ".rubocop.yml"
 - ".travis.yml"
 - CODE_OF_CONDUCT.md
 - Gemfile
@@ -164,7 +165,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project:
-rubygems_version: 2.6.6
+rubygems_version: 2.6.11
 signing_key:
 specification_version: 4
 summary: Machine Learning & Data Mining with JRuby.