excel_to_code 0.3.17 → 0.3.18.beta.1

data/src/commands/excel_to_c.rb

@@ -10,6 +10,8 @@ class ExcelToC < ExcelToX
   attr_accessor :create_makefile
   # If true, writes tests in C rather than in ruby
   attr_accessor :write_tests_in_c
+  # If true, allows unknown Excel functions rather than aborting
+  attr_accessor :allow_unknown_functions
   
   def set_defaults
     super
@@ -78,6 +80,7 @@ class ExcelToC < ExcelToX
     variable_set_counter = 0
     
     c = CompileToC.new
+    c.allow_unknown_functions = self.allow_unknown_functions
     c.variable_set_counter = variable_set_counter
     # Output the elements from each worksheet in turn
     c.settable = settable

data/src/commands/excel_to_go.rb

@@ -0,0 +1,91 @@
+# coding: utf-8
+
+require_relative 'excel_to_x'
+require 'pathname'
+
+class ExcelToGo < ExcelToX
+
+  def language
+    'go'
+  end  
+  
+  # Skip this
+  def replace_values_with_constants    
+  end
+  
+  # These actually create the code version of the excel
+  def write_code
+    write_out_excel_as_code
+    write_out_test_as_code
+  end
+    
+  def write_out_excel_as_code
+    log.info "Starting to write out code"
+
+    o = output("#{output_name.downcase}.go")
+
+    o.puts "// Compiled version of #{excel_file}"
+    o.puts "package #{output_name.downcase}"
+    o.puts
+    o.puts excel_lib_imports
+    o.puts
+
+    c = CompileToGo.new
+    c.settable = settable
+    c.gettable = gettable
+    c.rewrite @formulae, @worksheet_c_names, o
+    o.puts
+
+    o.puts excel_lib_functions
+    o.puts 
+
+    close(o)
+    log.info "Finished writing code"
+
+  end
+
+  def excel_lib
+    @excel_lib ||= IO.readlines(File.join(File.dirname(__FILE__),'..','compile','go','excel.go')).join
+  end
+
+  def excel_lib_imports
+    excel_lib[/import \(.*?\)/m]
+  end
+
+  def excel_lib_functions
+    excel_lib[/import \(.*?\)(.*)/m,1]
+  end
+
+  def write_out_test_as_code
+    log.info "Starting to write out test"
+    
+    o = output("#{output_name.downcase}_test.go")
+
+    o.puts "// Test of compiled version of #{excel_file}"
+    o.puts "package #{output_name.downcase}"
+    o.puts
+    o.puts "import ("
+    o.puts "    \"testing\""
+    o.puts ")"
+    o.puts
+
+    c = CompileToGoTest.new
+    c.settable = settable
+    c.gettable = gettable
+    c.rewrite @formulae, @worksheet_c_names, o
+    o.puts
+
+    close(o)
+    log.info "Finished writing tests"
+  end
+  
+  def compile_code
+    # Not needed
+  end
+  
+  def run_tests
+    return unless actually_run_tests
+    log.info "Running the resulting tests"
+    log.info `cd #{File.join(output_directory)}; go test`
+  end
+end

data/src/commands/excel_to_x.rb

@@ -6,6 +6,7 @@ class XMLFileNotFoundException < Exception; end
 require 'fileutils'
 require 'logger'
 require 'tmpdir'
+require 'shellwords'
 require_relative '../excel_to_code'
 
 # FIXME: Correct case for all worksheet references
@@ -121,6 +122,22 @@ class ExcelToX
   # cells on tha sheet and nothing else.
   attr_accessor :isolate
 
+  # Optional attribute, Boolean. Default false
+  # If set to true, will persevere through some errors where it can rather than aborting
+  # immediately. This can be helpful in getting to grips with conversion errors on a 
+  # really messy sheet, since it allows you to see all the errors at once and which are 
+  # really fatal.
+  attr_accessor :persevere
+  
+  # This is a private method, default is a hash, keys are cell references.
+  # The code will dump debuging information about the given cells as they
+  # progress through the conversion
+  attr_accessor :dump_steps
+
+  # This is a method to use carefull, if true will not abort on external references, but instead
+  # treat them as local references.
+  attr_accessor :treat_external_references_as_local
+
   # This is the main method. Once all the above attributes have been set, it should be called to actually do the work.
   def go!
     # This sorts out the settings
@@ -226,6 +243,9 @@ class ExcelToX
     # Make sure the relevant directories exist
     self.excel_file = File.expand_path(excel_file)
     self.output_directory = File.expand_path(output_directory)
+
+    # For debugging
+    self.dump_steps ||= {}
     
     # Set up our log file
     unless self.log
@@ -268,8 +288,20 @@ class ExcelToX
   
   # FIXME: Replace these with pure ruby versions?
   def unzip_excel
-    log.info "Removing any old xml #{`rm -fr '#{xml_directory}'`}" # Force delete
-    log.info "Unziping excel into xml #{`unzip -q '#{excel_file}' -d '#{xml_directory}'`}" # If don't force delete, make sure that force the zip to overwrite old files 
+    log.info "Removing old folders"
+    execute_system_command 'rm', '-fr', xml_directory
+    log.info "Unzipping the spreadsheet"
+    execute_system_command 'unzip', '-q', excel_file, '-d', xml_directory
+  end
+
+  def execute_system_command(*args) 
+    c = args.shelljoin
+    output = `#{c}`
+    unless $?.exitstatus == 0
+      log.error "Command failed: #{c}"
+      log.error output
+      exit 1
+    end
   end
   
   # The excel workbook.xml and allied relationship files knows about
@@ -308,16 +340,24 @@ class ExcelToX
     # Then we parse them
     @named_references.each do |name, reference|
       begin
-        parsed = CachingFormulaParser.parse(reference)
+        parsed = CachingFormulaParser.parse(reference, treat_external_references_as_local)
         if parsed
           @named_references[name] = parsed
         else
           $stderr.puts "Named reference #{name} #{reference} not parsed"
           exit
         end
-      rescue Exception
-        $stderr.puts "Named reference #{name} #{reference} not parsed"
-        raise
+      rescue Exception => e
+        if e.respond_to?(:'ref=')
+          e.ref = ['Named reference', name]
+        end
+        if persevere 
+          $stderr.puts e.message
+          $stderr.puts "--persevere true, so setting #{name} = #REF!"
+          @named_references[name] = [:error, "#REF!"]
+        else
+          raise
+        end
       end
     end
 
@@ -441,6 +481,10 @@ class ExcelToX
     # Named references_to_keep can be passed a block, in which case this loops
     # through offering up the named references. If the block returns true then
     # the named reference is kept
+    if named_references_to_keep == :all
+      @named_references_to_keep = @named_references.keys.concat(@table_areas.keys)
+    end
+
     if named_references_to_keep.is_a?(Proc)
       new_named_references_to_keep = @named_references.keys.select do |named_reference|
         named_references_to_keep.call(named_reference)
@@ -495,6 +539,7 @@ class ExcelToX
     # All are hashes of the format ["SheetName", "A1"] => [:number, "1"]
     # This one has a series of table references
     extractor = ExtractDataFromWorksheet.new
+    extractor.persevere = persevere
     
     # Loop through the worksheets
     # FIXME: make xml_filename be the IO object?
@@ -857,7 +902,7 @@ class ExcelToX
         sheet = ref[1]
         cell = Reference.for(ref[2][1]).unfix.to_sym
         s = cells_that_can_be_set[sheet]
-        if s && s.include?(cell)
+        if s && ( s == :all || s.include?(cell) )
           @named_references_that_can_be_set_at_runtime << name 
           cells_that_can_be_set_due_to_named_reference[sheet] << cell.to_sym
           cells_that_can_be_set_due_to_named_reference[sheet].uniq!
@@ -902,6 +947,11 @@ class ExcelToX
     end
 
   end
+
+  def debug_dump(ref, ast, location = "")
+    return unless dump_steps[ref]
+    puts "#{location}: #{ref} = #{ast}" 
+  end
     
   def simplify(cells = @formulae)
     log.info "Simplifying cells"
@@ -923,6 +973,7 @@ class ExcelToX
     #require 'pry'; binding.pry
 
     cells.each do |ref, ast|
+      debug_dump(ref, ast, "simplify 1 - start")
       begin
         @sheetless_cell_reference_replacer.worksheet = ref.first
         @sheetless_cell_reference_replacer.map(ast)
@@ -932,6 +983,17 @@ class ExcelToX
         @table_reference_replacer.worksheet = ref.first
         @table_reference_replacer.referring_cell = ref.last
         @table_reference_replacer.map(ast)
+        column_and_row_function_replacement.current_reference = ref.last
+        column_and_row_function_replacement.replace(ast)
+      rescue  Exception => e
+        log.fatal "Exception when simplifying #{ref}: #{ast}"
+        raise
+      end
+      debug_dump(ref, ast, "simplify 1 - finish")
+    end
+    cells.each do |ref, ast|
+      debug_dump(ref, ast, "simplify 2 - start")
+      begin
         @replace_ranges_with_array_literals_replacer.map(ast)
         @replace_arrays_with_single_cells_replacer.ref = ref
         a = @replace_arrays_with_single_cells_replacer.map(ast)
@@ -941,8 +1003,6 @@ class ExcelToX
         @replace_arithmetic_on_ranges_replacer.map(ast)
         @replace_string_joins_on_ranges_replacer.map(ast)
         @wrap_formulae_that_return_arrays_replacer.map(ast)
-        column_and_row_function_replacement.current_reference = ref.last
-        column_and_row_function_replacement.replace(ast)
         @replace_references_to_blanks_with_zeros.current_sheet_name = ref.first
         @replace_references_to_blanks_with_zeros.map(ast)
         @fix_subtotal_of_subtotals.map(ast)
