excel_to_code 0.1.13 → 0.1.16

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 5a9204f1b847531abe1231be586e07efde9d6f56
-  data.tar.gz: 55e3970859d6b607b877e91c4670777c098e5d78
+  metadata.gz: 37491ae4c70dc1d7a26a9d2487bb5e993791eb4b
+  data.tar.gz: ac3feebc2f5dcff782cd919d125146ad18a0865a
 SHA512:
-  metadata.gz: 994609e98432c12a0abe413587fe7cefa9c138aedd43e174c1ff54a349bf716ed7e82e05413fab9f94b5291df2a1ff89881226c1559593a9052ff20c204ef9ef
-  data.tar.gz: 83139c0c54325b3303c64065b07d18a529a2a761de1391932388c41dc038d51c152bff100bf50c9e50066962eb5e45c136b996bcfba764f2fe025f2f0eb6a9c8
+  metadata.gz: 8d92241f090a56b107cfc75f3f066a1ede7cfec0f9b246f824702eb55749b52cd8de42b1f529b249c52a74e48b0698494f5c04623394a03a120d4feff3d74d99
+  data.tar.gz: c16f7d74c3986ddd28cf83def0453ce5efa31e983b6d548e5c789aa79782bc236fdc5b4dd48233f1894fdb2b87e0f3ed16770e56f875c8f94aca156d613c2f32

data/src/commands/excel_to_x.rb

@@ -564,6 +564,9 @@ class ExcelToX
       replace r, [name, 'Formulae'], "Workbook tables", [name, 'Formulae']
       
       replace ReplaceRangesWithArrayLiterals, [name, 'Formulae'],  [name, 'Formulae']
+      replace ReplaceArithmeticOnRanges, [name, 'Formulae'],  [name, 'Formulae']
+      replace ReplaceArraysWithSingleCells, [name, 'Formulae'],  [name, 'Formulae']
+      replace WrapFormulaeThatReturnArraysAndAReNotInArrays, [name, 'Formulae'],  [name, 'Formulae']
     end
   end
     
@@ -612,7 +615,9 @@ class ExcelToX
       
       # The result of the indirect might be a range, which we need to simplify
       replace ReplaceRangesWithArrayLiterals, [name, 'Formulae'],  [name, 'Formulae']
+      replace ReplaceArithmeticOnRanges, [name, 'Formulae'],  [name, 'Formulae']
       replace ReplaceArraysWithSingleCells, [name, 'Formulae'],  [name, 'Formulae']
+      replace WrapFormulaeThatReturnArraysAndAReNotInArrays, [name, 'Formulae'],  [name, 'Formulae']
     end
   end
   

data/src/compile/c/excel_to_c_runtime.c

@@ -67,6 +67,7 @@ static ExcelValue excel_log(ExcelValue number);
 static ExcelValue excel_log_2(ExcelValue number, ExcelValue base);
 static ExcelValue max(int number_of_arguments, ExcelValue *arguments);
 static ExcelValue min(int number_of_arguments, ExcelValue *arguments);
+static ExcelValue mmult(ExcelValue a_v, ExcelValue b_v);
 static ExcelValue mod(ExcelValue a_v, ExcelValue b_v);
 static ExcelValue negative(ExcelValue a_v);
 static ExcelValue pmt(ExcelValue rate_v, ExcelValue number_of_periods_v, ExcelValue present_value_v);
@@ -1071,6 +1072,57 @@ static ExcelValue min(int number_of_arguments, ExcelValue *arguments) {
 	return new_excel_number(smallest_number_found);	
 }
 
