evoc 3.5.0

data/lib/evoc/experiment.rb

@@ -0,0 +1,239 @@
+module Evoc
+  class Experiment
+    include Logging
+    attr_accessor :opts
+
+    @@logger_level = :error
+
+    def initialize(opts = Hash.new)
+      self.opts = opts
+      # Set logger level
+      Logging.set_level(self.opts[:logger_level])
+      logger.debug "Initialized experiment with options: #{opts}"
+      # setup history
+      if !opts[:transactions].nil?
+        Evoc::HistoryStore.initialize(path: self.opts[:transactions],case_id: self.opts[:case_id], granularity: self.opts[:granularity])
+      end
+    end
+
+    def sample_transactions
+      STDERR.puts "Sampling transactions.."
+      # by default we can sample from the whole history
+      sampling_history = Evoc::HistoryStore.base_history
+      sample = []
+      # filter out transactions larger than X
+      if !self.opts[:maximum_commit_size].nil?
+        STDERR.puts "Only sampling txes smaller than #{self.opts[:maximum_commit_size]}"
+        sampling_history = sampling_history.clone_with_subset(0,sampling_history.size-1,self.opts[:maximum_commit_size])
+      end
+      # only sample transactions that have at least 'minimum_history' previous history
+      if !self.opts[:minimum_history].nil?
+        STDERR.puts "Only sampling txes with at least #{self.opts[:minimum_history]} previous txes (history)"
+        if self.opts[:minimum_history] >= sampling_history.size-1
+          raise ArgumentError, "The history you provided (#{self.opts[:transactions]}), only contains #{sampling_history.size}, not enough to sample with a minimum history set to #{self.opts[:minimum_history]}. Perhaps also #{self.opts[:maximum_commit_size]} must be increased."
+        end
+        sampling_history = sampling_history.clone_with_subset(self.opts[:minimum_history],sampling_history.size-1)
+      end
+      # group the txes by size
+      groups = sampling_history.group_by {|tx| tx.size}
+      # sort the sample_groups option to reduce the need for maintaining control over which txes that have been sampled
+      # i.e., random sampling is done first, then the sampled txes are removed from the sampling
+      tx_sizes_to_sample_from = self.opts[:sample_groups].sort_by(&:to_s)
+      tx_sizes_to_sample_from.each do |group_size|
+        if group_size == '*'
+          # TODO: > 2 should be generalized to > X
+          txes_larger_than_one = sampling_history.select {|tx| tx.size > 2}.map(&:id)
+          sampled_ids = txes_larger_than_one.sample(self.opts[:sample_size])
+          sample << sampled_ids
+          STDERR.puts "Sampled #{sampled_ids.size} txes from the whole history"
+          # remove sampled txes from sampling_history
+          filtered_hist = sampling_history.reject {|tx| sampled_ids.include? tx.id}
+          sampling_history.clear
+          filtered_hist.each {|tx| sampling_history << tx}
+        elsif group_size.to_i
+          # check if there were any txes of this size
+          if group = groups[group_size.to_i]
+            if group.size < self.opts[:sample_size]
+              logger.warn "Only #{group.size} transactions found of size #{group_size}, asked for #{self.opts[:sample_size]}"
+            end
+            sampled_ids = group.sample(self.opts[:sample_size]).map(&:id)
+            sample << sampled_ids
+            STDERR.puts "Sampled #{sampled_ids.size} txes of size #{group_size}"
+          else
+            logger.warn "No transactions found of size #{group_size}, asked for #{self.opts[:sample_size]} (minimum history: #{self.opts[:minimum_history]})"
+          end
+        else
+          raise ArgumentError.new, "Tx size for sampling must either be specified by an Integer or '*' (was #{group_size}:#{group_size.class})"
+        end
+      end
+      sample.flatten.uniq
+    end
+
+
+    ##
+    # Generates a CSV of queries according to the given options
+    #
+    # CSV HEADER:
+    #
+    # tx_id, query
+    #
+    def generate_queries
+      ##
+      # WRITE CSV HEADER
+      CSV {|row| row << %W(tx_id query)}
+
+      ###
+      # Iterate over sampled tx ids
+      CSV.foreach(self.opts[:transaction_ids_path], headers: true) do |row|
+        tx_id = row['tx_id']
+        ##
+        # GET THE TRANSACTION
+        if tx = Evoc::HistoryStore.base_history.get_tx(id: tx_id, id_type: :id)
+          items = tx.items
+          tx_size = items.size
+          ##
+          # SAMPLE QUERIES
+          #
+          # We have 3 different strategies, which may produce the same sizes,
+          # but the same size does not need to be executed several times, 
+          # so duplicates are removed
+          specified_sizes = []
+          if !self.opts[:select].nil? then specified_sizes << self.opts[:select].map(&:to_i) end
+          if !self.opts[:reverse_select].nil? then specified_sizes << self.opts[:reverse_select].map {|i| tx_size-i.to_i} end
+          if !self.opts[:percentage].nil? then specified_sizes << self.opts[:percentage].map {|p| (p.to_f/100*tx_size).ceil} end
+          # filter out sizes <= 1
+          specified_sizes.flatten!.select! {|s| s > 0}
+          specified_sizes.uniq!
+
+          random_sizes = []
+          if self.opts[:random_select] then random_sizes << Random.new.rand(1..(tx_size-1)) end
+
+          sampled_queries = []
+          # only specified sizes
+          if random_sizes.empty? & !specified_sizes.empty?
+            sampled_queries = specified_sizes.map {|s| items.sample(s)}
+            # only random sizes
+          elsif !random_sizes.empty? & specified_sizes.empty?
+            sampled_queries = random_sizes.map {|s| items.sample(s)}
+            # random + specified = randomly sample in range defined by specified
+            # ex:
+            # specified = [1,3,10,20]
+            # tx size = 4
+            #
+            # 1. remove X in specified that are larger than or equal to 4
+            # 2. randomly select X in specified = Y
+            # 3. randomly select Y in tx
+          elsif !random_sizes.empty? & !specified_sizes.empty?
+            specified_sizes.select! {|s| (s < tx_size) & (s > 1)} #1.
+            if randomly_sampled_size = specified_sizes.sample #2.
+              sampled_queries = [items.sample(randomly_sampled_size)] #3.
+            end
+          end
+
+          if sampled_queries.empty?
+            logger.warn "Unable to generate query from tx: #{items}, with params #{self.opts}"
+          end
+
+          ##
+          # WRITE CSV
+          sampled_queries.each do |query| 
+            if query.size == tx_size
+              logger.debug "The size of the sampled query was equal to the size of the transaction, skipping.. Tx ID: #{tx_id}. Query size: #{query.size}"
+              next
+            end
+            CSV {|row| row << [tx_id,query.join(',')]}
+          end
+        else
+          raise ArgumentError, "The tx with id '#{tx_id}' was not found in the history: #{self.opts[:transactions]}, wrong file?"
+        end
+      end
+
+      #TODO  possibly move this to execution
+      #############################################
+      # Filter the generated queries if requested #
+      #############################################
+      #
+      #
+      #      logger.debug "Number of queries before filtering: #{query_store.size}"
+      #
+      #      if self.opts[:filter_expected_outcome]
+      #        STDERR.puts "Filtering expected outcome.."
+      #        init_size = query_store.size
+      #        query_store.filter_expected_outcome!
+      #        STDERR.puts "Had to remove #{init_size - query_store.size} queries as a result of the expected outcome now being empty"
+      #      end
+      #      if query_store.empty?
+      #        STDERR.puts "WARNING: Returning 0 queries (maybe increase sample size?)"
+      #      end
+    end
+
+    ##
+    # Execute a set of scenarios
+    #
+    # @return: json lines stream to stdout (http://jsonlines.org/)
+    def execute_scenarios
+
+      ######
+      # Setup factors
+      #####
+
+      # Factor: model size aka model/learning/history size
+      factor_model_size = self.opts[:model_size].nil? ? nil : self.opts[:model_size].map {|s| [ 'model_size',s ]}
+      # Factor: Max size aka filtering constraint on history
+      factor_max_size = self.opts[:max_size].nil? ? nil : self.opts[:max_size].map {|s| [ 'max_size',s ]}
+      # Factor: Model age aka number of commits between query and last tx in history
+      factor_model_age = self.opts[:model_age].nil? ? nil : self.opts[:model_age].map {|s| [ 'model_age',s ]}
+      # Factor: Algorithm
+      factor_algorithms = self.opts[:algorithms].nil? ? nil : self.opts[:algorithms].map {|a| ['algorithm',a]}
+      # Factor: Measures
+      factor_measures = self.opts[:measures].map {|c| ['measures',c]}
+      # Factor: Aggregator
+      # if aggregation is requested, we also assume that no aggregation wants to be tested
+      # the non-aggregation rows are specified with 'aggregator' == nil
+      factor_aggregators = self.opts[:aggregators].nil? ? nil : (self.opts[:aggregators]+[nil]).map {|a| ['aggregator',a]}
+      # deprecated factor, allways set to 1 for backwards compatibility
+      # factor_permutation = self.opts[:permutation].nil? ? nil : (1..self.opts[:permutation]).to_a.map {|p| [ 'permutation',p ]}
+      factor_permutation =  [[ 'permutation',1 ]]
+
+      ####
+      # Iterate over the queries provided and execute each query in each scenario
+      #
+      # queries CSV header:
+      # tx_id,tx_index,tx,query,query_size,expected_outcome,expected_outcome_size
+
+      # Count the number of lines so we can properly format the output json
+      num_lines = File.read(self.opts[:queries]).each_line.count-1
+      current_line = 1
+
+      factors = [factor_model_size,factor_max_size,factor_model_age,factor_algorithms,factor_measures,factor_permutation,factor_aggregators].compact
+      num_of_scenarios = factors.inject(1) {|product,f| product * f.size}
+      CSV.foreach(self.opts[:queries], headers: true) do |query|
+        # abort if the failsafe file is present 
+        if !self.opts[:fail_safe].nil?
+          if File.exists?(self.opts[:fail_safe])
+            $stderr.puts "\nFail safe detected, exiting.."
+            break
+          end
+        end
+        current_scenario = 1
+        # - compact removes nil values (not used factors)
+        # - the splat operator '*' turns the array into parameters for #product
+        # - the block form of #product makes it lazy (i.e., the whole cartesian product isn't generated at once)
+        factors.first.product(*factors[1..-1]).each do |scenario|
+          # Print progress to stderr
+          STDERR.print "(#{self.opts[:case_id]}) Executing scenario #{current_scenario} of #{num_of_scenarios} on query #{current_line} of #{num_lines}                             \r"
+
+          params = query.to_h.merge(scenario.to_h)
+          params[:case_id] = self.opts[:case_id]
+          params[:granularity] = self.opts[:granularity]
+          # initialize scenario
+          q =  Evoc::Scenario.new(params)
+          $stdout.puts  q.call(evaluators: self.opts[:evaluators]).to_json
+          current_scenario += 1
+        end
+        current_line += 1
+      end
+      STDERR.puts "\n(#{self.opts[:case_id]}) DONE"
+    end
+  end
+end

