kyanite 0.3.1

data/lib/kyanite/enumerable.rb

@@ -0,0 +1,7 @@
+
+require 'kyanite/enumerable/enumerable_enumerables'
+require 'kyanite/enumerable/enumerable_numerics'
+require 'kyanite/enumerable/enumerable_strings'
+require 'kyanite/enumerable/structure'
+
+

data/lib/kyanite/enumerable/enumerable_enumerables.rb

@@ -0,0 +1,70 @@
+
+module Enumerable
+
+ # In-place-Variante von transpose. 
+  def transpose!
+      self.replace(self.transpose)
+  end    
+
+
+end
+
+# Enumerable, EnumerableNumerics, EnumerableStrings, EnumerableEnumerables
+#
+# ==Aufzählungen aufzählbarer Objekte
+# Für zweidimensionale Enumerables bzw. Aufzählungen von Objekten, die wiederum aufzählbar sind.
+# Ein ArrayOfEnumerables inkludiert dieses Modul.
+# 
+module EnumerableEnumerables
+
+  # Macht das Enumerable rechteckig.
+  # Maßgeblich ist die erste Zeile.
+  #
+  # Tests und Beispiele siehe TestKyaniteEnumerableEnumerables.
+  def rectangle
+    qsize = self[0].size   
+    result = []
+    self.each do |zeile|
+      size_diff = qsize - zeile.size  
+      # so lassen oder zuschneiden      
+      if size_diff <= 0
+        result << zeile[0..qsize-1]
+      # ergänzen
+      else
+        result << zeile + ([nil] * size_diff)
+      end # if
+    end # each zeile   
+    result
+  end # def
+
+end
+
+# Array, ArrayOfNumerics, ArrayOfStrings, ArrayOfEnumerables
+#
+# Ein ArrayOfEnumerables ist ein Array mit inkludiertem Modul EnumerableEnumerables
+#
+class ArrayOfEnumerables < Array
+  include EnumerableEnumerables
+end
+
+
+class Array
+
+  # Liefert ein ArrayOfEnumerables (das ist ein Array mit inkludiertem Modul EnumerableEnumerables)
+  def to_array_of_enumerables
+    ArrayOfEnumerables.new(self)
+  end
+end
+
+
+class NilClass
+  def transpose!;                     nil;            end  
+  def transpose;                      nil;            end  
+  def rectangle;                      nil;            end  
+end
+
+
+
+
+
+

data/lib/kyanite/enumerable/enumerable_numerics.rb

