excel_to_code 0.2.10 → 0.2.11

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: d131943e44d296b38b2b2f52d4e710fb72b3290c
-  data.tar.gz: 1ced79386e0e176fb515794fb5026a4779d56c2a
+  metadata.gz: a444173d8318385277afd731b47cedcb7fe2b783
+  data.tar.gz: 13c5f6fa4d20cc45730c9c15f736c68c17a810af
 SHA512:
-  metadata.gz: 90c8c2c66e70b2beb0073a904d02c70444d3881bce4b570fe681a99098597319cee266611282f6789326efaf9a69198c85750633392c5aeae4fed329bfc7c521
-  data.tar.gz: 39325a065501520c32b29be75d0af212c498c8d8d2baf580e1a0e585b2841fa6610679a1298d2dbe86ab5bf6269821612b97ce969b1d178a514ea16ef4831e94
+  metadata.gz: 201c1f56ae3807bce72ca38c48f78300f2c1c6a2857e2ddf58e111dfe9a64660d0cfc4bf453fe9eb817a8d5c1719e60fb19943b998f5342aea9f9d0873c5d79e
+  data.tar.gz: 9945c873cfc1d3e76f6fff18c8fd43ad38f3862efcd24c16e8eccc53670d247fe8d00792d920fd86efe8732f86c2be1b2cdb0db998af112f68ed10081bd6e358

data/bin/excel_to_c

@@ -4,6 +4,7 @@ require_relative '../src/excel_to_code'
 
 command = ExcelToC.new
 
+#FIXME: Add a version option
 opts = OptionParser.new do |opts|
   opts.banner = <<-END
 

data/src/commands/excel_to_x.rb

@@ -112,6 +112,8 @@ class ExcelToX
   def go!
     # This sorts out the settings
     set_defaults
+
+    log.info "Excel to Code version #{ExcelToCode.version}\n\n"
     
     # These turn the excel into xml on disk
     sort_out_output_directories
@@ -480,10 +482,17 @@ class ExcelToX
     functions_that_are_removed_during_compilation.each do |f|
       functions_used.delete(f)
     end
+
     unless functions_used.empty?
-      puts
-      puts "The following functions have not been implemented in excel_to_code. Please see https://github.com/tamc/excel_to_code/blob/master/doc/How_to_add_a_missing_function.md"
-      puts functions_used
+      
+      log.fatal "The following functions have not been implemented in excel_to_code #{ExcelToCode.version}:"
+
+      functions_used.each do |f|
+        log.fatal f.to_s
+      end 
+      
+      log.fatal "Check for a new version of excel_to_code at https://github.com/tamc/excel_to_code"
+      log.fatal "Or follow the instractions at https://github.com/tamc/excel_to_code/blob/master/doc/How_to_add_a_missing_function.md to implement the function yourself"
       exit
     end
   end

data/src/compile/c/excel_to_c_runtime.c

@@ -55,6 +55,8 @@ static ExcelValue more_than_or_equal(ExcelValue a_v, ExcelValue b_v);
 static ExcelValue not_equal(ExcelValue a_v, ExcelValue b_v);
 static ExcelValue less_than(ExcelValue a_v, ExcelValue b_v);
 static ExcelValue less_than_or_equal(ExcelValue a_v, ExcelValue b_v);
+static ExcelValue average(int array_size, ExcelValue *array);
+static ExcelValue averageifs(ExcelValue average_range_v, int number_of_arguments, ExcelValue *arguments);
 static ExcelValue find_2(ExcelValue string_to_look_for_v, ExcelValue string_to_look_in_v);
 static ExcelValue find(ExcelValue string_to_look_for_v, ExcelValue string_to_look_in_v, ExcelValue position_to_start_at_v);
 static ExcelValue hlookup_3(ExcelValue lookup_value_v,ExcelValue lookup_table_v, ExcelValue row_number_v);
