excel_to_code 0.3.17 → 0.3.18.beta.1

data/src/compile/ruby/map_formulae_to_ruby.rb

@@ -1,10 +1,10 @@
 require_relative 'map_values_to_ruby'
 
 class MapFormulaeToRuby < MapValuesToRuby
-  
+
   attr_accessor :sheet_names
   attr_accessor :worksheet
-  
+
   FUNCTIONS = {
     :'*' => 'multiply',
     :'+' => 'add',
@@ -21,6 +21,8 @@ class MapFormulaeToRuby < MapValuesToRuby
     :'AND' => 'excel_and',
     :'AVERAGE' => 'average',
     :'AVERAGEIFS' => 'averageifs',
+    :'CEILING' => 'ceiling',
+    :'_xlfn.CEILING.MATH' => 'ceiling',
     :'CELL' => 'cell',
     :'CHAR' => 'char',
     :'CHOOSE' => 'choose',
@@ -28,11 +30,15 @@ class MapFormulaeToRuby < MapValuesToRuby
     :'COSH' => 'cosh',
     :'COUNT' => 'count',
     :'COUNTA' => 'counta',
+    :'COUNTIF' => 'countif',
+    :'COUNTIFS' => 'countifs',
     :'ENSURE_IS_NUMBER' => 'ensure_is_number',
     :'EXP' => 'exp',
     :'FIND' => 'find',
+    :'FLOOR' => 'floor',
     :'FORECAST' => 'forecast',
     :'HLOOKUP' => 'hlookup',
+    :'HYPERLINK' => 'hyperlink',
     :'IF' => 'excel_if',
     :'IFERROR' => 'iferror',
     :'INDEX' => 'index',
@@ -54,17 +60,24 @@ class MapFormulaeToRuby < MapValuesToRuby
     :'MIN' => 'min',
     :'MMULT' => 'mmult',
     :'MOD' => 'mod',
+    :'NA' => 'na',
+    :'NOT' => 'excel_not',
     :'NPV' => 'npv',
     :'NUMBER_OR_ZERO' => 'number_or_zero',
+    :'OR' => 'excel_or',
     :'PI' => 'pi',
     :'PMT' => 'pmt',
     :'POWER' => 'power',
+    :'PRODUCT' => 'product',
     :'PV' => 'pv',
     :'RANK' => 'rank',
+    :'RATE' => 'rate',
+    :'REPLACE' => 'replace',
     :'RIGHT' => 'right',
     :'ROUND' => 'round',
     :'ROUNDDOWN' => 'rounddown',
     :'ROUNDUP' => 'roundup',
+    :'SQRT' => 'sqrt',
     :'SUBSTITUTE' => 'substitute',
     :'SUBTOTAL' => 'subtotal',
     :'SUM' => 'sum',
@@ -75,18 +88,23 @@ class MapFormulaeToRuby < MapValuesToRuby
     :'TRIM' => 'trim',
     :'VALUE' => 'value',
     :'VLOOKUP' => 'vlookup',
-    :'^' => 'power'
+    :'^' => 'power',
+    :'_xlfn.FORECAST.LINEAR' => 'forecast',
+    :'curve' => 'curve',
+    :'halfscurve' => 'halfscurve',
+    :'lcurve' => 'lcurve',
+    :'scurve' => 'scurve'
   }
-  
+
   def prefix(symbol,ast)
     return map(ast) if symbol == "+"
     return "negative(#{map(ast)})"
   end
-  
+
   def brackets(*contents)
     "(#{contents.map { |a| map(a) }.join(',')})"
   end
-  
+
   def arithmetic(left,operator,right)
     "#{FUNCTIONS[operator.last]}(#{map(left)},#{map(right)})"
   end
@@ -103,7 +121,7 @@ class MapFormulaeToRuby < MapValuesToRuby
   def comparison(left,operator,right)
     "#{FUNCTIONS[operator.last]}(#{map(left)},#{map(right)})"
   end
-  
+
   def function(function_name,*arguments)
     if FUNCTIONS.has_key?(function_name)
       "#{FUNCTIONS[function_name]}(#{arguments.map { |a| map(a) }.join(",")})"
