tioga 1.4

data/split/namespace.h

@@ -0,0 +1,47 @@
+/* namespace.h: an attempt at rationalizing shared objects
+   namespace use.
+  
+   Copyright (C) 2006  Vincent Fourmond
+
+   This program is free software; you can redistribute it and/or modify
+   it under the terms of the GNU General Library Public License as published
+   by the Free Software Foundation; either version 2 of the License, or
+   (at your option) any later version.
+   
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU Library General Public License for more details.
+   
+   You should have received a copy of the GNU Library General Public License
+   along with this program; if not, write to the Free Software
+   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+*/
+
+#ifndef _NAMESPACE_H
+#define _NAMESPACE_H
+
+/* This header file provides two OS-specific macros for the definition of
+   extern symbols:
+
+   * PUBLIC, which has to be used to mark objects that will be used
+   outside the module
+
+   * PRIVATE, for symbols which are "extern" but intern to the module
+
+   Please don't add "extern" after the PRIVATE or PUBLIC declaration
+   as this would break compilation on Darwin.
+*/
+
+#ifdef __APPLE__
+# define PRIVATE __private_extern__
+# define PUBLIC 
+#elif __GNUC__ >= 4 /* we have the visibility attribute */
+# define PRIVATE __attribute__ ((visibility ("hidden"))) 
+# define PUBLIC __attribute__ ((visibility ("default"))) 
+#else /* not really good */
+# define PRIVATE 
+# define PUBLIC 
+#endif /* __APPLE__  and __GNU_C_ >= 4*/
+
+#endif

data/split/safe_double.h

@@ -0,0 +1,104 @@
+/**********************************************************************
+
+   safe_double.h: small abstraction for storing double without endianess
+   problems
+   
+   Copyright (C) 2006 Vincent Fourmond
+
+   This program is free software; you can redistribute it and/or modify
+   it under the terms of the GNU General Library Public License as published
+   by the Free Software Foundation; either version 2 of the License, or
+   (at your option) any later version.
+   
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU Library General Public License for more details.
+   
+   You should have received a copy of the GNU Library General Public License
+   along with this program; if not, write to the Free Software
+   Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301 USA
+   
+**********************************************************************/
+
+/* This file provides two functions: store_double and get_double, which
+   can be used in a 'safe' way to store doubles  and retrive them
+   in a hopefully platform-independent form. However, it just 
+   stores it without regards to that if ieee754.h isn't found...
+*/
+
+#ifndef _DOUBLE_H
+#define _DOUBLE_H
+
+#define STORE_LOWER_BYTE(a,p) do {\
+*(p++) = (a) & 0xFF; (a) >>= 8; }\
+while(0)
+#define STORE_UNSIGNED(a,p)   for(i = 0; i < 4; i++) STORE_LOWER_BYTE(a,p);
+#define GET_UNSIGNED(a,p) do { a = 0; for(i = 0; i < 4; i++) \
+(a) |= *(p++) << (i * 8); } while (0)
+
+#ifdef HAVE_IEEE754_H
+#include <ieee754.h>
+
+
+static inline void store_double(double a, unsigned char * p)
+{
+  unsigned int tmp;
+  int i;
+  union ieee754_double d;
+  d.d = a;
+  /* we store it with lower bytes firts */
+  tmp = d.ieee.mantissa1;
+  STORE_UNSIGNED(tmp, p);
+  tmp = d.ieee.negative << 31 |
+    d.ieee.exponent << 20 | 
+    d.ieee.mantissa0;
+  STORE_UNSIGNED(tmp, p);
+}
+
+
+static inline double get_double(const unsigned char * p)
+{
+  unsigned int tmp;
+  int i;
+  union ieee754_double d;
+  GET_UNSIGNED(tmp, p);
+  d.ieee.mantissa1 = tmp;
+  GET_UNSIGNED(tmp, p);
+  d.ieee.mantissa0 = tmp & 0xFFFFF;
+  d.ieee.exponent = (tmp >> 20) & 0x7FF;
+  d.ieee.negative = (tmp >> 31) & 0x1;
+  return d.d;
+}
+
+#else
+
+union basic_double{
+  double d;
+  struct {
+    unsigned int a:32;
+    unsigned int b:32;
+  } i;
+};
+
+static inline void store_double(double a, unsigned char * p)
+{
+  union basic_double d;
+  int i;
+  d.d = a;
+  STORE_UNSIGNED(d.i.a, p);
+  STORE_UNSIGNED(d.i.b, p);
+}
+
+static inline double get_double(const unsigned char * p)
+{
+  union basic_double d;
+  int i;
+  GET_UNSIGNED(d.i.a, p);
+  GET_UNSIGNED(d.i.b, p);
+  return d.d;
+}
+
+#endif /* HAVE_IEEE754_H */
+
+#endif /* _DOUBLE_H */

