casacore
ExprGroupAggrFuncArray.h
Go to the documentation of this file.
1 //# ExprGroupAggrFuncArray.h: The various array reduction aggregation functions
2 //# Copyright (C) 2013
3 //# Associated Universities, Inc. Washington DC, USA.
4 //#
5 //# This library is free software; you can redistribute it and/or modify it
6 //# under the terms of the GNU Library General Public License as published by
7 //# the Free Software Foundation; either version 2 of the License, or (at your
8 //# option) any later version.
9 //#
10 //# This library is distributed in the hope that it will be useful, but WITHOUT
11 //# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
12 //# FITNESS FOR A PARTICULAR PURPOSE. See the GNU Library General Public
13 //# License for more details.
14 //#
15 //# You should have received a copy of the GNU Library General Public License
16 //# along with this library; if not, write to the Free Software Foundation,
17 //# Inc., 675 Massachusetts Ave, Cambridge, MA 02139, USA.
18 //#
19 //# Correspondence concerning AIPS++ should be addressed as follows:
20 //# Internet email: aips2-request@nrao.edu.
21 //# Postal address: AIPS++ Project Office
22 //# National Radio Astronomy Observatory
23 //# 520 Edgemont Road
24 //# Charlottesville, VA 22903-2475 USA
25 //#
26 //# $Id: TaQLNode.h 21051 2011-04-20 11:46:29Z gervandiepen $
27 
28 #ifndef TABLES_EXPRGROUPAGGRFUNCARRAY_H
29 #define TABLES_EXPRGROUPAGGRFUNCARRAY_H
30 
31 //# Includes
32 #include <casacore/casa/aips.h>
33 #include <casacore/tables/TaQL/ExprGroup.h>
34 #include <vector>
35 
36 
37 namespace casacore { //# NAMESPACE CASACORE - BEGIN
38 
39 
40  // <summary>
41  // Aggregate class counting if any array value in a group is true
42  // </summary>
43  // <use visibility=local>
44  // <reviewed reviewer="" date="" tests="tExprGroup">
45  // </reviewed>
46  // <synopsis>
47  // Aggregate class counting if any array value in a group is true.
48  // </synopsis>
50  {
51  public:
54  virtual void apply (const TableExprId& id);
55  };
56 
57  // <summary>
58  // Aggregate class counting if all array values in a group are true
59  // </summary>
60  // <use visibility=local>
61  // <reviewed reviewer="" date="" tests="tExprGroup">
62  // </reviewed>
63  // <synopsis>
64  // Aggregate class counting if all array values in a group are true.
65  // </synopsis>
67  {
68  public:
71  virtual void apply (const TableExprId& id);
72  };
73 
74  // <summary>
75  // Aggregate class counting the number of true array values in a group
76  // </summary>
77  // <use visibility=local>
78  // <reviewed reviewer="" date="" tests="tExprGroup">
79  // </reviewed>
80  // <synopsis>
81  // Aggregate class counting the number of true array values in a group.
82  // </synopsis>
84  {
85  public:
88  virtual void apply (const TableExprId& id);
89  };
90 
91  // <summary>
92  // Aggregate class counting the number of false array values in a group
93  // </summary>
94  // <use visibility=local>
95  // <reviewed reviewer="" date="" tests="tExprGroup">
96  // </reviewed>
97  // <synopsis>
98  // Aggregate class counting the number of false array values in a group.
99  // </synopsis>
101  {
102  public:
105  virtual void apply (const TableExprId& id);
106  };
107 
108 
109  // <summary>
110  // Aggregate class determining the minimum integer array value in a group
111  // </summary>
112  // <use visibility=local>
113  // <reviewed reviewer="" date="" tests="tExprGroup">
114  // </reviewed>
115  // <synopsis>
116  // Aggregate class determining the minimum integer array value in a group.
117  // </synopsis>
119  {
120  public:
123  virtual void apply (const TableExprId& id);
124  };
125 
126  // <summary>
127  // Aggregate class determining the maximum integer array value in a group
128  // </summary>
129  // <use visibility=local>
130  // <reviewed reviewer="" date="" tests="tExprGroup">
131  // </reviewed>
132  // <synopsis>
133  // Aggregate class determining the maximum integer array value in a group.
134  // </synopsis>
136  {
137  public:
140  virtual void apply (const TableExprId& id);
141  };
142 
143  // <summary>
144  // Aggregate class determining the sum of integer array values in a group
145  // </summary>
146  // <use visibility=local>
147  // <reviewed reviewer="" date="" tests="tExprGroup">
148  // </reviewed>
149  // <synopsis>
150  // Aggregate class determining the sum of integer array values in a group.
151  // </synopsis>
153  {
154  public:
157  virtual void apply (const TableExprId& id);
158  };
159 
160  // <summary>
161  // Aggregate class determining the product of integer array values in a group
162  // </summary>
163  // <use visibility=local>
164  // <reviewed reviewer="" date="" tests="tExprGroup">
165  // </reviewed>
166  // <synopsis>
167  // Aggregate class determining the product of integer array values in a group.
168  // </synopsis>
170  {
171  public:
174  virtual void apply (const TableExprId& id);
175  };
176 
177  // <summary>
178  // Aggregate class determining the sum of squares of integer array values
179  // in a group
180  // </summary>
181  // <use visibility=local>
182  // <reviewed reviewer="" date="" tests="tExprGroup">
183  // </reviewed>
184  // <synopsis>
185  // Aggregate class determining the sum of squares of integer array values
186  // in a group.
187  // </synopsis>
189  {
190  public:
193  virtual void apply (const TableExprId& id);
194  };
195 
196 
197  // <summary>
198  // Aggregate class determining the minimum double array value in a group
199  // </summary>
200  // <use visibility=local>
201  // <reviewed reviewer="" date="" tests="tExprGroup">
202  // </reviewed>
203  // <synopsis>
204  // Aggregate class determining the minimum double array value in a group.
205  // </synopsis>
207  {
208  public:
211  virtual void apply (const TableExprId& id);
212  };
213 
214  // <summary>
215  // Aggregate class determining the maximum double array value in a group
216  // </summary>
217  // <use visibility=local>
218  // <reviewed reviewer="" date="" tests="tExprGroup">
219  // </reviewed>
220  // <synopsis>
221  // Aggregate class determining the maximum double array value in a group.
222  // </synopsis>
224  {
225  public:
228  virtual void apply (const TableExprId& id);
229  };
230 
231  // <summary>
232  // Aggregate class determining the sum of double array values in a group
233  // </summary>
234  // <use visibility=local>
235  // <reviewed reviewer="" date="" tests="tExprGroup">
236  // </reviewed>
237  // <synopsis>
238  // Aggregate class determining the sum of double array values in a group.
239  // </synopsis>
241  {
242  public:
245  virtual void apply (const TableExprId& id);
246  };
247 
248  // <summary>
249  // Aggregate class determining the product of double array values in a group
250  // </summary>
251  // <use visibility=local>
252  // <reviewed reviewer="" date="" tests="tExprGroup">
253  // </reviewed>
254  // <synopsis>
255  // Aggregate class determining the product of double array values in a group.
256  // </synopsis>
258  {
259  public:
262  virtual void apply (const TableExprId& id);
263  };
264 
265  // <summary>
266  // Aggregate class determining the sum of squares of double array values
267  // in a group
268  // </summary>
269  // <use visibility=local>
270  // <reviewed reviewer="" date="" tests="tExprGroup">
271  // </reviewed>
272  // <synopsis>
273  // Aggregate class determining the sum of squares of double array values
274  // in a group.
275  // </synopsis>
277  {
278  public:
281  virtual void apply (const TableExprId& id);
282  };
283 
284  // <summary>
285  // Aggregate class determining the mean of array values in a group
286  // </summary>
287  // <use visibility=local>
288  // <reviewed reviewer="" date="" tests="tExprGroup">
289  // </reviewed>
290  // <synopsis>
291  // Aggregate class determining the mean of array values in a group.
292  // </synopsis>
294  {
295  public:
298  virtual void apply (const TableExprId& id);
299  virtual void finish();
300  private:
302  };
303 
304  // <summary>
305  // Aggregate class determining the variance of array values in a group
306  // </summary>
307  // <use visibility=local>
308  // <reviewed reviewer="" date="" tests="tExprGroup">
309  // </reviewed>
310  // <synopsis>
311  // Aggregate class determining the variance of array values in a group.
312  // It uses a running algorithm
313  // (see en.wikipedia.org/wiki/Algorithms_for_calculating_variance)
314  // </synopsis>
316  {
317  public:
320  virtual void apply (const TableExprId& id);
321  virtual void finish();
322  protected:
326  };
327 
328  // <summary>
329  // Aggregate class determining the standard devation of array values
330  // in a group
331  // </summary>
332  // <use visibility=local>
333  // <reviewed reviewer="" date="" tests="tExprGroup">
334  // </reviewed>
335  // <synopsis>
336  // Aggregate class determining the standard deviation of array values
337  // in a group. It uses a running algorithm
338  // (see en.wikipedia.org/wiki/Algorithms_for_calculating_variance)
339  // </synopsis>
341  {
342  public:
345  virtual void finish();
346  };
347 
348  // <summary>
349  // Aggregate class determining the RMS of array values in a group
350  // </summary>
351  // <use visibility=local>
352  // <reviewed reviewer="" date="" tests="tExprGroup">
353  // </reviewed>
354  // <synopsis>
355  // Aggregate class determining the RMS of array values in a group.
356  // </synopsis>
358  {
359  public:
362  virtual void apply (const TableExprId& id);
363  virtual void finish();
364  private:
366  };
367 
368  // <summary>
369  // Aggregate class determining the fractile of array values in a group
370  // </summary>
371  // <use visibility=local>
372  // <reviewed reviewer="" date="" tests="tExprGroup">
373  // </reviewed>
374  // <synopsis>
375  // Aggregate class determining the fractile of array values in a group.
376  // <br>It is a lazy aggregate class, thus <src>apply</src> does nothing.
377  // Instead, <src>getDouble</src> assembles the values and determines the
378  // fractile.
379  // </synopsis>
381  {
382  public:
384  Double fractile);
386  virtual Bool isLazy() const;
387  virtual void apply (const TableExprId& id);
388  virtual Double getDouble (const vector<TableExprId>& ids);
389  private:
391  };
392 
393 
394  // <summary>
395  // Aggregate class determining the sum of complex array values in a group
396  // </summary>
397  // <use visibility=local>
398  // <reviewed reviewer="" date="" tests="tExprGroup">
399  // </reviewed>
400  // <synopsis>
401  // Aggregate class determining the sum of complex array values in a group.
402  // </synopsis>
404  {
405  public:
408  virtual void apply (const TableExprId& id);
409  };
410 
411  // <summary>
412  // Aggregate class determining the product of complex array values in a group
413  // </summary>
414  // <use visibility=local>
415  // <reviewed reviewer="" date="" tests="tExprGroup">
416  // </reviewed>
417  // <synopsis>
418  // Aggregate class determining the product of complex array values in a group.
419  // </synopsis>
421  {
422  public:
425  virtual void apply (const TableExprId& id);
426  };
427 
428  // <summary>
429  // Aggregate class determining the sum of squares of complex array values
430  // in a group
431  // </summary>
432  // <use visibility=local>
433  // <reviewed reviewer="" date="" tests="tExprGroup">
434  // </reviewed>
435  // <synopsis>
436  // Aggregate class determining the sum of squares of complex array values
437  // in a group.
438  // </synopsis>
440  {
441  public:
444  virtual void apply (const TableExprId& id);
445  };
446 
447  // <summary>
448  // Aggregate class determining the mean of complex array values in a group
449  // </summary>
450  // <use visibility=local>
451  // <reviewed reviewer="" date="" tests="tExprGroup">
452  // </reviewed>
453  // <synopsis>
454  // Aggregate class determining the mean of complex array values in a group.
455  // </synopsis>
457  {
458  public:
461  virtual void apply (const TableExprId& id);
462  virtual void finish();
463  private:
465  };
466 
467  // <summary>
468  // Aggregate class determining the variance of array values in a group
469  // </summary>
470  // <use visibility=local>
471  // <reviewed reviewer="" date="" tests="tExprGroup">
472  // </reviewed>
473  // <synopsis>
474  // Aggregate class determining the variance of array values in a group.
475  // It uses a running algorithm
476  // (see en.wikipedia.org/wiki/Algorithms_for_calculating_variance)
477  // Note that the result is a Double value (not DComplex).
478  // </synopsis>
480  {
481  public:
484  virtual void apply (const TableExprId& id);
485  virtual void finish();
486  protected:
490  };
491 
492  // <summary>
493  // Aggregate class determining the standard devation of array values
494  // in a group
495  // </summary>
496  // <use visibility=local>
497  // <reviewed reviewer="" date="" tests="tExprGroup">
498  // </reviewed>
499  // <synopsis>
500  // Aggregate class determining the standard deviation of array values
501  // in a group. It uses a running algorithm
502  // (see en.wikipedia.org/wiki/Algorithms_for_calculating_variance)
503  // </synopsis>
505  {
506  public:
509  virtual void finish();
510  };
511 
512  // <summary>
513  // Aggregate class counting per array index in a group if any is true
514  // </summary>
515  // <use visibility=local>
516  // <reviewed reviewer="" date="" tests="tExprGroup">
517  // </reviewed>
518  // <synopsis>
519  // Aggregate class counting per array index in a group if any is true.
520  // </synopsis>
522  {
523  public:
526  virtual void apply (const TableExprId& id);
527  };
528 
529  // <summary>
530  // Aggregate class counting per array index in a group if all are true
531  // </summary>
532  // <use visibility=local>
533  // <reviewed reviewer="" date="" tests="tExprGroup">
534  // </reviewed>
535  // <synopsis>
536  // Aggregate class counting per array index in a group if all are true.
537  // </synopsis>
539  {
540  public:
543  virtual void apply (const TableExprId& id);
544  };
545 
546  // <summary>
547  // Aggregate class counting per array index in a group the nr of true values
548  // </summary>
549  // <use visibility=local>
550  // <reviewed reviewer="" date="" tests="tExprGroup">
551  // </reviewed>
552  // <synopsis>
553  // Aggregate class counting per array index in a group the nr of true values.
554  // </synopsis>
556  {
557  public:
560  virtual void apply (const TableExprId& id);
561  };
562 
563  // <summary>
564  // Aggregate class counting per array index in a group the nr of false values
565  // </summary>
566  // <use visibility=local>
567  // <reviewed reviewer="" date="" tests="tExprGroup">
568  // </reviewed>
569  // <synopsis>
570  // Aggregate class counting per array index in a group the nr of false values.
571  // </synopsis>
573  {
574  public:
577  virtual void apply (const TableExprId& id);
578  };
579 
580  // <summary>
581  // Aggregate class determining per array index in a group the minimum value
582  // </summary>
583  // <use visibility=local>
584  // <reviewed reviewer="" date="" tests="tExprGroup">
585  // </reviewed>
586  // <synopsis>
587  // Aggregate class determining per array index in a group the minimum value.
588  // </synopsis>
590  {
591  public:
594  virtual void apply (const TableExprId& id);
595  virtual void finish();
596  };
597 
598  // <summary>
599  // Aggregate class determining per array index in a group the maximum value
600  // </summary>
601  // <use visibility=local>
602  // <reviewed reviewer="" date="" tests="tExprGroup">
603  // </reviewed>
604  // <synopsis>
605  // Aggregate class determining per array index in a group the maximum value.
606  // </synopsis>
608  {
609  public:
612  virtual void apply (const TableExprId& id);
613  virtual void finish();
614  };
615 
616  // <summary>
617  // Aggregate class determining per array index in a group the sum of values
618  // </summary>
619  // <use visibility=local>
620  // <reviewed reviewer="" date="" tests="tExprGroup">
621  // </reviewed>
622  // <synopsis>
623  // Aggregate class determining per array index in a group the sum of values.
624  // </synopsis>
626  {
627  public:
630  virtual void apply (const TableExprId& id);
631  };
632 
633  // <summary>
634  // Aggregate class determining per array index in a group the product of values
635  // </summary>
636  // <use visibility=local>
637  // <reviewed reviewer="" date="" tests="tExprGroup">
638  // </reviewed>
639  // <synopsis>
640  // Aggregate class determining per array index in a group the product of values.
641  // </synopsis>
643  {
644  public:
647  virtual void apply (const TableExprId& id);
648  virtual void finish();
649  };
650 
651  // <summary>
652  // Aggregate class determining per array index in a group the sum of value squares
653  // in a group
654  // </summary>
655  // <use visibility=local>
656  // <reviewed reviewer="" date="" tests="tExprGroup">
657  // </reviewed>
658  // <synopsis>
659  // Aggregate class determining per array index in a group the sum of value squares.
660  // </synopsis>
662  {
663  public:
666  virtual void apply (const TableExprId& id);
667  };
668 
669 
670  // <summary>
671  // Aggregate class determining the minimum double array value in a group
672  // </summary>
673  // <use visibility=local>
674  // <reviewed reviewer="" date="" tests="tExprGroup">
675  // </reviewed>
676  // <synopsis>
677  // Aggregate class determining the minimum double array value in a group.
678  // </synopsis>
680  {
681  public:
684  virtual void apply (const TableExprId& id);
685  virtual void finish();
686  };
687 
688  // <summary>
689  // Aggregate class determining the maximum double array value in a group
690  // </summary>
691  // <use visibility=local>
692  // <reviewed reviewer="" date="" tests="tExprGroup">
693  // </reviewed>
694  // <synopsis>
695  // Aggregate class determining the maximum double array value in a group.
696  // </synopsis>
698  {
699  public:
702  virtual void apply (const TableExprId& id);
703  virtual void finish();
704  };
705 
706  // <summary>
707  // Aggregate class determining the sum of double array values in a group
708  // </summary>
709  // <use visibility=local>
710  // <reviewed reviewer="" date="" tests="tExprGroup">
711  // </reviewed>
712  // <synopsis>
713  // Aggregate class determining the sum of double array values in a group.
714  // </synopsis>
716  {
717  public:
720  virtual void apply (const TableExprId& id);
721  };
722 
723  // <summary>
724  // Aggregate class determining the product of double array values in a group
725  // </summary>
726  // <use visibility=local>
727  // <reviewed reviewer="" date="" tests="tExprGroup">
728  // </reviewed>
729  // <synopsis>
730  // Aggregate class determining the product of double array values in a group.
731  // </synopsis>
733  {
734  public:
737  virtual void apply (const TableExprId& id);
738  virtual void finish();
739  };
740 
741  // <summary>
742  // Aggregate class determining the sum of squares of double array values
743  // in a group
744  // </summary>
745  // <use visibility=local>
746  // <reviewed reviewer="" date="" tests="tExprGroup">
747  // </reviewed>
748  // <synopsis>
749  // Aggregate class determining the sum of squares of double array values
750  // in a group.
751  // </synopsis>
753  {
754  public:
757  virtual void apply (const TableExprId& id);
758  };
759 
760  // <summary>
761  // Aggregate class determining the mean of array values in a group
762  // </summary>
763  // <use visibility=local>
764  // <reviewed reviewer="" date="" tests="tExprGroup">
765  // </reviewed>
766  // <synopsis>
767  // Aggregate class determining the mean of array values in a group.
768  // </synopsis>
770  {
771  public:
774  virtual void apply (const TableExprId& id);
775  virtual void finish();
776  private:
778  };
779 
780  // <summary>
781  // Aggregate class determining the variance of array values in a group
782  // </summary>
783  // <use visibility=local>
784  // <reviewed reviewer="" date="" tests="tExprGroup">
785  // </reviewed>
786  // <synopsis>
787  // Aggregate class determining the variance of array values in a group.
788  // It uses a running algorithm
789  // (see en.wikipedia.org/wiki/Algorithms_for_calculating_variance)
790  // </synopsis>
792  {
793  public:
796  virtual void apply (const TableExprId& id);
797  virtual void finish();
798  protected:
802  };
803 
804  // <summary>
805  // Aggregate class determining the standard devation of array values
806  // in a group
807  // </summary>
808  // <use visibility=local>
809  // <reviewed reviewer="" date="" tests="tExprGroup">
810  // </reviewed>
811  // <synopsis>
812  // Aggregate class determining the standard deviation of array values
813  // in a group. It uses a running algorithm
814  // (see en.wikipedia.org/wiki/Algorithms_for_calculating_variance)
815  // </synopsis>
817  {
818  public:
821  virtual void finish();
822  };
823 
824  // <summary>
825  // Aggregate class determining the RMS of array values in a group
826  // </summary>
827  // <use visibility=local>
828  // <reviewed reviewer="" date="" tests="tExprGroup">
829  // </reviewed>
830  // <synopsis>
831  // Aggregate class determining the RMS of array values in a group.
832  // </synopsis>
834  {
835  public:
838  virtual void apply (const TableExprId& id);
839  virtual void finish();
840  private:
842  };
843 
844 
845  // <summary>
846  // Aggregate class determining the sum of complex array values in a group
847  // </summary>
848  // <use visibility=local>
849  // <reviewed reviewer="" date="" tests="tExprGroup">
850  // </reviewed>
851  // <synopsis>
852  // Aggregate class determining the sum of complex array values in a group.
853  // </synopsis>
855  {
856  public:
859  virtual void apply (const TableExprId& id);
860  };
861 
862  // <summary>
863  // Aggregate class determining the product of complex array values in a group
864  // </summary>
865  // <use visibility=local>
866  // <reviewed reviewer="" date="" tests="tExprGroup">
867  // </reviewed>
868  // <synopsis>
869  // Aggregate class determining the product of complex array values in a group.
870  // </synopsis>
872  {
873  public:
876  virtual void apply (const TableExprId& id);
877  virtual void finish();
878  };
879 
880  // <summary>
881  // Aggregate class determining the sum of squares of complex array values
882  // in a group
883  // </summary>
884  // <use visibility=local>
885  // <reviewed reviewer="" date="" tests="tExprGroup">
886  // </reviewed>
887  // <synopsis>
888  // Aggregate class determining the sum of squares of complex array values
889  // in a group.
890  // </synopsis>
892  {
893  public:
896  virtual void apply (const TableExprId& id);
897  };
898 
899  // <summary>
900  // Aggregate class determining the mean of complex array values in a group
901  // </summary>
902  // <use visibility=local>
903  // <reviewed reviewer="" date="" tests="tExprGroup">
904  // </reviewed>
905  // <synopsis>
906  // Aggregate class determining the mean of complex array values in a group.
907  // </synopsis>
909  {
910  public:
913  virtual void apply (const TableExprId& id);
914  virtual void finish();
915  private:
917  };
918 
919  // <summary>
920  // Aggregate class determining the variance of array values in a group
921  // </summary>
922  // <use visibility=local>
923  // <reviewed reviewer="" date="" tests="tExprGroup">
924  // </reviewed>
925  // <synopsis>
926  // Aggregate class determining the variance of array values in a group.
927  // It uses a running algorithm
928  // (see en.wikipedia.org/wiki/Algorithms_for_calculating_variance)
929  // Note that result is a Double value (npot DComplex).
930  // </synopsis>
932  {
933  public:
936  virtual void apply (const TableExprId& id);
937  virtual void finish();
938  protected:
942  };
943 
944  // <summary>
945  // Aggregate class determining the standard devation of array values
946  // in a group
947  // </summary>
948  // <use visibility=local>
949  // <reviewed reviewer="" date="" tests="tExprGroup">
950  // </reviewed>
951  // <synopsis>
952  // Aggregate class determining the standard deviation of array values
953  // in a group. It uses a running algorithm
954  // (see en.wikipedia.org/wiki/Algorithms_for_calculating_variance)
955  // </synopsis>
957  {
958  public:
961  virtual void finish();
962  };
963 
964 
965  // <summary>
966  // Base aggregate class determining the histogram of values in a group
967  // </summary>
968  // <use visibility=local>
969  // <reviewed reviewer="" date="" tests="tExprGroup">
970  // </reviewed>
971  // <synopsis>
972  // Base aggregate class determining the histogram of values in a group
973  // </synopsis>
975  {
976  public:
978  Int64 nbin, Double start, Double end);
980  virtual MArray<Int64> getArrayInt (const vector<TableExprId>&);
981  protected:
982  // Add the value to the histogram.
983  void add (Double value);
984  private:
988  };
989 
990  // <summary>
991  // Aggregate class determining the histogram of scalar values in a group
992  // </summary>
993  // <use visibility=local>
994  // <reviewed reviewer="" date="" tests="tExprGroup">
995  // </reviewed>
996  // <synopsis>
997  // Aggregate class determining the histogram of scalar values in a group
998  // </synopsis>
1000  {
1001  public:
1003  Int64 nbin, Double start, Double end);
1005  virtual void apply (const TableExprId& id);
1006  };
1007 
1008  // <summary>
1009  // Aggregate class determining the histogram of integer array values in a group
1010  // </summary>
1011  // <use visibility=local>
1012  // <reviewed reviewer="" date="" tests="tExprGroup">
1013  // </reviewed>
1014  // <synopsis>
1015  // Aggregate class determining the histogram of integer array values in a group
1016  // </synopsis>
1018  {
1019  public:
1021  Int64 nbin, Double start, Double end);
1023  virtual void apply (const TableExprId& id);
1024  };
1025 
1026  // <summary>
1027  // Aggregate class determining the histogram of double array values in a group
1028  // </summary>
1029  // <use visibility=local>
1030  // <reviewed reviewer="" date="" tests="tExprGroup">
1031  // </reviewed>
1032  // <synopsis>
1033  // Aggregate class determining the histogram of double array values in a group
1034  // </synopsis>
1036  {
1037  public:
1039  Int64 nbin, Double start, Double end);
1041  virtual void apply (const TableExprId& id);
1042  };
1043 
1044 
1045 } //# NAMESPACE CASACORE - END
1046 
1047 #endif
Aggregate class counting if all array values in a group are true.
TableExprGroupArrayAll(TableExprNodeRep *node)
virtual void apply(const TableExprId &id)
Get the operand's value for the given row and apply it to the aggregation.
Aggregate class counting per array index in a group if all are true.
TableExprGroupArrayAlls(TableExprNodeRep *node)
virtual void apply(const TableExprId &id)
Get the operand's value for the given row and apply it to the aggregation.
TableExprGroupArrayAny(TableExprNodeRep *node)
virtual void apply(const TableExprId &id)
Get the operand's value for the given row and apply it to the aggregation.
Aggregate class counting per array index in a group if any is true.
virtual void apply(const TableExprId &id)
Get the operand's value for the given row and apply it to the aggregation.
TableExprGroupArrayAnys(TableExprNodeRep *node)
Aggregate class counting the number of false array values in a group.
TableExprGroupArrayNFalse(TableExprNodeRep *node)
virtual void apply(const TableExprId &id)
Get the operand's value for the given row and apply it to the aggregation.
Aggregate class counting per array index in a group the nr of false values.
virtual void apply(const TableExprId &id)
Get the operand's value for the given row and apply it to the aggregation.
TableExprGroupArrayNFalses(TableExprNodeRep *node)
Aggregate class counting the number of true array values in a group.
virtual void apply(const TableExprId &id)
Get the operand's value for the given row and apply it to the aggregation.
TableExprGroupArrayNTrue(TableExprNodeRep *node)
Aggregate class counting per array index in a group the nr of true values.
virtual void apply(const TableExprId &id)
Get the operand's value for the given row and apply it to the aggregation.
TableExprGroupArrayNTrues(TableExprNodeRep *node)
Aggregate class determining the fractile of array values in a group.
TableExprGroupFractileArrayDouble(TableExprNodeRep *node, Double fractile)
virtual Bool isLazy() const
Does the aggregate function use lazy semantics? The default implementation returns False.
virtual Double getDouble(const vector< TableExprId > &ids)
virtual void apply(const TableExprId &id)
Get the operand's value for the given row and apply it to the aggregation.
Abstract base class for aggregate functions giving a bool array.
Definition: ExprGroup.h:634
Abstract base class for aggregate functions giving a dcomplex array.
Definition: ExprGroup.h:718
Abstract base class for aggregate functions giving a double array.
Definition: ExprGroup.h:690
Abstract base class for aggregate functions giving an integer array.
Definition: ExprGroup.h:662
Abstract base class for classes calculating an aggregated group result.
Definition: ExprGroup.h:202
Abstract base class for aggregate functions giving a bool scalar.
Definition: ExprGroup.h:470
Abstract base class for aggregate functions giving a dcomplex scalar.
Definition: ExprGroup.h:553
Abstract base class for aggregate functions giving a double scalar.
Definition: ExprGroup.h:526
Abstract base class for aggregate functions giving an integer scalar.
Definition: ExprGroup.h:499
Base aggregate class determining the histogram of values in a group.
TableExprGroupHistBase(TableExprNodeRep *node, Int64 nbin, Double start, Double end)
virtual MArray< Int64 > getArrayInt(const vector< TableExprId > &)
void add(Double value)
Add the value to the histogram.
Aggregate class determining the histogram of double array values in a group.
TableExprGroupHistDouble(TableExprNodeRep *node, Int64 nbin, Double start, Double end)
virtual void apply(const TableExprId &id)
Get the operand's value for the given row and apply it to the aggregation.
Aggregate class determining the histogram of integer array values in a group.
TableExprGroupHistInt(TableExprNodeRep *node, Int64 nbin, Double start, Double end)
virtual void apply(const TableExprId &id)
Get the operand's value for the given row and apply it to the aggregation.
Aggregate class determining the histogram of scalar values in a group.
virtual void apply(const TableExprId &id)
Get the operand's value for the given row and apply it to the aggregation.
TableExprGroupHistScalar(TableExprNodeRep *node, Int64 nbin, Double start, Double end)
Aggregate class determining the maximum double array value in a group.
virtual void apply(const TableExprId &id)
Get the operand's value for the given row and apply it to the aggregation.
TableExprGroupMaxArrayDouble(TableExprNodeRep *node)
Aggregate class determining the maximum integer array value in a group.
TableExprGroupMaxArrayInt(TableExprNodeRep *node)
virtual void apply(const TableExprId &id)
Get the operand's value for the given row and apply it to the aggregation.
Aggregate class determining the maximum double array value in a group.
TableExprGroupMaxsArrayDouble(TableExprNodeRep *node)
virtual void finish()
If needed, finish the aggregation.
virtual void apply(const TableExprId &id)
Get the operand's value for the given row and apply it to the aggregation.
Aggregate class determining per array index in a group the maximum value.
virtual void finish()
If needed, finish the aggregation.
virtual void apply(const TableExprId &id)
Get the operand's value for the given row and apply it to the aggregation.
TableExprGroupMaxsArrayInt(TableExprNodeRep *node)
Aggregate class determining the mean of complex array values in a group.
TableExprGroupMeanArrayDComplex(TableExprNodeRep *node)
virtual void finish()
If needed, finish the aggregation.
virtual void apply(const TableExprId &id)
Get the operand's value for the given row and apply it to the aggregation.
Aggregate class determining the mean of array values in a group.
virtual void apply(const TableExprId &id)
Get the operand's value for the given row and apply it to the aggregation.
virtual void finish()
If needed, finish the aggregation.
TableExprGroupMeanArrayDouble(TableExprNodeRep *node)
Aggregate class determining the mean of complex array values in a group.
TableExprGroupMeansArrayDComplex(TableExprNodeRep *node)
virtual void finish()
If needed, finish the aggregation.
virtual void apply(const TableExprId &id)
Get the operand's value for the given row and apply it to the aggregation.
Aggregate class determining the mean of array values in a group.
TableExprGroupMeansArrayDouble(TableExprNodeRep *node)
virtual void finish()
If needed, finish the aggregation.
virtual void apply(const TableExprId &id)
Get the operand's value for the given row and apply it to the aggregation.
Aggregate class determining the minimum double array value in a group.
TableExprGroupMinArrayDouble(TableExprNodeRep *node)
virtual void apply(const TableExprId &id)
Get the operand's value for the given row and apply it to the aggregation.
Aggregate class determining the minimum integer array value in a group.
virtual void apply(const TableExprId &id)
Get the operand's value for the given row and apply it to the aggregation.
TableExprGroupMinArrayInt(TableExprNodeRep *node)
Aggregate class determining the minimum double array value in a group.
virtual void finish()
If needed, finish the aggregation.
TableExprGroupMinsArrayDouble(TableExprNodeRep *node)
virtual void apply(const TableExprId &id)
Get the operand's value for the given row and apply it to the aggregation.
Aggregate class determining per array index in a group the minimum value.
virtual void finish()
If needed, finish the aggregation.
TableExprGroupMinsArrayInt(TableExprNodeRep *node)
virtual void apply(const TableExprId &id)
Get the operand's value for the given row and apply it to the aggregation.
Aggregate class determining the product of complex array values in a group.
virtual void apply(const TableExprId &id)
Get the operand's value for the given row and apply it to the aggregation.
TableExprGroupProductArrayDComplex(TableExprNodeRep *node)
Aggregate class determining the product of double array values in a group.
virtual void apply(const TableExprId &id)
Get the operand's value for the given row and apply it to the aggregation.
TableExprGroupProductArrayDouble(TableExprNodeRep *node)
Aggregate class determining the product of integer array values in a group.
TableExprGroupProductArrayInt(TableExprNodeRep *node)
virtual void apply(const TableExprId &id)
Get the operand's value for the given row and apply it to the aggregation.
Aggregate class determining the product of complex array values in a group.
TableExprGroupProductsArrayDComplex(TableExprNodeRep *node)
virtual void finish()
If needed, finish the aggregation.
virtual void apply(const TableExprId &id)
Get the operand's value for the given row and apply it to the aggregation.
Aggregate class determining the product of double array values in a group.
TableExprGroupProductsArrayDouble(TableExprNodeRep *node)
virtual void apply(const TableExprId &id)
Get the operand's value for the given row and apply it to the aggregation.
virtual void finish()
If needed, finish the aggregation.
Aggregate class determining per array index in a group the product of values.
virtual void finish()
If needed, finish the aggregation.
virtual void apply(const TableExprId &id)
Get the operand's value for the given row and apply it to the aggregation.
TableExprGroupProductsArrayInt(TableExprNodeRep *node)
Aggregate class determining the RMS of array values in a group.
virtual void apply(const TableExprId &id)
Get the operand's value for the given row and apply it to the aggregation.
TableExprGroupRmsArrayDouble(TableExprNodeRep *node)
virtual void finish()
If needed, finish the aggregation.
Aggregate class determining the RMS of array values in a group.
virtual void finish()
If needed, finish the aggregation.
virtual void apply(const TableExprId &id)
Get the operand's value for the given row and apply it to the aggregation.
TableExprGroupRmssArrayDouble(TableExprNodeRep *node)
Aggregate class determining the standard devation of array values in a group.
virtual void finish()
If needed, finish the aggregation.
TableExprGroupStdDevArrayDComplex(TableExprNodeRep *node, uInt ddof)
Aggregate class determining the standard devation of array values in a group.
virtual void finish()
If needed, finish the aggregation.
TableExprGroupStdDevArrayDouble(TableExprNodeRep *node, uInt ddof)
Aggregate class determining the standard devation of array values in a group.
TableExprGroupStdDevsArrayDComplex(TableExprNodeRep *node, uInt ddof)
virtual void finish()
If needed, finish the aggregation.
Aggregate class determining the standard devation of array values in a group.
virtual void finish()
If needed, finish the aggregation.
TableExprGroupStdDevsArrayDouble(TableExprNodeRep *node, uInt ddof)
Aggregate class determining the sum of complex array values in a group.
virtual void apply(const TableExprId &id)
Get the operand's value for the given row and apply it to the aggregation.
TableExprGroupSumArrayDComplex(TableExprNodeRep *node)
Aggregate class determining the sum of double array values in a group.
TableExprGroupSumArrayDouble(TableExprNodeRep *node)
virtual void apply(const TableExprId &id)
Get the operand's value for the given row and apply it to the aggregation.
Aggregate class determining the sum of integer array values in a group.
virtual void apply(const TableExprId &id)
Get the operand's value for the given row and apply it to the aggregation.
TableExprGroupSumArrayInt(TableExprNodeRep *node)
Aggregate class determining the sum of squares of complex array values in a group.
virtual void apply(const TableExprId &id)
Get the operand's value for the given row and apply it to the aggregation.
TableExprGroupSumSqrArrayDComplex(TableExprNodeRep *node)
Aggregate class determining the sum of squares of double array values in a group.
virtual void apply(const TableExprId &id)
Get the operand's value for the given row and apply it to the aggregation.
TableExprGroupSumSqrArrayDouble(TableExprNodeRep *node)
Aggregate class determining the sum of squares of integer array values in a group.
virtual void apply(const TableExprId &id)
Get the operand's value for the given row and apply it to the aggregation.
TableExprGroupSumSqrArrayInt(TableExprNodeRep *node)
Aggregate class determining the sum of squares of complex array values in a group.
virtual void apply(const TableExprId &id)
Get the operand's value for the given row and apply it to the aggregation.
TableExprGroupSumSqrsArrayDComplex(TableExprNodeRep *node)
Aggregate class determining the sum of squares of double array values in a group.
TableExprGroupSumSqrsArrayDouble(TableExprNodeRep *node)
virtual void apply(const TableExprId &id)
Get the operand's value for the given row and apply it to the aggregation.
Aggregate class determining per array index in a group the sum of value squares in a group.
virtual void apply(const TableExprId &id)
Get the operand's value for the given row and apply it to the aggregation.
TableExprGroupSumSqrsArrayInt(TableExprNodeRep *node)
Aggregate class determining the sum of complex array values in a group.
TableExprGroupSumsArrayDComplex(TableExprNodeRep *node)
virtual void apply(const TableExprId &id)
Get the operand's value for the given row and apply it to the aggregation.
Aggregate class determining the sum of double array values in a group.
TableExprGroupSumsArrayDouble(TableExprNodeRep *node)
virtual void apply(const TableExprId &id)
Get the operand's value for the given row and apply it to the aggregation.
Aggregate class determining per array index in a group the sum of values.
virtual void apply(const TableExprId &id)
Get the operand's value for the given row and apply it to the aggregation.
TableExprGroupSumsArrayInt(TableExprNodeRep *node)
Aggregate class determining the variance of array values in a group.
virtual void apply(const TableExprId &id)
Get the operand's value for the given row and apply it to the aggregation.
virtual void finish()
If needed, finish the aggregation.
TableExprGroupVarianceArrayDComplex(TableExprNodeRep *node, uInt ddof)
Aggregate class determining the variance of array values in a group.
virtual void apply(const TableExprId &id)
Get the operand's value for the given row and apply it to the aggregation.
TableExprGroupVarianceArrayDouble(TableExprNodeRep *node, uInt ddof)
virtual void finish()
If needed, finish the aggregation.
Aggregate class determining the variance of array values in a group.
TableExprGroupVariancesArrayDComplex(TableExprNodeRep *node, uInt ddof)
virtual void apply(const TableExprId &id)
Get the operand's value for the given row and apply it to the aggregation.
virtual void finish()
If needed, finish the aggregation.
Aggregate class determining the variance of array values in a group.
virtual void apply(const TableExprId &id)
Get the operand's value for the given row and apply it to the aggregation.
virtual void finish()
If needed, finish the aggregation.
TableExprGroupVariancesArrayDouble(TableExprNodeRep *node, uInt ddof)
Abstract base class for a node in a table column expression tree.
Definition: ExprNodeRep.h:158
this file contains all the compiler specific defines
Definition: mainpage.dox:28
LatticeExprNode fractile(const LatticeExprNode &expr, const LatticeExprNode &fraction)
Determine the value of the element at the part fraction from the beginning of the given lattice.
unsigned int uInt
Definition: aipstype.h:51
long long Int64
Define the extra non-standard types used by Casacore (like proposed uSize, Size)
Definition: aipsxtype.h:38
bool Bool
Define the standard types used by Casacore.
Definition: aipstype.h:42
LatticeExprNode value(const LatticeExprNode &expr)
This function returns the value of the expression without a mask.
double Double
Definition: aipstype.h:55