@@ -111,21 +129,21 @@ class MapFormulaeToRuby < MapValuesToRuby
       raise NotSupportedException.new("Function #{function_name} not supported")
     end
   end
-  
+
   def cell(reference)
     reference.to_s.downcase.gsub('$','')
   end
-  
+
   def sheet_reference(sheet,reference)
     "#{sheet_names[sheet]}_#{map(reference)}"
   end
-  
+
   def array(*rows)
     "[#{rows.map {|r| map(r)}.join(",")}]"
   end
-  
+
   def row(*cells)
     "[#{cells.map {|r| map(r)}.join(",")}]"
   end
-  
+
 end

data/src/excel/excel_functions.rb

@@ -3,6 +3,7 @@ end
 
 # Support functions
 require_relative 'excel_functions/number_argument'
+require_relative 'excel_functions/string_argument'
 require_relative 'excel_functions/reset'
 
 # Constants
@@ -31,6 +32,7 @@ require_relative 'excel_functions/negative'
 require_relative 'excel_functions/abs'
 require_relative 'excel_functions/and'
 require_relative 'excel_functions/mod'
+require_relative 'excel_functions/not'
 
 # Array arithmetic
 require_relative 'excel_functions/sum'
@@ -71,7 +73,6 @@ require_relative 'excel_functions/int'
 
 # Other functions
 
-
 require_relative 'excel_functions/cell'
 
 require_relative 'excel_functions/trim'
@@ -123,3 +124,27 @@ require_relative 'excel_functions/char'
 require_relative 'excel_functions/address'
 
 require_relative 'excel_functions/number_or_zero'
+
+require_relative 'excel_functions/countif'
+
+require_relative 'excel_functions/hyperlink'
+
+require_relative 'excel_functions/na'
+
+require_relative 'excel_functions/or'
+
+require_relative 'excel_functions/scurve'
+
+require_relative 'excel_functions/floor'
+
+require_relative 'excel_functions/sqrt'
+
+require_relative 'excel_functions/product'
+
+require_relative 'excel_functions/countifs'
+
+require_relative 'excel_functions/replace'
+
+require_relative 'excel_functions/rate'
+
+require_relative 'excel_functions/ceiling'

data/src/excel/excel_functions/ceiling.rb

@@ -0,0 +1,23 @@
+module ExcelFunctions
+  
+  def ceiling(number, multiple, mode = 0)
+    return number if number.is_a?(Symbol)
+    return multiple if multiple.is_a?(Symbol)
+    return mode if mode.is_a?(Symbol)
+    number = number_argument(number)
+    multiple = number_argument(multiple)
+    mode = number_argument(mode)
+    return :value unless number.is_a?(Numeric)
+    return :value unless multiple.is_a?(Numeric)
+    return :value unless mode.is_a?(Numeric)
+    return 0 if multiple == 0
+    if mode == 0 || number > 0
+      whole, remainder = number.divmod(multiple)
+      num_steps = remainder > 0 ? whole + 1 : whole
+      num_steps * multiple
+    else # Need to round negative away from zero
+      -ceiling(-number, multiple, 0)
+    end
+  end
+  
+end

data/src/excel/excel_functions/countif.rb

@@ -0,0 +1,15 @@
+module ExcelFunctions
+  
+  def countif(count_range, criteria)
+    return 0 if criteria.kind_of?(Array) # Who knows why, Excel
+    count_range = [count_range] unless count_range.kind_of?(Array)
+    rows = count_range.size
+    if count_range.first && count_range.first.kind_of?(Array)
+        sum_range = Array.new(rows, Array.new(count_range.first.size,1))
+    else
+        sum_range = Array.new(rows, 1)
+    end
+    return sumif(count_range, criteria, sum_range)
+  end
+  
+end

data/src/excel/excel_functions/countifs.rb

@@ -0,0 +1,10 @@
+module ExcelFunctions
+  
+  def countifs(*criteria)
+    return 0 if criteria.empty?
+    c = criteria[0].is_a?(Array) ? criteria[0] : [criteria[0]]
+    count = c.map { 1 }
+    return sumifs(count, *criteria)
+  end
+  
+end

data/src/excel/excel_functions/floor.rb

