weka 0.3.0-java → 0.4.0-java

data/lib/weka/clusterers/cluster_evaluation.rb

@@ -3,12 +3,10 @@ module Weka
     java_import 'weka.clusterers.ClusterEvaluation'
 
     class ClusterEvaluation
-
-      alias :summary        :cluster_results_to_string
-      alias :clusters_count :num_clusters
+      alias summary        cluster_results_to_string
+      alias clusters_count num_clusters
     end
 
     Java::WekaClusterers::ClusterEvaluation.__persistent__ = true
-
   end
 end

data/lib/weka/clusterers/utils.rb

@@ -1,103 +1,100 @@
-require 'active_support/concern'
 require 'weka/clusterers/cluster_evaluation'
 require 'weka/core/instances'
 
 module Weka
   module Clusterers
     module Utils
-      extend ActiveSupport::Concern
+      def self.included(base)
+        base.class_eval do
+          java_import 'java.util.Random'
 
-      included do
-        java_import 'java.util.Random'
+          if instance_methods.include?(:build_clusterer)
+            attr_reader :training_instances
 
-        if instance_methods.include?(:build_clusterer)
-          attr_reader :training_instances
+            def train_with_instances(instances)
+              @training_instances = instances
+              build_clusterer(instances)
 
-          def train_with_instances(instances)
-            @training_instances = instances
-            build_clusterer(instances)
+              self
+            end
 
-            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
 
-          if ancestors.include?(Java::WekaClusterers::DensityBasedClusterer)
-            def cross_validate(folds: 3)
+            def evaluate(test_instances)
               ensure_trained_with_instances!
 
-              ClusterEvaluation.cross_validate_model(
-                self,
-                training_instances,
-                folds.to_i,
-                Java::JavaUtil::Random.new(1)
-              )
+              ClusterEvaluation.new.tap do |evaluation|
+                evaluation.clusterer = self
+                evaluation.evaluate_clusterer(test_instances)
+              end
             end
           end
 
-          def evaluate(test_instances)
-            ensure_trained_with_instances!
+          if instance_methods.include?(:cluster_instance)
+            def cluster(instance_or_values)
+              ensure_trained_with_instances!
 
-            ClusterEvaluation.new.tap do |evaluation|
-              evaluation.clusterer = self
-              evaluation.evaluate_clusterer(test_instances)
+              instance = clusterable_instance_from(instance_or_values)
+              cluster_instance(instance)
             end
           end
-        end
 
-        if instance_methods.include?(:cluster_instance)
-          def cluster(instance_or_values)
-            ensure_trained_with_instances!
+          if instance_methods.include?(:update_clusterer)
+            def add_training_instance(instance)
+              training_instances.add(instance)
+              update_clusterer(instance)
 
-            instance = clusterable_instance_from(instance_or_values)
-            cluster_instance(instance)
-          end
-        end
-
-        if instance_methods.include?(:update_clusterer)
-          def add_training_instance(instance)
-            training_instances.add(instance)
-            update_clusterer(instance)
-
-            self
-          end
+              self
+            end
 
-          def add_training_data(data)
-            values   = self.training_instances.internal_values_of(data)
-            instance = Weka::Core::DenseInstance.new(values)
-            add_training_instance(instance)
+            def add_training_data(data)
+              values   = training_instances.internal_values_of(data)
+              instance = Weka::Core::DenseInstance.new(values)
+              add_training_instance(instance)
+            end
           end
-        end
 
-        if instance_methods.include?(:distribution_for_instance)
-          def distribution_for(instance_or_values)
-            ensure_trained_with_instances!
+          if instance_methods.include?(:distribution_for_instance)
+            def distribution_for(instance_or_values)
+              ensure_trained_with_instances!
 
-            instance = clusterable_instance_from(instance_or_values)
-            distribution_for_instance(instance).to_a
+              instance = clusterable_instance_from(instance_or_values)
+              distribution_for_instance(instance).to_a
+            end
           end
-        end
 
-        private
+          private
 
