Loading...
Searching...
No Matches
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
casacore::TableExprGroupAll::TableExprGroupAll
TableExprGroupAll(TableExprNodeRep *node)
casacore::TableExprGroupAll::~TableExprGroupAll
virtual ~TableExprGroupAll()
casacore::TableExprGroupAll::apply
virtual void apply(const TableExprId &id)
Get the operand's value for the given row and apply it to the aggregation.
casacore::TableExprGroupAny::~TableExprGroupAny
virtual ~TableExprGroupAny()
casacore::TableExprGroupAny::TableExprGroupAny
TableExprGroupAny(TableExprNodeRep *node)
casacore::TableExprGroupAny::apply
virtual void apply(const TableExprId &id)
Get the operand's value for the given row and apply it to the aggregation.
casacore::TableExprGroupCountAll::setResult
void setResult(Int64 cnt)
Set result in case it is known directly.
Definition ExprGroupAggrFunc.h:57
casacore::TableExprGroupCountAll::~TableExprGroupCountAll
virtual ~TableExprGroupCountAll()
casacore::TableExprGroupCountAll::TableExprGroupCountAll
TableExprGroupCountAll(TableExprNodeRep *node)
casacore::TableExprGroupCountAll::apply
virtual void apply(const TableExprId &id)
Get the operand's value for the given row and apply it to the aggregation.
casacore::TableExprGroupCount::TableExprGroupCount
TableExprGroupCount(TableExprNodeRep *node)
casacore::TableExprGroupCount::~TableExprGroupCount
virtual ~TableExprGroupCount()
casacore::TableExprGroupCount::itsColumn
TableExprNodeArrayColumn * itsColumn
Definition ExprGroupAggrFunc.h:77
casacore::TableExprGroupCount::apply
virtual void apply(const TableExprId &id)
Get the operand's value for the given row and apply it to the aggregation.
casacore::TableExprGroupFractileDouble::isLazy
virtual Bool isLazy() const
Does the aggregate function use lazy semantics?
casacore::TableExprGroupFractileDouble::itsFrac
Double itsFrac
Definition ExprGroupAggrFunc.h:424
casacore::TableExprGroupFractileDouble::apply
virtual void apply(const TableExprId &id)
Get the operand's value for the given row and apply it to the aggregation.
casacore::TableExprGroupFractileDouble::getDouble
virtual Double getDouble(const vector< TableExprId > &ids)
casacore::TableExprGroupFractileDouble::TableExprGroupFractileDouble
TableExprGroupFractileDouble(TableExprNodeRep *node, Double fractile)
casacore::TableExprGroupFractileDouble::~TableExprGroupFractileDouble
virtual ~TableExprGroupFractileDouble()
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::itsValue
Int64 itsValue
Definition ExprGroup.h:506
casacore::TableExprGroupFuncInt::TableExprGroupFuncInt
TableExprGroupFuncInt(TableExprNodeRep *node, Int64 initValue=0)
Definition ExprGroup.h:498
casacore::TableExprGroupMaxDouble::~TableExprGroupMaxDouble
virtual ~TableExprGroupMaxDouble()
casacore::TableExprGroupMaxDouble::TableExprGroupMaxDouble
TableExprGroupMaxDouble(TableExprNodeRep *node)
casacore::TableExprGroupMaxDouble::apply
virtual void apply(const TableExprId &id)
Get the operand's value for the given row and apply it to the aggregation.
casacore::TableExprGroupMaxInt::TableExprGroupMaxInt
TableExprGroupMaxInt(TableExprNodeRep *node)
casacore::TableExprGroupMaxInt::~TableExprGroupMaxInt
virtual ~TableExprGroupMaxInt()
casacore::TableExprGroupMaxInt::apply
virtual void apply(const TableExprId &id)
Get the operand's value for the given row and apply it to the aggregation.
casacore::TableExprGroupMeanDComplex::~TableExprGroupMeanDComplex
virtual ~TableExprGroupMeanDComplex()
casacore::TableExprGroupMeanDComplex::TableExprGroupMeanDComplex
TableExprGroupMeanDComplex(TableExprNodeRep *node)
casacore::TableExprGroupMeanDComplex::finish
virtual void finish()
If needed, finish the aggregation.
casacore::TableExprGroupMeanDComplex::itsNr
Int64 itsNr
Definition ExprGroupAggrFunc.h:496
casacore::TableExprGroupMeanDComplex::apply
virtual void apply(const TableExprId &id)
Get the operand's value for the given row and apply it to the aggregation.
casacore::TableExprGroupMeanDouble::apply
virtual void apply(const TableExprId &id)
Get the operand's value for the given row and apply it to the aggregation.
casacore::TableExprGroupMeanDouble::itsNr
Int64 itsNr
Definition ExprGroupAggrFunc.h:336
casacore::TableExprGroupMeanDouble::TableExprGroupMeanDouble
TableExprGroupMeanDouble(TableExprNodeRep *node)
casacore::TableExprGroupMeanDouble::~TableExprGroupMeanDouble
virtual ~TableExprGroupMeanDouble()
casacore::TableExprGroupMeanDouble::finish
virtual void finish()
If needed, finish the aggregation.
casacore::TableExprGroupMinDouble::apply
virtual void apply(const TableExprId &id)
Get the operand's value for the given row and apply it to the aggregation.
casacore::TableExprGroupMinDouble::~TableExprGroupMinDouble
virtual ~TableExprGroupMinDouble()
casacore::TableExprGroupMinDouble::TableExprGroupMinDouble
TableExprGroupMinDouble(TableExprNodeRep *node)
casacore::TableExprGroupMinInt::apply
virtual void apply(const TableExprId &id)
Get the operand's value for the given row and apply it to the aggregation.
casacore::TableExprGroupMinInt::TableExprGroupMinInt
TableExprGroupMinInt(TableExprNodeRep *node)
casacore::TableExprGroupMinInt::~TableExprGroupMinInt
virtual ~TableExprGroupMinInt()
casacore::TableExprGroupNFalse::~TableExprGroupNFalse
virtual ~TableExprGroupNFalse()
casacore::TableExprGroupNFalse::apply
virtual void apply(const TableExprId &id)
Get the operand's value for the given row and apply it to the aggregation.
casacore::TableExprGroupNFalse::TableExprGroupNFalse
TableExprGroupNFalse(TableExprNodeRep *node)
casacore::TableExprGroupNTrue::TableExprGroupNTrue
TableExprGroupNTrue(TableExprNodeRep *node)
casacore::TableExprGroupNTrue::apply
virtual void apply(const TableExprId &id)
Get the operand's value for the given row and apply it to the aggregation.
casacore::TableExprGroupNTrue::~TableExprGroupNTrue
virtual ~TableExprGroupNTrue()
casacore::TableExprGroupProductDComplex::apply
virtual void apply(const TableExprId &id)
Get the operand's value for the given row and apply it to the aggregation.
casacore::TableExprGroupProductDComplex::~TableExprGroupProductDComplex
virtual ~TableExprGroupProductDComplex()
casacore::TableExprGroupProductDComplex::TableExprGroupProductDComplex
TableExprGroupProductDComplex(TableExprNodeRep *node)
casacore::TableExprGroupProductDouble::apply
virtual void apply(const TableExprId &id)
Get the operand's value for the given row and apply it to the aggregation.
casacore::TableExprGroupProductDouble::TableExprGroupProductDouble
TableExprGroupProductDouble(TableExprNodeRep *node)
casacore::TableExprGroupProductDouble::~TableExprGroupProductDouble
virtual ~TableExprGroupProductDouble()
casacore::TableExprGroupProductInt::~TableExprGroupProductInt
virtual ~TableExprGroupProductInt()
casacore::TableExprGroupProductInt::TableExprGroupProductInt
TableExprGroupProductInt(TableExprNodeRep *node)
casacore::TableExprGroupProductInt::apply
virtual void apply(const TableExprId &id)
Get the operand's value for the given row and apply it to the aggregation.
casacore::TableExprGroupRmsDouble::~TableExprGroupRmsDouble
virtual ~TableExprGroupRmsDouble()
casacore::TableExprGroupRmsDouble::TableExprGroupRmsDouble
TableExprGroupRmsDouble(TableExprNodeRep *node)
casacore::TableExprGroupRmsDouble::finish
virtual void finish()
If needed, finish the aggregation.
casacore::TableExprGroupRmsDouble::apply
virtual void apply(const TableExprId &id)
Get the operand's value for the given row and apply it to the aggregation.
casacore::TableExprGroupRmsDouble::itsNr
Int64 itsNr
Definition ExprGroupAggrFunc.h:399
casacore::TableExprGroupStdDevDComplex::finish
virtual void finish()
If needed, finish the aggregation.
casacore::TableExprGroupStdDevDComplex::TableExprGroupStdDevDComplex
TableExprGroupStdDevDComplex(TableExprNodeRep *node, uInt ddof)
casacore::TableExprGroupStdDevDComplex::~TableExprGroupStdDevDComplex
virtual ~TableExprGroupStdDevDComplex()
casacore::TableExprGroupStdDevDouble::finish
virtual void finish()
If needed, finish the aggregation.
casacore::TableExprGroupStdDevDouble::~TableExprGroupStdDevDouble
virtual ~TableExprGroupStdDevDouble()
casacore::TableExprGroupStdDevDouble::TableExprGroupStdDevDouble
TableExprGroupStdDevDouble(TableExprNodeRep *node, uInt ddof)
casacore::TableExprGroupSumDComplex::TableExprGroupSumDComplex
TableExprGroupSumDComplex(TableExprNodeRep *node)
casacore::TableExprGroupSumDComplex::apply
virtual void apply(const TableExprId &id)
Get the operand's value for the given row and apply it to the aggregation.
casacore::TableExprGroupSumDComplex::~TableExprGroupSumDComplex
virtual ~TableExprGroupSumDComplex()
casacore::TableExprGroupSumDouble::apply
virtual void apply(const TableExprId &id)
Get the operand's value for the given row and apply it to the aggregation.
casacore::TableExprGroupSumDouble::TableExprGroupSumDouble
TableExprGroupSumDouble(TableExprNodeRep *node)
casacore::TableExprGroupSumDouble::~TableExprGroupSumDouble
virtual ~TableExprGroupSumDouble()
casacore::TableExprGroupSumInt::TableExprGroupSumInt
TableExprGroupSumInt(TableExprNodeRep *node)
casacore::TableExprGroupSumInt::apply
virtual void apply(const TableExprId &id)
Get the operand's value for the given row and apply it to the aggregation.
casacore::TableExprGroupSumInt::~TableExprGroupSumInt
virtual ~TableExprGroupSumInt()
casacore::TableExprGroupSumSqrDComplex::TableExprGroupSumSqrDComplex
TableExprGroupSumSqrDComplex(TableExprNodeRep *node)
casacore::TableExprGroupSumSqrDComplex::~TableExprGroupSumSqrDComplex
virtual ~TableExprGroupSumSqrDComplex()
casacore::TableExprGroupSumSqrDComplex::apply
virtual void apply(const TableExprId &id)
Get the operand's value for the given row and apply it to the aggregation.
casacore::TableExprGroupSumSqrDouble::apply
virtual void apply(const TableExprId &id)
Get the operand's value for the given row and apply it to the aggregation.
casacore::TableExprGroupSumSqrDouble::~TableExprGroupSumSqrDouble
virtual ~TableExprGroupSumSqrDouble()
casacore::TableExprGroupSumSqrDouble::TableExprGroupSumSqrDouble
TableExprGroupSumSqrDouble(TableExprNodeRep *node)
casacore::TableExprGroupSumSqrInt::~TableExprGroupSumSqrInt
virtual ~TableExprGroupSumSqrInt()
casacore::TableExprGroupSumSqrInt::TableExprGroupSumSqrInt
TableExprGroupSumSqrInt(TableExprNodeRep *node)
casacore::TableExprGroupSumSqrInt::apply
virtual void apply(const TableExprId &id)
Get the operand's value for the given row and apply it to the aggregation.
casacore::TableExprGroupVarianceDComplex::itsNr
Int64 itsNr
Definition ExprGroupAggrFunc.h:520
casacore::TableExprGroupVarianceDComplex::~TableExprGroupVarianceDComplex
virtual ~TableExprGroupVarianceDComplex()
casacore::TableExprGroupVarianceDComplex::TableExprGroupVarianceDComplex
TableExprGroupVarianceDComplex(TableExprNodeRep *node, uInt ddof)
casacore::TableExprGroupVarianceDComplex::apply
virtual void apply(const TableExprId &id)
Get the operand's value for the given row and apply it to the aggregation.
casacore::TableExprGroupVarianceDComplex::itsDdof
uInt itsDdof
Definition ExprGroupAggrFunc.h:519
casacore::TableExprGroupVarianceDComplex::itsCurMean
DComplex itsCurMean
Definition ExprGroupAggrFunc.h:521
casacore::TableExprGroupVarianceDComplex::finish
virtual void finish()
If needed, finish the aggregation.
casacore::TableExprGroupVarianceDouble::itsDdof
uInt itsDdof
Definition ExprGroupAggrFunc.h:358
casacore::TableExprGroupVarianceDouble::itsNr
Int64 itsNr
Definition ExprGroupAggrFunc.h:359
casacore::TableExprGroupVarianceDouble::finish
virtual void finish()
If needed, finish the aggregation.
casacore::TableExprGroupVarianceDouble::itsCurMean
Double itsCurMean
Definition ExprGroupAggrFunc.h:360
casacore::TableExprGroupVarianceDouble::~TableExprGroupVarianceDouble
virtual ~TableExprGroupVarianceDouble()
casacore::TableExprGroupVarianceDouble::TableExprGroupVarianceDouble
TableExprGroupVarianceDouble(TableExprNodeRep *node, uInt ddof)
casacore::TableExprGroupVarianceDouble::apply
virtual void apply(const TableExprId &id)
Get the operand's value for the given row and apply it to the aggregation.
casacore::TableExprId
Definition TableExprId.h:95
casacore::TableExprNodeArrayColumn
Base class for Array column in table select expression.
Definition ExprNodeArray.h:211
casacore::TableExprNodeRep
Abstract base class for a node in a table column expression tree.
Definition ExprNodeRep.h:202
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::Double
double Double
Definition aipstype.h:53