data/split/scripts/tioga

@@ -0,0 +1,4 @@
+#!/usr/bin/env ruby
+require 'Tioga/tioga_ui.rb'
+
+

data/split/symbols.c

@@ -0,0 +1,92 @@
+/*
+   Copyright (C) 2006 Vincent Fourmond
+
+   Symbols is free software; you can redistribute it and/or modify
+   it under the terms of the GNU General Library Public License as published
+   by the Free Software Foundation; either version 2 of the License, or
+   (at your option) any later version.
+
+   Symbols is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU Library General Public License for more details.
+
+   You should have received a copy of the GNU Library General Public License
+   along with Dvector; if not, write to the Free Software
+   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+*/
+
+
+/* Simple code for sharing C symbols across different Ruby libraries */
+
+#include <ruby.h>
+#include <intern.h>
+
+#include <namespace.h>
+
+
+/* MV stands for Module Variable */
+#define MV_SYMBOLS "@_exported_C_symbols"
+/* modified to use instance variables instead of global class variables:
+   this way, children don't overwrite the parent's export table
+*/
+
+
+/* makes sure that the hash is registered for the given
+   module and returns it */
+static VALUE get_symbol_hash(VALUE module)
+{
+  VALUE hash;
+  ID mv_id = rb_intern(MV_SYMBOLS);
+  if(RTEST(rb_ivar_defined(module, mv_id)))
+    {
+      hash = rb_ivar_get(module, mv_id);
+      Check_Type(hash, T_HASH);
+      return hash;
+    }
+  else
+    {
+      /* module variable uninitialized, we need to make sure it's here */
+      hash = rb_hash_new();
+      rb_ivar_set(module, mv_id, hash);
+      return hash;
+    }
+}
+
+/* registers a symbol in the given module. This one is the internal
+   function */
+PRIVATE void rb_export_symbol(VALUE module, const char * symbol_name,
+			    void * symbol)
+{
+  VALUE hash = get_symbol_hash(module);
+  rb_hash_aset(hash, rb_str_new2(symbol_name),LONG2NUM((long) symbol));
+}
+
+PRIVATE void * rb_import_symbol_no_raise(VALUE module, 
+					 const char * symbol_name)
+{
+  VALUE hash = rb_iv_get(module, MV_SYMBOLS);
+  if(TYPE(hash) != T_HASH) 
+    return NULL; /* doesn't fail, but the importing module
+		    should definitely check the return value. Beware
+		    of segfaults ! */
+  VALUE symbol = rb_hash_aref(hash, rb_str_new2(symbol_name));
+  
+  if(TYPE(symbol) == T_FIXNUM || TYPE(symbol) == T_BIGNUM)
+    return (void *) NUM2LONG(symbol);
+  return NULL;
+}
+
+/* same as before, but raises something is the return value is NULL,
+   which is probably best as a default behavior*/
+PRIVATE void * rb_import_symbol(VALUE module, const char * symbol_name)
+{
+  void * symbol = rb_import_symbol_no_raise(module, symbol_name);
+  if(symbol)
+    return symbol;
+  /* we get the name of the module: */
+  VALUE module_name = rb_funcall(module, rb_intern("to_s"), 0);
+  rb_raise(rb_eRuntimeError, "The symbol %s was not found in "
+	   "module %s", symbol_name, 
+	   rb_string_value_cstr(&module_name));
+}