-        def ensure_trained_with_instances!
-          return unless training_instances.nil?
+          def ensure_trained_with_instances!
+            return unless training_instances.nil?
 
-          error   = 'Clusterer is not trained with Instances.'
-          hint    = 'You can set the training instances with #train_with_instances.'
-          message = "#{error} #{hint}"
+            error   = 'Clusterer is not trained with Instances.'
+            hint    = 'You can set the training instances with #train_with_instances.'
+            message = "#{error} #{hint}"
 
-          raise UnassignedTrainingInstancesError, message
-        end
+            raise UnassignedTrainingInstancesError, message
+          end
 
-        def clusterable_instance_from(instance_or_values)
-          attributes = training_instances.attributes
-          instances  = Weka::Core::Instances.new(attributes: attributes)
+          def clusterable_instance_from(instance_or_values)
+            attributes = training_instances.attributes
+            instances  = Weka::Core::Instances.new(attributes: attributes)
 
-          instances.add_instance(instance_or_values)
-          instances.first
+            instances.add_instance(instance_or_values)
+            instances.first
+          end
         end
       end
-
     end
   end
 end
-

data/lib/weka/concerns.rb

@@ -1,4 +1,3 @@
-require 'active_support/concern'
 require 'weka/concerns/buildable'
 require 'weka/concerns/describable'
 require 'weka/concerns/optionizable'
@@ -7,13 +6,11 @@ require 'weka/concerns/serializable'
 
 module Weka
   module Concerns
-    extend ActiveSupport::Concern
-
-    included do
-      include Buildable
-      include Describable
-      include Optionizable
-      include Persistent
+    def self.included(base)
+      base.include Buildable
+      base.include Describable
+      base.include Optionizable
+      base.include Persistent
     end
   end
 end

data/lib/weka/concerns/buildable.rb

@@ -1,19 +1,17 @@
-require 'active_support/concern'
-
 module Weka
   module Concerns
     module Buildable
-      extend ActiveSupport::Concern
+      def self.included(base)
+        base.extend ClassMethods
+      end
 
       module ClassMethods
-
         def build(&block)
           instance = new
           instance.instance_eval(&block) if block_given?
           instance
         end
       end
-
     end
   end
 end

data/lib/weka/concerns/describable.rb

@@ -1,12 +1,11 @@
-require 'active_support/concern'
-
 module Weka
   module Concerns
     module Describable
-      extend ActiveSupport::Concern
+      def self.included(base)
+        base.extend ClassMethods
+      end
 
       module ClassMethods
-
         def description
           new.global_info
         end

data/lib/weka/concerns/optionizable.rb

@@ -1,40 +1,40 @@
-require 'active_support/concern'
-
 module Weka
   module Concerns
     module Optionizable
-      extend ActiveSupport::Concern
+      def self.included(base)
+        base.extend(ClassMethods)
 
-      included do
-        java_import "weka.core.Utils"
+        base.class_eval do
+          java_import 'weka.core.Utils'
 
-        def use_options(*single_options, **hash_options)
-          joined_options = join_options(single_options, hash_options)
-          options        = Java::WekaCore::Utils.split_options(joined_options)
+          def use_options(*single_options, **hash_options)
+            joined_options = join_options(single_options, hash_options)
+            options        = Java::WekaCore::Utils.split_options(joined_options)
 
-          set_options(options)
-          @options = joined_options
-        end
+            set_options(options)
+            @options = joined_options
+          end
 
-        def options
-          @options || self.class.default_options
-        end
+          def options
+            @options || self.class.default_options
+          end
 
-        private
+          private
 
-        def join_options(*single_options, **hash_options)
-          [
-            join_single_options(*single_options),
-            join_hash_options(**hash_options)
-          ].reject(&:empty?).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_single_options(options)
-          options.map { |option| "-#{option.to_s.sub(/^-/, '')}" }.join(' ')
-        end
+          def join_single_options(options)
+            options.map { |option| "-#{option.to_s.sub(/^-/, '')}" }.join(' ')
+          end
 
