excel_to_code 0.2.15 → 0.2.16

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: f02167c81fefd0532b50c1fc9c9014a4398306f5
-  data.tar.gz: ec0ce7e9de3c7ed214052a9a45bad36c02e1c763
+  metadata.gz: 1cae4231d0e0d0c80b485f2a0fc87d565f226c11
+  data.tar.gz: 625f3ef6ec924295ee2e3f5cba56868381f4f404
 SHA512:
-  metadata.gz: 52fd6998dddf65a826c6bb3a014d5b915342845ab5a1801dfc3c4fc7572f446aedd2f8662c92aa186be8c0b5dd9719ffcc2f90f1b71842df6cb5c97e886cbc8f
-  data.tar.gz: 7725a362a6049b3533e1db2c1be5c256581fb915519d274b89d3c9790f83e654d9470deb6c9148549fe905cf51e3ff6ee35794f6d4026feb357d23e2c07a1d74
+  metadata.gz: 6cd4db1bfcf22fbea826c79c02f61d8e414ae7b58aec81e4f6a19d64c0ffa5fa4afd1d60a33b1326c6e86a49ce8f43bca36679abf8545039f0d99fcab05afe81
+  data.tar.gz: 2b9f571923590f5a66dda004568a968cfd6add015b85e9bed0bb18a752295e96299f5aa020e75a6e5c85ba56684b788436e7667c11ddc38f3f62cd02dff1140a

data/bin/excel_to_c

@@ -47,6 +47,10 @@ END
   opts.on('--precise-tests',"The generated tests treat blanks and zeros as different and requires numbers to be exactly the same.") do
     command.sloppy_tests = false
   end
+
+  opts.on('--isolate WORKSHEET', "Only performs translation and optimiation of that one worksheet. Useful for debugging an incorrect translation of a large worksheet") do |sheet|
+    command.isolate = sheet
+  end
   
   opts.on("-h", "--help", "Show this message") do
     puts opts

data/src/commands/excel_to_c.rb

@@ -110,7 +110,7 @@ class ExcelToC < ExcelToX
     
     # Target for compiled version
     o.puts "#{name}.o:"
-    o.puts "\tgcc -Wall -fPIC -c #{name}.c"
+    o.puts "\tgcc -fPIC -c #{name}.c"
     o.puts
     
     # Target for cleaning
@@ -256,7 +256,7 @@ END
       # Put in place the setters, if any
       settable_refs = @cells_that_can_be_set_at_runtime[name]
       if settable_refs
-        settable_refs = all_formulae[name].keys if settable_refs == :all
+        settable_refs = @formulae.keys.select { |k| k.first == name }.map { |k| k.last } if settable_refs == :all
         settable_refs.each do |ref|
           o.puts "  attach_function 'set_#{c_name}_#{ref.downcase}', [ExcelValue.by_value], :void"
         end

data/src/commands/excel_to_x.rb

@@ -103,6 +103,13 @@ class ExcelToX
   #   * false - the compiler leaves calculations fully expanded. This may make debugging easier
   attr_accessor :extract_repeated_parts_of_formulae
 
+  # Optional attribute, Array. Default nil
+  # This is used to help debug large spreadsheets that aren't working correctly.
+  # If set to the name of a worksheet then ONLY that worksheet will be run through the 
+  # optimisation and simplification code. Will also override cells_to_keep to keep all
+  # cells on tha sheet and nothing else.
+  attr_accessor :isolate
+
   # Deprecated
   def run_in_memory=(boolean)
     $stderr.puts "The run_in_memory switch is deprecated (it is now always true). Please remove calls to it"
@@ -146,7 +153,7 @@ class ExcelToX
     transfer_named_references_to_keep_into_cells_to_keep
     transfer_named_references_that_can_be_set_at_runtime_into_cells_that_can_be_set_at_runtime
     
-    # These perform some translations to simplify the excel
+    # These perform some translations to tsimplify the excel
     # Including:
     # * Turning row and column references (e.g., A:A) to areas, based on the size of the worksheet
     # * Turning range references (e.g., A1:B2) into array litterals (e.g., {A1,B1;A2,B2})
@@ -221,6 +228,11 @@ class ExcelToX
 
     # Setting this to false may make it easier to figure out errors
     self.extract_repeated_parts_of_formulae = true if @extract_repeated_parts_of_formulae == nil
+    if self.isolate
+      self.cells_to_keep = { isolate.to_s => :all }
+      self.isolate = self.isolate.to_sym 
+      log.warn "Isolating #{@isolate} worksheet. No other sheets will be converted"
+    end
   end
   
 
@@ -440,6 +452,13 @@ class ExcelToX
     # Loop through the worksheets
     # FIXME: make xml_filename be the IO object?
     worksheets do |name, xml_filename|
+
+      # This is used in debugging large worksheets to limit 
+      # the optimisation to a particular worksheet
+      if isolate
+        extractor.only_extract_values = (isolate != name)
+      end
+
       log.info "Extracting data from #{name}"
       xml(xml_filename) do |input|
         extractor.extract(name, input)
@@ -643,6 +662,8 @@ class ExcelToX
       @replace_ranges_with_array_literals_replacer.map(details.last)
       transpose_function_replacer.map(details.last)
       simplify_arithmetic_replacer.map(details.last)
+      # FIXME: Seem to need to do this twice, second time to eliminate brackets?!
+      simplify_arithmetic_replacer.map(details.last)
       expand_array_formulae_replacer.map(details.last)
     end
 
@@ -829,15 +850,13 @@ class ExcelToX
         @table_reference_replacer.referring_cell = ref.last
         @table_reference_replacer.map(ast)
         @replace_ranges_with_array_literals_replacer.map(ast)
-        #@replace_arithmetic_on_ranges_replacer.map(ast)
-
         @replace_arrays_with_single_cells_replacer.ref = ref
         a = @replace_arrays_with_single_cells_replacer.map(ast)
         if @replace_arrays_with_single_cells_replacer.need_to_replace
-          cells[ref] = a
+          cells[ref] = @formulae[ref] = a
         end
-
-        #@replace_string_joins_on_ranges_replacer.map(ast)
+        @replace_arithmetic_on_ranges_replacer.map(ast)
+        @replace_string_joins_on_ranges_replacer.map(ast)
         @wrap_formulae_that_return_arrays_replacer.map(ast)
       rescue  Exception => e
         log.fatal "Exception when simplifying #{ref}: #{ast}"

data/src/compile/c/compile_to_c.rb

@@ -66,6 +66,12 @@ class CompileToC
         mapper.reset
       rescue Exception => e
         puts "Exception at #{ref} #{ast}"
+        if ref.first == "" # Then it is a common method, helpful to indicate where it comes from
+          s = /#{ref.last}/io
+          formulae.each do |r, a|
+            puts "Referenced in #{r}" if a.to_s =~ s
+          end
+        end
         raise
       end      
     end

data/src/compile/c/excel_to_c_runtime.c

@@ -57,6 +57,7 @@ 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 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);
 static ExcelValue hlookup_3(ExcelValue lookup_value_v,ExcelValue lookup_table_v, ExcelValue row_number_v);
@@ -70,6 +71,7 @@ static ExcelValue forecast(ExcelValue required_x, ExcelValue known_y, ExcelValue
 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);
+static ExcelValue len(ExcelValue string_v);
 static ExcelValue excel_log(ExcelValue number);
 static ExcelValue excel_log_2(ExcelValue number, ExcelValue base);
 static ExcelValue excel_exp(ExcelValue number);
