daikini-octave-ruby 1.0.9

data/ext/octave_api/or-array.h

@@ -0,0 +1,20 @@
+#ifndef OR_ARRAY_DEFINED_H_
+#define OR_ARRAY_DEFINED_H_
+
+#include "ruby.h"
+#include "octave-includes.h"
+
+class OR_Array
+{
+  private:
+    VALUE ruby_val;
+    
+    bool should_convert_to_cell_matrix();
+  public:
+    OR_Array(VALUE r) : ruby_val(r) { };
+    ~OR_Array();
+  
+    octave_value to_octave();
+};
+
+#endif /* OR_ARRAY_DEFINED_H_ */

data/ext/octave_api/or-boolean_matrix.cpp

@@ -0,0 +1,61 @@
+#include "or-boolean_matrix.h"
+
+OR_BooleanMatrix::~OR_BooleanMatrix() {}
+
+VALUE OR_BooleanMatrix::to_ruby()
+{
+  Matrix matrix;
+  MArray<double> values;
+  double cell;
+  int i, number_of_values;
+  VALUE argv[2];
+  
+  matrix = octave_val.matrix_value();
+  int number_of_rows = matrix.rows();
+  int number_of_columns = matrix.columns();
+  
+  if (number_of_rows == 1) {
+    values = matrix.row(0);
+  } else if (number_of_columns == 1) {
+    values = matrix.column(0);
+  } else {
+    argv[0] = INT2FIX(number_of_rows);
+    argv[1] = INT2FIX(number_of_columns);
+    ruby_val = rb_class_new_instance(2, argv, rb_path2class("Octave::Matrix"));
+    
+    int row_index, column_index = 0;
+    VALUE cells, row;
+    cells = rb_ary_new2(number_of_rows);
+    for (row_index = 0; row_index < number_of_rows; row_index++) {
+      row = rb_ary_new2(number_of_columns);
+      values = matrix.row(row_index);
+      
+      for (column_index = 0; column_index < number_of_columns; column_index++) {
+        cell = values(column_index);
+        if (xisnan(cell) || octave_is_NA(cell)) {
+          rb_ary_push(row, Qnil);
+        } else {
+          rb_ary_push(row, (int(cell) == 1 ? Qtrue : Qfalse));
+        }
+      }
+      
+      rb_ary_push(cells, row);
+    }
+    
+    rb_iv_set(ruby_val, "@cells", cells);
+    return ruby_val;
+  }
+  
+  number_of_values = values.length();
+  ruby_val = rb_ary_new2(number_of_values);
+  for (i = 0; i < number_of_values; i++) {
+    cell = values(i);
+    if (xisnan(cell) || octave_is_NA(cell)) {
+      rb_ary_push(ruby_val, Qnil);
+    } else {
+      rb_ary_push(ruby_val, (int(cell) == 1 ? Qtrue : Qfalse));
+    }
+  }
+  
+  return ruby_val;
+}

data/ext/octave_api/or-boolean_matrix.h

@@ -0,0 +1,20 @@
+#ifndef OR_BOOLEAN_MATRIX_DEFINED_H_
+#define OR_BOOLEAN_MATRIX_DEFINED_H_
+
+#include "ruby.h"
+#include "octave-includes.h"
+
+class OR_BooleanMatrix
+{
+  private:
+    VALUE ruby_val;
+    octave_value octave_val;
+
+  public:
+    OR_BooleanMatrix(octave_value o) : octave_val(o) { };
+    ~OR_BooleanMatrix();
+  
+    VALUE to_ruby();
+};
+
+#endif /* OR_BOOLEAN_MATRIX_DEFINED_H_ */

data/ext/octave_api/or-cell_matrix.cpp