@@ -0,0 +1,14 @@
+module ExcelFunctions
+  
+  def floor(number, multiple)
+    return number if number.is_a?(Symbol)
+    return multiple if multiple.is_a?(Symbol)
+    number ||= 0
+    return :value unless number.is_a?(Numeric)
+    return :value unless multiple.is_a?(Numeric)
+    return :div0 if multiple == 0
+    return :num if multiple < 0
+    number - (number % multiple)
+  end
+  
+end

data/src/excel/excel_functions/hyperlink.rb

@@ -0,0 +1,9 @@
+module ExcelFunctions
+  
+  def hyperlink(url, text = url)
+    u = string_argument(url)
+    t = string_argument(text)
+    "<a href=#{u.inspect}>#{t}</a>"
+  end
+  
+end

data/src/excel/excel_functions/na.rb

@@ -0,0 +1,7 @@
+module ExcelFunctions
+  
+  def na()
+    return :na
+  end
+  
+end

data/src/excel/excel_functions/not.rb

@@ -0,0 +1,13 @@
+module ExcelFunctions
+  
+  def excel_not(a)
+    return a if a.is_a?(Symbol)
+    return :value if a.is_a?(String)
+    return :value if a.is_a?(Array)
+    a = false if a == nil
+    a = false if a == 0
+    a = true if a.is_a?(Numeric)
+    !a
+  end
+  
+end

data/src/excel/excel_functions/or.rb

@@ -0,0 +1,30 @@
+module ExcelFunctions
+  
+  def excel_or(*args)
+    # Flatten arrays
+    args = args.flatten
+    
+    # If an argument is an error, return that
+    error = args.find {|a| a.is_a?(Symbol)}
+    return error if error
+    
+    # Replace 1 and 0 with true and false
+    args.map! do |a|
+      case a
+      when 1; true
+      when 0; false
+      else; a
+      end
+    end
+    
+    # Remove anything not boolean
+    args.delete_if { |a| !(a.is_a?(TrueClass) || a.is_a?(FalseClass)) }
+    
+    # Return an error if nothing less
+    return :value if args.empty?
+    
+    # Now calculate and return
+    args.any? {|a| a == true }
+ end
+  
+end

data/src/excel/excel_functions/product.rb

@@ -0,0 +1,8 @@
+module ExcelFunctions
+  
+  def product(*args)
+    args = args.flatten
+    args.find {|a| a.is_a?(Symbol)} || args.delete_if { |a| !a.is_a?(Numeric) }.inject(0) { |m,i| m + i }
+  end
+  
+end

data/src/excel/excel_functions/rate.rb

@@ -0,0 +1,16 @@
+module ExcelFunctions
+  
+  def rate(periods, payment, presentValue, finalValue)
+    raise NotSupportedException.new("rate() function has not been implemented fully. Edit src/excel/excel_functions/rate.rb") unless (payment || 0) == 0
+    return periods if periods.is_a?(Symbol)
+    return presentValue if presentValue.is_a?(Symbol)
+    return finalValue if finalValue.is_a?(Symbol)
+
+    return :num unless periods.is_a?(Numeric)
+    return :num unless presentValue.is_a?(Numeric)
+    return :num unless finalValue.is_a?(Numeric)
+
+    ((finalValue.to_f/(-presentValue.to_f)) ** (1.0/periods))-1.0
+  end
+  
+end

data/src/excel/excel_functions/replace.rb

@@ -0,0 +1,13 @@
+module ExcelFunctions
+  
+  def replace(string, start, length, replacement)
+    return string if string.is_a?(Symbol)
+    return start if start.is_a?(Symbol)
+    return length if length.is_a?(Symbol)
+    return replacement if replacement.is_a?(Symbol)
+    string = string.to_s
+    return string + replacement if start >= string.length
+    string_join(left(string,start-1),replacement,right(string,string.length - (start - 1 + length)))
+  end
+  
+end

data/src/excel/excel_functions/scurve.rb

