ExprGroupAggrFunc.h

Go to the documentation of this file.

//# ExprGroupAggrFunc.h: The various scalar aggregation functions
//# Copyright (C) 2013
//# Associated Universities, Inc. Washington DC, USA.
//#
//# This library is free software; you can redistribute it and/or modify it
//# under the terms of the GNU Library General Public License as published by
//# the Free Software Foundation; either version 2 of the License, or (at your
//# option) any later version.
//#
//# This library is distributed in the hope that it will be useful, but WITHOUT
//# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
//# FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Library General Public
//# License for more details.
//#
//# You should have received a copy of the GNU Library General Public License
//# along with this library; if not, write to the Free Software Foundation,
//# Inc., 675 Massachusetts Ave, Cambridge, MA 02139, USA.
//#
//# Correspondence concerning AIPS++ should be addressed as follows:
//#        Internet email: casa-feedback@nrao.edu.
//#        Postal address: AIPS++ Project Office
//#                        National Radio Astronomy Observatory
//#                        520 Edgemont Road
//#                        Charlottesville, VA 22903-2475 USA
 
#ifndef TABLES_EXPRGROUPAGGRFUNC_H
#define TABLES_EXPRGROUPAGGRFUNC_H
 
//# Includes
#include <casacore/casa/aips.h>
#include <casacore/tables/TaQL/ExprGroup.h>
#include <vector>
 
 
namespace casacore { //# NAMESPACE CASACORE - BEGIN
 
  //# Forward Declaration
  class TableExprNodeArrayColumn;
 
 
  // <summary>
  // Aggregate class counting number of rows in a group
  // </summary>
  // <use visibility=local>
  // <reviewed reviewer="" date="" tests="tExprGroup">
  // </reviewed>
  // <synopsis>
  // Aggregate class counting number of rows in a group.
  // </synopsis>
  class TableExprGroupCountAll: public TableExprGroupFuncInt
  {
  public:
    explicit TableExprGroupCountAll (TableExprNodeRep* node);
    virtual ~TableExprGroupCountAll();
    virtual void apply (const TableExprId& id);
    // Set result in case it is known directly.
    void setResult (Int64 cnt)
      { itsValue = cnt; }
  };
 
  // <summary>
  // Aggregate class counting number of rows in a group containing a value
  // </summary>
  // <use visibility=local>
  // <reviewed reviewer="" date="" tests="tExprGroup">
  // </reviewed>
  // <synopsis>
  // Aggregate class counting number of rows in a group containing a value.
  // </synopsis>
  class TableExprGroupCount: public TableExprGroupFuncInt
  {
  public:
    explicit TableExprGroupCount (TableExprNodeRep* node);
    virtual ~TableExprGroupCount();
    virtual void apply (const TableExprId& id);
  private:
    TableExprNodeArrayColumn* itsColumn;
  };
 
  // <summary>
  // Aggregate class counting if any value in a group is true
  // </summary>
  // <use visibility=local>
  // <reviewed reviewer="" date="" tests="tExprGroup">
  // </reviewed>
  // <synopsis>
  // Aggregate class counting if any value in a group is true.
  // </synopsis>
  class TableExprGroupAny: public TableExprGroupFuncBool
  {
  public:
    explicit TableExprGroupAny (TableExprNodeRep* node);
    virtual ~TableExprGroupAny();
    virtual void apply (const TableExprId& id);
  };
 
  // <summary>
  // Aggregate class counting if all values in a group are true
  // </summary>
  // <use visibility=local>
  // <reviewed reviewer="" date="" tests="tExprGroup">
  // </reviewed>
  // <synopsis>
  // Aggregate class counting if all values in a group are true.
  // </synopsis>
  class TableExprGroupAll: public TableExprGroupFuncBool
  {
  public:
    explicit TableExprGroupAll (TableExprNodeRep* node);
    virtual ~TableExprGroupAll();
    virtual void apply (const TableExprId& id);
  };
 
  // <summary>
  // Aggregate class counting the number of true values in a group
  // </summary>
  // <use visibility=local>
  // <reviewed reviewer="" date="" tests="tExprGroup">
  // </reviewed>
  // <synopsis>
  // Aggregate class counting the number of true values in a group.
  // </synopsis>
  class TableExprGroupNTrue: public TableExprGroupFuncInt
  {
  public:
    explicit TableExprGroupNTrue (TableExprNodeRep* node);
    virtual ~TableExprGroupNTrue();
    virtual void apply (const TableExprId& id);
  };
 
