[pure-lang-svn] SF.net SVN: pure-lang:[845] pure/trunk

[<ag...@us...>]

Revision: 845
          http://pure-lang.svn.sourceforge.net/pure-lang/?rev=845&view=rev
Author:   agraef
Date:     2008-09-23 23:56:53 +0000 (Tue, 23 Sep 2008)

Log Message:
-----------
Add some more matrix-pointer operations for alternative base types.

Modified Paths:
--------------
    pure/trunk/lib/matrices.pure
    pure/trunk/runtime.cc
    pure/trunk/runtime.h

Modified: pure/trunk/lib/matrices.pure
===================================================================
--- pure/trunk/lib/matrices.pure	2008-09-23 23:25:21 UTC (rev 844)
+++ pure/trunk/lib/matrices.pure	2008-09-23 23:56:53 UTC (rev 845)
@@ -421,3 +421,34 @@
 			= cmatrix_from_array_dup p (1,n);
 imatrix_from_array_dup p::pointer n::int
 			= imatrix_from_array_dup p (1,n);
+
+/* Some helper routines for dealing with alternate base types. These work like
+   the routines above, but initialize the data from float, complex float,
+   short and byte arrays, respectively. */
+
+private matrix_from_float_array_dup;
+private matrix_from_complex_float_array_dup;
+private matrix_from_short_array_dup;
+private matrix_from_byte_array_dup;
+extern expr* matrix_from_float_array_dup(void* p, int n, int m);
+extern expr* matrix_from_complex_float_array_dup(void* p, int n, int m);
+extern expr* matrix_from_short_array_dup(void* p, int n, int m);
+extern expr* matrix_from_byte_array_dup(void* p, int n, int m);
+
+fmatrix_from_array_dup p::pointer (n::int,m::int)
+			= matrix_from_float_array_dup p n m;
+cfmatrix_from_array_dup p::pointer (n::int,m::int)
+			= matrix_from_complex_float_array_dup p n m;
+smatrix_from_array_dup p::pointer (n::int,m::int)
+			= matrix_from_short_array_dup p n m;
+bmatrix_from_array_dup p::pointer (n::int,m::int)
+			= matrix_from_byte_array_dup p n m;
+
+fmatrix_from_array_dup p::pointer n::int
+			= fmatrix_from_array_dup p (1,n);
+cfmatrix_from_array_dup p::pointer n::int
+			= cfmatrix_from_array_dup p (1,n);
+smatrix_from_array_dup p::pointer n::int
+			= smatrix_from_array_dup p (1,n);
+bmatrix_from_array_dup p::pointer n::int
+			= bmatrix_from_array_dup p (1,n);

Modified: pure/trunk/runtime.cc
===================================================================
--- pure/trunk/runtime.cc	2008-09-23 23:25:21 UTC (rev 844)
+++ pure/trunk/runtime.cc	2008-09-23 23:56:53 UTC (rev 845)
@@ -5191,6 +5191,152 @@
 #endif
 }
 