@@ -64,6 +66,7 @@ static ExcelValue excel_index(ExcelValue array_v, ExcelValue row_number_v, Excel
 static ExcelValue excel_index_2(ExcelValue array_v, ExcelValue row_number_v);
 static ExcelValue excel_isnumber(ExcelValue number);
 static ExcelValue excel_isblank(ExcelValue value);
+static ExcelValue forecast(ExcelValue required_x, ExcelValue known_y, ExcelValue known_x);
 static ExcelValue large(ExcelValue array_v, ExcelValue k_v);
 static ExcelValue left(ExcelValue string_v, ExcelValue number_of_characters_v);
 static ExcelValue left_1(ExcelValue string_v);
@@ -399,6 +402,74 @@ static ExcelValue average(int array_size, ExcelValue *array) {
 	return new_excel_number(r.sum/r.count);
 }
 
+static ExcelValue forecast(ExcelValue required_x_v, ExcelValue known_y, ExcelValue known_x) {
+  CHECK_FOR_PASSED_ERROR(required_x_v)
+
+	NUMBER(required_x_v, required_x)
+	CHECK_FOR_CONVERSION_ERROR
+
+  if(known_x.type != ExcelRange) { return NA; }
+  if(known_y.type != ExcelRange) { return NA; }
+
+  int known_x_size = known_x.rows * known_x.columns;
+  int known_y_size = known_y.rows * known_y.columns;
+
+  int i;
+  ExcelValue *x_array, *y_array;
+  ExcelValue vx, vy;
+
+  x_array = known_x.array;
+  y_array = known_y.array;
+
+  for(i=0; i<known_x_size; i++) {
+    vx = x_array[i];
+    if(vx.type == ExcelError) {
+      return vx;
+    }
+  }
+
+  for(i=0; i<known_x_size; i++) {
+    vy = y_array[i];
+    if(vy.type == ExcelError) {
+      return vy;
+    }
+  }
+
+  if(known_x_size != known_y_size) { return NA; }
+  if(known_x_size == 0) { return NA; }
+
+  ExcelValue mean_y = average(1, &known_y);
+  ExcelValue mean_x = average(1, &known_x);
+
+  if(mean_y.type == ExcelError) { return mean_y; }
+  if(mean_x.type == ExcelError) { return mean_x; }
+
+  float mx = mean_x.number;
+  float my = mean_y.number;
+
+  float b_numerator, b_denominator, b, a;
+  
+  b_denominator = 0;
+  b_numerator = 0;
+
+  for(i=0; i<known_x_size; i++) {
+    vx = x_array[i];
+    vy = y_array[i];
+    if(vx.type != ExcelNumber) { continue; }
+    if(vy.type != ExcelNumber) { continue; }
+
+    b_denominator = b_denominator + pow(vx.number - mx, 2);
+    b_numerator = b_numerator + ((vx.number - mx)*(vy.number-my));
+  }
+
+  if(b_denominator == 0) { return DIV0; }
+
+  b = b_numerator / b_denominator;
+  a = mean_y.number - (b*mean_x.number);
+
+  return new_excel_number(a + (b*required_x));
+}
+
 static ExcelValue choose(ExcelValue index_v, int array_size, ExcelValue *array) {
 	CHECK_FOR_PASSED_ERROR(index_v)
 
@@ -1419,24 +1490,29 @@ static ExcelValue subtotal(ExcelValue subtotal_type_v, int number_of_arguments,
   }
 }
 
-static ExcelValue sumifs(ExcelValue sum_range_v, int number_of_arguments, ExcelValue *arguments) {
-  // First, set up the sum_range
-  CHECK_FOR_PASSED_ERROR(sum_range_v);
+
+static ExcelValue filter_range(ExcelValue original_range_v, int number_of_arguments, ExcelValue *arguments) {
+  // First, set up the original_range
+  CHECK_FOR_PASSED_ERROR(original_range_v);
 
   // Set up the sum range
-  ExcelValue *sum_range;
-  int sum_range_rows, sum_range_columns;
+  ExcelValue *original_range;
+  int original_range_rows, original_range_columns;
   
-  if(sum_range_v.type == ExcelRange) {
-    sum_range = sum_range_v.array;
-    sum_range_rows = sum_range_v.rows;
-    sum_range_columns = sum_range_v.columns;
+  if(original_range_v.type == ExcelRange) {
+    original_range = original_range_v.array;
+    original_range_rows = original_range_v.rows;
+    original_range_columns = original_range_v.columns;
   } else {
-    sum_range = (ExcelValue*) new_excel_value_array(1);
-	sum_range[0] = sum_range_v;
-    sum_range_rows = 1;
-    sum_range_columns = 1;
+    original_range = (ExcelValue*) new_excel_value_array(1);
+	original_range[0] = original_range_v;
+    original_range_rows = 1;
+    original_range_columns = 1;
   }
+
+  // This is the filtered range
+  ExcelValue *filtered_range = new_excel_value_array(original_range_rows*original_range_columns);
+  int number_of_filtered_values = 0; 
   
   // Then go through and set up the check ranges
   if(number_of_arguments % 2 != 0) return VALUE;
@@ -1448,11 +1524,11 @@ static ExcelValue sumifs(ExcelValue sum_range_v, int number_of_arguments, ExcelV
     current_value = arguments[i*2];
     if(current_value.type == ExcelRange) {
       criteria_range[i] = current_value;
-      if(current_value.rows != sum_range_rows) return VALUE;
-      if(current_value.columns != sum_range_columns) return VALUE;
+      if(current_value.rows != original_range_rows) return VALUE;
+      if(current_value.columns != original_range_columns) return VALUE;
     } else {
-      if(sum_range_rows != 1) return VALUE;
-      if(sum_range_columns != 1) return VALUE;
+      if(original_range_rows != 1) return VALUE;
+      if(original_range_columns != 1) return VALUE;
       ExcelValue *tmp_array2 =  (ExcelValue*) new_excel_value_array(1);
       tmp_array2[0] = current_value;
       criteria_range[i] =  new_excel_range(tmp_array2,1,1);
@@ -1503,8 +1579,7 @@ static ExcelValue sumifs(ExcelValue sum_range_v, int number_of_arguments, ExcelV
     }
   }
   
-  double total = 0;
-  int size = sum_range_columns * sum_range_rows;
+  int size = original_range_columns * original_range_rows;
   int j;
   int passed = 0;
   ExcelValue value_to_be_checked;
@@ -1628,17 +1703,28 @@ static ExcelValue sumifs(ExcelValue sum_range_v, int number_of_arguments, ExcelV
       if(passed == 0) break;
     }
     if(passed == 1) {
-      current_value = sum_range[j];
+      current_value = original_range[j];
       if(current_value.type == ExcelError) {
         return current_value;
       } else if(current_value.type == ExcelNumber) {
-        total += current_value.number;
+        filtered_range[number_of_filtered_values] = current_value;
+        number_of_filtered_values += 1;
       }
     }
   }
   // Tidy up
   free(criteria);
-  return new_excel_number(total);
+  return new_excel_range(filtered_range, number_of_filtered_values, 1);
+}
+
+static ExcelValue sumifs(ExcelValue sum_range_v, int number_of_arguments, ExcelValue *arguments) {
+  ExcelValue filtered_range = filter_range(sum_range_v, number_of_arguments, arguments);
+  return sum(1,&filtered_range);
+}
+
+static ExcelValue averageifs(ExcelValue average_range_v, int number_of_arguments, ExcelValue *arguments) {
+  ExcelValue filtered_range = filter_range(average_range_v, number_of_arguments, arguments);
+  return average(1,&filtered_range);
 }
 
 static ExcelValue sumif(ExcelValue check_range_v, ExcelValue criteria_v, ExcelValue sum_range_v ) {

data/src/compile/c/excel_to_c_runtime_test.c

@@ -762,6 +762,83 @@ int test_functions() {
   assert(excel_isblank(TRUE).number == false);
   assert(excel_isblank(FALSE).number == false);
   assert(excel_isblank(new_excel_string("")).number == false);
+  
+  // Test AVERAGEIFS function
+  ExcelValue averageifs_array_1[] = {new_excel_number(10),new_excel_number(100),BLANK};
+  ExcelValue averageifs_array_1_v = new_excel_range(averageifs_array_1,3,1);
+  ExcelValue averageifs_array_2[] = {new_excel_string("pear"),new_excel_string("bear"),new_excel_string("apple")};
+  ExcelValue averageifs_array_2_v = new_excel_range(averageifs_array_2,3,1);
+  ExcelValue averageifs_array_3[] = {new_excel_number(1),new_excel_number(2),new_excel_number(3),new_excel_number(4),new_excel_number(5),new_excel_number(5)};
+  ExcelValue averageifs_array_3_v = new_excel_range(averageifs_array_3,6,1);
+  ExcelValue averageifs_array_4[] = {new_excel_string("CO2"),new_excel_string("CH4"),new_excel_string("N2O"),new_excel_string("CH4"),new_excel_string("N2O"),new_excel_string("CO2")};
+  ExcelValue averageifs_array_4_v = new_excel_range(averageifs_array_4,6,1);
+  ExcelValue averageifs_array_5[] = {new_excel_string("1A"),new_excel_string("1A"),new_excel_string("1A"),new_excel_number(4),new_excel_number(4),new_excel_number(5)};
+  ExcelValue averageifs_array_5_v = new_excel_range(averageifs_array_5,6,1);
+  
+  // ... should only average values that meet all of the criteria
+  ExcelValue averageifs_array_6[] = { averageifs_array_1_v, new_excel_number(10), averageifs_array_2_v, new_excel_string("Bear") };
+  assert(averageifs(averageifs_array_1_v,4,averageifs_array_6).type == ExcelError);
+  
+  ExcelValue averageifs_array_7[] = { averageifs_array_1_v, new_excel_number(10), averageifs_array_2_v, new_excel_string("Pear") };
+  assert(averageifs(averageifs_array_1_v,4,averageifs_array_7).number == 10.0);
+  
+  // ... should work when single cells are given where ranges expected
+  ExcelValue averageifs_array_8[] = { new_excel_string("CAR"), new_excel_string("CAR"), new_excel_string("FCV"), new_excel_string("FCV")};
+  assert(averageifs(new_excel_number(0.143897265452564), 4, averageifs_array_8).number == 0.143897265452564);
+
+  // ... should match numbers with strings that contain numbers
+  ExcelValue averageifs_array_9[] = { new_excel_number(10), new_excel_string("10.0")};
+  assert(averageifs(new_excel_number(100),2,averageifs_array_9).number == 100);
+  
+  ExcelValue averageifs_array_10[] = { averageifs_array_4_v, new_excel_string("CO2"), averageifs_array_5_v, new_excel_number(2)};
+  assert(averageifs(averageifs_array_3_v,4, averageifs_array_10).type == ExcelError);
+  
+  // ... should match with strings that contain criteria
+  ExcelValue averageifs_array_10a[] = { averageifs_array_3_v, new_excel_string("=5")};
+  assert(averageifs(averageifs_array_3_v,2, averageifs_array_10a).number == 5);
+
+  ExcelValue averageifs_array_10b[] = { averageifs_array_3_v, new_excel_string("<>3")};
+  assert(averageifs(averageifs_array_3_v,2, averageifs_array_10b).number == 3.4);
+
+  ExcelValue averageifs_array_10c[] = { averageifs_array_3_v, new_excel_string("<3")};
+  assert(averageifs(averageifs_array_3_v,2, averageifs_array_10c).number == 1.5);
+  
+  ExcelValue averageifs_array_10d[] = { averageifs_array_3_v, new_excel_string("<=3")};
+  assert(averageifs(averageifs_array_3_v,2, averageifs_array_10d).number == 2);
+
+  ExcelValue averageifs_array_10e[] = { averageifs_array_3_v, new_excel_string(">3")};
+  assert(averageifs(averageifs_array_3_v,2, averageifs_array_10e).number == 14.0/3.0);
+
+  ExcelValue averageifs_array_10f[] = { averageifs_array_3_v, new_excel_string(">=3")};
+  assert(averageifs(averageifs_array_3_v,2, averageifs_array_10f).number == (3.0+4.0+5.0+5.0)/4.0);
+  
+  // ... should treat BLANK as an empty string when in the check_range, but not in the criteria
+  ExcelValue averageifs_array_11[] = { BLANK, new_excel_number(20)};
+  assert(averageifs(new_excel_number(100),2,averageifs_array_11).type == ExcelError);
+  
+  ExcelValue averageifs_array_12[] = {BLANK, new_excel_string("")};
+  assert(averageifs(new_excel_number(100),2,averageifs_array_12).number == 100);
+  
+  ExcelValue averageifs_array_13[] = {BLANK, BLANK};
+  assert(averageifs(new_excel_number(100),2,averageifs_array_13).type == ExcelError);
+    
+  // ... should return an error if range argument is an error
+  assert(averageifs(REF,2,averageifs_array_13).type == ExcelError);
+
+  // Tests for the FORECAST function
+  ExcelValue forecast_array1[] = { new_excel_number(1), new_excel_number(2), new_excel_number(3), new_excel_number(4), new_excel_number(5)};
+  ExcelValue forecast_array2[] = { new_excel_number(2), new_excel_number(3), new_excel_number(4), new_excel_number(5), new_excel_number(6)};
+  ExcelValue forecast_array1_v = new_excel_range(forecast_array1,5,1);
+  ExcelValue forecast_array2_v = new_excel_range(forecast_array2,5,1);
+
+  assert(forecast(new_excel_number(0), forecast_array2_v, forecast_array1_v).number == 1);
+  assert(forecast(new_excel_number(1), forecast_array2_v, forecast_array1_v).number == 2);
+  assert(forecast(new_excel_number(6), forecast_array2_v, forecast_array1_v).number == 7);
+
+  ExcelValue forecast_array3[] = { BLANK, new_excel_number(2), new_excel_number(3), new_excel_number(4), BLANK};
+  ExcelValue forecast_array3_v = new_excel_range(forecast_array3,5,1);
+
+  assert(forecast(new_excel_number(6), forecast_array2_v, forecast_array3_v).number == 7);
 
   // Release memory
   free_all_allocated_memory();

data/src/compile/c/map_formulae_to_c.rb

@@ -30,6 +30,7 @@ class MapFormulaeToC < MapValuesToC
     :'ABS' => 'excel_abs',
     :'AND' => 'excel_and',
     :'AVERAGE' => 'average',
+    :'AVERAGEIFS' => 'averageifs',
     :'CHOOSE' => 'choose',
     :'CONCATENATE' => 'string_join',
     :'COSH' => 'cosh',
@@ -38,6 +39,7 @@ class MapFormulaeToC < MapValuesToC
     :'EXP' => 'excel_exp',
     :'FIND2' => 'find_2',
     :'FIND3' => 'find',
+    :'FORECAST' => 'forecast',
     :'HLOOKUP3' => 'hlookup_3',
     :'HLOOKUP4' => 'hlookup',
     :'IF2' => 'excel_if_2',
@@ -142,6 +144,10 @@ class MapFormulaeToC < MapValuesToC
     "#{FUNCTIONS[:SUMIFS]}(#{map(sum_range)}, #{map_arguments_to_array(criteria)})"
   end
 
+  def function_averageifs(average_range,*criteria)
+    "#{FUNCTIONS[:AVERAGEIFS]}(#{map(average_range)}, #{map_arguments_to_array(criteria)})"
+  end
+
   
   def any_number_of_argument_function(function_name,arguments)    
     "#{FUNCTIONS[function_name.to_sym]}(#{map_arguments_to_array(arguments)})"

data/src/compile/ruby/map_formulae_to_ruby.rb

@@ -19,6 +19,7 @@ class MapFormulaeToRuby < MapValuesToRuby
     :'ABS' => 'abs',
     :'AND' => 'excel_and',
     :'AVERAGE' => 'average',
+    :'AVERAGEIFS' => 'averageifs',
     :'CELL' => 'cell',
     :'CHOOSE' => 'choose',
     :'CONCATENATE' => 'string_join',
@@ -27,6 +28,7 @@ class MapFormulaeToRuby < MapValuesToRuby
     :'COUNTA' => 'counta',
     :'EXP' => 'exp',
     :'FIND' => 'find',
+    :'FORECAST' => 'forecast',
     :'HLOOKUP' => 'hlookup',
     :'IF' => 'excel_if',
     :'IFERROR' => 'iferror',

data/src/excel/excel_functions.rb

@@ -100,3 +100,7 @@ require_relative 'excel_functions/lower'
 require_relative 'excel_functions/exp'
 
 require_relative 'excel_functions/isblank'
+
+require_relative 'excel_functions/averageifs'
+
+require_relative 'excel_functions/forecast'

data/src/excel/excel_functions/averageifs.rb

@@ -0,0 +1,76 @@
+module ExcelFunctions
+  
+  def averageifs(average_range, *criteria)
+    # First, get rid of the errors
+    return average_range if average_range.is_a?(Symbol)
+    error = criteria.find { |a| a.is_a?(Symbol) }
+    return error if error
+    
+    # Sort out the average range
+    average_range = [average_range] unless average_range.is_a?(Array)
+    average_range = average_range.flatten
+    
+    # Sort out the criteria
+    0.step(criteria.length-1,2).each do |i|
+      if criteria[i].is_a?(Array)
+        criteria[i] = criteria[i].flatten
+      else
+        criteria[i] = [criteria[i]]
+      end
+    end
+      
+    # This will hold the items that pass the test
+    accumulator = []
+    
+    # Work through each part of the average range
+    average_range.each_with_index do |potential_average,index|
+      next unless potential_average.is_a?(Numeric)
+      
+      # If a criteria fails, this is set to false and no further criteria are evaluated
+      pass = true
+      
+      0.step(criteria.length-1,2).each do |i|
+        check_range = criteria[i]
+        required_value = criteria[i+1]
+        return :value if index >= check_range.length
+        check_value = check_range[index]
+        
+        pass = case check_value
+        when String
+          check_value.downcase == required_value.to_s.downcase
+        when true, false
+          check_value == required_value
+        when nil
+          required_value == ""
+        when Numeric
+          case required_value
+          when Numeric
+            check_value == required_value
+          when String
+            required_value =~ /^(<=|>=|<|>)?([-+]?[0-9]+\.?[0-9]*([eE][-+]?[0-9]+)?)$/
+            if $1 && $2
+              check_value.send($1,$2.to_f)
+            elsif $2
+              check_value == $2.to_f
+            else
+              false
+            end
+          else
+            check_value == required_value
+          end
+        end # case check_value
+                
+        break unless pass
+      end # criteria loop
+      
+      accumulator << potential_average if pass
+        
+      end
+
+      accumulator.delete_if { |a| !a.is_a?(Numeric) }
+      return :div0 if accumulator.empty?
+      accumulator.inject(0.0) { |m,i| m + i.to_f } / accumulator.size.to_f
+      
+  end
+  
+end

data/src/excel/excel_functions/forecast.rb

@@ -0,0 +1,44 @@
+module ExcelFunctions
+  
+  def forecast(required_x, known_y, known_x)
+    required_x = number_argument(required_x)
+    return required_x if required_x.is_a?(Symbol)
+    return :na unless known_y.is_a?(Array)
+    return :na unless known_x.is_a?(Array)
+    known_y = known_y.flatten
+    known_x = known_x.flatten
+    known_y.each { |y| return y if y.is_a?(Symbol) }
+    known_x.each { |x| return x if x.is_a?(Symbol) }
+    return :na unless known_x.length == known_y.length
+    return :na if known_y.empty?
+    return :na if known_x.empty?
+
+    0.upto(known_x.length-1).each do |i|
+      known_x[i] = nil unless known_y[i].is_a?(Numeric)
+      known_y[i] = nil unless known_x[i].is_a?(Numeric)
+    end
+
+    known_x.compact!
+    known_y.compact!
+
+    mean_y = known_y.inject(0.0) { |m,i| m + i.to_f }   / known_y.size.to_f
+    mean_x = known_x.inject(0.0) { |m,i| m + i.to_f }   / known_x.size.to_f
+
+    b_denominator = known_x.inject(0.0) { |s,x| x.is_a?(Numeric) ? (s + (x-mean_x)**2 ) : s  }
+    return :div0 if b_denominator == 0
+    b_numerator = 0.0
+    known_x.each.with_index do |x,i|
+      y = known_y[i]
+      next unless x.is_a?(Numeric)
+      next unless y.is_a?(Numeric)
+      b_numerator = b_numerator + ((x-mean_x)*(y-mean_y))
+    end
+
+    b = b_numerator / b_denominator
+
+    a = mean_y - (b * mean_x)
+
+    return a + (b*required_x)
+  end
+  
+end

data/src/excel_to_code.rb

@@ -1,7 +1,11 @@
+class ExcelToCode
+  def self.version() "0.2.11" end
+end
+
 require_relative 'commands'
 require_relative 'compile'
 require_relative 'excel'
 require_relative 'extract'
 require_relative 'rewrite'
 require_relative 'simplify'
-require_relative 'util'
+require_relative 'util'

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: excel_to_code
 version: !ruby/object:Gem::Version
-  version: 0.2.10
+  version: 0.2.11
 platform: ruby
 authors:
 - Thomas Counsell, Green on Black Ltd
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-02-01 00:00:00.000000000 Z
+date: 2014-02-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rubypeg
@@ -142,6 +142,7 @@ files:
 - src/excel/excel_functions/and.rb
 - src/excel/excel_functions/apply_to_range.rb
 - src/excel/excel_functions/average.rb
+- src/excel/excel_functions/averageifs.rb
 - src/excel/excel_functions/cell.rb
 - src/excel/excel_functions/choose.rb
 - src/excel/excel_functions/cosh.rb
@@ -153,6 +154,7 @@ files:
 - src/excel/excel_functions/excel_match.rb
 - src/excel/excel_functions/exp.rb
 - src/excel/excel_functions/find.rb
+- src/excel/excel_functions/forecast.rb
 - src/excel/excel_functions/hlookup.rb
 - src/excel/excel_functions/iferror.rb
 - src/excel/excel_functions/index.rb