@@ -0,0 +1,66 @@
+#include "or-cell_matrix.h"
+#include "or-variable.h"
+
+OR_CellMatrix::~OR_CellMatrix() {}
+
+VALUE OR_CellMatrix::to_ruby()
+{
+  int i, number_of_values;
+  int number_of_rows = octave_val.rows();
+  int number_of_columns = octave_val.columns();
+  Cell cell = octave_val.cell_value();
+  
+  if (number_of_rows == 1 && number_of_columns == 1) {
+    return OR_Variable(cell(0)).to_ruby();
+  } else if (number_of_columns == 1) {
+    number_of_values = number_of_rows;
+  } else {
+    VALUE argv[2];
+    argv[0] = INT2FIX(number_of_rows);
+    argv[1] = INT2FIX(number_of_columns);
+    ruby_val = rb_class_new_instance(2, argv, rb_path2class("Octave::CellMatrix"));
+    
+    int row_index, column_index = 0;
+    VALUE cells, row;
+    cells = rb_ary_new2(number_of_rows);
+    for (row_index = 0; row_index < number_of_rows; row_index++) {
+      row = rb_ary_new2(number_of_columns);
+
+      for (column_index = 0; column_index < number_of_columns; column_index++) {
+        rb_ary_push(row, OR_Variable(cell(row_index, column_index)).to_ruby());
+      }
+      
+      rb_ary_push(cells, row);
+    }
+    
+    rb_iv_set(ruby_val, "@cells", cells);
+    return ruby_val;
+  }
+  
+  ruby_val = rb_ary_new2(number_of_values);
+  for (i = 0; i < number_of_values; i++) {
+    rb_ary_push(ruby_val, OR_Variable(cell(i)).to_ruby());
+  }
+  return ruby_val;
+}
+
+octave_value OR_CellMatrix::to_octave()
+{
+  int i, row_index, column_index;
+  int number_of_rows = FIX2INT(rb_iv_get(ruby_val, "@m"));
+  int number_of_columns = FIX2INT(rb_iv_get(ruby_val, "@n"));
+  VALUE cells = rb_iv_get(ruby_val, "@cells");
+  VALUE row, cell;
+  Cell matrix = Cell(number_of_rows, number_of_columns);
+  
+  for (row_index = 0; row_index < number_of_rows; row_index++) {
+    row = RARRAY(cells)->ptr[row_index];
+    
+    for (column_index = 0; column_index < number_of_columns; column_index++) {
+      cell = RARRAY(row)->ptr[column_index];
+      matrix(row_index, column_index) = OR_Variable(cell).to_octave();
+    }
+  }
+  
+  return matrix;
+}

data/ext/octave_api/or-cell_matrix.h

@@ -0,0 +1,22 @@
+#ifndef OR_CELL_MATRIX_DEFINED_H_
+#define OR_CELL_MATRIX_DEFINED_H_
+
+#include "ruby.h"
+#include "octave-includes.h"
+
+class OR_CellMatrix
+{
+  private:
+    VALUE ruby_val;
+    octave_value octave_val;
+    
+  public:
+    OR_CellMatrix(VALUE r) : ruby_val(r) { };
+    OR_CellMatrix(octave_value o) : octave_val(o) { };
+    ~OR_CellMatrix();
+  
+    VALUE to_ruby();
+    octave_value to_octave();
+};
+
+#endif /* OR_CELL_MATRIX_DEFINED_H_ */

data/ext/octave_api/or-hash.cpp

@@ -0,0 +1,23 @@
+#include "or-hash.h"
+#include "or-variable.h"
+
+OR_Hash::~OR_Hash() {}
+
+octave_value OR_Hash::to_octave()
+{
+  int i;
+  VALUE names = rb_funcall(ruby_val, rb_intern("keys"), 0);
+  int number_of_keys = RARRAY(names)->len;
+
+  string_vector keys = string_vector();
+  for (i = 0; i < number_of_keys; i++) {
+    keys.append(std::string(RSTRING(RARRAY(names)->ptr[i])->ptr));
+  }
+
+  Octave_map struct_matrix = Octave_map(dim_vector(1, 1), Cell(keys));
+  for (i = 0; i < number_of_keys; i++) {
+    struct_matrix.contents(std::string(RSTRING(RARRAY(names)->ptr[i])->ptr)) = OR_Variable(rb_hash_aref(ruby_val, rb_str_new2(RSTRING(RARRAY(names)->ptr[i])->ptr))).to_octave();
+  }
+
+  return struct_matrix;
+}

data/ext/octave_api/or-hash.h

@@ -0,0 +1,19 @@
+#ifndef OR_HASH_DEFINED_H_
+#define OR_HASH_DEFINED_H_
+
+#include "ruby.h"
+#include "octave-includes.h"
+
+class OR_Hash
+{
+  private:
+    VALUE ruby_val;
+    
+  public:
+    OR_Hash(VALUE r) : ruby_val(r) { };
+    ~OR_Hash();
+  
+    octave_value to_octave();
+};
+
+#endif /* OR_HASH_DEFINED_H_ */

data/ext/octave_api/or-matrix.cpp