  // <summary>
  // Aggregate class counting the number of false values in a group
  // </summary>
  // <use visibility=local>
  // <reviewed reviewer="" date="" tests="tExprGroup">
  // </reviewed>
  // <synopsis>
  // Aggregate class counting the number of false values in a group.
  // </synopsis>
  class TableExprGroupNFalse: public TableExprGroupFuncInt
  {
  public:
    explicit TableExprGroupNFalse (TableExprNodeRep* node);
    virtual ~TableExprGroupNFalse();
    virtual void apply (const TableExprId& id);
  };
 
  // <summary>
  // Aggregate class determining the minimum integer value in a group
  // </summary>
  // <use visibility=local>
  // <reviewed reviewer="" date="" tests="tExprGroup">
  // </reviewed>
  // <synopsis>
  // Aggregate class determining the minimum integer value in a group.
  // </synopsis>
  class TableExprGroupMinInt: public TableExprGroupFuncInt
  {
  public:
    explicit TableExprGroupMinInt (TableExprNodeRep* node);
    virtual ~TableExprGroupMinInt();
    virtual void apply (const TableExprId& id);
  };
 
  // <summary>
  // Aggregate class determining the maximum integer value in a group
  // </summary>
  // <use visibility=local>
  // <reviewed reviewer="" date="" tests="tExprGroup">
  // </reviewed>
  // <synopsis>
  // Aggregate class determining the maximum integer value in a group.
  // </synopsis>
  class TableExprGroupMaxInt: public TableExprGroupFuncInt
  {
  public:
    explicit TableExprGroupMaxInt (TableExprNodeRep* node);
    virtual ~TableExprGroupMaxInt();
    virtual void apply (const TableExprId& id);
  };
 
  // <summary>
  // Aggregate class determining the sum of integer values in a group
  // </summary>
  // <use visibility=local>
  // <reviewed reviewer="" date="" tests="tExprGroup">
  // </reviewed>
  // <synopsis>
  // Aggregate class determining the sum of integer values in a group.
  // </synopsis>
  class TableExprGroupSumInt: public TableExprGroupFuncInt
  {
  public:
    explicit TableExprGroupSumInt (TableExprNodeRep* node);
    virtual ~TableExprGroupSumInt();
    virtual void apply (const TableExprId& id);
  };
 
  // <summary>
  // Aggregate class determining the product of integer values in a group
  // </summary>
  // <use visibility=local>
  // <reviewed reviewer="" date="" tests="tExprGroup">
  // </reviewed>
  // <synopsis>
  // Aggregate class determining the product of integer values in a group.
  // </synopsis>
  class TableExprGroupProductInt: public TableExprGroupFuncInt
  {
  public:
    explicit TableExprGroupProductInt (TableExprNodeRep* node);
    virtual ~TableExprGroupProductInt();
    virtual void apply (const TableExprId& id);
  };
 
  // <summary>
  // Aggregate class determining the sum of squares of integer values in a group
  // </summary>
  // <use visibility=local>
  // <reviewed reviewer="" date="" tests="tExprGroup">
  // </reviewed>
  // <synopsis>
  // Aggregate class determining the sum of squares of integer values in a group.
  // </synopsis>
  class TableExprGroupSumSqrInt: public TableExprGroupFuncInt
  {
  public:
    explicit TableExprGroupSumSqrInt (TableExprNodeRep* node);
    virtual ~TableExprGroupSumSqrInt();
    virtual void apply (const TableExprId& id);
  };
 
 
  // <summary>
  // Aggregate class determining the minimum double value in a group
  // </summary>
  // <use visibility=local>
  // <reviewed reviewer="" date="" tests="tExprGroup">
  // </reviewed>
  // <synopsis>
  // Aggregate class determining the minimum double value in a group.
  // </synopsis>
  class TableExprGroupMinDouble: public TableExprGroupFuncDouble
  {
  public:
    explicit TableExprGroupMinDouble (TableExprNodeRep* node);
    virtual ~TableExprGroupMinDouble();
    virtual void apply (const TableExprId& id);
  };
 
  // <summary>
  // Aggregate class determining the maximum double value in a group
  // </summary>
  // <use visibility=local>
  // <reviewed reviewer="" date="" tests="tExprGroup">
  // </reviewed>
  // <synopsis>
  // Aggregate class determining the maximum double value in a group.
  // </synopsis>
  class TableExprGroupMaxDouble: public TableExprGroupFuncDouble
  {
  public:
    explicit TableExprGroupMaxDouble (TableExprNodeRep* node);
    virtual ~TableExprGroupMaxDouble();
    virtual void apply (const TableExprId& id);
  };
 
