narray-bigmem 0.0.0

data/ext/narray/narray.def

@@ -0,0 +1,29 @@
+EXPORTS
+Init_narray
+na_sizeof
+na_make_object
+na_make_scalar
+na_make_empty
+na_get_typecode
+na_clear_data
+na_clone
+na_fill
+na_copy_nary
+na_to_array
+na_ary_to_nary
+na_object_type
+na_cast_object
+na_cast_unless_narray
+na_cast_unless_array
+na_upcast_object
+na_dup_w_type
+na_change_type
+na_upcast_type
+na_to_narray
+na_aset
+na_aref
+na_slice
+na_count_true
+na_count_false
+na_aref_mask
+na_aset_mask

data/ext/narray/narray.h

@@ -0,0 +1,231 @@
+/*
+  narray.h
+  NArray with big memory support
+    (C) Copyright 1999-2011 by Masahiro TANAKA
+    (C) Copyright 2013-2015 by Seiya NISHIZAWA
+
+  This program is free software.
+  You can distribute/modify this program
+  under the same terms as Ruby itself.
+  NO WARRANTY.
+*/
+#ifndef NARRAY_H
+#define NARRAY_H
+
+#include <math.h>
+
+#include "narray_config.h"
+
+#ifdef HAVE_STDINT_H
+# include <stdint.h>
+#endif
+
+#ifdef HAVE_SYS_TYPES_H
+# include <sys/types.h>
+#endif
+
+#define NARRAY_VERSION "0.6.0.8"
+#define NARRAY_VERSION_CODE 608
+
+#define NARRAYBIGMEM_VERSION "0.0.0"
+#define NARRAYBIGMEM_VERSION_CODE 000
+
+/* big memory support */
+#define NARRAY_BIGMEM 1
+
+/*
+  Data types used in NArray :
+  Please modify these types if your system has any different type.
+*/
+
+
+/* NA_BYTE : unsigned 8-bit integer */
+#ifndef HAVE_U_INT8_T
+# ifdef HAVE_UINT8_T
+typedef uint8_t			u_int8_t;
+# else
+typedef unsigned char		u_int8_t;
+# endif
+#endif
+
+#ifndef HAVE_INT16_T
+# if SIZEOF_SHORT == 2
+typedef short                  int16_t;  /* NA_SINT */
+# else
+---->> Please define int16_t manually because sizeof(short) != 2. <<----
+# endif
+#endif /* HAVE_INT16_T */
+
+#ifndef HAVE_INT32_T
+# if SIZEOF_LONG == 4
+typedef long                   int32_t;  /* NA_LINT */
+# else
+#  if SIZEOF_INT == 4
+typedef int                    int32_t;  /* NA_LINT */
+#  else
+---->> Please define int32_t manually because sizeof(long) != 4. <<----
+#  endif
+# endif
+#endif /* HAVE_INT32_T */
+
+#ifndef HAVE_INT64_T
+# if SIZEOF_LONG_LONG == 8
+typedef long long                   int64_t;  /* NA_LLINT */
+# else
+---->> Please define int64_t manually because sizeof(long long) != 8. <<----
+# endif
+#endif /* HAVE_INT64_T */
+
+/* unsigned 64-bit integer */
+#ifndef HAVE_U_INT64_T
+# ifdef HAVE_UINT64_T
+typedef uint64_t			u_int64_t;
+# else
+#  if SIZEOF_LONG_LONG == 8
+typedef unsigned long long              u_int64_t;
+#  else
+---->> Please define u_int64_t manually because sizeof(long long) != 8. <<----
+#  endif
+# endif
+#endif /* HAVE_U_INT64_T */
+
+/* shape type */
+#if SIZEOF_VOIDP == 4
+typedef int32_t na_shape_t;
+#elif SIZEOF_VOIDP == 8
+typedef int64_t na_shape_t;
+#else
+  ---->> Please define na_shape_t manually because sizeof(*void) != 4, 8. <<----
+#endif
+#if SIZEOF_INT == SIZEOF_VOIDP
+#define NUM2SHAPE(v) NUM2INT(v)
+#define SHAPE2NUM(v) INT2NUM(v)
+#elif SIZEOF_LONG == SIZEOF_VOIDP
+#define NUM2SHAPE(v) NUM2LONG(v)
+#define SHAPE2NUM(v) LONG2NUM(v)
+#elif SIZEOF_LONG_LONG == SIZEOF_VOIDP
+#define NUM2SHAPE(v) NUM2LL(v)
+#define SHAPE2NUM(v) LL2NUM(v)
+#else
+  ---->> Please define NUM2SHAPE and SHAPE2NUM manually because sizeof(int,long,long long) != sizeof(*void). <<----
+#endif
+
+
+typedef struct { float r,i; }  scomplex;
+typedef struct { double r,i; } dcomplex;
+
+enum NArray_Types {
+  NA_NONE,
+  NA_BYTE,	/* 1 */
+  NA_SINT,	/* 2 */
+  NA_LINT,	/* 3 */
+  NA_LLINT,	/* 4 */
+  NA_SFLOAT,	/* 5 */
+  NA_DFLOAT,	/* 6 */
+  NA_SCOMPLEX,	/* 7 */
+  NA_DCOMPLEX,	/* 8 */
+  NA_ROBJ,	/* 9 */
+  NA_NTYPES	/* 10 */
+};
+
+#if SIZEOF_VOIDP == 4
+#define NA_SIZE NA_LINT
+#elif SIZEOF_VOIDP == 8
+#define NA_SIZE NA_LLINT
+#else
+---->> Please define NA_SIZE manually because sizeof(*void) != 4 or 8. <<----
+#endif
+
+/* struct for Numerical Array */
+struct NARRAY {
+  int    rank;	  /* # of dimension */
+  na_shape_t total;  /* # of total element */
+  int    type;	  /* data type */
+  na_shape_t *shape;
+  char  *ptr;	  /* pointer to data */
+  VALUE  ref;	  /* NArray object wrapping this structure */
+};
+
+#ifndef NARRAY_C
+extern VALUE cNArray;
+
+extern const int na_sizeof[NA_NTYPES+1];
+#endif
+
+#define NA_MAX_RANK 15
+
+#define GetNArray(obj,var)  Data_Get_Struct(obj, struct NARRAY, var)
+#define IsNArray(obj) (rb_obj_is_kind_of(obj,cNArray)==Qtrue)
+
+#define NA_PTR(a,p)    ((a)->ptr+(p)*na_sizeof[(a)->type])
+#define NA_STRUCT(val) ((struct NARRAY*)DATA_PTR(val))
+#define NA_PTR_TYPE(val,type) (type)(((struct NARRAY*)DATA_PTR(val))->ptr)
+#define NA_RANK(val)   (((struct NARRAY*)DATA_PTR(val))->rank)
+#define NA_TYPE(val)   (((struct NARRAY*)DATA_PTR(val))->type)
+#define NA_TOTAL(val)  (((struct NARRAY*)DATA_PTR(val))->total)
+#define NA_SHAPE0(val) (((struct NARRAY*)DATA_PTR(val))->shape[0])
+#define NA_SHAPE1(val) (((struct NARRAY*)DATA_PTR(val))->shape[1])
+
+#define NA_IsNArray(obj) \
+  (rb_obj_is_kind_of(obj,cNArray)==Qtrue)
+#define NA_IsArray(obj) \
+  (TYPE(obj)==T_ARRAY || rb_obj_is_kind_of(obj,cNArray)==Qtrue)
+#define NA_IsROBJ(d) ((d)->type==NA_ROBJ)
+#define NA_IsINTEGER(a) \
+  ((a)->type==NA_BYTE || (a)->type==NA_SINT || (a)->type==NA_LINT )
+#define NA_IsCOMPLEX(a) \
+  ((a)->type==NA_SCOMPLEX || (a)->type==NA_DCOMPLEX)
+#define NA_MAX(a,b) (((a)>(b))?(a):(b))
+#define NA_MAX3(a,b,c) NA_MAX( (NA_MAX((a),(b))), (c) )
+
+
+#define NA_SWAP(a,b,tmp) {(tmp)=(a);(a)=(b);(b)=(tmp);}
+
+#define na_class_dim(klass) NUM2INT(rb_const_get(klass, na_id_class_dim))
+
+#define NUM2REAL(v)  NUM2DBL( rb_funcall((v),na_id_real,0) )
+#define NUM2IMAG(v)  NUM2DBL( rb_funcall((v),na_id_imag,0) )
+
+#define NA_ALLOC_SLICE(slc,nc,shp,np) \
+{ slc = (struct slice*)xmalloc( sizeof(struct slice)*(nc) + \
+				sizeof(na_shape_t)*(np) );	    \
+  shp = (na_shape_t*)&( (slc)[nc] ); }
+
+
+/* Function Prototypes */
+
+/* narray.c */
+VALUE na_make_object(int type, int rank, na_shape_t *shape, VALUE klass);
+VALUE na_make_scalar(VALUE obj, int type);
+VALUE na_make_empty(int type, VALUE klass);
+int   na_get_typecode(VALUE v);
+void  na_clear_data(struct NARRAY *ary);
+VALUE na_clone(VALUE self);
+VALUE na_fill(VALUE self, volatile VALUE obj);
+void  na_copy_nary(struct NARRAY *dst, struct NARRAY *src);
+
+/* na_array.c */
+VALUE na_to_array(VALUE obj);
+VALUE na_make_inspect(VALUE self);
+VALUE na_ary_to_nary(VALUE ary, VALUE klass);
+int   na_object_type(VALUE v);
+
+VALUE na_cast_object(VALUE obj, int type);
+VALUE na_cast_unless_narray(VALUE obj, int type);
+VALUE na_cast_unless_array(VALUE obj, int type);
+VALUE na_upcast_object(VALUE obj, int type);
+VALUE na_dup_w_type(VALUE obj, int type);
+VALUE na_change_type(VALUE obj, int type);
+VALUE na_upcast_type(VALUE obj, int type);
+VALUE na_to_narray(VALUE obj);
+
+/* na_index.c */
+VALUE na_aset(int argc, VALUE *argv, VALUE self);
+VALUE na_aref(int argc, VALUE *argv, VALUE self);
+VALUE na_slice(int argc, VALUE *argv, VALUE self);
+VALUE na_count_true(VALUE self);
+VALUE na_count_false(VALUE self);
+VALUE na_aref_mask(VALUE self, VALUE mask);
+void  na_aset_mask(VALUE self, VALUE mask, VALUE v);
+
+#endif /* ifndef NARRAY_H */