data/lib/evoc/hash.rb

@@ -0,0 +1,56 @@
+class Hash
+  include Logging
+
+  def convert_values(except: [],converter: Rational, convert_empty: false)
+    logger.debug "Converter: #{converter}, Hash: #{self}"
+    if except.is_a?(Array)
+      Hash[self.map {|k, v|  
+        if except.include?(k)
+          [k,v]
+        else
+          # don't convert empty fields to avoid side-effects
+          # "".to_i is 0 for example
+          if convert_empty
+            [k, converter.method(converter.to_s).call(v)]
+          else
+            if v.to_s.empty?
+              [k,v]
+            else
+              [k, converter.method(converter.to_s).call(v)]
+            end
+          end
+        end}]
+    else
+      raise ArgumentError.new, "Specify an array of keys whose values you don't want to convert"
+    end
+  end
+
+  ##
+  # stolen from rails
+  # http://api.rubyonrails.org/classes/Hash.html
+  ##
+  def symbolize_keys
+    transform_keys{ |key| key.to_sym rescue key }
+  end
+
+  def symbolize_keys!
+    transform_keys!{ |key| key.to_sym rescue key }
+  end
+
+  def transform_keys
+    return enum_for(:transform_keys) unless block_given?
+    result = self.class.new
+    each_key do |key|
+      result[yield(key)] = self[key]
+    end
+    result
+  end
+
+  def transform_keys!
+    return enum_for(:transform_keys!) unless block_given?
+    keys.each do |key|
+      self[yield(key)] = delete(key)
+    end
+    self
+  end
+end