@@ -0,0 +1,89 @@
+#include "or-matrix.h"
+
+OR_Matrix::~OR_Matrix() {}
+
+VALUE OR_Matrix::to_ruby()
+{
+  Matrix matrix;
+  MArray<double> values;
+  double cell;
+  int i, number_of_values;
+  VALUE argv[2];
+  
+  matrix = octave_val.matrix_value();
+  int number_of_rows = matrix.rows();
+  int number_of_columns = matrix.columns();
+  
+  if ((number_of_rows == 0) && (number_of_columns == 0)) {
+    return rb_ary_new2(0);
+  } else if (number_of_columns == 1) {
+    values = matrix.column(0);
+  } else {
+    argv[0] = INT2FIX(number_of_rows);
+    argv[1] = INT2FIX(number_of_columns);
+    ruby_val = rb_class_new_instance(2, argv, rb_path2class("Octave::Matrix"));
+    
+    int row_index, column_index = 0;
+    VALUE cells, row;
+    cells = rb_ary_new2(number_of_rows);
+    for (row_index = 0; row_index < number_of_rows; row_index++) {
+      row = rb_ary_new2(number_of_columns);
+      values = matrix.row(row_index);
+      
+      for (column_index = 0; column_index < number_of_columns; column_index++) {
+        cell = values(column_index);
+        if (xisnan(cell) || octave_is_NA(cell)) {
+          rb_ary_push(row, Qnil);
+        } else {
+          rb_ary_push(row, rb_float_new(cell));
+        }
+      }
+      
+      rb_ary_push(cells, row);
+    }
+    
+    rb_iv_set(ruby_val, "@cells", cells);
+    return ruby_val;
+  }
+  
+  number_of_values = values.length();
+  ruby_val = rb_ary_new2(number_of_values);
+  for (i = 0; i < number_of_values; i++) {
+    cell = values(i);
+    if (xisnan(cell) || octave_is_NA(cell)) {
+      rb_ary_push(ruby_val, Qnil);
+    } else {
+      rb_ary_push(ruby_val, rb_float_new(cell));
+    }
+  }
+  
+  return ruby_val;
+}
+
+octave_value OR_Matrix::to_octave()
+{
+  int row_index, column_index;
+  int number_of_rows = FIX2INT(rb_iv_get(ruby_val, "@m"));
+  int number_of_columns = FIX2INT(rb_iv_get(ruby_val, "@n"));
+  VALUE cells = rb_iv_get(ruby_val, "@cells");
+  VALUE row, cell;
+  Matrix matrix = Matrix(number_of_rows, number_of_columns);
+  
+  for (row_index = 0; row_index < number_of_rows; row_index++) {
+    row = RARRAY(cells)->ptr[row_index];
+    
+    for (column_index = 0; column_index < number_of_columns; column_index++) {
+      cell = RARRAY(row)->ptr[column_index];
+      
+      if (rb_type(cell) == T_FLOAT) {
+        matrix(row_index, column_index) = RFLOAT(cell)->value;
+      } else if (rb_type(cell) == T_FIXNUM) {
+        matrix(row_index, column_index) = FIX2LONG(cell);
+      } else {
+        matrix(row_index, column_index) = octave_NaN;
+      }
+    }
+  }
+  
+  return matrix;
+}

data/ext/octave_api/or-matrix.h

@@ -0,0 +1,22 @@
+#ifndef OR_MATRIX_DEFINED_H_
+#define OR_MATRIX_DEFINED_H_
+
+#include "ruby.h"
+#include "octave-includes.h"
+
+class OR_Matrix
+{
+  private:
+    VALUE ruby_val;
+    octave_value octave_val;
+
+  public:
+    OR_Matrix(VALUE r) : ruby_val(r) { };
+    OR_Matrix(octave_value o) : octave_val(o) { };
+    ~OR_Matrix();
+  
+    VALUE to_ruby();
+    octave_value to_octave();
+};
+
+#endif /* OR_MATRIX_DEFINED_H_ */

data/ext/octave_api/or-string.cpp

@@ -0,0 +1,13 @@
+#include "or-string.h"
+
+OR_String::~OR_String() {}
+
+VALUE OR_String::to_ruby()
+{
+  return rb_str_new2(octave_val.string_value().c_str());
+}
+
+octave_value OR_String::to_octave()
+{
+  return std::string(RSTRING(ruby_val)->ptr);
+}

data/ext/octave_api/or-string.h

@@ -0,0 +1,22 @@
+#ifndef OR_STRING_DEFINED_H_
+#define OR_STRING_DEFINED_H_
+
+#include "ruby.h"
+#include "octave-includes.h"
+
+class OR_String
+{
+  private:
+    VALUE ruby_val;
+    octave_value octave_val;
+    
+  public:
+    OR_String(VALUE r) : ruby_val(r) { };
+    OR_String(octave_value o) : octave_val(o) { };
+    ~OR_String();
+  
+    VALUE to_ruby();
+    octave_value to_octave();
+};
+
+#endif /* OR_STRING_DEFINED_H_ */