@@ -86,6 +88,8 @@ static ExcelValue pv_5(ExcelValue a_v, ExcelValue b_v, ExcelValue c_v, ExcelValu
 static ExcelValue excel_round(ExcelValue number_v, ExcelValue decimal_places_v);
 static ExcelValue rank(ExcelValue number_v, ExcelValue range_v, ExcelValue order_v);
 static ExcelValue rank_2(ExcelValue number_v, ExcelValue range_v);
+static ExcelValue right(ExcelValue string_v, ExcelValue number_of_characters_v);
+static ExcelValue right_1(ExcelValue string_v);
 static ExcelValue rounddown(ExcelValue number_v, ExcelValue decimal_places_v);
 static ExcelValue roundup(ExcelValue number_v, ExcelValue decimal_places_v);
 static ExcelValue excel_int(ExcelValue number_v);
@@ -147,7 +151,7 @@ void reset() {
 static void * new_excel_value_array(int size) {
 	ExcelValue *pointer = malloc(sizeof(ExcelValue)*size); // Freed later
 	if(pointer == 0) {
-		printf("Out of memory\n");
+		printf("Out of memory in new_excel_value_array\n");
 		exit(-1);
 	}
 	free_later(pointer);
@@ -299,6 +303,15 @@ static ExcelValue add(ExcelValue a_v, ExcelValue b_v) {
 	return new_excel_number(a + b);
 }
 
+static ExcelValue ensure_is_number(ExcelValue maybe_number_v) {
+  if(maybe_number_v.type == ExcelNumber) {
+    return maybe_number_v;
+  }
+  NUMBER(maybe_number_v, maybe_number)
+	CHECK_FOR_CONVERSION_ERROR
+	return new_excel_number(maybe_number);
+}
+
 static ExcelValue excel_log(ExcelValue number) {
   return excel_log_2(number, TEN);
 }
@@ -888,6 +901,10 @@ static ExcelValue left(ExcelValue string_v, ExcelValue number_of_characters_v) {
 	int number_of_characters = (int) number_from(number_of_characters_v);
 	CHECK_FOR_CONVERSION_ERROR
 
+  if(number_of_characters < 0) {
+    return VALUE;
+  }
+
 	char *string;
 	int string_must_be_freed = 0;
 	switch (string_v.type) {
@@ -897,11 +914,11 @@ static ExcelValue left(ExcelValue string_v, ExcelValue number_of_characters_v) {
   	  case ExcelNumber:
 		  string = malloc(20); // Freed
 		  if(string == 0) {
-			  printf("Out of memory");
+			  printf("Out of memory in left");
 			  exit(-1);
 		  }
 		  string_must_be_freed = 1;
-		  snprintf(string,20,"%f",string_v.number);
+		  snprintf(string,20,"%0.0f",string_v.number);
 		  break;
 	  case ExcelBoolean:
 	  	if(string_v.number == true) {
@@ -918,7 +935,7 @@ static ExcelValue left(ExcelValue string_v, ExcelValue number_of_characters_v) {
 	
 	char *left_string = malloc(number_of_characters+1); // Freed
 	if(left_string == 0) {
-	  printf("Out of memory");
+	  printf("Out of memoryn in left");
 	  exit(-1);
 	}
 	memcpy(left_string,string,number_of_characters);
@@ -934,6 +951,112 @@ static ExcelValue left_1(ExcelValue string_v) {
 	return left(string_v, ONE);
 }
 
+static ExcelValue len(ExcelValue string_v) {
+	CHECK_FOR_PASSED_ERROR(string_v)
+	if(string_v.type == ExcelEmpty) return ZERO;
+
+	char *string;
+	int string_must_be_freed = 0;
+	switch (string_v.type) {
+  	  case ExcelString:
+  		string = string_v.string;
+  		break;
+  	  case ExcelNumber:
+		  string = malloc(20); // Freed
+		  if(string == 0) {
+			  printf("Out of memory in len");
+			  exit(-1);
+		  }
+		  snprintf(string,20,"%0.0f",string_v.number);
+		  string_must_be_freed = 1;
+		  break;
+	  case ExcelBoolean:
+	  	if(string_v.number == true) {
+	  		string = "TRUE";
+		} else {
+			string = "FALSE";
+		}
+		break;
+	  case ExcelEmpty:	  	 
+  	  case ExcelError:
+  	  case ExcelRange:
+		return string_v;
+	}
+
+  int length = strlen(string);
+	if(string_must_be_freed == 1) {
+		free(string);
+	}
+	return new_excel_number(length);
+}
+
+static ExcelValue right(ExcelValue string_v, ExcelValue number_of_characters_v) {
+	CHECK_FOR_PASSED_ERROR(string_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
+
+  if(number_of_characters < 0) {
+    return VALUE;
+  }
+
+	char *string;
+	int string_must_be_freed = 0;
+	switch (string_v.type) {
+  	  case ExcelString:
+  		string = string_v.string;
+  		break;
+  	  case ExcelNumber:
+		  string = malloc(20); // Freed
+		  if(string == 0) {
+			  printf("Out of memory in right");
+			  exit(-1);
+		  }
+		  string_must_be_freed = 1;
+		  snprintf(string,20,"%0.0f",string_v.number);
+		  break;
+	  case ExcelBoolean:
+	  	if(string_v.number == true) {
+	  		string = "TRUE";
+		} else {
+			string = "FALSE";
+		}
+		break;
+	  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");
+	  exit(-1);
+	}
+  int length = strlen(string);
+  if(length < number_of_characters) {
+    if(string_must_be_freed == 1) {
+      free(string);
+    }
+    return new_excel_string("");
+  } else {
+    memcpy(right_string,string+length-number_of_characters,number_of_characters);
+    right_string[number_of_characters] = '\0';
+    if(string_must_be_freed == 1) {
+      free(string);
+    }
+    free_later(right_string);
+    return new_excel_string(right_string);
+  }
+}
+
+static ExcelValue right_1(ExcelValue string_v) {
+	return right(string_v, ONE);
+}
+
 static ExcelValue iferror(ExcelValue value, ExcelValue value_if_error) {
 	if(value.type == ExcelError) return value_if_error;
 	return value;
@@ -1406,7 +1529,7 @@ static ExcelValue string_join(int number_of_arguments, ExcelValue *arguments) {
 	int used_length = 0;
 	char *string = malloc(allocated_length); // Freed later
 	if(string == 0) {
-	  printf("Out of memory");
+	  printf("Out of memory in string_join");
 	  exit(-1);
 	}
 	char *current_string;
@@ -1424,7 +1547,7 @@ static ExcelValue string_join(int number_of_arguments, ExcelValue *arguments) {
   	  case ExcelNumber:
 			  current_string = malloc(20); // Freed
 		  	if(current_string == 0) {
-		  	  printf("Out of memory");
+		  	  printf("Out of memory in string join");
 		  	  exit(-1);
 		  	}
 			must_free_current_string = 1;				  
@@ -1538,7 +1661,7 @@ static ExcelValue filter_range(ExcelValue original_range_v, int number_of_argume
   // 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\n");
+	  printf("Out of memory in filter_range\n");
 	  exit(-1);
   }
   char *s;
@@ -1748,7 +1871,7 @@ static ExcelValue sumproduct(int number_of_arguments, ExcelValue *arguments) {
   ExcelValue current_value;
   ExcelValue **ranges = malloc(sizeof(ExcelValue *)*number_of_arguments); // Added free statements
   if(ranges == 0) {
-	  printf("Out of memory\n");
+	  printf("Out of memory in sumproduct\n");
 	  exit(-1);
   }
   double product = 1;

data/src/compile/c/excel_to_c_runtime_test.c

@@ -1,49 +1,49 @@
 #include "excel_to_c_runtime.c"
 
 int test_functions() {
-	// Test ABS
-	assert(excel_abs(ONE).number == 1);
-	assert(excel_abs(new_excel_number(-1)).number == 1);
-	assert(excel_abs(VALUE).type == ExcelError);
-	
-	// Test ADD
-	assert(add(ONE,new_excel_number(-2.5)).number == -1.5);
-	assert(add(ONE,VALUE).type == ExcelError);
-	
-	// Test AND
-	ExcelValue true_array1[] = { TRUE, new_excel_number(10)};
-	ExcelValue true_array2[] = { ONE };
-	ExcelValue false_array1[] = { FALSE, new_excel_number(10)};
-	ExcelValue false_array2[] = { TRUE, new_excel_number(0)};
-	// ExcelValue error_array1[] = { new_excel_number(10)}; // Not implemented
-	ExcelValue error_array2[] = { TRUE, NA};
-	assert(excel_and(2,true_array1).number == 1);
-	assert(excel_and(1,true_array2).number == 1);
-	assert(excel_and(2,false_array1).number == 0);
-	assert(excel_and(2,false_array2).number == 0);
-	// assert(excel_and(1,error_array1).type == ExcelError); // Not implemented
-	assert(excel_and(2,error_array2).type == ExcelError);
-	
-	// Test AVERAGE
-	ExcelValue array1[] = { new_excel_number(10), new_excel_number(5), TRUE, FALSE};
-	ExcelValue array1_v = new_excel_range(array1,2,2);
-	ExcelValue array2[] = { array1_v, new_excel_number(9), new_excel_string("Hello")};
-	ExcelValue array3[] = { array1_v, new_excel_number(9), new_excel_string("Hello"), VALUE};
-	assert(average(4, array1).number == 7.5);
-	assert(average(3, array2).number == 8);
-	assert(average(4, array3).type == ExcelError);
-	
-	// Test CHOOSE
-	assert(choose(ONE,4,array1).number == 10);
-	assert(choose(new_excel_number(4),4,array1).type == ExcelBoolean);
-	assert(choose(new_excel_number(0),4,array1).type == ExcelError);
-	assert(choose(new_excel_number(5),4,array1).type == ExcelError);
-	assert(choose(ONE,4,array3).type == ExcelError);	
-	
-	// Test COUNT
-	assert(count(4,array1).number == 2);
-	assert(count(3,array2).number == 3);
-	assert(count(4,array3).number == 3);
+  // Test ABS
+  assert(excel_abs(ONE).number == 1);
+  assert(excel_abs(new_excel_number(-1)).number == 1);
+  assert(excel_abs(VALUE).type == ExcelError);
+
+  // Test ADD
+  assert(add(ONE,new_excel_number(-2.5)).number == -1.5);
+  assert(add(ONE,VALUE).type == ExcelError);
+
+  // Test AND
+  ExcelValue true_array1[] = { TRUE, new_excel_number(10)};
+  ExcelValue true_array2[] = { ONE };
+  ExcelValue false_array1[] = { FALSE, new_excel_number(10)};
+  ExcelValue false_array2[] = { TRUE, new_excel_number(0)};
+  // ExcelValue error_array1[] = { new_excel_number(10)}; // Not implemented
+  ExcelValue error_array2[] = { TRUE, NA};
+  assert(excel_and(2,true_array1).number == 1);
+  assert(excel_and(1,true_array2).number == 1);
+  assert(excel_and(2,false_array1).number == 0);
+  assert(excel_and(2,false_array2).number == 0);
+  // assert(excel_and(1,error_array1).type == ExcelError); // Not implemented
+  assert(excel_and(2,error_array2).type == ExcelError);
+
+  // Test AVERAGE
+  ExcelValue array1[] = { new_excel_number(10), new_excel_number(5), TRUE, FALSE};
+  ExcelValue array1_v = new_excel_range(array1,2,2);
+  ExcelValue array2[] = { array1_v, new_excel_number(9), new_excel_string("Hello")};
+  ExcelValue array3[] = { array1_v, new_excel_number(9), new_excel_string("Hello"), VALUE};
+  assert(average(4, array1).number == 7.5);
+  assert(average(3, array2).number == 8);
+  assert(average(4, array3).type == ExcelError);
+
+  // Test CHOOSE
+  assert(choose(ONE,4,array1).number == 10);
+  assert(choose(new_excel_number(4),4,array1).type == ExcelBoolean);
+  assert(choose(new_excel_number(0),4,array1).type == ExcelError);
+  assert(choose(new_excel_number(5),4,array1).type == ExcelError);
+  assert(choose(ONE,4,array3).type == ExcelError);	
+
+  // Test COUNT
+  assert(count(4,array1).number == 2);
+  assert(count(3,array2).number == 3);
+  assert(count(4,array3).number == 3);
 
   // Test Large
   ExcelValue large_test_array_1[] = { new_excel_number(10), new_excel_number(100), new_excel_number(500), BLANK };
@@ -58,380 +58,381 @@ int test_functions() {
   assert(large(large_test_array_2_v,new_excel_number(2)).type == ExcelError);
   assert(large(new_excel_number(500),VALUE).type == ExcelError);
 
-	
-	// Test COUNTA
-	ExcelValue count_a_test_array_1[] = { new_excel_number(10), new_excel_number(5), TRUE, FALSE, new_excel_string("Hello"), VALUE, BLANK};
+
+  // Test COUNTA
+  ExcelValue count_a_test_array_1[] = { new_excel_number(10), new_excel_number(5), TRUE, FALSE, new_excel_string("Hello"), VALUE, BLANK};
   ExcelValue count_a_test_array_1_v = new_excel_range(count_a_test_array_1,7,1);
   ExcelValue count_a_test_array_2[] = {new_excel_string("Bye"),count_a_test_array_1_v};
-	assert(counta(7, count_a_test_array_1).number == 6);
+  assert(counta(7, count_a_test_array_1).number == 6);
   assert(counta(2, count_a_test_array_2).number == 7);
-	
-	// Test divide
-	assert(divide(new_excel_number(12.4),new_excel_number(3.2)).number == 3.875);
-	assert(divide(new_excel_number(12.4),new_excel_number(0)).type == ExcelError);
-	
-	// Test excel_equal
-	assert(excel_equal(new_excel_number(1.2),new_excel_number(3.4)).type == ExcelBoolean);
-	assert(excel_equal(new_excel_number(1.2),new_excel_number(3.4)).number == false);
-	assert(excel_equal(new_excel_number(1.2),new_excel_number(1.2)).number == true);
-	assert(excel_equal(new_excel_string("hello"), new_excel_string("HELLO")).number == true);
-	assert(excel_equal(new_excel_string("hello world"), new_excel_string("HELLO")).number == false);
-	assert(excel_equal(new_excel_string("1"), ONE).number == false);
-	assert(excel_equal(DIV0, ONE).type == ExcelError);
-
-	// Test not_equal
-	assert(not_equal(new_excel_number(1.2),new_excel_number(3.4)).type == ExcelBoolean);
-	assert(not_equal(new_excel_number(1.2),new_excel_number(3.4)).number == true);
-	assert(not_equal(new_excel_number(1.2),new_excel_number(1.2)).number == false);
-	assert(not_equal(new_excel_string("hello"), new_excel_string("HELLO")).number == false);
-	assert(not_equal(new_excel_string("hello world"), new_excel_string("HELLO")).number == true);
-	assert(not_equal(new_excel_string("1"), ONE).number == true);
-	assert(not_equal(DIV0, ONE).type == ExcelError);
-	
-	// Test excel_if
-	// Two argument version
-	assert(excel_if_2(TRUE,new_excel_number(10)).type == ExcelNumber);
-	assert(excel_if_2(TRUE,new_excel_number(10)).number == 10);
-	assert(excel_if_2(FALSE,new_excel_number(10)).type == ExcelBoolean);
-	assert(excel_if_2(FALSE,new_excel_number(10)).number == false);
-	assert(excel_if_2(NA,new_excel_number(10)).type == ExcelError);
-	// Three argument version
-	assert(excel_if(TRUE,new_excel_number(10),new_excel_number(20)).type == ExcelNumber);
-	assert(excel_if(TRUE,new_excel_number(10),new_excel_number(20)).number == 10);
-	assert(excel_if(FALSE,new_excel_number(10),new_excel_number(20)).type == ExcelNumber);
-	assert(excel_if(FALSE,new_excel_number(10),new_excel_number(20)).number == 20);
-	assert(excel_if(NA,new_excel_number(10),new_excel_number(20)).type == ExcelError);
-	assert(excel_if(TRUE,new_excel_number(10),NA).type == ExcelNumber);
-	assert(excel_if(TRUE,new_excel_number(10),NA).number == 10);
-	
-	// Test excel_match
-	ExcelValue excel_match_array_1[] = { new_excel_number(10), new_excel_number(100) };
-	ExcelValue excel_match_array_1_v = new_excel_range(excel_match_array_1,1,2);
-	ExcelValue excel_match_array_2[] = { new_excel_string("Pear"), new_excel_string("Bear"), new_excel_string("Apple") };
-	ExcelValue excel_match_array_2_v = new_excel_range(excel_match_array_2,3,1);
-	ExcelValue excel_match_array_4[] = { ONE, BLANK, new_excel_number(0) };
-	ExcelValue excel_match_array_4_v = new_excel_range(excel_match_array_4,1,3);
-	ExcelValue excel_match_array_5[] = { ONE, new_excel_number(0), BLANK };
-	ExcelValue excel_match_array_5_v = new_excel_range(excel_match_array_5,1,3);
-	
-	// Two argument version
-	assert(excel_match_2(new_excel_number(10),excel_match_array_1_v).number == 1);
-	assert(excel_match_2(new_excel_number(100),excel_match_array_1_v).number == 2);
-	assert(excel_match_2(new_excel_number(1000),excel_match_array_1_v).type == ExcelError);
-    assert(excel_match_2(new_excel_number(0), excel_match_array_4_v).number == 2);
-    assert(excel_match_2(BLANK, excel_match_array_5_v).number == 2);
-
-	// Three argument version	
-    assert(excel_match(new_excel_number(10.0), excel_match_array_1_v, new_excel_number(0) ).number == 1);
-    assert(excel_match(new_excel_number(100.0), excel_match_array_1_v, new_excel_number(0) ).number == 2);
-    assert(excel_match(new_excel_number(1000.0), excel_match_array_1_v, new_excel_number(0) ).type == ExcelError);
-    assert(excel_match(new_excel_string("bEAr"), excel_match_array_2_v, new_excel_number(0) ).number == 2);
-    assert(excel_match(new_excel_number(1000.0), excel_match_array_1_v, ONE ).number == 2);
-    assert(excel_match(new_excel_number(1.0), excel_match_array_1_v, ONE ).type == ExcelError);
-    assert(excel_match(new_excel_string("Care"), excel_match_array_2_v, new_excel_number(-1) ).number == 1  );
-    assert(excel_match(new_excel_string("Zebra"), excel_match_array_2_v, new_excel_number(-1) ).type == ExcelError);
-    assert(excel_match(new_excel_string("a"), excel_match_array_2_v, new_excel_number(-1) ).number == 2);
-	
-	// When not given a range
-    assert(excel_match(new_excel_number(10.0), new_excel_number(10), new_excel_number(0.0)).number == 1);
-    assert(excel_match(new_excel_number(20.0), new_excel_number(10), new_excel_number(0.0)).type == ExcelError);
-    assert(excel_match(new_excel_number(10.0), excel_match_array_1_v, BLANK).number == 1);
-
-	// Test more than on
-	// .. numbers
-    assert(more_than(ONE,new_excel_number(2)).number == false);
-    assert(more_than(ONE,ONE).number == false);
-    assert(more_than(ONE,new_excel_number(0)).number == true);
-	// .. booleans
-    assert(more_than(FALSE,FALSE).number == false);
-    assert(more_than(FALSE,TRUE).number == false);
-    assert(more_than(TRUE,FALSE).number == true);
-    assert(more_than(TRUE,TRUE).number == false);
-	// ..strings
-    assert(more_than(new_excel_string("HELLO"),new_excel_string("Ardvark")).number == true);		
-    assert(more_than(new_excel_string("HELLO"),new_excel_string("world")).number == false);
-    assert(more_than(new_excel_string("HELLO"),new_excel_string("hello")).number == false);
-	// ..blanks
-    assert(more_than(BLANK,ONE).number == false);
-    assert(more_than(BLANK,new_excel_number(-1)).number == true);
-    assert(more_than(ONE,BLANK).number == true);
-    assert(more_than(new_excel_number(-1),BLANK).number == false);
-
-	// Test less than on
-	// .. numbers
-    assert(less_than(ONE,new_excel_number(2)).number == true);
-    assert(less_than(ONE,ONE).number == false);
-    assert(less_than(ONE,new_excel_number(0)).number == false);
-	// .. booleans
-    assert(less_than(FALSE,FALSE).number == false);
-    assert(less_than(FALSE,TRUE).number == true);
-    assert(less_than(TRUE,FALSE).number == false);
-    assert(less_than(TRUE,TRUE).number == false);
-	// ..strings
-    assert(less_than(new_excel_string("HELLO"),new_excel_string("Ardvark")).number == false);		
-    assert(less_than(new_excel_string("HELLO"),new_excel_string("world")).number == true);
-    assert(less_than(new_excel_string("HELLO"),new_excel_string("hello")).number == false);
-	// ..blanks
-    assert(less_than(BLANK,ONE).number == true);
-    assert(less_than(BLANK,new_excel_number(-1)).number == false);
-    assert(less_than(ONE,BLANK).number == false);
-    assert(less_than(new_excel_number(-1),BLANK).number == true);
-
-	// Test FIND function
-	// ... should find the first occurrence of one string in another, returning :value if the string doesn't match
-	assert(find_2(new_excel_string("one"),new_excel_string("onetwothree")).number == 1);
-	assert(find_2(new_excel_string("one"),new_excel_string("twoonethree")).number == 4);
-	assert(find_2(new_excel_string("one"),new_excel_string("twoonthree")).type == ExcelError);
-    // ... should find the first occurrence of one string in another after a given index, returning :value if the string doesn't match
-	assert(find(new_excel_string("one"),new_excel_string("onetwothree"),ONE).number == 1);
-	assert(find(new_excel_string("one"),new_excel_string("twoonethree"),new_excel_number(5)).type == ExcelError);
-	assert(find(new_excel_string("one"),new_excel_string("oneone"),new_excel_number(2)).number == 4);
-    // ... should be possible for the start_num to be a string, if that string converts to a number
-	assert(find(new_excel_string("one"),new_excel_string("oneone"),new_excel_string("2")).number == 4);
-    // ... should return a :value error when given anything but a number as the third argument
-	assert(find(new_excel_string("one"),new_excel_string("oneone"),new_excel_string("a")).type == ExcelError);
-    // ... should return a :value error when given a third argument that is less than 1 or greater than the length of the string
-	assert(find(new_excel_string("one"),new_excel_string("oneone"),new_excel_number(0)).type == ExcelError);
-	assert(find(new_excel_string("one"),new_excel_string("oneone"),new_excel_number(-1)).type == ExcelError);
-	assert(find(new_excel_string("one"),new_excel_string("oneone"),new_excel_number(7)).type == ExcelError);
-	// ... BLANK in the first argument matches any character
-	assert(find_2(BLANK,new_excel_string("abcdefg")).number == 1);
-	assert(find(BLANK,new_excel_string("abcdefg"),new_excel_number(4)).number == 4);
-    // ... should treat BLANK in the second argument as an empty string
-	assert(find_2(BLANK,BLANK).number == 1);
-	assert(find_2(new_excel_string("a"),BLANK).type == ExcelError);
-	// ... should return an error if any argument is an error
-	assert(find(new_excel_string("one"),new_excel_string("onetwothree"),NA).type == ExcelError);
-	assert(find(new_excel_string("one"),NA,ONE).type == ExcelError);
-	assert(find(NA,new_excel_string("onetwothree"),ONE).type == ExcelError);
-	
-	// Test the IFERROR function
-    assert(iferror(new_excel_string("ok"),ONE).type == ExcelString);
-	assert(iferror(VALUE,ONE).type == ExcelNumber);		
-	
-	// Test the INDEX function
-	ExcelValue index_array_1[] = { new_excel_number(10), new_excel_number(20), BLANK };
-	ExcelValue index_array_1_v_column = new_excel_range(index_array_1,3,1);
-	ExcelValue index_array_1_v_row = new_excel_range(index_array_1,1,3);
-	ExcelValue index_array_2[] = { BLANK, ONE, new_excel_number(10), new_excel_number(11), new_excel_number(100), new_excel_number(101) };
-	ExcelValue index_array_2_v = new_excel_range(index_array_2,3,2);
-	// ... if given one argument should return the value at that offset in the range
-	assert(excel_index_2(index_array_1_v_column,new_excel_number(2.0)).number == 20);
-	assert(excel_index_2(index_array_1_v_row,new_excel_number(2.0)).number == 20);
-	// ... but not if the range is not a single row or single column
-	assert(excel_index_2(index_array_2_v,new_excel_number(2.0)).type == ExcelError);
-    // ... it should return the value in the array at position row_number, column_number
-	assert(excel_index(new_excel_number(10),ONE,ONE).number == 10);
-	assert(excel_index(index_array_2_v,new_excel_number(1.0),new_excel_number(2.0)).number == 1);
-	assert(excel_index(index_array_2_v,new_excel_number(2.0),new_excel_number(1.0)).number == 10);
-	assert(excel_index(index_array_2_v,new_excel_number(3.0),new_excel_number(1.0)).number == 100);
-	assert(excel_index(index_array_2_v,new_excel_number(3.0),new_excel_number(3.0)).type == ExcelError);
-	// ... it should return ZERO not blank, if a blank cell is picked
-	assert(excel_index(index_array_2_v,new_excel_number(1.0),new_excel_number(1.0)).type == ExcelNumber);
-	assert(excel_index(index_array_2_v,new_excel_number(1.0),new_excel_number(1.0)).number == 0);
-	assert(excel_index_2(index_array_1_v_row,new_excel_number(3.0)).type == ExcelNumber);
-	assert(excel_index_2(index_array_1_v_row,new_excel_number(3.0)).number == 0);
-	// ... it should return the whole row if given a zero column number
-	ExcelValue index_result_1_v = excel_index(index_array_2_v,new_excel_number(1.0),new_excel_number(0.0));
-	assert(index_result_1_v.type == ExcelRange);
-	assert(index_result_1_v.rows == 1);
-	assert(index_result_1_v.columns == 2);
-	ExcelValue *index_result_1_a = index_result_1_v.array;
-	assert(index_result_1_a[0].number == 0);
-	assert(index_result_1_a[1].number == 1);
-	// ... it should return the whole column if given a zero row number
-	ExcelValue index_result_2_v = excel_index(index_array_2_v,new_excel_number(0),new_excel_number(1.0));
-	assert(index_result_2_v.type == ExcelRange);
-	assert(index_result_2_v.rows == 3);
-	assert(index_result_2_v.columns == 1);
-	ExcelValue *index_result_2_a = index_result_2_v.array;
-	assert(index_result_2_a[0].number == 0);
-	assert(index_result_2_a[1].number == 10);
-	assert(index_result_2_a[2].number == 100);
-    // ... it should return a :ref error when given arguments outside array range
-	assert(excel_index_2(index_array_1_v_row,new_excel_number(-1)).type == ExcelError);
-	assert(excel_index_2(index_array_1_v_row,new_excel_number(4)).type == ExcelError);
-    // ... it should treat BLANK as zero if given as a required row or column number
-	assert(excel_index(index_array_2_v,new_excel_number(1.0),BLANK).type == ExcelRange);
-	assert(excel_index(index_array_2_v,BLANK,new_excel_number(2.0)).type == ExcelRange);
-    // ... it should return an error if an argument is an error
-	assert(excel_index(NA,NA,NA).type == ExcelError);
-	
-	// LEFT(string,[characters])
-	// ... should return the left n characters from a string
-    assert(strcmp(left_1(new_excel_string("ONE")).string,"O") == 0);
-    assert(strcmp(left(new_excel_string("ONE"),ONE).string,"O") == 0);
-    assert(strcmp(left(new_excel_string("ONE"),new_excel_number(3)).string,"ONE") == 0);
-	// ... should turn numbers into strings before processing
-	assert(strcmp(left(new_excel_number(1.31e12),new_excel_number(3)).string, "131") == 0);
-	// ... should turn booleans into the words TRUE and FALSE before processing
-    assert(strcmp(left(TRUE,new_excel_number(3)).string,"TRU") == 0);
-	assert(strcmp(left(FALSE,new_excel_number(3)).string,"FAL") == 0);
-	// ... should return BLANK if given BLANK for either argument
-	assert(left(BLANK,new_excel_number(3)).type == ExcelEmpty);
-	assert(left(new_excel_string("ONE"),BLANK).type == ExcelEmpty);
-	// ... should return an error if an argument is an error
-    assert(left_1(NA).type == ExcelError);
-    assert(left(new_excel_string("ONE"),NA).type == ExcelError);
-	
-	// Test less than or equal to
-	// .. numbers
-    assert(less_than_or_equal(ONE,new_excel_number(2)).number == true);
-    assert(less_than_or_equal(ONE,ONE).number == true);
-    assert(less_than_or_equal(ONE,new_excel_number(0)).number == false);
-	// .. booleans
-    assert(less_than_or_equal(FALSE,FALSE).number == true);
-    assert(less_than_or_equal(FALSE,TRUE).number == true);
-    assert(less_than_or_equal(TRUE,FALSE).number == false);
-    assert(less_than_or_equal(TRUE,TRUE).number == true);
-	// ..strings
-    assert(less_than_or_equal(new_excel_string("HELLO"),new_excel_string("Ardvark")).number == false);		
-    assert(less_than_or_equal(new_excel_string("HELLO"),new_excel_string("world")).number == true);
-    assert(less_than_or_equal(new_excel_string("HELLO"),new_excel_string("hello")).number == true);
-	// ..blanks
-    assert(less_than_or_equal(BLANK,ONE).number == true);
-    assert(less_than_or_equal(BLANK,new_excel_number(-1)).number == false);
-    assert(less_than_or_equal(ONE,BLANK).number == false);
-    assert(less_than_or_equal(new_excel_number(-1),BLANK).number == true);
-
-	// Test MAX
-	assert(max(4, array1).number == 10);
-	assert(max(3, array2).number == 10);
-	assert(max(4, array3).type == ExcelError);
-
-	// Test MIN
-	assert(min(4, array1).number == 5);
-	assert(min(3, array2).number == 5);
-	assert(min(4, array3).type == ExcelError);
-
-	// Test MOD
-    // ... should return the remainder of a number
-	assert(mod(new_excel_number(10), new_excel_number(3)).number == 1.0);
-	assert(mod(new_excel_number(10), new_excel_number(5)).number == 0.0);
-    // ... should be possible for the the arguments to be strings, if they convert to a number
-	assert(mod(new_excel_string("3.5"),new_excel_string("2")).number == 1.5);
-    // ... should treat BLANK as zero
-	assert(mod(BLANK,new_excel_number(10)).number == 0);
-	assert(mod(new_excel_number(10),BLANK).type == ExcelError);
-	assert(mod(BLANK,BLANK).type == ExcelError);
-    // ... should treat true as 1 and FALSE as 0
-	assert((mod(new_excel_number(1.1),TRUE).number - 0.1) < 0.001);	
-	assert(mod(new_excel_number(1.1),FALSE).type == ExcelError);
-	assert(mod(FALSE,new_excel_number(10)).number == 0);
-    // ... should return an error when given inappropriate arguments
-	assert(mod(new_excel_string("Asdasddf"),new_excel_string("adsfads")).type == ExcelError);
-    // ... should return an error if an argument is an error
-	assert(mod(new_excel_number(1),VALUE).type == ExcelError);
-	assert(mod(VALUE,new_excel_number(1)).type == ExcelError);
-	assert(mod(VALUE,VALUE).type == ExcelError);
-	
-	// Test more than or equal to on
-	// .. numbers
-    assert(more_than_or_equal(ONE,new_excel_number(2)).number == false);
-    assert(more_than_or_equal(ONE,ONE).number == true);
-    assert(more_than_or_equal(ONE,new_excel_number(0)).number == true);
-	// .. booleans
-    assert(more_than_or_equal(FALSE,FALSE).number == true);
-    assert(more_than_or_equal(FALSE,TRUE).number == false);
-    assert(more_than_or_equal(TRUE,FALSE).number == true);
-    assert(more_than_or_equal(TRUE,TRUE).number == true);
-	// ..strings
-    assert(more_than_or_equal(new_excel_string("HELLO"),new_excel_string("Ardvark")).number == true);		
-    assert(more_than_or_equal(new_excel_string("HELLO"),new_excel_string("world")).number == false);
-    assert(more_than_or_equal(new_excel_string("HELLO"),new_excel_string("hello")).number == true);
-	// ..blanks
-    assert(more_than_or_equal(BLANK,BLANK).number == true);
-    assert(more_than_or_equal(BLANK,ONE).number == false);
-    assert(more_than_or_equal(BLANK,new_excel_number(-1)).number == true);
-    assert(more_than_or_equal(ONE,BLANK).number == true);
-    assert(more_than_or_equal(new_excel_number(-1),BLANK).number == false);	
-	
-	// Test negative
-    // ... should return the negative of its arguments
-	assert(negative(new_excel_number(1)).number == -1);
-	assert(negative(new_excel_number(-1)).number == 1);
-    // ... should treat strings that only contain numbers as numbers
-	assert(negative(new_excel_string("10")).number == -10);
-	assert(negative(new_excel_string("-1.3")).number == 1.3);
-    // ... should return an error when given inappropriate arguments
-	assert(negative(new_excel_string("Asdasddf")).type == ExcelError);
-    // ... should treat BLANK as zero
-	assert(negative(BLANK).number == 0);
-	
-	// Test PMT(rate,number_of_periods,present_value) - optional arguments not yet implemented
-    // ... should calculate the monthly payment required for a given principal, interest rate and loan period
-    assert((pmt(new_excel_number(0.1),new_excel_number(10),new_excel_number(100)).number - -16.27) < 0.01);
-    assert((pmt(new_excel_number(0.0123),new_excel_number(99.1),new_excel_number(123.32)).number - -2.159) < 0.01);
-    assert((pmt(new_excel_number(0),new_excel_number(2),new_excel_number(10)).number - -5) < 0.01);
-
-	// Test power
-    // ... should return power of its arguments
-	assert(power(new_excel_number(2),new_excel_number(3)).number == 8);
-	assert(power(new_excel_number(4.0),new_excel_number(0.5)).number == 2.0);
-	assert(power(new_excel_number(-4.0),new_excel_number(0.5)).type == ExcelError);
-	
-	// Test round
-    assert(excel_round(new_excel_number(1.1), new_excel_number(0)).number == 1.0);
-    assert(excel_round(new_excel_number(1.5), new_excel_number(0)).number == 2.0);
-    assert(excel_round(new_excel_number(1.56),new_excel_number(1)).number == 1.6);
-    assert(excel_round(new_excel_number(-1.56),new_excel_number(1)).number == -1.6);
-
-	// Test rounddown
-    assert(rounddown(new_excel_number(1.1), new_excel_number(0)).number == 1.0);
-    assert(rounddown(new_excel_number(1.5), new_excel_number(0)).number == 1.0);
-    assert(rounddown(new_excel_number(1.56),new_excel_number(1)).number == 1.5);
-    assert(rounddown(new_excel_number(-1.56),new_excel_number(1)).number == -1.5);	
-
-	// Test int
-    assert(excel_int(new_excel_number(8.9)).number == 8.0);
-    assert(excel_int(new_excel_number(-8.9)).number == -9.0);
-
-	// Test roundup
-    assert(roundup(new_excel_number(1.1), new_excel_number(0)).number == 2.0);
-    assert(roundup(new_excel_number(1.5), new_excel_number(0)).number == 2.0);
-    assert(roundup(new_excel_number(1.56),new_excel_number(1)).number == 1.6);
-    assert(roundup(new_excel_number(-1.56),new_excel_number(1)).number == -1.6);	
-	
-	// Test string joining
-	ExcelValue string_join_array_1[] = {new_excel_string("Hello "), new_excel_string("world")};
-	ExcelValue string_join_array_2[] = {new_excel_string("Hello "), new_excel_string("world"), new_excel_string("!")};
-	ExcelValue string_join_array_3[] = {new_excel_string("Top "), new_excel_number(10.0)};
-	ExcelValue string_join_array_4[] = {new_excel_string("Top "), new_excel_number(10.5)};	
-	ExcelValue string_join_array_5[] = {new_excel_string("Top "), TRUE, FALSE};	
-	// ... should return a string by combining its arguments
-	// inspect_excel_value(string_join(2, string_join_array_1));
+
+  // Test divide
+  assert(divide(new_excel_number(12.4),new_excel_number(3.2)).number == 3.875);
+  assert(divide(new_excel_number(12.4),new_excel_number(0)).type == ExcelError);
+
+  // Test excel_equal
+  assert(excel_equal(new_excel_number(1.2),new_excel_number(3.4)).type == ExcelBoolean);
+  assert(excel_equal(new_excel_number(1.2),new_excel_number(3.4)).number == false);
+  assert(excel_equal(new_excel_number(1.2),new_excel_number(1.2)).number == true);
+  assert(excel_equal(new_excel_string("hello"), new_excel_string("HELLO")).number == true);
+  assert(excel_equal(new_excel_string("hello world"), new_excel_string("HELLO")).number == false);
+  assert(excel_equal(new_excel_string("1"), ONE).number == false);
+  assert(excel_equal(DIV0, ONE).type == ExcelError);
+
+  // Test not_equal
+  assert(not_equal(new_excel_number(1.2),new_excel_number(3.4)).type == ExcelBoolean);
+  assert(not_equal(new_excel_number(1.2),new_excel_number(3.4)).number == true);
+  assert(not_equal(new_excel_number(1.2),new_excel_number(1.2)).number == false);
+  assert(not_equal(new_excel_string("hello"), new_excel_string("HELLO")).number == false);
+  assert(not_equal(new_excel_string("hello world"), new_excel_string("HELLO")).number == true);
+  assert(not_equal(new_excel_string("1"), ONE).number == true);
+  assert(not_equal(DIV0, ONE).type == ExcelError);
+
+  // Test excel_if
+  // Two argument version
+  assert(excel_if_2(TRUE,new_excel_number(10)).type == ExcelNumber);
+  assert(excel_if_2(TRUE,new_excel_number(10)).number == 10);
+  assert(excel_if_2(FALSE,new_excel_number(10)).type == ExcelBoolean);
+  assert(excel_if_2(FALSE,new_excel_number(10)).number == false);
+  assert(excel_if_2(NA,new_excel_number(10)).type == ExcelError);
+  // Three argument version
+  assert(excel_if(TRUE,new_excel_number(10),new_excel_number(20)).type == ExcelNumber);
+  assert(excel_if(TRUE,new_excel_number(10),new_excel_number(20)).number == 10);
+  assert(excel_if(FALSE,new_excel_number(10),new_excel_number(20)).type == ExcelNumber);
+  assert(excel_if(FALSE,new_excel_number(10),new_excel_number(20)).number == 20);
+  assert(excel_if(NA,new_excel_number(10),new_excel_number(20)).type == ExcelError);
+  assert(excel_if(TRUE,new_excel_number(10),NA).type == ExcelNumber);
+  assert(excel_if(TRUE,new_excel_number(10),NA).number == 10);
+
+  // Test excel_match
+  ExcelValue excel_match_array_1[] = { new_excel_number(10), new_excel_number(100) };
+  ExcelValue excel_match_array_1_v = new_excel_range(excel_match_array_1,1,2);
+  ExcelValue excel_match_array_2[] = { new_excel_string("Pear"), new_excel_string("Bear"), new_excel_string("Apple") };
+  ExcelValue excel_match_array_2_v = new_excel_range(excel_match_array_2,3,1);
+  ExcelValue excel_match_array_4[] = { ONE, BLANK, new_excel_number(0) };
+  ExcelValue excel_match_array_4_v = new_excel_range(excel_match_array_4,1,3);
+  ExcelValue excel_match_array_5[] = { ONE, new_excel_number(0), BLANK };
+  ExcelValue excel_match_array_5_v = new_excel_range(excel_match_array_5,1,3);
+
+  // Two argument version
+  assert(excel_match_2(new_excel_number(10),excel_match_array_1_v).number == 1);
+  assert(excel_match_2(new_excel_number(100),excel_match_array_1_v).number == 2);
+  assert(excel_match_2(new_excel_number(1000),excel_match_array_1_v).type == ExcelError);
+  assert(excel_match_2(new_excel_number(0), excel_match_array_4_v).number == 2);
+  assert(excel_match_2(BLANK, excel_match_array_5_v).number == 2);
+
+  // Three argument version	
+  assert(excel_match(new_excel_number(10.0), excel_match_array_1_v, new_excel_number(0) ).number == 1);
+  assert(excel_match(new_excel_number(100.0), excel_match_array_1_v, new_excel_number(0) ).number == 2);
+  assert(excel_match(new_excel_number(1000.0), excel_match_array_1_v, new_excel_number(0) ).type == ExcelError);
+  assert(excel_match(new_excel_string("bEAr"), excel_match_array_2_v, new_excel_number(0) ).number == 2);
+  assert(excel_match(new_excel_number(1000.0), excel_match_array_1_v, ONE ).number == 2);
+  assert(excel_match(new_excel_number(1.0), excel_match_array_1_v, ONE ).type == ExcelError);
+  assert(excel_match(new_excel_string("Care"), excel_match_array_2_v, new_excel_number(-1) ).number == 1  );
+  assert(excel_match(new_excel_string("Zebra"), excel_match_array_2_v, new_excel_number(-1) ).type == ExcelError);
+  assert(excel_match(new_excel_string("a"), excel_match_array_2_v, new_excel_number(-1) ).number == 2);
+
+  // When not given a range
+  assert(excel_match(new_excel_number(10.0), new_excel_number(10), new_excel_number(0.0)).number == 1);
+  assert(excel_match(new_excel_number(20.0), new_excel_number(10), new_excel_number(0.0)).type == ExcelError);
+  assert(excel_match(new_excel_number(10.0), excel_match_array_1_v, BLANK).number == 1);
+
+  // Test more than on
+  // .. numbers
+  assert(more_than(ONE,new_excel_number(2)).number == false);
+  assert(more_than(ONE,ONE).number == false);
+  assert(more_than(ONE,new_excel_number(0)).number == true);
+  // .. booleans
+  assert(more_than(FALSE,FALSE).number == false);
+  assert(more_than(FALSE,TRUE).number == false);
+  assert(more_than(TRUE,FALSE).number == true);
+  assert(more_than(TRUE,TRUE).number == false);
+  // ..strings
+  assert(more_than(new_excel_string("HELLO"),new_excel_string("Ardvark")).number == true);		
+  assert(more_than(new_excel_string("HELLO"),new_excel_string("world")).number == false);
+  assert(more_than(new_excel_string("HELLO"),new_excel_string("hello")).number == false);
+  // ..blanks
+  assert(more_than(BLANK,ONE).number == false);
+  assert(more_than(BLANK,new_excel_number(-1)).number == true);
+  assert(more_than(ONE,BLANK).number == true);
+  assert(more_than(new_excel_number(-1),BLANK).number == false);
+
+  // Test less than on
+  // .. numbers
+  assert(less_than(ONE,new_excel_number(2)).number == true);
+  assert(less_than(ONE,ONE).number == false);
+  assert(less_than(ONE,new_excel_number(0)).number == false);
+  // .. booleans
+  assert(less_than(FALSE,FALSE).number == false);
+  assert(less_than(FALSE,TRUE).number == true);
+  assert(less_than(TRUE,FALSE).number == false);
+  assert(less_than(TRUE,TRUE).number == false);
+  // ..strings
+  assert(less_than(new_excel_string("HELLO"),new_excel_string("Ardvark")).number == false);		
+  assert(less_than(new_excel_string("HELLO"),new_excel_string("world")).number == true);
+  assert(less_than(new_excel_string("HELLO"),new_excel_string("hello")).number == false);
+  // ..blanks
+  assert(less_than(BLANK,ONE).number == true);
+  assert(less_than(BLANK,new_excel_number(-1)).number == false);
+  assert(less_than(ONE,BLANK).number == false);
+  assert(less_than(new_excel_number(-1),BLANK).number == true);
+
+  // Test FIND function
+  // ... should find the first occurrence of one string in another, returning :value if the string doesn't match
+  assert(find_2(new_excel_string("one"),new_excel_string("onetwothree")).number == 1);
+  assert(find_2(new_excel_string("one"),new_excel_string("twoonethree")).number == 4);
+  assert(find_2(new_excel_string("one"),new_excel_string("twoonthree")).type == ExcelError);
+  // ... should find the first occurrence of one string in another after a given index, returning :value if the string doesn't match
+  assert(find(new_excel_string("one"),new_excel_string("onetwothree"),ONE).number == 1);
+  assert(find(new_excel_string("one"),new_excel_string("twoonethree"),new_excel_number(5)).type == ExcelError);
+  assert(find(new_excel_string("one"),new_excel_string("oneone"),new_excel_number(2)).number == 4);
+  // ... should be possible for the start_num to be a string, if that string converts to a number
+  assert(find(new_excel_string("one"),new_excel_string("oneone"),new_excel_string("2")).number == 4);
+  // ... should return a :value error when given anything but a number as the third argument
+  assert(find(new_excel_string("one"),new_excel_string("oneone"),new_excel_string("a")).type == ExcelError);
+  // ... should return a :value error when given a third argument that is less than 1 or greater than the length of the string
+  assert(find(new_excel_string("one"),new_excel_string("oneone"),new_excel_number(0)).type == ExcelError);
+  assert(find(new_excel_string("one"),new_excel_string("oneone"),new_excel_number(-1)).type == ExcelError);
+  assert(find(new_excel_string("one"),new_excel_string("oneone"),new_excel_number(7)).type == ExcelError);
+  // ... BLANK in the first argument matches any character
+  assert(find_2(BLANK,new_excel_string("abcdefg")).number == 1);
+  assert(find(BLANK,new_excel_string("abcdefg"),new_excel_number(4)).number == 4);
+  // ... should treat BLANK in the second argument as an empty string
+  assert(find_2(BLANK,BLANK).number == 1);
+  assert(find_2(new_excel_string("a"),BLANK).type == ExcelError);
+  // ... should return an error if any argument is an error
+  assert(find(new_excel_string("one"),new_excel_string("onetwothree"),NA).type == ExcelError);
+  assert(find(new_excel_string("one"),NA,ONE).type == ExcelError);
+  assert(find(NA,new_excel_string("onetwothree"),ONE).type == ExcelError);
+
+  // Test the IFERROR function
+  assert(iferror(new_excel_string("ok"),ONE).type == ExcelString);
+  assert(iferror(VALUE,ONE).type == ExcelNumber);		
+
+  // Test the INDEX function
+  ExcelValue index_array_1[] = { new_excel_number(10), new_excel_number(20), BLANK };
+  ExcelValue index_array_1_v_column = new_excel_range(index_array_1,3,1);
+  ExcelValue index_array_1_v_row = new_excel_range(index_array_1,1,3);
+  ExcelValue index_array_2[] = { BLANK, ONE, new_excel_number(10), new_excel_number(11), new_excel_number(100), new_excel_number(101) };
+  ExcelValue index_array_2_v = new_excel_range(index_array_2,3,2);
+  // ... if given one argument should return the value at that offset in the range
+  assert(excel_index_2(index_array_1_v_column,new_excel_number(2.0)).number == 20);
+  assert(excel_index_2(index_array_1_v_row,new_excel_number(2.0)).number == 20);
+  // ... but not if the range is not a single row or single column
+  assert(excel_index_2(index_array_2_v,new_excel_number(2.0)).type == ExcelError);
+  // ... it should return the value in the array at position row_number, column_number
+  assert(excel_index(new_excel_number(10),ONE,ONE).number == 10);
+  assert(excel_index(index_array_2_v,new_excel_number(1.0),new_excel_number(2.0)).number == 1);
+  assert(excel_index(index_array_2_v,new_excel_number(2.0),new_excel_number(1.0)).number == 10);
+  assert(excel_index(index_array_2_v,new_excel_number(3.0),new_excel_number(1.0)).number == 100);
+  assert(excel_index(index_array_2_v,new_excel_number(3.0),new_excel_number(3.0)).type == ExcelError);
+  // ... it should return ZERO not blank, if a blank cell is picked
+  assert(excel_index(index_array_2_v,new_excel_number(1.0),new_excel_number(1.0)).type == ExcelNumber);
+  assert(excel_index(index_array_2_v,new_excel_number(1.0),new_excel_number(1.0)).number == 0);
+  assert(excel_index_2(index_array_1_v_row,new_excel_number(3.0)).type == ExcelNumber);
+  assert(excel_index_2(index_array_1_v_row,new_excel_number(3.0)).number == 0);
+  // ... it should return the whole row if given a zero column number
+  ExcelValue index_result_1_v = excel_index(index_array_2_v,new_excel_number(1.0),new_excel_number(0.0));
+  assert(index_result_1_v.type == ExcelRange);
+  assert(index_result_1_v.rows == 1);
+  assert(index_result_1_v.columns == 2);
+  ExcelValue *index_result_1_a = index_result_1_v.array;
+  assert(index_result_1_a[0].number == 0);
+  assert(index_result_1_a[1].number == 1);
+  // ... it should return the whole column if given a zero row number
+  ExcelValue index_result_2_v = excel_index(index_array_2_v,new_excel_number(0),new_excel_number(1.0));
+  assert(index_result_2_v.type == ExcelRange);
+  assert(index_result_2_v.rows == 3);
+  assert(index_result_2_v.columns == 1);
+  ExcelValue *index_result_2_a = index_result_2_v.array;
+  assert(index_result_2_a[0].number == 0);
+  assert(index_result_2_a[1].number == 10);
+  assert(index_result_2_a[2].number == 100);
+  // ... it should return a :ref error when given arguments outside array range
+  assert(excel_index_2(index_array_1_v_row,new_excel_number(-1)).type == ExcelError);
+  assert(excel_index_2(index_array_1_v_row,new_excel_number(4)).type == ExcelError);
+  // ... it should treat BLANK as zero if given as a required row or column number
+  assert(excel_index(index_array_2_v,new_excel_number(1.0),BLANK).type == ExcelRange);
+  assert(excel_index(index_array_2_v,BLANK,new_excel_number(2.0)).type == ExcelRange);
+  // ... it should return an error if an argument is an error
+  assert(excel_index(NA,NA,NA).type == ExcelError);
+
+  // LEFT(string,[characters])
+  // ... should return the left n characters from a string
+  assert(strcmp(left_1(new_excel_string("ONE")).string,"O") == 0);
+  assert(strcmp(left(new_excel_string("ONE"),ONE).string,"O") == 0);
+  assert(strcmp(left(new_excel_string("ONE"),new_excel_number(3)).string,"ONE") == 0);
+  // ... should turn numbers into strings before processing
+  assert(strcmp(left(new_excel_number(1.31e12),new_excel_number(3)).string, "131") == 0);
+  // ... should turn booleans into the words TRUE and FALSE before processing
+  assert(strcmp(left(TRUE,new_excel_number(3)).string,"TRU") == 0);
+  assert(strcmp(left(FALSE,new_excel_number(3)).string,"FAL") == 0);
+  // ... should return BLANK if given BLANK for either argument
+  assert(left(BLANK,new_excel_number(3)).type == ExcelEmpty);
+  assert(left(new_excel_string("ONE"),BLANK).type == ExcelEmpty);
+  // ... should return an error if an argument is an error
+  assert(left_1(NA).type == ExcelError);
+  assert(left(new_excel_string("ONE"),NA).type == ExcelError);
+  assert(left(new_excel_string("ONE"),new_excel_number(-10)).type == ExcelError);
+
+  // Test less than or equal to
+  // .. numbers
+  assert(less_than_or_equal(ONE,new_excel_number(2)).number == true);
+  assert(less_than_or_equal(ONE,ONE).number == true);
+  assert(less_than_or_equal(ONE,new_excel_number(0)).number == false);
+  // .. booleans
+  assert(less_than_or_equal(FALSE,FALSE).number == true);
+  assert(less_than_or_equal(FALSE,TRUE).number == true);
+  assert(less_than_or_equal(TRUE,FALSE).number == false);
+  assert(less_than_or_equal(TRUE,TRUE).number == true);
+  // ..strings
+  assert(less_than_or_equal(new_excel_string("HELLO"),new_excel_string("Ardvark")).number == false);		
+  assert(less_than_or_equal(new_excel_string("HELLO"),new_excel_string("world")).number == true);
+  assert(less_than_or_equal(new_excel_string("HELLO"),new_excel_string("hello")).number == true);
+  // ..blanks
+  assert(less_than_or_equal(BLANK,ONE).number == true);
+  assert(less_than_or_equal(BLANK,new_excel_number(-1)).number == false);
+  assert(less_than_or_equal(ONE,BLANK).number == false);
+  assert(less_than_or_equal(new_excel_number(-1),BLANK).number == true);
+
+  // Test MAX
+  assert(max(4, array1).number == 10);
+  assert(max(3, array2).number == 10);
+  assert(max(4, array3).type == ExcelError);
+
+  // Test MIN
+  assert(min(4, array1).number == 5);
+  assert(min(3, array2).number == 5);
+  assert(min(4, array3).type == ExcelError);
+
+  // Test MOD
+  // ... should return the remainder of a number
+  assert(mod(new_excel_number(10), new_excel_number(3)).number == 1.0);
+  assert(mod(new_excel_number(10), new_excel_number(5)).number == 0.0);
+  // ... should be possible for the the arguments to be strings, if they convert to a number
+  assert(mod(new_excel_string("3.5"),new_excel_string("2")).number == 1.5);
+  // ... should treat BLANK as zero
+  assert(mod(BLANK,new_excel_number(10)).number == 0);
+  assert(mod(new_excel_number(10),BLANK).type == ExcelError);
+  assert(mod(BLANK,BLANK).type == ExcelError);
+  // ... should treat true as 1 and FALSE as 0
+  assert((mod(new_excel_number(1.1),TRUE).number - 0.1) < 0.001);	
+  assert(mod(new_excel_number(1.1),FALSE).type == ExcelError);
+  assert(mod(FALSE,new_excel_number(10)).number == 0);
+  // ... should return an error when given inappropriate arguments
+  assert(mod(new_excel_string("Asdasddf"),new_excel_string("adsfads")).type == ExcelError);
+  // ... should return an error if an argument is an error
+  assert(mod(new_excel_number(1),VALUE).type == ExcelError);
+  assert(mod(VALUE,new_excel_number(1)).type == ExcelError);
+  assert(mod(VALUE,VALUE).type == ExcelError);
+
+  // Test more than or equal to on
+  // .. numbers
+  assert(more_than_or_equal(ONE,new_excel_number(2)).number == false);
+  assert(more_than_or_equal(ONE,ONE).number == true);
+  assert(more_than_or_equal(ONE,new_excel_number(0)).number == true);
+  // .. booleans
+  assert(more_than_or_equal(FALSE,FALSE).number == true);
+  assert(more_than_or_equal(FALSE,TRUE).number == false);
+  assert(more_than_or_equal(TRUE,FALSE).number == true);
+  assert(more_than_or_equal(TRUE,TRUE).number == true);
+  // ..strings
+  assert(more_than_or_equal(new_excel_string("HELLO"),new_excel_string("Ardvark")).number == true);		
+  assert(more_than_or_equal(new_excel_string("HELLO"),new_excel_string("world")).number == false);
+  assert(more_than_or_equal(new_excel_string("HELLO"),new_excel_string("hello")).number == true);
+  // ..blanks
+  assert(more_than_or_equal(BLANK,BLANK).number == true);
+  assert(more_than_or_equal(BLANK,ONE).number == false);
+  assert(more_than_or_equal(BLANK,new_excel_number(-1)).number == true);
+  assert(more_than_or_equal(ONE,BLANK).number == true);
+  assert(more_than_or_equal(new_excel_number(-1),BLANK).number == false);	
+
+  // Test negative
+  // ... should return the negative of its arguments
+  assert(negative(new_excel_number(1)).number == -1);
+  assert(negative(new_excel_number(-1)).number == 1);
+  // ... should treat strings that only contain numbers as numbers
+  assert(negative(new_excel_string("10")).number == -10);
+  assert(negative(new_excel_string("-1.3")).number == 1.3);
+  // ... should return an error when given inappropriate arguments
+  assert(negative(new_excel_string("Asdasddf")).type == ExcelError);
+  // ... should treat BLANK as zero
+  assert(negative(BLANK).number == 0);
+
+  // Test PMT(rate,number_of_periods,present_value) - optional arguments not yet implemented
+  // ... should calculate the monthly payment required for a given principal, interest rate and loan period
+  assert((pmt(new_excel_number(0.1),new_excel_number(10),new_excel_number(100)).number - -16.27) < 0.01);
+  assert((pmt(new_excel_number(0.0123),new_excel_number(99.1),new_excel_number(123.32)).number - -2.159) < 0.01);
+  assert((pmt(new_excel_number(0),new_excel_number(2),new_excel_number(10)).number - -5) < 0.01);
+
+  // Test power
+  // ... should return power of its arguments
+  assert(power(new_excel_number(2),new_excel_number(3)).number == 8);
+  assert(power(new_excel_number(4.0),new_excel_number(0.5)).number == 2.0);
+  assert(power(new_excel_number(-4.0),new_excel_number(0.5)).type == ExcelError);
+
+  // Test round
+  assert(excel_round(new_excel_number(1.1), new_excel_number(0)).number == 1.0);
+  assert(excel_round(new_excel_number(1.5), new_excel_number(0)).number == 2.0);
+  assert(excel_round(new_excel_number(1.56),new_excel_number(1)).number == 1.6);
+  assert(excel_round(new_excel_number(-1.56),new_excel_number(1)).number == -1.6);
+
+  // Test rounddown
+  assert(rounddown(new_excel_number(1.1), new_excel_number(0)).number == 1.0);
+  assert(rounddown(new_excel_number(1.5), new_excel_number(0)).number == 1.0);
+  assert(rounddown(new_excel_number(1.56),new_excel_number(1)).number == 1.5);
+  assert(rounddown(new_excel_number(-1.56),new_excel_number(1)).number == -1.5);	
+
+  // Test int
+  assert(excel_int(new_excel_number(8.9)).number == 8.0);
+  assert(excel_int(new_excel_number(-8.9)).number == -9.0);
+
+  // Test roundup
+  assert(roundup(new_excel_number(1.1), new_excel_number(0)).number == 2.0);
+  assert(roundup(new_excel_number(1.5), new_excel_number(0)).number == 2.0);
+  assert(roundup(new_excel_number(1.56),new_excel_number(1)).number == 1.6);
+  assert(roundup(new_excel_number(-1.56),new_excel_number(1)).number == -1.6);	
+
+  // Test string joining
+  ExcelValue string_join_array_1[] = {new_excel_string("Hello "), new_excel_string("world")};
+  ExcelValue string_join_array_2[] = {new_excel_string("Hello "), new_excel_string("world"), new_excel_string("!")};
+  ExcelValue string_join_array_3[] = {new_excel_string("Top "), new_excel_number(10.0)};
+  ExcelValue string_join_array_4[] = {new_excel_string("Top "), new_excel_number(10.5)};	
+  ExcelValue string_join_array_5[] = {new_excel_string("Top "), TRUE, FALSE};	
+  // ... should return a string by combining its arguments
+  // inspect_excel_value(string_join(2, string_join_array_1));
   assert(string_join(2, string_join_array_1).string[6] == 'w');
   assert(string_join(2, string_join_array_1).string[11] == '\0');
-	// ... should cope with an arbitrary number of arguments
+  // ... should cope with an arbitrary number of arguments
   assert(string_join(3, string_join_array_2).string[11] == '!');
   assert(string_join(3, string_join_array_3).string[12] == '\0');
-	// ... should convert values to strings as it goes
+  // ... should convert values to strings as it goes
   assert(string_join(2, string_join_array_3).string[4] == '1');
   assert(string_join(2, string_join_array_3).string[5] == '0');
   assert(string_join(2, string_join_array_3).string[6] == '\0');
-	// ... should convert integer values into strings without decimal points, and float values with decimal points
+  // ... should convert integer values into strings without decimal points, and float values with decimal points
   assert(string_join(2, string_join_array_4).string[4] == '1');
   assert(string_join(2, string_join_array_4).string[5] == '0');
   assert(string_join(2, string_join_array_4).string[6] == '.');
   assert(string_join(2, string_join_array_4).string[7] == '5');
   assert(string_join(2, string_join_array_4).string[8] == '\0');
-	// ... should convert TRUE and FALSE into strings
+  // ... should convert TRUE and FALSE into strings
   assert(string_join(3,string_join_array_5).string[4] == 'T');
   // Should deal with very long string joins
-	ExcelValue string_join_array_6[] = {new_excel_string("0123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789"), new_excel_string("012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789")};
+  ExcelValue string_join_array_6[] = {new_excel_string("0123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789"), new_excel_string("012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789")};
   assert(string_join(2, string_join_array_6).string[0] == '0');
   free_all_allocated_memory();
-	
+
   // Test SUBTOTAL function
   ExcelValue subtotal_array_1[] = {new_excel_number(10),new_excel_number(100),BLANK};
   ExcelValue subtotal_array_1_v = new_excel_range(subtotal_array_1,3,1);
   ExcelValue subtotal_array_2[] = {new_excel_number(1),new_excel_string("two"),subtotal_array_1_v};
-  
+
   // new_excel_number(1.0); 
   // inspect_excel_value(new_excel_number(1.0)); 
   // inspect_excel_value(new_excel_range(subtotal_array_2,3,1)); 
   // inspect_excel_value(subtotal(new_excel_number(1.0),3,subtotal_array_2)); 
-  
+
   assert(subtotal(new_excel_number(1.0),3,subtotal_array_2).number == 111.0/3.0);
   assert(subtotal(new_excel_number(2.0),3,subtotal_array_2).number == 3);
   assert(subtotal(new_excel_number(3.0),7, count_a_test_array_1).number == 6);
@@ -441,7 +442,7 @@ int test_functions() {
   assert(subtotal(new_excel_number(102.0),3,subtotal_array_2).number == 3);
   assert(subtotal(new_excel_number(103.0),3,subtotal_array_2).number == 4);
   assert(subtotal(new_excel_number(109.0),3,subtotal_array_2).number == 111);
-  
+
   // Test SUMIFS function
   ExcelValue sumifs_array_1[] = {new_excel_number(10),new_excel_number(100),BLANK};
   ExcelValue sumifs_array_1_v = new_excel_range(sumifs_array_1,3,1);
@@ -453,14 +454,14 @@ int test_functions() {
   ExcelValue sumifs_array_4_v = new_excel_range(sumifs_array_4,6,1);
   ExcelValue sumifs_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 sumifs_array_5_v = new_excel_range(sumifs_array_5,6,1);
-  
+
   // ... should only sum values that meet all of the criteria
   ExcelValue sumifs_array_6[] = { sumifs_array_1_v, new_excel_number(10), sumifs_array_2_v, new_excel_string("Bear") };
   assert(sumifs(sumifs_array_1_v,4,sumifs_array_6).number == 0.0);
-  
+
   ExcelValue sumifs_array_7[] = { sumifs_array_1_v, new_excel_number(10), sumifs_array_2_v, new_excel_string("Pear") };
   assert(sumifs(sumifs_array_1_v,4,sumifs_array_7).number == 10.0);
-  
+
   // ... should work when single cells are given where ranges expected
   ExcelValue sumifs_array_8[] = { new_excel_string("CAR"), new_excel_string("CAR"), new_excel_string("FCV"), new_excel_string("FCV")};
   assert(sumifs(new_excel_number(0.143897265452564), 4, sumifs_array_8).number == 0.143897265452564);
@@ -468,10 +469,10 @@ int test_functions() {
   // ... should match numbers with strings that contain numbers
   ExcelValue sumifs_array_9[] = { new_excel_number(10), new_excel_string("10.0")};
   assert(sumifs(new_excel_number(100),2,sumifs_array_9).number == 100);
-  
+
   ExcelValue sumifs_array_10[] = { sumifs_array_4_v, new_excel_string("CO2"), sumifs_array_5_v, new_excel_number(2)};
   assert(sumifs(sumifs_array_3_v,4, sumifs_array_10).number == 0);
-  
+
   // ... should match with strings that contain criteria
   ExcelValue sumifs_array_10a[] = { sumifs_array_3_v, new_excel_string("=5")};
   assert(sumifs(sumifs_array_3_v,2, sumifs_array_10a).number == 10);
@@ -481,7 +482,7 @@ int test_functions() {
 
   ExcelValue sumifs_array_10c[] = { sumifs_array_3_v, new_excel_string("<3")};
   assert(sumifs(sumifs_array_3_v,2, sumifs_array_10c).number == 3);
-  
+
   ExcelValue sumifs_array_10d[] = { sumifs_array_3_v, new_excel_string("<=3")};
   assert(sumifs(sumifs_array_3_v,2, sumifs_array_10d).number == 6);
 
@@ -490,33 +491,33 @@ int test_functions() {
 
   ExcelValue sumifs_array_10f[] = { sumifs_array_3_v, new_excel_string(">=3")};
   assert(sumifs(sumifs_array_3_v,2, sumifs_array_10f).number == 17);
-  
+
   // ... should treat BLANK as an empty string when in the check_range, but not in the criteria
   ExcelValue sumifs_array_11[] = { BLANK, new_excel_number(20)};
   assert(sumifs(new_excel_number(100),2,sumifs_array_11).number == 0);
-  
+
   ExcelValue sumifs_array_12[] = {BLANK, new_excel_string("")};
   assert(sumifs(new_excel_number(100),2,sumifs_array_12).number == 100);
-  
+
   ExcelValue sumifs_array_13[] = {BLANK, BLANK};
   assert(sumifs(new_excel_number(100),2,sumifs_array_13).number == 0);
-    
+
   // ... should return an error if range argument is an error
   assert(sumifs(REF,2,sumifs_array_13).type == ExcelError);
-  
-  
+
+
   // Test SUMIF
   // ... where there is only a check range
   assert(sumif_2(sumifs_array_1_v,new_excel_string(">0")).number == 110.0);
   assert(sumif_2(sumifs_array_1_v,new_excel_string(">10")).number == 100.0);
   assert(sumif_2(sumifs_array_1_v,new_excel_string("<100")).number == 10.0);
-  
+
   // ... where there is a seprate sum range
   ExcelValue sumif_array_1[] = {new_excel_number(15),new_excel_number(20), new_excel_number(30)};
   ExcelValue sumif_array_1_v = new_excel_range(sumif_array_1,3,1);
   assert(sumif(sumifs_array_1_v,new_excel_string("10"),sumif_array_1_v).number == 15);
-  
-  
+
+
   // Test SUMPRODUCT
   ExcelValue sumproduct_1[] = { new_excel_number(10), new_excel_number(100), BLANK};
   ExcelValue sumproduct_2[] = { BLANK, new_excel_number(100), new_excel_number(10), BLANK};
@@ -527,7 +528,7 @@ int test_functions() {
   ExcelValue sumproduct_7[] = { new_excel_number(10), new_excel_number(20), new_excel_number(40), new_excel_number(50)};
   ExcelValue sumproduct_8[] = { new_excel_number(11), new_excel_number(21), new_excel_number(41), new_excel_number(51)};
   ExcelValue sumproduct_9[] = { BLANK, BLANK };
-  
+
   ExcelValue sumproduct_1_v = new_excel_range( sumproduct_1, 3, 1);
   ExcelValue sumproduct_2_v = new_excel_range( sumproduct_2, 3, 1);
   ExcelValue sumproduct_3_v = new_excel_range( sumproduct_3, 1, 1);
@@ -537,7 +538,7 @@ int test_functions() {
   ExcelValue sumproduct_7_v = new_excel_range( sumproduct_7, 2, 2);
   ExcelValue sumproduct_8_v = new_excel_range( sumproduct_8, 2, 2);
   ExcelValue sumproduct_9_v = new_excel_range( sumproduct_9, 2, 1);
-  
+
   // ... should multiply together and then sum the elements in row or column areas given as arguments
   ExcelValue sumproducta_1[] = {sumproduct_1_v, sumproduct_2_v};
   assert(sumproduct(2,sumproducta_1).number == 100*100);
@@ -569,7 +570,7 @@ int test_functions() {
   // ... should return an error if an argument is an error
   ExcelValue sumproducta_8[] = {VALUE};
   assert(sumproduct(1,sumproducta_8).type == ExcelError);
-  
+
   // Test VLOOKUP
   ExcelValue vlookup_a1[] = {new_excel_number(1),new_excel_number(10),new_excel_number(2),new_excel_number(20),new_excel_number(3),new_excel_number(30)};
   ExcelValue vlookup_a2[] = {new_excel_string("hello"),new_excel_number(10),new_excel_number(2),new_excel_number(20),new_excel_number(3),new_excel_number(30)};
@@ -599,7 +600,7 @@ int test_functions() {
   assert(vlookup(new_excel_number(2.0),vlookup_a1_v,VALUE,FALSE).type == ExcelError);
   assert(vlookup(new_excel_number(2.0),vlookup_a1_v,new_excel_number(2),VALUE).type == ExcelError);
   assert(vlookup(VALUE,VALUE,VALUE,VALUE).type == ExcelError);
-	
+
   // Test HLOOKUP
   ExcelValue hlookup_a1[] = {new_excel_number(1),new_excel_number(2),new_excel_number(3),new_excel_number(10),new_excel_number(20),new_excel_number(30)};
   ExcelValue hlookup_a2[] = {new_excel_string("hello"),new_excel_number(2),new_excel_number(3),new_excel_number(10),new_excel_number(20),new_excel_number(30)};
@@ -642,7 +643,7 @@ int test_functions() {
   assert((int) pv_3(new_excel_number(0.03), new_excel_number(12), new_excel_number(100)).number == -995);
   assert((int) pv_4(new_excel_number(0.03), new_excel_number(12), new_excel_number(-100), new_excel_number(100)).number == 925);
   assert((int) pv_5(new_excel_number(0.03), new_excel_number(12), new_excel_number(-100), new_excel_number(-100), new_excel_number(1)).number == 1095);
-  
+
   // Test TEXT
   assert(strcmp(text(new_excel_number(1.0), new_excel_string("0%")).string, "100%") == 0);
   assert(strcmp(text(new_excel_string("1"), new_excel_string("0%")).string, "100%") == 0);
@@ -652,13 +653,13 @@ int test_functions() {
 
   // Test LOG
   // One argument variant assumes LOG base 10
-	assert(excel_log(new_excel_number(10)).number == 1);
-	assert(excel_log(new_excel_number(100)).number == 2);
-	assert(excel_log(new_excel_number(0)).type == ExcelError);
+  assert(excel_log(new_excel_number(10)).number == 1);
+  assert(excel_log(new_excel_number(100)).number == 2);
+  assert(excel_log(new_excel_number(0)).type == ExcelError);
   // Two argument variant allows LOG base to be specified
-	assert(excel_log_2(new_excel_number(8),new_excel_number(2)).number == 3.0);
-	assert(excel_log_2(new_excel_number(8),new_excel_number(0)).type == ExcelError);
-  
+  assert(excel_log_2(new_excel_number(8),new_excel_number(2)).number == 3.0);
+  assert(excel_log_2(new_excel_number(8),new_excel_number(0)).type == ExcelError);
+
   // Test MMULT (Matrix multiplication)
   ExcelValue mmult_1[] = { ONE, TWO, THREE, FOUR};
   ExcelValue mmult_2[] = { FOUR, THREE, TWO, ONE};
@@ -682,7 +683,7 @@ int test_functions() {
   assert(mmult_result_1_a[1].number == 5);
   assert(mmult_result_1_a[2].number == 20);
   assert(mmult_result_1_a[3].number == 13);
-  
+
   ExcelValue mmult_result_2_v = mmult(mmult_3_v, mmult_4_v);
   assert(mmult_result_2_v.type == ExcelRange);
   assert(mmult_result_2_v.rows == 1);
@@ -700,12 +701,12 @@ int test_functions() {
   assert(mmult_result_3_a[1].type == ExcelError);
   assert(mmult_result_3_a[2].type == ExcelError);
   assert(mmult_result_3_a[3].type == ExcelError);
-  
+
   // Returns errors if arguments are not ranges
   // FIXME: Should work in edge case where passed two numbers which excel treats as ranges with one row and column
   ExcelValue mmult_result_4_v = mmult(ONE, mmult_2_v);
   assert(mmult_result_4_v.type == ExcelError);
-  
+
   // Returns errors if the ranges aren't the right size to multiply
   ExcelValue mmult_result_5_v = mmult(mmult_1_v, mmult_3_v);
   assert(mmult_result_5_v.type == ExcelRange);
@@ -762,7 +763,7 @@ 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);
@@ -774,14 +775,14 @@ int test_functions() {
   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);
@@ -789,10 +790,10 @@ int test_functions() {
   // ... 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);
@@ -802,7 +803,7 @@ int test_functions() {
 
   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);
 
@@ -811,17 +812,17 @@ int test_functions() {
 
   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);
 
@@ -840,15 +841,55 @@ int test_functions() {
 
   assert(forecast(new_excel_number(6), forecast_array2_v, forecast_array3_v).number == 7);
 
+  // Tests ENSURE_IS_NUMBER function
+  assert(ensure_is_number(new_excel_number(1.3)).type == ExcelNumber);
+  assert(ensure_is_number(new_excel_number(1.3)).number == 1.3);
+  assert(ensure_is_number(BLANK).type == ExcelNumber);
+  assert(ensure_is_number(BLANK).number == 0);
+  assert(ensure_is_number(TRUE).type == ExcelNumber);
+  assert(ensure_is_number(TRUE).number == 1.0);
+  assert(ensure_is_number(FALSE).type == ExcelNumber);
+  assert(ensure_is_number(FALSE).number == 0.0);
+  assert(ensure_is_number(new_excel_string("1.3")).type == ExcelNumber);
+  assert(ensure_is_number(new_excel_string("1.3")).number == 1.3);
+  assert(ensure_is_number(new_excel_string("BASDASD")).type == ExcelError);
+  assert(ensure_is_number(DIV0).type == ExcelError);
+
+  // RIGHT(string,[characters])
+  // ... should return the right n characters from a string
+  assert(strcmp(right_1(new_excel_string("ONE")).string,"E") == 0);
+  assert(strcmp(right(new_excel_string("ONE"),ONE).string,"E") == 0);
+  assert(strcmp(right(new_excel_string("ONE"),new_excel_number(3)).string,"ONE") == 0);
+  // ... should turn numbers into strings before processing
+  assert(strcmp(right(new_excel_number(1.31e12),new_excel_number(3)).string, "000") == 0);
+  // ... should turn booleans into the words TRUE and FALSE before processing
+  assert(strcmp(right(TRUE,new_excel_number(3)).string,"RUE") == 0);
+  assert(strcmp(right(FALSE,new_excel_number(3)).string,"LSE") == 0);
+  // ... should return BLANK if given BLANK for either argument
+  assert(right(BLANK,new_excel_number(3)).type == ExcelEmpty);
+  assert(right(new_excel_string("ONE"),BLANK).type == ExcelEmpty);
+  // ... should return an error if an argument is an error
+  assert(right_1(NA).type == ExcelError);
+  assert(right(new_excel_string("ONE"),NA).type == ExcelError);
+  assert(right(new_excel_string("ONE"),new_excel_number(-10)).type == ExcelError);
+
+  // LEN(string)
+  assert(len(BLANK).type == ExcelNumber);
+  assert(len(BLANK).number == 0);
+  assert(len(new_excel_string("Hello")).number == 5);
+  assert(len(new_excel_number(123)).number == 3);
+  assert(len(TRUE).number == 4);
+  assert(len(FALSE).number == 5);
+
   // Release memory
   free_all_allocated_memory();
-  
+
   // Yay!
   printf("All tests passed\n");
-  
+
   return 0;
 }
 
 int main() {
-	return test_functions();
+  return test_functions();
 }