@@ -0,0 +1,171 @@
+
+# Enumerable, EnumerableNumerics, EnumerableStrings, EnumerableEnumerables
+#
+# ==Aufzählungen numerischer Objekte
+# Ein ArrayOfNumerics inkludiert dieses Modul.
+#
+module EnumerableNumerics
+
+  
+# ======================================================================================
+# :section: Mittelwerte
+#  
+
+  # Arithmetrischer Mittelwert
+  # Tests und Beispiele siehe TestKyaniteEnumerableNumerics.
+  #    
+  def mean
+    self.inject(0.0) { |sum, i | sum += i } / self.length.to_f 
+  end
+  alias avg              mean
+  alias average          mean
+  alias mean_arithmetric mean
+ 
+  # Harmonischer Mittelwert
+  #
+  # Normalerweise ist der harmonische Mittelwert nur für positive Zahlen sinnvoll definiert.
+  # Mit der Option <tt>:allow_negative => true </tt>kann man aber auch negative Zahlen mit einbeziehen.
+  # Dann wird der harmonische Mittelwert aller positiven Elemente mit dem 
+  # harmonische Mittelwert aller negativen Elemente verrechnet (als gewichtetes arithmetisches Mittel).
+  #
+  # Tests und Beispiele siehe TestKyaniteEnumerableNumerics.
+  #    
+  def mean_harmonic( options={} )
+    return 0              if self.empty?  
+    return self.first     if self.size == 1
+    allow_negative = options[:allow_negative] || false
+    unless allow_negative
+      summe = 0
+      self.each { |x| summe += ( 1.0/x ) }
+      return self.size / summe
+      
+    else
+      positives = []
+      negatives = []
+      self.each do |e|
+        if e >= 0
+          positives << e
+        else
+          negatives << -e
+        end
+      end #each
+      if positives.size > 0 
+        if negatives.size > 0
+          return  ( positives.mean_harmonic(:allow_negative => false) * positives.size -
+                    negatives.mean_harmonic(:allow_negative => false) * negatives.size
+                  ) / (positives.size + negatives.size).to_f
+        else
+          return  positives.mean_harmonic(:allow_negative => false)
+        end
+      else
+        return   -negatives.mean_harmonic(:allow_negative => false)
+      end
+
+    end #if allow_negative
+  end #def 
+  
+ 
+  # Geometrischer Mittelwert 
+  def mean_geometric
+    self.product**( 1.0/self.size ) 
+  end  
+  
+
+  
+# ======================================================================================
+# :section: Summe, Produkt, Parallelschaltung
+#    
+  
+  
+  # Summe
+  #
+  # Methode darf nicht sum heißen, kollidiert sonst schnell mit ActiveRecord.
+  # Tests und Beispiele siehe TestKyaniteEnumerableNumerics.
+  #  
+  def summation
+    self.inject(0.0) { |sum, i | sum += i }  
+  end  
+  
+  
+  # Produkt
+  #  
+  # Tests und Beispiele siehe TestKyaniteEnumerableNumerics.
+  #    
+  def product
+    self.inject(1.0) { |prd, i | prd *= i }  
+  end   
+  alias prd product  
+  
+  
+  # Ergebnis entspricht der Parallelschaltung von Widerständen.
+  # Tests und Beispiele siehe TestKyaniteEnumerableNumerics.
+  #    
+  def parallel
+    mean_harmonic / size  
+  end
+    
+
+
+end #class
+
+
+
+# Array, ArrayOfNumerics, ArrayOfStrings, ArrayOfEnumerables
+#
+# Ein ArrayOfNumerics ist ein Array mit inkludiertem Modul EnumerableNumerics
+#
+class ArrayOfNumerics < Array
+  include EnumerableNumerics
+end
+
+
+
+class Array
+
+  # Liefert ein ArrayOfNumerics (das ist ein Array mit inkludiertem Modul EnumerableNumerics)
+  def to_array_of_numerics
+    ArrayOfNumerics.new(self)
+  end
+  
+end
+
+
+
+class NilClass
+  def average;                                  nil;            end  
+  def avg;                                      nil;            end  
+  def mean;                                     nil;            end  
+  def mean_arithmetric;                         nil;            end  
+  def mean_geometric;                           nil;            end  
+  def mean_harmonic(*a);                        nil;            end  
+  def parallel(*a);                             nil;            end  
+  def prd;                                      nil;            end  
+  def product;                                  nil;            end  
+  def sum;                                      nil;            end  
+  def summation;                                nil;            end  
+end
+
+
+# ==================================================================================
+# Ausprobieren
+#
+if $0 == __FILE__ 
+  require 'perception'
+  class Array
+    include EnumerableNumerics
+  end  
+
+
+
+
+
+
+
+
+end
+
+
+
+
+
+

data/lib/kyanite/enumerable/enumerable_strings.rb

@@ -0,0 +1,58 @@
+
+# Enumerable, EnumerableNumerics, EnumerableStrings, EnumerableEnumerables
+#
+# ==Aufzählungen textueller Objekte
+# Ein ArrayOfStrings inkludiert dieses Modul.
+# 
+module EnumerableStrings
+
+
+  # Bsp.: 
+  #  ['lut', 'lutm', 'lutmi', 'lutmil', 'lutmila', 'lutrika', 'lutrik', 'lutri', 'lutr', 'lut'].palindrom_rumpf  =>
+  #  ['lutm', 'lutmi', 'lutmil', 'lutmila', 'lutrika', 'lutrik', 'lutri', 'lutr']
+  # d.h. vorne und hinten wird alles Gleiche weggestrichen.
+  #
+  # Tests und Beispiele siehe TestKyaniteEnumerableStrings.
+  #
+  def palindrom_rumpf
+    result = self.dup
+    0.upto( size/2 - 1 ) do |i|
+      if result[0] == result[-1]
+        result.delete_at(0)   
+        result.delete_at(-1)  
+      end
+    end
+    result
+  end
+
+
+
+
+end
+
+
+
+# Array, ArrayOfNumerics, ArrayOfStrings, ArrayOfEnumerables
+#
+# Ein ArrayOfStrings ist ein Array mit inkludiertem Modul EnumerableStrings
+#
+class ArrayOfStrings < Array
+  include EnumerableStrings
+end
+
+
+
+class Array
+
+  # Liefert ein ArrayOfStrings (das ist ein Array mit inkludiertem Modul EnumerableStrings)
+  def to_array_of_strings
+    ArrayOfStrings.new(self)
+  end
+  
+end
+
+
+
+
+
+

data/lib/kyanite/enumerable/structure.rb

