hist_2d.h
Go to the documentation of this file.
1 /*
2  -------------------------------------------------------------------
3 
4  Copyright (C) 2010-2017, Andrew W. Steiner
5 
6  This file is part of O2scl.
7 
8  O2scl is free software; you can redistribute it and/or modify
9  it under the terms of the GNU General Public License as published by
10  the Free Software Foundation; either version 3 of the License, or
11  (at your option) any later version.
12 
13  O2scl is distributed in the hope that it will be useful,
14  but WITHOUT ANY WARRANTY; without even the implied warranty of
15  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16  GNU General Public License for more details.
17 
18  You should have received a copy of the GNU General Public License
19  along with O2scl. If not, see <http://www.gnu.org/licenses/>.
20 
21  -------------------------------------------------------------------
22 */
23 #ifndef O2SCL_HIST_2D_H
24 #define O2SCL_HIST_2D_H
25 
26 /** \file hist_2d.h
27  \brief File defining \ref o2scl::hist_2d
28 */
29 #include <iostream>
30 
31 #include <boost/numeric/ublas/vector.hpp>
32 #include <boost/numeric/ublas/matrix.hpp>
33 
34 #include <o2scl/convert_units.h>
35 #include <o2scl/interp.h>
36 #include <o2scl/uniform_grid.h>
37 #include <o2scl/table3d.h>
38 
39 // Forward definition of the hist_2d class for HDF I/O
40 namespace o2scl {
41  class hist_2d;
42 }
43 
44 // Forward definition of HDF I/O to extend friendship
45 namespace o2scl_hdf {
46  class hdf_file;
47  void hdf_input(hdf_file &hf, o2scl::hist_2d &t, std::string name);
48  void hdf_output(hdf_file &hf, o2scl::hist_2d &t, std::string name);
49 }
50 
51 #ifndef DOXYGEN_NO_O2NS
52 namespace o2scl {
53 #endif
54 
55  /** \brief A two-dimensional histogram class
56 
57  See discussion in the User's guide in the \ref hist_section
58  section.
59 
60  Typical usage begins with setting the histogram bins using
61  \ref hist_2d::set_bin_edges(). Note that if one attempts to set
62  the bins on a histogram where the bins have already been set,
63  one must ensure that the new and old bin settings have the same
64  size (in both x and y directions). This ensures that there is no
65  ambiguity in rebinning the data and also prevents accidental
66  data loss. One may set the bin edges either with generic
67  vectors, or with \ref uniform_grid objects.
68 
69  \note In order to ensure the histogram does not employ
70  user-specified representative values that are not defined, the
71  function \ref set_rep_mode() does not allow one to change the
72  mode to \ref hist::rmode_user directly. Instead, use \ref
73  set_reps() which automatically sets the mode to \ref
74  hist::rmode_user and allows the user to specify the
75  representatives.
76 
77  \comment
78 
79  This is commented out for now. The \ref twod_intp
80  object stores a reference to xrep and yrep, and thus
81  can't be used since xrep and yrep don't always exist.
82 
83  Interpolation for \ref hist_2d objects is performed by creating
84  a \ref twod_intp object from the internal histogram data. This
85  is done using \ref o2scl::hist_2d::setup_interp() .
86 
87  \endcomment
88 
89  Internally, either \ref hsize_x and \ref hsize_y should
90  both be zero or both be non-zero.
91 
92  \future Write a function to create a 1-d histogram
93  from a 2-d histogram either by selecting one bin
94  in one axis or by marginalizing over one direction.
95 
96  \future Note that here, there is a conflict between implementing
97  operator(size_t,size_t) to give matrix indexing of the histogram
98  weights, and operator(double,double) to implement
99  two-dimensional interpolation using the weights and the
100  representatives. Currently neither is implemented, but maybe
101  both should be implemented instead?
102  */
103  class hist_2d {
104 
105  public:
106 
109 
110  protected:
111 
112  /// Bin locations (Nx+1)
113  ubvector xa;
114 
115  /// Bin locations (Ny+1)
116  ubvector ya;
117 
118  /// Values (Nx,Ny)
119  ubmatrix wgt;
120 
121  /// "Central" values for x-axis (N)
122  ubvector xrep;
123 
124  /// "Central" values for y-axis (N)
125  ubvector yrep;
126 
127  /// User-defined central values for x-axis (N)
128  ubvector user_xrep;
129 
130  /// User-defined central values for y-axis (N)
131  ubvector user_yrep;
132 
133  /// Number of x-bins
134  size_t hsize_x;
135 
136  /// Number of y-bins
137  size_t hsize_y;
138 
139  /// Rep mode for x
140  size_t xrmode;
141 
142  /// Rep mode for y
143  size_t yrmode;
144 
145  /** \brief Allocate for a histogram of size \c nx, \c ny
146 
147  This function also sets all the weights to zero.
148  */
149  void allocate(size_t nx, size_t ny);
150 
151  /** \brief An internal function to automatically set
152  \ref xrep and \ref yrep
153  */
154  void set_reps_auto();
155 
156  public:
157 
158  hist_2d();
159 
160  virtual ~hist_2d();
161 
162  /// Copy constructor
163  hist_2d(const hist_2d &h);
164 
165  /// Copy from <tt>operator=()</tt>
166  hist_2d &operator=(const hist_2d &h);
167 
168  /// Create from vectors of data
169  template<class vec_t, class vec2_t> hist_2d
170  (size_t nv, const vec_t &v, const vec2_t &v2, size_t n_bins_x,
171  size_t n_bins_y) {
172 
173  xrmode=rmode_avg;
174  yrmode=rmode_avg;
175  extend_rhs=false;
176  extend_lhs=false;
177  hsize_x=0;
178  hsize_y=0;
179 
180  double min_x, max_x, min_y, max_y;
181  o2scl::vector_minmax_value(nv,v,min_x,max_x);
182  o2scl::vector_minmax_value(nv,v2,min_y,max_y);
183  uniform_grid<double> ugx=uniform_grid_end<double>(min_x,max_x,n_bins_x);
184  uniform_grid<double> ugy=uniform_grid_end<double>(min_y,max_y,n_bins_y);
185  set_bin_edges(ugx,ugy);
186 
187  for(size_t i=0;i<nv;i++) {
188  update(v[i],v2[i]);
189  }
190  return;
191  }
192 
193  /// Create from vectors of data
194  template<class vec_t, class vec2_t, class vec3_t> hist_2d
195  (size_t nv, const vec_t &v, const vec2_t &v2, const vec3_t &v3,
196  size_t n_bins_x, size_t n_bins_y) {
197 
198  xrmode=rmode_avg;
199  yrmode=rmode_avg;
200  extend_rhs=false;
201  extend_lhs=false;
202  hsize_x=0;
203  hsize_y=0;
204 
205  double min_x, max_x, min_y, max_y;
206  o2scl::vector_minmax_value(nv,v,min_x,max_x);
207  o2scl::vector_minmax_value(nv,v2,min_y,max_y);
208  uniform_grid<double> ugx=uniform_grid_end<double>(min_x,max_x,n_bins_x);
209  uniform_grid<double> ugy=uniform_grid_end<double>(min_y,max_y,n_bins_y);
210  set_bin_edges(ugx,ugy);
211 
212  for(size_t i=0;i<nv;i++) {
213  update(v[i],v2[i],v3[i]);
214  }
215  return;
216  }
217 
218  /// Create from vectors of data
219  template<class vec_t, class vec2_t> hist_2d
220  (const vec_t &v, const vec2_t &v2, size_t n_bins_x,
221  size_t n_bins_y) {
222 
223  hist_2d(v.size(),v,v2,n_bins_x,n_bins_y);
224 
225  return;
226  }
227 
228  /// Create from vectors of data
229  template<class vec_t, class vec2_t, class vec3_t> hist_2d
230  (const vec_t &v, const vec2_t &v2, const vec3_t &v3, size_t n_bins_x,
231  size_t n_bins_y) {
232 
233  hist_2d(v.size(),v,v2,v3,n_bins_x,n_bins_y);
234 
235  return;
236  }
237 
238  // Create from a table
239  void from_table(o2scl::table<> &t, std::string colx, std::string coly,
240  size_t n_bins_x, size_t n_bins_y) {
241  *this=hist_2d(t.get_nlines(),t.get_column(colx),t.get_column(coly),
242  n_bins_x,n_bins_y);
243  return;
244  }
245 
246  // Create from a table
247  void from_table(o2scl::table<> &t, std::string colx, std::string coly,
248  std::string colz, size_t n_bins_x, size_t n_bins_y) {
249  *this=hist_2d(t.get_nlines(),t.get_column(colx),t.get_column(coly),
250  t.get_column(colz),n_bins_x,n_bins_y);
251  return;
252  }
253 
254  /** \brief If true, allow abcissa larger than largest bin limit
255  to correspond to the highest bin (default false).
256  */
258 
259  /** \brief If true, allow abcissa smaller than smallest bin
260  limit to correspond to the lowest bin (default false).
261  */
263 
264  /** \brief Return the sum of all of the weights
265  */
266  double sum_wgts();
267 
268  /** \brief Return the integral under the histogram
269 
270  This function returns the sum of
271  \f[
272  w_{i,j} ( \mathrm{x,high}_i - \mathrm{x,low}_i)
273  ( \mathrm{y,high}_j - \mathrm{y,low}_j) \, .
274  \f]
275  */
276  double integ_wgts();
277 
278  /// \name Initial bin setup
279  //@{
280  /// Set the bins from two \ref uniform_grid objects
281  void set_bin_edges(uniform_grid<double> gx, uniform_grid<double> gy);
282 
283  /// Set the bins from a vector
284  template<class vec_t> void set_bin_edges(size_t nx, vec_t &vx,
285  size_t ny, vec_t &vy) {
286  if (nx!=hsize_x+1 || ny!=hsize_y+1) {
287  if (hsize_x!=0 || hsize_y!=0) {
288  O2SCL_ERR2("Requested binning change in non-empty ",
289  "histogram in hist_2d::set_bin_edges().",
290  exc_efailed);
291  }
292  allocate(nx-1,ny-1);
293  }
294  for(size_t i=0;i<nx;i++) xa[i]=vx[i];
295  for(size_t i=0;i<ny;i++) ya[i]=vy[i];
296  // Reset internal reps
297  if (xrep.size()>0) xrep.resize(0);
298  if (yrep.size()>0) yrep.resize(0);
299  return;
300  }
301  //@}
302 
303  /// \name Weight functions
304  //@{
305  /// Increment bin at <tt>(i,j)</tt> by value \c val
306  void update_i(size_t i, size_t j, double val=1.0) {
307  wgt(i,j)+=val;
308  return;
309  }
310 
311  /// Increment bin for \c x by value \c val
312  void update(double x, double y, double val=1.0) {
313  size_t i, j;
314  get_bin_indices(x,y,i,j);
315  update_i(i,j,val);
316  return;
317  }
318 
319  /// Return contents of bin at <tt>(i,j)</tt>
320  const double &get_wgt_i(size_t i, size_t j) const;
321 
322  /// Return contents of bin for \c x
323  const double &get_wgt(double x, double y) const {
324  size_t i, j;
325  get_bin_indices(x,y,i,j);
326  return get_wgt_i(i,j);
327  }
328 
329  /// Return contents of bin at <tt>(i,j)</tt>
330  double &get_wgt_i(size_t i, size_t j);
331 
332  /// Return contents of bin for \c x
333  double &get_wgt(double x, double y) {
334  size_t i, j;
335  get_bin_indices(x,y,i,j);
336  return get_wgt_i(i,j);
337  }
338 
339  /// Set contents of bin at <tt>(i,j)</tt> to value \c val
340  void set_wgt_i(size_t i, size_t j, double val);
341 
342  /// Set contents of bin for \c x to value \c val
343  void set_wgt(double x, double y, double val) {
344  size_t i, j;
345  get_bin_indices(x,y,i,j);
346  set_wgt_i(i,j,val);
347  return;
348  }
349 
350  /// Get a const reference to the full matrix of data
351  const ubmatrix &get_wgts() const {
352  return wgt;
353  }
354 
355  /// Get a reference to the full matrix of data
356  ubmatrix &get_wgts() {
357  return wgt;
358  }
359  //@}
360 
361  /// \name Delete functions
362  //@{
363  /// Clear the data, but leave the bins as is
364  void clear_wgts();
365 
366  /// Clear the entire histogram
367  void clear();
368  //@}
369 
370  /// \name Bin manipulation
371  //@{
372  /** \brief Get the index of the bin which holds \c x and
373  the bin which holds \c y
374  */
375  void get_bin_indices(double x, double y, size_t &i, size_t &j) const;
376 
377  /// Get the index of the bin which holds \c x
378  size_t get_x_bin_index(double x) const;
379 
380  /// Get the indey of the bin which holds \c y
381  size_t get_y_bin_index(double y) const;
382 
383  /// Get the lower edge of bin of index \c i
384  double &get_x_low_i(size_t i);
385 
386  /// Get the lower edge of bin of index \c i
387  const double &get_x_low_i(size_t i) const;
388 
389  /// Get the upper edge of bin of index \c i
390  double &get_x_high_i(size_t i);
391 
392  /// Get the upper edge of bin of index \c i
393  const double &get_x_high_i(size_t i) const;
394 
395  /// Get the lower edge of bin of index \c j
396  double &get_y_low_i(size_t j);
397 
398  /// Get the lower edge of bin of index \c j
399  const double &get_y_low_i(size_t j) const;
400 
401  /// Get the upper edge of bin of index \c j
402  double &get_y_high_i(size_t j);
403 
404  /// Get the upper edge of bin of index \c j
405  const double &get_y_high_i(size_t j) const;
406  //@}
407 
408  /// \name Rep modes (default is \c rmode_avg)
409  //@{
410  static const size_t rmode_avg=0;
411  static const size_t rmode_user=1;
412  static const size_t rmode_low=2;
413  static const size_t rmode_high=3;
414  static const size_t rmode_gmean=4;
415  //@}
416 
417  /// \name Representative functions
418  //@{
419  /// Set the representative x-values for each bin
420  template<class vec_t> void set_reps(size_t nx, vec_t &vx,
421  size_t ny, vec_t &vy) {
422  if (user_xrep.size()!=hsize_x || user_yrep.size()!=hsize_y) {
423  std::string s="Expected vectors of size "+itos(hsize_x)+
424  ", "+itos(hsize_y)+" and got a vectors of size "+itos(nx)+
425  ", "+itos(ny)+" in hist_2d::set_reps().";
426  O2SCL_ERR(s.c_str(),exc_einval);
427  }
428  xrmode=rmode_user;
429  yrmode=rmode_user;
430  if (user_xrep.size()>0) user_xrep.clear();
431  if (user_yrep.size()>0) user_yrep.clear();
432  user_xrep.resize(nx);
433  user_yrep.resize(ny);
434  for(size_t i=0;i<nx;i++) user_xrep[i]=vx[i];
435  for(size_t i=0;i<ny;i++) user_yrep[i]=vy[i];
436  return;
437  }
438 
439  /// Set the representative x-values for each bin
440  template<class vec_t> void set_x_reps(size_t nx, vec_t &vx) {
441  if (hsize_x!=nx) {
442  std::string s="Expected vector of size "+itos(hsize_x)+
443  " and got a vector of size "+itos(nx)+" in hist_2d::set_reps().";
444  O2SCL_ERR(s.c_str(),exc_einval);
445  }
446  xrmode=rmode_user;
447  if (user_xrep.size()>0) user_xrep.clear();
448  user_xrep.resize(nx);
449  for(size_t i=0;i<nx;i++) user_xrep[i]=vx[i];
450  return;
451  }
452 
453  /// Set the representative y-values for each bin
454  template<class vec_t> void set_y_reps(size_t ny, vec_t &vy) {
455  if (hsize_y!=ny) {
456  std::string s="Expected vector of size "+itos(hsize_y)+
457  " and got a vector of size "+itos(ny)+" in hist_2d::set_reps().";
458  O2SCL_ERR(s.c_str(),exc_einval);
459  }
460  yrmode=rmode_user;
461  if (user_yrep.size()>0) user_yrep.clear();
462  user_yrep.resize(ny);
463  for(size_t i=0;i<ny;i++) user_yrep[i]=vy[i];
464  return;
465  }
466 
467  /// Set mode used to compute bin reps
468  void set_rep_mode(size_t x_mode, size_t y_mode);
469 
470  /// Get mode used to compute bin reps
471  size_t get_x_rep_mode() const {
472  return xrmode;
473  }
474 
475  /// Get mode used to compute bin reps
476  size_t get_y_rep_mode() const {
477  return yrmode;
478  }
479 
480  /// Get a reference to the full vector of bin specifications
481  const ubvector &get_x_bins() const {
482  return xa;
483  }
484 
485  /// Get a reference to the full vector of bin specifications
486  const ubvector &get_y_bins() const {
487  return ya;
488  }
489 
490  /// Return the histogram size of the x coordinate
491  size_t size_x() const {
492  return hsize_x;
493  }
494 
495  /// Return the histogram size of the y coordinate
496  size_t size_y() const {
497  return hsize_y;
498  }
499 
500  /** \brief Get a reference to the user-specified reps for x coordinates
501 
502  This function will call the error handler if the x-axis
503  representative mode is not \ref hist::rmode_user .
504 
505  \warning This vector reference is only valid so long as
506  the representative mode is unchanged and the function
507  clear() is not called.
508 
509  This member function is used by the \o2 HDF I/O functions.
510  */
511  const ubvector &get_user_reps_x() const {
512  if (xrmode!=rmode_user) {
513  O2SCL_ERR("Not user mode in hist::get_user_reps_x().",
514  exc_efailed);
515  }
516  return user_xrep;
517  }
518 
519  /** \brief Get a reference to the user-specified reps for y coordinates
520 
521  This function will call the error handler if the y-axis
522  representative mode is not \ref hist::rmode_user .
523 
524  \warning This vector reference is only valid so long as
525  the representative mode is unchanged and the function
526  clear() is not called.
527 
528  This member function is used by the \o2 HDF I/O functions.
529  */
530  const ubvector &get_user_reps_y() const {
531  if (yrmode!=rmode_user) {
532  O2SCL_ERR("Not user mode in hist::get_user_reps_y().",
533  exc_efailed);
534  }
535  return user_yrep;
536  }
537 
538  /** \brief Return the rep of bin of index \c i
539 
540  Note that this function returns a value and not a reference.
541  This is because we can't return a reference to the internally
542  computed representatives, since they don't always exist.
543  */
544  double get_x_rep_i(size_t i);
545 
546  /** \brief Return the rep of bin of index \c j
547 
548  Note that this function returns a value and not a reference.
549  This is because we can't return a reference to the internally
550  computed representatives, since they don't always exist.
551  */
552  double get_y_rep_i(size_t j);
553  //@}
554 
555  /* \brief Set up a twod_intp object for interpolation
556 
557  \future This is commented out for now. The \ref twod_intp
558  object stores a reference to xrep and yrep, and thus
559  can't be used since xrep and yrep don't always exist.
560  */
561  //void setup_interp(twod_intp &ti, bool x_first=true) {
562  //ti.set_data(hsize_x,hsize_y,xrep,yrep,wgt,x_first);
563  //return;
564  //}
565 
566  /// Internal consistency check
567  void is_valid() const;
568 
569  /** \brief Create a table3d object based on the histogram data
570  */
571  void copy_to_table(table3d &t, std::string xreps_name,
572  std::string yreps_name, std::string weights);
573 
574  friend void o2scl_hdf::hdf_output(o2scl_hdf::hdf_file &hf,
575  o2scl::hist_2d &h, std::string name);
576  friend void o2scl_hdf::hdf_input(o2scl_hdf::hdf_file &hf,
577  o2scl::hist_2d &h, std::string name);
578 
579  };
580 
581 #ifndef DOXYGEN_NO_O2NS
582 }
583 #endif
584 
585 #endif
size_t get_y_rep_mode() const
Get mode used to compute bin reps.
Definition: hist_2d.h:476
size_t size_y() const
Return the histogram size of the y coordinate.
Definition: hist_2d.h:496
const ubvector & get_y_bins() const
Get a reference to the full vector of bin specifications.
Definition: hist_2d.h:486
The main O<span style=&#39;position: relative; top: 0.3em; font-size: 0.8em&#39;>2</span>scl O$_2$scl names...
Definition: anneal.h:42
ubvector ya
Bin locations (Ny+1)
Definition: hist_2d.h:116
size_t get_nlines() const
Return the number of lines.
Definition: table.h:457
ubvector xa
Bin locations (Nx+1)
Definition: hist_2d.h:113
size_t size_x() const
Return the histogram size of the x coordinate.
Definition: hist_2d.h:491
const ubvector & get_user_reps_y() const
Get a reference to the user-specified reps for y coordinates.
Definition: hist_2d.h:530
const ubmatrix & get_wgts() const
Get a const reference to the full matrix of data.
Definition: hist_2d.h:351
void set_y_reps(size_t ny, vec_t &vy)
Set the representative y-values for each bin.
Definition: hist_2d.h:454
Data table table class.
Definition: table.h:49
size_t hsize_y
Number of y-bins.
Definition: hist_2d.h:137
invalid argument supplied by user
Definition: err_hnd.h:59
void set_wgt(double x, double y, double val)
Set contents of bin for x to value val.
Definition: hist_2d.h:343
ubvector yrep
"Central" values for y-axis (N)
Definition: hist_2d.h:125
void set_reps(size_t nx, vec_t &vx, size_t ny, vec_t &vy)
Set the representative x-values for each bin.
Definition: hist_2d.h:420
A two-dimensional histogram class.
Definition: hist_2d.h:103
void set_x_reps(size_t nx, vec_t &vx)
Set the representative x-values for each bin.
Definition: hist_2d.h:440
ubmatrix & get_wgts()
Get a reference to the full matrix of data.
Definition: hist_2d.h:356
generic failure
Definition: err_hnd.h:61
const vec_t & get_column(std::string scol) const
Returns a reference to the column named col. .
Definition: table.h:619
bool extend_lhs
If true, allow abcissa smaller than smallest bin limit to correspond to the lowest bin (default false...
Definition: hist_2d.h:262
const ubvector & get_x_bins() const
Get a reference to the full vector of bin specifications.
Definition: hist_2d.h:481
bool extend_rhs
If true, allow abcissa larger than largest bin limit to correspond to the highest bin (default false)...
Definition: hist_2d.h:257
ubvector xrep
"Central" values for x-axis (N)
Definition: hist_2d.h:122
void update(double x, double y, double val=1.0)
Increment bin for x by value val.
Definition: hist_2d.h:312
#define O2SCL_ERR2(d, d2, n)
Set an error, two-string version.
Definition: err_hnd.h:281
ubmatrix wgt
Values (Nx,Ny)
Definition: hist_2d.h:119
void set_bin_edges(size_t nx, vec_t &vx, size_t ny, vec_t &vy)
Set the bins from a vector.
Definition: hist_2d.h:284
The O<span style=&#39;position: relative; top: 0.3em; font-size: 0.8em&#39;>2</span>scl O$_2$scl namespace ...
Definition: table.h:53
void vector_minmax_value(size_t n, vec_t &data, data_t &min, data_t &max)
Compute the minimum and maximum of the first n elements of a vector.
Definition: vector.h:1229
ubvector user_yrep
User-defined central values for y-axis (N)
Definition: hist_2d.h:131
size_t xrmode
Rep mode for x.
Definition: hist_2d.h:140
#define O2SCL_ERR(d, n)
Set an error with message d and code n.
Definition: err_hnd.h:273
const ubvector & get_user_reps_x() const
Get a reference to the user-specified reps for x coordinates.
Definition: hist_2d.h:511
void update_i(size_t i, size_t j, double val=1.0)
Increment bin at (i,j) by value val.
Definition: hist_2d.h:306
A class representing a uniform linear or logarithmic grid.
Definition: uniform_grid.h:38
A data structure containing many slices of two-dimensional data points defined on a grid...
Definition: table3d.h:78
Store data in an O<span style=&#39;position: relative; top: 0.3em; font-size: 0.8em&#39;>2</span>scl O$_2$sc...
Definition: hdf_file.h:96
size_t get_x_rep_mode() const
Get mode used to compute bin reps.
Definition: hist_2d.h:471
const double & get_wgt(double x, double y) const
Return contents of bin for x.
Definition: hist_2d.h:323
double & get_wgt(double x, double y)
Return contents of bin for x.
Definition: hist_2d.h:333
ubvector user_xrep
User-defined central values for x-axis (N)
Definition: hist_2d.h:128
std::string itos(int x)
Convert an integer to a string.
size_t hsize_x
Number of x-bins.
Definition: hist_2d.h:134
void hdf_input(hdf_file &hf, o2scl::table< vec_t > &t, std::string name)
Input a o2scl::table object from a hdf_file.
Definition: hdf_io.h:59
size_t yrmode
Rep mode for y.
Definition: hist_2d.h:143
Linear grid with fixed number of bins and fixed endpoint.
Definition: uniform_grid.h:315

Documentation generated with Doxygen. Provided under the GNU Free Documentation License (see License Information).