Class: Reporter::Formula

Inherits:
Object
  • Object
show all
Defined in:
lib/reporter/formula.rb

Overview

Formula parser and calculator

Author

Matthijs Groen

This class has two main functions:

  1. to parse formula into ready-to-use-arrays

  2. use those arrays to perform calculations

Parsing formula

my_formula = Formula.new(“100% – (MAX(score – 5, 0) * 10%)”) => Formula my_formula_data = Formula.make(“100% – (MAX(score – 5, 0) * 10%)”) => Array

The array format used for formula data is [:operator, [parameter, parameter]] the parameters can also be arrays: e.g. sub-calculations

The text formula can be build with the following elements:

operators:

-

subtract. subtracts the right side from the left side argument.

*

multiply. multiplies the left side with the right side argument.

/

divide. divides the left side with the ride side argument.

+

add. adds the right side to the left side argument.

^

power. multiplies the left side by the power of the right side.

functions:

functions have the format of name(parameters) the parameters of the function will be pre calculated before the code of the function is executed. supported functions:

max

selects the biggest value from the provided values

min

selects the smallest value from the provided values

sum

creates a sum of all the provided values

avg

creates an average of all the provided values

select

selects the value with the index of the first parameter

empty

returns 1 if the given string is empty, 0 otherwise

parenthesis:

parentesis can be used to group calculation parts

variables:

terms that start with a alfabetic character and contain only alfanumeric characters and underscores can be used as variables. A hash with variables should be supplied when the calculation is performed

numeric values:

numeric values like integers, floats and percentages are also allowed. Percentages will be converted to floats. 3% and 66% will be converted to resp. 100% / 3 and 200% / 3

Performing calculations

my_formula.call(:score => 7.0) => 0.8 (using the above formula example) Formula.calculate(my_formula_data, :score => 3.0) => 1.0 (using the above formula example)

Constant Summary collapse

OPERATORS =

Known operators

"-*/+^"

Instance Attribute Summary collapse

Class Method Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize(code) ⇒ Formula

parse the given code formula in an array using the format calculation = [operation, [parameter, parameter]] a parameter can ofcourse be in turn another calculation



59
60
61
62
 
# File 'lib/reporter/formula.rb', line 59

def initialize(code)
  @calculation = Reporter::Formula.make code
  #puts "#{@calculation.inspect}"
end

Instance Attribute Details

#calculation ⇒ Object (readonly)

Returns the value of attribute calculation.



64
65
66
 
# File 'lib/reporter/formula.rb', line 64

def calculation
  @calculation
end

Class Method Details

.calculate(calculation, input) ⇒ Object 



168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
 
# File 'lib/reporter/formula.rb', line 168

def self.calculate(calculation, input)
  operation, parameters = *calculation

  parameters = parameters.collect do |parameter|
    parameter.is_a?(Array) ? calculate(parameter, input) : parameter
  end

  return nil if (parameters[0].nil? or parameters[1].nil?) and [:add, :subtract, :times, :divide, :power].include? operation

  case operation
    when :add then
      parameters[0] + parameters[1]
    when :subtract then
      parameters[0] - parameters[1]
    when :times then
      parameters[0] * parameters[1]
    when :divide then
      parameters[1] == 0 ? nil : parameters[0].to_f / parameters[1].to_f
    when :power then
      parameters[0] ** parameters[1]
    # functions:
    when :max then
      parameters.compact.max
    when :min then
      parameters.compact.min
    when :sum then
      begin
        result = 0.0
        parameters.each { |value| result += value || 0.0 }
        result
      end
    when :select then
      begin
        index = parameters.shift
        index.is_a?(Numeric) ? parameters[index - 1] : nil
      end
    when :avg then
      begin
        items = parameters.compact
        result = 0.0
        items.each { |value| result += value }
        result / items.length
      end
    when :empty then
      begin
        result = parameters.collect { |item| item.to_s.strip == "" ? 1 : 0 }
        result.include?(0) ? 0 : 1          
      end
    # variables
    when :term then
      begin
        raise "Can't find  term: #{parameters[0]}. Has keys: #{input.keys.collect(&:to_s).sort.inspect}" unless input.has_key? parameters[0]
        input[parameters[0]]
      end
    when :negative_term then
      begin
        raise "Can't find  term: #{parameters[0]}. Has keys: #{input.keys.sort.inspect}" unless input.has_key? parameters[0]
        val = input[parameters[0]]
        return nil unless val
        - val
      end
    when :literal
      parameters[0]
    when :text
      parameters[0]
    # no-op
    when nil, :percentage then
      parameters[0].to_f
  end