data/ext/narray/narray_local.h

@@ -0,0 +1,218 @@
+/*
+  narray_local.h
+  Numerical Array Extention for Ruby
+    (C) Copyright 1999-2008 by Masahiro TANAKA
+
+  This program is free software.
+  You can distribute/modify this program
+  under the same terms as Ruby itself.
+  NO WARRANTY.
+*/
+
+typedef int32_t na_index_t;
+
+struct slice {
+  char *p;   	/* pointer to data		--- used in loop */
+  na_shape_t n;    	/* n of indices of this rank */
+  na_shape_t pstep; /* = step * stride * elmsz	--- set in na_init_slice */ 
+  na_shape_t pbeg;  /* = beg * stride * elmsz	--- set in na_init_slice */
+  na_shape_t stride; /* = shape[0]*shape[1]*...*shape[r-1]
+						--- set in na_init_slice */
+  na_shape_t step;
+  na_shape_t beg;
+  na_shape_t *idx;  /* NULL if normal step */
+};
+
+typedef void (*na_setfunc_t[NA_NTYPES][NA_NTYPES]) ();
+typedef void (*na_func_t[NA_NTYPES]) ();
+typedef void (*na_ufunc_t[NA_NTYPES]) ();
+typedef void (*na_bifunc_t[NA_NTYPES]) ();
+typedef void (*na_mathfunc_t[NA_NTYPES]) ();
+typedef int  (*na_sortfunc_t[NA_NTYPES]) (const void *, const void *);
+
+/* function arrays */
+extern na_setfunc_t SetFuncs;
+extern na_ufunc_t  SwpFuncs;
+extern na_ufunc_t  H2NFuncs;
+extern na_ufunc_t  H2VFuncs;
+extern na_ufunc_t  NegFuncs;
+extern na_ufunc_t  RcpFuncs;
+extern na_ufunc_t  AbsFuncs;
+extern na_ufunc_t  RealFuncs;
+extern na_ufunc_t  ImagFuncs;
+extern na_ufunc_t  AnglFuncs;
+extern na_ufunc_t  ImagMulFuncs;
+extern na_ufunc_t  ConjFuncs;
+extern na_ufunc_t  FloorFuncs;
+extern na_ufunc_t  CeilFuncs;
+extern na_ufunc_t  RoundFuncs;
+extern na_ufunc_t  ToStrFuncs;
+extern na_ufunc_t  InspFuncs;
+extern na_ufunc_t  IndGenFuncs;
+extern na_ufunc_t  AddUFuncs;
+extern na_ufunc_t  SbtUFuncs;
+extern na_ufunc_t  MulUFuncs;
+extern na_ufunc_t  DivUFuncs;
+extern na_ufunc_t  ModUFuncs;
+extern na_bifunc_t AddBFuncs;
+extern na_bifunc_t SbtBFuncs;
+extern na_bifunc_t MulBFuncs;
+extern na_bifunc_t DivBFuncs;
+extern na_bifunc_t MulAddFuncs;
+extern na_bifunc_t MulSbtFuncs;
+extern na_bifunc_t ModBFuncs;
+extern na_bifunc_t BAnFuncs;
+extern na_bifunc_t BOrFuncs;
+extern na_bifunc_t BXoFuncs;
+extern na_ufunc_t  BRvFuncs;
+extern na_bifunc_t ImgSetFuncs;
+extern na_setfunc_t PowFuncs;
+extern na_bifunc_t atan2Funcs;
+extern na_bifunc_t CmpFuncs;
+extern na_bifunc_t EqlFuncs;
+extern na_ufunc_t  AndFuncs;
+extern na_ufunc_t  Or_Funcs;
+extern na_ufunc_t  XorFuncs;
+extern na_ufunc_t  NotFuncs;
+extern na_ufunc_t  MinFuncs;
+extern na_ufunc_t  MaxFuncs;
+extern na_sortfunc_t SortFuncs;
+extern na_sortfunc_t SortIdxFuncs;
+extern na_bifunc_t RefMaskFuncs;
+extern na_bifunc_t SetMaskFuncs;
+
+/* variables */
+
+extern VALUE rb_mNMath;
+extern ID na_id_beg, na_id_end, na_id_exclude_end;
+extern ID na_id_minus, na_id_abs, na_id_power;
+extern ID na_id_compare, na_id_and, na_id_or;
+extern ID na_id_equal;
+extern ID na_id_class_dim;
+extern ID na_id_add, na_id_sbt, na_id_mul, na_id_div, na_id_mod;
+extern ID na_id_real, na_id_imag;
+extern ID na_id_coerce_rev;
+extern ID na_id_new;
+extern ID na_id_Complex;
+
+extern const int na_upcast[NA_NTYPES][NA_NTYPES];
+extern const int na_no_cast[NA_NTYPES];
+extern const int na_cast_real[NA_NTYPES];
+extern const int na_cast_comp[NA_NTYPES];
+extern const int na_cast_round[NA_NTYPES];
+extern const int na_cast_byte[NA_NTYPES];
+
+extern const char *na_typestring[];
+
+extern VALUE cNArrayScalar, cComplex;
+
+/* narray.c */
+VALUE na_newdim_ref(int argc, VALUE *argv, VALUE self);
+
+/* na_func.c */
+void na_shape_max3(int ndim, na_shape_t *max_shp, na_shape_t *shp1, na_shape_t *shp2, na_shape_t *shp3);
+void na_shape_copy( int ndim, na_shape_t *shape, struct NARRAY *a );
+
+void na_init_slice(struct slice *s, int rank, na_shape_t *shape, int elmsz);
+void na_set_slice_1obj(int ndim, struct slice *slc, na_shape_t *shape);
+int  na_set_slice_3obj( int ndim,
+			struct slice *s1, struct slice *s2, struct slice *s3,
+			na_shape_t *shp1, na_shape_t *shp2, na_shape_t *shp3, na_shape_t *shape );
+void na_loop_general(struct NARRAY *a1, struct NARRAY *a2,
+		     struct slice *s1, struct slice *s2, void (*func)());
+void na_loop_index_ref(struct NARRAY *a1, struct NARRAY *a2,
+		       struct slice *s1, struct slice *s2, void (*func)());
+
+/* na_index.c */
+void  na_aset_slice(struct NARRAY *dst, struct NARRAY *src, struct slice *s1);
+int   na_shrink_class(int class_dim, int *shrink);
+VALUE na_shrink_rank(VALUE obj, int class_dim, int *shrink);
+
+#define rb_complex_new(r,i) \
+  rb_funcall(rb_mKernel, na_id_Complex, 2, rb_float_new(r), rb_float_new(i))
+
+
+typedef union {
+  u_int8_t b[2];
+  int16_t s;
+} na_size16_t;
+
+typedef union {
+  u_int8_t b[4];
+  int32_t  i;
+  float    f;
+} na_size32_t;
+
+typedef union {
+  u_int8_t  b[8];
+  u_int64_t g;
+  float     f[2];
+  double    d;
+} na_size64_t;
+
+typedef union {
+  u_int8_t b[16];
+  double   d[2];
+} na_size128_t;
+
+
+#define swap16(d,s) \
+(d).b[0]=(s).b[1];\
+(d).b[1]=(s).b[0];
+
+#define swap32(d,s) \
+(d).b[0]=(s).b[3];\
+(d).b[1]=(s).b[2];\
+(d).b[2]=(s).b[1];\
+(d).b[3]=(s).b[0];
+
+#define swap64(d,s) \
+(d).b[0]=(s).b[7];\
+(d).b[1]=(s).b[6];\
+(d).b[2]=(s).b[5];\
+(d).b[3]=(s).b[4];\
+(d).b[4]=(s).b[3];\
+(d).b[5]=(s).b[2];\
+(d).b[6]=(s).b[1];\
+(d).b[7]=(s).b[0];
+
+#define swap64c(d,s) \
+(d).b[0]=(s).b[3];\
+(d).b[1]=(s).b[2];\
+(d).b[2]=(s).b[1];\
+(d).b[3]=(s).b[0];\
+(d).b[4]=(s).b[7];\
+(d).b[5]=(s).b[6];\
+(d).b[6]=(s).b[5];\
+(d).b[7]=(s).b[4];
+
+#define swap128c(d,s) \
+(d).b[0]=(s).b[7];\
+(d).b[1]=(s).b[6];\
+(d).b[2]=(s).b[5];\
+(d).b[3]=(s).b[4];\
+(d).b[4]=(s).b[3];\
+(d).b[5]=(s).b[2];\
+(d).b[6]=(s).b[1];\
+(d).b[7]=(s).b[0];\
+(d).b[8]=(s).b[15];\
+(d).b[9]=(s).b[14];\
+(d).b[10]=(s).b[13];\
+(d).b[11]=(s).b[12];\
+(d).b[12]=(s).b[11];\
+(d).b[13]=(s).b[10];\
+(d).b[14]=(s).b[9];\
+(d).b[15]=(s).b[8];
+
+#if !defined RSTRING_LEN
+#define RSTRING_LEN(a) RSTRING(a)->len
+#endif
+#if !defined RSTRING_PTR
+#define RSTRING_PTR(a) RSTRING(a)->ptr
+#endif
+#if !defined RARRAY_LEN
+#define RARRAY_LEN(a) RARRAY(a)->len
+#endif
+#if !defined RARRAY_PTR
+#define RARRAY_PTR(a) RARRAY(a)->ptr
+#endif