+extern "C"
+pure_expr *matrix_from_float_array_dup(void *p, uint32_t n1, uint32_t n2)
+{
+#ifdef HAVE_GSL
+  if (n1 == 0 || n2 == 0) // empty matrix
+    return pure_double_matrix(create_double_matrix(n1, n2));
+  if (!p)
+    p = calloc(n1*n2, sizeof(double));
+  else {
+    void *q = malloc(n1*n2*sizeof(double));
+    float *p1 = (float*)p; double *q1 = (double*)q;
+    for (size_t i = 0; i < n1*n2; i++) q1[i] = (double)p1[i];
+    p = q;
+  }
+  if (!p) return 0;
+  gsl_matrix_view v = gsl_matrix_view_array((double*)p, n1, n2);
+  // take a copy of the view matrix
+  gsl_matrix *m = (gsl_matrix*)malloc(sizeof(gsl_matrix));
+  gsl_block *b = (gsl_block*)malloc(sizeof(gsl_block));
+  assert(m && b && v.matrix.data);
+  *m = v.matrix;
+  b->size = n1*n2;
+  b->data = m->data;
+  m->block = b;
+  pure_expr *x = new_expr();
+  x->tag = EXPR::DMATRIX;
+  x->data.mat.p = m;
+  x->data.mat.refc = new uint32_t;
+  *x->data.mat.refc = 1;
+  MEMDEBUG_NEW(x)
+  return x;
+#else
+  return 0;
+#endif
+}
+
+extern "C"
+pure_expr *matrix_from_complex_float_array_dup(void *p, uint32_t n1, uint32_t n2)
+{
+#ifdef HAVE_GSL
+  if (n1 == 0 || n2 == 0) // empty matrix
+    return pure_complex_matrix(create_complex_matrix(n1, n2));
+  if (!p)
+    p = calloc(2*n1*n2, sizeof(double));
+  else {
+    void *q = malloc(2*n1*n2*sizeof(double));
+    float *p1 = (float*)p; double *q1 = (double*)q;
+    for (size_t i = 0; i < 2*n1*n2; i++) q1[i] = (double)p1[i];
+    p = q;
+  }
+  if (!p) return 0;
+  gsl_matrix_complex_view v =
+    gsl_matrix_complex_view_array((double*)p, n1, n2);
+  // take a copy of the view matrix
+  gsl_matrix_complex *m =
+    (gsl_matrix_complex*)malloc(sizeof(gsl_matrix_complex));
+  gsl_block_complex *b = (gsl_block_complex*)malloc(sizeof(gsl_block_complex));
+  assert(m && b && v.matrix.data);
+  *m = v.matrix;
+  b->size = n1*n2;
+  b->data = m->data;
+  m->block = b;
+  pure_expr *x = new_expr();
+  x->tag = EXPR::CMATRIX;
+  x->data.mat.p = m;
+  x->data.mat.refc = new uint32_t;
+  *x->data.mat.refc = 1;
+  MEMDEBUG_NEW(x)
+  return x;
+#else
+  return 0;
+#endif
+}
+
+extern "C"
+pure_expr *matrix_from_short_array_dup(void *p, uint32_t n1, uint32_t n2)
+{
+#ifdef HAVE_GSL
+  if (n1 == 0 || n2 == 0) // empty matrix
+    return pure_int_matrix(create_int_matrix(n1, n2));
+  if (!p)
+    p = calloc(n1*n2, sizeof(int));
+  else {
+    void *q = malloc(n1*n2*sizeof(int));
+    short *p1 = (short*)p; int *q1 = (int*)q;
+    for (size_t i = 0; i < n1*n2; i++) q1[i] = (int)p1[i];
+    p = q;
+  }
+  if (!p) return 0;
+  gsl_matrix_int_view v = gsl_matrix_int_view_array((int*)p, n1, n2);
+  // take a copy of the view matrix
+  gsl_matrix_int *m = (gsl_matrix_int*)malloc(sizeof(gsl_matrix_int));
+  gsl_block_int *b = (gsl_block_int*)malloc(sizeof(gsl_block_int));
+  assert(m && b && v.matrix.data);
+  *m = v.matrix;
+  b->size = n1*n2;
+  b->data = m->data;
+  m->block = b;
+  pure_expr *x = new_expr();
+  x->tag = EXPR::IMATRIX;
+  x->data.mat.p = m;
+  x->data.mat.refc = new uint32_t;
+  *x->data.mat.refc = 1;
+  MEMDEBUG_NEW(x)
+  return x;
+#else
+  return 0;
+#endif
+}
+
+extern "C"
+pure_expr *matrix_from_byte_array_dup(void *p, uint32_t n1, uint32_t n2)
+{
+#ifdef HAVE_GSL
+  if (n1 == 0 || n2 == 0) // empty matrix
+    return pure_int_matrix(create_int_matrix(n1, n2));
+  if (!p)
+    p = calloc(n1*n2, sizeof(int));
+  else {
+    void *q = malloc(n1*n2*sizeof(int));
+    int8_t *p1 = (int8_t*)p; int *q1 = (int*)q;
+    for (size_t i = 0; i < n1*n2; i++) q1[i] = (int)p1[i];
+    p = q;
+  }
+  if (!p) return 0;
+  gsl_matrix_int_view v = gsl_matrix_int_view_array((int*)p, n1, n2);
+  // take a copy of the view matrix
+  gsl_matrix_int *m = (gsl_matrix_int*)malloc(sizeof(gsl_matrix_int));
+  gsl_block_int *b = (gsl_block_int*)malloc(sizeof(gsl_block_int));
+  assert(m && b && v.matrix.data);
+  *m = v.matrix;
+  b->size = n1*n2;
+  b->data = m->data;
+  m->block = b;
+  pure_expr *x = new_expr();
+  x->tag = EXPR::IMATRIX;
+  x->data.mat.p = m;
+  x->data.mat.refc = new uint32_t;
+  *x->data.mat.refc = 1;
+  MEMDEBUG_NEW(x)
+  return x;
+#else
+  return 0;
+#endif
+}
+
 static uint32_t mpz_hash(const mpz_t z)
 {
   uint32_t h = 0;

Modified: pure/trunk/runtime.h
===================================================================
--- pure/trunk/runtime.h	2008-09-23 23:25:21 UTC (rev 844)
+++ pure/trunk/runtime.h	2008-09-23 23:56:53 UTC (rev 845)
@@ -746,6 +746,7 @@
 
 /* The following routines work like the above, but copy the data to newly
    allocated memory, so the original data can be freed after the call.
+   Additional routines are provided for various alternate data sizes.
    Moreover, the source pointer p may also be NULL in which case the new
    matrix is filled with zeros instead. */
 
@@ -753,6 +754,11 @@
 pure_expr *matrix_from_complex_array_dup(void *p, uint32_t n, uint32_t m);
 pure_expr *matrix_from_int_array_dup(void *p, uint32_t n, uint32_t m);
 
+pure_expr *matrix_from_float_array_dup(void *p, uint32_t n, uint32_t m);
+pure_expr *matrix_from_complex_float_array_dup(void *p, uint32_t n, uint32_t m);
+pure_expr *matrix_from_short_array_dup(void *p, uint32_t n, uint32_t m);
+pure_expr *matrix_from_byte_array_dup(void *p, uint32_t n, uint32_t m);
+
 /* Compute a 32 bit hash code of a Pure expression. This makes it possible to
    use arbitary Pure values as keys in a hash table. */
 


This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site.