rb-gsl 1.15.3.1

data/ext/histogram3d_source.c

@@ -0,0 +1,750 @@
+/*
+  histogram3d_source.c
+  Ruby/GSL: Ruby extension library for GSL (GNU Scientific Library)
+    (C) Copyright 2001-2006 by Yoshiki Tsunesada
+
+  Ruby/GSL is free software: you can redistribute it and/or modify it
+  under the terms of the GNU General Public License.
+  This library is distributed in the hope that it will be useful, but
+  WITHOUT ANY WARRANTY.
+*/
+
+/*
+  This source code is created modifying gsl-1.5/histogram/ *2d.c
+ */
+
+#include "rb_gsl_histogram.h"
+
+mygsl_histogram3d* mygsl_histogram3d_alloc(const size_t nx, const size_t ny,
+					   const size_t nz)
+{
+  mygsl_histogram3d *h = NULL;
+  if (nx == 0) GSL_ERROR_VAL ("histogram3d length nx must be positive integer",
+			      GSL_EDOM, 0);
+  if (ny == 0) GSL_ERROR_VAL ("histogram3d length ny must be positive integer",
+			      GSL_EDOM, 0);
+  if (nz == 0) GSL_ERROR_VAL ("histogram3d length nz must be positive integer",
+			      GSL_EDOM, 0);
+  h = (mygsl_histogram3d *) malloc(sizeof(mygsl_histogram3d));
+  if (h == NULL) GSL_ERROR_VAL ("failed to allocate space for histogram3d struct",
+				GSL_ENOMEM, 0);
+  h->xrange = (double *) malloc ((nx + 1) * sizeof (double));
+  if (h->xrange == 0) {
+    free (h);         /* exception in constructor, avoid memory leak */
+    GSL_ERROR_VAL ("failed to allocate space for histogram3d x ranges",
+		   GSL_ENOMEM, 0);
+  }
+  h->yrange = (double *) malloc ((ny + 1) * sizeof (double));
+  if (h->yrange == 0) {
+    free (h->xrange);
+    free (h);         /* exception in constructor, avoid memory leak */
+    GSL_ERROR_VAL ("failed to allocate space for histogram3d y ranges",
+		   GSL_ENOMEM, 0);
+  }
+  h->zrange = (double *) malloc ((nz + 1) * sizeof (double));
+  if (h->zrange == 0) {
+    free (h->xrange);
+    free (h->yrange);
+    free (h);         /* exception in constructor, avoid memory leak */
+    GSL_ERROR_VAL ("failed to allocate space for histogram3d z ranges",
+		   GSL_ENOMEM, 0);
+  }
+  h->bin = (double *) malloc (nx*ny*nz*sizeof (double));
+  if (h->bin == 0) {
+    free (h->xrange);
+    free (h->yrange);
+    free (h->zrange);
+    free (h);         /* exception in constructor, avoid memory leak */
+    GSL_ERROR_VAL ("failed to allocate space for histogram bins",
+		   GSL_ENOMEM, 0);
+  }
+  h->nx = nx;
+  h->ny = ny;
+  h->nz = nz;
+  return h;
+}
+
+mygsl_histogram3d* mygsl_histogram3d_calloc_uniform(const size_t nx, 
+						    const size_t ny,
+						    const size_t nz,
+						    const double xmin,
+						    const double xmax,
+						    const double ymin,
+						    const double ymax,
+						    const double zmin,
+						    const double zmax)
+{
+  mygsl_histogram3d *h;
+  size_t i;
+  h = mygsl_histogram3d_alloc(nx, ny, nz);
+  for (i = 0; i < nx + 1; i++)
+    h->xrange[i] = xmin + ((double) i / (double) nx) * (xmax - xmin);
+  for (i = 0; i < ny + 1; i++)
+    h->yrange[i] = ymin + ((double) i / (double) ny) * (ymax - ymin);
+  for (i = 0; i < nz + 1; i++)
+    h->zrange[i] = zmin + ((double) i / (double) nz) * (zmax - zmin);
+  return h;
+}
+
+mygsl_histogram3d* mygsl_histogram3d_calloc(const size_t nx, 
+					    const size_t ny,
+					    const size_t nz)
+{
+  mygsl_histogram3d *h;
+  size_t i;
+  h = mygsl_histogram3d_alloc(nx, ny, nz);
+  for (i = 0; i < nx + 1; i++)
+    h->xrange[i] = i;
+  for (i = 0; i < ny + 1; i++)
+    h->yrange[i] = i;
+  for (i = 0; i < nz + 1; i++)
+    h->zrange[i] = i;
+  for (i = 0; i < nx*ny*nz; i++)
+    h->bin[i] = 0;
+  return h;
+}
+
+int mygsl_histogram3d_set_ranges_uniform (mygsl_histogram3d * h, 
+					  double xmin, double xmax,
+					  double ymin, double ymax,
+					  double zmin, double zmax)
+{
+  size_t i;
+  const size_t nx = h->nx, ny = h->ny, nz = h->nz;
+
+  if (xmin >= xmax) GSL_ERROR_VAL ("xmin must be less than xmax", GSL_EINVAL, 0);
+  if (ymin >= ymax) GSL_ERROR_VAL ("ymin must be less than ymax", GSL_EINVAL, 0);
+  if (zmin >= zmax) GSL_ERROR_VAL ("zmin must be less than zmax", GSL_EINVAL, 0);
+
+  for (i = 0; i <= nx; i++)
+    h->xrange[i] = xmin + ((double) i / (double) nx) * (xmax - xmin);
+  for (i = 0; i <= ny; i++)
+    h->yrange[i] = ymin + ((double) i / (double) ny) * (ymax - ymin);
+  for (i = 0; i <= nz; i++)
+    h->zrange[i] = zmin + ((double) i / (double) nz) * (zmax - zmin);
+  for (i = 0; i < nx*ny*nz; i++) h->bin[i] = 0;
+  return GSL_SUCCESS;
+}
+
+int mygsl_histogram3d_set_ranges(mygsl_histogram3d * h, 
+				 const double xrange[], size_t xsize,
+				 const double yrange[], size_t ysize,
+				 const double zrange[], size_t zsize)
+{
+  size_t i;
+  const size_t nx = h->nx, ny = h->ny, nz = h->nz;
+  if (xsize != (nx + 1))
+    GSL_ERROR_VAL ("size of xrange must match size of histogram", 
+		   GSL_EINVAL, 0);
+  if (ysize != (ny + 1))
+    GSL_ERROR_VAL ("size of yrange must match size of histogram", 
+		   GSL_EINVAL, 0);
+  if (zsize != (nz + 1))
+    GSL_ERROR_VAL ("size of yrange must match size of histogram", 
+		   GSL_EINVAL, 0);
+  memcpy(h->xrange, xrange, sizeof(double)*xsize);
+  memcpy(h->yrange, yrange, sizeof(double)*ysize);
+  memcpy(h->zrange, zrange, sizeof(double)*zsize);
+  for (i = 0; i < nx*ny*nz; i++) h->bin[i] = 0;
+  return GSL_SUCCESS;
+}
+
+void mygsl_histogram3d_free (mygsl_histogram3d * h)
+{
+  free (h->xrange);
+  free (h->yrange);
+  free (h->zrange);
+  free (h->bin);
+  free (h);
+}
+
+/*****/
+
+int mygsl_histogram3d_memcpy(mygsl_histogram3d * dest, const mygsl_histogram3d * src)
+{  
+  size_t nx = src->nx;  
+  size_t ny = src->ny;  
+  size_t nz = src->nz;  
+  if (dest->nx != src->nx || dest->ny != src->ny ||  dest->nz != src->nz) {
+    GSL_ERROR ("histograms have different sizes, cannot copy",   
+	       GSL_EINVAL);    
+  }
+  memcpy(dest->xrange, src->xrange, sizeof(double)*(nx+1));
+  memcpy(dest->yrange, src->yrange, sizeof(double)*(ny+1));
+  memcpy(dest->zrange, src->zrange, sizeof(double)*(nz+1));
+  memcpy(dest->bin, src->bin, sizeof(double)*nx*ny*nz);
+  return GSL_SUCCESS;
+}
+
+mygsl_histogram3d* mygsl_histogram3d_clone(const mygsl_histogram3d * src)
+{
+  mygsl_histogram3d *h;
+  h = mygsl_histogram3d_alloc(src->nx, src->ny, src->nz);
+  mygsl_histogram3d_memcpy(h, src);
+  return h;
+}
+
+/*****/
+
+int mygsl_histogram3d_fread(FILE * stream, mygsl_histogram3d * h)
+{  
+  int status = gsl_block_raw_fread (stream, h->xrange, h->nx + 1, 1);  
+  if (status)    return status;  
+  status = gsl_block_raw_fread (stream, h->yrange, h->ny + 1, 1);  
+  if (status)    return status;  
+  status = gsl_block_raw_fread (stream, h->zrange, h->nz + 1, 1);  
+  if (status)    return status;  
+  status = gsl_block_raw_fread (stream, h->bin, h->nx * h->ny * h->nz, 1);  
+  return status;
+}
+
+int mygsl_histogram3d_fwrite(FILE * stream, const mygsl_histogram3d * h)
+{  
+  int status = gsl_block_raw_fwrite (stream, h->xrange, h->nx + 1, 1);  
+  if (status)    return status;  
+  status = gsl_block_raw_fwrite (stream, h->yrange, h->ny + 1, 1);  
+  if (status)    return status;  
+  status = gsl_block_raw_fwrite (stream, h->zrange, h->nz + 1, 1);  
+  if (status)    return status;  
+  status = gsl_block_raw_fwrite (stream, h->bin, h->nx * h->ny * h->nz, 1);  
+  return status;
+}
+
+int mygsl_histogram3d_increment(mygsl_histogram3d * h, double x, double y, double z)
+{  
+  int status = mygsl_histogram3d_accumulate (h, x, y, z, 1.0);  
+  return status;
+}
+
+int mygsl_find (const size_t n, const double range[], const double x, size_t * i);
+int mygsl_find2d (const size_t nx, const double xrange[],
+		  const size_t ny, const double yrange[],
+		  const double x, const double y,
+		  size_t * i, size_t * j);
+int mygsl_find3d (const size_t nx, const double xrange[],
+		  const size_t ny, const double yrange[],
+		  const size_t nz, const double zrange[],
+		  const double x, const double y, const double z,
+		  size_t * i, size_t * j, size_t *k);
+
+int mygsl_histogram3d_accumulate(mygsl_histogram3d * h, 
+				 double x, double y, double z, double weight)
+{  
+  const size_t nx = h->nx;  
+  const size_t ny = h->ny;  
+  const size_t nz = h->nz;  
+  size_t i = 0, j = 0, k = 0;  
+  int status = mygsl_find3d (h->nx, h->xrange, h->ny, h->yrange, h->nz, h->zrange,
+			     x, y, z, &i, &j, &k);  
+  if (status) return GSL_EDOM; 
+  if (i >= nx) GSL_ERROR ("index lies outside valid range of 0 .. nx - 1",   
+			  GSL_ESANITY);    
+  if (j >= ny) GSL_ERROR ("index lies outside valid range of 0 .. ny - 1",  
+			  GSL_ESANITY);   
+  if (k >= nz) GSL_ERROR ("index lies outside valid range of 0 .. nz - 1",  
+			  GSL_ESANITY);   
+  h->bin[i*ny*nz + j*nz + k] += weight;  
+  return GSL_SUCCESS;
+}
+
+int mygsl_histogram3d_increment2(mygsl_histogram3d * h, 
+				 double x, double y, double z)
+{
+  return mygsl_histogram3d_accumulate2(h, x, y, z, 1.0);
+}
+
+int mygsl_histogram3d_accumulate2(mygsl_histogram3d * h, 
+				  double x, double y, double z, double weight)
+{  
+  const size_t nx = h->nx;  
+  const size_t ny = h->ny;  
+  const size_t nz = h->nz;  
+  size_t i = 0, j = 0, k = 0;
+  int status;
+  if (x < h->xrange[0]) x = h->xrange[0] + 4*GSL_DBL_EPSILON;
+  if (x > h->xrange[h->nx]) x = h->xrange[h->nx] - 4*GSL_DBL_EPSILON;
+  if (y < h->yrange[0]) y = h->yrange[0] + 4*GSL_DBL_EPSILON;
+  if (y > h->yrange[h->ny]) y = h->yrange[h->ny] - 4*GSL_DBL_EPSILON;
+  if (z < h->zrange[0]) z = h->zrange[0] + 4*GSL_DBL_EPSILON;
+  if (z > h->zrange[h->nz]) z = h->zrange[h->nz] - 4*GSL_DBL_EPSILON;
+  status = mygsl_find3d (h->nx, h->xrange, h->ny, h->yrange, h->nz, h->zrange,
+			 x, y, z, &i, &j, &k);  
+  if (status) return GSL_EDOM; 
+  if (i >= nx) GSL_ERROR ("index lies outside valid range of 0 .. nx - 1",   
+			  GSL_ESANITY);    
+  if (j >= ny) GSL_ERROR ("index lies outside valid range of 0 .. ny - 1",  
+			  GSL_ESANITY);   
+  if (k >= nz) GSL_ERROR ("index lies outside valid range of 0 .. nz - 1",  
+			  GSL_ESANITY);   
+  h->bin[i*ny*nz + j*nz + k] += weight;  
+  return GSL_SUCCESS;
+}
+
+double mygsl_histogram3d_get(const mygsl_histogram3d * h, const size_t i, 
+			     const size_t j, const size_t k)
+{  
+  const size_t nx = h->nx;  
+  const size_t ny = h->ny;  
+  const size_t nz = h->nz;  
+  if (i >= nx) GSL_ERROR_VAL ("index i lies outside valid range of 0 .. nx - 1", 
+			      GSL_EDOM, 0);   
+  if (j >= ny) GSL_ERROR_VAL ("index j lies outside valid range of 0 .. ny - 1",    
+			      GSL_EDOM, 0);    
+  if (k >= nz) GSL_ERROR_VAL ("index k lies outside valid range of 0 .. nz - 1",    
+			      GSL_EDOM, 0);    
+  return h->bin[i*ny*nz + j*nz + k];
+}
+
+int mygsl_histogram3d_get_xrange(const mygsl_histogram3d * h, const size_t i,  
+			       double *xlower, double *xupper)
+{ 
+  const size_t nx = h->nx;  
+  if (i >= nx) GSL_ERROR ("index i lies outside valid range of 0 .. nx - 1", 
+			  GSL_EDOM);    
+  *xlower = h->xrange[i];  
+  *xupper = h->xrange[i + 1];  
+  return GSL_SUCCESS;
+}
+
+int mygsl_histogram3d_get_yrange(const mygsl_histogram3d * h, const size_t j,  
+			       double *ylower, double *yupper)
+{ 
+  const size_t ny = h->ny;  
+  if (j >= ny) GSL_ERROR ("index j lies outside valid range of 0 .. ny - 1", 
+			  GSL_EDOM);    
+  *ylower = h->yrange[j];  
+  *yupper = h->yrange[j + 1];  
+  return GSL_SUCCESS;
+}
+
+int mygsl_histogram3d_get_zrange(const mygsl_histogram3d * h, const size_t k,  
+			       double *zlower, double *zupper)
+{ 
+  const size_t nz = h->nz;  
+  if (k >= nz) GSL_ERROR ("index k lies outside valid range of 0 .. nz - 1", 
+			  GSL_EDOM);    
+  *zlower = h->zrange[k];  
+  *zupper = h->zrange[k + 1];  
+  return GSL_SUCCESS;
+}
+
+int mygsl_histogram3d_find (const mygsl_histogram3d * h,
+			    const double x, const double y, const double z,
+			    size_t * i, size_t * j, size_t *k)
+{ 
+  int status = mygsl_find(h->nx, h->xrange, x, i);  
+  if (status) GSL_ERROR ("x not found in range of h", GSL_EDOM);    
+  status = mygsl_find (h->ny, h->yrange, y, j);  
+  if (status) GSL_ERROR ("y not found in range of h", GSL_EDOM);    
+  status = mygsl_find (h->nz, h->zrange, z, k);  
+  if (status) GSL_ERROR ("z not found in range of h", GSL_EDOM);    
+  return GSL_SUCCESS;
+}
+
+gsl_histogram2d* mygsl_histogram3d_xyproject(const mygsl_histogram3d * h3,
+					     size_t kstart, size_t kend)
+{
+  gsl_histogram2d *h2;
+  double count;
+  size_t i, j, k;
+  h2 = gsl_histogram2d_calloc(h3->nx, h3->ny);
+  gsl_histogram2d_set_ranges(h2, h3->xrange, h3->nx+1, h3->yrange, h3->ny+1);
+  for (i = 0; i < h3->nx; i++) {
+    for (j = 0; j < h3->ny; j++) {
+      count = 0;
+      for (k = kstart; k <= kend; k++) {
+	if (k >= h3->nz) break;
+	count += mygsl_histogram3d_get(h3, i, j, k);
+      }
+      h2->bin[i*h2->ny + j] = count;
+    }
+  }
+  return h2;
+}
+
+gsl_histogram2d* mygsl_histogram3d_xzproject(const mygsl_histogram3d * h3,
+					     size_t jstart, size_t jend)
+{
+  gsl_histogram2d *h2;
+  double count;
+  size_t i, j, k;
+  h2 = gsl_histogram2d_calloc(h3->nx, h3->nz);
+  gsl_histogram2d_set_ranges(h2, h3->xrange, h3->nx+1, h3->zrange, h3->nz+1);
+  for (i = 0; i < h3->nx; i++) {
+    for (k = 0; k < h3->nz; k++) {
+      count = 0;
+      for (j = jstart; j <= jend; j++) {
+	if (j >= h3->ny) break;
+	count += mygsl_histogram3d_get(h3, i, j, k);
+      }
+      h2->bin[i*h2->ny + k] = count;
+    }
+  }
+  return h2;
+}
+
+gsl_histogram2d* mygsl_histogram3d_yzproject(const mygsl_histogram3d * h3,
+					     size_t istart, size_t iend)
+{
+  gsl_histogram2d *h2;
+  double count;
+  size_t i, j, k;
+  h2 = gsl_histogram2d_calloc(h3->ny, h3->nz);
+  gsl_histogram2d_set_ranges(h2, h3->yrange, h3->ny+1, h3->zrange, h3->nz+1);
+  for (j = 0; j < h3->ny; j++) {
+    for (k = 0; k < h3->nz; k++) {
+      count = 0;
+      for (i = istart; i <= iend; i++) {
+	if (i >= h3->nx) break;
+	count += mygsl_histogram3d_get(h3, i, j, k);
+      }
+      h2->bin[j*h2->ny + k] = count;
+    }
+  }
+  return h2;
+}
+
+int mygsl_histogram3d_scale(mygsl_histogram3d * h, double scale)
+{
+  size_t i, n;
+  n = h->nx*h->ny*h->nz;
+  for (i = 0; i < n; i++) h->bin[i] *= scale;
+  return GSL_SUCCESS;
+}
+
+int mygsl_histogram3d_shift(mygsl_histogram3d * h, double shift)
+{
+  size_t i, n;
+  n = h->nx*h->ny*h->nz;
+  for (i = 0; i < n; i++) h->bin[i] += shift;
+  return GSL_SUCCESS;
+}
+
+double mygsl_histogram3d_xmax(const mygsl_histogram3d * h)
+{
+  const int nx = h->nx;  
+  return h->xrange[nx];
+}
+double mygsl_histogram3d_xmin(const mygsl_histogram3d * h)
+{
+  return h->xrange[0];
+}
+
+double mygsl_histogram3d_ymax(const mygsl_histogram3d * h)
+{
+  const int ny = h->ny;  
+  return h->yrange[ny];
+}
+double mygsl_histogram3d_ymin(const mygsl_histogram3d * h)
+{
+  return h->yrange[0];
+}
+
+double mygsl_histogram3d_zmax(const mygsl_histogram3d * h)
+{
+  const int nz = h->nz;  
+  return h->zrange[nz];
+}
+
+double mygsl_histogram3d_zmin(const mygsl_histogram3d * h)
+{
+  return h->zrange[0];
+}
+
+double mygsl_histogram3d_max_val(const mygsl_histogram3d * h)
+{
+  const size_t nx = h->nx;
+  const size_t ny = h->ny;
+  const size_t nz = h->nz;
+  size_t i;
+  double max = h->bin[0];
+  for (i = 0; i < nx*ny*nz; i++) {
+    if (h->bin[i] > max) max = h->bin[i];
+  }
+  return max;
+}
+
+void mygsl_histogram3d_max_bin(const mygsl_histogram3d * h, 
+			       size_t *imax_out, size_t *jmax_out, size_t *kmax_out)
+{
+  const size_t nx = h->nx;
+  const size_t ny = h->ny;
+  const size_t nz = h->nz;
+  size_t imax = 0, jmax = 0, kmax = 0, i, j, k;
+  double max = h->bin[0], x;
+  for (i = 0; i < nx; i++) {
+    for (j = 0; j < ny; j++) {
+      for (k = 0; k < nz; k++) {
+	x = h->bin[i * ny*nz + j*nz + k];
+	if (x > max) {
+	  max = x;
+	  imax = i;
+	  jmax = j;
+	  kmax = k;
+	}
+      }
+    }
+  }
+  *imax_out = imax;
+  *jmax_out = jmax;
+  *kmax_out = kmax;
+}
+
+double mygsl_histogram3d_min_val(const mygsl_histogram3d * h)
+{
+  const size_t nx = h->nx;
+  const size_t ny = h->ny;
+  const size_t nz = h->nz;
+  size_t i;
+  double min = h->bin[0];
+  for (i = 0; i < nx*ny*nz; i++) {
+    if (h->bin[i] < min) min = h->bin[i];
+  }
+  return min;
+}
+
+void mygsl_histogram3d_min_bin(const mygsl_histogram3d * h, 
+			       size_t *imin_out, size_t *jmin_out, size_t *kmin_out)
+{
+  const size_t nx = h->nx;
+  const size_t ny = h->ny;
+  const size_t nz = h->nz;
+  size_t imin = 0, jmin = 0, kmin = 0, i, j, k;
+  double min = h->bin[0], x;
+  for (i = 0; i < nx; i++) {
+    for (j = 0; j < ny; j++) {
+      for (k = 0; k < nz; k++) {
+	x = h->bin[i * ny*nz + j*nz + k];
+	if (x < min) {
+	  min = x;
+	  imin = i;
+	  jmin = j;
+	  kmin = k;
+	}
+      }
+    }
+  }
+  *imin_out = imin;
+  *jmin_out = jmin;
+  *kmin_out = kmin;
+}
+
+double mygsl_histogram3d_sum (const mygsl_histogram3d * h)
+{
+  const size_t n = h->nx*h->ny*h->nz;
+  double sum = 0;
+  size_t i = 0;
+  while (i < n) sum += h->bin[i++];
+  return sum;
+}
+
+double mygsl_histogram3d_xmean (const mygsl_histogram3d * h)
+{
+  const size_t nx = h->nx;
+  const size_t ny = h->ny;
+  const size_t nz = h->nz;
+  size_t i, j, k;
+  double wmean = 0;
+  double W = 0;
+  for (i = 0; i < nx; i++) {
+    double xi = (h->xrange[i + 1] + h->xrange[i]) / 2.0;
+    double wi = 0;
+    for (j = 0; j < ny; j++) {
+      for (k = 0; k < nz; k++) {
+	double wijk = h->bin[i * ny *nz + j * nz + k];
+	if (wijk > 0) wi += wijk;
+      }
+    }
+    if (wi > 0) {
+      W += wi;
+      wmean += (xi - wmean) * (wi / W);
+    }
+  }
+  return wmean;
+}
+
+double mygsl_histogram3d_ymean (const mygsl_histogram3d * h)
+{
+  const size_t nx = h->nx;
+  const size_t ny = h->ny;
+  const size_t nz = h->nz;
+  size_t i, j, k;
+  double wmean = 0;
+  double W = 0;
+  for (j = 0; j < ny; j++) {
+    double yj = (h->yrange[j + 1] + h->yrange[j]) / 2.0;
+    double wj = 0;
+    for (i = 0; i < nx; i++) {
+      for (k = 0; k < nz; k++) {
+	double wijk = h->bin[i * ny *nz + j * nz + k];
+	if (wijk > 0) wj += wijk;
+      }
+    }
+    if (wj > 0) {
+      W += wj;
+      wmean += (yj - wmean) * (wj / W);
+    }
+  }
+  return wmean;
+}
+
+double mygsl_histogram3d_zmean (const mygsl_histogram3d * h)
+{
+  const size_t nx = h->nx;
+  const size_t ny = h->ny;
+  const size_t nz = h->nz;
+  size_t i, j, k;
+  double wmean = 0;
+  double W = 0;
+  for (k = 0; k < nz; k++) {
+    double zk = (h->zrange[k + 1] + h->zrange[k]) / 2.0;
+    double wk = 0;
+    for (i = 0; i < nx; i++) {
+      for (j = 0; j < ny; j++) {
+	double wijk = h->bin[i * ny *nz + j * nz + k];
+	if (wijk > 0) wk += wijk;
+      }
+    }
+    if (wk > 0) {
+      W += wk;
+      wmean += (zk - wmean) * (wk / W);
+    }
+  }
+  return wmean;
+}
+
+double mygsl_histogram3d_xsigma(const mygsl_histogram3d * h)
+{
+  const double xmean = mygsl_histogram3d_xmean(h);
+  const size_t nx = h->nx, ny = h->ny, nz = h->nz;
+  size_t i, j, k;
+  double wvariance = 0, W = 0;
+  for (i = 0; i < nx; i++) {
+    double xi = (h->xrange[i + 1] + h->xrange[i]) / 2 - xmean;
+    double wi = 0;
+    for (j = 0; j < ny; j++) {
+      for (k = 0; k < nz; k++) {
+	double wijk = h->bin[i * ny*nz + j*nz + k];
+	if (wijk > 0) wi += wijk;
+      }
+    }
+    if (wi > 0) {
+      W += wi;
+      wvariance += ((xi * xi) - wvariance) * (wi / W);
+    }
+  }
+  return  sqrt(wvariance);
+}
+
+double mygsl_histogram3d_ysigma(const mygsl_histogram3d * h)
+{
+  const double ymean = mygsl_histogram3d_ymean(h);
+  const size_t nx = h->nx, ny = h->ny, nz = h->nz;
+  size_t i, j, k;
+  double wvariance = 0, W = 0;
+  for (j = 0; j < ny; j++) {
+    double yj = (h->yrange[j + 1] + h->yrange[j]) / 2 - ymean;
+    double wj = 0;
+    for (i = 0; i < nx; i++) {
+      for (k = 0; k < nz; k++) {
+	double wjjk = h->bin[i * ny*nz + j*nz + k];
+	if (wjjk > 0) wj += wjjk;
+      }
+    }
+    if (wj > 0) {
+      W += wj;
+      wvariance += ((yj * yj) - wvariance) * (wj / W);
+    }
+  }
+  return  sqrt(wvariance);
+}
+
+double mygsl_histogram3d_zsigma(const mygsl_histogram3d * h)
+{
+  const double zmean = mygsl_histogram3d_zmean(h);
+  const size_t nx = h->nx, ny = h->ny, nz = h->nz;
+  size_t i, j, k;
+  double wvariance = 0, W = 0;
+  for (k = 0; k < nz; k++) {
+    double zk = (h->zrange[k + 1] + h->zrange[k]) / 2 - zmean;
+    double wk = 0;
+    for (i = 0; i < nx; i++) {
+      for (j = 0; j < ny; j++) {
+	double wijk = h->bin[i * ny*nz + j*nz + k];
+	if (wijk > 0) wk += wijk;
+      }
+    }
+    if (wk > 0) {
+      W += wk;
+      wvariance += ((zk * zk) - wvariance) * (wk / W);
+    }
+  }
+  return  sqrt(wvariance);
+}
+
+void mygsl_histogram3d_reset(mygsl_histogram3d * h)
+{
+  size_t i;
+  const size_t nx = h->nx;
+  const size_t ny = h->ny;
+  const size_t nz = h->nz;
+
+  for (i = 0; i < nx * ny * nz; i++)
+    {
+      h->bin[i] = 0;
+    }
+}
+
+int mygsl_histogram3d_equal_bins_p(const mygsl_histogram3d * h1,
+				   const mygsl_histogram3d * h2)
+{
+  size_t i;
+  if ((h1->nx != h2->nx) || (h1->ny != h2->ny) || (h1->nz != h2->nz)) return 0;
+  for (i = 0; i <= h1->nx; i++) 
+    if (h1->xrange[i] != h2->xrange[i]) return 0;
+  for (i = 0; i <= h1->ny; i++)
+    if (h1->yrange[i] != h2->yrange[i]) return 0;
+  for (i = 0; i <= h1->nz; i++)
+    if (h1->zrange[i] != h2->zrange[i]) return 0;
+  return 1;
+}
+
+int mygsl_histogram3d_add(mygsl_histogram3d * h1, const mygsl_histogram3d * h2)
+{
+  size_t i;
+  if (!mygsl_histogram3d_equal_bins_p(h1, h2))
+    GSL_ERROR ("histograms have different binning", GSL_EINVAL);
+  for (i = 0; i < (h1->nx) * (h1->ny) * (h1->nz); i++)
+    h1->bin[i] += h2->bin[i];
+  return GSL_SUCCESS;
+}
+
+int mygsl_histogram3d_sub(mygsl_histogram3d * h1, const mygsl_histogram3d * h2)
+{
+  size_t i;
+  if (!mygsl_histogram3d_equal_bins_p(h1, h2))
+    GSL_ERROR ("histograms have different binning", GSL_EINVAL);
+  for (i = 0; i < (h1->nx) * (h1->ny) * (h1->nz); i++)
+    h1->bin[i] -= h2->bin[i];
+  return GSL_SUCCESS;
+}
+
+int mygsl_histogram3d_mul(mygsl_histogram3d * h1, const mygsl_histogram3d * h2)
+{
+  size_t i;
+  if (!mygsl_histogram3d_equal_bins_p(h1, h2))
+    GSL_ERROR ("histograms have different binning", GSL_EINVAL);
+  for (i = 0; i < (h1->nx) * (h1->ny) * (h1->nz); i++)
+    h1->bin[i] *= h2->bin[i];
+  return GSL_SUCCESS;
+}
+
+int mygsl_histogram3d_div(mygsl_histogram3d * h1, const mygsl_histogram3d * h2)
+{
+  size_t i;
+  if (!mygsl_histogram3d_equal_bins_p(h1, h2))
+    GSL_ERROR ("histograms have different binning", GSL_EINVAL);
+  for (i = 0; i < (h1->nx) * (h1->ny) * (h1->nz); i++)
+    h1->bin[i] /= h2->bin[i];
+  return GSL_SUCCESS;
+}