+static ExcelValue mmult_error(ExcelValue a_v, ExcelValue b_v) {
+  int rows = a_v.rows > b_v.rows ? a_v.rows : b_v.rows;
+  int columns = a_v.columns > b_v.columns ? a_v.columns : b_v.columns;
+  int i, j;
+
+  ExcelValue *result = (ExcelValue*) new_excel_value_array(rows*columns);
+
+  for(i=0; i<rows; i++) {
+    for(j=0; j<columns; j++) {
+      result[(i*columns) + j] = VALUE;
+    }
+  }
+  return new_excel_range(result, rows, columns);
+}
+
+static ExcelValue mmult(ExcelValue a_v, ExcelValue b_v) {
+	CHECK_FOR_PASSED_ERROR(a_v)
+	CHECK_FOR_PASSED_ERROR(b_v)
+  if(a_v.type != ExcelRange) { return VALUE;}
+  if(b_v.type != ExcelRange) { return VALUE;}
+  if(a_v.columns != b_v.rows) { return mmult_error(a_v, b_v); }
+  int n = a_v.columns;
+  int a_rows = a_v.rows;
+  int a_columns = a_v.columns;
+  int b_rows = b_v.rows;
+  int b_columns = b_v.columns;
+  ExcelValue *result = (ExcelValue*) new_excel_value_array(a_rows*b_columns);
+  int i, j, k;
+  double sum; 
+  ExcelValue *array_a = a_v.array;
+  ExcelValue *array_b = b_v.array;
+
+  ExcelValue a;
+  ExcelValue b;
+  
+  for(i=0; i<a_rows; i++) {
+    for(j=0; j<b_columns; j++) {
+      sum = 0;
+      for(k=0; k<n; k++) {
+        a = array_a[(i*a_columns)+k];
+        b = array_b[(k*b_columns)+j];
+        if(a.type != ExcelNumber) { return mmult_error(a_v, b_v); }
+        if(b.type != ExcelNumber) { return mmult_error(a_v, b_v); }
+        sum = sum + (a.number * b.number);
+      }
+      result[(i*b_columns)+j] = new_excel_number(sum);
+    }
+  }
+  return new_excel_range(result, a_rows, b_columns);
+}
+
 static ExcelValue mod(ExcelValue a_v, ExcelValue b_v) {
 	CHECK_FOR_PASSED_ERROR(a_v)
 	CHECK_FOR_PASSED_ERROR(b_v)
@@ -2414,6 +2466,64 @@ int test_functions() {
   // 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);
+  
+  // Test MMULT (Matrix multiplication)
+  ExcelValue mmult_1[] = { ONE, TWO, THREE, FOUR};
+  ExcelValue mmult_2[] = { FOUR, THREE, TWO, ONE};
+  ExcelValue mmult_3[] = { ONE, TWO};
+  ExcelValue mmult_4[] = { THREE, FOUR};
+  ExcelValue mmult_5[] = { ONE, BLANK, THREE, FOUR};
+
+  ExcelValue mmult_1_v = new_excel_range( mmult_1, 2, 2);
+  ExcelValue mmult_2_v = new_excel_range( mmult_2, 2, 2);
+  ExcelValue mmult_3_v = new_excel_range( mmult_3, 1, 2);
+  ExcelValue mmult_4_v = new_excel_range( mmult_4, 2, 1);
+  ExcelValue mmult_5_v = new_excel_range( mmult_5, 2, 2);
+
+  // Treat the ranges as matrices and multiply them
+  ExcelValue mmult_result_1_v = mmult(mmult_1_v, mmult_2_v);
+  assert(mmult_result_1_v.type == ExcelRange);
+  assert(mmult_result_1_v.rows == 2);
+  assert(mmult_result_1_v.columns == 2);
+  ExcelValue *mmult_result_1_a = mmult_result_1_v.array;
+  assert(mmult_result_1_a[0].number == 8);
+  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);
+  assert(mmult_result_2_v.columns == 1);
+  ExcelValue *mmult_result_2_a = mmult_result_2_v.array;
+  assert(mmult_result_2_a[0].number == 11);
+
+  // Return an error if any cells are not numbers
+  ExcelValue mmult_result_3_v = mmult(mmult_5_v, mmult_2_v);
+  assert(mmult_result_3_v.type == ExcelRange);
+  assert(mmult_result_3_v.rows == 2);
+  assert(mmult_result_3_v.columns == 2);
+  ExcelValue *mmult_result_3_a = mmult_result_3_v.array;
+  assert(mmult_result_3_a[0].type == ExcelError);
+  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);
+  assert(mmult_result_5_v.rows == 2);
+  assert(mmult_result_5_v.columns == 2);
+  ExcelValue *mmult_result_5_a = mmult_result_5_v.array;
+  assert(mmult_result_5_a[0].type == ExcelError);
+  assert(mmult_result_5_a[1].type == ExcelError);
+  assert(mmult_result_5_a[2].type == ExcelError);
+  assert(mmult_result_5_a[3].type == ExcelError);
 
   // Release memory
   free_all_allocated_memory();

data/src/compile/c/map_formulae_to_c.rb

@@ -53,6 +53,7 @@ class MapFormulaeToC < MapValuesToC
     'MATCH3' => 'excel_match',
     'MAX' => 'max',
     'MIN' => 'min',
