Loading...
Searching...
No Matches
ExprGroupAggrFuncArray.h
Go to the documentation of this file.
//# ExprGroupAggrFuncArray.h: The various array reduction 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_EXPRGROUPAGGRFUNCARRAY_H
#define TABLES_EXPRGROUPAGGRFUNCARRAY_H
//# Includes
#include <casacore/casa/aips.h>
#include <casacore/tables/TaQL/ExprGroup.h>
#include <vector>
namespace casacore { //# NAMESPACE CASACORE - BEGIN
// <summary>
// Aggregate class counting if any array value in a group is true
// </summary>
// <use visibility=local>
// <reviewed reviewer="" date="" tests="tExprGroup">
// </reviewed>
// <synopsis>
// Aggregate class counting if any array value in a group is true.
// </synopsis>
class TableExprGroupArrayAny: public TableExprGroupFuncBool
{
public:
TableExprGroupArrayAny (TableExprNodeRep* node);
virtual ~TableExprGroupArrayAny();
virtual void apply (const TableExprId& id);
};
// <summary>
// Aggregate class counting if all array values in a group are true
// </summary>
// <use visibility=local>
// <reviewed reviewer="" date="" tests="tExprGroup">
// </reviewed>
// <synopsis>
// Aggregate class counting if all array values in a group are true.
// </synopsis>
class TableExprGroupArrayAll: public TableExprGroupFuncBool
{
public:
TableExprGroupArrayAll (TableExprNodeRep* node);
virtual ~TableExprGroupArrayAll();
virtual void apply (const TableExprId& id);
};
// <summary>
// Aggregate class counting the number of true array values in a group
// </summary>
// <use visibility=local>
// <reviewed reviewer="" date="" tests="tExprGroup">
// </reviewed>
// <synopsis>
// Aggregate class counting the number of true array values in a group.
// </synopsis>
class TableExprGroupArrayNTrue: public TableExprGroupFuncInt
{
public:
TableExprGroupArrayNTrue (TableExprNodeRep* node);
virtual ~TableExprGroupArrayNTrue();
virtual void apply (const TableExprId& id);
};
// <summary>
// Aggregate class counting the number of false array values in a group
// </summary>
// <use visibility=local>
// <reviewed reviewer="" date="" tests="tExprGroup">
// </reviewed>
// <synopsis>
// Aggregate class counting the number of false array values in a group.
// </synopsis>
class TableExprGroupArrayNFalse: public TableExprGroupFuncInt
{
public:
TableExprGroupArrayNFalse (TableExprNodeRep* node);
virtual ~TableExprGroupArrayNFalse();
virtual void apply (const TableExprId& id);
};
// <summary>
// Aggregate class determining the minimum integer array value in a group
// </summary>
// <use visibility=local>
// <reviewed reviewer="" date="" tests="tExprGroup">
// </reviewed>
// <synopsis>
// Aggregate class determining the minimum integer array value in a group.
// </synopsis>
class TableExprGroupMinArrayInt: public TableExprGroupFuncInt
{
public:
TableExprGroupMinArrayInt (TableExprNodeRep* node);
virtual ~TableExprGroupMinArrayInt();
virtual void apply (const TableExprId& id);
};
// <summary>
// Aggregate class determining the maximum integer array value in a group
// </summary>
// <use visibility=local>
// <reviewed reviewer="" date="" tests="tExprGroup">
// </reviewed>
// <synopsis>
// Aggregate class determining the maximum integer array value in a group.
// </synopsis>
class TableExprGroupMaxArrayInt: public TableExprGroupFuncInt
{
public:
TableExprGroupMaxArrayInt (TableExprNodeRep* node);
virtual ~TableExprGroupMaxArrayInt();
virtual void apply (const TableExprId& id);
};
// <summary>
// Aggregate class determining the sum of integer array values in a group
// </summary>
// <use visibility=local>
// <reviewed reviewer="" date="" tests="tExprGroup">
// </reviewed>
// <synopsis>
// Aggregate class determining the sum of integer array values in a group.
// </synopsis>
class TableExprGroupSumArrayInt: public TableExprGroupFuncInt
{
public:
TableExprGroupSumArrayInt (TableExprNodeRep* node);
virtual ~TableExprGroupSumArrayInt();
virtual void apply (const TableExprId& id);
};
// <summary>
// Aggregate class determining the product of integer array values in a group
// </summary>
// <use visibility=local>
// <reviewed reviewer="" date="" tests="tExprGroup">
// </reviewed>
// <synopsis>
// Aggregate class determining the product of integer array values in a group.
// </synopsis>
class TableExprGroupProductArrayInt: public TableExprGroupFuncInt
{
public:
TableExprGroupProductArrayInt (TableExprNodeRep* node);
virtual ~TableExprGroupProductArrayInt();
virtual void apply (const TableExprId& id);
};
// <summary>
// Aggregate class determining the sum of squares of integer array values
// in a group
// </summary>
// <use visibility=local>
// <reviewed reviewer="" date="" tests="tExprGroup">
// </reviewed>
// <synopsis>
// Aggregate class determining the sum of squares of integer array values
// in a group.
// </synopsis>
class TableExprGroupSumSqrArrayInt: public TableExprGroupFuncInt
{
public:
TableExprGroupSumSqrArrayInt (TableExprNodeRep* node);
virtual ~TableExprGroupSumSqrArrayInt();
virtual void apply (const TableExprId& id);
};
// <summary>
// Aggregate class determining the minimum double array value in a group
// </summary>
// <use visibility=local>
// <reviewed reviewer="" date="" tests="tExprGroup">
// </reviewed>
// <synopsis>
// Aggregate class determining the minimum double array value in a group.
// </synopsis>
class TableExprGroupMinArrayDouble: public TableExprGroupFuncDouble
{
public:
TableExprGroupMinArrayDouble (TableExprNodeRep* node);
virtual ~TableExprGroupMinArrayDouble();
virtual void apply (const TableExprId& id);
};
// <summary>
// Aggregate class determining the maximum double array value in a group
// </summary>
// <use visibility=local>
// <reviewed reviewer="" date="" tests="tExprGroup">
// </reviewed>
// <synopsis>
// Aggregate class determining the maximum double array value in a group.
// </synopsis>
class TableExprGroupMaxArrayDouble: public TableExprGroupFuncDouble
{
public:
TableExprGroupMaxArrayDouble (TableExprNodeRep* node);
virtual ~TableExprGroupMaxArrayDouble();
virtual void apply (const TableExprId& id);
};
// <summary>
// Aggregate class determining the sum of double array values in a group
// </summary>
// <use visibility=local>
// <reviewed reviewer="" date="" tests="tExprGroup">
// </reviewed>
// <synopsis>
// Aggregate class determining the sum of double array values in a group.
// </synopsis>
class TableExprGroupSumArrayDouble: public TableExprGroupFuncDouble
{
public:
TableExprGroupSumArrayDouble (TableExprNodeRep* node);
virtual ~TableExprGroupSumArrayDouble();
virtual void apply (const TableExprId& id);
};
// <summary>
// Aggregate class determining the product of double array values in a group
// </summary>
// <use visibility=local>
// <reviewed reviewer="" date="" tests="tExprGroup">
// </reviewed>
// <synopsis>
// Aggregate class determining the product of double array values in a group.
// </synopsis>
class TableExprGroupProductArrayDouble: public TableExprGroupFuncDouble
{
public:
TableExprGroupProductArrayDouble (TableExprNodeRep* node);
virtual ~TableExprGroupProductArrayDouble();
virtual void apply (const TableExprId& id);
};
// <summary>
// Aggregate class determining the sum of squares of double array values
// in a group
// </summary>
// <use visibility=local>
// <reviewed reviewer="" date="" tests="tExprGroup">
// </reviewed>
// <synopsis>
// Aggregate class determining the sum of squares of double array values
// in a group.
// </synopsis>
class TableExprGroupSumSqrArrayDouble: public TableExprGroupFuncDouble
{
public:
TableExprGroupSumSqrArrayDouble (TableExprNodeRep* node);
virtual ~TableExprGroupSumSqrArrayDouble();
virtual void apply (const TableExprId& id);
};
// <summary>
// Aggregate class determining the mean of array values in a group
// </summary>
// <use visibility=local>
// <reviewed reviewer="" date="" tests="tExprGroup">
// </reviewed>
// <synopsis>
// Aggregate class determining the mean of array values in a group.
// </synopsis>
class TableExprGroupMeanArrayDouble: public TableExprGroupFuncDouble
{
public:
TableExprGroupMeanArrayDouble (TableExprNodeRep* node);
virtual ~TableExprGroupMeanArrayDouble();
virtual void apply (const TableExprId& id);
virtual void finish();
private:
Int64 itsNr;
};
// <summary>
// Aggregate class determining the variance of array values in a group
// </summary>
// <use visibility=local>
// <reviewed reviewer="" date="" tests="tExprGroup">
// </reviewed>
// <synopsis>
// Aggregate class determining the variance of array values in a group.
// It uses a running algorithm
// (see en.wikipedia.org/wiki/Algorithms_for_calculating_variance)
// </synopsis>
class TableExprGroupVarianceArrayDouble: public TableExprGroupFuncDouble
{
public:
TableExprGroupVarianceArrayDouble (TableExprNodeRep* node, uInt ddof);
virtual ~TableExprGroupVarianceArrayDouble();
virtual void apply (const TableExprId& id);
virtual void finish();
protected:
uInt itsDdof;
Int64 itsNr;
Double itsCurMean;
};
// <summary>
// Aggregate class determining the standard devation of array values
// in a group
// </summary>
// <use visibility=local>
// <reviewed reviewer="" date="" tests="tExprGroup">
// </reviewed>
// <synopsis>
// Aggregate class determining the standard deviation of array values
// in a group. It uses a running algorithm
// (see en.wikipedia.org/wiki/Algorithms_for_calculating_variance)
// </synopsis>
class TableExprGroupStdDevArrayDouble: public TableExprGroupVarianceArrayDouble
{
public:
TableExprGroupStdDevArrayDouble (TableExprNodeRep* node, uInt ddof);
virtual ~TableExprGroupStdDevArrayDouble();
virtual void finish();
};
// <summary>
// Aggregate class determining the RMS of array values in a group
// </summary>
// <use visibility=local>
// <reviewed reviewer="" date="" tests="tExprGroup">
// </reviewed>
// <synopsis>
// Aggregate class determining the RMS of array values in a group.
// </synopsis>
class TableExprGroupRmsArrayDouble: public TableExprGroupFuncDouble
{
public:
TableExprGroupRmsArrayDouble (TableExprNodeRep* node);
virtual ~TableExprGroupRmsArrayDouble();
virtual void apply (const TableExprId& id);
virtual void finish();
private:
Int64 itsNr;
};
// <summary>
// Aggregate class determining the fractile of array values in a group
// </summary>
// <use visibility=local>
// <reviewed reviewer="" date="" tests="tExprGroup">
// </reviewed>
// <synopsis>
// Aggregate class determining the fractile of array 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 TableExprGroupFractileArrayDouble: public TableExprGroupFuncDouble
{
public:
explicit TableExprGroupFractileArrayDouble (TableExprNodeRep* node,
Double fractile);
virtual ~TableExprGroupFractileArrayDouble();
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 array values in a group
// </summary>
// <use visibility=local>
// <reviewed reviewer="" date="" tests="tExprGroup">
// </reviewed>
// <synopsis>
// Aggregate class determining the sum of complex array values in a group.
// </synopsis>
class TableExprGroupSumArrayDComplex: public TableExprGroupFuncDComplex
{
public:
TableExprGroupSumArrayDComplex (TableExprNodeRep* node);
virtual ~TableExprGroupSumArrayDComplex();
virtual void apply (const TableExprId& id);
};
// <summary>
// Aggregate class determining the product of complex array values in a group
// </summary>
// <use visibility=local>
// <reviewed reviewer="" date="" tests="tExprGroup">
// </reviewed>
// <synopsis>
// Aggregate class determining the product of complex array values in a group.
// </synopsis>
class TableExprGroupProductArrayDComplex: public TableExprGroupFuncDComplex
{
public:
TableExprGroupProductArrayDComplex (TableExprNodeRep* node);
virtual ~TableExprGroupProductArrayDComplex();
virtual void apply (const TableExprId& id);
};
// <summary>
// Aggregate class determining the sum of squares of complex array values
// in a group
// </summary>
// <use visibility=local>
// <reviewed reviewer="" date="" tests="tExprGroup">
// </reviewed>
// <synopsis>
// Aggregate class determining the sum of squares of complex array values
// in a group.
// </synopsis>
class TableExprGroupSumSqrArrayDComplex: public TableExprGroupFuncDComplex
{
public:
TableExprGroupSumSqrArrayDComplex (TableExprNodeRep* node);
virtual ~TableExprGroupSumSqrArrayDComplex();
virtual void apply (const TableExprId& id);
};
// <summary>
// Aggregate class determining the mean of complex array values in a group
// </summary>
// <use visibility=local>
// <reviewed reviewer="" date="" tests="tExprGroup">
// </reviewed>
// <synopsis>
// Aggregate class determining the mean of complex array values in a group.
// </synopsis>
class TableExprGroupMeanArrayDComplex: public TableExprGroupFuncDComplex
{
public:
TableExprGroupMeanArrayDComplex (TableExprNodeRep* node);
virtual ~TableExprGroupMeanArrayDComplex();
virtual void apply (const TableExprId& id);
virtual void finish();
private:
Int64 itsNr;
};
// <summary>
// Aggregate class determining the variance of array values in a group
// </summary>
// <use visibility=local>
// <reviewed reviewer="" date="" tests="tExprGroup">
// </reviewed>
// <synopsis>
// Aggregate class determining the variance of array 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 TableExprGroupVarianceArrayDComplex: public TableExprGroupFuncDouble
{
public:
TableExprGroupVarianceArrayDComplex (TableExprNodeRep* node, uInt ddof);
virtual ~TableExprGroupVarianceArrayDComplex();
virtual void apply (const TableExprId& id);
virtual void finish();
protected:
uInt itsDdof;
Int64 itsNr;
DComplex itsCurMean;
};
// <summary>
// Aggregate class determining the standard devation of array values
// in a group
// </summary>
// <use visibility=local>
// <reviewed reviewer="" date="" tests="tExprGroup">
// </reviewed>
// <synopsis>
// Aggregate class determining the standard deviation of array values
// in a group. It uses a running algorithm
// (see en.wikipedia.org/wiki/Algorithms_for_calculating_variance)
// </synopsis>
class TableExprGroupStdDevArrayDComplex: public TableExprGroupVarianceArrayDComplex
{
public:
TableExprGroupStdDevArrayDComplex (TableExprNodeRep* node, uInt ddof);
virtual ~TableExprGroupStdDevArrayDComplex();
virtual void finish();
};
// <summary>
// Aggregate class counting per array index in a group if any is true
// </summary>
// <use visibility=local>
// <reviewed reviewer="" date="" tests="tExprGroup">
// </reviewed>
// <synopsis>
// Aggregate class counting per array index in a group if any is true.
// </synopsis>
class TableExprGroupArrayAnys: public TableExprGroupFuncArrayBool
{
public:
TableExprGroupArrayAnys (TableExprNodeRep* node);
virtual ~TableExprGroupArrayAnys();
virtual void apply (const TableExprId& id);
};
// <summary>
// Aggregate class counting per array index in a group if all are true
// </summary>
// <use visibility=local>
// <reviewed reviewer="" date="" tests="tExprGroup">
// </reviewed>
// <synopsis>
// Aggregate class counting per array index in a group if all are true.
// </synopsis>
class TableExprGroupArrayAlls: public TableExprGroupFuncArrayBool
{
public:
TableExprGroupArrayAlls (TableExprNodeRep* node);
virtual ~TableExprGroupArrayAlls();
virtual void apply (const TableExprId& id);
};
// <summary>
// Aggregate class counting per array index in a group the nr of true values
// </summary>
// <use visibility=local>
// <reviewed reviewer="" date="" tests="tExprGroup">
// </reviewed>
// <synopsis>
// Aggregate class counting per array index in a group the nr of true values.
// </synopsis>
class TableExprGroupArrayNTrues: public TableExprGroupFuncArrayInt
{
public:
TableExprGroupArrayNTrues (TableExprNodeRep* node);
virtual ~TableExprGroupArrayNTrues();
virtual void apply (const TableExprId& id);
};
// <summary>
// Aggregate class counting per array index in a group the nr of false values
// </summary>
// <use visibility=local>
// <reviewed reviewer="" date="" tests="tExprGroup">
// </reviewed>
// <synopsis>
// Aggregate class counting per array index in a group the nr of false values.
// </synopsis>
class TableExprGroupArrayNFalses: public TableExprGroupFuncArrayInt
{
public:
TableExprGroupArrayNFalses (TableExprNodeRep* node);
virtual ~TableExprGroupArrayNFalses();
virtual void apply (const TableExprId& id);
};
// <summary>
// Aggregate class determining per array index in a group the minimum value
// </summary>
// <use visibility=local>
// <reviewed reviewer="" date="" tests="tExprGroup">
// </reviewed>
// <synopsis>
// Aggregate class determining per array index in a group the minimum value.
// </synopsis>
class TableExprGroupMinsArrayInt: public TableExprGroupFuncArrayInt
{
public:
TableExprGroupMinsArrayInt (TableExprNodeRep* node);
virtual ~TableExprGroupMinsArrayInt();
virtual void apply (const TableExprId& id);
virtual void finish();
};
// <summary>
// Aggregate class determining per array index in a group the maximum value
// </summary>
// <use visibility=local>
// <reviewed reviewer="" date="" tests="tExprGroup">
// </reviewed>
// <synopsis>
// Aggregate class determining per array index in a group the maximum value.
// </synopsis>
class TableExprGroupMaxsArrayInt: public TableExprGroupFuncArrayInt
{
public:
TableExprGroupMaxsArrayInt (TableExprNodeRep* node);
virtual ~TableExprGroupMaxsArrayInt();
virtual void apply (const TableExprId& id);
virtual void finish();
};
// <summary>
// Aggregate class determining per array index in a group the sum of values
// </summary>
// <use visibility=local>
// <reviewed reviewer="" date="" tests="tExprGroup">
// </reviewed>
// <synopsis>
// Aggregate class determining per array index in a group the sum of values.
// </synopsis>
class TableExprGroupSumsArrayInt: public TableExprGroupFuncArrayInt
{
public:
TableExprGroupSumsArrayInt (TableExprNodeRep* node);
virtual ~TableExprGroupSumsArrayInt();
virtual void apply (const TableExprId& id);
};
// <summary>
// Aggregate class determining per array index in a group the product of values
// </summary>
// <use visibility=local>
// <reviewed reviewer="" date="" tests="tExprGroup">
// </reviewed>
// <synopsis>
// Aggregate class determining per array index in a group the product of values.
// </synopsis>
class TableExprGroupProductsArrayInt: public TableExprGroupFuncArrayInt
{
public:
TableExprGroupProductsArrayInt (TableExprNodeRep* node);
virtual ~TableExprGroupProductsArrayInt();
virtual void apply (const TableExprId& id);
virtual void finish();
};
// <summary>
// Aggregate class determining per array index in a group the sum of value squares
// in a group
// </summary>
// <use visibility=local>
// <reviewed reviewer="" date="" tests="tExprGroup">
// </reviewed>
// <synopsis>
// Aggregate class determining per array index in a group the sum of value squares.
// </synopsis>
class TableExprGroupSumSqrsArrayInt: public TableExprGroupFuncArrayInt
{
public:
TableExprGroupSumSqrsArrayInt (TableExprNodeRep* node);
virtual ~TableExprGroupSumSqrsArrayInt();
virtual void apply (const TableExprId& id);
};
// <summary>
// Aggregate class determining the minimum double array value in a group
// </summary>
// <use visibility=local>
// <reviewed reviewer="" date="" tests="tExprGroup">
// </reviewed>
// <synopsis>
// Aggregate class determining the minimum double array value in a group.
// </synopsis>
class TableExprGroupMinsArrayDouble: public TableExprGroupFuncArrayDouble
{
public:
TableExprGroupMinsArrayDouble (TableExprNodeRep* node);
virtual ~TableExprGroupMinsArrayDouble();
virtual void apply (const TableExprId& id);
virtual void finish();
};
// <summary>
// Aggregate class determining the maximum double array value in a group
// </summary>
// <use visibility=local>
// <reviewed reviewer="" date="" tests="tExprGroup">
// </reviewed>
// <synopsis>
// Aggregate class determining the maximum double array value in a group.
// </synopsis>
class TableExprGroupMaxsArrayDouble: public TableExprGroupFuncArrayDouble
{
public:
TableExprGroupMaxsArrayDouble (TableExprNodeRep* node);
virtual ~TableExprGroupMaxsArrayDouble();
virtual void apply (const TableExprId& id);
virtual void finish();
};
// <summary>
// Aggregate class determining the sum of double array values in a group
// </summary>
// <use visibility=local>
// <reviewed reviewer="" date="" tests="tExprGroup">
// </reviewed>
// <synopsis>
// Aggregate class determining the sum of double array values in a group.
// </synopsis>
class TableExprGroupSumsArrayDouble: public TableExprGroupFuncArrayDouble
{
public:
TableExprGroupSumsArrayDouble (TableExprNodeRep* node);
virtual ~TableExprGroupSumsArrayDouble();
virtual void apply (const TableExprId& id);
};
// <summary>
// Aggregate class determining the product of double array values in a group
// </summary>
// <use visibility=local>
// <reviewed reviewer="" date="" tests="tExprGroup">
// </reviewed>
// <synopsis>
// Aggregate class determining the product of double array values in a group.
// </synopsis>
class TableExprGroupProductsArrayDouble: public TableExprGroupFuncArrayDouble
{
public:
TableExprGroupProductsArrayDouble (TableExprNodeRep* node);
virtual ~TableExprGroupProductsArrayDouble();
virtual void apply (const TableExprId& id);
virtual void finish();
};
// <summary>
// Aggregate class determining the sum of squares of double array values
// in a group
// </summary>
// <use visibility=local>
// <reviewed reviewer="" date="" tests="tExprGroup">
// </reviewed>
// <synopsis>
// Aggregate class determining the sum of squares of double array values
// in a group.
// </synopsis>
class TableExprGroupSumSqrsArrayDouble: public TableExprGroupFuncArrayDouble
{
public:
TableExprGroupSumSqrsArrayDouble (TableExprNodeRep* node);
virtual ~TableExprGroupSumSqrsArrayDouble();
virtual void apply (const TableExprId& id);
};
// <summary>
// Aggregate class determining the mean of array values in a group
// </summary>
// <use visibility=local>
// <reviewed reviewer="" date="" tests="tExprGroup">
// </reviewed>
// <synopsis>
// Aggregate class determining the mean of array values in a group.
// </synopsis>
class TableExprGroupMeansArrayDouble: public TableExprGroupFuncArrayDouble
{
public:
TableExprGroupMeansArrayDouble (TableExprNodeRep* node);
virtual ~TableExprGroupMeansArrayDouble();
virtual void apply (const TableExprId& id);
virtual void finish();
private:
Array<Int64> itsNr;
};
// <summary>
// Aggregate class determining the variance of array values in a group
// </summary>
// <use visibility=local>
// <reviewed reviewer="" date="" tests="tExprGroup">
// </reviewed>
// <synopsis>
// Aggregate class determining the variance of array values in a group.
// It uses a running algorithm
// (see en.wikipedia.org/wiki/Algorithms_for_calculating_variance)
// </synopsis>
class TableExprGroupVariancesArrayDouble: public TableExprGroupFuncArrayDouble
{
public:
TableExprGroupVariancesArrayDouble (TableExprNodeRep* node, uInt ddof);
virtual ~TableExprGroupVariancesArrayDouble();
virtual void apply (const TableExprId& id);
virtual void finish();
protected:
uInt itsDdof;
Array<Int64> itsNr;
Array<Double> itsCurMean;
};
// <summary>
// Aggregate class determining the standard devation of array values
// in a group
// </summary>
// <use visibility=local>
// <reviewed reviewer="" date="" tests="tExprGroup">
// </reviewed>
// <synopsis>
// Aggregate class determining the standard deviation of array values
// in a group. It uses a running algorithm
// (see en.wikipedia.org/wiki/Algorithms_for_calculating_variance)
// </synopsis>
class TableExprGroupStdDevsArrayDouble: public TableExprGroupVariancesArrayDouble
{
public:
TableExprGroupStdDevsArrayDouble (TableExprNodeRep* node, uInt ddof);
virtual ~TableExprGroupStdDevsArrayDouble();
virtual void finish();
};
// <summary>
// Aggregate class determining the RMS of array values in a group
// </summary>
// <use visibility=local>
// <reviewed reviewer="" date="" tests="tExprGroup">
// </reviewed>
// <synopsis>
// Aggregate class determining the RMS of array values in a group.
// </synopsis>
class TableExprGroupRmssArrayDouble: public TableExprGroupFuncArrayDouble
{
public:
TableExprGroupRmssArrayDouble (TableExprNodeRep* node);
virtual ~TableExprGroupRmssArrayDouble();
virtual void apply (const TableExprId& id);
virtual void finish();
private:
Array<Int64> itsNr;
};
// <summary>
// Aggregate class determining the sum of complex array values in a group
// </summary>
// <use visibility=local>
// <reviewed reviewer="" date="" tests="tExprGroup">
// </reviewed>
// <synopsis>
// Aggregate class determining the sum of complex array values in a group.
// </synopsis>
class TableExprGroupSumsArrayDComplex: public TableExprGroupFuncArrayDComplex
{
public:
TableExprGroupSumsArrayDComplex (TableExprNodeRep* node);
virtual ~TableExprGroupSumsArrayDComplex();
virtual void apply (const TableExprId& id);
};
// <summary>
// Aggregate class determining the product of complex array values in a group
// </summary>
// <use visibility=local>
// <reviewed reviewer="" date="" tests="tExprGroup">
// </reviewed>
// <synopsis>
// Aggregate class determining the product of complex array values in a group.
// </synopsis>
class TableExprGroupProductsArrayDComplex: public TableExprGroupFuncArrayDComplex
{
public:
TableExprGroupProductsArrayDComplex (TableExprNodeRep* node);
virtual ~TableExprGroupProductsArrayDComplex();
virtual void apply (const TableExprId& id);
virtual void finish();
};
// <summary>
// Aggregate class determining the sum of squares of complex array values
// in a group
// </summary>
// <use visibility=local>
// <reviewed reviewer="" date="" tests="tExprGroup">
// </reviewed>
// <synopsis>
// Aggregate class determining the sum of squares of complex array values
// in a group.
// </synopsis>
class TableExprGroupSumSqrsArrayDComplex: public TableExprGroupFuncArrayDComplex
{
public:
TableExprGroupSumSqrsArrayDComplex (TableExprNodeRep* node);
virtual ~TableExprGroupSumSqrsArrayDComplex();
virtual void apply (const TableExprId& id);
};
// <summary>
// Aggregate class determining the mean of complex array values in a group
// </summary>
// <use visibility=local>
// <reviewed reviewer="" date="" tests="tExprGroup">
// </reviewed>
// <synopsis>
// Aggregate class determining the mean of complex array values in a group.
// </synopsis>
class TableExprGroupMeansArrayDComplex: public TableExprGroupFuncArrayDComplex
{
public:
TableExprGroupMeansArrayDComplex (TableExprNodeRep* node);
virtual ~TableExprGroupMeansArrayDComplex();
virtual void apply (const TableExprId& id);
virtual void finish();
private:
Array<Int64> itsNr;
};
// <summary>
// Aggregate class determining the variance of array values in a group
// </summary>
// <use visibility=local>
// <reviewed reviewer="" date="" tests="tExprGroup">
// </reviewed>
// <synopsis>
// Aggregate class determining the variance of array values in a group.
// It uses a running algorithm
// (see en.wikipedia.org/wiki/Algorithms_for_calculating_variance)
// Note that result is a Double value (npot DComplex).
// </synopsis>
class TableExprGroupVariancesArrayDComplex: public TableExprGroupFuncArrayDouble
{
public:
TableExprGroupVariancesArrayDComplex (TableExprNodeRep* node, uInt ddof);
virtual ~TableExprGroupVariancesArrayDComplex();
virtual void apply (const TableExprId& id);
virtual void finish();
protected:
uInt itsDdof;
Array<Int64> itsNr;
Array<DComplex> itsCurMean;
};
// <summary>
// Aggregate class determining the standard devation of array values
// in a group
// </summary>
// <use visibility=local>
// <reviewed reviewer="" date="" tests="tExprGroup">
// </reviewed>
// <synopsis>
// Aggregate class determining the standard deviation of array values
// in a group. It uses a running algorithm
// (see en.wikipedia.org/wiki/Algorithms_for_calculating_variance)
// </synopsis>
class TableExprGroupStdDevsArrayDComplex: public TableExprGroupVariancesArrayDComplex
{
public:
TableExprGroupStdDevsArrayDComplex (TableExprNodeRep* node, uInt ddof);
virtual ~TableExprGroupStdDevsArrayDComplex();
virtual void finish();
};
// <summary>
// Base aggregate class determining the histogram of values in a group
// </summary>
// <use visibility=local>
// <reviewed reviewer="" date="" tests="tExprGroup">
// </reviewed>
// <synopsis>
// Base aggregate class determining the histogram of values in a group
// </synopsis>
class TableExprGroupHistBase: public TableExprGroupFuncBase
{
public:
explicit TableExprGroupHistBase (TableExprNodeRep* node,
Int64 nbin, Double start, Double end);
virtual ~TableExprGroupHistBase();
virtual MArray<Int64> getArrayInt (const vector<TableExprId>&);
protected:
// Add the value to the histogram.
void add (Double value);
private:
Vector<Int64> itsHist;
Double itsStart;
Double itsWidth;
};
// <summary>
// Aggregate class determining the histogram of scalar values in a group
// </summary>
// <use visibility=local>
// <reviewed reviewer="" date="" tests="tExprGroup">
// </reviewed>
// <synopsis>
// Aggregate class determining the histogram of scalar values in a group
// </synopsis>
class TableExprGroupHistScalar: public TableExprGroupHistBase
{
public:
explicit TableExprGroupHistScalar (TableExprNodeRep* node,
Int64 nbin, Double start, Double end);
virtual ~TableExprGroupHistScalar();
virtual void apply (const TableExprId& id);
};
// <summary>
// Aggregate class determining the histogram of integer array values in a group
// </summary>
// <use visibility=local>
// <reviewed reviewer="" date="" tests="tExprGroup">
// </reviewed>
// <synopsis>
// Aggregate class determining the histogram of integer array values in a group
// </synopsis>
class TableExprGroupHistInt: public TableExprGroupHistBase
{
public:
explicit TableExprGroupHistInt (TableExprNodeRep* node,
Int64 nbin, Double start, Double end);
virtual ~TableExprGroupHistInt();
virtual void apply (const TableExprId& id);
};
// <summary>
// Aggregate class determining the histogram of double array values in a group
// </summary>
// <use visibility=local>
// <reviewed reviewer="" date="" tests="tExprGroup">
// </reviewed>
// <synopsis>
// Aggregate class determining the histogram of double array values in a group
// </synopsis>
class TableExprGroupHistDouble: public TableExprGroupHistBase
{
public:
explicit TableExprGroupHistDouble (TableExprNodeRep* node,
Int64 nbin, Double start, Double end);
virtual ~TableExprGroupHistDouble();
virtual void apply (const TableExprId& id);
};
} //# NAMESPACE CASACORE - END
#endif
casacore::Array
Definition Array.h:155
casacore::MArray
Definition MArray.h:68
casacore::TableExprGroupArrayAll::TableExprGroupArrayAll
TableExprGroupArrayAll(TableExprNodeRep *node)
casacore::TableExprGroupArrayAll::apply
virtual void apply(const TableExprId &id)
Get the operand's value for the given row and apply it to the aggregation.
casacore::TableExprGroupArrayAll::~TableExprGroupArrayAll
virtual ~TableExprGroupArrayAll()
casacore::TableExprGroupArrayAlls::TableExprGroupArrayAlls
TableExprGroupArrayAlls(TableExprNodeRep *node)
casacore::TableExprGroupArrayAlls::apply
virtual void apply(const TableExprId &id)
Get the operand's value for the given row and apply it to the aggregation.
casacore::TableExprGroupArrayAlls::~TableExprGroupArrayAlls
virtual ~TableExprGroupArrayAlls()
casacore::TableExprGroupArrayAny::TableExprGroupArrayAny
TableExprGroupArrayAny(TableExprNodeRep *node)
casacore::TableExprGroupArrayAny::apply
virtual void apply(const TableExprId &id)
Get the operand's value for the given row and apply it to the aggregation.
casacore::TableExprGroupArrayAny::~TableExprGroupArrayAny
virtual ~TableExprGroupArrayAny()
casacore::TableExprGroupArrayAnys::apply
virtual void apply(const TableExprId &id)
Get the operand's value for the given row and apply it to the aggregation.
casacore::TableExprGroupArrayAnys::TableExprGroupArrayAnys
TableExprGroupArrayAnys(TableExprNodeRep *node)
casacore::TableExprGroupArrayAnys::~TableExprGroupArrayAnys
virtual ~TableExprGroupArrayAnys()
casacore::TableExprGroupArrayNFalse::~TableExprGroupArrayNFalse
virtual ~TableExprGroupArrayNFalse()
casacore::TableExprGroupArrayNFalse::TableExprGroupArrayNFalse
TableExprGroupArrayNFalse(TableExprNodeRep *node)
casacore::TableExprGroupArrayNFalse::apply
virtual void apply(const TableExprId &id)
Get the operand's value for the given row and apply it to the aggregation.
casacore::TableExprGroupArrayNFalses::apply
virtual void apply(const TableExprId &id)
Get the operand's value for the given row and apply it to the aggregation.
casacore::TableExprGroupArrayNFalses::TableExprGroupArrayNFalses
TableExprGroupArrayNFalses(TableExprNodeRep *node)
casacore::TableExprGroupArrayNFalses::~TableExprGroupArrayNFalses
virtual ~TableExprGroupArrayNFalses()
casacore::TableExprGroupArrayNTrue::~TableExprGroupArrayNTrue
virtual ~TableExprGroupArrayNTrue()
casacore::TableExprGroupArrayNTrue::apply
virtual void apply(const TableExprId &id)
Get the operand's value for the given row and apply it to the aggregation.
casacore::TableExprGroupArrayNTrue::TableExprGroupArrayNTrue
TableExprGroupArrayNTrue(TableExprNodeRep *node)
casacore::TableExprGroupArrayNTrues::~TableExprGroupArrayNTrues
virtual ~TableExprGroupArrayNTrues()
casacore::TableExprGroupArrayNTrues::apply
virtual void apply(const TableExprId &id)
Get the operand's value for the given row and apply it to the aggregation.
casacore::TableExprGroupArrayNTrues::TableExprGroupArrayNTrues
TableExprGroupArrayNTrues(TableExprNodeRep *node)
casacore::TableExprGroupFractileArrayDouble::TableExprGroupFractileArrayDouble
TableExprGroupFractileArrayDouble(TableExprNodeRep *node, Double fractile)
casacore::TableExprGroupFractileArrayDouble::~TableExprGroupFractileArrayDouble
virtual ~TableExprGroupFractileArrayDouble()
casacore::TableExprGroupFractileArrayDouble::isLazy
virtual Bool isLazy() const
Does the aggregate function use lazy semantics?
casacore::TableExprGroupFractileArrayDouble::itsFrac
Double itsFrac
Definition ExprGroupAggrFuncArray.h:388
casacore::TableExprGroupFractileArrayDouble::getDouble
virtual Double getDouble(const vector< TableExprId > &ids)
casacore::TableExprGroupFractileArrayDouble::apply
virtual void apply(const TableExprId &id)
Get the operand's value for the given row and apply it to the aggregation.
casacore::TableExprGroupFuncArrayBool::TableExprGroupFuncArrayBool
TableExprGroupFuncArrayBool(TableExprNodeRep *node)
Definition ExprGroup.h:633
casacore::TableExprGroupFuncArrayDComplex::TableExprGroupFuncArrayDComplex
TableExprGroupFuncArrayDComplex(TableExprNodeRep *node)
Definition ExprGroup.h:717
casacore::TableExprGroupFuncArrayDouble::TableExprGroupFuncArrayDouble
TableExprGroupFuncArrayDouble(TableExprNodeRep *node)
Definition ExprGroup.h:689
casacore::TableExprGroupFuncArrayInt::TableExprGroupFuncArrayInt
TableExprGroupFuncArrayInt(TableExprNodeRep *node)
Definition ExprGroup.h:661
casacore::TableExprGroupFuncBase::TableExprGroupFuncBase
TableExprGroupFuncBase(TableExprNodeRep *node)
Construct from the TaQL aggregation node.
casacore::TableExprGroupFuncBool::TableExprGroupFuncBool
TableExprGroupFuncBool(TableExprNodeRep *node)
Definition ExprGroup.h:469
casacore::TableExprGroupFuncDComplex::TableExprGroupFuncDComplex
TableExprGroupFuncDComplex(TableExprNodeRep *node, const DComplex &initValue=DComplex())
Definition ExprGroup.h:552
casacore::TableExprGroupFuncDouble::TableExprGroupFuncDouble
TableExprGroupFuncDouble(TableExprNodeRep *node, Double initValue=0)
Definition ExprGroup.h:525
casacore::TableExprGroupFuncInt::TableExprGroupFuncInt
TableExprGroupFuncInt(TableExprNodeRep *node, Int64 initValue=0)
Definition ExprGroup.h:498
casacore::TableExprGroupHistBase::getArrayInt
virtual MArray< Int64 > getArrayInt(const vector< TableExprId > &)
casacore::TableExprGroupHistBase::TableExprGroupHistBase
TableExprGroupHistBase(TableExprNodeRep *node, Int64 nbin, Double start, Double end)
casacore::TableExprGroupHistBase::itsStart
Double itsStart
Definition ExprGroupAggrFuncArray.h:984
casacore::TableExprGroupHistBase::~TableExprGroupHistBase
virtual ~TableExprGroupHistBase()
casacore::TableExprGroupHistBase::add
void add(Double value)
Add the value to the histogram.
casacore::TableExprGroupHistBase::itsWidth
Double itsWidth
Definition ExprGroupAggrFuncArray.h:985
casacore::TableExprGroupHistBase::itsHist
Vector< Int64 > itsHist
Definition ExprGroupAggrFuncArray.h:983
casacore::TableExprGroupHistDouble::TableExprGroupHistDouble
TableExprGroupHistDouble(TableExprNodeRep *node, Int64 nbin, Double start, Double end)
casacore::TableExprGroupHistDouble::apply
virtual void apply(const TableExprId &id)
Get the operand's value for the given row and apply it to the aggregation.
casacore::TableExprGroupHistDouble::~TableExprGroupHistDouble
virtual ~TableExprGroupHistDouble()
casacore::TableExprGroupHistInt::TableExprGroupHistInt
TableExprGroupHistInt(TableExprNodeRep *node, Int64 nbin, Double start, Double end)
casacore::TableExprGroupHistInt::~TableExprGroupHistInt
virtual ~TableExprGroupHistInt()
casacore::TableExprGroupHistInt::apply
virtual void apply(const TableExprId &id)
Get the operand's value for the given row and apply it to the aggregation.
casacore::TableExprGroupHistScalar::apply
virtual void apply(const TableExprId &id)
Get the operand's value for the given row and apply it to the aggregation.
casacore::TableExprGroupHistScalar::TableExprGroupHistScalar
TableExprGroupHistScalar(TableExprNodeRep *node, Int64 nbin, Double start, Double end)
casacore::TableExprGroupHistScalar::~TableExprGroupHistScalar
virtual ~TableExprGroupHistScalar()
casacore::TableExprGroupMaxArrayDouble::~TableExprGroupMaxArrayDouble
virtual ~TableExprGroupMaxArrayDouble()
casacore::TableExprGroupMaxArrayDouble::apply
virtual void apply(const TableExprId &id)
Get the operand's value for the given row and apply it to the aggregation.
casacore::TableExprGroupMaxArrayDouble::TableExprGroupMaxArrayDouble
TableExprGroupMaxArrayDouble(TableExprNodeRep *node)
casacore::TableExprGroupMaxArrayInt::~TableExprGroupMaxArrayInt
virtual ~TableExprGroupMaxArrayInt()
casacore::TableExprGroupMaxArrayInt::TableExprGroupMaxArrayInt
TableExprGroupMaxArrayInt(TableExprNodeRep *node)
casacore::TableExprGroupMaxArrayInt::apply
virtual void apply(const TableExprId &id)
Get the operand's value for the given row and apply it to the aggregation.
casacore::TableExprGroupMaxsArrayDouble::TableExprGroupMaxsArrayDouble
TableExprGroupMaxsArrayDouble(TableExprNodeRep *node)
casacore::TableExprGroupMaxsArrayDouble::~TableExprGroupMaxsArrayDouble
virtual ~TableExprGroupMaxsArrayDouble()
casacore::TableExprGroupMaxsArrayDouble::finish
virtual void finish()
If needed, finish the aggregation.
casacore::TableExprGroupMaxsArrayDouble::apply
virtual void apply(const TableExprId &id)
Get the operand's value for the given row and apply it to the aggregation.
casacore::TableExprGroupMaxsArrayInt::finish
virtual void finish()
If needed, finish the aggregation.
casacore::TableExprGroupMaxsArrayInt::apply
virtual void apply(const TableExprId &id)
Get the operand's value for the given row and apply it to the aggregation.
casacore::TableExprGroupMaxsArrayInt::~TableExprGroupMaxsArrayInt
virtual ~TableExprGroupMaxsArrayInt()
casacore::TableExprGroupMaxsArrayInt::TableExprGroupMaxsArrayInt
TableExprGroupMaxsArrayInt(TableExprNodeRep *node)
casacore::TableExprGroupMeanArrayDComplex::TableExprGroupMeanArrayDComplex
TableExprGroupMeanArrayDComplex(TableExprNodeRep *node)
casacore::TableExprGroupMeanArrayDComplex::finish
virtual void finish()
If needed, finish the aggregation.
casacore::TableExprGroupMeanArrayDComplex::~TableExprGroupMeanArrayDComplex
virtual ~TableExprGroupMeanArrayDComplex()
casacore::TableExprGroupMeanArrayDComplex::apply
virtual void apply(const TableExprId &id)
Get the operand's value for the given row and apply it to the aggregation.
casacore::TableExprGroupMeanArrayDComplex::itsNr
Int64 itsNr
Definition ExprGroupAggrFuncArray.h:462
casacore::TableExprGroupMeanArrayDouble::itsNr
Int64 itsNr
Definition ExprGroupAggrFuncArray.h:299
casacore::TableExprGroupMeanArrayDouble::apply
virtual void apply(const TableExprId &id)
Get the operand's value for the given row and apply it to the aggregation.
casacore::TableExprGroupMeanArrayDouble::~TableExprGroupMeanArrayDouble
virtual ~TableExprGroupMeanArrayDouble()
casacore::TableExprGroupMeanArrayDouble::finish
virtual void finish()
If needed, finish the aggregation.
casacore::TableExprGroupMeanArrayDouble::TableExprGroupMeanArrayDouble
TableExprGroupMeanArrayDouble(TableExprNodeRep *node)
casacore::TableExprGroupMeansArrayDComplex::TableExprGroupMeansArrayDComplex
TableExprGroupMeansArrayDComplex(TableExprNodeRep *node)
casacore::TableExprGroupMeansArrayDComplex::~TableExprGroupMeansArrayDComplex
virtual ~TableExprGroupMeansArrayDComplex()
casacore::TableExprGroupMeansArrayDComplex::itsNr
Array< Int64 > itsNr
Definition ExprGroupAggrFuncArray.h:914
casacore::TableExprGroupMeansArrayDComplex::finish
virtual void finish()
If needed, finish the aggregation.
casacore::TableExprGroupMeansArrayDComplex::apply
virtual void apply(const TableExprId &id)
Get the operand's value for the given row and apply it to the aggregation.
casacore::TableExprGroupMeansArrayDouble::~TableExprGroupMeansArrayDouble
virtual ~TableExprGroupMeansArrayDouble()
casacore::TableExprGroupMeansArrayDouble::itsNr
Array< Int64 > itsNr
Definition ExprGroupAggrFuncArray.h:775
casacore::TableExprGroupMeansArrayDouble::TableExprGroupMeansArrayDouble
TableExprGroupMeansArrayDouble(TableExprNodeRep *node)
casacore::TableExprGroupMeansArrayDouble::finish
virtual void finish()
If needed, finish the aggregation.
casacore::TableExprGroupMeansArrayDouble::apply
virtual void apply(const TableExprId &id)
Get the operand's value for the given row and apply it to the aggregation.
casacore::TableExprGroupMinArrayDouble::~TableExprGroupMinArrayDouble
virtual ~TableExprGroupMinArrayDouble()
casacore::TableExprGroupMinArrayDouble::TableExprGroupMinArrayDouble
TableExprGroupMinArrayDouble(TableExprNodeRep *node)
casacore::TableExprGroupMinArrayDouble::apply
virtual void apply(const TableExprId &id)
Get the operand's value for the given row and apply it to the aggregation.
casacore::TableExprGroupMinArrayInt::apply
virtual void apply(const TableExprId &id)
Get the operand's value for the given row and apply it to the aggregation.
casacore::TableExprGroupMinArrayInt::~TableExprGroupMinArrayInt
virtual ~TableExprGroupMinArrayInt()
casacore::TableExprGroupMinArrayInt::TableExprGroupMinArrayInt
TableExprGroupMinArrayInt(TableExprNodeRep *node)
casacore::TableExprGroupMinsArrayDouble::~TableExprGroupMinsArrayDouble
virtual ~TableExprGroupMinsArrayDouble()
casacore::TableExprGroupMinsArrayDouble::finish
virtual void finish()
If needed, finish the aggregation.
casacore::TableExprGroupMinsArrayDouble::TableExprGroupMinsArrayDouble
TableExprGroupMinsArrayDouble(TableExprNodeRep *node)
casacore::TableExprGroupMinsArrayDouble::apply
virtual void apply(const TableExprId &id)
Get the operand's value for the given row and apply it to the aggregation.
casacore::TableExprGroupMinsArrayInt::finish
virtual void finish()
If needed, finish the aggregation.
casacore::TableExprGroupMinsArrayInt::TableExprGroupMinsArrayInt
TableExprGroupMinsArrayInt(TableExprNodeRep *node)
casacore::TableExprGroupMinsArrayInt::~TableExprGroupMinsArrayInt
virtual ~TableExprGroupMinsArrayInt()
casacore::TableExprGroupMinsArrayInt::apply
virtual void apply(const TableExprId &id)
Get the operand's value for the given row and apply it to the aggregation.
casacore::TableExprGroupProductArrayDComplex::~TableExprGroupProductArrayDComplex
virtual ~TableExprGroupProductArrayDComplex()
casacore::TableExprGroupProductArrayDComplex::apply
virtual void apply(const TableExprId &id)
Get the operand's value for the given row and apply it to the aggregation.
casacore::TableExprGroupProductArrayDComplex::TableExprGroupProductArrayDComplex
TableExprGroupProductArrayDComplex(TableExprNodeRep *node)
casacore::TableExprGroupProductArrayDouble::apply
virtual void apply(const TableExprId &id)
Get the operand's value for the given row and apply it to the aggregation.
casacore::TableExprGroupProductArrayDouble::~TableExprGroupProductArrayDouble
virtual ~TableExprGroupProductArrayDouble()
casacore::TableExprGroupProductArrayDouble::TableExprGroupProductArrayDouble
TableExprGroupProductArrayDouble(TableExprNodeRep *node)
casacore::TableExprGroupProductArrayInt::TableExprGroupProductArrayInt
TableExprGroupProductArrayInt(TableExprNodeRep *node)
casacore::TableExprGroupProductArrayInt::~TableExprGroupProductArrayInt
virtual ~TableExprGroupProductArrayInt()
casacore::TableExprGroupProductArrayInt::apply
virtual void apply(const TableExprId &id)
Get the operand's value for the given row and apply it to the aggregation.
casacore::TableExprGroupProductsArrayDComplex::TableExprGroupProductsArrayDComplex
TableExprGroupProductsArrayDComplex(TableExprNodeRep *node)
casacore::TableExprGroupProductsArrayDComplex::finish
virtual void finish()
If needed, finish the aggregation.
casacore::TableExprGroupProductsArrayDComplex::apply
virtual void apply(const TableExprId &id)
Get the operand's value for the given row and apply it to the aggregation.
casacore::TableExprGroupProductsArrayDComplex::~TableExprGroupProductsArrayDComplex
virtual ~TableExprGroupProductsArrayDComplex()
casacore::TableExprGroupProductsArrayDouble::TableExprGroupProductsArrayDouble
TableExprGroupProductsArrayDouble(TableExprNodeRep *node)
casacore::TableExprGroupProductsArrayDouble::apply
virtual void apply(const TableExprId &id)
Get the operand's value for the given row and apply it to the aggregation.
casacore::TableExprGroupProductsArrayDouble::~TableExprGroupProductsArrayDouble
virtual ~TableExprGroupProductsArrayDouble()
casacore::TableExprGroupProductsArrayDouble::finish
virtual void finish()
If needed, finish the aggregation.
casacore::TableExprGroupProductsArrayInt::finish
virtual void finish()
If needed, finish the aggregation.
casacore::TableExprGroupProductsArrayInt::apply
virtual void apply(const TableExprId &id)
Get the operand's value for the given row and apply it to the aggregation.
casacore::TableExprGroupProductsArrayInt::~TableExprGroupProductsArrayInt
virtual ~TableExprGroupProductsArrayInt()
casacore::TableExprGroupProductsArrayInt::TableExprGroupProductsArrayInt
TableExprGroupProductsArrayInt(TableExprNodeRep *node)
casacore::TableExprGroupRmsArrayDouble::itsNr
Int64 itsNr
Definition ExprGroupAggrFuncArray.h:363
casacore::TableExprGroupRmsArrayDouble::~TableExprGroupRmsArrayDouble
virtual ~TableExprGroupRmsArrayDouble()
casacore::TableExprGroupRmsArrayDouble::apply
virtual void apply(const TableExprId &id)
Get the operand's value for the given row and apply it to the aggregation.
casacore::TableExprGroupRmsArrayDouble::TableExprGroupRmsArrayDouble
TableExprGroupRmsArrayDouble(TableExprNodeRep *node)
casacore::TableExprGroupRmsArrayDouble::finish
virtual void finish()
If needed, finish the aggregation.
casacore::TableExprGroupRmssArrayDouble::itsNr
Array< Int64 > itsNr
Definition ExprGroupAggrFuncArray.h:839
casacore::TableExprGroupRmssArrayDouble::finish
virtual void finish()
If needed, finish the aggregation.
casacore::TableExprGroupRmssArrayDouble::apply
virtual void apply(const TableExprId &id)
Get the operand's value for the given row and apply it to the aggregation.
casacore::TableExprGroupRmssArrayDouble::TableExprGroupRmssArrayDouble
TableExprGroupRmssArrayDouble(TableExprNodeRep *node)
casacore::TableExprGroupRmssArrayDouble::~TableExprGroupRmssArrayDouble
virtual ~TableExprGroupRmssArrayDouble()
casacore::TableExprGroupStdDevArrayDComplex::finish
virtual void finish()
If needed, finish the aggregation.
casacore::TableExprGroupStdDevArrayDComplex::~TableExprGroupStdDevArrayDComplex
virtual ~TableExprGroupStdDevArrayDComplex()
casacore::TableExprGroupStdDevArrayDComplex::TableExprGroupStdDevArrayDComplex
TableExprGroupStdDevArrayDComplex(TableExprNodeRep *node, uInt ddof)
casacore::TableExprGroupStdDevArrayDouble::~TableExprGroupStdDevArrayDouble
virtual ~TableExprGroupStdDevArrayDouble()
casacore::TableExprGroupStdDevArrayDouble::finish
virtual void finish()
If needed, finish the aggregation.
casacore::TableExprGroupStdDevArrayDouble::TableExprGroupStdDevArrayDouble
TableExprGroupStdDevArrayDouble(TableExprNodeRep *node, uInt ddof)
casacore::TableExprGroupStdDevsArrayDComplex::TableExprGroupStdDevsArrayDComplex
TableExprGroupStdDevsArrayDComplex(TableExprNodeRep *node, uInt ddof)
casacore::TableExprGroupStdDevsArrayDComplex::finish
virtual void finish()
If needed, finish the aggregation.
casacore::TableExprGroupStdDevsArrayDComplex::~TableExprGroupStdDevsArrayDComplex
virtual ~TableExprGroupStdDevsArrayDComplex()
casacore::TableExprGroupStdDevsArrayDouble::finish
virtual void finish()
If needed, finish the aggregation.
casacore::TableExprGroupStdDevsArrayDouble::TableExprGroupStdDevsArrayDouble
TableExprGroupStdDevsArrayDouble(TableExprNodeRep *node, uInt ddof)
casacore::TableExprGroupStdDevsArrayDouble::~TableExprGroupStdDevsArrayDouble
virtual ~TableExprGroupStdDevsArrayDouble()
casacore::TableExprGroupSumArrayDComplex::apply
virtual void apply(const TableExprId &id)
Get the operand's value for the given row and apply it to the aggregation.
casacore::TableExprGroupSumArrayDComplex::~TableExprGroupSumArrayDComplex
virtual ~TableExprGroupSumArrayDComplex()
casacore::TableExprGroupSumArrayDComplex::TableExprGroupSumArrayDComplex
TableExprGroupSumArrayDComplex(TableExprNodeRep *node)
casacore::TableExprGroupSumArrayDouble::~TableExprGroupSumArrayDouble
virtual ~TableExprGroupSumArrayDouble()
casacore::TableExprGroupSumArrayDouble::TableExprGroupSumArrayDouble
TableExprGroupSumArrayDouble(TableExprNodeRep *node)
casacore::TableExprGroupSumArrayDouble::apply
virtual void apply(const TableExprId &id)
Get the operand's value for the given row and apply it to the aggregation.
casacore::TableExprGroupSumArrayInt::apply
virtual void apply(const TableExprId &id)
Get the operand's value for the given row and apply it to the aggregation.
casacore::TableExprGroupSumArrayInt::~TableExprGroupSumArrayInt
virtual ~TableExprGroupSumArrayInt()
casacore::TableExprGroupSumArrayInt::TableExprGroupSumArrayInt
TableExprGroupSumArrayInt(TableExprNodeRep *node)
casacore::TableExprGroupSumSqrArrayDComplex::~TableExprGroupSumSqrArrayDComplex
virtual ~TableExprGroupSumSqrArrayDComplex()
casacore::TableExprGroupSumSqrArrayDComplex::apply
virtual void apply(const TableExprId &id)
Get the operand's value for the given row and apply it to the aggregation.
casacore::TableExprGroupSumSqrArrayDComplex::TableExprGroupSumSqrArrayDComplex
TableExprGroupSumSqrArrayDComplex(TableExprNodeRep *node)
casacore::TableExprGroupSumSqrArrayDouble::apply
virtual void apply(const TableExprId &id)
Get the operand's value for the given row and apply it to the aggregation.
casacore::TableExprGroupSumSqrArrayDouble::TableExprGroupSumSqrArrayDouble
TableExprGroupSumSqrArrayDouble(TableExprNodeRep *node)
casacore::TableExprGroupSumSqrArrayDouble::~TableExprGroupSumSqrArrayDouble
virtual ~TableExprGroupSumSqrArrayDouble()
casacore::TableExprGroupSumSqrArrayInt::apply
virtual void apply(const TableExprId &id)
Get the operand's value for the given row and apply it to the aggregation.
casacore::TableExprGroupSumSqrArrayInt::TableExprGroupSumSqrArrayInt
TableExprGroupSumSqrArrayInt(TableExprNodeRep *node)
casacore::TableExprGroupSumSqrArrayInt::~TableExprGroupSumSqrArrayInt
virtual ~TableExprGroupSumSqrArrayInt()
casacore::TableExprGroupSumSqrsArrayDComplex::apply
virtual void apply(const TableExprId &id)
Get the operand's value for the given row and apply it to the aggregation.
casacore::TableExprGroupSumSqrsArrayDComplex::TableExprGroupSumSqrsArrayDComplex
TableExprGroupSumSqrsArrayDComplex(TableExprNodeRep *node)
casacore::TableExprGroupSumSqrsArrayDComplex::~TableExprGroupSumSqrsArrayDComplex
virtual ~TableExprGroupSumSqrsArrayDComplex()
casacore::TableExprGroupSumSqrsArrayDouble::~TableExprGroupSumSqrsArrayDouble
virtual ~TableExprGroupSumSqrsArrayDouble()
casacore::TableExprGroupSumSqrsArrayDouble::TableExprGroupSumSqrsArrayDouble
TableExprGroupSumSqrsArrayDouble(TableExprNodeRep *node)
casacore::TableExprGroupSumSqrsArrayDouble::apply
virtual void apply(const TableExprId &id)
Get the operand's value for the given row and apply it to the aggregation.
casacore::TableExprGroupSumSqrsArrayInt::apply
virtual void apply(const TableExprId &id)
Get the operand's value for the given row and apply it to the aggregation.
casacore::TableExprGroupSumSqrsArrayInt::~TableExprGroupSumSqrsArrayInt
virtual ~TableExprGroupSumSqrsArrayInt()
casacore::TableExprGroupSumSqrsArrayInt::TableExprGroupSumSqrsArrayInt
TableExprGroupSumSqrsArrayInt(TableExprNodeRep *node)
casacore::TableExprGroupSumsArrayDComplex::~TableExprGroupSumsArrayDComplex
virtual ~TableExprGroupSumsArrayDComplex()
casacore::TableExprGroupSumsArrayDComplex::TableExprGroupSumsArrayDComplex
TableExprGroupSumsArrayDComplex(TableExprNodeRep *node)
casacore::TableExprGroupSumsArrayDComplex::apply
virtual void apply(const TableExprId &id)
Get the operand's value for the given row and apply it to the aggregation.
casacore::TableExprGroupSumsArrayDouble::TableExprGroupSumsArrayDouble
TableExprGroupSumsArrayDouble(TableExprNodeRep *node)
casacore::TableExprGroupSumsArrayDouble::apply
virtual void apply(const TableExprId &id)
Get the operand's value for the given row and apply it to the aggregation.
casacore::TableExprGroupSumsArrayDouble::~TableExprGroupSumsArrayDouble
virtual ~TableExprGroupSumsArrayDouble()
casacore::TableExprGroupSumsArrayInt::apply
virtual void apply(const TableExprId &id)
Get the operand's value for the given row and apply it to the aggregation.
casacore::TableExprGroupSumsArrayInt::TableExprGroupSumsArrayInt
TableExprGroupSumsArrayInt(TableExprNodeRep *node)
casacore::TableExprGroupSumsArrayInt::~TableExprGroupSumsArrayInt
virtual ~TableExprGroupSumsArrayInt()
casacore::TableExprGroupVarianceArrayDComplex::itsDdof
uInt itsDdof
Definition ExprGroupAggrFuncArray.h:485
casacore::TableExprGroupVarianceArrayDComplex::~TableExprGroupVarianceArrayDComplex
virtual ~TableExprGroupVarianceArrayDComplex()
casacore::TableExprGroupVarianceArrayDComplex::itsCurMean
DComplex itsCurMean
Definition ExprGroupAggrFuncArray.h:487
casacore::TableExprGroupVarianceArrayDComplex::apply
virtual void apply(const TableExprId &id)
Get the operand's value for the given row and apply it to the aggregation.
casacore::TableExprGroupVarianceArrayDComplex::finish
virtual void finish()
If needed, finish the aggregation.
casacore::TableExprGroupVarianceArrayDComplex::itsNr
Int64 itsNr
Definition ExprGroupAggrFuncArray.h:486
casacore::TableExprGroupVarianceArrayDComplex::TableExprGroupVarianceArrayDComplex
TableExprGroupVarianceArrayDComplex(TableExprNodeRep *node, uInt ddof)
casacore::TableExprGroupVarianceArrayDouble::itsCurMean
Double itsCurMean
Definition ExprGroupAggrFuncArray.h:323
casacore::TableExprGroupVarianceArrayDouble::apply
virtual void apply(const TableExprId &id)
Get the operand's value for the given row and apply it to the aggregation.
casacore::TableExprGroupVarianceArrayDouble::TableExprGroupVarianceArrayDouble
TableExprGroupVarianceArrayDouble(TableExprNodeRep *node, uInt ddof)
casacore::TableExprGroupVarianceArrayDouble::~TableExprGroupVarianceArrayDouble
virtual ~TableExprGroupVarianceArrayDouble()
casacore::TableExprGroupVarianceArrayDouble::itsNr
Int64 itsNr
Definition ExprGroupAggrFuncArray.h:322
casacore::TableExprGroupVarianceArrayDouble::finish
virtual void finish()
If needed, finish the aggregation.
casacore::TableExprGroupVarianceArrayDouble::itsDdof
uInt itsDdof
Definition ExprGroupAggrFuncArray.h:321
casacore::TableExprGroupVariancesArrayDComplex::itsCurMean
Array< DComplex > itsCurMean
Definition ExprGroupAggrFuncArray.h:939
casacore::TableExprGroupVariancesArrayDComplex::TableExprGroupVariancesArrayDComplex
TableExprGroupVariancesArrayDComplex(TableExprNodeRep *node, uInt ddof)
casacore::TableExprGroupVariancesArrayDComplex::itsDdof
uInt itsDdof
Definition ExprGroupAggrFuncArray.h:937
casacore::TableExprGroupVariancesArrayDComplex::itsNr
Array< Int64 > itsNr
Definition ExprGroupAggrFuncArray.h:938
casacore::TableExprGroupVariancesArrayDComplex::~TableExprGroupVariancesArrayDComplex
virtual ~TableExprGroupVariancesArrayDComplex()
casacore::TableExprGroupVariancesArrayDComplex::apply
virtual void apply(const TableExprId &id)
Get the operand's value for the given row and apply it to the aggregation.
casacore::TableExprGroupVariancesArrayDComplex::finish
virtual void finish()
If needed, finish the aggregation.
casacore::TableExprGroupVariancesArrayDouble::apply
virtual void apply(const TableExprId &id)
Get the operand's value for the given row and apply it to the aggregation.
casacore::TableExprGroupVariancesArrayDouble::finish
virtual void finish()
If needed, finish the aggregation.
casacore::TableExprGroupVariancesArrayDouble::itsNr
Array< Int64 > itsNr
Definition ExprGroupAggrFuncArray.h:798
casacore::TableExprGroupVariancesArrayDouble::~TableExprGroupVariancesArrayDouble
virtual ~TableExprGroupVariancesArrayDouble()
casacore::TableExprGroupVariancesArrayDouble::itsDdof
uInt itsDdof
Definition ExprGroupAggrFuncArray.h:797
casacore::TableExprGroupVariancesArrayDouble::itsCurMean
Array< Double > itsCurMean
Definition ExprGroupAggrFuncArray.h:799
casacore::TableExprGroupVariancesArrayDouble::TableExprGroupVariancesArrayDouble
TableExprGroupVariancesArrayDouble(TableExprNodeRep *node, uInt ddof)
casacore::TableExprId
Definition TableExprId.h:95
casacore::TableExprNodeRep
Abstract base class for a node in a table column expression tree.
Definition ExprNodeRep.h:202
casacore::Vector
Definition Vector.h:82
casacore
this file contains all the compiler specific defines
Definition mainpage.dox:28
casacore::fractile
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.
casacore::uInt
unsigned int uInt
Definition aipstype.h:49
casacore::Int64
long long Int64
Define the extra non-standard types used by Casacore (like proposed uSize, Size).
Definition aipsxtype.h:36
casacore::Bool
bool Bool
Define the standard types used by Casacore.
Definition aipstype.h:40
casacore::value
NewDelAllocator< T > NewDelAllocator< T >::value
Definition Allocator.h:368
casacore::Double
double Double
Definition aipstype.h:53