excel_to_code 0.3.17 → 0.3.18.beta.1

data/src/compile/c/excel_to_c_runtime_test.c

@@ -34,6 +34,23 @@ int test_functions() {
   // assert(excel_and(1,error_array1).type == ExcelError); // Not implemented
   assert(excel_and(2,error_array2).type == ExcelError);
 
+  // Test OR
+  assert(excel_or(2,true_array1).number == 1);
+  assert(excel_or(1,true_array2).number == 1);
+  assert(excel_or(2,false_array1).number == 0);
+  assert(excel_or(2,false_array2).number == 1);
+  //assert(excel_or(2,error_array2).type == ExcelError); // Not implemented
+
+  // Test NOT
+  assert(excel_not(TRUE).number == false);
+  assert(excel_not(FALSE).number == true);
+  assert(excel_not(ZERO).number == true);
+  assert(excel_not(ONE).number == false);
+  assert(excel_not(TWO).number == false);
+  assert(excel_not(BLANK).number == true);
+  assert(excel_not(NA).type == ExcelError);
+  assert(excel_not(EXCEL_STRING("hello world")).type == ExcelError);
+
   // Test AVERAGE
   ExcelValue array1[] = { EXCEL_NUMBER(10), EXCEL_NUMBER(5), TRUE, FALSE};
   ExcelValue array1_v = EXCEL_RANGE(array1,2,2);
@@ -48,7 +65,7 @@ int test_functions() {
   assert(choose(EXCEL_NUMBER(4),4,array1).type == ExcelBoolean);
   assert(choose(EXCEL_NUMBER(0),4,array1).type == ExcelError);
   assert(choose(EXCEL_NUMBER(5),4,array1).type == ExcelError);
-  assert(choose(ONE,4,array3).type == ExcelError);	
+  assert(choose(ONE,4,array3).type == ExcelError);
 
   // Test COUNT
   assert(count(4,array1).number == 2);
@@ -123,13 +140,15 @@ int test_functions() {
   ExcelValue excel_match_array_4_v = EXCEL_RANGE(excel_match_array_4,1,3);
   ExcelValue excel_match_array_5[] = { ONE, EXCEL_NUMBER(0), BLANK };
   ExcelValue excel_match_array_5_v = EXCEL_RANGE(excel_match_array_5,1,3);
+  ExcelValue excel_match_array_6[] = { EXCEL_STRING(""), ONE, TWO, THREE, FOUR };
+  ExcelValue excel_match_array_6_v = EXCEL_RANGE(excel_match_array_6,5,1);
 
   // Two argument version
   assert(excel_match_2(EXCEL_NUMBER(14),excel_match_array_1_v).number == 1);
   assert(excel_match_2(EXCEL_NUMBER(110),excel_match_array_1_v).number == 2);
   assert(excel_match_2(EXCEL_NUMBER(-10),excel_match_array_1_v).type == ExcelError);
 
-  // Three argument version	
+  // Three argument version
   assert(excel_match(EXCEL_NUMBER(10.0), excel_match_array_1_v, EXCEL_NUMBER(0) ).number == 1);
   assert(excel_match(EXCEL_NUMBER(100.0), excel_match_array_1_v, EXCEL_NUMBER(0) ).number == 2);
   assert(excel_match(EXCEL_NUMBER(1000.0), excel_match_array_1_v, EXCEL_NUMBER(0) ).type == ExcelError);
@@ -139,6 +158,8 @@ int test_functions() {
   assert(excel_match(EXCEL_STRING("Care"), excel_match_array_2_v, EXCEL_NUMBER(-1) ).number == 1  );
   assert(excel_match(EXCEL_STRING("Zebra"), excel_match_array_2_v, EXCEL_NUMBER(-1) ).type == ExcelError);
   assert(excel_match(EXCEL_STRING("a"), excel_match_array_2_v, EXCEL_NUMBER(-1) ).number == 2);
+  // EMPTY STRINGS
+  assert(excel_match(EXCEL_NUMBER(1), excel_match_array_6_v, ONE).number == 2);
 
   // When not given a range
   assert(excel_match(EXCEL_NUMBER(10.0), EXCEL_NUMBER(10), EXCEL_NUMBER(0.0)).number == 1);
@@ -156,7 +177,7 @@ int test_functions() {
   assert(more_than(TRUE,FALSE).number == true);
   assert(more_than(TRUE,TRUE).number == false);
   // ..strings
-  assert(more_than(EXCEL_STRING("HELLO"),EXCEL_STRING("Ardvark")).number == true);		
+  assert(more_than(EXCEL_STRING("HELLO"),EXCEL_STRING("Ardvark")).number == true);
   assert(more_than(EXCEL_STRING("HELLO"),EXCEL_STRING("world")).number == false);
   assert(more_than(EXCEL_STRING("HELLO"),EXCEL_STRING("hello")).number == false);
   // ..blanks
@@ -183,7 +204,7 @@ int test_functions() {
   assert(less_than(TRUE,FALSE).number == false);
   assert(less_than(TRUE,TRUE).number == false);
   // ..strings
-  assert(less_than(EXCEL_STRING("HELLO"),EXCEL_STRING("Ardvark")).number == false);		
+  assert(less_than(EXCEL_STRING("HELLO"),EXCEL_STRING("Ardvark")).number == false);
   assert(less_than(EXCEL_STRING("HELLO"),EXCEL_STRING("world")).number == true);
   assert(less_than(EXCEL_STRING("HELLO"),EXCEL_STRING("hello")).number == false);
   // ..blanks
@@ -229,7 +250,7 @@ int test_functions() {
 
   // Test the IFERROR function
   assert(iferror(EXCEL_STRING("ok"),ONE).type == ExcelString);
-  assert(iferror(VALUE,ONE).type == ExcelNumber);		
+  assert(iferror(VALUE,ONE).type == ExcelNumber);
 
   // Test the ISERR function
   assert(iserr(NA).type == ExcelBoolean);
@@ -252,7 +273,7 @@ int test_functions() {
   assert(iserr(ONE).number == 0);
   assert(iserr(EXCEL_STRING("Hello")).number == 0);
   assert(iserr(EXCEL_STRING("Hello")).number == 0);
-  
+
   // Test the ISERROR function
   assert_equal(iserror(NA), TRUE, "ISERROR(NA)");
   assert_equal(iserror(DIV0), TRUE, "ISERROR(DIV0)");
@@ -347,7 +368,7 @@ int test_functions() {
   assert(less_than_or_equal(TRUE,FALSE).number == false);
   assert(less_than_or_equal(TRUE,TRUE).number == true);
   // ..strings
-  assert(less_than_or_equal(EXCEL_STRING("HELLO"),EXCEL_STRING("Ardvark")).number == false);		
+  assert(less_than_or_equal(EXCEL_STRING("HELLO"),EXCEL_STRING("Ardvark")).number == false);
   assert(less_than_or_equal(EXCEL_STRING("HELLO"),EXCEL_STRING("world")).number == true);
   assert(less_than_or_equal(EXCEL_STRING("HELLO"),EXCEL_STRING("hello")).number == true);
   // ..blanks
@@ -377,7 +398,7 @@ int test_functions() {
   assert(mod(EXCEL_NUMBER(10),BLANK).type == ExcelError);
   assert(mod(BLANK,BLANK).type == ExcelError);
   // ... should treat true as 1 and FALSE as 0
-  assert((mod(EXCEL_NUMBER(1.1),TRUE).number - 0.1) < 0.001);	
+  assert((mod(EXCEL_NUMBER(1.1),TRUE).number - 0.1) < 0.001);
   assert(mod(EXCEL_NUMBER(1.1),FALSE).type == ExcelError);
   assert(mod(FALSE,EXCEL_NUMBER(10)).number == 0);
   // ... should return an error when given inappropriate arguments
@@ -398,7 +419,7 @@ int test_functions() {
   assert(more_than_or_equal(TRUE,FALSE).number == true);
   assert(more_than_or_equal(TRUE,TRUE).number == true);
   // ..strings
-  assert(more_than_or_equal(EXCEL_STRING("HELLO"),EXCEL_STRING("Ardvark")).number == true);		
+  assert(more_than_or_equal(EXCEL_STRING("HELLO"),EXCEL_STRING("Ardvark")).number == true);
   assert(more_than_or_equal(EXCEL_STRING("HELLO"),EXCEL_STRING("world")).number == false);
   assert(more_than_or_equal(EXCEL_STRING("HELLO"),EXCEL_STRING("hello")).number == true);
   // ..blanks
@@ -406,7 +427,7 @@ int test_functions() {
   assert(more_than_or_equal(BLANK,ONE).number == false);
   assert(more_than_or_equal(BLANK,EXCEL_NUMBER(-1)).number == true);
   assert(more_than_or_equal(ONE,BLANK).number == true);
-  assert(more_than_or_equal(EXCEL_NUMBER(-1),BLANK).number == false);	
+  assert(more_than_or_equal(EXCEL_NUMBER(-1),BLANK).number == false);
 
   // Test negative
   // ... should return the negative of its arguments
@@ -444,7 +465,7 @@ int test_functions() {
   assert(rounddown(EXCEL_NUMBER(1.1), EXCEL_NUMBER(0)).number == 1.0);
   assert(rounddown(EXCEL_NUMBER(1.5), EXCEL_NUMBER(0)).number == 1.0);
   assert(rounddown(EXCEL_NUMBER(1.56),EXCEL_NUMBER(1)).number == 1.5);
-  assert(rounddown(EXCEL_NUMBER(-1.56),EXCEL_NUMBER(1)).number == -1.5);	
+  assert(rounddown(EXCEL_NUMBER(-1.56),EXCEL_NUMBER(1)).number == -1.5);
 
   // Test int
   assert(excel_int(EXCEL_NUMBER(8.9)).number == 8.0);
@@ -454,14 +475,14 @@ int test_functions() {
   assert(roundup(EXCEL_NUMBER(1.1), EXCEL_NUMBER(0)).number == 2.0);
   assert(roundup(EXCEL_NUMBER(1.5), EXCEL_NUMBER(0)).number == 2.0);
   assert(roundup(EXCEL_NUMBER(1.56),EXCEL_NUMBER(1)).number == 1.6);
-  assert(roundup(EXCEL_NUMBER(-1.56),EXCEL_NUMBER(1)).number == -1.6);	
+  assert(roundup(EXCEL_NUMBER(-1.56),EXCEL_NUMBER(1)).number == -1.6);
 
   // Test string joining
   ExcelValue string_join_array_1[] = {EXCEL_STRING("Hello "), EXCEL_STRING("world")};
   ExcelValue string_join_array_2[] = {EXCEL_STRING("Hello "), EXCEL_STRING("world"), EXCEL_STRING("!")};
   ExcelValue string_join_array_3[] = {EXCEL_STRING("Top "), EXCEL_NUMBER(10.0)};
-  ExcelValue string_join_array_4[] = {EXCEL_STRING("Top "), EXCEL_NUMBER(10.5)};	
-  ExcelValue string_join_array_5[] = {EXCEL_STRING("Top "), TRUE, FALSE};	
+  ExcelValue string_join_array_4[] = {EXCEL_STRING("Top "), EXCEL_NUMBER(10.5)};
+  ExcelValue string_join_array_5[] = {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');
@@ -498,10 +519,10 @@ int test_functions() {
   ExcelValue subtotal_array_1_v = EXCEL_RANGE(subtotal_array_1,3,1);
   ExcelValue subtotal_array_2[] = {EXCEL_NUMBER(1),EXCEL_STRING("two"),subtotal_array_1_v};
 
-  // EXCEL_NUMBER(1.0); 
-  // inspect_excel_value(EXCEL_NUMBER(1.0)); 
-  // inspect_excel_value(EXCEL_RANGE(subtotal_array_2,3,1)); 
-  // inspect_excel_value(subtotal(EXCEL_NUMBER(1.0),3,subtotal_array_2)); 
+  // EXCEL_NUMBER(1.0);
+  // inspect_excel_value(EXCEL_NUMBER(1.0));
+  // inspect_excel_value(EXCEL_RANGE(subtotal_array_2,3,1));
+  // inspect_excel_value(subtotal(EXCEL_NUMBER(1.0),3,subtotal_array_2));
 
   assert(subtotal(EXCEL_NUMBER(1.0),3,subtotal_array_2).number == 111.0/3.0);
   assert(subtotal(EXCEL_NUMBER(2.0),3,subtotal_array_2).number == 3);
@@ -588,6 +609,76 @@ int test_functions() {
   ExcelValue sumifs_array_15[] = {ONE, ONE};
   assert(sumifs(REF,2,sumifs_array_15).type == ExcelError);
 
+  // Test COUNTIFS function
+  ExcelValue countifs_array_1[] = {EXCEL_NUMBER(10),EXCEL_NUMBER(100),BLANK};
+  ExcelValue countifs_array_1_v = EXCEL_RANGE(countifs_array_1,3,1);
+  ExcelValue countifs_array_2[] = {EXCEL_STRING("pear"),EXCEL_STRING("bear"),EXCEL_STRING("apple")};
+  ExcelValue countifs_array_2_v = EXCEL_RANGE(countifs_array_2,3,1);
+  ExcelValue countifs_array_3[] = {EXCEL_NUMBER(1),EXCEL_NUMBER(2),EXCEL_NUMBER(3),EXCEL_NUMBER(4),EXCEL_NUMBER(5),EXCEL_NUMBER(5)};
+  ExcelValue countifs_array_3_v = EXCEL_RANGE(countifs_array_3,6,1);
+  ExcelValue countifs_array_4[] = {EXCEL_STRING("CO2"),EXCEL_STRING("CH4"),EXCEL_STRING("N2O"),EXCEL_STRING("CH4"),EXCEL_STRING("N2O"),EXCEL_STRING("CO2")};
+  ExcelValue countifs_array_4_v = EXCEL_RANGE(countifs_array_4,6,1);
+  ExcelValue countifs_array_5[] = {EXCEL_STRING("1A"),EXCEL_STRING("1A"),EXCEL_STRING("1A"),EXCEL_NUMBER(4),EXCEL_NUMBER(4),EXCEL_NUMBER(5)};
+  ExcelValue countifs_array_5_v = EXCEL_RANGE(countifs_array_5,6,1);
+
+  // ... should only sum values that meet all of the criteria
+  ExcelValue countifs_array_6[] = { countifs_array_1_v, EXCEL_NUMBER(10), countifs_array_2_v, EXCEL_STRING("Bear") };
+  assert(countifs(4,countifs_array_6).number == 0.0);
+
+  ExcelValue countifs_array_7[] = { countifs_array_1_v, EXCEL_NUMBER(10), countifs_array_2_v, EXCEL_STRING("Pear") };
+  assert(countifs(4,countifs_array_7).number == 1.0);
+
+  // ... should work when single cells are given where ranges expected
+  ExcelValue countifs_array_8[] = { EXCEL_STRING("CAR"), EXCEL_STRING("CAR"), EXCEL_STRING("FCV"), EXCEL_STRING("FCV")};
+  assert(countifs(4, countifs_array_8).number == 1.0);
+
+  // ... should match numbers with strings that contain numbers
+  ExcelValue countifs_array_9[] = { EXCEL_NUMBER(10), EXCEL_STRING("10.0")};
+  assert(countifs(2,countifs_array_9).number == 1.0);
+
+  ExcelValue countifs_array_9b[] = { EXCEL_STRING("10"), EXCEL_NUMBER(10.0)};
+  assert(countifs(2,countifs_array_9b).number == 1.0);
+
+  ExcelValue countifs_array_10[] = { countifs_array_4_v, EXCEL_STRING("CO2"), countifs_array_5_v, EXCEL_NUMBER(2)};
+  assert(countifs(4, countifs_array_10).number == 0.0);
+
+  // ... should match with strings that contain criteria
+  ExcelValue countifs_array_10a[] = { countifs_array_3_v, EXCEL_STRING("=5")};
+  assert(countifs(2, countifs_array_10a).number == 2.0);
+
+  ExcelValue countifs_array_10b[] = { countifs_array_3_v, EXCEL_STRING("<>3")};
+  assert(countifs(2, countifs_array_10b).number == 5.0);
+
+  ExcelValue countifs_array_10c[] = { countifs_array_3_v, EXCEL_STRING("<3")};
+  assert(countifs(2, countifs_array_10c).number == 2.0);
+
+  ExcelValue countifs_array_10d[] = { countifs_array_3_v, EXCEL_STRING("<=3")};
+  assert(countifs(2, countifs_array_10d).number == 3.0);
+
+  ExcelValue countifs_array_10e[] = { countifs_array_3_v, EXCEL_STRING(">3")};
+  assert(countifs(2, countifs_array_10e).number == 3.0);
+
+  ExcelValue countifs_array_10f[] = { countifs_array_3_v, EXCEL_STRING(">=3")};
+  assert(countifs(2, countifs_array_10f).number == 4.0);
+
+  // ... BLANK in check range should match empty strings, BLANK in criteria should match zero
+  ExcelValue countifs_array_11[] = { BLANK, EXCEL_NUMBER(0)};
+  assert(countifs(2,countifs_array_11).number == 0);
+
+  ExcelValue countifs_array_11b[] = { BLANK, EXCEL_STRING("")};
+  assert(countifs(2,countifs_array_11b).number == 1);
+
+  ExcelValue countifs_array_11c[] = { EXCEL_STRING(""), BLANK};
+  assert(countifs(2,countifs_array_11c).number == 0);
+
+  ExcelValue countifs_array_12[] = {EXCEL_NUMBER(0), BLANK};
+  assert(countifs(2,countifs_array_12).number == 1);
+
+  ExcelValue countifs_array_13[] = {BLANK, BLANK};
+  assert(countifs(2,countifs_array_13).number == 0);
+
+  ExcelValue countifs_array_14[] = {EXCEL_NUMBER(10), BLANK};
+  assert(countifs(2,countifs_array_14).number == 0);
 
   // Test SUMIF
   // ... where there is only a check range
@@ -654,6 +745,61 @@ int test_functions() {
   ExcelValue sumproducta_8[] = {VALUE};
   assert(sumproduct(1,sumproducta_8).type == ExcelError);
 
+  // Test PRODUCT
+  ExcelValue product_1[] = { EXCEL_NUMBER(10), EXCEL_NUMBER(100), BLANK};
+  ExcelValue product_2[] = { BLANK, EXCEL_NUMBER(100), EXCEL_NUMBER(10), BLANK};
+  ExcelValue product_3[] = { BLANK };
+  ExcelValue product_4[] = { EXCEL_NUMBER(10), EXCEL_NUMBER(100), EXCEL_NUMBER(1000)};
+  ExcelValue product_5[] = { EXCEL_NUMBER(1), EXCEL_NUMBER(2), EXCEL_NUMBER(3)};
+  ExcelValue product_6[] = { EXCEL_NUMBER(1), EXCEL_NUMBER(2), EXCEL_NUMBER(4), EXCEL_NUMBER(5)};
+  ExcelValue product_7[] = { EXCEL_NUMBER(10), EXCEL_NUMBER(20), EXCEL_NUMBER(40), EXCEL_NUMBER(50)};
+  ExcelValue product_8[] = { EXCEL_NUMBER(11), EXCEL_NUMBER(21), EXCEL_NUMBER(41), EXCEL_NUMBER(51)};
+  ExcelValue product_9[] = { BLANK, BLANK };
+
+  ExcelValue product_1_v = EXCEL_RANGE( product_1, 3, 1);
+  ExcelValue product_2_v = EXCEL_RANGE( product_2, 3, 1);
+  ExcelValue product_3_v = EXCEL_RANGE( product_3, 1, 1);
+  // ExcelValue product_4_v = EXCEL_RANGE( product_4, 1, 3); // Unused
+  ExcelValue product_5_v = EXCEL_RANGE( product_5, 3, 1);
+  ExcelValue product_6_v = EXCEL_RANGE( product_6, 2, 2);
+  ExcelValue product_7_v = EXCEL_RANGE( product_7, 2, 2);
+  ExcelValue product_8_v = EXCEL_RANGE( product_8, 2, 2);
+  ExcelValue product_9_v = EXCEL_RANGE( product_9, 2, 1);
+
+  // ... should multiply together the elements in row or column areas given as arguments
+  ExcelValue producta_1[] = {product_1_v, product_2_v};
+  assert(product(2,producta_1).number == 10*100*100*10);
+
+  // ... should work when miss-matched array sizes
+  ExcelValue producta_2[] = {product_1_v, product_3_v};
+  assert(product(2,producta_2).number == 10 * 100);
+
+  // ... if all its arguments are single values, should multiply them together
+  // ExcelValue *producta_3 = product_4;
+  assert(product(3,product_4).number == 10*100*1000);
+
+  // ... if it only has one range as an argument, should multiply its elements together
+  ExcelValue producta_4[] = {product_5_v};
+  assert(product(1,producta_4).number == 1 * 2 * 3);
+
+  // ... if given multi row and column areas as arguments, should multipy the corresponding cell in each area
+  // NB: Repeating this test from SUMPRODUCT, doesn't matter really with multiplication
+  ExcelValue producta_5[] = {product_6_v, product_7_v, product_8_v};
+  // NB: The 1.0 at the start is important, otherwise RHS will be an int with does not equal the double
+  assert(product(3,producta_5).number == (1.0*2*4*5)*(10*20*40*50)*(11*21*41*51));
+
+  // ... should ignore BLANK values outside of an array
+  ExcelValue producta_6[] = {BLANK,EXCEL_NUMBER(1)};
+  assert(product(2,producta_6).type == 1);
+
+  // ... should ignore non-numeric values within an array
+  ExcelValue producta_7[] = {product_9_v, product_9_v};
+  assert(product(2,producta_7).number == 0);
+
+  // ... should return an error if an argument is an error
+  ExcelValue producta_8[] = {VALUE};
+  assert(product(1,producta_8).type == ExcelError);
+
   // Test VLOOKUP
   ExcelValue vlookup_a1[] = {EXCEL_NUMBER(1),EXCEL_NUMBER(10),EXCEL_NUMBER(2),EXCEL_NUMBER(20),EXCEL_NUMBER(3),EXCEL_NUMBER(30)};
   ExcelValue vlookup_a2[] = {EXCEL_STRING("hello"),EXCEL_NUMBER(10),EXCEL_NUMBER(2),EXCEL_NUMBER(20),EXCEL_NUMBER(3),EXCEL_NUMBER(30)};
@@ -761,6 +907,28 @@ int test_functions() {
   assert(ln(EXCEL_NUMBER(0)).type == ExcelError);
   assert(ln(EXCEL_NUMBER(-1)).type == ExcelError);
 
+  // Test excel_sqrt
+  assert(excel_sqrt(EXCEL_NUMBER(1)).number == 1.0);
+  assert(excel_sqrt(EXCEL_NUMBER(4)).number == 2.0);
+  assert(excel_sqrt(EXCEL_NUMBER(1.6)).number == 1.2649110640673518);
+  assert(excel_sqrt(BLANK).number == 0);
+  assert(excel_sqrt(EXCEL_STRING("Hello world")).type == ExcelError);
+  assert(excel_sqrt(EXCEL_NUMBER(-1)).type == ExcelError);
+
+  // Test excel_floor
+  assert(excel_floor(EXCEL_NUMBER(1990), EXCEL_NUMBER(100)).number == 1900.0);
+  assert(excel_floor(EXCEL_NUMBER(10.99), EXCEL_NUMBER(0.1)).number == 10.9);
+  assert(excel_floor(BLANK, ONE).number == 0);
+  assert(excel_floor(EXCEL_NUMBER(10.99), ZERO).type == ExcelError);
+  assert(excel_floor(EXCEL_NUMBER(10.99), EXCEL_NUMBER(-1.0)).type == ExcelError);
+  assert(excel_floor(EXCEL_STRING("Hello world"), ONE).type == ExcelError);
+  assert(excel_floor(ONE, EXCEL_STRING("Hello world")).type == ExcelError);
+  assert(excel_floor(NA, ONE).type == ExcelError);
+  assert(excel_floor(ONE, NA).type == ExcelError);
+
+  // Test partial implementation of rate
+  assert(excel_round(multiply(rate(EXCEL_NUMBER(12), ZERO, EXCEL_NUMBER(-69999), EXCEL_NUMBER(64786)), EXCEL_NUMBER(1000)),ONE).number == -6.4);
+
   // Test MMULT (Matrix multiplication)
   ExcelValue mmult_1[] = { ONE, TWO, THREE, FOUR};
   ExcelValue mmult_2[] = { FOUR, THREE, TWO, ONE};
@@ -955,7 +1123,7 @@ int test_functions() {
   assert(ensure_is_number(EXCEL_STRING("1.3")).number == 1.3);
   assert(ensure_is_number(EXCEL_STRING("BASDASD")).type == ExcelError);
   assert(ensure_is_number(DIV0).type == ExcelError);
-  
+
   // Tests ther NUMBER_OR_ZERO function
   assert_equal(ZERO, number_or_zero(ZERO), "number_or_zero 0");
   assert_equal(ONE, number_or_zero(ONE), "number_or_zero 1");
@@ -965,7 +1133,7 @@ int test_functions() {
   assert_equal(ZERO, number_or_zero(BLANK), "number_or_zero blank");
   assert_equal(ZERO, number_or_zero(EXCEL_STRING("1.3")), "number_or_zero '1.3'");
   assert_equal(ZERO, number_or_zero(EXCEL_STRING("Aasdfadsf")), "number_or_zero 'Asdfad'");
-  
+
   // RIGHT(string,[characters])
   // ... should return the right n characters from a string
   assert(strcmp(right_1(EXCEL_STRING("ONE")).string,"E") == 0);
@@ -1034,6 +1202,44 @@ int test_functions() {
   assert_equal(EXCEL_STRING("a"), excel_char(EXCEL_NUMBER(97)), "excel_char(97) == 'a'");
   assert_equal(EXCEL_STRING("a"), excel_char(EXCEL_NUMBER(97.5)), "excel_char(97.5) == 'a'");
 
+  // NA()
+  assert_equal(NA, na(), "na() == NA");
+  
+  // CEILING.MATH
+  assert(excel_ceiling_math(EXCEL_NUMBER(0.1),EXCEL_NUMBER(0.1), ZERO).number == 0.1);
+  assert(excel_ceiling_math(EXCEL_NUMBER(-0.1), EXCEL_NUMBER(0.1), ZERO).number == -0.1);
+  assert(excel_ceiling_math(EXCEL_NUMBER(-0.1), EXCEL_NUMBER(0.1), ONE).number == -0.1);
+  assert(excel_ceiling_math(EXCEL_NUMBER(136), EXCEL_NUMBER(10), ZERO).number == 140);
+  assert(excel_ceiling_math(EXCEL_NUMBER(-136), EXCEL_NUMBER(10), ZERO).number == -130);
+  assert(excel_ceiling_math(EXCEL_NUMBER(-136), EXCEL_NUMBER(10), ONE).number == -140);
+
+  // curve (a custom climact function)
+  assert_equal(
+    EXCEL_NUMBER(4.99),
+    curve_5(
+      EXCEL_STRING("s"),
+      EXCEL_NUMBER(2023),
+      EXCEL_NUMBER(0),
+      EXCEL_NUMBER(10),
+      EXCEL_NUMBER(10)
+    ),
+    "curve_5('s', 2023, 0, 10, 10) == 4.99"
+  );
+
+  // If blank, defaults to lcurve
+  assert_equal(
+    EXCEL_NUMBER(5.0),
+    curve_5(
+      BLANK,
+      EXCEL_NUMBER(2023),
+      EXCEL_NUMBER(0),
+      EXCEL_NUMBER(10),
+      EXCEL_NUMBER(10)
+    ),
+    "curve_5(blank, 2023, 0, 10, 10) == 5"
+  );
+
+
   // Release memory
   free_all_allocated_memory();
 

data/src/compile/c/map_formulae_to_c.rb

@@ -1,21 +1,22 @@
 require_relative 'map_values_to_c'
 
 class MapFormulaeToC < MapValuesToC
-  
+
   attr_accessor :sheet_names
   attr_accessor :worksheet
   attr_reader :initializers
   attr_reader :counter
-  
+  attr_accessor :allow_unknown_functions
+
   def initialize
     reset
   end
-  
+
   def reset
     @initializers = []
     @counter = 0
   end
-  
+
   FUNCTIONS = {
     :'*' => 'multiply',
     :'+' => 'add',
@@ -31,17 +32,23 @@ class MapFormulaeToC < MapValuesToC
     :'AND' => 'excel_and',
     :'AVERAGE' => 'average',
     :'AVERAGEIFS' => 'averageifs',
+    :'CEILING' => 'ceiling_2',
+    :'_xlfn.CEILING.MATH2' => 'excel_ceiling_math_2',
+    :'_xlfn.CEILING.MATH3' => 'excel_ceiling_math',
     :'CHAR' => 'excel_char',
     :'CHOOSE' => 'choose',
     :'CONCATENATE' => 'string_join',
     :'COSH' => 'cosh',
     :'COUNT' => 'count',
     :'COUNTA' => 'counta',
+    :'COUNTIFS' => 'countifs',
     :'ENSURE_IS_NUMBER' => 'ensure_is_number',
     :'EXP' => 'excel_exp',
     :'FIND2' => 'find_2',
     :'FIND3' => 'find',
+    :'FLOOR' => 'excel_floor',
     :'FORECAST' => 'forecast',
+    :'_xlfn.FORECAST.LINEAR' => 'forecast',
     :'HLOOKUP3' => 'hlookup_3',
     :'HLOOKUP4' => 'hlookup',
     :'IF2' => 'excel_if_2',
@@ -68,14 +75,19 @@ class MapFormulaeToC < MapValuesToC
     :'MIN' => 'min',
     :'MMULT' => 'mmult',
     :'MOD' => 'mod',
+    :'NA' => 'na',
+    :'NOT' => 'excel_not',
+    :'OR' => 'excel_or',
     :'NPV' => 'npv',
     :'NUMBER_OR_ZERO' => 'number_or_zero',
     :'PMT3' => 'pmt',
     :'PMT4' => 'pmt_4',
     :'PMT5' => 'pmt_5',
+    :'PRODUCT' => 'product',
     :'PV3' => 'pv_3',
     :'PV4' => 'pv_4',
     :'PV5' => 'pv_5',
+    :'RATE' => 'rate',
     :'RANK2' => 'rank_2',
     :'RANK3' => 'rank',
     :'RIGHT1' => 'right_1',
@@ -95,30 +107,39 @@ class MapFormulaeToC < MapValuesToC
     :'VLOOKUP3' => 'vlookup_3',
     :'VLOOKUP4' => 'vlookup',
     :'^' => 'power',
-    :'POWER' => 'power'
+    :'POWER' => 'power',
+    :'SQRT' => 'excel_sqrt',
+    :'curve5' => 'curve_5',
+    :'curve' => 'curve',
+    :'scurve4' => 'scurve_4',
+    :'scurve' => 'scurve',
+    :'halfscurve4' => 'halfscurve_4',
+    :'halfscurve' => 'halfscurve',
+    :'lcurve4' => 'lcurve_4',
+    :'lcurve' => 'lcurve',
   }
-  
+
   def prefix(symbol,ast)
     return map(ast) if symbol == "+"
     return "negative(#{map(ast)})"
   end
-  
+
   def brackets(*contents)
     "(#{contents.map { |a| map(a) }.join(',')})"
   end
-  
+
   def arithmetic(left,operator,right)
     "#{FUNCTIONS[operator.last]}(#{map(left)},#{map(right)})"
   end
-  
+
   def string_join(*strings)
     any_number_of_argument_function('string_join',strings)
   end
-  
+
   def comparison(left,operator,right)
     "#{FUNCTIONS[operator.last]}(#{map(left)},#{map(right)})"
   end
-  
+
   def function(function_name,*arguments)
     # Some functions are special cases
     if self.respond_to?("function_#{function_name.to_s.downcase}")
@@ -135,21 +156,39 @@ class MapFormulaeToC < MapValuesToC
     elsif FUNCTIONS.has_key?(function_name.to_sym)
       "#{FUNCTIONS[function_name.to_sym]}(#{arguments.map { |a| map(a) }.join(",")})"
 
+    # Optionally, can dump unknown functions
+  elsif self.allow_unknown_functions
+      "#{function_name.to_s.downcase}(#{arguments.map { |a| map(a) }.join(",")})"
+
+    # But default is to raise an error
     else
       raise NotSupportedException.new("Function #{function_name} with #{arguments.size} arguments not supported")
     end
   end
-  
-  FUNCTIONS_WITH_ANY_NUMBER_OF_ARGUMENTS = %w{SUM AND AVERAGE COUNT COUNTA MAX MIN SUMPRODUCT CONCATENATE}
-  
-  def function_pi() 
+
+  FUNCTIONS_WITH_ANY_NUMBER_OF_ARGUMENTS = %w{
+    SUM 
+    PRODUCT 
+    AND 
+    OR
+    AVERAGE 
+    COUNT 
+    COUNTA 
+    MAX 
+    MIN 
+    SUMPRODUCT 
+    COUNTIFS 
+    CONCATENATE
+  }
+
+  def function_pi()
     "M_PI"
   end
-  
+
   def function_choose(index,*arguments)
     "#{FUNCTIONS[:CHOOSE]}(#{map(index)}, #{map_arguments_to_array(arguments)})"
   end
-  
+
   def function_subtotal(type,*arguments)
     "#{FUNCTIONS[:SUBTOTAL]}(#{map(type)}, #{map_arguments_to_array(arguments)})"
   end
@@ -205,11 +244,11 @@ class MapFormulaeToC < MapValuesToC
 
     return result_name
   end
-  
-  def any_number_of_argument_function(function_name,arguments)    
+
+  def any_number_of_argument_function(function_name,arguments)
     "#{FUNCTIONS[function_name.to_sym]}(#{map_arguments_to_array(arguments)})"
   end
-  
+
   def map_arguments_to_array(arguments)
     # First we have to create an excel array
     array_name = "array#{@counter}"
@@ -219,7 +258,7 @@ class MapFormulaeToC < MapValuesToC
     initializers << "ExcelValue #{array_name}[] = {#{arguments}};"
     "#{arguments_size}, #{array_name}"
   end
-  
+
   def cell(reference)
     # FIXME: What a cludge.
     if reference =~ /common\d+/
@@ -228,7 +267,7 @@ class MapFormulaeToC < MapValuesToC
       reference.to_s.downcase.gsub('$','')
     end
   end
-  
+
   def sheet_reference(sheet,reference)
     "#{sheet_names[sheet]}_#{map(reference).to_s.downcase}()"
   end
@@ -252,7 +291,7 @@ class MapFormulaeToC < MapValuesToC
         i += 1
       end
     end
-    
+
     # Then we need to assign it to an excel value
     range_name = array_name+"_ev"
     initializers << "ExcelValue #{range_name} = EXCEL_RANGE(#{array_name},#{number_of_rows},#{number_of_columns});"