+    'MMULT' => 'mmult',
     'MOD' => 'mod',
     'PMT' => 'pmt',
     'PV3' => 'pv_3',

data/src/compile/ruby/map_formulae_to_ruby.rb

@@ -37,6 +37,7 @@ class MapFormulaeToRuby < MapValuesToRuby
     'MAX' => 'max',
     'MID' => 'mid',
     'MIN' => 'min',
+    'MMULT' => 'mmult',
     'MOD' => 'mod',
     'PI' => 'pi',
     'PMT' => 'pmt',

data/src/excel/excel_functions.rb

@@ -83,3 +83,5 @@ require_relative 'excel_functions/text'
 require_relative 'excel_functions/hlookup'
 
 require_relative 'excel_functions/log'
+
+require_relative 'excel_functions/mmult'

data/src/excel/excel_functions/mmult.rb

@@ -0,0 +1,26 @@
+module ExcelFunctions
+  
+  def mmult(array_a, array_b)
+    return array_a if array_a.is_a?(Symbol)
+    return array_b if array_b.is_a?(Symbol)
+    return :value unless array_a.is_a?(Array)
+    return :value unless array_b.is_a?(Array)
+
+    columns = array_a.first.length
+    rows = array_b.length
+    error = Array.new([rows, columns].max) { Array.new([rows, columns].max, :value) }
+    return error unless columns == rows
+    return error unless array_a.all? { |a| a.all? { |b| b.is_a?(Numeric) }} 
+    return error unless array_b.all? { |a| a.all? { |b| b.is_a?(Numeric) }}
+    result = Array.new(array_a.length) { Array.new(array_b.first.length) }
+    indices = (0...rows).to_a
+    result.map.with_index do |row, i|
+      row.map.with_index do |cell, j|
+        indices.inject(0) do |sum, n|
+          sum = sum + (array_a[i][n] * array_b[n][j])
+        end
+      end
+    end
+  end
+  
+end

data/src/rewrite/ast_expand_array_formulae.rb

@@ -64,7 +64,7 @@ class AstExpandArrayFormulae
     end]
   end
   
-  FUNCTIONS_THAT_ACCEPT_RANGES_FOR_ALL_ARGUMENTS = %w{AVERAGE COUNT COUNTA MAX MIN SUM SUMPRODUCT}
+  FUNCTIONS_THAT_ACCEPT_RANGES_FOR_ALL_ARGUMENTS = %w{AVERAGE COUNT COUNTA MAX MIN SUM SUMPRODUCT MMULT}
   
   def function(name,*arguments)
     if FUNCTIONS_THAT_ACCEPT_RANGES_FOR_ALL_ARGUMENTS.include?(name)
@@ -82,9 +82,7 @@ class AstExpandArrayFormulae
   end
   
   def map_match(*args)
-    $DEBUGN = true
     a = array_map args, 'MATCH', false, true, false
-    $DEBUGN = false
     a
   end
   

data/src/rewrite/rewrite_array_formulae.rb

@@ -30,7 +30,7 @@ class ExtractArrayFormulaForCell
     ast[@row_offset+1][@column_offset+1] # plus ones to skip tthe [:array,[:row,"cell"]] symbols
   end
   
-  FUNCTIONS_THAT_CAN_RETURN_ARRAYS = %w{INDEX}
+  FUNCTIONS_THAT_CAN_RETURN_ARRAYS = %w{INDEX MMULT}
   
   def map_function(ast)
     return ast unless FUNCTIONS_THAT_CAN_RETURN_ARRAYS.include?(ast[1])

data/src/simplify.rb

@@ -16,3 +16,5 @@ require_relative "simplify/replace_common_elements_in_formulae"
 require_relative "simplify/replace_arrays_with_single_cells"
 require_relative "simplify/replace_values_with_constants"
 require_relative "simplify/sort_into_calculation_order"
+require_relative "simplify/replace_arithmetic_on_ranges"
+require_relative "simplify/wrap_formulae_that_return_arrays_and_are_not_in_arrays"

data/src/simplify/replace_arithmetic_on_ranges.rb