@@ -0,0 +1,73 @@
+module ExcelFunctions
+  
+  def scurve(currentYear, startValue, endValue, duration, startYear = 2018.0)
+    currentYear = number_argument(currentYear)
+    startValue = number_argument(startValue)
+    endValue = number_argument(endValue)
+    duration = number_argument(duration)
+    startYear = number_argument(startYear)
+
+    return currentYear if currentYear.is_a?(Symbol)
+    return startValue if startValue.is_a?(Symbol)
+    return endValue if endValue.is_a?(Symbol)
+    return duration if duration.is_a?(Symbol)
+    return startYear if startYear.is_a?(Symbol)
+    
+    return startValue if currentYear < startYear 
+
+    x = (currentYear - startYear) / duration.to_f
+    x0 = 0.0
+    a = endValue - startValue
+    sc = 0.999
+    eps = 1.0 - sc
+    mu = 0.5
+    beta = (mu - 1.0) / Math.log(1.0 / sc - 1)
+    scurve = a * (((Math.exp(-(x - mu) / beta) + 1) ** -1) - ((Math.exp(-(x0 - mu) / beta) + 1) ** -1)) + startValue
+  end
+
+  def halfscurve(currentYear, startValue, endValue , duration, startYear = 2018)
+    currentYear = number_argument(currentYear)
+    startValue = number_argument(startValue)
+    endValue = number_argument(endValue)
+    duration = number_argument(duration)
+    startYear = number_argument(startYear)
+
+    return currentYear if currentYear.is_a?(Symbol)
+    return startValue if startValue.is_a?(Symbol)
+    return endValue if endValue.is_a?(Symbol)
+    return duration if duration.is_a?(Symbol)
+    return startYear if startYear.is_a?(Symbol)
+    return startValue if currentYear < startYear 
+
+    scurve(currentYear + duration, startValue, endValue, duration * 2, startYear) - ((endValue - startValue) / 2.0)
+  end
+
+  def lcurve(currentYear, startValue, endValue , duration, startYear = 2018)
+    currentYear = number_argument(currentYear)
+    startValue = number_argument(startValue)
+    endValue = number_argument(endValue)
+    duration = number_argument(duration)
+    startYear = number_argument(startYear)
+
+    return currentYear if currentYear.is_a?(Symbol)
+    return startValue if startValue.is_a?(Symbol)
+    return endValue if endValue.is_a?(Symbol)
+    return duration if duration.is_a?(Symbol)
+    return startYear if startYear.is_a?(Symbol)
+
+    return startValue if currentYear < startYear 
+    return endValue if currentYear > (startYear + duration)
+    return startValue if currentYear < startYear 
+    startValue + (endValue - startValue) / duration * (currentYear - startYear)
+  end
+
+  def curve(curveType, currentYear, startValue, endValue, duration, startYear = 2018)
+    if curveType == "s"
+      return scurve(currentYear, startValue, endValue, duration, startYear)
+    elsif curveType == "hs"
+      return halfscurve(currentYear, startValue, endValue, duration, startYear)
+    else
+      return lcurve(currentYear, startValue, endValue, duration, startYear)
+    end
+  end
+end

data/src/excel/excel_functions/sqrt.rb

@@ -0,0 +1,11 @@
+module ExcelFunctions
+  
+  def sqrt(a)
+    return a if a.is_a?(Symbol)
+    a ||= 0
+    return :value unless a.is_a?(Numeric)
+    return :num if a < 0
+    Math.sqrt(a)
+  end
+  
+end

data/src/excel/excel_functions/string_argument.rb

@@ -0,0 +1,37 @@
+module ExcelFunctions
+  
+  # This is a support function for mapping arguments that are not strings to their
+  # Excel string equivalent. e.g., true = TRUE, :div0 = "DIV/0!"
+  def string_argument(a)
+    case a
+    when Symbol
+      return {
+        :name => "#NAME?",
+        :value => "#VALUE!",
+        :div0 => "#DIV/0!",
+        :ref => "#REF!",
+        :na => "#N/A",
+        :num => "#NUM!",
+      }[a] || :value
+    when String
+      return a
+    when nil
+      return "" 
+    when true
+      return "TRUE"
+    when false
+      return "FALSE" 
+    when Numeric
+      if a.round == a
+        return a.to_i.to_s
+      else
+        return a.to_s
+      end
+    when Array
+      return string_argument(a[0][0])
+    else
+      return :value
+    end
+  end
+  
+end