end

.calculation_to_s(calculation, input, solve = false) ⇒ Object 



101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
 
# File 'lib/reporter/formula.rb', line 101

def self.calculation_to_s(calculation, input, solve = false)
  operation, parameters = * calculation

  string_parameters = parameters.collect do |parameter|
    parameter.is_a?(Array) ? "#{calculation_to_s(parameter, input, solve)}" : parameter
  end
  case operation
    when :add,
      :subtract,
      :times,
      :divide,
      :power then
      "(#{string_parameters[0]} #{{:add => "+",
                                   :subtract => "-",
                                   :times => "*",
                                   :divide => "/",
                                   :power => "^"}[operation]} #{string_parameters[1]})"
    # functions:
    when :max,
      :min,
      :sum,
      :select,
      :avg,
      :empty then
      if solve
        result = calculate(calculation, input)
        "#{operation}(#{string_parameters * ","})[#{result}]"
      else
        "#{operation}(#{string_parameters * ","})"
      end
    # variables
    when :text then
      "\"#{string_parameters[0]}\""
    when :term then
      "#{string_parameters[0]}[#{input[string_parameters[0]] ? input[string_parameters[0]] : "nil"}]"
    when :negative_term then
      "-#{string_parameters[0]}[#{input[string_parameters[0]] ? input[string_parameters[0]] : "nil"}]"
    when :literal then
      begin
        "nil" if string_parameters[0].nil?
      end
    # no-op
    when nil then
      string_parameters[0].to_s
    when :percentage then
      "#{string_parameters[0] * 100.0}%"
    else
      "!unsupported(#{operation}}"
  end
end

.make(code) ⇒ Object

Parses the given formula as text and returns the formula in nested array form.



67
68
69
70
71
72
73
74
75
 
# File 'lib/reporter/formula.rb', line 67

def self.make(code)
  #puts "parsing: #{code}"
  begin
    parse_operation(code)
  rescue StandardError => e
    puts "Error in formula: #{code}: #{e}"
    raise
  end
end

.term_list(calculation, input = {}) ⇒ Object 



152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
 
# File 'lib/reporter/formula.rb', line 152

def self.term_list(calculation, input = {})
  operation, parameters = *calculation

  parameters = parameters.collect do |parameter|
    parameter.is_a?(Array) ? term_list(parameter, input) : parameter
  end

  case operation
    # variables
    when :term then
        input[parameters[0]] = :term
    when :negative_term then
        input[parameters[0]] = :term
  end
end

Instance Method Details

#call(input) ⇒ Object

executes the formula with a hash of given calculation terms



78
79
80
81
82
83
84
85
 
# File 'lib/reporter/formula.rb', line 78

def call(input)
  begin
    Reporter::Formula.calculate(@calculation, input)
  rescue StandardError => e
    Rails.logger.error "Error executing formula: #{Reporter::Formula.calculation_to_s(@calculation, input)} : #{e.message}"
    raise
  end
end

#solve(input) ⇒ Object 



97
98
99
 
# File 'lib/reporter/formula.rb', line 97

def solve(input)
  Reporter::Formula.calculation_to_s(@calculation, input, true)
end

#term_list ⇒ Object 



87
88
89
90
91
 
# File 'lib/reporter/formula.rb', line 87

def term_list
  terms = {}
  Reporter::Formula.term_list @calculation, terms
  terms.keys
end

#to_string(input) ⇒ Object 



93
94
95
 
# File 'lib/reporter/formula.rb', line 93

def to_string(input)
  Reporter::Formula.calculation_to_s(@calculation, input)
end