data/lib/evoc/history_store.rb

@@ -0,0 +1,53 @@
+module Evoc
+  class HistoryStore
+      extend Logging
+
+    # create accessors for class level instance variables
+    class << self
+      attr_accessor :tag, :history, :svd
+    end
+
+    def self.initialize(path:,case_id: 'CASEID_NOT_PROVIDED', granularity: 'mixed')
+        self.base_history = Evoc::TxStore.new(path: path,case_id: case_id, granularity: granularity)
+        self.tag = gen_tag(0,self.base_history.size,"all")
+        return self
+    end
+
+    def self.get_history(start_index,end_index,max_size=nil)
+      tag = gen_tag(start_index,end_index,max_size)
+      if self.tag.nil?
+          raise Evoc::Exceptions::NotInitialized.new, "The history store must be initialized with a base history before fetching subhistories"
+      elsif self.tag != tag
+        # new history
+        self.tag = tag
+        # create new subset
+        self.history = self.base_history.clone_with_subset(start_index,end_index,max_size)
+        logger.info "Caching new history | start_index: #{start_index}, end_index: #{end_index}, max_size: #{max_size}, actual filtered size: #{self.history.size}"
+        # make the history unmutable
+        self.history.freeze
+      end
+      self.history
+    end
+
+    def self.base_history=tx_store
+        @@base_history = tx_store.freeze
+    end
+
+    def self.base_history
+        @@base_history
+    end
+
+    def self.get_svd(start_index,end_index,max_size=nil)
+      tag = self.gen_tag(start_index,end_index,max_size)
+      if self.svd.nil? || (self.tag != tag)
+        self.svd = Evoc::SVD.new(get_history(start_index,end_index,max_size)) 
+      end
+      self.svd
+    end
+
+    private
+    def self.gen_tag(start_index,end_index,max_size)
+      start_index.to_s+end_index.to_s+max_size.to_s
+    end
+  end # HistoryStore
+end # Evoc