@@ -950,6 +1010,7 @@ class ExcelToX
         log.fatal "Exception when simplifying #{ref}: #{ast}"
         raise
       end
+      debug_dump(ref, ast, "simplify 2 - finish")
     end
   end
 
@@ -1014,6 +1075,7 @@ class ExcelToX
     indirect_replacement = ReplaceIndirectsWithReferencesAst.new
     column_and_row_function_replacement = ReplaceColumnAndRowFunctionsAST.new
     offset_replacement = ReplaceOffsetsWithReferencesAst.new
+    cell_address_replacement = ReplaceCellAddressesWithReferencesAst.new
 
     begin 
       number_of_passes += 1
@@ -1024,6 +1086,7 @@ class ExcelToX
       value_replacer.replacements_made_in_the_last_pass = 0
       column_and_row_function_replacement.count_replaced = 0
       offset_replacement.count_replaced = 0
+      cell_address_replacement.count_replaced = 0
       indirect_replacement.count_replaced = 0
       references_that_need_updating = {}
 
@@ -1036,6 +1099,9 @@ class ExcelToX
           if offset_replacement.replace(ast)
             references_that_need_updating[ref] = ast
           end
+          if cell_address_replacement.replace(ast)
+            references_that_need_updating[ref] = ast
+          end
           # FIXME: Shouldn't need to wrap ref.fist in an array
           inline_replacer.current_sheet_name = [ref.first]
           inline_replacer.map(ast)
@@ -1051,7 +1117,6 @@ class ExcelToX
           raise
         end
       end
-      
 
       @named_references.each do |ref, ast|
         inline_replacer.current_sheet_name = ref.is_a?(Array) ? [ref.first] : []
@@ -1064,6 +1129,7 @@ class ExcelToX
       replacements_made_in_the_last_pass += value_replacer.replacements_made_in_the_last_pass
       replacements_made_in_the_last_pass += column_and_row_function_replacement.count_replaced
       replacements_made_in_the_last_pass += offset_replacement.count_replaced
+      replacements_made_in_the_last_pass += cell_address_replacement.count_replaced
       replacements_made_in_the_last_pass += indirect_replacement.count_replaced
 
       log.info "Pass #{number_of_passes}: Made #{replacements_made_in_the_last_pass} replacements"
@@ -1352,7 +1418,7 @@ class ExcelToX
     args.flatten!
     File.open(File.join(output_directory,*args),'w')
   end
-  
+
   def close(*args)
     args.map do |f|
       next if f.is_a?(StringIO)

data/src/compile.rb

@@ -1,2 +1,3 @@
 require_relative 'compile/ruby'
 require_relative 'compile/c'
+require_relative 'compile/go'

data/src/compile/c/compile_to_c.rb

@@ -5,6 +5,7 @@ class CompileToC
   attr_accessor :settable
   attr_accessor :gettable
   attr_accessor :variable_set_counter
+  attr_accessor :allow_unknown_functions
   
   def self.rewrite(*args)
     self.new.rewrite(*args)
@@ -16,6 +17,7 @@ class CompileToC
     @variable_set_counter ||= 0
 
     mapper = MapFormulaeToC.new
+    mapper.allow_unknown_functions = self.allow_unknown_functions
     mapper.sheet_names = sheet_names
     formulae.each do |ref, ast|
       begin

data/src/compile/c/excel_to_c_runtime.c

@@ -11,7 +11,7 @@
 #endif
 
 #ifndef EXCEL_FILENAME
-  #define EXCEL_FILENAME "NoExcelFilename" 
+  #define EXCEL_FILENAME "NoExcelFilename"
 #endif
 
 // Need to retain malloc'd values for a while, so can return to functions that use this library