-        def join_hash_options(options)
-          options.map { |key, value| "-#{key} #{value}" }.join(' ')
+          def join_hash_options(options)
+            options.map { |key, value| "-#{key} #{value}" }.join(' ')
+          end
         end
       end
 
@@ -43,7 +43,6 @@ module Weka
           new.get_options.to_a.join(' ')
         end
       end
-
     end
   end
 end

data/lib/weka/concerns/persistent.rb

@@ -1,16 +1,11 @@
-require 'active_support/concern'
-
 module Weka
   module Concerns
     module Persistent
-      extend ActiveSupport::Concern
-
-      included do
-        if self.respond_to?(:__persistent__=)
-          self.__persistent__ = true
+      def self.included(base)
+        base.class_eval do
+          self.__persistent__ = true if respond_to?(:__persistent__=)
         end
       end
-
     end
   end
 end

data/lib/weka/concerns/serializable.rb

@@ -1,17 +1,15 @@
-require 'active_support/concern'
 require 'weka/core/serialization_helper'
 
 module Weka
   module Concerns
     module Serializable
-      extend ActiveSupport::Concern
-
-      included do
-        def serialize(filename)
-          Weka::Core::SerializationHelper.write(filename, self)
+      def self.included(base)
+        base.class_eval do
+          def serialize(filename)
+            Weka::Core::SerializationHelper.write(filename, self)
+          end
         end
       end
-
     end
   end
-end
+end

data/lib/weka/core/attribute.rb

@@ -1,13 +1,73 @@
+require 'weka/concerns/persistent'
+
 module Weka
   module Core
-    java_import "weka.core.Attribute"
+    java_import 'weka.core.Attribute'
 
     class Attribute
+      include Weka::Concerns::Persistent
+
+      TYPES = %i(numeric nominal string date).freeze
+
+      class << self
+        def new_numeric(name)
+          new(name.to_s)
+        end
+
+        def new_nominal(name, values)
+          new(name.to_s, Array(values).map(&:to_s))
+        end
+
+        def new_date(name, format)
+          new(name.to_s, format.to_s)
+        end
+
+        ##
+        # Creates a new Attribute instance of type string.
+        #
+        # The java class defines the same constructor:
+        # Attribute(java.lang.String, java.util.List<java.lang.String>)
+        # for nominal and string attributes and handles the type internally
+        # based on the second argument.
+        #
+        # In Java you would write following code to create a string Attribute:
+        #   Attribute attribute = new Attribute("name", (FastVector) null);
+        #
+        # When we use a similar approach in JRuby:
+        #   attribute = Attribute.new('name', nil)
+        # then a Java::JavaLang::NullPointerException is thrown.
+        #
+        # Thus, we use refelection here and call the contructor explicitly, see
+        # https://github.com/jruby/jruby/wiki/CallingJavaFromJRuby#constructors
+        #
+        # The object returned from Java constructor only has class
+        # Java::JavaObject so we need to cast it to the proper class
+        #
+        # See also:
+        # https://stackoverflow.com/questions/1792495/casting-objects-in-jruby
+        def new_string(name)
+          constructor = Attribute.java_class.declared_constructor(
+            java.lang.String,
+            java.util.List
+          )
+
+          constructor.new_instance(name.to_s, nil).to_java(Attribute)
+        end
+      end
 
       def values
         enumerate_values.to_a
       end
 
+      ##
+      # Returns the string representation of the attribute's type.
+      # Overwrites the weka.core.Attribute type Java method, which returns an
+      # integer representation of the type based on the defined type constants.
+      def type
+        self.class.type_to_string(self)
+      end
+
+      ##
       # The order of the if statements is important here, because a date is also
       # a numeric.
       def internal_value_of(value)
@@ -15,10 +75,8 @@ module Weka
         return Float::NAN                 if [nil, '?'].include?(value)
         return parse_date(value.to_s)     if date?
         return value.to_f                 if numeric?
-        return index_of_value(value.to_s) if nominal?
+        return index_of_value(value.to_s) if nominal? || string?
       end
     end
-
-    Weka::Core::Attribute.__persistent__ = true
   end
 end