  // <summary>
  // Aggregate class determining the sum of double values in a group
  // </summary>
  // <use visibility=local>
  // <reviewed reviewer="" date="" tests="tExprGroup">
  // </reviewed>
  // <synopsis>
  // Aggregate class determining the sum of double values in a group.
  // </synopsis>
  class TableExprGroupSumDouble: public TableExprGroupFuncDouble
  {
  public:
    explicit TableExprGroupSumDouble (TableExprNodeRep* node);
    virtual ~TableExprGroupSumDouble();
    virtual void apply (const TableExprId& id);
  };
 
  // <summary>
  // Aggregate class determining the product of double values in a group
  // </summary>
  // <use visibility=local>
  // <reviewed reviewer="" date="" tests="tExprGroup">
  // </reviewed>
  // <synopsis>
  // Aggregate class determining the product of double values in a group.
  // </synopsis>
  class TableExprGroupProductDouble: public TableExprGroupFuncDouble
  {
  public:
    explicit TableExprGroupProductDouble (TableExprNodeRep* node);
    virtual ~TableExprGroupProductDouble();
    virtual void apply (const TableExprId& id);
  };
 
  // <summary>
  // Aggregate class determining the sum of squares of double values in a group
  // </summary>
  // <use visibility=local>
  // <reviewed reviewer="" date="" tests="tExprGroup">
  // </reviewed>
  // <synopsis>
  // Aggregate class determining the sum of squares of double values in a group.
  // </synopsis>
  class TableExprGroupSumSqrDouble: public TableExprGroupFuncDouble
  {
  public:
    explicit TableExprGroupSumSqrDouble (TableExprNodeRep* node);
    virtual ~TableExprGroupSumSqrDouble();
    virtual void apply (const TableExprId& id);
  };
 
  // <summary>
  // Aggregate class determining the mean of values in a group
  // </summary>
  // <use visibility=local>
  // <reviewed reviewer="" date="" tests="tExprGroup">
  // </reviewed>
  // <synopsis>
  // Aggregate class determining the mean of values in a group.
  // </synopsis>
  class TableExprGroupMeanDouble: public TableExprGroupFuncDouble
  {
  public:
    explicit TableExprGroupMeanDouble (TableExprNodeRep* node);
    virtual ~TableExprGroupMeanDouble();
    virtual void apply (const TableExprId& id);
    virtual void finish();
  private:
    Int64 itsNr;
  };
 
  // <summary>
  // Aggregate class determining the variance of values in a group
  // </summary>
  // <use visibility=local>
  // <reviewed reviewer="" date="" tests="tExprGroup">
  // </reviewed>
  // <synopsis>
  // Aggregate class determining the variance of values in a group.
  // It uses a running algorithm
  // (see en.wikipedia.org/wiki/Algorithms_for_calculating_variance)
  // </synopsis>
  class TableExprGroupVarianceDouble: public TableExprGroupFuncDouble
  {
  public:
    explicit TableExprGroupVarianceDouble (TableExprNodeRep* node, uInt ddof);
    virtual ~TableExprGroupVarianceDouble();
    virtual void apply (const TableExprId& id);
    virtual void finish();
  protected:
    uInt   itsDdof;
    Int64  itsNr;
    Double itsCurMean;
  };
 
  // <summary>
  // Aggregate class determining the standard deviation of values in a group
  // </summary>
  // <use visibility=local>
  // <reviewed reviewer="" date="" tests="tExprGroup">
  // </reviewed>
  // <synopsis>
  // Aggregate class determining the standard deviation of values in a group.
  // It uses a running algorithm
  // (see en.wikipedia.org/wiki/Algorithms_for_calculating_variance)
  // </synopsis>
  class TableExprGroupStdDevDouble: public TableExprGroupVarianceDouble
  {
  public:
    explicit TableExprGroupStdDevDouble (TableExprNodeRep* node, uInt ddof);
    virtual ~TableExprGroupStdDevDouble();
    virtual void finish();
  };
 
  // <summary>
  // Aggregate class determining the RMS of values in a group
  // </summary>
  // <use visibility=local>
  // <reviewed reviewer="" date="" tests="tExprGroup">
  // </reviewed>
  // <synopsis>
  // Aggregate class determining the RMS of values in a group.
  // </synopsis>
  class TableExprGroupRmsDouble: public TableExprGroupFuncDouble
  {
  public:
    explicit TableExprGroupRmsDouble (TableExprNodeRep* node);
    virtual ~TableExprGroupRmsDouble();
    virtual void apply (const TableExprId& id);
    virtual void finish();
  private:
    Int64 itsNr;
  };
 