data/lib/evoc/hyper_rule.rb

@@ -0,0 +1,53 @@
+module Evoc
+  class HyperRule < Rule
+    attr_accessor :lhs, :rhs, :hyper_coefficient, :hyper_confidence
+
+    def initialize(rules,aggregator,measures)
+      if measures.nil? || measures.empty?
+        raise ArgumentError, "At least one measure must be provided when defining a new hyper rule"
+      end
+      self.lhs = rules.map(&:lhs).array_union
+      self.rhs = rules.map(&:rhs).array_union
+      self.tx_store = rules.first.tx_store
+      self.hyper_coefficient = rules.size
+      # aggregate measures
+      measures.each do |m|
+        logger.debug "Aggregating #{self.hyper_coefficient} rules on #{m}"
+        # check if its the hyper confidence
+        if m == 'm_hyper_confidence'
+          antecedent = self.tx_store.transactions_of_list(self.lhs)
+          consequent = self.tx_store.transactions_of_list(self.rhs)
+          numerator = (antecedent & consequent).size
+          denominator = antecedent.size
+          hyper_confidence = numerator/denominator
+          self.set_measure(m,hyper_confidence,hyper_measure: true)
+        else
+          begin
+            # get the 'm' measure of each rule 
+            m_measures = rules.map {|rule| rule.get_measure(m)}
+            # remove undefined measures
+            m_measures.reject! {|a| a.value.nil?}
+            # group the measures into negative and positive correlations
+            pos_correlation = m_measures.group_by {|a| a.value > Evoc::Rule.get_mid(m)}
+            positive_correlation = pos_correlation[true].nil?  ? 0 : Evoc::InterestingnessMeasureAggregator.new(m,pos_correlation[true]).method(aggregator).call.value
+            # add the agggregated measure
+            self.set_measure(m,positive_correlation,hyper_measure: true)
+
+            # add the hyper coefficient as a measure for aggregators called with '.._hc'
+            if !(aggregator =~ /_hc\z/).nil? 
+              self.set_measure('m_hyper_coefficient',hyper_coefficient,hyper_measure: true)
+            end
+
+          rescue Evoc::Exceptions::InterestingnessMeasure::NonFinite
+            logger.debug "Could not aggregate #{m} using #{aggregator}, aggregation produced a non-finite value, probably a range problem, setting measure value to nil"
+            self.set_measure(m,nil, hyper_measure: true)
+          end
+        end
+      end
+    end
+
+    def name
+      self.lhs.join(',') + " => " + self.rhs.join(',')
+    end
+  end
+end

data/lib/evoc/interestingness_measure.rb