@@ -27,10 +27,10 @@ typedef enum {ExcelEmpty, ExcelNumber, ExcelString, ExcelBoolean, ExcelError, Ex
 
 struct excel_value {
 	ExcelType type;
-	
+
 	double number; // Used for numbers and for error types
 	char *string; // Used for strings
-	
+
 	// The following three are used for ranges
 	void *array;
 	int rows;
@@ -59,6 +59,8 @@ 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 excel_char(ExcelValue number_v);
+static ExcelValue excel_ceiling_math_2(ExcelValue number_v, ExcelValue multiple_v);
+static ExcelValue excel_ceiling_math(ExcelValue number_v, ExcelValue multiple_v, ExcelValue mode_v);
 static ExcelValue ensure_is_number(ExcelValue maybe_number_v);
 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);
@@ -84,7 +86,9 @@ static ExcelValue max(int number_of_arguments, ExcelValue *arguments);
 static ExcelValue min(int number_of_arguments, ExcelValue *arguments);
 static ExcelValue mmult(ExcelValue a_v, ExcelValue b_v);
 static ExcelValue mod(ExcelValue a_v, ExcelValue b_v);
+static ExcelValue na();
 static ExcelValue negative(ExcelValue a_v);
+static ExcelValue excel_not(ExcelValue a_v);
 static ExcelValue number_or_zero(ExcelValue maybe_number_v);
 static ExcelValue npv(ExcelValue rate, int number_of_arguments, ExcelValue *arguments);
 static ExcelValue pmt(ExcelValue rate_v, ExcelValue number_of_periods_v, ExcelValue present_value_v);
@@ -112,6 +116,19 @@ static ExcelValue text(ExcelValue number_v, ExcelValue format_v);
 static ExcelValue value(ExcelValue string_v);
 static ExcelValue vlookup_3(ExcelValue lookup_value_v,ExcelValue lookup_table_v, ExcelValue column_number_v);
 static ExcelValue vlookup(ExcelValue lookup_value_v,ExcelValue lookup_table_v, ExcelValue column_number_v, ExcelValue match_type_v);
+static ExcelValue scurve_4(ExcelValue currentYear, ExcelValue startValue, ExcelValue endValue, ExcelValue duration);
+static ExcelValue scurve(ExcelValue currentYear, ExcelValue startValue, ExcelValue endValue, ExcelValue duration, ExcelValue startYear);
+static ExcelValue halfscurve_4(ExcelValue currentYear, ExcelValue startValue, ExcelValue endValue, ExcelValue duration);
+static ExcelValue halfscurve(ExcelValue currentYear, ExcelValue startValue, ExcelValue endValue, ExcelValue duration, ExcelValue startYear);
+static ExcelValue lcurve_4(ExcelValue currentYear, ExcelValue startValue, ExcelValue endValue, ExcelValue duration);
+static ExcelValue lcurve(ExcelValue currentYear, ExcelValue startValue, ExcelValue endValue, ExcelValue duration, ExcelValue startYear);
+static ExcelValue curve_5(ExcelValue curveType, ExcelValue currentYear, ExcelValue startValue, ExcelValue endValue, ExcelValue duration);
+static ExcelValue curve(ExcelValue curveType, ExcelValue currentYear, ExcelValue startValue, ExcelValue endValue, ExcelValue duration, ExcelValue startYear);
+
+static ExcelValue product(int number_of_arguments, ExcelValue *arguments);
+static ExcelValue excel_floor(ExcelValue number_v, ExcelValue multiple_v);
+static ExcelValue rate(ExcelValue a1, ExcelValue a2, ExcelValue a3, ExcelValue a4);
+static ExcelValue excel_sqrt(ExcelValue number_v);
 
 // My little heap for keeping pointers to memory that I need to reclaim
 void **memory_that_needs_to_be_freed;
@@ -119,7 +136,7 @@ int memory_that_needs_to_be_freed_counter = 0;
 int memory_that_needs_to_be_freed_size = -1;
 
 static void free_later(void *pointer) {
-	if(memory_that_needs_to_be_freed_counter >= memory_that_needs_to_be_freed_size) { 
+	if(memory_that_needs_to_be_freed_counter >= memory_that_needs_to_be_freed_size) {
     if(memory_that_needs_to_be_freed_size <= 0) {
       memory_that_needs_to_be_freed = malloc(MEMORY_TO_BE_FREED_LATER_HEAP_INCREMENT*sizeof(void*));
       memory_that_needs_to_be_freed_size = MEMORY_TO_BE_FREED_LATER_HEAP_INCREMENT;
@@ -221,7 +238,7 @@ static void inspect_excel_value(ExcelValue v) {
 	  	if(v.number == 0) {
 	  		printf("Empty\n");
 		} else {
-			printf("Empty with unexpected state %f\n",v.number);	
+			printf("Empty with unexpected state %f\n",v.number);
 		}
 		break;
 	  case ExcelRange:
@@ -264,18 +281,18 @@ static double number_from(ExcelValue v) {
 	ExcelValue *array;
 	switch (v.type) {
   	  case ExcelNumber:
-	  case ExcelBoolean: 
+	  case ExcelBoolean:
 	  	return v.number;
-	  case ExcelEmpty: 
+	  case ExcelEmpty:
 	  	return 0;
-	  case ExcelRange: 
+	  case ExcelRange:
 		 array = v.array;
 	     return number_from(array[0]);
 	  case ExcelString:
  	 	s = v.string;
 		if (s == NULL || *s == '\0' || isspace(*s)) {
 			return 0;
-		}	        
+		}
 		n = strtod (s, &p);
 		if(*p == '\0') {
 			return n;
@@ -291,12 +308,12 @@ static double number_from(ExcelValue v) {
 #define NUMBER(value_name, name) double name; if(value_name.type == ExcelError) { return value_name; }; name = number_from(value_name);
 #define CHECK_FOR_CONVERSION_ERROR 	if(conversion_error) { conversion_error = 0; return VALUE; };
 #define CHECK_FOR_PASSED_ERROR(name) 	if(name.type == ExcelError) return name;
-	
+
 static ExcelValue excel_abs(ExcelValue a_v) {
-	CHECK_FOR_PASSED_ERROR(a_v)	
+	CHECK_FOR_PASSED_ERROR(a_v)
 	NUMBER(a_v, a)
 	CHECK_FOR_CONVERSION_ERROR
-	
+
 	if(a >= 0.0 ) {
 		return a_v;
 	} else {
@@ -305,7 +322,7 @@ static ExcelValue excel_abs(ExcelValue a_v) {
 }
 
 static ExcelValue excel_char(ExcelValue a_v) {
-	CHECK_FOR_PASSED_ERROR(a_v)	
+	CHECK_FOR_PASSED_ERROR(a_v)
 	NUMBER(a_v, a)
 	CHECK_FOR_CONVERSION_ERROR
   if(a <= 0) { return VALUE; }
@@ -387,18 +404,88 @@ static ExcelValue excel_exp(ExcelValue number_v) {
   return	EXCEL_NUMBER(exp(n));
 }
 
+static ExcelValue excel_sqrt(ExcelValue number_v) {
+	CHECK_FOR_PASSED_ERROR(number_v)
+	NUMBER(number_v, n)
+	CHECK_FOR_CONVERSION_ERROR
+
+  if(n<0) { return NUM; }
+
+  return	EXCEL_NUMBER(sqrt(n));
+}
+
+static ExcelValue excel_floor(ExcelValue number_v, ExcelValue multiple_v) {
+  CHECK_FOR_PASSED_ERROR(number_v)
+  CHECK_FOR_PASSED_ERROR(multiple_v)
+	NUMBER(number_v, n)
+  NUMBER(multiple_v, m)
+	CHECK_FOR_CONVERSION_ERROR
+  if(m == 0) { return DIV0; }
+  if(m < 0) { return NUM; }
+  return EXCEL_NUMBER((n - fmod(n, m)));
+}
+
+static ExcelValue excel_ceiling_math_2(ExcelValue number_v, ExcelValue multiple_v) {
+  return excel_ceiling_math(number_v, multiple_v, ZERO);
+}
+
+static ExcelValue excel_ceiling_math(ExcelValue number_v, ExcelValue multiple_v, ExcelValue mode_v) {
+  CHECK_FOR_PASSED_ERROR(number_v)
+  CHECK_FOR_PASSED_ERROR(multiple_v)
+  CHECK_FOR_PASSED_ERROR(mode_v)
+	NUMBER(number_v, n)
+  NUMBER(multiple_v, m)
+  NUMBER(mode_v, d)
+	CHECK_FOR_CONVERSION_ERROR
+  if(m == 0) { return ZERO; }
+    
+  if(d == 0 || n > 0 ) {
+    double remainder = fmod(n, m);
+    if(remainder == 0) {
+      return number_v;
+    } else {
+      return EXCEL_NUMBER(((double) ceil(n/m))*m);
+    }
+    
+    
+  } else { // Need to round negative away from zero
+    return negative(excel_ceiling_math(excel_abs(number_v), multiple_v, mode_v));
+  }
+  
+  return EXCEL_NUMBER((n - fmod(n, m)));
+}
+
+static ExcelValue rate(ExcelValue periods_v, ExcelValue payment_v, ExcelValue presentValue_v, ExcelValue finalValue_v) {
+  CHECK_FOR_PASSED_ERROR(periods_v)
+  CHECK_FOR_PASSED_ERROR(payment_v)
+  CHECK_FOR_PASSED_ERROR(presentValue_v)
+  CHECK_FOR_PASSED_ERROR(finalValue_v)
+
+  NUMBER(periods_v, periods)
+  NUMBER(payment_v, payment)
+  NUMBER(presentValue_v, presentValue)
+  NUMBER(finalValue_v, finalValue)
+
+  // FIXME: Only implemented the case where payment is zero
+  if(payment != 0) {
+    return NA;
+  }
+
+  return EXCEL_NUMBER(pow((finalValue/(-presentValue)),(1.0/periods))-1.0);
+}
+
 static ExcelValue excel_and(int array_size, ExcelValue *array) {
 	int i;
 	ExcelValue current_excel_value, array_result;
-	
+
 	for(i=0;i<array_size;i++) {
 		current_excel_value = array[i];
 		switch (current_excel_value.type) {
-	  	  case ExcelNumber: 
-		  case ExcelBoolean: 
+	  	  case ExcelNumber:
+		  case ExcelBoolean:
 			  if(current_excel_value.number == false) return FALSE;
 			  break;
-		  case ExcelRange: 
+		  case ExcelRange:
 		  	array_result = excel_and( current_excel_value.rows * current_excel_value.columns, current_excel_value.array );
 			if(array_result.type == ExcelError) return array_result;
 			if(array_result.type == ExcelBoolean && array_result.number == false) return FALSE;
@@ -414,20 +501,71 @@ static ExcelValue excel_and(int array_size, ExcelValue *array) {
 	 return TRUE;
 }
 
+static ExcelValue excel_or(int array_size, ExcelValue *array) {
+	int i;
+	ExcelValue current_excel_value, array_result;
+
+	for(i=0;i<array_size;i++) {
+		current_excel_value = array[i];
+		switch (current_excel_value.type) {
+	  	case ExcelNumber:
+		  case ExcelBoolean:
+			  if(current_excel_value.number == true) return TRUE;
+			  break;
+		  case ExcelRange:
+		  	array_result = excel_or( current_excel_value.rows * current_excel_value.columns, current_excel_value.array );
+        if(array_result.type == ExcelError) return array_result;
+        if(array_result.type == ExcelBoolean && array_result.number == true) return TRUE;
+        break;
+		  case ExcelString:
+		  case ExcelEmpty:
+        break;
+		  case ExcelError:
+			 return current_excel_value;
+			 break;
+		 }
+	 }
+	 return FALSE;
+}
+
+static ExcelValue excel_not(ExcelValue boolean_v) {
+  switch (boolean_v.type) {
+    case ExcelNumber:
+      if(boolean_v.number == 0) return TRUE;
+      return FALSE;
+
+    case ExcelBoolean:
+      if(boolean_v.number == false) return TRUE;
+      return FALSE;
+
+    case ExcelRange:
+      return VALUE;
+
+    case ExcelString:
+      return VALUE;
+
+    case ExcelEmpty:
+      return TRUE;
+
+    case ExcelError:
+      return boolean_v;
+  }
+}
+
 struct average_result {
 	double sum;
 	double count;
 	int has_error;
 	ExcelValue error;
 };
-	
+
 static struct average_result calculate_average(int array_size, ExcelValue *array) {
 	double sum = 0;
 	double count = 0;
 	int i;
 	ExcelValue current_excel_value;
 	struct average_result array_result, r;
-		 
+
 	for(i=0;i<array_size;i++) {
 		current_excel_value = array[i];
 		switch (current_excel_value.type) {
@@ -435,13 +573,13 @@ static struct average_result calculate_average(int array_size, ExcelValue *array
 			  sum += current_excel_value.number;
 			  count++;
 			  break;
-		  case ExcelRange: 
+		  case ExcelRange:
 		  	array_result = calculate_average( current_excel_value.rows * current_excel_value.columns, current_excel_value.array );
 			if(array_result.has_error == true) return array_result;
 			sum += array_result.sum;
 			count += array_result.count;
 			break;
-		  case ExcelBoolean: 
+		  case ExcelBoolean:
 		  case ExcelString:
 		  case ExcelEmpty:
 			 break;
@@ -511,7 +649,7 @@ static ExcelValue forecast(ExcelValue required_x_v, ExcelValue known_y, ExcelVal
   float my = mean_y.number;
 
   float b_numerator, b_denominator, b, a;
-  
+
   b_denominator = 0;
   b_numerator = 0;
 
@@ -537,7 +675,7 @@ static ExcelValue choose(ExcelValue index_v, int array_size, ExcelValue *array)
 	CHECK_FOR_PASSED_ERROR(index_v)
 
 	int index = (int) number_from(index_v);
-	CHECK_FOR_CONVERSION_ERROR	
+	CHECK_FOR_CONVERSION_ERROR
 	int i;
 	for(i=0;i<array_size;i++) {
 		if(array[i].type == ExcelError) return array[i];
@@ -545,23 +683,23 @@ static ExcelValue choose(ExcelValue index_v, int array_size, ExcelValue *array)
 	if(index < 1) return VALUE;
 	if(index > array_size) return VALUE;
 	return array[index-1];
-}	
+}
 
 static ExcelValue count(int array_size, ExcelValue *array) {
 	int i;
 	int n = 0;
 	ExcelValue current_excel_value;
-	
+
 	for(i=0;i<array_size;i++) {
 		current_excel_value = array[i];
 		switch (current_excel_value.type) {
 	  	  case ExcelNumber:
 		  	n++;
 			break;
-		  case ExcelRange: 
+		  case ExcelRange:
 		  	n += count( current_excel_value.rows * current_excel_value.columns, current_excel_value.array ).number;
 			break;
-  		  case ExcelBoolean: 			
+  		  case ExcelBoolean:
 		  case ExcelString:
 		  case ExcelEmpty:
 		  case ExcelError:
@@ -575,7 +713,7 @@ static ExcelValue counta(int array_size, ExcelValue *array) {
 	int i;
 	int n = 0;
 	ExcelValue current_excel_value;
-	
+
 	for(i=0;i<array_size;i++) {
 		current_excel_value = array[i];
     switch(current_excel_value.type) {
@@ -585,7 +723,7 @@ static ExcelValue counta(int array_size, ExcelValue *array) {
   	  case ExcelError:
         n++;
         break;
-      case ExcelRange: 
+      case ExcelRange:
 	  	  n += counta( current_excel_value.rows * current_excel_value.columns, current_excel_value.array ).number;
         break;
   	  case ExcelEmpty:
@@ -610,11 +748,11 @@ static ExcelValue excel_equal(ExcelValue a_v, ExcelValue b_v) {
 	CHECK_FOR_PASSED_ERROR(b_v)
 
 	if(a_v.type != b_v.type) return FALSE;
-	
+
 	switch (a_v.type) {
   	case ExcelNumber:
-	  case ExcelBoolean: 
-	  case ExcelEmpty: 
+	  case ExcelBoolean:
+	  case ExcelEmpty:
 			if(a_v.number != b_v.number) return FALSE;
 			return TRUE;
 	  case ExcelString:
@@ -655,7 +793,7 @@ static ExcelValue excel_isblank(ExcelValue value) {
 
 static ExcelValue excel_if(ExcelValue condition, ExcelValue true_case, ExcelValue false_case ) {
 	CHECK_FOR_PASSED_ERROR(condition)
-	
+
 	switch (condition.type) {
   	  case ExcelBoolean:
   	  	if(condition.number == true) return true_case;
@@ -663,7 +801,7 @@ static ExcelValue excel_if(ExcelValue condition, ExcelValue true_case, ExcelValu
   	  case ExcelNumber:
 		if(condition.number == false) return false_case;
 		return true_case;
-	  case ExcelEmpty: 
+	  case ExcelEmpty:
 		return false_case;
 	  case ExcelString:
 	  	return VALUE;
@@ -683,15 +821,15 @@ static ExcelValue excel_index(ExcelValue array_v, ExcelValue row_number_v, Excel
 	CHECK_FOR_PASSED_ERROR(array_v)
 	CHECK_FOR_PASSED_ERROR(row_number_v)
 	CHECK_FOR_PASSED_ERROR(column_number_v)
-		
+
 	ExcelValue *array;
 	int rows;
 	int columns;
-	
+
 	NUMBER(row_number_v, row_number)
 	NUMBER(column_number_v, column_number)
 	CHECK_FOR_CONVERSION_ERROR
-	
+
 	if(array_v.type == ExcelRange) {
 		array = array_v.array;
 		rows = array_v.rows;
@@ -702,13 +840,13 @@ static ExcelValue excel_index(ExcelValue array_v, ExcelValue row_number_v, Excel
 		rows = 1;
 		columns = 1;
 	}
-	
+
 	if(row_number > rows) return REF;
 	if(column_number > columns) return REF;
 
   if(row_number == 0 && rows == 1) row_number = 1;
   if(column_number == 0 && columns == 1) column_number = 1;
-		
+
 	if(row_number == 0) { // We need the whole column
 		if(column_number < 1) return REF;
 		ExcelValue *result = (ExcelValue *) new_excel_value_array(rows);
@@ -723,7 +861,7 @@ static ExcelValue excel_index(ExcelValue array_v, ExcelValue row_number_v, Excel
 				result[result_index] = ZERO;
 			} else {
 				result[result_index] = r;
-			}			
+			}
 			result_index++;
 		}
 		return EXCEL_RANGE(result,rows,1);
@@ -753,7 +891,7 @@ static ExcelValue excel_index(ExcelValue array_v, ExcelValue row_number_v, Excel
 		if(result.type == ExcelEmpty) return ZERO;
 		return result;
 	}
-	
+
 	return FALSE;
 };
 
@@ -798,7 +936,7 @@ static ExcelValue large(ExcelValue range_v, ExcelValue k_v) {
   }
 
   // Otherwise grumble if not a range
-  if(!range_v.type == ExcelRange) { return VALUE; }
+  if(range_v.type != ExcelRange) { return VALUE; }
 
   // Check that our k is within bounds
   if(k < 1) { return NUM; }
@@ -810,7 +948,7 @@ static ExcelValue large(ExcelValue range_v, ExcelValue k_v) {
   int sorted_size = 0;
   ExcelValue *array_v = range_v.array;
   ExcelValue x_v;
-  int i; 
+  int i;
   for(i = 0; i < range_size; i++ ) {
     x_v = array_v[i];
     if(x_v.type == ExcelError) { free(sorted); return x_v; };
@@ -834,7 +972,7 @@ static ExcelValue excel_match(ExcelValue lookup_value, ExcelValue lookup_array,
 	CHECK_FOR_PASSED_ERROR(lookup_value)
 	CHECK_FOR_PASSED_ERROR(lookup_array)
 	CHECK_FOR_PASSED_ERROR(match_type)
-		
+
 	// Blanks are treaked as zeros
 	if(lookup_value.type == ExcelEmpty) lookup_value = ZERO;
 
@@ -856,13 +994,13 @@ static ExcelValue excel_match(ExcelValue lookup_value, ExcelValue lookup_array,
 		ExcelValue tmp_array[1] = {lookup_array};
 		array = tmp_array;
 	}
-    
+
 	int type = (int) number_from(match_type);
 	CHECK_FOR_CONVERSION_ERROR;
-	
+
 	int i;
 	ExcelValue x;
-	
+
 	switch(type) {
 		case 0:
 			for(i = 0; i < size; i++ ) {
@@ -875,7 +1013,7 @@ static ExcelValue excel_match(ExcelValue lookup_value, ExcelValue lookup_array,
 		case 1:
 			for(i = 0; i < size; i++ ) {
 				x = array[i];
-				if(x.type == ExcelEmpty) x = ZERO;
+				if(lookup_value.type != x.type ) { continue; }
 				if(more_than(x,lookup_value).number == true) {
 					if(i==0) return NA;
 					return EXCEL_NUMBER(i);
@@ -886,7 +1024,7 @@ static ExcelValue excel_match(ExcelValue lookup_value, ExcelValue lookup_array,
 		case -1:
 			for(i = 0; i < size; i++ ) {
 				x = array[i];
-				if(x.type == ExcelEmpty) x = ZERO;
+        if(lookup_value.type != x.type ) { continue; }
 				if(less_than(x,lookup_value).number == true) {
 					if(i==0) return NA;
 					return EXCEL_NUMBER(i);
@@ -907,14 +1045,14 @@ static ExcelValue find(ExcelValue find_text_v, ExcelValue within_text_v, ExcelVa
 	CHECK_FOR_PASSED_ERROR(within_text_v)
 	CHECK_FOR_PASSED_ERROR(start_number_v)
 
-	char *find_text;	
+	char *find_text;
 	char *within_text;
 	char *within_text_offset;
 	char *result;
 	int start_number = number_from(start_number_v);
 	CHECK_FOR_CONVERSION_ERROR
 
-	// Deal with blanks 
+	// Deal with blanks
 	if(within_text_v.type == ExcelString) {
 		within_text = within_text_v.string;
 	} else if( within_text_v.type == ExcelEmpty) {
@@ -926,11 +1064,11 @@ static ExcelValue find(ExcelValue find_text_v, ExcelValue within_text_v, ExcelVa
 	} else if( find_text_v.type == ExcelEmpty) {
 		return start_number_v;
 	}
-	
+
 	// Check length
 	if(start_number < 1) return VALUE;
 	if(start_number > strlen(within_text)) return VALUE;
-	
+
 	// Offset our within_text pointer
 	// FIXME: No way this is utf-8 compatible
 	within_text_offset = within_text + (start_number - 1);
@@ -950,7 +1088,7 @@ static ExcelValue left(ExcelValue string_v, ExcelValue number_of_characters_v) {
 	CHECK_FOR_PASSED_ERROR(number_of_characters_v)
 	if(string_v.type == ExcelEmpty) return BLANK;
 	if(number_of_characters_v.type == ExcelEmpty) return BLANK;
-	
+
 	int number_of_characters = (int) number_from(number_of_characters_v);
 	CHECK_FOR_CONVERSION_ERROR
 
@@ -980,7 +1118,7 @@ static ExcelValue left(ExcelValue string_v, ExcelValue number_of_characters_v) {
 			  string = "FALSE";
 		  }
 		  break;
-	  case ExcelEmpty:	  	 
+	  case ExcelEmpty:
   	case ExcelError:
   	case ExcelRange:
 		  return string_v;
@@ -989,7 +1127,7 @@ static ExcelValue left(ExcelValue string_v, ExcelValue number_of_characters_v) {
   if(number_of_characters > strlen(string)) {
     number_of_characters = strlen(string);
   }
-	
+
 	char *left_string = malloc(number_of_characters+1); // Freed
 	if(left_string == 0) {
 	  printf("Out of memoryn in left");
@@ -1034,7 +1172,7 @@ static ExcelValue len(ExcelValue string_v) {
 			  string = "FALSE";
 		  }
 		  break;
-	  case ExcelEmpty:	  	 
+	  case ExcelEmpty:
   	case ExcelError:
   	case ExcelRange:
 		  return string_v;
@@ -1052,7 +1190,7 @@ static ExcelValue right(ExcelValue string_v, ExcelValue number_of_characters_v)
 	CHECK_FOR_PASSED_ERROR(number_of_characters_v)
 	if(string_v.type == ExcelEmpty) return BLANK;
 	if(number_of_characters_v.type == ExcelEmpty) return BLANK;
-	
+
 	int number_of_characters = (int) number_from(number_of_characters_v);
 	CHECK_FOR_CONVERSION_ERROR
 
@@ -1082,12 +1220,12 @@ static ExcelValue right(ExcelValue string_v, ExcelValue number_of_characters_v)
 			  string = "FALSE";
 		  }
 		  break;
-	  case ExcelEmpty:	  	 
+	  case ExcelEmpty:
   	case ExcelError:
   	case ExcelRange:
 		  return string_v;
 	}
-	
+
 	char *right_string = malloc(number_of_characters+1); // Freed
 	if(right_string == 0) {
 	  printf("Out of memory in right");
@@ -1149,18 +1287,18 @@ static ExcelValue more_than(ExcelValue a_v, ExcelValue b_v) {
     case ExcelString:
       switch (b_v.type) {
         case ExcelString:
-          if(strcasecmp(a_v.string,b_v.string) <= 0 ) {return FALSE;} else {return TRUE;} 
-        case ExcelNumber: 
+          if(strcasecmp(a_v.string,b_v.string) <= 0 ) {return FALSE;} else {return TRUE;}
+        case ExcelNumber:
           return TRUE;
         case ExcelBoolean:
           return FALSE;
         // Following shouldn't happen
-        case ExcelEmpty: 
-        case ExcelError: 
+        case ExcelEmpty:
+        case ExcelError:
         case ExcelRange:
           return NA;
       }
-    case ExcelBoolean: 
+    case ExcelBoolean:
       switch (b_v.type) {
         case ExcelBoolean:
           if(a_v.number == true) {
@@ -1169,11 +1307,11 @@ static ExcelValue more_than(ExcelValue a_v, ExcelValue b_v) {
             return FALSE;
           }
         case ExcelString:
-        case ExcelNumber: 
+        case ExcelNumber:
           return TRUE;
         // Following shouldn't happen
-        case ExcelEmpty: 
-        case ExcelError: 
+        case ExcelEmpty:
+        case ExcelError:
         case ExcelRange:
           return NA;
       }
@@ -1185,17 +1323,17 @@ static ExcelValue more_than(ExcelValue a_v, ExcelValue b_v) {
         case ExcelBoolean:
           return FALSE;
         // Following shouldn't happen
-        case ExcelEmpty: 
-        case ExcelError: 
+        case ExcelEmpty:
+        case ExcelError:
         case ExcelRange:
           return NA;
       }
     // Following shouldn't happen
-    case ExcelEmpty: 
-    case ExcelError: 
+    case ExcelEmpty:
+    case ExcelError:
     case ExcelRange:
       return NA;
-  } 
+  }
   // Shouldn't reach here
   return NA;
 }
@@ -1264,7 +1402,7 @@ static ExcelValue less_than(ExcelValue a_v, ExcelValue b_v) {
       }
     case ExcelBoolean:
       switch(b_v.type) {
-        case ExcelBoolean: 
+        case ExcelBoolean:
           if(a_v.number == true) {
             return FALSE;
           } else { // a_v.number == false
@@ -1395,7 +1533,7 @@ static ExcelValue max(int number_of_arguments, ExcelValue *arguments) {
 	int any_number_found = 0;
 	int i;
 	ExcelValue current_excel_value;
-	
+
 	for(i=0;i<number_of_arguments;i++) {
 		current_excel_value = arguments[i];
 		if(current_excel_value.type == ExcelNumber) {
@@ -1403,7 +1541,7 @@ static ExcelValue max(int number_of_arguments, ExcelValue *arguments) {
 				any_number_found = 1;
 				biggest_number_found = current_excel_value.number;
 			}
-			if(current_excel_value.number > biggest_number_found) biggest_number_found = current_excel_value.number; 				
+			if(current_excel_value.number > biggest_number_found) biggest_number_found = current_excel_value.number;
 		} else if(current_excel_value.type == ExcelRange) {
 			current_excel_value = max( current_excel_value.rows * current_excel_value.columns, current_excel_value.array );
 			if(current_excel_value.type == ExcelError) return current_excel_value;
@@ -1412,7 +1550,7 @@ static ExcelValue max(int number_of_arguments, ExcelValue *arguments) {
 					any_number_found = 1;
 					biggest_number_found = current_excel_value.number;
 				}
-				if(current_excel_value.number > biggest_number_found) biggest_number_found = current_excel_value.number; 				
+				if(current_excel_value.number > biggest_number_found) biggest_number_found = current_excel_value.number;
 		} else if(current_excel_value.type == ExcelError) {
 			return current_excel_value;
 		}
@@ -1421,7 +1559,7 @@ static ExcelValue max(int number_of_arguments, ExcelValue *arguments) {
 		any_number_found = 1;
 		biggest_number_found = 0;
 	}
-	return EXCEL_NUMBER(biggest_number_found);	
+	return EXCEL_NUMBER(biggest_number_found);
 }
 
 static ExcelValue min(int number_of_arguments, ExcelValue *arguments) {
@@ -1429,7 +1567,7 @@ static ExcelValue min(int number_of_arguments, ExcelValue *arguments) {
 	int any_number_found = 0;
 	int i;
 	ExcelValue current_excel_value;
-	
+
 	for(i=0;i<number_of_arguments;i++) {
 		current_excel_value = arguments[i];
 		if(current_excel_value.type == ExcelNumber) {
@@ -1437,7 +1575,7 @@ static ExcelValue min(int number_of_arguments, ExcelValue *arguments) {
 				any_number_found = 1;
 				smallest_number_found = current_excel_value.number;
 			}
-			if(current_excel_value.number < smallest_number_found) smallest_number_found = current_excel_value.number; 				
+			if(current_excel_value.number < smallest_number_found) smallest_number_found = current_excel_value.number;
 		} else if(current_excel_value.type == ExcelRange) {
 			current_excel_value = min( current_excel_value.rows * current_excel_value.columns, current_excel_value.array );
 			if(current_excel_value.type == ExcelError) return current_excel_value;
@@ -1446,7 +1584,7 @@ static ExcelValue min(int number_of_arguments, ExcelValue *arguments) {
 					any_number_found = 1;
 					smallest_number_found = current_excel_value.number;
 				}
-				if(current_excel_value.number < smallest_number_found) smallest_number_found = current_excel_value.number; 				
+				if(current_excel_value.number < smallest_number_found) smallest_number_found = current_excel_value.number;
 		} else if(current_excel_value.type == ExcelError) {
 			return current_excel_value;
 		}
@@ -1455,7 +1593,7 @@ static ExcelValue min(int number_of_arguments, ExcelValue *arguments) {
 		any_number_found = 1;
 		smallest_number_found = 0;
 	}
-	return EXCEL_NUMBER(smallest_number_found);	
+	return EXCEL_NUMBER(smallest_number_found);
 }
 
 static ExcelValue mmult_error(ExcelValue a_v, ExcelValue b_v) {
@@ -1485,13 +1623,13 @@ static ExcelValue mmult(ExcelValue a_v, ExcelValue b_v) {
   int b_columns = b_v.columns;
   ExcelValue *result = (ExcelValue*) new_excel_value_array(a_rows*b_columns);
   int i, j, k;
-  double sum; 
+  double sum;
   ExcelValue *array_a = a_v.array;
   ExcelValue *array_b = b_v.array;
 
   ExcelValue a;
   ExcelValue b;
-  
+
   for(i=0; i<a_rows; i++) {
     for(j=0; j<b_columns; j++) {
       sum = 0;
@@ -1511,7 +1649,7 @@ static ExcelValue mmult(ExcelValue a_v, ExcelValue b_v) {
 static ExcelValue mod(ExcelValue a_v, ExcelValue b_v) {
 	CHECK_FOR_PASSED_ERROR(a_v)
 	CHECK_FOR_PASSED_ERROR(b_v)
-		
+
 	NUMBER(a_v, a)
 	NUMBER(b_v, b)
 	CHECK_FOR_CONVERSION_ERROR
@@ -1519,6 +1657,10 @@ static ExcelValue mod(ExcelValue a_v, ExcelValue b_v) {
 	return EXCEL_NUMBER(fmod(a,b));
 }
 
+static ExcelValue na() {
+  return NA;
+}
+
 static ExcelValue negative(ExcelValue a_v) {
 	CHECK_FOR_PASSED_ERROR(a_v)
 	NUMBER(a_v, a)
@@ -1530,22 +1672,22 @@ static ExcelValue pmt(ExcelValue rate_v, ExcelValue number_of_periods_v, ExcelVa
 	CHECK_FOR_PASSED_ERROR(rate_v)
 	CHECK_FOR_PASSED_ERROR(number_of_periods_v)
 	CHECK_FOR_PASSED_ERROR(present_value_v)
-		
+
 	NUMBER(rate_v,rate)
 	NUMBER(number_of_periods_v,number_of_periods)
 	NUMBER(present_value_v,present_value)
 	CHECK_FOR_CONVERSION_ERROR
-	
+
 	if(rate == 0) return EXCEL_NUMBER(-(present_value / number_of_periods));
 	return EXCEL_NUMBER(-present_value*(rate*(pow((1+rate),number_of_periods)))/((pow((1+rate),number_of_periods))-1));
 }
 
 static ExcelValue pmt_4(ExcelValue rate_v, ExcelValue number_of_periods_v, ExcelValue present_value_v, ExcelValue final_value_v) {
   CHECK_FOR_PASSED_ERROR(final_value_v)
-    
+
     NUMBER(final_value_v, final_value)
     CHECK_FOR_CONVERSION_ERROR
-      
+
     if(final_value == 0) return pmt(rate_v, number_of_periods_v, present_value_v);
     printf("PMT with non-zero final_value not implemented. halting.");
     exit(-1);
@@ -1553,10 +1695,10 @@ static ExcelValue pmt_4(ExcelValue rate_v, ExcelValue number_of_periods_v, Excel
 
 static ExcelValue pmt_5(ExcelValue rate_v, ExcelValue number_of_periods_v, ExcelValue present_value_v, ExcelValue final_value_v, ExcelValue type_v) {
   CHECK_FOR_PASSED_ERROR(type_v)
-    
+
     NUMBER(type_v, type)
     CHECK_FOR_CONVERSION_ERROR
-      
+
     if(type == 0) return pmt(rate_v, number_of_periods_v, present_value_v);
     printf("PMT with non-zero type not implemented. halting.");
     exit(-1);
@@ -1605,11 +1747,11 @@ static ExcelValue pv_5(ExcelValue rate_v, ExcelValue nper_v, ExcelValue pmt_v, E
    present_value = present_value * (1+rate);
   } else {
    return VALUE;
-  } 
+  }
 
   // Add on the final value
   present_value = present_value - (fv/pow(1+rate,nper));
-  
+
   return EXCEL_NUMBER(present_value);
 }
 
@@ -1617,7 +1759,7 @@ static ExcelValue pv_5(ExcelValue rate_v, ExcelValue nper_v, ExcelValue pmt_v, E
 static ExcelValue power(ExcelValue a_v, ExcelValue b_v) {
 	CHECK_FOR_PASSED_ERROR(a_v)
 	CHECK_FOR_PASSED_ERROR(b_v)
-		
+
 	NUMBER(a_v, a)
 	NUMBER(b_v, b)
 	CHECK_FOR_CONVERSION_ERROR
@@ -1676,48 +1818,48 @@ static ExcelValue rank_2(ExcelValue number_v, ExcelValue range_v) {
 static ExcelValue excel_round(ExcelValue number_v, ExcelValue decimal_places_v) {
 	CHECK_FOR_PASSED_ERROR(number_v)
 	CHECK_FOR_PASSED_ERROR(decimal_places_v)
-		
+
 	NUMBER(number_v, number)
 	NUMBER(decimal_places_v, decimal_places)
 	CHECK_FOR_CONVERSION_ERROR
-		
+
 	double multiple = pow(10,decimal_places);
-	
+
 	return EXCEL_NUMBER( round(number * multiple) / multiple );
 }
 
 static ExcelValue rounddown(ExcelValue number_v, ExcelValue decimal_places_v) {
 	CHECK_FOR_PASSED_ERROR(number_v)
 	CHECK_FOR_PASSED_ERROR(decimal_places_v)
-		
+
 	NUMBER(number_v, number)
 	NUMBER(decimal_places_v, decimal_places)
 	CHECK_FOR_CONVERSION_ERROR
-		
+
 	double multiple = pow(10,decimal_places);
-	
-	return EXCEL_NUMBER( trunc(number * multiple) / multiple );	
+
+	return EXCEL_NUMBER( trunc(number * multiple) / multiple );
 }
 
 static ExcelValue roundup(ExcelValue number_v, ExcelValue decimal_places_v) {
 	CHECK_FOR_PASSED_ERROR(number_v)
 	CHECK_FOR_PASSED_ERROR(decimal_places_v)
-		
+
 	NUMBER(number_v, number)
 	NUMBER(decimal_places_v, decimal_places)
 	CHECK_FOR_CONVERSION_ERROR
-		
+
 	double multiple = pow(10,decimal_places);
 	if(number < 0) return EXCEL_NUMBER( floor(number * multiple) / multiple );
-	return EXCEL_NUMBER( ceil(number * multiple) / multiple );	
+	return EXCEL_NUMBER( ceil(number * multiple) / multiple );
 }
 
 static ExcelValue excel_int(ExcelValue number_v) {
 	CHECK_FOR_PASSED_ERROR(number_v)
-		
+
 	NUMBER(number_v, number)
 	CHECK_FOR_CONVERSION_ERROR
-		
+
 	return EXCEL_NUMBER(floor(number));
 }
 
@@ -1747,7 +1889,7 @@ static ExcelValue string_join(int number_of_arguments, ExcelValue *arguments) {
 		  	  printf("Out of memory in string join");
 		  	  exit(-1);
 		  	}
-			  must_free_current_string = 1;				  
+			  must_free_current_string = 1;
 			  snprintf(current_string,20,"%g",current_v.number);
 			  break;
 		  case ExcelBoolean:
@@ -1796,7 +1938,7 @@ static ExcelValue subtotal(ExcelValue subtotal_type_v, int number_of_arguments,
   CHECK_FOR_PASSED_ERROR(subtotal_type_v)
   NUMBER(subtotal_type_v,subtotal_type)
   CHECK_FOR_CONVERSION_ERROR
-      
+
   switch((int) subtotal_type) {
     case 1:
     case 101:
@@ -1829,22 +1971,22 @@ static ExcelValue filter_range(ExcelValue original_range_v, int number_of_argume
   // Set up the sum range
   ExcelValue *original_range;
   int original_range_rows, original_range_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 {
     original_range = (ExcelValue*) new_excel_value_array(1);
-	original_range[0] = original_range_v;
+	  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; 
-  
+  int number_of_filtered_values = 0;
+
   // Then go through and set up the check ranges
   if(number_of_arguments % 2 != 0) return VALUE;
   int number_of_criteria = number_of_arguments / 2;
@@ -1865,7 +2007,7 @@ static ExcelValue filter_range(ExcelValue original_range_v, int number_of_argume
       criteria_range[i] =  EXCEL_RANGE(tmp_array2,1,1);
     }
   }
-  
+
   // Now go through and set up the criteria
   ExcelComparison *criteria =  malloc(sizeof(ExcelComparison)*number_of_criteria); // freed at end of function
   if(criteria == 0) {
@@ -1877,7 +2019,7 @@ static ExcelValue filter_range(ExcelValue original_range_v, int number_of_argume
 
   for(i = 0; i < number_of_criteria; i++) {
     current_value = arguments[(i*2)+1];
-    
+
     if(current_value.type == ExcelString) {
       s = current_value.string;
       if(s[0] == '<') {
@@ -1916,14 +2058,14 @@ static ExcelValue filter_range(ExcelValue original_range_v, int number_of_argume
         criteria[i].comparator = EXCEL_STRING(new_comparator);
       } else {
         criteria[i].type = Equal;
-        criteria[i].comparator = current_value;          
+        criteria[i].comparator = current_value;
       }
     } else {
       criteria[i].type = Equal;
       criteria[i].comparator = current_value;
     }
   }
-  
+
   int size = original_range_columns * original_range_rows;
   int j;
   int passed = 0;
@@ -1943,7 +2085,7 @@ static ExcelValue filter_range(ExcelValue original_range_v, int number_of_argume
       if(comparator.type == ExcelEmpty) {
         comparator = ZERO;
       }
-      
+
       switch(value_to_be_checked.type) {
         case ExcelError: // Errors match only errors
           if(comparison.type != Equal) passed = 0;
@@ -1984,16 +2126,16 @@ static ExcelValue filter_range(ExcelValue original_range_v, int number_of_argume
               break;
             case LessThan:
               if(value_to_be_checked.number >= number) passed = 0;
-              break;            
+              break;
             case LessThanOrEqual:
               if(value_to_be_checked.number > number) passed = 0;
-              break;                        
+              break;
             case NotEqual:
               if(value_to_be_checked.number == number) passed = 0;
-              break;            
+              break;
             case MoreThanOrEqual:
               if(value_to_be_checked.number < number) passed = 0;
-              break;            
+              break;
             case MoreThan:
               if(value_to_be_checked.number <= number) passed = 0;
               break;
@@ -2034,16 +2176,16 @@ static ExcelValue filter_range(ExcelValue original_range_v, int number_of_argume
                 break;
               case LessThan:
                 if(less_than(value_to_be_checked,comparator).number == 0) passed = 0;
-                break;            
+                break;
               case LessThanOrEqual:
                 if(less_than_or_equal(value_to_be_checked,comparator).number == 0) passed = 0;
-                break;                        
+                break;
               case NotEqual:
                 if(not_equal(value_to_be_checked,comparator).number == 0) passed = 0;
-                break;            
+                break;
               case MoreThanOrEqual:
                 if(more_than_or_equal(value_to_be_checked,comparator).number == 0) passed = 0;
-                break;            
+                break;
               case MoreThan:
                 if(more_than(value_to_be_checked,comparator).number == 0) passed = 0;
                 break;
@@ -2055,7 +2197,7 @@ static ExcelValue filter_range(ExcelValue original_range_v, int number_of_argume
           break;
         case ExcelRange:
           free(criteria);
-          return VALUE;            
+          return VALUE;
       }
       if(passed == 0) break;
     }
@@ -2080,6 +2222,245 @@ static ExcelValue sumifs(ExcelValue sum_range_v, int number_of_arguments, ExcelV
   return sum(1,&filtered_range);
 }
 
+static ExcelValue countifs(int number_of_arguments, ExcelValue *arguments) {
+  if(number_of_arguments < 2) { return NA;}
+  // Set up the sum range
+  ExcelValue range = arguments[0];
+  int rows, columns;
+
+  if(range.type == ExcelRange) {
+    rows = range.rows;
+    columns = range.columns;
+  } else {
+    rows = 1;
+    columns = 1;
+  }
+
+  int count = 0;
+
+  // Then go through and set up the check ranges
+  if(number_of_arguments % 2 != 0) return VALUE;
+  int number_of_criteria = number_of_arguments / 2;
+  ExcelValue *criteria_range =  (ExcelValue*) new_excel_value_array(number_of_criteria);
+  ExcelValue current_value;
+  int i;
+  for(i = 0; i < number_of_criteria; i++) {
+    current_value = arguments[i*2];
+    if(current_value.type == ExcelRange) {
+      criteria_range[i] = current_value;
+      if(current_value.rows != rows) return VALUE;
+      if(current_value.columns != columns) return VALUE;
+    } else {
+      if(rows != 1) return VALUE;
+      if(columns != 1) return VALUE;
+      ExcelValue *tmp_array2 =  (ExcelValue*) new_excel_value_array(1);
+      tmp_array2[0] = current_value;
+      criteria_range[i] = EXCEL_RANGE(tmp_array2,1,1);
+    }
+  }
+
+  // Now go through and set up the criteria
+  ExcelComparison *criteria =  malloc(sizeof(ExcelComparison)*number_of_criteria); // freed at end of function
+  if(criteria == 0) {
+	  printf("Out of memory in filter_range\n");
+	  exit(-1);
+  }
+  char *s;
+  char *new_comparator;
+
+  for(i = 0; i < number_of_criteria; i++) {
+    current_value = arguments[(i*2)+1];
+
+    if(current_value.type == ExcelString) {
+      s = current_value.string;
+      if(s[0] == '<') {
+        if( s[1] == '>') {
+          new_comparator = strndup(s+2,strlen(s)-2);
+          free_later(new_comparator);
+          criteria[i].type = NotEqual;
+          criteria[i].comparator = EXCEL_STRING(new_comparator);
+        } else if(s[1] == '=') {
+          new_comparator = strndup(s+2,strlen(s)-2);
+          free_later(new_comparator);
+          criteria[i].type = LessThanOrEqual;
+          criteria[i].comparator = EXCEL_STRING(new_comparator);
+        } else {
+          new_comparator = strndup(s+1,strlen(s)-1);
+          free_later(new_comparator);
+          criteria[i].type = LessThan;
+          criteria[i].comparator = EXCEL_STRING(new_comparator);
+        }
+      } else if(s[0] == '>') {
+        if(s[1] == '=') {
+          new_comparator = strndup(s+2,strlen(s)-2);
+          free_later(new_comparator);
+          criteria[i].type = MoreThanOrEqual;
+          criteria[i].comparator = EXCEL_STRING(new_comparator);
+        } else {
+          new_comparator = strndup(s+1,strlen(s)-1);
+          free_later(new_comparator);
+          criteria[i].type = MoreThan;
+          criteria[i].comparator = EXCEL_STRING(new_comparator);
+        }
+      } else if(s[0] == '=') {
+        new_comparator = strndup(s+1,strlen(s)-1);
+        free_later(new_comparator);
+        criteria[i].type = Equal;
+        criteria[i].comparator = EXCEL_STRING(new_comparator);
+      } else {
+        criteria[i].type = Equal;
+        criteria[i].comparator = current_value;
+      }
+    } else {
+      criteria[i].type = Equal;
+      criteria[i].comparator = current_value;
+    }
+  }
+
+  int size = columns * rows;
+  int j;
+  int passed = 0;
+  ExcelValue value_to_be_checked;
+  ExcelComparison comparison;
+  ExcelValue comparator;
+  double number;
+  // For each cell in the sum range
+  for(j=0; j < size; j++ ) {
+    passed = 1;
+    for(i=0; i < number_of_criteria; i++) {
+      value_to_be_checked = ((ExcelValue *) ((ExcelValue) criteria_range[i]).array)[j];
+      comparison = criteria[i];
+      comparator = comparison.comparator;
+
+      // For the purposes of comparison, treates a blank criteria as matching zeros.
+      if(comparator.type == ExcelEmpty) {
+        comparator = ZERO;
+      }
+
+      switch(value_to_be_checked.type) {
+        case ExcelError: // Errors match only errors
+          if(comparison.type != Equal) passed = 0;
+          if(comparator.type != ExcelError) passed = 0;
+          if(value_to_be_checked.number != comparator.number) passed = 0;
+          break;
+        case ExcelBoolean: // Booleans match only booleans (FIXME: I think?)
+          if(comparison.type != Equal) passed = 0;
+          if(comparator.type != ExcelBoolean ) passed = 0;
+          if(value_to_be_checked.number != comparator.number) passed = 0;
+          break;
+        case ExcelEmpty:
+          // if(comparator.type == ExcelEmpty) break; // FIXME: Huh? In excel blank doesn't match blank?!
+          if(comparator.type != ExcelString) {
+            passed = 0;
+            break;
+          } else {
+            if(strlen(comparator.string) != 0) passed = 0; // Empty strings match blanks.
+            break;
+          }
+        case ExcelNumber:
+          if(comparator.type == ExcelNumber) {
+            number = comparator.number;
+          } else if(comparator.type == ExcelString) {
+            number = number_from(comparator);
+            if(conversion_error == 1) {
+              conversion_error = 0;
+              passed = 0;
+              break;
+            }
+          } else {
+            passed = 0;
+            break;
+          }
+          switch(comparison.type) {
+            case Equal:
+              if(value_to_be_checked.number != number) passed = 0;
+              break;
+            case LessThan:
+              if(value_to_be_checked.number >= number) passed = 0;
+              break;
+            case LessThanOrEqual:
+              if(value_to_be_checked.number > number) passed = 0;
+              break;
+            case NotEqual:
+              if(value_to_be_checked.number == number) passed = 0;
+              break;
+            case MoreThanOrEqual:
+              if(value_to_be_checked.number < number) passed = 0;
+              break;
+            case MoreThan:
+              if(value_to_be_checked.number <= number) passed = 0;
+              break;
+          }
+          break;
+        case ExcelString:
+          // First case, the comparator is a number, simplification is that it can only be equal
+          if(comparator.type == ExcelNumber) {
+            if(comparison.type != Equal) {
+              printf("This shouldn't be possible?");
+              passed = 0;
+              break;
+            }
+
+            // Special case, empty strings don't match zeros here
+            if(strlen(value_to_be_checked.string) == 0) {
+              passed = 0;
+              break;
+            }
+
+            number = number_from(value_to_be_checked);
+            if(conversion_error == 1) {
+              conversion_error = 0;
+              passed = 0;
+              break;
+            }
+            if(number != comparator.number) {
+              passed = 0;
+              break;
+            } else {
+              break;
+            }
+          // Second case, the comparator is also a string, so need to be able to do full range of tests
+          } else if(comparator.type == ExcelString) {
+            switch(comparison.type) {
+              case Equal:
+                if(excel_equal(value_to_be_checked,comparator).number == 0) passed = 0;
+                break;
+              case LessThan:
+                if(less_than(value_to_be_checked,comparator).number == 0) passed = 0;
+                break;
+              case LessThanOrEqual:
+                if(less_than_or_equal(value_to_be_checked,comparator).number == 0) passed = 0;
+                break;
+              case NotEqual:
+                if(not_equal(value_to_be_checked,comparator).number == 0) passed = 0;
+                break;
+              case MoreThanOrEqual:
+                if(more_than_or_equal(value_to_be_checked,comparator).number == 0) passed = 0;
+                break;
+              case MoreThan:
+                if(more_than(value_to_be_checked,comparator).number == 0) passed = 0;
+                break;
+              }
+          } else {
+            passed = 0;
+            break;
+          }
+          break;
+        case ExcelRange:
+          free(criteria);
+          return VALUE;
+      }
+      if(passed == 0) break;
+    }
+    if(passed == 1) {
+        count += 1;
+    }
+  }
+  // Tidy up
+  free(criteria);
+  return EXCEL_NUMBER(count);
+}
+
 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);
@@ -2097,7 +2478,7 @@ static ExcelValue sumif_2(ExcelValue check_range_v, ExcelValue criteria_v) {
 
 static ExcelValue sumproduct(int number_of_arguments, ExcelValue *arguments) {
   if(number_of_arguments <1) return VALUE;
-  
+
   int a;
   int i;
   int j;
@@ -2111,7 +2492,7 @@ static ExcelValue sumproduct(int number_of_arguments, ExcelValue *arguments) {
   }
   double product = 1;
   double sum = 0;
-  
+
   // Find out dimensions of first argument
   if(arguments[0].type == ExcelRange) {
     rows = arguments[0].rows;
@@ -2143,7 +2524,7 @@ static ExcelValue sumproduct(int number_of_arguments, ExcelValue *arguments) {
         break;
     }
   }
-  	
+
 	for(i=0;i<rows;i++) {
 		for(j=0;j<columns;j++) {
 			product = 1;
@@ -2162,6 +2543,71 @@ static ExcelValue sumproduct(int number_of_arguments, ExcelValue *arguments) {
   return EXCEL_NUMBER(sum);
 }
 
+static ExcelValue product(int number_of_arguments, ExcelValue *arguments) {
+  if(number_of_arguments <1) return VALUE;
+
+  int a,b;
+  ExcelValue sub_total;
+  ExcelValue current_value;
+  int sub_total_array_size;
+  ExcelValue *sub_total_array;
+  ExcelValue sub_total_value;
+  double total = 0;
+
+  // Extract arrays from each of the given ranges, checking for errors and bounds as we go
+  for(a=0;a<number_of_arguments;a++) {
+    current_value = arguments[a];
+    switch(current_value.type) {
+      case ExcelRange:
+        sub_total_array_size = current_value.rows * current_value.columns;
+        sub_total_array = current_value.array;
+        // We don't use recursion, because we need to check if
+        // the result is 0 becaues a zero, or zero because all blank.
+        for(b=0;b<sub_total_array_size;b++) {
+          sub_total_value = sub_total_array[b];
+          switch(sub_total_value.type) {
+            case ExcelError:
+              return sub_total_value;
+              break;
+
+            case ExcelNumber:
+              // We do this rather than starting with total = 1
+              // so that the product of all blanks is zero
+              if(total == 0) {
+                total = sub_total_value.number;
+              } else {
+                total *= sub_total_value.number;
+              }
+              break;
+
+            default:
+              // Skip
+              break;
+          }
+        }
+        break;
+
+      case ExcelError:
+        return current_value;
+        break;
+
+      case ExcelNumber:
+        if(total == 0) {
+          total = current_value.number;
+        } else {
+          total *= current_value.number;
+        }
+        break;
+
+      default:
+        // Skip
+        break;
+    }
+  }
+
+  return EXCEL_NUMBER(total);
+}
+
 // FIXME: This could do with being done properly, rather than
 // on a case by case basis.
 static ExcelValue text(ExcelValue number_v, ExcelValue format_v) {
@@ -2189,7 +2635,7 @@ static ExcelValue text(ExcelValue number_v, ExcelValue format_v) {
  	 	s = number_v.string;
 		if (s == NULL || *s == '\0' || isspace(*s)) {
 			number_v = ZERO;
-		}	        
+		}
 		n = strtod (s, &p);
 		if(*p == '\0') {
 		  number_v = EXCEL_NUMBER(n);
@@ -2204,7 +2650,7 @@ static ExcelValue text(ExcelValue number_v, ExcelValue format_v) {
     return format_v;
   }
 
-  // FIXME: Too little? 
+  // FIXME: Too little?
   s = malloc(100);
   setlocale(LC_ALL,"");
 
@@ -2259,17 +2705,17 @@ static ExcelValue vlookup(ExcelValue lookup_value_v,ExcelValue lookup_table_v, E
     match_type_v.type = ExcelBoolean;
   }
   if(match_type_v.type != ExcelBoolean) return NA;
-    
+
   int i;
   int last_good_match = 0;
   int rows = lookup_table_v.rows;
   int columns = lookup_table_v.columns;
   ExcelValue *array = lookup_table_v.array;
   ExcelValue possible_match_v;
-  
+
   if(column_number_v.number > columns) return REF;
   if(column_number_v.number < 1) return VALUE;
-  
+
   if(match_type_v.number == false) { // Exact match required
     for(i=0; i< rows; i++) {
       possible_match_v = array[i*columns];
@@ -2289,7 +2735,7 @@ static ExcelValue vlookup(ExcelValue lookup_value_v,ExcelValue lookup_table_v, E
         last_good_match = i;
       }
     }
-    return array[(last_good_match*columns)+(((int) column_number_v.number) - 1)];   
+    return array[(last_good_match*columns)+(((int) column_number_v.number) - 1)];
   }
   return NA;
 }
@@ -2311,17 +2757,17 @@ static ExcelValue hlookup(ExcelValue lookup_value_v,ExcelValue lookup_table_v, E
     match_type_v.type = ExcelBoolean;
   }
   if(match_type_v.type != ExcelBoolean) return NA;
-    
+
   int i;
   int last_good_match = 0;
   int rows = lookup_table_v.rows;
   int columns = lookup_table_v.columns;
   ExcelValue *array = lookup_table_v.array;
   ExcelValue possible_match_v;
-  
+
   if(row_number_v.number > rows) return REF;
   if(row_number_v.number < 1) return VALUE;
-  
+
   if(match_type_v.number == false) { // Exact match required
     for(i=0; i< columns; i++) {
       possible_match_v = array[i];
@@ -2354,14 +2800,116 @@ static ExcelValue value(ExcelValue string_v) {
 	return EXCEL_NUMBER(a);
 }
 
+static ExcelValue scurve_4(ExcelValue currentYear, ExcelValue startValue, ExcelValue endValue, ExcelValue duration) {
+  ExcelValue startYear = EXCEL_NUMBER(2018);
+  return scurve(currentYear, startValue, endValue, duration, startYear);
+}
+
+static ExcelValue halfscurve_4(ExcelValue currentYear, ExcelValue startValue, ExcelValue endValue, ExcelValue duration) {
+  ExcelValue startYear = EXCEL_NUMBER(2018);
+  return halfscurve(currentYear, startValue, endValue, duration, startYear);
+}
+
+static ExcelValue lcurve_4(ExcelValue currentYear, ExcelValue startValue, ExcelValue endValue, ExcelValue duration) {
+  ExcelValue startYear = EXCEL_NUMBER(2018);
+  return lcurve(currentYear, startValue, endValue, duration, startYear);
+}
+
+static ExcelValue curve_5(ExcelValue curveType, ExcelValue currentYear, ExcelValue startValue, ExcelValue endValue, ExcelValue duration) {
+  ExcelValue startYear = EXCEL_NUMBER(2018);
+  return curve(curveType, currentYear, startValue, endValue, duration, startYear);
+}
+
+static ExcelValue scurve(ExcelValue currentYear_v, ExcelValue startValue_v, ExcelValue endValue_v, ExcelValue duration_v, ExcelValue startYear_v) {
+
+	NUMBER(currentYear_v, currentYear)
+	NUMBER(startValue_v, startValue)
+	NUMBER(endValue_v, endValue)
+	NUMBER(duration_v, duration)
+	NUMBER(startYear_v, startYear)
+	CHECK_FOR_CONVERSION_ERROR
+
+  if(currentYear < startYear) {
+    return startValue_v;
+  }
+  double x = (currentYear - startYear) / duration;
+  double x0 = 0.0;
+  double a = endValue - startValue;
+  double sc = 0.999;
+  double eps = 1.0 - sc;
+  double mu = 0.5;
+  double beta = (mu - 1.0) / log(1.0 / sc - 1);
+  double scurve = a * (pow((exp(-(x - mu) / beta) + 1),-1) - pow((exp(-(x0 - mu) / beta) + 1),-1)) + startValue;
+  return EXCEL_NUMBER(scurve);
+}
+
+static ExcelValue halfscurve(ExcelValue currentYear_v, ExcelValue startValue_v, ExcelValue endValue_v, ExcelValue duration_v, ExcelValue startYear_v) {
+
+	NUMBER(currentYear_v, currentYear)
+	NUMBER(startValue_v, startValue)
+	NUMBER(endValue_v, endValue)
+	NUMBER(duration_v, duration)
+	NUMBER(startYear_v, startYear)
+	CHECK_FOR_CONVERSION_ERROR
+
+  if(currentYear < startYear) {
+    return startValue_v;
+  }
+
+  ExcelValue newCurrentYear = EXCEL_NUMBER(currentYear + duration);
+  ExcelValue newDuration = EXCEL_NUMBER(duration *2);
+  ExcelValue result_v = scurve(newCurrentYear, startValue_v, endValue_v, newDuration, startYear_v);
+
+	NUMBER(result_v, result)
+	CHECK_FOR_CONVERSION_ERROR
+
+  return EXCEL_NUMBER(result -((endValue - startValue)/2.0));
+}
+
+static ExcelValue lcurve(ExcelValue currentYear_v, ExcelValue startValue_v, ExcelValue endValue_v, ExcelValue duration_v, ExcelValue startYear_v) {
+
+	NUMBER(currentYear_v, currentYear)
+	NUMBER(startValue_v, startValue)
+	NUMBER(endValue_v, endValue)
+	NUMBER(duration_v, duration)
+	NUMBER(startYear_v, startYear)
+	CHECK_FOR_CONVERSION_ERROR
+
+  if(currentYear > (startYear + duration)) {
+    return endValue_v;
+  }
+
+  if(currentYear < startYear) {
+    return startValue_v;
+  }
+
+  double result = startValue + (((endValue - startValue) / duration) * (currentYear - startYear));
+  return EXCEL_NUMBER(result);
+}
+
+static ExcelValue curve(ExcelValue type_v, ExcelValue currentYear_v, ExcelValue startValue_v, ExcelValue endValue_v, ExcelValue duration_v, ExcelValue startYear_v) {
+
+  if(type_v.type == ExcelString && strcasecmp(type_v.string, "s") == 0 ) {
+    return scurve(currentYear_v, startValue_v, endValue_v, duration_v, startYear_v);
+  }
+
+  if(type_v.type == ExcelString && strcasecmp(type_v.string, "hs") == 0 ) {
+    return halfscurve(currentYear_v, startValue_v, endValue_v, duration_v, startYear_v);
+  }
+
+  return lcurve(currentYear_v, startValue_v, endValue_v, duration_v, startYear_v);
+}
+
+
+
 // Allows numbers to be 0.1% different
 static ExcelValue roughly_equal(ExcelValue a_v, ExcelValue b_v) {
 
   if(a_v.type == ExcelEmpty && b_v.type == ExcelNumber && b_v.number == 0) return TRUE;
   if(b_v.type == ExcelEmpty && a_v.type == ExcelNumber && a_v.number == 0) return TRUE;
-      
+
 	if(a_v.type != b_v.type) return FALSE;
-	
+
   float epsilon, difference;
 
 	switch (a_v.type) {
@@ -2378,8 +2926,8 @@ static ExcelValue roughly_equal(ExcelValue a_v, ExcelValue b_v) {
       if(difference <= epsilon) return TRUE;
       // For debuging: printf("a: %e b:%e d: %e e: %e", a_v.number, b_v.number, difference, epsilon);
       return FALSE;
-	  case ExcelBoolean: 
-	  case ExcelEmpty: 
+	  case ExcelBoolean:
+	  case ExcelEmpty:
 			if(a_v.number != b_v.number) return FALSE;
 			return TRUE;
 	  case ExcelString:
@@ -2393,7 +2941,7 @@ static ExcelValue roughly_equal(ExcelValue a_v, ExcelValue b_v) {
   }
   return FALSE;
 }
-  
+
 
 static void assert_equal(ExcelValue expected, ExcelValue actual, char location[]) {
   ExcelValue comparison = roughly_equal(actual, expected);
@@ -2408,5 +2956,3 @@ static void assert_equal(ExcelValue expected, ExcelValue actual, char location[]
     putchar('\n');
   }
 }
-
-