  // <summary>
  // Aggregate class determining the fractile of values in a group
  // </summary>
  // <use visibility=local>
  // <reviewed reviewer="" date="" tests="tExprGroup">
  // </reviewed>
  // <synopsis>
  // Aggregate class determining the fractile of values in a group.
  // <br>It is a lazy aggregate class, thus <src>apply</src> does nothing.
  // Instead, <src>getDouble</src> assembles the values and determines the
  // fractile.
  // </synopsis>
  class TableExprGroupFractileDouble: public TableExprGroupFuncDouble
  {
  public:
    explicit TableExprGroupFractileDouble (TableExprNodeRep* node,
                                           Double fractile);
    virtual ~TableExprGroupFractileDouble();
    virtual Bool isLazy() const;
    virtual void apply (const TableExprId& id);
    virtual Double getDouble (const vector<TableExprId>& ids);
  private:
    Double itsFrac;
  };
 
 
  // <summary>
  // Aggregate class determining the sum of complex values in a group
  // </summary>
  // <use visibility=local>
  // <reviewed reviewer="" date="" tests="tExprGroup">
  // </reviewed>
  // <synopsis>
  // Aggregate class determining the sum of complex values in a group.
  // </synopsis>
  class TableExprGroupSumDComplex: public TableExprGroupFuncDComplex
  {
  public:
    explicit TableExprGroupSumDComplex (TableExprNodeRep* node);
    virtual ~TableExprGroupSumDComplex();
    virtual void apply (const TableExprId& id);
  };
 
  // <summary>
  // Aggregate class determining the product of complex values in a group
  // </summary>
  // <use visibility=local>
  // <reviewed reviewer="" date="" tests="tExprGroup">
  // </reviewed>
  // <synopsis>
  // Aggregate class determining the product of complex values in a group.
  // </synopsis>
  class TableExprGroupProductDComplex: public TableExprGroupFuncDComplex
  {
  public:
    explicit TableExprGroupProductDComplex (TableExprNodeRep* node);
    virtual ~TableExprGroupProductDComplex();
    virtual void apply (const TableExprId& id);
  };
 
  // <summary>
  // Aggregate class determining the sum of squares of complex values in a group
  // </summary>
  // <use visibility=local>
  // <reviewed reviewer="" date="" tests="tExprGroup">
  // </reviewed>
  // <synopsis>
  // Aggregate class determining the sum of squares of complex values in a group.
  // </synopsis>
  class TableExprGroupSumSqrDComplex: public TableExprGroupFuncDComplex
  {
  public:
    explicit TableExprGroupSumSqrDComplex (TableExprNodeRep* node);
    virtual ~TableExprGroupSumSqrDComplex();
    virtual void apply (const TableExprId& id);
  };
 
  // <summary>
  // Aggregate class determining the mean of complex values in a group
  // </summary>
  // <use visibility=local>
  // <reviewed reviewer="" date="" tests="tExprGroup">
  // </reviewed>
  // <synopsis>
  // Aggregate class determining the mean of complex values in a group.
  // </synopsis>
  class TableExprGroupMeanDComplex: public TableExprGroupFuncDComplex
  {
  public:
    explicit TableExprGroupMeanDComplex (TableExprNodeRep* node);
    virtual ~TableExprGroupMeanDComplex();
    virtual void apply (const TableExprId& id);
    virtual void finish();
  private:
    Int64 itsNr;
  };
 
  // <summary>
  // Aggregate class determining the variance of values in a group
  // </summary>
  // <use visibility=local>
  // <reviewed reviewer="" date="" tests="tExprGroup">
  // </reviewed>
  // <synopsis>
  // Aggregate class determining the variance of values in a group.
  // It uses a running algorithm
  // (see en.wikipedia.org/wiki/Algorithms_for_calculating_variance)
  // Note that the result is a Double value (not DComplex).
  // </synopsis>
  class TableExprGroupVarianceDComplex: public TableExprGroupFuncDouble
  {
  public:
    explicit TableExprGroupVarianceDComplex (TableExprNodeRep* node, uInt ddof);
    virtual ~TableExprGroupVarianceDComplex();
    virtual void apply (const TableExprId& id);
    virtual void finish();
  protected:
    uInt     itsDdof;
    Int64    itsNr;
    DComplex itsCurMean;
  };
 
  // <summary>
  // Aggregate class determining the standard deviation of values in a group
  // </summary>
  // <use visibility=local>
  // <reviewed reviewer="" date="" tests="tExprGroup">
  // </reviewed>
  // <synopsis>
  // Aggregate class determining the standard deviation of values in a group.
  // It uses a running algorithm
  // (see en.wikipedia.org/wiki/Algorithms_for_calculating_variance)
  // </synopsis>
  class TableExprGroupStdDevDComplex: public TableExprGroupVarianceDComplex
  {
  public:
    explicit TableExprGroupStdDevDComplex (TableExprNodeRep* node, uInt ddof);
    virtual ~TableExprGroupStdDevDComplex();
    virtual void finish();
  };
 
 
} //# NAMESPACE CASACORE - END
 
#endif