data/split/symbols.h

@@ -0,0 +1,52 @@
+#ifndef _SYMBOLS_H
+#define _SYMBOLS_H
+
+#include <ruby.h>
+/* A small layer for exporting and importing symbols from
+   a compiled module */
+
+#include <namespace.h>
+
+
+PRIVATE void rb_export_symbol(VALUE module, const char * symbol_name,
+		      void * symbol);
+PRIVATE void * rb_import_symbol(VALUE module, const char * symbol_name);
+PRIVATE void * rb_import_symbol_no_raise(VALUE module, 
+						const char * symbol_name);
+
+/* a shortcut for exporting something with the same name */
+#define RB_EXPORT_SYMBOL(module, name) \
+  rb_export_symbol(module, #name, name)
+
+/* A shortcut for getting a symbol */
+		   
+#define DECLARE_SYMBOL(ret_type,name,args) \
+  typedef ret_type (*rb_export_##name##_type) args;\
+  PRIVATE rb_export_##name##_type name
+
+#define IMPLEMENT_SYMBOL(name)\
+  PRIVATE rb_export_##name##_type name = 0;
+
+#define RB_IMPORT_SYMBOL(module, name) \
+  name = (rb_export_##name##_type) rb_import_symbol(module, #name)
+
+
+/* These three macro enable a simple use of function declaration: this way,
+   you can type in a header file that is used by the importer:
+
+   DECLARE_SYMBOL(int, biniou, (int, int));
+
+   in one file of the importer code, you write 
+
+   IMPLEMENT_SYMBOL(biniou);
+
+   and in the Init_... function, you write:
+
+   RB_IMPORT_SYMBOL(module, biniou);
+
+   and you can just use biniou as if it was a function declared as
+   usual in the header file
+*/
+#endif   
+   
+

data/tests/dtable_test.data

@@ -0,0 +1,6 @@
+test.data
+0 1 2 3
+-9 8 7 6
+0.1 -1.1 2.2 -3.3
+0.126933 0.302696 0.700303 -1.03798
+0.1904 0.322089 0.744037 -0.984045

data/tests/dvector_read_test.data

@@ -0,0 +1 @@
+  0.10000000+001 -0.63188067-104 -0.20107803+002 1E0

data/tests/dvector_test.data

@@ -0,0 +1,101 @@
+23 3
+0 0.286477 0.603729 -1.08582
+0.0634665 0.290788 0.653458 -1.07284
+0 -1.1 2.2 -3.3
+0.126933 0.302696 0.700303 -1.03798
+0.1904 0.322089 0.744037 -0.984045
+0.253866 0.348769 0.784447 -0.914921
+0.317333 0.382438 0.821343 -0.834875
+0.380799 0.422669 0.85455 -0.747997
+0.444266 0.468879 0.883916 -0.657877
+0.507732 0.520296 0.90931 -0.567498
+0.571199 0.575921 0.930622 -0.479272
+0.634665 0.634495 0.947765 -0.395142
+0.698132 0.694464 0.960675 -0.3167
+0.761598 0.753955 0.969311 -0.245308
+0.825065 0.810764 0.973655 -0.182211
+0.888531 0.862358 0.973714 -0.128624
+0.951998 0.905904 0.969515 -0.0858351
+1.01546 0.938327 0.96111 -0.0552914
+1.07893 0.956398 0.948574 -0.0387219
+1.1424 0.956874 0.932001 -0.0382904
+1.20586 0.936664 0.91151 -0.0568315
+1.26933 0.893059 0.887236 -0.0982393
+1.3328 0.823979 0.859336 -0.168167
+1.39626 0.728269 0.827985 -0.275415
+1.45973 0.605995 0.793372 -0.435061
+1.5232 0.458732 0.755706 -0.676879
+1.58666 0.289821 0.715206 -1.07574
+1.65013 0.104532 0.672107 -1.96146
+1.7136 -0.0898792 0.626654 -2.09263
+1.77706 -0.284282 0.579102 -1.0925
+1.84053 -0.467981 0.529712 -0.659541
+1.904 -0.62926 0.478755 -0.402339
+1.96746 -0.756151 0.426504 -0.242782
+2.03093 -0.837439 0.373237 -0.154093
+2.0944 -0.863825 0.319231 -0.127147
+2.15786 -0.829179 0.264766 -0.162703
+2.22133 -0.731738 0.210116 -0.271289
+2.28479 -0.575102 0.155555 -0.480509
+2.34826 -0.368835 0.101351 -0.866332
+2.41173 -0.128489 0.0477643 -1.78224
+2.47519 0.1251 -0.00495156 -1.80546
+2.53866 0.367332 -0.0565527 -0.869878
+2.60213 0.572175 -0.106806 -0.484941
+2.66559 0.715158 -0.15549 -0.291195
+2.72906 0.77675 -0.202396 -0.219436
+2.79253 0.745684 -0.247329 -0.25489
+2.85599 0.621689 -0.29011 -0.412853
+2.91946 0.417058 -0.330574 -0.759605
+2.98293 0.156524 -0.368572 -1.61082
+3.04639 -0.124905 -0.403973 -1.80681
+3.10986 -0.386187 -0.436663 -0.826402
+3.17333 -0.586239 -0.466544 -0.46385
+3.23679 -0.690906 -0.493537 -0.321162
+3.30026 -0.679757 -0.517579 -0.335292
+3.36373 -0.551336 -0.538628 -0.517167
+3.42719 -0.325495 -0.556656 -0.974908
+3.49066 -0.0417951 -0.571653 -2.7575
+3.55413 0.246405 -0.583627 -1.21669
+3.61759 0.481614 -0.592602 -0.6346
+3.68106 0.614085 -0.598616 -0.423542
+3.74452 0.613487 -0.601726 -0.424388
+3.80799 0.47755 -0.601999 -0.64196
+3.87146 0.235052 -0.599518 -1.25766
+3.93492 -0.0584959 -0.59438 -2.46562
+3.99839 -0.332444 -0.586691 -0.956558
+4.06186 -0.517883 -0.576569 -0.571535
+4.12532 -0.565922 -0.564143 -0.494486
+4.18879 -0.462435 -0.54955 -0.669896
+4.25226 -0.234505 -0.532934 -1.25969
+4.31572 0.0544649 -0.514446 -2.52762
+4.37919 0.32097 -0.494243 -0.987067
+4.44266 0.485363 -0.472487 -0.627865
+4.50612 0.496851 -0.449341 -0.607546
+4.56959 0.351455 -0.424973 -0.908257
+4.63306 0.0960696 -0.39955 -2.03478
+4.69652 -0.184411 -0.37324 -1.46841
+4.75999 -0.394267 -0.34621 -0.808416
+4.82346 -0.460204 -0.318626 -0.674097
+4.88692 -0.359033 -0.290649 -0.889728
+4.95039 -0.128725 -0.262439 -1.78065
+5.01385 0.143147 -0.234149 -1.68841
+5.07732 0.351261 -0.205929 -0.908737
+5.14079 0.41374 -0.17792 -0.766543
+5.20425 0.306526 -0.150261 -1.02706
+5.26772 0.0757187 -0.123078 -2.24152
+5.33119 -0.179423 -0.096495 -1.49223
+5.39465 -0.347867 -0.0706236 -0.91717
+5.45812 -0.355939 -0.0455687 -0.897245
+5.52159 -0.202159 -0.0214262 -1.38861
+5.58505 0.0397937 0.00171714 -2.8001
+5.64852 0.253889 0.0237839 -1.1907
+5.71199 0.336949 0.0447058 -0.944868
+5.77545 0.250192 0.0644241 -1.20345
+5.83892 0.0405176 0.0828894 -2.78445
+5.90239 -0.18169 0.100061 -1.48132
+5.96585 -0.299364 0.115909 -1.0476
+6.02932 -0.25159 0.13041 -1.19861
+6.09279 -0.0681354 0.143551 -2.33316
+6.15625 0.145564 0.155327 -1.67387
+6.21972 0.267255 0.16574 -1.14614

data/tests/tc_Dtable.rb

@@ -0,0 +1,221 @@
+#  tc_Dtable.rb
+
+require 'Dobjects/Dtable'
+require 'test/unit'
+
+class TestDtable < Test::Unit::TestCase
+
+    include Dobjects
+
+    def read_data  # do this first to read in the test.data array
+        return if @arr != nil
+        @num_cols = 4; @num_rows = 5
+        @arr = Dtable.new(@num_cols, @num_rows)
+        dir = File.dirname(__FILE__)
+        if dir.empty?
+          file = "dtable_test.data"
+        else
+          file = "#{dir}/dtable_test.data"
+        end
+        @arr.read(file, 1) # skip the first line
+        assert_equal(@num_cols, @arr.num_cols)
+        assert_equal(@num_rows, @arr.num_rows)
+    end
+    
+    def test_at
+        read_data
+        assert_equal(7, @arr.at(1,2))
+        assert_equal(0.1, @arr.at(2,0))
+        assert_equal(-1.1, @arr.at(2,1))
+        assert_equal(2.2, @arr[2,2])
+        assert_equal(-3.3, @arr[2,3])
+        tmp = @arr[3,2]
+        @arr[3,2] = 1e3
+        assert_equal(1e3, @arr[3,2])
+        @arr[3,2] = tmp
+        assert_equal(tmp, @arr[3,2])
+    end
+    
+    def test_array_ops
+        read_data
+        @ar2 = @arr.dup
+        @num_rows.times do |i|
+            @num_cols.times do |j|
+                assert_equal(@arr[i,j], @ar2[i,j])
+            end
+        end
+        assert_equal(@num_rows, @arr.num_rows)
+        @num_rows.times do |i|
+            @num_cols.times do |j|
+                assert_equal(@arr[i,j], @ar2[i,j])
+            end
+        end
+        last_row = @num_rows - 1
+        last_col = @num_cols - 1
+        @arr[0,0] = 0
+        @arr[0,last_col] = 1
+        @arr[last_row,0] = 2
+        @arr[last_row,last_col] = 3
+        @ar2 = @arr.transpose
+        assert_equal(@num_cols, @ar2.num_rows)
+        assert_equal(@num_rows, @ar2.num_cols)
+        assert_equal(@ar2[0,0], 0)
+        assert_equal(@ar2[last_col,0], 1)
+        assert_equal(@ar2[0,last_row], 2)
+        assert_equal(@ar2[last_col,last_row], 3)
+        @num_rows.times do |i|
+            @num_cols.times do |j|
+                assert_equal(@arr[i,j], @ar2[j,i])
+            end
+        end
+        @ar2 = @arr.reverse_rows
+        assert_equal(@num_cols, @ar2.num_cols)
+        assert_equal(@num_rows, @ar2.num_rows)
+        assert_equal(@ar2[0,0], 2)
+        assert_equal(@ar2[0,last_col], 3)
+        assert_equal(@ar2[last_row,0], 0)
+        assert_equal(@ar2[last_row,last_col], 1)
+        @num_rows.times do |i|
+            @num_cols.times do |j|
+                assert_equal(@arr[i,j], @ar2[last_row-i,j])
+            end
+        end
+        @ar2 = @arr.reverse_cols
+        assert_equal(@num_cols, @ar2.num_cols)
+        assert_equal(@num_rows, @ar2.num_rows)
+        assert_equal(@ar2[0,0], 1)
+        assert_equal(@ar2[0,last_col], 0)
+        assert_equal(@ar2[last_row,0], 3)
+        assert_equal(@ar2[last_row,last_col], 2)
+        @num_rows.times do |i|
+            @num_cols.times do |j|
+                assert_equal(@arr[i,j], @ar2[i,last_col-j])
+            end
+        end
+        @ar2 = @arr.rotate_ccw90
+        assert_equal(@num_cols, @ar2.num_rows)
+        assert_equal(@num_rows, @ar2.num_cols)
+        assert_equal(@ar2[0,0], 1)
+        assert_equal(@ar2[0,last_row], 3)
+        assert_equal(@ar2[last_col,0], 0)
+        assert_equal(@ar2[last_col,last_row], 2)
+        @ar2 = @arr.rotate_cw90
+        assert_equal(@num_cols, @ar2.num_rows)
+        assert_equal(@num_rows, @ar2.num_cols)
+        assert_equal(@ar2[0,0], 2)
+        assert_equal(@ar2[0,last_row], 0)
+        assert_equal(@ar2[last_col,0], 3)
+        assert_equal(@ar2[last_col,last_row], 1)
+        @ar2.set(-1)
+        @num_rows.times do |i|
+            @num_cols.times do |j|
+                assert_equal(-1, @ar2[j,i])
+            end
+        end
+        assert_equal(-9, @arr.min)
+        assert_equal(8, @arr.max)
+        assert_equal(2, @arr.min_gt(1))
+        assert_equal(7, @arr.max_lt(8))
+    end
+
+    def test_math_ops
+        read_data
+        @ar2 = @arr + 2
+        @num_rows.times do |i|
+            @num_cols.times do |j|
+                assert_equal(@arr[i,j]+2, @ar2[i,j])
+            end
+        end
+        @ar2 = 2 * @arr
+        @num_rows.times do |i|
+            @num_cols.times do |j|
+                assert_equal(2 * @arr[i,j], @ar2[i,j])
+            end
+        end
+        @ar2 = @arr.floor
+        @num_rows.times do |i|
+            @num_cols.times do |j|
+                assert_equal(@arr[i,j].floor, @ar2[i,j])
+            end
+        end
+        @ar2 = @arr.pow(3)
+        @num_rows.times do |i|
+            @num_cols.times do |j|
+                assert_equal(@arr[i,j].pow(3), @ar2[i,j])
+            end
+        end
+        @ar2 = @arr.safe_log10
+        @num_rows.times do |i|
+            @num_cols.times do |j|
+                assert_equal(@arr[i,j].safe_log10, @ar2[i,j])
+            end
+        end
+    end
+    
+    def test_bang_ops
+        read_data
+        @ar2 = @arr.dup.abs!.safe_sqrt!
+        @num_rows.times do |i|
+            @num_cols.times do |j|
+                assert_equal(@arr[i,j].abs.safe_sqrt, @ar2[i,j])
+            end
+        end
+    end
+    
+    def test_dvec_ops
+        read_data
+        @row1 = @arr.row(1)
+        assert_equal(@num_cols, @row1.size)
+        @num_cols.times do |j|
+            assert_equal(@arr[1,j], @row1[j])
+        end
+        @col1 = @arr.column(1)
+        assert_equal(@num_rows, @col1.size)
+        @num_rows.times do |i|
+            assert_equal(@arr[i,1], @col1[i])
+        end
+        @arr.set_row(2,@row1)
+        @num_cols.times do |j|
+            assert_equal(@arr[2,j], @row1[j])
+        end
+        @arr.set_column(2,@col1)
+        @num_rows.times do |i|
+            assert_equal(@arr[i,2], @col1[i])
+        end
+    end
+
+    def test_marshal
+      t = Dtable.new(3,4)
+      t[1,1] = 1.2
+      t[3,2] = 2.5
+      
+      str = Marshal.dump(t)
+      tbis = Marshal.restore(str)
+      assert_equal(t.num_rows, tbis.num_rows)
+      i = 0
+      while i < t.num_rows
+        assert_equal(t.row(i), tbis.row(i))
+        i += 1
+      end
+    end
+
+end
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+