evoc 3.5.0

data/lib/evoc/interestingness_measures.rb

@@ -0,0 +1,882 @@
+module Evoc
+  module InterestingnessMeasures
+
+    VALUE_TYPE = Rational
+    # USE Rational(Math.log(1/3)).rationalize(0.001)
+
+    #
+    # methods that must be implemented in the class that uses this module as a mixin
+    #
+    def tx_store
+      raise NotImplementedError.new, "tx_store has not been implemented on the current class"
+    end
+
+    def lhs
+      raise NotImplementedError.new, "lhs has not been implemented on the current class"
+    end
+
+    def rhs
+      raise NotImplementedError.new, "rhs has not been implemented on the current class"
+    end
+
+    def name
+      raise NotImplementedError.new, "name has not been implemented on the current class"
+    end
+
+    ##
+    # class methods
+    #
+    # the following is a idiom/hack that enables also including class methods when a class includes this module
+    # (normally one would use 'extend')
+    #
+    ##
+    def self.included(base)
+      base.extend(ClassMethods)
+    end
+
+    def self.get_min(measure)
+      const_get(measure.to_s.upcase+"_MIN")
+    end
+
+    def self.get_max(measure)
+      const_get(measure.to_s.upcase+"_MAX")
+    end
+
+    def self.get_mid(measure)
+      const_get(measure.to_s.upcase+"_MID")
+    end
+
+    def self.measures
+      self.instance_methods.grep(/\Am_(.*)/)
+    end
+
+    def self.hyper_measures
+      self.instance_methods.grep(/\Am_(.*)/).select {|m| is_hyper_measure?(m)}
+    end
+
+    def self.is_hyper_measure?(m)
+      begin
+        const_get(m.to_s.upcase+"_HYPER_MEASURE")
+      rescue NameError
+        return false
+      end
+    end
+
+    module ClassMethods
+
+      def initialize_measure(measure, hyper_measure: false)
+        if block_given?
+          Evoc::InterestingnessMeasure.new(type: measure,min: get_min(measure),mid: get_mid(measure), max: get_max(measure), hyper_measure: hyper_measure) {
+            yield
+          }
+        else
+          Evoc::InterestingnessMeasure.new(type: measure,min: get_min(measure),mid: get_mid(measure), max: get_max(measure), hyper_measure: hyper_measure)
+        end
+      end
+
+      ##
+      # returns the list of interestingness measures which are implemented
+      def measures
+        self.instance_methods.grep(/\Am_(.*)/)
+      end
+
+      def p_measures
+        self.instance_methods.grep(/\Ap_(.*)/)
+      end
+
+      def csv_header
+        ['lhs','rhs'] + measures
+      end
+
+      def pretty_csv_header
+        ['lhs','rhs'] + measures.map {|m| m.to_s.gsub(/m_/,'')}
+      end
+
+      def get_min(measure)
+        const_get(measure.to_s.upcase+"_MIN")
+      end
+
+      def get_max(measure)
+        const_get(measure.to_s.upcase+"_MAX")
+      end
+
+      def get_mid(measure)
+        const_get(measure.to_s.upcase+"_MID")
+      end
+
+    end
+
+    def to_a
+      [lhs.join(',')] + [rhs.join(',')] + instantiated_measures.map {|m| self.get_measure(m).value}
+    end
+
+
+
+    ##
+    # a common getter for all measures  
+    #
+    # handles exceptions and converts the final measure to float
+    def get_measure(measure)
+      if m = self.method(measure).call
+        return m
+      else
+        raise NotImplementedError.new, "#{measure} not implemented"
+      end
+    rescue Evoc::Exceptions::MeasureCalculationError => e
+      logger.warn "#{measure} was undefined for #{self.name} on the current history, error: #{e}"
+      m = self.class.initialize_measure(measure)
+      self.instance_variable_set('@'+measure.to_s,m)
+      self.method(measure).call
+    end
+
+    def set_measure(measure,value,hyper_measure: false)
+      m = self.class.initialize_measure(measure, hyper_measure: hyper_measure) {value}
+      self.instance_variable_set('@'+measure.to_s,m)
+    end
+
+    ##
+    # manually set the probability p of this rule
+    def set_p(p,value)
+      self.instance_variable_set('@'+p.to_s,value)
+    end
+
+    ##
+    # @param [String] the p probability to get
+    def get_p(p)
+      p = self.method(p).call
+      if p_A < p_AB
+        raise Evoc::Exceptions::MeasureCalculationError, "p_A was smaller than p_AB"
+      elsif p_B < p_AB
+        raise Evoc::Exceptions::MeasureCalculationError, "p_B was smaller than p_AB"
+      elsif p_A == 0
+        raise Evoc::Exceptions::MeasureCalculationError, "p_A was 0"
+      elsif p_B == 0
+        raise Evoc::Exceptions::MeasureCalculationError, "p_B was 0"
+      elsif p_B > 1-p_A+p_AB
+        raise Evoc::Exceptions::MeasureCalculationError, "p_B mismatch with p_A and p_AB, (a #{p_a}, b #{p_B}, ab #{p_AB})"
+      elsif p_A > 1-p_B+p_AB
+        raise Evoc::Exceptions::MeasureCalculationError, "p_A mismatch with p_B and p_AB, (a #{p_a}, b #{p_B}, ab #{p_AB})"
+      end
+      return p
+    end
+
+    ##
+    # @return [Hash] a hash containing the p probabilities of this rule 
+    def get_p_values
+      values = Hash.new
+      Evoc::Rule.p_measures.each do |p|
+        values[p] = self.get_p(p)
+      end
+      return values
+    end
+
+    ##
+    # returns the measures which has been instantiated
+    def instantiated_measures
+      self.class.measures.select {|m| measure_instantiated?(m) }
+    end
+
+    ##
+    # Returns true if the measure has been instantiated
+    def measure_instantiated?(measure)
+      !self.instance_variable_get('@'+measure.to_s).nil?
+    end
+
+    ##
+    # NATIVE AGGREGATED MEASURES
+    #
+    # these measures are defined natively for aggregated rules
+    #
+    # e.g., 
+    # a -> c
+    # b -> c
+    # aggregated is: a,b -> c
+    #
+    # the listed measures are well defined also for the aggregated rule
+    #
+    # With the exception of the hyper coefficient, all other hyper measures
+    # are allways recalculated on request.
+    # I.e., they use '@m = ..' rather than '@m ||= ..'
+    # This way they will overwrite the aggregation that has been calculated on the hyper rule 
+    # (which is done for the concentional rules)
+    
+    
+    ##
+    # Hyper Coefficient
+    # The number of rules used to form a hyper rule
+    M_HYPER_COEFFICIENT_MIN = 0
+    M_HYPER_COEFFICIENT_MID = 0
+    M_HYPER_COEFFICIENT_MAX = Float::INFINITY
+    M_HYPER_COEFFICIENT_HYPER_MEASURE = true
+    def m_hyper_coefficient
+      @m_hyper_coefficient = self.class.initialize_measure(__method__) {
+        if self.respond_to?(:hyper_coefficient)
+          self.hyper_coefficient
+        else
+          0
+        end
+      }
+    end
+    
+    ##
+    # Hyper confidence
+    #
+    # A confidence like measure that is well defined for all hyper rules
+    #
+    # "the number of times something in rhs changed with something in lhs, divided by the number of times something in lhs changed"
+    ##
+    #M_HYPER_CONFIDENCE_MIN = 0
+    #M_HYPER_CONFIDENCE_MID = 0
+    #M_HYPER_CONFIDENCE_MAX = 1
+    #M_HYPER_CONFIDENCE_HYPER_MEASURE = true
+    #def m_hyper_confidence
+    #  @m_hyper_confidence ||= self.class.initialize_measure(__method__) {
+    #    # hyper confidence is equal to the confidence for non hyper rules
+    #    if !self.respond_to?(:hyper_confidence)
+    #      m_confidence.value
+    #    else
+    #      raise ArgumentError, "Asked for the hyper confidence of a hyper rule, the value was not initialized, but should have been when creating the hyper rule"
+    #    end
+    #  }
+    #end
+
+    
+    ##
+    # INTERESTINGNESS MEASURES
+    #
+    # if not stated otherwise, all of the implementations are based on 
+    # Michael Hahslers overview at:
+    # http://michael.hahsler.net/research/association_rules/measures.html
+    #
+    ##
+    
+    M_SUPPORT_MIN = 0
+    M_SUPPORT_MID = 0
+    M_SUPPORT_MAX = 1
+    def m_support
+      @m_support ||= self.class.initialize_measure(__method__) {
+        p_AB
+      }
+    end 
+
+    M_CONFIDENCE_MIN = 0
+    M_CONFIDENCE_MID = 0
+    M_CONFIDENCE_MAX = 1
+    def m_confidence
+      @m_confidence ||= self.class.initialize_measure(__method__) {
+        p_BgivenA
+      }
+    end
+
+    M_COVERAGE_MIN = 0
+    M_COVERAGE_MID = 0
+    M_COVERAGE_MAX = 1
+    def m_coverage
+      @m_coverage ||= self.class.initialize_measure(__method__) {
+        p_A
+      }
+    end
+
+    M_PREVALENCE_MIN = 0
+    M_PREVALENCE_MID = 0
+    M_PREVALENCE_MAX = 1
+    def m_prevalence
+      @m_prevalence ||= self.class.initialize_measure(__method__) {
+        p_B
+      }
+    end
+
+    M_RECALL_MIN = 0
+    M_RECALL_MID = 0
+    M_RECALL_MAX = 1
+    def m_recall
+      @m_recall ||= self.class.initialize_measure(__method__) {
+        p_AgivenB
+      }
+    end
+
+    M_SPECIFICITY_MIN = 0
+    M_SPECIFICITY_MID = 0
+    M_SPECIFICITY_MAX = 1
+    def m_specificity
+      @m_specificity ||= self.class.initialize_measure(__method__) {
+        p_notBgivennotA
+      }
+    end
+
+    M_LIFT_MIN = 0
+    M_LIFT_MID = 1
+    M_LIFT_MAX = Float::INFINITY
+    ##
+    # aka interest
+    # Lift measures how many times more often X and Y occur 
+    # together than expected if they where statistically independent
+    ##
+    def m_lift
+      @m_lift ||= self.class.initialize_measure(__method__) {
+        p_AB/(p_A*p_B)
+      }
+    end
+
+    M_LEVERAGE_MIN = -1
+    M_LEVERAGE_MID = 0
+    M_LEVERAGE_MAX = 1
+    ##
+    # Leverage measures the difference of X and Y appearing together 
+    # in the data set and what would be expected if X and Y where statistically dependent
+    ##
+    def m_leverage
+      @m_leverage ||= self.class.initialize_measure(__method__) {
+        p_BgivenA - (p_A*p_B)
+      }
+    end
+
+    M_PIATETSKY_SHAPIRO_MIN = -0.25
+    M_PIATETSKY_SHAPIRO_MID = 0
+    M_PIATETSKY_SHAPIRO_MAX = 0.25
+    def m_piatetsky_shapiro
+      @m_piatetsky_shapiro ||= self.class.initialize_measure(__method__) {
+        p_AB - p_A*p_B
+      }
+    end
+
+    # aka: pavillion index, centered confidence
+    M_ADDED_VALUE_MIN = -0.5
+    M_ADDED_VALUE_MID = 0
+    M_ADDED_VALUE_MAX = 1
+    def m_added_value
+      @m_added_value ||= self.class.initialize_measure(__method__) {
+        p_BgivenA - p_B
+      }
+    end
+
+    M_CAUSAL_CONFIDENCE_MIN = 0
+    M_CAUSAL_CONFIDENCE_MID = 0
+    M_CAUSAL_CONFIDENCE_MAX = 1
+    def m_causal_confidence
+      @m_causal_confidence ||= self.class.initialize_measure(__method__) {
+        (1.to_r/2)*(p_BgivenA + p_notAgivennotB)
+      }
+    end
+
+    M_CAUSAL_SUPPORT_MIN = 0
+    M_CAUSAL_SUPPORT_MID = 0
+    M_CAUSAL_SUPPORT_MAX = 1
+    def m_causal_support
+      @m_causal_support ||= self.class.initialize_measure(__method__) {
+        p_AB + p_notA_notB
+      }
+    end
+
+    M_DESCRIPTIVE_CONFIRMED_CONFIDENCE_MIN = -1
+    M_DESCRIPTIVE_CONFIRMED_CONFIDENCE_MID = 0
+    M_DESCRIPTIVE_CONFIRMED_CONFIDENCE_MAX = 1
+    def m_descriptive_confirmed_confidence
+      @m_descriptive_confirmed_confidence ||= self.class.initialize_measure(__method__) {
+        p_BgivenA - p_notBgivenA
+      }
+    end
+
+    M_DIFFERENCE_OF_CONFIDENCE_MIN = -1
+    M_DIFFERENCE_OF_CONFIDENCE_MID = 0
+    M_DIFFERENCE_OF_CONFIDENCE_MAX = 1
+    def m_difference_of_confidence
+      @m_difference_of_confidence ||= self.class.initialize_measure(__method__) {
+        p_BgivenA - p_BgivennotA
+      }
+    end
+
+    M_RELATIVE_RISK_MIN = 0
+    M_RELATIVE_RISK_MID = 0
+    M_RELATIVE_RISK_MAX = Float::INFINITY
+    def m_relative_risk
+      @m_relative_risk ||= self.class.initialize_measure(__method__) {
+        if p_BgivennotA == 0
+          Float::INFINITY
+        else
+          p_BgivenA/p_BgivennotA
+        end
+      }
+    end
+
+    M_JACCARD_MIN = 0
+    M_JACCARD_MID = 0
+    M_JACCARD_MAX = 1
+    def m_jaccard
+      @m_jaccard ||= self.class.initialize_measure(__method__) {
+        p_AB/(p_A+p_B-p_AB)
+      }
+    end
+
+
+    M_IMBALANCE_RATIO_MIN = 0
+    M_IMBALANCE_RATIO_MID = 0
+    M_IMBALANCE_RATIO_MAX = 1
+    ##
+    # IR gauges the degree of imbalance between two events that the lhs and the rhs are contained in a transaction.
+    # The ratio is close to 0 if the conditional probabilities are similar (i.e., very balanced) and close to 1 if they are very different
+    ##
+    def m_imbalance_ratio
+      @m_imbalance_ratio ||= self.class.initialize_measure(__method__) {
+        numerator = (p_AgivenB - p_BgivenA).abs
+        denominator = (p_AgivenB + p_BgivenA - p_AgivenB*p_BgivenA)
+        if denominator == 0
+          if numerator ==  0
+            0
+          else
+            raise Evoc::MeasureCalculationError.new, "Numerator was not 0 when denominator was 0 when calculating imbalance ratio"
+          end
+        else
+          numerator/denominator
+        end
+      }
+    end
+
+    M_ODDS_RATIO_MIN = 0
+    M_ODDS_RATIO_MID = 1
+    M_ODDS_RATIO_MAX = Float::INFINITY
+    ##
+    # The odds of finding X in transactions which contain Y divided by the
+    # odds of finding X in transactions which do not contain Y
+    ##
+    def m_odds_ratio
+      @m_odds_ratio ||= self.class.initialize_measure(__method__) {
+        numerator = p_AB*p_notA_notB
+        denominator = p_A_notB*p_notA_B
+        if denominator == 0
+          Float::INFINITY
+        else
+          numerator/denominator
+        end
+      }
+    end
+
+    M_YULES_Q_MIN = -1
+    M_YULES_Q_MID = 0
+    M_YULES_Q_MAX = 1
+    def m_yules_q
+      @m_yules_q ||= self.class.initialize_measure(__method__) {
+        odds_ratio = self.m_odds_ratio.value
+        if !odds_ratio.nil?
+          if odds_ratio.to_f.finite?
+            (odds_ratio - 1)/(odds_ratio + 1)
+          else
+            # -1 if odds ratio -inf
+            # 1 if odds ratio +inf
+            odds_ratio.to_f.infinite?
+          end
+        else
+          raise Evoc::MeasureCalculationError.new, "Odds ratio was nil when calculating yules q"
+        end
+      }
+    end
+
+    M_YULES_Y_MIN = -1
+    M_YULES_Y_MID = 0
+    M_YULES_Y_MAX = 1
+    def m_yules_y
+      @m_yules_y ||= self.class.initialize_measure(__method__) {
+        odds_ratio = self.m_odds_ratio.value
+        if !odds_ratio.nil?
+          if odds_ratio.to_f.finite?
+            ((Math.sqrt(odds_ratio).rationalize) - 1)/((Math.sqrt(odds_ratio).rationalize) + 1)
+          else
+            odds_ratio.to_f.infinite?
+          end
+        else
+          raise Evoc::Exceptions::MeasureCalculationError.new, "Odds ratio was nil when calculating yules y"
+        end
+      }
+    end
+
+    # from Tan2004
+    M_KLOSGEN_MIN = -1
+    M_KLOSGEN_MID = 0
+    M_KLOSGEN_MAX = 1
+    def m_klosgen
+      @m_klosgen ||= self.class.initialize_measure(__method__) {
+        (Math.sqrt(p_AB)*[(p_BgivenA-p_B),p_AgivenB-p_A].max).rationalize
+      }
+    end
+
+    M_KULCZYNSKI_MIN = 0
+    M_KULCZYNSKI_MID = 0
+    M_KULCZYNSKI_MAX = 1
+    ##
+    # Calculate the null-invariant Kulczynski measure with a preference for skewed patterns.
+    ##
+    def m_kulczynski
+      @m_kulczynski ||= self.class.initialize_measure(__method__) {
+        (p_AB/2)*((1/p_A)+(1/p_B))
+      }
+    end
+
+    M_CONVICTION_MIN = 0
+    M_CONVICTION_MID = 0
+    M_CONVICTION_MAX = Float::INFINITY
+    def m_conviction
+      @m_conviction ||= self.class.initialize_measure(__method__) {
+        numerator = p_A*p_notB
+        denominator = p_A_notB
+        if denominator == 0
+          if numerator == 0
+            0
+          else
+            Float::INFINITY
+          end
+        else
+          numerator/denominator
+        end
+      }
+    end
+
+    ##
+    # uses 2 coefficients two weight the importance of the two factors
+    # k : dependency
+    # m : generality
+    M_INTERESTINGNESS_WEIGHTING_DEPENDENCY_MIN = 0
+    M_INTERESTINGNESS_WEIGHTING_DEPENDENCY_MID = 0
+    M_INTERESTINGNESS_WEIGHTING_DEPENDENCY_MAX = 1
+    def m_interestingness_weighting_dependency
+      k = 2
+      m = 2
+      @m_interestingness_weighting_dependency ||= self.class.initialize_measure(__method__) {
+        ((p_BgivenA/p_B)**(k-1))*(p_AB**m)
+      }
+    end
+
+    M_COLLECTIVE_STRENGTH_MIN = -Float::INFINITY
+    M_COLLECTIVE_STRENGTH_MID = 1
+    M_COLLECTIVE_STRENGTH_MAX = Float::INFINITY
+    # range from Aggarwal1998
+    def m_collective_strength
+      @m_collective_strength ||= self.class.initialize_measure(__method__) {
+        n1 = (p_AB+p_notBgivennotA)
+        d1 = (p_A*p_B+p_notA*p_notB)
+        first = ((d1 == 0) ? n1/d1.to_f : n1/d1)
+        n2 = (1-p_A*p_B-p_notA*p_notB)
+        d2 = (1-p_AB-p_notBgivennotA)
+        second = ((d2 == 0) ? n2/d2.to_f : n2/d2)
+        first * second
+      }
+    end
+
+    M_GINI_INDEX_MIN = 0
+    M_GINI_INDEX_MID = 0
+    M_GINI_INDEX_MAX = 1
+    ##
+    # Measures quadratic entropy 
+    #
+    ##
+    def m_gini_index
+      @m_gini_index ||= self.class.initialize_measure(__method__) {
+        p_A*((p_BgivenA**2)+(p_notBgivenA**2))+p_notA*((p_BgivennotA**2)+(p_notBgivennotA**2))-p_B**2-p_notB**2
+      }
+    end
+
+    M_KAPPA_MIN = -1
+    M_KAPPA_MID = 0
+    M_KAPPA_MAX = 1
+    def m_kappa
+      @m_kappa ||= self.class.initialize_measure(__method__) {
+        num = (p_AB + p_notA_notB - p_A*p_B - p_notA*p_notB)
+        den = (1 - p_A*p_B - p_notA*p_notB)
+        ((den == 0) ? num/den.to_f : num/den)
+      }
+    end
+
+    M_J_MEASURE_MIN = 0
+    M_J_MEASURE_MID = 0
+    M_J_MEASURE_MAX = 1
+    ##
+    # Measures cross entropy
+    #
+    ##
+    def m_j_measure
+      @m_j_measure ||= self.class.initialize_measure(__method__) {
+        first_log = Math.log(p_BgivenA/(p_B.to_f))
+        second_log = Math.log(p_notBgivenA/(p_notB.to_f))
+        first = ((p_AB == 0) ? 0 : p_AB*first_log)
+        second = ((p_A_notB == 0) ? 0 : p_A_notB*second_log)
+
+        first+second
+      }
+    end
+
+    M_ONE_WAY_SUPPORT_MIN = -1
+    M_ONE_WAY_SUPPORT_MID = 0
+    M_ONE_WAY_SUPPORT_MAX = Float::INFINITY
+    def m_one_way_support
+      @m_one_way_support ||= self.class.initialize_measure(__method__) {
+        if p_BgivenA == 0
+          0
+        else
+          p_BgivenA*(Math.log2(p_AB/(p_A*p_B)).rationalize)
+        end
+      }
+    end
+
+    M_TWO_WAY_SUPPORT_MIN = -1
+    M_TWO_WAY_SUPPORT_MID = 0
+    M_TWO_WAY_SUPPORT_MAX = 1
+    def m_two_way_support
+      @m_two_way_support ||= self.class.initialize_measure(__method__) {
+        if p_AB == 0
+          0
+        else
+          p_AB*(Math.log2(p_AB/(p_A*p_B)).rationalize)
+        end
+      }
+    end
+
+    # aka Ø-coefficient
+    M_LINEAR_CORRELATION_COEFFICIENT_MIN = -1
+    M_LINEAR_CORRELATION_COEFFICIENT_MID = 0
+    M_LINEAR_CORRELATION_COEFFICIENT_MAX = 1
+    def m_linear_correlation_coefficient
+      @m_linear_correlation_coefficient ||= self.class.initialize_measure(__method__) {
+        num = (p_AB-(p_A*p_B))
+        den = (Math.sqrt(p_A*p_B*p_notA*p_notB))
+        ((den == 0) ? num/den.to_f : num/(den.rationalize))
+      }
+    end
+
+    M_COSINE_MIN = 0
+    M_COSINE_MID = 0
+    M_COSINE_MAX = 1
+    def m_cosine
+      @m_cosine ||= self.class.initialize_measure(__method__) {
+        num = p_AB
+        den = Math.sqrt(p_A*p_B).rationalize
+        if den == 0
+          raise Evoc::Exceptions::MeasureCalculationError, "Denominator became 0 when calculating cosine (a #{p_a}, b #{p_B}, ab #{p_AB})"
+        else
+          num/den
+        end
+      }
+    end
+
+    M_LOEVINGER_MIN = -1
+    M_LOEVINGER_MID = 0
+    M_LOEVINGER_MAX = 1
+    ##
+    # aka Certainty Factor
+    # The certainty factor is a measure of variation of the probability that
+    # Y is in a transaction when only considering transactions with X.
+    # An increasing CF means a decrease of the probability that Y is not in
+    # a transaction that X is in. Negative CFs have a similar interpretation
+    #
+    ##
+    def m_loevinger
+      @m_loevinger ||= self.class.initialize_measure(__method__) {
+        if p_A*p_notB == 0
+          1
+        else
+          1 - ((p_A_notB)/(p_A*p_notB))
+        end
+      }
+    end
+
+    M_SEBAG_SCHOENAUER_MIN = 0
+    M_SEBAG_SCHOENAUER_MID = 0
+    M_SEBAG_SCHOENAUER_MAX = Float::INFINITY
+    def m_sebag_schoenauer
+      @m_sebag_schoenauer ||= self.class.initialize_measure(__method__) {
+        if p_A_notB == 0
+          Float::INFINITY
+        else
+          p_AB/p_A_notB
+        end
+      }
+    end
+
+    M_VARYING_RATES_LIAISON_MIN = -1
+    M_VARYING_RATES_LIAISON_MID = 0 
+    M_VARYING_RATES_LIAISON_MAX = Float::INFINITY
+    def m_varying_rates_liaison
+      @m_varying_rates_liaison ||= self.class.initialize_measure(__method__) {
+        (p_AB/(p_A*p_B)) - 1
+      }
+    end
+
+    M_LEAST_CONTRADICTION_MIN = -Float::INFINITY
+    M_LEAST_CONTRADICTION_MID = 0
+    M_LEAST_CONTRADICTION_MAX = 1
+    def m_least_contradiction
+      @m_least_contradiction ||= self.class.initialize_measure(__method__) {
+        (p_AB-p_A_notB)/p_B
+      }
+    end
+
+    M_ODD_MULTIPLIER_MIN = 0
+    M_ODD_MULTIPLIER_MID = 0
+    M_ODD_MULTIPLIER_MAX = Float::INFINITY
+    def m_odd_multiplier
+      @m_odd_multiplier ||= self.class.initialize_measure(__method__) {
+        numerator = p_AB*p_notB
+        denominator = p_B*p_A_notB
+        if denominator == 0
+          if numerator == 0
+            0
+          else
+            Float::INFINITY
+          end
+        else
+          numerator/denominator
+        end
+      }
+    end
+
+    M_EXAMPLE_AND_COUNTEREXAMPLE_RATE_MIN = -Float::INFINITY
+    M_EXAMPLE_AND_COUNTEREXAMPLE_RATE_MID = 0
+    M_EXAMPLE_AND_COUNTEREXAMPLE_RATE_MAX = 1
+    # 0 when equally many examples as counter examples
+    def m_example_and_counterexample_rate
+      @m_example_and_counterexample_rate ||= self.class.initialize_measure(__method__) {
+        numerator = (p_AB - p_A_notB)
+        denominator = p_AB
+        if denominator == 0
+          -Float::INFINITY
+        else
+          numerator/denominator
+        end
+      }
+    end
+
+    M_ZHANG_MIN = -1
+    M_ZHANG_MID = 0
+    M_ZHANG_MAX = 1
+    def m_zhang
+      @m_zhang ||= self.class.initialize_measure(__method__) {
+        numerator = p_AB-p_A*p_B
+        denominator = [p_AB*p_notB,p_B*p_A_notB].max
+        if denominator == 0
+          0
+        else
+          numerator/denominator
+        end
+      }
+    end
+
+    M_LAPLACE_CORRECTED_CONFIDENCE_MIN = 0
+    M_LAPLACE_CORRECTED_CONFIDENCE_MID = 0
+    M_LAPLACE_CORRECTED_CONFIDENCE_MAX = 1
+    ##
+    # Corrected confidence estimate decreases with lower support
+    # to account for estimation uncertainty with low counts.
+    ##
+    def m_laplace_corrected_confidence
+      @m_laplace_corrected_confidence ||= self.class.initialize_measure(__method__) {
+        (p_AB + 1)/(p_B + 2)
+      }
+    end
+
+    ##
+    # building blocks for interestingness measures
+    #
+    # A refers to the antecedent of a rule
+    # B refers to the consequent of a rule 
+
+    ##
+    # the number of transactions
+    # n is converted into the specified type to ensure
+    # that the type is used throughout calculations
+    def n
+      @n ||= VALUE_TYPE.method(VALUE_TYPE.to_s).call(tx_store.size)
+    end
+
+    ##
+    # the ratio of tx with A as a subset
+    def p_A
+      @p_A ||= tx_store.transactions_of_list(lhs,strict: true).size/n
+    end 
+
+    ##
+    # the ratio of tx where A is not a subset
+    def p_notA
+      @p_notA ||= (1 - p_A)
+    end  
+
+    ##
+    # the ratio of tx with B as a subset
+    def p_B
+      @p_B ||= tx_store.transactions_of_list(rhs,strict: true).size/n
+    end
+
+    ##
+    # the ratio of tx where B is not a subset
+    def p_notB
+      @p_notB ||= (1 - p_B)
+    end  
+
+    ##
+    # the ratio of tx with the union of A and B as a subset
+    def p_AB
+      @p_AB ||= tx_store.transactions_of_list((lhs | rhs),strict: true).size/n
+    end
+
+    ##
+    # the ratio of tx where A or B is a subset
+    def p_AorB
+      @p_AorB ||= p_A + p_B - p_AB 
+    end
+
+    ##
+    # the ratio of tx where neither A or B is a subset
+    def p_notA_notB
+      @p_notA_notB ||= 1 - (p_A + p_B) + p_AB
+    end
+
+    ##
+    # the ratio of tx where A is not a subset but B is
+    def p_notA_B
+      @p_notA_B ||= p_B - p_AB
+    end
+
+    ## 
+    # the ratio of tx where A is a subset but B is not
+    def p_A_notB
+      @p_A_notB ||= p_A - p_AB
+    end
+
+    ##
+    # the ratio of the union being a subset to the number of txes where B is a subset 
+    def p_AgivenB
+      @p_AgivenB ||= ((p_B == 0) ? 0 : p_AB/p_B)
+    end
+
+    ##
+    # the ratio of the union being a subset to the number of txes where A is a subset 
+    def p_BgivenA
+      @p_BgivenA ||= ((p_A == 0) ? 0 : p_AB/p_A)
+    end
+
+    def p_notAgivenB
+      @p_notAgivenB ||= ((p_B == 0) ? 0 : p_notA_B/p_B)
+    end
+
+    # if A is 0, so is A,notB
+    def p_notBgivenA
+      @p_notBgivenA ||= ((p_A == 0) ? 0 : p_A_notB/p_A)
+    end
+
+    # if notB is 0, so is A_notB
+    def p_AgivennotB
+      @p_AgivennotB ||= ((p_notB == 0) ? 0 : p_A_notB/p_notB)
+    end
+
+    # if notA is 0, so is notA_B
+    def p_BgivennotA
+      @p_BgivennotA ||= ((p_notA == 0) ? 0 : p_notA_B/p_notA)
+    end
+
+    def p_notBgivennotA  
+      @p_notBgivennotA ||= ((p_notA == 0) ? 0 : p_notA_notB/p_notA)
+    end
+
+    # if notB is 0, so is notA and notB
+    def p_notAgivennotB  
+      @p_notAgivennotB ||= ((p_notB == 0) ? 0 : p_notA_notB/p_notB)
+    end
+  end
+end