@@ -0,0 +1,77 @@
+module Evoc
+  class InterestingnessMeasure
+    include Comparable, Logging
+    attr_accessor :type, :value, :min, :max, :mid, :hyper_measure
+
+    def initialize(type:,min:,mid:,max:,value: nil,hyper_measure: false)
+      @type = type
+      self.min  = min
+      self.max  = max
+      self.mid  = mid
+      self.hyper_measure = hyper_measure
+      if block_given?
+        self.value = yield
+      else
+        self.value = value
+      end
+    end
+
+    #def value
+    #  @value.nil? ? @value : @value
+    #end
+   
+    def min=m
+        @min = m
+    end
+    
+    def max=m
+        @max = m
+    end
+
+    def mid=m
+        @mid = m
+    end
+
+    def value=v
+      if v.nil?
+        @value = nil
+      elsif v.to_f.nan?
+        logger.warn "#{self.type}: #{v} was NAN"
+        @value = nil
+      else
+        @value = v
+        if !self.hyper_measure
+          if !v.between?(self.min,self.max)
+            logger.warn "#{self.type}: #{v} is not in the domain of [#{self.min},#{self.max}]"
+          end
+        end
+      end
+    end
+
+    def <=> other
+      return nil unless constr_equal_type other
+      self.value <=> other.value
+    end
+
+    def -@
+      -self.value
+    end
+
+    def finite?
+      self.value.finite?
+    end
+
+    def to_s
+      self.value.to_s
+    end
+
+    private
+    def constr_equal_type other
+      (self.class == other.class ? true : ( raise ArgumentError, "self: #{self.type}: #{self.class} was of different class than other: #{other.class}" ) ) &
+      (self.max == other.max     ? true : ( raise ArgumentError, "self: #{self.type}: #{self.max} had a different max than other: #{other.max}" ) ) &
+      (self.mid == other.mid     ? true : ( raise ArgumentError, "self: #{self.type}: #{self.mid} had a different mid than other: #{other.mid}" ) ) &
+      (self.min == other.min     ? true : ( raise ArgumentError, "self: #{self.type}: #{self.min} had a different min than other: #{other.min}" ) ) &
+      (self.type == other.type   ? true : ( raise ArgumentError, "self: #{self.type}: #{self.type}had a different type than other: #{other.type}" ) ) 
+    end
+  end
+end

data/lib/evoc/interestingness_measure_aggregator.rb