@@ -0,0 +1,83 @@
+class ReplaceArithmeticOnRangesAst
+    
+  def map(ast)
+    return ast unless ast.is_a?(Array)
+    operator = ast[0]
+    if respond_to?(operator)
+      send(operator,*ast[1..-1])
+    else
+      [operator,*ast[1..-1].map {|a| map(a) }]
+    end
+  end
+  
+  def arithmetic(left, operator, right)
+    if left.first == :array && right.first != :array
+      mapped_right = map(right)
+      array_map(left) do |cell|
+        [:arithmetic, map(cell), operator, mapped_right]
+      end
+    elsif left.first != :array && right.first == :array
+      mapped_left = map(left)
+      array_map(right) do |cell|
+        [:arithmetic, mapped_left, operator, map(cell)]
+      end
+    elsif left.first == :array && right.first == :array 
+      left.map.with_index do |row, i|
+        if row == :array
+          row
+        else
+          row.map.with_index do |cell, j|
+            if cell == :row
+              cell
+            elsif i >= left.length || i >= right.length || j >= left.first.length || j >= right.first.length
+              [:error, "#VALUE!"]
+            else
+              [:arithmetic, map(left[i][j]), operator, map(right[i][j])]
+            end
+          end
+        end
+      end
+    else
+      [:arithmetic, map(left), operator, map(right)]
+    end
+  end
+
+  def array_map(array)
+    array.map do |row|
+      if row == :array
+        row
+      else
+        row.map do |column|
+          if column == :row
+            column
+          else
+            yield column
+          end
+        end
+      end
+    end
+  end
+    
+end
+  
+
+class ReplaceArithmeticOnRanges
+    
+  def self.replace(*args)
+    self.new.replace(*args)
+  end
+  
+  def replace(input,output)
+    rewriter = ReplaceArithmeticOnRangesAst.new
+    input.each_line do |line|
+      # Looks to match lines with references
+      if line =~ /:arithmetic/ && line =~ /:array/
+        content = line.split("\t")
+        ast = eval(content.pop)
+        output.puts "#{content.join("\t")}\t#{rewriter.map(ast).inspect}"
+      else
+        output.puts line
+      end
+    end
+  end
+end

data/src/simplify/wrap_formulae_that_return_arrays_and_are_not_in_arrays.rb

@@ -0,0 +1,28 @@
+require_relative '../excel'
+
+class WrapFormulaeThatReturnArraysAndAReNotInArrays
+  
+  def self.replace(*args)
+    self.new.replace(*args)
+  end
+  
+  def replace(input,output)
+  
+    input.each_line do |line|
+      # Looks to match lines that contain formulae that return ranges, such as MMULT
+      if line =~ /"MMULT"/
+        content = line.split("\t")
+        ast = eval(content.pop)
+        if ast[0] == :function && ast[1] == "MMULT"
+          new_ast = [:function, "INDEX", ast, [:number, "1"], [:number, "1"]] 
+          output.puts "#{content.join("\t")}\t#{new_ast.inspect}"          
+        else
+          output.puts line
+        end
+      else
+        output.puts line
+      end
+    end
+  end
+  
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: excel_to_code
 version: !ruby/object:Gem::Version
-  version: 0.1.13
+  version: 0.1.16
 platform: ruby
 authors:
 - Thomas Counsell, Green on Black Ltd
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-08-19 00:00:00.000000000 Z
+date: 2013-08-21 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rubypeg
@@ -145,6 +145,7 @@ files:
 - src/excel/excel_functions/max.rb
 - src/excel/excel_functions/mid.rb
 - src/excel/excel_functions/min.rb
+- src/excel/excel_functions/mmult.rb
 - src/excel/excel_functions/mod.rb
 - src/excel/excel_functions/more_than.rb
 - src/excel/excel_functions/more_than_or_equal.rb
@@ -212,6 +213,7 @@ files:
 - src/simplify/inline_formulae.rb
 - src/simplify/map_formulae_to_values.rb
 - src/simplify/remove_cells.rb
+- src/simplify/replace_arithmetic_on_ranges.rb
 - src/simplify/replace_arrays_with_single_cells.rb
 - src/simplify/replace_column_with_column_number.rb
 - src/simplify/replace_common_elements_in_formulae.rb
@@ -225,6 +227,7 @@ files:
 - src/simplify/replace_values_with_constants.rb
 - src/simplify/simplify_arithmetic.rb
 - src/simplify/sort_into_calculation_order.rb
+- src/simplify/wrap_formulae_that_return_arrays_and_are_not_in_arrays.rb
 - src/simplify.rb
 - src/util/not_supported_exception.rb
 - src/util/try.rb