data/ext/octave_api/or-struct_matrix.cpp

@@ -0,0 +1,88 @@
+#include "or-struct_matrix.h"
+#include "or-variable.h"
+
+OR_StructMatrix::~OR_StructMatrix() {}
+
+VALUE OR_StructMatrix::to_ruby()
+{
+  Octave_map struct_matrix = Octave_map(octave_val.map_value());
+  string_vector keys = struct_matrix.keys();
+  int number_of_keys = keys.length();
+  int number_of_rows = struct_matrix.rows();
+  int number_of_columns = struct_matrix.columns();
+  int i;
+  VALUE cells, row, cell;
+
+  if (number_of_rows == 0 && number_of_columns == 1) {
+    ruby_val = rb_hash_new();
+    for (i = 0; i < number_of_keys; i++) {
+      rb_hash_aset(ruby_val, rb_str_new2(keys[i].c_str()), OR_Variable(struct_matrix.contents(keys[i])).to_ruby());
+    }
+  } else if (number_of_rows == 1 && number_of_columns == 1) {
+    ruby_val = rb_hash_new();
+    for (i = 0; i < number_of_keys; i++) {
+      rb_hash_aset(ruby_val, rb_str_new2(keys[i].c_str()), OR_Variable(struct_matrix.contents(keys[i])(0)).to_ruby());
+    }
+  } else {
+    int number_of_arguments_to_struct_matrix = number_of_keys + 2;
+    VALUE argv[number_of_arguments_to_struct_matrix];
+    argv[0] = INT2FIX(number_of_rows);
+    argv[1] = INT2FIX(number_of_columns);
+  
+    for (i = 0; i < number_of_keys; i++) {
+      argv[2 + i] = rb_str_new2(keys[i].c_str());
+    }
+    ruby_val = rb_class_new_instance(number_of_arguments_to_struct_matrix, argv, rb_path2class("Octave::StructMatrix"));
+    cells = rb_ary_new2(number_of_rows);
+  
+    int row_index, column_index;
+    for (row_index = 0; row_index < number_of_rows; row_index++) {
+      row = rb_ary_new2(number_of_columns);
+    
+      for (column_index = 0; column_index < number_of_columns; column_index++) {
+        cell = rb_hash_new();
+        for (i = 0; i < number_of_keys; i++) {
+          rb_hash_aset(cell, rb_str_new2(keys[i].c_str()), OR_Variable(struct_matrix.contents(keys[i])(row_index, column_index)).to_ruby());
+        }
+        rb_ary_push(row, cell);
+      }
+    
+      rb_ary_push(cells, row);
+    }
+  
+    rb_iv_set(ruby_val, "@cells", cells);
+  }
+  
+  return ruby_val;
+}
+
+octave_value OR_StructMatrix::to_octave()
+{
+  int i, row_index, column_index;
+  VALUE row, cell;
+  VALUE cells = rb_iv_get(ruby_val, "@cells");
+  VALUE names = rb_iv_get(ruby_val, "@names");
+  int number_of_keys = RARRAY(names)->len;
+  int number_of_rows = FIX2INT(rb_iv_get(ruby_val, "@m"));
+  int number_of_columns = FIX2INT(rb_iv_get(ruby_val, "@n"));
+
+  string_vector keys = string_vector();
+  for (i = 0; i < number_of_keys; i++) {
+    keys.append(std::string(RSTRING(RARRAY(names)->ptr[i])->ptr));
+  }
+  
+  Octave_map struct_matrix = Octave_map(dim_vector(number_of_rows, number_of_columns), Cell(keys));
+  for (row_index = 0; row_index < number_of_rows; row_index++) {
+    row = RARRAY(cells)->ptr[row_index];
+  
+    for (column_index = 0; column_index < number_of_columns; column_index++) {
+      cell = RARRAY(row)->ptr[column_index];
+      
+      for (i = 0; i < number_of_keys; i++) {
+        struct_matrix.contents(std::string(RSTRING(RARRAY(names)->ptr[i])->ptr))(row_index, column_index) = OR_Variable(rb_hash_aref(cell, rb_str_new2(RSTRING(RARRAY(names)->ptr[i])->ptr))).to_octave();
+      }
+    }
+  }
+  
+  return struct_matrix;
+}