@@ -0,0 +1,170 @@
+
+# 
+# is_collection?
+#
+
+class Object
+
+  # Enthält ein Objekt mehrere Objekte?
+  # String und Range gelten nicht als Collection.
+  #
+  # Tests & Beispiele siehe TestKyaniteEnumerableStructure.
+  def is_collection?;                 false;          end
+end
+
+
+module Enumerable
+
+  # Enthält ein Objekt mehrere Objekte?
+  # String und Range gelten nicht als Collection.
+  #
+  # Tests & Beispiele siehe TestKyaniteEnumerableStructure.
+  def is_collection?;                 true;          end
+end
+
+
+class String # :nodoc:
+  def is_collection?;                 false;          end
+end
+
+
+class Range # :nodoc:
+  def is_collection?;                 false;          end
+end
+
+
+
+
+# 
+# Distribution
+#
+
+
+# Enumerable, EnumerableNumerics, EnumerableStrings, EnumerableEnumerables
+#
+# ==Allgemeine Aufzählungen
+# 
+module Enumerable
+
+  # Liefert die Verteilung der size 
+  # oder die Verteilung der class 
+  # oder die Verteilung eines anderen Merkmals der aufgezählten Elemente.
+  #
+  # Tests & Beispiele siehe TestKyaniteEnumerableStructure.
+  #
+  def distribution( mode = :size)
+    verteilung = Hash.new
+    each do | element |
+      value = element.respond(mode)
+      if verteilung.has_key?(value)
+        verteilung[value] += 1
+      else
+        verteilung[value] = 1
+      end # if      
+    end #each
+    verteilung.to_a.sort   
+  end
+  
+  
+  
+  
+# 
+# contentclass
+#  
+  
+  # Was für Objekte beinhaltet die Collection?
+  # Liefert die Klasse der Contentelemente, oder <tt>Object</tt> wenn es verschiedene sind. 
+  #  
+  # Parameter ist die Genauigkeit, mit der der Inhalt geprüft wird.
+  #  :precision  => 1      nur das erste Element wird geprüft
+  #  :precision  => 2      das erste und das letzte Element werden geprüft   (STANDARD)
+  #  :precision  => :all   alle Elemente werden geprüft
+  #  :ignore_nil => true   NilClass wird nicht aufgeführt                    (STANDARD)
+  #  :ignore_nil => false  NilClass wird mit aufgeführt  
+  #
+  # Tests & Beispiele siehe TestKyaniteEnumerableStructure.  
+  #
+  def contentclass( options={} )
+    precision  = options[:precision]    || 2
+    ignore_nil = options[:ignore_nil];  ignore_nil = true   if ignore_nil.nil?
+    return nil   if  self.empty? 
+    case precision
+    
+    when 1
+      result = self.first.class
+      if ( result == NilClass  &&  ignore_nil )
+        return self.compact.contentclass( :precision => precision, :ignore_nil => false  )
+      else
+        return result
+      end
+      
+    when 2
+      f = self.first.class    
+      l = self.last.class   
+      if ( (f == NilClass || l == NilClass) &&  ignore_nil )
+        return self.compact.contentclass( :precision => precision, :ignore_nil => false  )
+      end      
+      if f == l      
+        return f
+      else
+        result = f.ancestors & l.ancestors
+        #see result - [Object, Kernel, Precision, Perception::NumericI,  PP::ObjectMixin,  KyaniteKernel]
+        return Numeric      if result.include?(Numeric)
+        return Enumerable   if result.include?(Enumerable)
+        return Object
+      end
+      
+    when :all
+      unless ( self.kind_of?(Hash) || self.kind_of?(Dictionary) )
+        c = self.collect {|e| e.class}
+      else
+        c = self.collect {| key, value | value.class}      
+      end 
+      c = c - [NilClass]  if ignore_nil
+      c.uniq!  
+      if c.empty? 
+        return nil       if ignore_nil
+        return NilClass   
+      end
+      return c[0]       if c.size == 1 
+      result = c[0].ancestors
+      c[1..-1].each do |e|
+        result = result & e.ancestors
+      end
+      #see result - [Object, Kernel, Precision, Perception::NumericI,  PP::ObjectMixin,  KyaniteKernel]      
+      return Numeric      if result.include?(Numeric)
+      return Enumerable   if result.include?(Enumerable)
+      return Object
+
+    else # case precision
+      raise ArgumentError, ':precision should be 1, 2 or :all'
+    end #case
+    
+  end #def
+
+end #module
+
+
+
+
+
+
+# ==================================================================================
+# Ausprobieren
+#
+if $0 == __FILE__ 
+
+  require 'kyanite/smart_load_path'; smart_load_path
+  class Array
+    include Enumerable
+  end  
+  require 'perception'
+
+  test = [ ]
+  see test.contentclass(:precision => :all)
+
+  
+
+end
+
+