tioga 1.4

data/split/Dvector/lib/Numeric_extras.rb

@@ -0,0 +1,134 @@
+#  Numeric_extras.rb
+
+# add some Numeric methods
+
+class Numeric
+
+    # Math functions
+
+    def acos
+        Math.acos(self)
+    end
+    
+    def acosh
+        Math.acosh(self)
+    end
+    
+    def asin
+        Math.asin(self)
+    end
+    
+    def asinh
+        Math.asinh(self)
+    end
+    
+    def atan
+        Math.atan(self)
+    end
+    
+    def atanh
+        Math.atanh(self)
+    end
+    
+    def atan2(n)
+        Math.atan2(self,n)
+    end
+    
+    def cos
+        Math.cos(self)
+    end
+    
+    def cosh
+        Math.cosh(self)
+    end
+    
+    def exp
+        Math.exp(self)
+    end
+    
+    def log
+        Math.log(self)
+    end
+    
+    def log10
+        Math.log10(self)
+    end
+    
+    def sin
+        Math.sin(self)
+    end
+    
+    def sinh
+        Math.sinh(self)
+    end
+    
+    def sqrt
+        Math.sqrt(self)
+    end
+    
+    def tan
+        Math.tan(self)
+    end
+    
+    def tanh
+        Math.tanh(self)
+    end
+    
+    def neg
+        -self
+    end
+    
+    def exp10
+        10**self
+    end
+    
+    def inv
+        1/self
+    end
+    
+    def trim(cutoff=1e-6)
+        (self.abs < cutoff)? 0.0 : self
+    end
+    
+    def pow(y)
+        self**y
+    end
+    
+    def raised_to(y)
+        self**y
+    end
+    
+    def as_exponent_of(y)
+        y**self
+    end
+    
+    def safe_log(cutoff=1e-99)
+        ((self > cutoff)? self : cutoff).log
+    end
+    
+    def safe_log10(cutoff=1e-99)
+        ((self > cutoff)? self : cutoff).log10
+    end
+    
+    def safe_inv(cutoff=1e-99)
+        (self.abs > cutoff)? 1/self : (self > 0)? 1/cutoff : -1/cutoff
+    end
+    
+    def safe_sqrt
+        (self > 0.0)? self.sqrt : 0.0
+    end
+    
+    def safe_asin
+        ((self > 1.0)? 1.0 : (self < -1.0)? -1.0 : self).asin
+    end
+    
+    def safe_acos
+        ((self > 1.0)? 1.0 : (self < -1.0)? -1.0 : self).acos
+    end
+
+    def mod(y)
+        self.modulo(y)
+    end
+
+    
+end

data/split/Dvector/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/Dvector/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/Dvector/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/Dvector/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/split/Flate/defs.h

@@ -0,0 +1,33 @@
+/**********************************************************************
+
+   defs.h: 
+   some definitions that are used everywhere and that depend on some
+   HAVE_* macros.
+   
+   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
+   
+**********************************************************************/
+
+
+#ifdef HAVE_ISNAN
+/* we use isnan and isinf, which are much faster than the workaround */
+#define is_okay_number(x) (! isnan(x) && ! isinf(x))
+#else
+#define is_okay_number(x) ((x) - (x) == 0.0)
+#define isnan(x) ((x) != (x))
+/* yes, as funny as it may look  NaN != NaN, and that's the only one */
+#endif