@@ -0,0 +1,147 @@
+module Evoc
+  class InterestingnessMeasureAggregator
+    attr_accessor :type,:min,:mid,:max,:values,:size
+
+    def initialize(type,values)
+      self.type     = type
+      self.min      = Evoc::InterestingnessMeasures.get_min(type)
+      self.mid      = Evoc::InterestingnessMeasures.get_mid(type)
+      self.max      = Evoc::InterestingnessMeasures.get_max(type)
+      self.values   = values
+      self.size     = values.size
+    end
+
+    ###
+    # Our own aggregation functions
+    
+    def hcg
+      agr = normalize_measures.inject {|tot,i| 
+        direction = i > 0 ? self.max-self.mid : self.min-self.mid
+        coefficient = direction.to_f.finite? ? (direction-tot)/direction : 1
+        tot + coefficient*i
+      } + self.mid
+      Evoc::InterestingnessMeasure.new(type: self.type, min: self.min, mid: self.mid, max: self.max, value: agr)
+    end
+
+    def hcg_hc
+      self.hcg
+    end
+
+    ##
+    # Aggregation functions borrowed from IR
+    
+    ##
+    # cumulative gain aka sum
+    def cg
+      aggregated = normalize_measures.inject(:+) + self.mid
+      Evoc::InterestingnessMeasure.new(type: self.type, min: self.min, mid: self.mid, max: self.max, value: aggregated)
+    end
+
+    # discounted CG
+    def dcg
+      agr = normalize_measures.first + normalize_measures[1..-1].each_with_index.inject(0) {|sum,(element,index)| sum + element/Math.log2(index+2)}
+      agr = agr + self.mid
+      Evoc::InterestingnessMeasure.new(type: self.type, min: self.min, mid: self.mid, max: self.max, value: agr)
+    end
+
+    # discounted CG2
+    def dcg2
+      agr = normalize_measures.first + normalize_measures[1..-1].each_with_index.inject(0) {|sum,(element,index)| 
+        sum + (element >= 0 ? (2**element-1)/Math.log2(index+2) : -(2**element.abs-1)/Math.log2(index+2))
+      }
+      agr = agr + self.mid
+      Evoc::InterestingnessMeasure.new(type: self.type, min: self.min, mid: self.mid, max: self.max, value: agr)
+    end
+
+#    def discounted_cg3
+#      agr = normalize_measures.each_with_index.inject(0) {|sum,(element,index)| 
+#        sum + element >= 0 ? (2**element-1)/Math.log2(index+2) : -(2**element.abs-1)/Math.log2(index+2)
+#      }
+#      agr = agr + self.mid
+#      Evoc::InterestingnessMeasure.new(type: self.type, min: self.min, mid: self.mid, max: self.max, value: agr)
+#    end
+#
+#    def discounted_cg4
+#      agr = normalize_measures.each_with_index.inject(0) {|sum,(element,index)| 
+#        sum + (2**element)/Math.log2(index+2)
+#      }
+#      agr = agr + self.mid
+#      Evoc::InterestingnessMeasure.new(type: self.type, min: self.min, mid: self.mid, max: self.max, value: agr)
+#    end
+#
+#    def discounted_cg5
+#      agr = normalize_measures.each_with_index.inject(0) {|sum,(element,index)| 
+#        sum + element == 0 ? 0 : (2**element)/Math.log2(index+2)
+#      }
+#      agr = agr + self.mid
+#      Evoc::InterestingnessMeasure.new(type: self.type, min: self.min, mid: self.mid, max: self.max, value: agr)
+#    end
+#
+#    def discounted_rank_cg
+#      agr = normalize_measures.each_with_index.inject(0) {|sum,(element,index)| 
+#        sum + element/(index+1)
+#      }
+#      agr = agr + self.mid
+#      Evoc::InterestingnessMeasure.new(type: self.type, min: self.min, mid: self.mid, max: self.max, value: agr)
+#    end
+#
+
+    def normalize_measures
+      self.values.map {|m| m - self.mid} 
+    end
+
+    ##
+    # values=
+    #
+    # set and sort by abs value
+    def values=(measures)
+      if measures.all? {|m| m.is_a?(Evoc::InterestingnessMeasure)}
+        @values = measures.map(&:value)
+      else
+        @values = measures
+      end
+      @values.map!(&:to_f)
+      @values.sort! {|x,y| y.abs<=>x.abs}
+    end
+
+    private
+    def constr_equal_type other
+      (self.class == other.class ? true : ( raise ArgumentError, "self: #{self.type}: #{self.class} was of different class than other: #{other.class}" ) ) &
+      (self.max == other.max     ? true : ( raise ArgumentError, "self: #{self.type}: #{self.max} had a different max than other: #{other.max}" ) ) &
+      (self.mid == other.mid     ? true : ( raise ArgumentError, "self: #{self.type}: #{self.mid} had a different mid than other: #{other.mid}" ) ) &
+      (self.min == other.min     ? true : ( raise ArgumentError, "self: #{self.type}: #{self.min} had a different min than other: #{other.min}" ) ) &
+      (self.type == other.type   ? true : ( raise ArgumentError, "self: #{self.type}: #{self.type}had a different type than other: #{other.type}" ) ) 
+#      ((self.value.round(2) >= self.mid) == (other.value.round(2) >= self.mid) ? true : ( raise ArgumentError, "#{self.type}: self: #{self.value} was on another side of the midpoint than other: #{other.value}, midpoint was #{self.mid}" ))
+    end
+
+    def constr_value_in_range(agr_val)
+      if !agr_val.between?(self.min,self.max)
+        #raise Evoc::Exceptions::AggregationError, "#{self.type}: #{agr_val} was not in range: [#{self.min},#{self.max}]"
+        logger.warn "#{self.type}: #{agr_val} was not in range: [#{self.min},#{self.max}]"
+      end
+    end
+
+    def constr_self_value_equal_mid
+      satisfied = self.value == self.mid
+      if satisfied
+        logger.warn "self value (#{self.value}) was equal to mid value (#{self.mid}) when aggregating #{self.type} measure, just returning other"
+      end
+      satisfied
+    end
+
+    def constr_other_value_equal_mid(other)
+      satisfied = other.value == self.mid
+      if satisfied
+        logger.warn "other value (#{other.value}) was equal to mid value (#{self.mid}) when aggregating #{self.type} measure, just returning self"
+      end
+      satisfied
+    end
+
+    def constr_other_absvalue_smaller_than_self_absvalue(self_value,other_value)
+      if other_value.abs > self_value.abs
+        #raise ArgumentError.new, "The absolute value of the right hand argument must always be smaller or equal to the absolute value of the left hand side. lhs was #{self_value}, rhs was #{other_value} (possibly normalized around 0)"
+        logger.warn "The absolute value of the right hand argument must always be smaller or equal to the absolute value of the left hand side. lhs was #{self_value}, rhs was #{other_value} (possibly normalized around 0)"
+      end
+    end
+  end
+end