casacore
ExprNode.h
Go to the documentation of this file.
1//# ExprNode.h: Handle class for a table column expression tree
2//# Copyright (C) 1994,1995,1996,1997,1998,2000,2001,2003
3//# Associated Universities, Inc. Washington DC, USA.
4//#
5//# This library is free software; you can redistribute it and/or modify it
6//# under the terms of the GNU Library General Public License as published by
7//# the Free Software Foundation; either version 2 of the License, or (at your
8//# option) any later version.
9//#
10//# This library is distributed in the hope that it will be useful, but WITHOUT
11//# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
12//# FITNESS FOR A PARTICULAR PURPOSE. See the GNU Library General Public
13//# License for more details.
14//#
15//# You should have received a copy of the GNU Library General Public License
16//# along with this library; if not, write to the Free Software Foundation,
17//# Inc., 675 Massachusetts Ave, Cambridge, MA 02139, USA.
18//#
19//# Correspondence concerning AIPS++ should be addressed as follows:
20//# Internet email: aips2-request@nrao.edu.
21//# Postal address: AIPS++ Project Office
22//# National Radio Astronomy Observatory
23//# 520 Edgemont Road
24//# Charlottesville, VA 22903-2475 USA
25//#
26//# $Id: ExprNode.h 21277 2012-10-31 16:07:31Z gervandiepen $
27
28#ifndef TABLES_EXPRNODE_H
29#define TABLES_EXPRNODE_H
30
31//# Includes
32#include <casacore/casa/aips.h>
33#include <casacore/tables/TaQL/ExprNodeRep.h>
34#include <casacore/tables/TaQL/ExprRange.h>
35#include <casacore/tables/TaQL/ExprFuncNode.h>
36#include <casacore/tables/TaQL/TaQLStyle.h>
37#include <casacore/tables/TaQL/MArray.h>
38#include <casacore/tables/Tables/RowNumbers.h>
39#include <casacore/casa/Arrays/ArrayFwd.h>
40#include <casacore/casa/Utilities/CountedPtr.h>
41#include <casacore/casa/Utilities/DataType.h>
42#include <casacore/casa/BasicSL/Complex.h>
43
44namespace casacore { //# NAMESPACE CASACORE - BEGIN
45
46//# Forward Declarations
47class Table;
48class String;
49class Regex;
50class StringDistance;
51class Unit;
52class Record;
53class TableRecord;
54class TableExprNodeBinary;
55class TableExprNodeSet;
56template<class T> class Block;
57template<class T> class MArray;
58
59
60// <summary>
61// Handle class for a table column expression tree
62// </summary>
63
64// <use visibility=export>
65
66// <reviewed reviewer="UNKNOWN" date="before2004/08/25" tests="">
67// </reviewed>
68
69// <prerequisite>
70//# Classes you should understand before using this one.
71// <li> <linkto class=Table>Table</linkto>
72// <li> Note 199 describing
73// <a href="../notes/199.html">
74// TaQL</a>
75// </prerequisite>
76
77// <etymology>
78// TableExprNode represents a node in the tree reflecting a
79// table select expression.
80// </etymology>
81
82// <synopsis>
83// TableExprNode is the class to store a table select expression,
84// making it possible to select rows from the table. The selected
85// rows form a table which is a view of the original table.
86// <p>
87// TableExprNode is a handle class for the counted referenced class
88// TableExprNodeRep.
89// Classes (like TableExprNodePlusXX) derived from TableExprNodeRep
90// hold the individual
91// nodes in the expression, i.e. the operators and operands. The nodes
92// form a binary tree reflecting the expression.
93// E.g. the expression 2*COLUMN results in the node TableExprNodeTimes
94// with its children TableExprNodeConst and TableExprNodeColumn.
95// Constant subexpressions (like 2*3) are evaluated immediately and
96// only the result is stored as a node.
97// <p>
98// There are a few TableExprNode constructors taking a constant scalar or array.
99// In this way constant value are automatically converted to the
100// appropriate TableExprNodeConst object.
101// <p>
102// The derived classes also reflect the data type of the node.
103// Data types Bool, Int64, Double, DComplex and String are used.
104// Char, uChar, Short, uShort, Int and uInt are converted to Int64,
105// float to Double, and Complex to DComplex.
106// Binary operators +, -, *, /, %, &, }, ^, ==, >=, >, <, <= and != are
107// recognized. Also &&, ||, parentheses and unary +, -, ~ and ! are recognized.
108// For strings the binary operator + can also be used.
109// The operators have the normal C++ precedence.
110// Furthermore functions (such as sin, max, ceil) can be used in an expression.
111// <br>Operator() can be used to take a slice from an array.
112// <p>
113// The Table function col has to be used to create a TableExprNode
114// object for a column in the table. The Table
115// <linkto file="Table.h#keycol">operator()</linkto> can be used
116// the do the actual selection from the top TableExprNode object.
117// </synopsis>
118
119// <example>
120// <srcblock>
121// // Select from table X all rows where column RA<5 and where column
122// // SWITCH is true.
123// Table table("X");
124// Table subtable = table(table.col("RA") < 5 && table.col("SWITCH"));
125//
126// // Select from that result all rows where the concatenation of
127// // the strings in columns STR1 and STR2 is equal to the string
128// // in keyword STRKEY.
129// Table subsub = subtable(subtable.col("STR1") + subtable.col("STR2")
130// == subtable.key("STRKEY"));
131// </srcblock>
132// </example>
133
134// <motivation>
135// Having TableExprNode as a handle class makes it possible to
136// handle temporary objects created by the compiler in a smooth way.
137// TableExprNode and its derivations allow to store an expression
138// before actually evaluating it. This also allows the classes to
139// be used by the table expression parser defined in TableParse and
140// TableGram.
141//
142// For each operator a special derived class is implemented.
143// Another approach could have been to store the operator as
144// a flag and switch on that. However, that causes extra overhead
145// and the C++ virtual function mechanism is the designed for
146// these purposes.
147// </motivation>
148
149// <todo asof="$DATE:$">
150//# A List of bugs, limitations, extensions or planned refinements.
151// <li> add operations on arrays
152// <li> add selection by comparing with a set of values
153// </todo>
154
155
157{
158public:
160
161 // Unary operators on numeric TableExprNode's.
162 // <group>
165 // </group>
166 // Unary NOT-operator on boolean TableExprNode's.
168 // Unary bitwise negate-operator on integer TableExprNode's.
170
171 // Slicing in a node containing an array. It is possible to
172 // address a single pixel or an n-dimensional subarray.
173 // In case of a single pixel the result is a scalar node.
174 // Otherwise the result is an array node with the same dimensionality
175 // as the source.
176 // <br>Note that there exist TableExprNodeSet constructors to
177 // convert an <src>IPosition</src> or <src>Slicer</src> object
178 // automatically to a <src>TableExprNodeSet</src>.
179 // An <src>IPosition</src> addresses a single element and results in
180 // a scalar node, while a <src>Slicer</src> can address multiple
181 // elements and always results in an array node.
183
184 // The IN operator to test if a value is contained in an array or set.
185 // The array can also be a scalar.
186 // <group>
188 const TaQLStyle& = TaQLStyle(0)) const;
190 const TaQLStyle& = TaQLStyle(0)) const;
191 // </group>
192
193 // Use a unit for the given TableExprNode.
194 // Note that if a column has a unit, it is automatically set. In that case
195 // this can be used to convert units.
197
198 // Constructors to convert a constant value to a TableExprNode.
199 // The constructor for char* is also supported to convert a
200 // character-array to a string, since a two step conversion
201 // is not done automatically.
202 // <group>
213 TableExprNode (const std::string& value);
214 TableExprNode (const char*);
226 //# The following constructor has to be explicit, othwerwise
227 //# Table(Vector<rownr_t>)
228 //# gives an ambiguous error as the preferred class RowNumbers
229 //# has a similar constructor.
251 // </group>
252
253 // Construct a node from a node representation shared pointer
254 // which increments the reference count.
256
257 // Construct from a node representation. It takes over the pointer, so the
258 // object gets deleted automatically.
260 : node_p(TENShPtr(rep)) {}
261
262 // copy constructor (reference semantics).
264
265 // Assignment (reference semantics).
267
268 // The destructor deletes all the underlying TableExprNode objects,
270
271 // Does the node contain no actual node?
272 Bool isNull() const
273 { return !node_p; }
274
275 // Do not apply the selection.
278
279 // Re-create the column object for a selection of rows.
280 // Nothing is done if the node does not represent a column object.
281 void applySelection (const Vector<rownr_t>& rownrs)
282 { node_p->applySelection (rownrs); }
283
284 // Get the unit of the expression.
285 const Unit& unit() const
286 { return node_p->unit(); }
287
288 // Get the attributes of the expression.
289 const Record& attributes() const
290 { return node_p->attributes(); }
291
292 // Get the data type of the expression.
293 // Currently the only possible values are TpBool, TpInt, TpDouble,
294 // TpDComplex, TpString, and TpOther.
295 // The latter is returned for a date or regex.
296 DataType dataType() const;
297
298 // Is the expression a scalar?
301
302 // Get the number of rows in the table associated with this expression.
303 // One is returned if the expression is a constant.
304 // Zero is returned if no table is associated with it.
305 rownr_t nrow() const
306 { return node_p->nrow(); }
307
308 // Get a value for this node in the given row.
309 // These functions are implemented in the derived classes and
310 // will usually invoke the get in their children and apply the
311 // operator on the resulting values.
312 // <group>
313 void get (const TableExprId& id, Bool& value) const;
314 void get (const TableExprId& id, Int64& value) const;
315 void get (const TableExprId& id, Double& value) const;
316 void get (const TableExprId& id, DComplex& value) const;
317 void get (const TableExprId& id, String& value) const;
318 void get (const TableExprId& id, TaqlRegex& value) const;
319 void get (const TableExprId& id, MVTime& value) const;
320 void get (const TableExprId& id, MArray<Bool>& value) const;
321 void get (const TableExprId& id, MArray<Int64>& value) const;
322 void get (const TableExprId& id, MArray<Double>& value) const;
323 void get (const TableExprId& id, MArray<DComplex>& value) const;
324 void get (const TableExprId& id, MArray<String>& value) const;
325 void get (const TableExprId& id, MArray<MVTime>& value) const;
326 void get (const TableExprId& id, Array<Bool>& value) const;
327 void get (const TableExprId& id, Array<Int64>& value) const;
328 void get (const TableExprId& id, Array<Double>& value) const;
329 void get (const TableExprId& id, Array<DComplex>& value) const;
330 void get (const TableExprId& id, Array<String>& value) const;
331 void get (const TableExprId& id, Array<MVTime>& value) const;
332 Bool getBool (const TableExprId& id) const;
333 Int64 getInt (const TableExprId& id) const;
334 Double getDouble (const TableExprId& id) const;
335 DComplex getDComplex (const TableExprId& id) const;
336 MVTime getDate (const TableExprId& id) const;
337 String getString (const TableExprId& id) const;
338 Array<Bool> getArrayBool (const TableExprId& id) const;
339 Array<Int64> getArrayInt (const TableExprId& id) const;
340 Array<Double> getArrayDouble (const TableExprId& id) const;
342 Array<String> getArrayString (const TableExprId& id) const;
343 Array<MVTime> getArrayDate (const TableExprId& id) const;
344 // Get a value as an array, even it it is a scalar.
345 // This is useful in case one can give an argument as scalar or array.
346 // <group>
347 MArray<Bool> getBoolAS (const TableExprId& id) const;
348 MArray<Int64> getIntAS (const TableExprId& id) const;
349 MArray<Double> getDoubleAS (const TableExprId& id) const;
351 MArray<String> getStringAS (const TableExprId& id) const;
352 MArray<MVTime> getDateAS (const TableExprId& id) const;
353 // </group>
354
355 // </group>
356
357 // Get the data type for doing a getColumn on the expression.
358 // This is the data type of the column if the expression
359 // consists of a single column only.
360 // Otherwise it is the expression data type as returned by
361 // function <src>dataType</src>.
362 DataType getColumnDataType() const;
363
364 // Get the value of the expression evaluated for the entire column.
365 // The data of function called should match the data type as
366 // returned by function <src>getColumnDataType</src>.
367 // <group>
368 Array<Bool> getColumnBool (const RowNumbers& rownrs) const;
369 Array<uChar> getColumnuChar (const RowNumbers& rownrs) const;
370 Array<Short> getColumnShort (const RowNumbers& rownrs) const;
371 Array<uShort> getColumnuShort (const RowNumbers& rownrs) const;
372 Array<Int> getColumnInt (const RowNumbers& rownrs) const;
373 Array<uInt> getColumnuInt (const RowNumbers& rownrs) const;
374 Array<Int64> getColumnInt64 (const RowNumbers& rownrs) const;
375 Array<Float> getColumnFloat (const RowNumbers& rownrs) const;
376 Array<Double> getColumnDouble (const RowNumbers& rownrs) const;
377 Array<Complex> getColumnComplex (const RowNumbers& rownrs) const;
378 Array<DComplex> getColumnDComplex (const RowNumbers& rownrs) const;
379 Array<String> getColumnString (const RowNumbers& rownrs) const;
380 // </group>
381
382 // The same functions as above for the old Vector<uInt>.
383 // They are primarily meant for CASA's SplatalogueTable class.
384 // Normally they should not be used, hence declared private
385 // unless told otherwise.
386#ifndef IMPLICIT_CTDS_32BIT
387private:
388#endif
389 // <group>
391 { return getColumnBool (RowNumbers(rownrs)); }
393 { return getColumnuChar (RowNumbers(rownrs)); }
395 { return getColumnShort (RowNumbers(rownrs)); }
397 { return getColumnuShort (RowNumbers(rownrs)); }
399 { return getColumnInt (RowNumbers(rownrs)); }
401 { return getColumnuInt (RowNumbers(rownrs)); }
403 { return getColumnInt64 (RowNumbers(rownrs)); }
405 { return getColumnFloat (RowNumbers(rownrs)); }
407 { return getColumnDouble (RowNumbers(rownrs)); }
409 { return getColumnComplex (RowNumbers(rownrs)); }
411 { return getColumnDComplex (RowNumbers(rownrs)); }
413 { return getColumnString (RowNumbers(rownrs)); }
414 // </group>
415public:
416
417 // Show the tree.
418 void show (ostream&) const;
419
420 // Convert the tree to a number of range vectors which at least
421 // select the same things.
422 // This function is very useful to convert the expression to
423 // some intervals covering the select expression. This can
424 // be used to do a rough fast selection via an index and do the
425 // the slower final selection on that much smaller subset.
426 // The function can only convert direct comparisons of columns
427 // with constants (via ==, !=, >, >=, < or <=) and their combinations
428 // using && or ||.
430
431 // Check if tables used in expression have the same number of
432 // rows as the given table.
433 Bool checkTableSize (const Table& table, Bool canBeConst) const;
434
435 // Get table. This gets the Table object to which a
436 // TableExprNode belongs. A TableExprNode belongs to the Table to
437 // which the column(s) used in an expression belong. Note that
438 // all columns in an expression have to belong to the same table.
439 const Table& table() const;
440
441 // Create a column node on behalf of the Table class.
442 // For builtin data types another type of node is created than
443 // for other data types.
445 const String& name,
446 const Vector<String>& fieldNames);
447
448 // Create a TableExprNodeConst for a table keyword
449 // (which is handled as a constant).
451 const Vector<String>& fieldNames);
452
453 // Handle all field names except the last one. ALl of them must
454 // be records. The last record is returned.
455 // fullName is filled with the full keyword name separated by dots.
456 static TableRecord* findLastKeyRec (const TableRecord& keyset,
457 const Vector<String>& fieldNames,
458 String& fullName);
459
460 // Throw invalid data type exception.
461 static void throwInvDT (const String& message);
462
463 // Create function node of the given type with the given arguments.
464 // <group>
466 const TableExprNodeSet& set,
467 const Table& table,
468 const TaQLStyle& = TaQLStyle(0));
470 const TableExprNode& node);
472 const TableExprNode& node1,
473 const TableExprNode& node2);
475 const TableExprNode& node1,
476 const TableExprNode& node2,
477 const TableExprNode& node3);
479 const TableExprNode& array,
480 const TableExprNodeSet& axes);
482 const TableExprNode& array,
483 const TableExprNode& node,
484 const TableExprNodeSet& axes);
485 // </group>
486
487 // Create a user defined function node.
488 static TableExprNode newUDFNode (const String& name,
489 const TableExprNodeSet& set,
490 const Table& table,
491 const TaQLStyle& = TaQLStyle(0));
492
493 // Create cone function node of the given type with the given arguments.
494 // <group>
496 const TableExprNodeSet& set,
497 uInt origin = 0);
499 const TableExprNode& node1,
500 const TableExprNode& node2);
502 const TableExprNode& node1,
503 const TableExprNode& node2,
504 const TableExprNode& node3);
505 // </group>
506
507 // Create rownumber() function node.
508 // Origin indicates whether the first row should be zero (for C++ binding)
509 // or an other value (one for TaQL binding).
510 static TableExprNode newRownrNode (const Table& table, uInt origin);
511
512 // Create rowid() function node.
513 // Origin is always 0.
515
516 // Create rand() function node.
518
519 // Create ArrayElement node for the given array with the given index.
520 // The origin is 0 for C++ and 1 for TaQL.
522 const TableExprNodeSet& indices,
523 const TaQLStyle& = TaQLStyle(0));
524
525 // returns const pointer to the underlying TableExprNodeRep object.
526 const TENShPtr& getRep() const;
527 const TableExprNodeRep* getNodeRep() const;
528
529 // Adapt the unit of the expression to the given unit (if not empty).
530 void adaptUnit (const Unit&);
531
532 // Construct a new node for the given operation.
533 // <group>
534 TENShPtr newPlus (const TENShPtr& right) const;
535 TENShPtr newMinus (const TENShPtr& right) const;
536 TENShPtr newTimes (const TENShPtr& right) const;
537 TENShPtr newDivide (const TENShPtr& right) const;
538 TENShPtr newModulo (const TENShPtr& right) const;
539 TENShPtr newBitAnd (const TENShPtr& right) const;
540 TENShPtr newBitOr (const TENShPtr& right) const;
541 TENShPtr newBitXor (const TENShPtr& right) const;
542 TENShPtr newEQ (const TENShPtr& right) const;
543 TENShPtr newNE (const TENShPtr& right) const;
544 TENShPtr newGE (const TENShPtr& right) const;
545 TENShPtr newGT (const TENShPtr& right) const;
546 TENShPtr newIN (const TENShPtr& right, const TaQLStyle&) const;
547 TENShPtr newOR (const TENShPtr& right) const;
548 TENShPtr newAND (const TENShPtr& right) const;
549 // </group>
550
551private:
552 // Put the new binary node object in a shared pointer.
553 // Set the node's info and adapt the children if needed.
554 // If the node is constant, it is evaluated and returned as result.
556 const TENShPtr& right=TENShPtr()) const;
557
558 // convert Block of TableExprNode to vector of TENShPtr.
559 static std::vector<TENShPtr> convertBlockTEN (Block<TableExprNode>& nodes);
560
561 // The actual (counted referenced) representation of a node.
563};
564
565
566
568 { node_p->ranges (blrange); }
569
570//# Get the table from which the node is derived.
571inline const Table& TableExprNode::table() const
572 { return node_p->table(); }
573
574//# Get the value of an expression.
575inline void TableExprNode::get (const TableExprId& id, Bool& value) const
576 { value = node_p->getBool (id); }
577inline void TableExprNode::get (const TableExprId& id, Int64& value) const
578 { value = node_p->getInt (id); }
579inline void TableExprNode::get (const TableExprId& id, Double& value) const
580 { value = node_p->getDouble (id); }
581inline void TableExprNode::get (const TableExprId& id, DComplex& value) const
582 { value = node_p->getDComplex (id); }
583inline void TableExprNode::get (const TableExprId& id, String& value) const
584 { value = node_p->getString (id); }
585inline void TableExprNode::get (const TableExprId& id, TaqlRegex& value) const
586 { value = node_p->getRegex (id); }
587inline void TableExprNode::get (const TableExprId& id, MVTime& value) const
588 { value = node_p->getDate (id); }
589inline void TableExprNode::get (const TableExprId& id,
590 MArray<Bool>& value) const
591 { value = node_p->getArrayBool (id); }
592inline void TableExprNode::get (const TableExprId& id,
593 MArray<Int64>& value) const
594 { value = node_p->getArrayInt (id); }
595inline void TableExprNode::get (const TableExprId& id,
596 MArray<Double>& value) const
597 { value = node_p->getArrayDouble (id); }
598inline void TableExprNode::get (const TableExprId& id,
599 MArray<DComplex>& value) const
600 { value = node_p->getArrayDComplex (id); }
601inline void TableExprNode::get (const TableExprId& id,
602 MArray<String>& value) const
603 { value = node_p->getArrayString (id); }
604inline void TableExprNode::get (const TableExprId& id,
605 MArray<MVTime>& value) const
606 { value = node_p->getArrayDate (id); }
607inline void TableExprNode::get (const TableExprId& id,
608 Array<Bool>& value) const
609 { value = node_p->getArrayBool (id).array(); }
610inline void TableExprNode::get (const TableExprId& id,
611 Array<Int64>& value) const
612 { value = node_p->getArrayInt (id).array(); }
613inline void TableExprNode::get (const TableExprId& id,
614 Array<Double>& value) const
615 { value = node_p->getArrayDouble (id).array(); }
616inline void TableExprNode::get (const TableExprId& id,
617 Array<DComplex>& value) const
618 { value = node_p->getArrayDComplex (id).array(); }
619inline void TableExprNode::get (const TableExprId& id,
620 Array<String>& value) const
621 { value = node_p->getArrayString (id).array(); }
622inline void TableExprNode::get (const TableExprId& id,
623 Array<MVTime>& value) const
624 { value = node_p->getArrayDate (id).array(); }
626 { return node_p->getBool (id); }
628 { return node_p->getInt (id); }
630 { return node_p->getDouble (id); }
632 { return node_p->getDComplex (id); }
634 { return node_p->getDate (id); }
636 { return node_p->getString (id); }
638 { return node_p->getArrayBool (id).array(); }
640 { return node_p->getArrayInt (id).array(); }
642 { return node_p->getArrayDouble (id).array(); }
644 { return node_p->getArrayDComplex (id).array(); }
646 { return node_p->getArrayString (id).array(); }
648 { return node_p->getArrayDate (id).array(); }
650 { return node_p->getBoolAS (id); }
652 { return node_p->getIntAS (id); }
654 { return node_p->getDoubleAS (id); }
656 { return node_p->getDComplexAS (id); }
658 { return node_p->getStringAS (id); }
660 { return node_p->getDateAS (id); }
661
663 { return node_p->getColumnBool (rownrs); }
665 { return node_p->getColumnuChar (rownrs); }
667 { return node_p->getColumnShort (rownrs); }
669 { return node_p->getColumnuShort (rownrs); }
671 { return node_p->getColumnInt (rownrs); }
673 { return node_p->getColumnuInt (rownrs); }
675 { return node_p->getColumnInt64 (rownrs); }
677 { return node_p->getColumnFloat (rownrs); }
679 { return node_p->getColumnDouble (rownrs); }
681 { return node_p->getColumnComplex (rownrs); }
683 { return node_p->getColumnDComplex (rownrs); }
685 { return node_p->getColumnString (rownrs); }
686
687inline void TableExprNode::show (ostream& os) const
688 { node_p->show (os, 0); }
689inline const TENShPtr& TableExprNode::getRep() const
690 { return node_p; }
692 { return node_p.get(); }
693
694
695
696// Define all global functions operating on a TableExprNode.
697// <group name=GlobalTableExprNode>
698
699 //# Define the operations we allow.
700 //# Note that the arguments are defined as const. This is necessary
701 //# because the compiler generates temporaries when converting a constant
702 //# to a TableExprNode using the constructors. Temporaries has to be const.
703 //# However, we have to delete created nodes, so lnode_p and rnode_p
704 //# cannot be const. The const arguments are casted to a non-const in
705 //# the function fill which calls the non-const function simplify.
706
707 // Arithmetic operators for numeric TableExprNode's.
708 // <group>
709 // + is also defined for strings (means concatenation).
711 const TableExprNode& right);
713 const TableExprNode& right);
715 const TableExprNode& right);
717 const TableExprNode& right);
719 const TableExprNode& right);
721 const TableExprNode& right);
723 const TableExprNode& right);
725 const TableExprNode& right);
726 // </group>
727
728 // Comparison operators.
729 // <group>
731 const TableExprNode& right);
733 const TableExprNode& right);
734 // Not defined for Bool.
735 // <group>
737 const TableExprNode& right);
739 const TableExprNode& right);
741 const TableExprNode& right);
743 const TableExprNode& right);
744 // </group>
745 // </group>
746
747 // Logical operators to combine boolean TableExprNode's.
748 // A null TableExprNode object is ignored, so it is possible to
749 // build up a full expression gradually.
750 // <group>
752 const TableExprNode& right);
754 const TableExprNode& right);
755 // </group>
756
757 // Functions to return whether a value is "relatively" near another.
758 // Returns <src> tol > abs(val2 - val1)/max(abs(val1),(val2))</src>.
759 // If tol <= 0, returns val1 == val2. If either val is 0.0, takes
760 // care of area around the minimum number that can be represented.
761 // <br>The nearAbs functions return whether a value is "absolutely" near
762 // another. Returns <src> tol > abs(val2 - val1)</src>.
763 // Default tolerance is 1.0e-13.
764 // They operate on scalars and arrays.
765 // <group>
766 TableExprNode near (const TableExprNode& left,
767 const TableExprNode& right);
768 TableExprNode near (const TableExprNode& left,
769 const TableExprNode& right,
770 const TableExprNode& tolerance);
772 const TableExprNode& right);
774 const TableExprNode& right,
775 const TableExprNode& tolerance);
776 // </group>
777
778 // Angular distance between positions.
779 // Both arguments have to be arrays. If both arrays contain 2 values
780 // (ra and dec), the result is a scalar.
781 // Otherwise the arrays have to contain a multiple of 2 values and the
782 // result is a 2-dim array giving the distance of each position in the
783 // first array to each position in the second array.
785 const TableExprNode& pos2);
786
787 // Angular distance as above, but only pair-wise enties are used if
788 // both arguments are arrays.
790 const TableExprNode& pos2);
791
792 // Cone search; test if the position of a source is inside a cone.
793 // <br>Argument <src>sourcePos</src> must be a double array
794 // containing two values (ra and dec of source) in radians.
795 // <br>Argument <src>cones</src> must be a double array
796 // specifying the position of the cone centers and radii in radians.
797 // So the array must contain three values (ra,dec,radius)
798 // or a multiple of it.
799 // <group>
800 // The result is a bool array telling for each cone if it contains the
801 // source. If there is only one cone, the result is a scalar.
802 TableExprNode cones (const TableExprNode& sourcePos,
803 const TableExprNode& cones);
804 // The result is always a Bool scalar telling if any cone contains
805 // the source.
806 TableExprNode anyCone (const TableExprNode& sourcePos,
807 const TableExprNode& cones);
808 // The sourcePos can contain multiple sources.
809 // The result is a double array giving the index of the first
810 // cone containing the corresponding source.
811 // If there is one source, the result is a double scalar.
812 TableExprNode findCone (const TableExprNode& sourcePos,
813 const TableExprNode& cones);
814 // </group>
815
816 // Cone search as above.
817 // However, the cone positions and radii are specified separately
818 // and (virtually) a larger array containing every combination of
819 // position/radius is formed.
820 // <group>
821 TableExprNode cones (const TableExprNode& sourcePos,
822 const TableExprNode& conePos,
823 const TableExprNode& radii);
824 TableExprNode anyCone (const TableExprNode& sourcePos,
825 const TableExprNode& conePos,
826 const TableExprNode& radii);
827 TableExprNode findCone (const TableExprNode& sourcePos,
828 const TableExprNode& conePos,
829 const TableExprNode& radii);
830 // </group>
831
832 // Transcendental functions that can be applied to essentially all numeric
833 // nodes containing scalars or arrays.
834 // <group>
835 TableExprNode sin (const TableExprNode& node);
836 TableExprNode sinh (const TableExprNode& node);
837 TableExprNode cos (const TableExprNode& node);
838 TableExprNode cosh (const TableExprNode& node);
839 TableExprNode exp (const TableExprNode& node);
840 TableExprNode log (const TableExprNode& node);
841 TableExprNode log10 (const TableExprNode& node);
843 TableExprNode square (const TableExprNode& node);
844 TableExprNode cube (const TableExprNode& node);
845 TableExprNode sqrt (const TableExprNode& node);
846 TableExprNode norm (const TableExprNode& node);
847 // </group>
848
849 // Transcendental functions applied to to nodes containing scalars or
850 // arrays with double values.
851 // They are invalid for Complex nodes.
852 // <group>
853 TableExprNode asin (const TableExprNode& node);
854 TableExprNode acos (const TableExprNode& node);
855 TableExprNode atan (const TableExprNode& node);
857 const TableExprNode& x);
858 TableExprNode tan (const TableExprNode& node);
859 TableExprNode tanh (const TableExprNode& node);
860 TableExprNode sign (const TableExprNode& node);
861 TableExprNode round (const TableExprNode& node);
862 TableExprNode ceil (const TableExprNode& node);
863 TableExprNode abs (const TableExprNode& node);
864 TableExprNode floor (const TableExprNode& node);
866 const TableExprNode& y);
867 // </group>
868
869 // String functions on scalars or arrays.
870 // <group>
872 TableExprNode upcase (const TableExprNode& node);
875 TableExprNode trim (const TableExprNode& node);
876 TableExprNode ltrim (const TableExprNode& node);
877 TableExprNode rtrim (const TableExprNode& node);
879 const TableExprNode& pos);
881 const TableExprNode& pos,
882 const TableExprNode& npos);
884 const TableExprNode& patt);
886 const TableExprNode& patt,
887 const TableExprNode& repl);
888 // </group>
889
890 // Functions for regular expression matching and
891 // pattern matching. Defined for scalars and arrays.
892 // <br><src>pattern</src> is for a file name like pattern.
893 // <br><src>sqlpattern</src> is for an SQL like pattern.
894 // <group>
895 TableExprNode regex (const TableExprNode& node);
896 TableExprNode pattern (const TableExprNode& node);
898 // </group>
899
900 // Functions for date-values. Defined for scalars and arrays.
901 //# Note, ctod is called ctodt, because Mac OS-X defines a macro
902 //# ctod in param.h
903 // <group>
906 TableExprNode mjd (const TableExprNode& node);
907 TableExprNode date (const TableExprNode& node);
908 TableExprNode year (const TableExprNode& node);
909 TableExprNode month (const TableExprNode& node);
910 TableExprNode day (const TableExprNode& node);
911 TableExprNode cmonth (const TableExprNode& node);
912 TableExprNode weekday (const TableExprNode& node);
913 TableExprNode cdow (const TableExprNode& node);
914 TableExprNode ctodt (const TableExprNode& node);
915 TableExprNode cdate (const TableExprNode& node);
916 TableExprNode ctime (const TableExprNode& node);
917 TableExprNode week (const TableExprNode& node);
918 TableExprNode time (const TableExprNode& node);
919 // </group>
920
921 // Functions for angle-values. Defined for scalars and arrays.
922 // dhms converts pairs of values to hms and dms and only works for arrays.
923 // <group>
924 TableExprNode hms (const TableExprNode& node);
925 TableExprNode dms (const TableExprNode& node);
926 TableExprNode hdms (const TableExprNode& node);
927 // </group>
928
929 // Function to convert any value to a string.
930 // See TaQL note 199 for possible format values.
931 // <group>
934 const TableExprNode& format);
935 // </group>
936
937 // Function to test if a scalar or array is NaN (not-a-number).
938 // It results in a Bool scalar or array.
939 TableExprNode isNaN (const TableExprNode& node);
940
941 // Function to test if a scalar or array is finite.
942 // It results in a Bool scalar or array.
944
945 // Minimum or maximum of 2 nodes.
946 // Makes sense for numeric and String values. For Complex values
947 // the norm is compared.
948 // One or both arguments can be scalar or array.
949 // <group>
950 TableExprNode min (const TableExprNode& a, const TableExprNode& b);
951 TableExprNode max (const TableExprNode& a, const TableExprNode& b);
952 // </group>
953
954 // The complex conjugate of a complex node.
955 // Defined for scalars and arrays.
956 TableExprNode conj (const TableExprNode& node);
957
958 // The real part of a complex node.
959 // Defined for scalars and arrays.
960 TableExprNode real (const TableExprNode& node);
961
962 // The imaginary part of a complex node.
963 // Defined for scalars and arrays.
964 TableExprNode imag (const TableExprNode& node);
965
966 // Convert double, bool, or string to int (using floor).
967 TableExprNode integer (const TableExprNode& node);
968
969 // Convert numeric or string value to bool (0, no, false, - means false)
970 TableExprNode boolean (const TableExprNode& node);
971
972 // The amplitude (i.e. sqrt(re*re + im*im)) of a complex node.
973 // This is a synonym for function abs.
974 // Defined for scalars and arrays.
976
977 // The phase (i.e. atan2(im, re)) of a complex node.
978 // This is a synonym for function arg.
979 // Defined for scalars and arrays.
980 TableExprNode phase (const TableExprNode& node);
981
982 // The arg (i.e. atan2(im, re)) of a complex node.
983 // Defined for scalars and arrays.
984 TableExprNode arg (const TableExprNode& node);
985
986 // Form a complex number from two Doubles.
987 // One or both arguments can be scalar or array.
989 const TableExprNode& imag);
990 // Form a complex number from a string.
991 // Defined for scalars and arrays.
993
994 // Functions operating on a Double or Complex scalar or array resulting in
995 // a scalar with the same data type.
996 // <group>
1000 // </group>
1001
1002 // Functions operating on a Double scalar or array resulting in
1003 // a Double scalar.
1004 // <group>
1014 const TableExprNode& fraction);
1015 // </group>
1016
1017 // <group>
1022 // </group>
1023
1024 // The partial version of the functions above.
1025 // They are applied to the array subsets defined by the axes in the set
1026 // using the partialXXX functions in ArrayMath.
1027 // The axes must be 0-relative.
1028 // <group>
1030 const TableExprNodeSet& collapseAxes);
1032 const TableExprNodeSet& collapseAxes);
1034 const TableExprNodeSet& collapseAxes);
1036 const TableExprNodeSet& collapseAxes);
1038 const TableExprNodeSet& collapseAxes);
1040 const TableExprNodeSet& collapseAxes);
1042 const TableExprNodeSet& collapseAxes);
1044 const TableExprNodeSet& collapseAxes);
1046 const TableExprNodeSet& collapseAxes);
1048 const TableExprNodeSet& collapseAxes);
1050 const TableExprNodeSet& collapseAxes);
1052 const TableExprNode& fraction,
1053 const TableExprNodeSet& collapseAxes);
1055 const TableExprNodeSet& collapseAxes);
1057 const TableExprNodeSet& collapseAxes);
1059 const TableExprNodeSet& collapseAxes);
1061 const TableExprNodeSet& collapseAxes);
1062 // </group>
1063
1064 // Functions operating for each element on a box around that element.
1065 // The elements at the edges (where no full box can be made) are set to 0.
1066 // <group>
1068 const TableExprNodeSet& halfBoxWidth);
1070 const TableExprNodeSet& halfBoxWidth);
1072 const TableExprNodeSet& halfBoxWidth);
1074 const TableExprNodeSet& halfBoxWidth);
1076 const TableExprNodeSet& halfBoxWidth);
1078 const TableExprNodeSet& halfBoxWidth);
1080 const TableExprNodeSet& halfBoxWidth);
1082 const TableExprNodeSet& halfBoxWidth);
1084 const TableExprNodeSet& halfBoxWidth);
1086 const TableExprNodeSet& halfBoxWidth);
1087 // </group>
1088
1089 // Create an array of the given shape and fill it with the values.
1090 // The <src>values</src> array is rewound as needed.
1091 TableExprNode array (const TableExprNode& values,
1092 const TableExprNodeSet& shape);
1093
1094 // Form a masked array.
1096 const TableExprNode& mask);
1097
1098 // Get the data array of a masked array.
1100
1101 // Flatten a masked array (get unmasked elements).
1103
1104 // Get the mask of a masked array.
1105 // If the array has no mask, it return an array with all False values.
1107
1108 // Get the diagonal of a (masked) array;
1109 // If the array is not a Matrix, it will take the diagonals of the
1110 // subarrays given by the two axes in the axes argument. Those
1111 // axes have to have the same length (thus each subarray is a Matrix).
1112 // If no axes are given, they default to the first two axes.
1113 // <br>The <src>diag</src> argument tells which diagonal to take.
1114 // 0 is the main diagonal, >0 is above main diagonal, <0 is below.
1117 const TableExprNode& firstAxis);
1119 const TableExprNode& firstAxis,
1120 const TableExprNode& diag);
1121
1122 // Transpose all axes of a (masked) array.
1124 // Transpose a (masked) array by making the given axes the first axes.
1126 const TableExprNode& axes);
1127
1128 // Function operating on a field resulting in a bool scalar.
1129 // It can be used to test if a column has an array in the current row.
1130 // It can also be used to test if a record contains a field.
1132
1133 // Functions operating on any scalar or array resulting in a Double scalar.
1134 // A scalar has 1 element and dimensionality 0.
1135 // <group>
1138 // </group>
1139
1140 // Function operating on any scalar or array resulting in a Double array
1141 // containing the shape. A scalar has shape [1].
1143
1144 // Function resembling the ternary <src>?:</src> construct in C++.
1145 // The argument "condition" has to be a Bool value.
1146 // If an element in "condition" is True, the corresponding element from
1147 // "arg1" is taken, otherwise it is taken from "arg2".
1148 // The arguments can be scalars or array or any combination.
1149 TableExprNode iif (const TableExprNode& condition,
1150 const TableExprNode& arg1,
1151 const TableExprNode& arg2);
1152// </group>
1153
1154
1155
1157 const TableExprNode& right)
1158{
1159 return left.newPlus (right.getRep());
1160}
1162 const TableExprNode& right)
1163{
1164 return left.newMinus (right.getRep());
1165}
1167 const TableExprNode& right)
1168{
1169 return left.newTimes (right.getRep());
1170}
1172 const TableExprNode& right)
1173{
1174 return left.newDivide (right.getRep());
1175}
1177 const TableExprNode& right)
1178{
1179 return left.newModulo (right.getRep());
1180}
1182 const TableExprNode& right)
1183{
1184 return left.newBitAnd (right.getRep());
1185}
1187 const TableExprNode& right)
1188{
1189 return left.newBitOr (right.getRep());
1190}
1192 const TableExprNode& right)
1193{
1194 return left.newBitXor (right.getRep());
1195}
1197 const TableExprNode& right)
1198{
1199 return left.newEQ (right.getRep());
1200}
1202 const TableExprNode& right)
1203{
1204 return left.newNE (right.getRep());
1205}
1207 const TableExprNode& right)
1208{
1209 return left.newGT (right.getRep());
1210}
1212 const TableExprNode& right)
1213{
1214 return left.newGE (right.getRep());
1215}
1217 const TableExprNode& right)
1218{
1219 return right.newGE (left.getRep());
1220}
1222 const TableExprNode& right)
1223{
1224 return right.newGT (left.getRep());
1225}
1227 const TaQLStyle& style) const
1228{
1229 return newIN (right.getRep(), style);
1230}
1232{
1233 // C++ indexing is 0-based.
1234 return newArrayPartNode (*this, indices, TaQLStyle(0));
1235}
1236
1238 const TableExprNode& right)
1239{
1241 left, right);
1242}
1244 const TableExprNode& right,
1245 const TableExprNode& tolerance)
1246{
1248 left, right, tolerance);
1249}
1251 const TableExprNode& right)
1252{
1254 left, right);
1255}
1257 const TableExprNode& right,
1258 const TableExprNode& tolerance)
1259{
1261 left, right, tolerance);
1262}
1264 const TableExprNode& pos2)
1265{
1267 pos1, pos2);
1268}
1270 const TableExprNode& pos2)
1271{
1273 pos1, pos2);
1274}
1275inline TableExprNode cones (const TableExprNode& sourcePos,
1276 const TableExprNode& cones)
1277{
1279 sourcePos, cones);
1280}
1281inline TableExprNode anyCone (const TableExprNode& sourcePos,
1282 const TableExprNode& cones)
1283{
1285 sourcePos, cones);
1286}
1287inline TableExprNode findCone (const TableExprNode& sourcePos,
1288 const TableExprNode& cones)
1289{
1291 sourcePos, cones);
1292}
1293inline TableExprNode cones (const TableExprNode& sourcePos,
1294 const TableExprNode& conePos,
1295 const TableExprNode& radii)
1296{
1298 sourcePos, conePos, radii);
1299}
1300inline TableExprNode anyCone (const TableExprNode& sourcePos,
1301 const TableExprNode& conePos,
1302 const TableExprNode& radii)
1303{
1305 sourcePos, conePos, radii);
1306}
1307inline TableExprNode findCone (const TableExprNode& sourcePos,
1308 const TableExprNode& conePos,
1309 const TableExprNode& radii)
1310{
1312 sourcePos, conePos, radii);
1313}
1314inline TableExprNode cos (const TableExprNode& node)
1315{
1317}
1319{
1321}
1322inline TableExprNode exp (const TableExprNode& node)
1323{
1325}
1326inline TableExprNode log (const TableExprNode& node)
1327{
1329}
1331{
1333}
1335{
1337}
1338inline TableExprNode sin (const TableExprNode& node)
1339{
1341}
1343{
1345}
1347{
1349 node);
1350}
1352{
1354 node);
1355}
1357{
1359}
1361{
1363}
1365{
1367}
1369{
1371}
1373{
1375}
1377{
1379}
1381{
1383}
1385{
1387}
1389{
1391}
1392inline TableExprNode abs (const TableExprNode& node)
1393{
1395}
1397{
1399}
1401{
1403}
1404inline TableExprNode tan (const TableExprNode& node)
1405{
1407}
1409{
1411}
1413{
1415}
1417{
1419}
1421{
1423}
1425{
1427}
1429{
1431}
1433{
1435}
1437{
1439}
1441{
1443}
1444inline TableExprNode arg (const TableExprNode& node)
1445{
1447}
1449{
1451}
1453 const TableExprNode& imag)
1454{
1456 real, imag);
1457}
1459{
1461 node);
1462}
1464{
1466 node);
1467}
1469{
1471 node);
1472}
1474{
1476 node);
1477}
1479{
1481 node);
1482}
1484{
1486}
1488{
1490 node);
1491}
1493{
1495 node);
1496}
1498{
1500 node);
1501}
1503{
1505 node);
1506}
1507inline TableExprNode mjd (const TableExprNode& node)
1508{
1510}
1512{
1514}
1516{
1518}
1520{
1522}
1523inline TableExprNode day (const TableExprNode& node)
1524{
1526}
1528{
1530 node);
1531}
1533{
1535 node);
1536}
1538{
1540}
1542{
1544}
1546{
1548}
1550{
1552}
1553inline TableExprNode hms (const TableExprNode& node)
1554{
1556}
1557inline TableExprNode dms (const TableExprNode& node)
1558{
1560}
1562{
1564}
1566{
1568 node);
1569}
1571 const TableExprNode& format)
1572{
1574 node, format);
1575}
1577{
1579}
1581{
1583}
1585{
1587}
1589{
1591}
1593{
1595}
1597 const TableExprNode& pos)
1598{
1600 node, pos);
1601}
1603 const TableExprNode& pos,
1604 const TableExprNode& npos)
1605{
1607 node, pos, npos);
1608}
1610 const TableExprNode& patt)
1611{
1613 node, patt);
1614}
1616 const TableExprNode& patt,
1617 const TableExprNode& repl)
1618{
1620 node, patt, repl);
1621}
1623{
1625}
1627{
1629}
1631{
1633 node);
1634}
1635inline TableExprNode min (const TableExprNode& node)
1636{
1638 node);
1639}
1640inline TableExprNode max (const TableExprNode& node)
1641{
1643 node);
1644}
1645inline TableExprNode sum (const TableExprNode& node)
1646{
1648 node);
1649}
1651{
1653 node);
1654}
1656{
1658 node);
1659}
1661{
1663 node);
1664}
1666{
1668 node);
1669}
1671{
1673 node);
1674}
1676{
1678 node);
1679}
1680inline TableExprNode rms (const TableExprNode& node)
1681{
1683 node);
1684}
1686{
1688 node);
1689}
1691 const TableExprNode& fraction)
1692{
1694 node, fraction);
1695}
1696inline TableExprNode any (const TableExprNode& node)
1697{
1699}
1700inline TableExprNode all (const TableExprNode& node)
1701{
1703}
1705{
1707}
1709{
1711}
1713 const TableExprNodeSet& axes)
1714{
1716 array, axes);
1717}
1719 const TableExprNodeSet& axes)
1720{
1722 array, axes);
1723}
1725 const TableExprNodeSet& axes)
1726{
1728 array, axes);
1729}
1731 const TableExprNodeSet& axes)
1732{
1734 array, axes);
1735}
1737 const TableExprNodeSet& axes)
1738{
1740 array, axes);
1741}
1743 const TableExprNodeSet& axes)
1744{
1746 array, axes);
1747}
1749 const TableExprNodeSet& axes)
1750{
1752 array, axes);
1753}
1755 const TableExprNodeSet& axes)
1756{
1758 array, axes);
1759}
1761 const TableExprNodeSet& axes)
1762{
1764 array, axes);
1765}
1767 const TableExprNodeSet& axes)
1768{
1770 array, axes);
1771}
1773 const TableExprNodeSet& axes)
1774{
1776 array, axes);
1777}
1779 const TableExprNode& fraction,
1780 const TableExprNodeSet& axes)
1781{
1783 array, fraction, axes);
1784}
1786 const TableExprNodeSet& axes)
1787{
1789 array, axes);
1790}
1792 const TableExprNodeSet& axes)
1793{
1795 array, axes);
1796}
1798 const TableExprNodeSet& axes)
1799{
1801 array, axes);
1802}
1804 const TableExprNodeSet& axes)
1805{
1807 array, axes);
1808}
1810 const TableExprNodeSet& halfBoxWidth)
1811{
1813 node, halfBoxWidth);
1814}
1816 const TableExprNodeSet& halfBoxWidth)
1817{
1819 node, halfBoxWidth);
1820}
1822 const TableExprNodeSet& halfBoxWidth)
1823{
1825 node, halfBoxWidth);
1826}
1828 const TableExprNodeSet& halfBoxWidth)
1829{
1831 node, halfBoxWidth);
1832}
1834 const TableExprNodeSet& halfBoxWidth)
1835{
1837 node, halfBoxWidth);
1838}
1840 const TableExprNodeSet& halfBoxWidth)
1841{
1843 node, halfBoxWidth);
1844}
1846 const TableExprNodeSet& halfBoxWidth)
1847{
1849 node, halfBoxWidth);
1850}
1852 const TableExprNodeSet& halfBoxWidth)
1853{
1855 node, halfBoxWidth);
1856}
1858 const TableExprNodeSet& halfBoxWidth)
1859{
1861 node, halfBoxWidth);
1862}
1864 const TableExprNodeSet& halfBoxWidth)
1865{
1867 node, halfBoxWidth);
1868}
1870 const TableExprNodeSet& halfBoxWidth)
1871{
1873 node, halfBoxWidth);
1874}
1876 const TableExprNodeSet& halfBoxWidth)
1877{
1879 node, halfBoxWidth);
1880}
1882 const TableExprNodeSet& halfBoxWidth)
1883{
1885 node, halfBoxWidth);
1886}
1888 const TableExprNodeSet& halfBoxWidth)
1889{
1891 node, halfBoxWidth);
1892}
1894 const TableExprNodeSet& halfBoxWidth)
1895{
1897 node, halfBoxWidth);
1898}
1900 const TableExprNodeSet& halfBoxWidth)
1901{
1903 node, halfBoxWidth);
1904}
1906 const TableExprNodeSet& halfBoxWidth)
1907{
1909 node, halfBoxWidth);
1910}
1912 const TableExprNodeSet& halfBoxWidth)
1913{
1915 node, halfBoxWidth);
1916}
1918 const TableExprNodeSet& halfBoxWidth)
1919{
1921 node, halfBoxWidth);
1922}
1924 const TableExprNodeSet& halfBoxWidth)
1925{
1927 node, halfBoxWidth);
1928}
1929inline TableExprNode array (const TableExprNode& values,
1930 const TableExprNodeSet& shape)
1931{
1933 values, shape);
1934}
1936 const TableExprNode& mask)
1937{
1939 array, mask);
1940}
1942{
1944 array);
1945}
1947{
1949 array);
1950}
1952{
1954 array);
1955}
1957{
1958 // Needs an empty axes argument.
1960 array,
1962}
1964 const TableExprNodeSet& axes)
1965{
1967 array, axes);
1968}
1970{
1972 array,
1974}
1976{
1978}
1980{
1982}
1984{
1986}
1988{
1990}
1991inline TableExprNode iif (const TableExprNode& condition,
1992 const TableExprNode& arg1,
1993 const TableExprNode& arg2)
1994{
1996 condition, arg1, arg2);
1997}
1998
1999
2000
2001} //# NAMESPACE CASACORE - END
2002
2003#endif
simple 1-D array
Definition: Block.h:200
t * get() const
Get the underlying pointer.
Definition: CountedPtr.h:183
const Array< T > & array() const
Get access to the array.
Definition: MArray.h:153
String: the storage and methods of handling collections of characters.
Definition: String.h:225
@ sinFUNC
for Int, Double or DComplex returning Double or Complex
Definition: ExprFuncNode.h:92
@ complexFUNC
for DComplex or String returning DComplex
Definition: ExprFuncNode.h:132
@ isdefFUNC
for any array returning Bool scalar
Definition: ExprFuncNode.h:221
@ stringFUNC
return values as strings
Definition: ExprFuncNode.h:261
@ boolFUNC
for Int, Double, Complex or String returning Bool
Definition: ExprFuncNode.h:289
@ angdistFUNC
angular distance returning radians
Definition: ExprFuncNode.h:277
@ iifFUNC
special function resembling if statement
Definition: ExprFuncNode.h:275
@ realFUNC
for Int, Double, DComplex, Bool or String returning Double
Definition: ExprFuncNode.h:113
@ hmsFUNC
return angles as hms strings
Definition: ExprFuncNode.h:263
@ arrsumFUNC
for Int, Double or Complex array returning the same
Definition: ExprFuncNode.h:134
@ asinFUNC
for Int, Double or Complex returning Double or Complex
Definition: ExprFuncNode.h:119
@ arranyFUNC
for Bool array returning Bool
Definition: ExprFuncNode.h:193
@ arrmeanFUNC
for Int or Double array returning Double
Definition: ExprFuncNode.h:156
@ arrayFUNC
for any type returning array of that type
Definition: ExprFuncNode.h:211
@ shapeFUNC
for any array returning Int array
Definition: ExprFuncNode.h:229
@ near2FUNC
for Int, or Double or Complex returning Bool (2 is with default tolerance)
Definition: ExprFuncNode.h:87
@ conesFUNC
cone search functions, implemented in derived class
Definition: ExprFuncNode.h:280
@ isnanFUNC
for Int, Double or DComplex array returning Bool
Definition: ExprFuncNode.h:217
@ intFUNC
for Int, Double, Bool or String returning Int (using floor)
Definition: ExprFuncNode.h:117
@ argFUNC
for Int, Double or DComplex returning Double
Definition: ExprFuncNode.h:111
@ arrminFUNC
for Int or Double array returning Int or Double
Definition: ExprFuncNode.h:147
@ hdmsFUNC
return angles as hms/dms strings
Definition: ExprFuncNode.h:267
@ arrntrueFUNC
for Bool array returning Int scalar
Definition: ExprFuncNode.h:202
@ imagFUNC
for Double or DComplex returning Double
Definition: ExprFuncNode.h:115
@ ndimFUNC
for any array returning Int scalar
Definition: ExprFuncNode.h:226
@ normFUNC
for Int, Double or DComplex returning Int or Double
Definition: ExprFuncNode.h:108
@ dmsFUNC
return angles as dms strings
Definition: ExprFuncNode.h:265
@ signFUNC
for Int or Double returning Int or Double
Definition: ExprFuncNode.h:126
@ squareFUNC
for Int, Double or DComplex returning Int, Double or Complex
Definition: ExprFuncNode.h:103
Abstract base class for a node having 0, 1, or 2 child nodes.
Definition: ExprNodeRep.h:559
Abstract base class for a node in a table column expression tree.
Definition: ExprNodeRep.h:158
rownr_t nrow() const
Get the number of rows in the table associated with this expression.
const Unit & unit() const
Get the unit.
Definition: ExprNodeRep.h:731
virtual Array< DComplex > getColumnDComplex(const Vector< rownr_t > &rownrs)
virtual String getString(const TableExprId &id)
virtual Array< Short > getColumnShort(const Vector< rownr_t > &rownrs)
virtual Array< uShort > getColumnuShort(const Vector< rownr_t > &rownrs)
MArray< String > getStringAS(const TableExprId &id)
virtual Array< Int64 > getColumnInt64(const Vector< rownr_t > &rownrs)
MArray< Double > getDoubleAS(const TableExprId &id)
virtual void applySelection(const Vector< rownr_t > &rownrs)
Re-create the column object for a selection of rows.
virtual MArray< Double > getArrayDouble(const TableExprId &id)
virtual Bool getBool(const TableExprId &id)
Get a scalar value for this node in the given row.
virtual DComplex getDComplex(const TableExprId &id)
MArray< DComplex > getDComplexAS(const TableExprId &id)
MArray< Int64 > getIntAS(const TableExprId &id)
virtual MArray< DComplex > getArrayDComplex(const TableExprId &id)
virtual MArray< MVTime > getArrayDate(const TableExprId &id)
const Record & attributes() const
Get the attributes.
Definition: ExprNodeRep.h:734
MArray< MVTime > getDateAS(const TableExprId &id)
virtual MArray< String > getArrayString(const TableExprId &id)
virtual Array< Double > getColumnDouble(const Vector< rownr_t > &rownrs)
virtual Array< uInt > getColumnuInt(const Vector< rownr_t > &rownrs)
virtual Array< uChar > getColumnuChar(const Vector< rownr_t > &rownrs)
virtual void ranges(Block< TableExprRange > &)
Convert the tree to a number of range vectors which at least select the same things.
virtual TaqlRegex getRegex(const TableExprId &id)
virtual MArray< Bool > getArrayBool(const TableExprId &id)
Get an array value for this node in the given row.
MArray< Bool > getBoolAS(const TableExprId &id)
Get a value as an array, even it it is a scalar.
virtual Array< Complex > getColumnComplex(const Vector< rownr_t > &rownrs)
virtual Double getDouble(const TableExprId &id)
virtual Int64 getInt(const TableExprId &id)
virtual Array< Float > getColumnFloat(const Vector< rownr_t > &rownrs)
virtual void show(ostream &, uInt indent) const
Show the expression tree.
virtual MVTime getDate(const TableExprId &id)
virtual Array< Bool > getColumnBool(const Vector< rownr_t > &rownrs)
Get the value of the expression evaluated for the entire column.
virtual MArray< Int64 > getArrayInt(const TableExprId &id)
Table & table()
Get table.
Definition: ExprNodeRep.h:749
virtual Array< Int > getColumnInt(const Vector< rownr_t > &rownrs)
virtual void disableApplySelection()
Do not apply the selection.
ValueType valueType() const
Get the value type.
Definition: ExprNodeRep.h:711
virtual Array< String > getColumnString(const Vector< rownr_t > &rownrs)
Class to hold multiple table expression nodes.
Definition: ExprNodeSet.h:311
Array< DComplex > getColumnDComplex(const RowNumbers &rownrs) const
Definition: ExprNode.h:682
Array< Short > getColumnShort(const Vector< uInt > &rownrs) const
Definition: ExprNode.h:394
TableExprNode(const MArray< Int > &value)
TableExprNode(const Array< String > &value)
TENShPtr newModulo(const TENShPtr &right) const
Int64 getInt(const TableExprId &id) const
Definition: ExprNode.h:627
TENShPtr node_p
The actual (counted referenced) representation of a node.
Definition: ExprNode.h:562
TableExprNode(const Float &value)
static TableExprNode newUDFNode(const String &name, const TableExprNodeSet &set, const Table &table, const TaQLStyle &=TaQLStyle(0))
Create a user defined function node.
static TableExprNode newConeNode(TableExprFuncNode::FunctionType, const TableExprNode &node1, const TableExprNode &node2, const TableExprNode &node3)
TableExprNode(const MArray< Short > &value)
Array< DComplex > getArrayDComplex(const TableExprId &id) const
Definition: ExprNode.h:643
Double getDouble(const TableExprId &id) const
Definition: ExprNode.h:629
static TableRecord * findLastKeyRec(const TableRecord &keyset, const Vector< String > &fieldNames, String &fullName)
Handle all field names except the last one.
rownr_t nrow() const
Get the number of rows in the table associated with this expression.
Definition: ExprNode.h:305
~TableExprNode()
The destructor deletes all the underlying TableExprNode objects,.
TableExprNode(const TableExprNode &)
copy constructor (reference semantics).
Array< DComplex > getColumnDComplex(const Vector< uInt > &rownrs) const
Definition: ExprNode.h:410
TableExprNode(const Int64 &value)
TENShPtr newGE(const TENShPtr &right) const
const Record & attributes() const
Get the attributes of the expression.
Definition: ExprNode.h:289
MArray< MVTime > getDateAS(const TableExprId &id) const
Definition: ExprNode.h:659
static TableExprNode newConeNode(TableExprFuncNode::FunctionType, const TableExprNodeSet &set, uInt origin=0)
Create cone function node of the given type with the given arguments.
TableExprNode(const Complex &value)
MArray< String > getStringAS(const TableExprId &id) const
Definition: ExprNode.h:657
static TableExprNode newFunctionNode(TableExprFuncNode::FunctionType, const TableExprNode &array, const TableExprNode &node, const TableExprNodeSet &axes)
TableExprNode(const MArray< Bool > &value)
TableExprNode(const Array< Bool > &value)
Array< uShort > getColumnuShort(const RowNumbers &rownrs) const
Definition: ExprNode.h:668
static TableExprNode newFunctionNode(TableExprFuncNode::FunctionType, const TableExprNodeSet &set, const Table &table, const TaQLStyle &=TaQLStyle(0))
Create function node of the given type with the given arguments.
Array< String > getColumnString(const Vector< uInt > &rownrs) const
Definition: ExprNode.h:412
MArray< Bool > getBoolAS(const TableExprId &id) const
Get a value as an array, even it it is a scalar.
Definition: ExprNode.h:649
TableExprNode(const Array< Int > &value)
TableExprNode(const std::string &value)
TableExprNode(const MArray< MVTime > &value)
TENShPtr newOR(const TENShPtr &right) const
Array< Double > getColumnDouble(const Vector< uInt > &rownrs) const
Definition: ExprNode.h:406
TableExprNode operator!() const
Unary NOT-operator on boolean TableExprNode's.
MArray< Int64 > getIntAS(const TableExprId &id) const
Definition: ExprNode.h:651
TableExprNode operator-() const
TableExprNode(const Array< uShort > &value)
Array< Bool > getColumnBool(const Vector< uInt > &rownrs) const
The same functions as above for the old Vector<uInt>.
Definition: ExprNode.h:390
Array< Int64 > getColumnInt64(const RowNumbers &rownrs) const
Definition: ExprNode.h:674
TENShPtr newBitXor(const TENShPtr &right) const
Array< uChar > getColumnuChar(const RowNumbers &rownrs) const
Definition: ExprNode.h:664
TableExprNode(const DComplex &value)
Array< Complex > getColumnComplex(const RowNumbers &rownrs) const
Definition: ExprNode.h:680
static TableExprNode newFunctionNode(TableExprFuncNode::FunctionType, const TableExprNode &node1, const TableExprNode &node2, const TableExprNode &node3)
TENShPtr newDivide(const TENShPtr &right) const
TableExprNode(const MArray< uInt > &value)
TENShPtr newEQ(const TENShPtr &right) const
TableExprNode in(const TableExprNode &array, const TaQLStyle &=TaQLStyle(0)) const
The IN operator to test if a value is contained in an array or set.
Definition: ExprNode.h:1226
Bool isScalar() const
Is the expression a scalar?
Definition: ExprNode.h:299
TENShPtr newTimes(const TENShPtr &right) const
TableExprNode(const Array< uInt64 > &value)
void get(const TableExprId &id, Bool &value) const
Get a value for this node in the given row.
Definition: ExprNode.h:575
TableExprNode & operator=(const TableExprNode &)
Assignment (reference semantics).
Array< Double > getColumnDouble(const RowNumbers &rownrs) const
Definition: ExprNode.h:678
TableExprNode(const Array< Complex > &value)
const Table & table() const
Get table.
Definition: ExprNode.h:571
void ranges(Block< TableExprRange > &)
Convert the tree to a number of range vectors which at least select the same things.
Definition: ExprNode.h:567
static TableExprNode newFunctionNode(TableExprFuncNode::FunctionType, const TableExprNode &node1, const TableExprNode &node2)
static TableExprNode newFunctionNode(TableExprFuncNode::FunctionType, const TableExprNode &node)
static TableExprNode newRowidNode(const Table &table)
Create rowid() function node.
static TableExprNode newRownrNode(const Table &table, uInt origin)
Create rownumber() function node.
static TableExprNode newColumnNode(const Table &tab, const String &name, const Vector< String > &fieldNames)
Create a column node on behalf of the Table class.
Bool isNull() const
Does the node contain no actual node?
Definition: ExprNode.h:272
Array< Float > getColumnFloat(const RowNumbers &rownrs) const
Definition: ExprNode.h:676
static TableExprNode newConeNode(TableExprFuncNode::FunctionType, const TableExprNode &node1, const TableExprNode &node2)
TableExprNode(const MArray< Float > &value)
Array< Float > getColumnFloat(const Vector< uInt > &rownrs) const
Definition: ExprNode.h:404
TENShPtr newBitOr(const TENShPtr &right) const
MArray< DComplex > getDComplexAS(const TableExprId &id) const
Definition: ExprNode.h:655
TableExprNode(const String &value)
TableExprNode(const Int &value)
TENShPtr newIN(const TENShPtr &right, const TaQLStyle &) const
TableExprNode(const Array< Float > &value)
TableExprNode operator+() const
Unary operators on numeric TableExprNode's.
Array< Short > getColumnShort(const RowNumbers &rownrs) const
Definition: ExprNode.h:666
Array< MVTime > getArrayDate(const TableExprId &id) const
Definition: ExprNode.h:647
TENShPtr newBitAnd(const TENShPtr &right) const
TableExprNode(const MArray< Complex > &value)
TableExprNode(const Array< uInt > &value)
TableExprNode(const MArray< uInt64 > &value)
const Unit & unit() const
Get the unit of the expression.
Definition: ExprNode.h:285
static TableExprNode newFunctionNode(TableExprFuncNode::FunctionType, const TableExprNode &array, const TableExprNodeSet &axes)
static void throwInvDT(const String &message)
Throw invalid data type exception.
Array< Int > getColumnInt(const Vector< uInt > &rownrs) const
Definition: ExprNode.h:398
TableExprNode(const MArray< DComplex > &value)
TableExprNode(const Array< uChar > &value)
static TableExprNode newRandomNode(const Table &table)
Create rand() function node.
TableExprNode useUnit(const Unit &unit) const
Use a unit for the given TableExprNode.
TableExprNode(const Regex &value)
TableExprNode operator()(const TableExprNodeSet &indices)
Slicing in a node containing an array.
Definition: ExprNode.h:1231
TableExprNode(const Array< MVTime > &value)
TENShPtr newMinus(const TENShPtr &right) const
Bool checkTableSize(const Table &table, Bool canBeConst) const
Check if tables used in expression have the same number of rows as the given table.
TableExprNode operator~() const
Unary bitwise negate-operator on integer TableExprNode's.
Bool getBool(const TableExprId &id) const
Definition: ExprNode.h:625
TENShPtr newGT(const TENShPtr &right) const
void disableApplySelection()
Do not apply the selection.
Definition: ExprNode.h:276
Array< uChar > getColumnuChar(const Vector< uInt > &rownrs) const
Definition: ExprNode.h:392
TableExprNode(const Double &value)
MArray< Double > getDoubleAS(const TableExprId &id) const
Definition: ExprNode.h:653
Array< Int64 > getColumnInt64(const Vector< uInt > &rownrs) const
Definition: ExprNode.h:402
Array< String > getColumnString(const RowNumbers &rownrs) const
Definition: ExprNode.h:684
TableExprNode(const Array< Int64 > &value)
Array< Double > getArrayDouble(const TableExprId &id) const
Definition: ExprNode.h:641
TableExprNode(const MArray< String > &value)
static TableExprNode newArrayPartNode(const TableExprNode &arrayNode, const TableExprNodeSet &indices, const TaQLStyle &=TaQLStyle(0))
Create ArrayElement node for the given array with the given index.
TableExprNode(const StringDistance &value)
TableExprNode(const Array< Double > &value)
DataType dataType() const
Get the data type of the expression.
static TableExprNode newKeyConst(const TableRecord &, const Vector< String > &fieldNames)
Create a TableExprNodeConst for a table keyword (which is handled as a constant).
TableExprNode(const MVTime &value)
Array< Int64 > getArrayInt(const TableExprId &id) const
Definition: ExprNode.h:639
TENShPtr newPlus(const TENShPtr &right) const
Construct a new node for the given operation.
const TableExprNodeRep * getNodeRep() const
Definition: ExprNode.h:691
TableExprNode(const MArray< Int64 > &value)
TableExprNode(const TENShPtr &)
Construct a node from a node representation shared pointer which increments the reference count.
TableExprNode(const MArray< uChar > &value)
void adaptUnit(const Unit &)
Adapt the unit of the expression to the given unit (if not empty).
Array< Int > getColumnInt(const RowNumbers &rownrs) const
Definition: ExprNode.h:670
Array< Bool > getColumnBool(const RowNumbers &rownrs) const
Get the value of the expression evaluated for the entire column.
Definition: ExprNode.h:662
TENShPtr newAND(const TENShPtr &right) const
Array< String > getArrayString(const TableExprId &id) const
Definition: ExprNode.h:645
Array< uShort > getColumnuShort(const Vector< uInt > &rownrs) const
Definition: ExprNode.h:396
Array< uInt > getColumnuInt(const Vector< uInt > &rownrs) const
Definition: ExprNode.h:400
TableExprNode(TableExprNodeRep *rep)
Construct from a node representation.
Definition: ExprNode.h:259
const TENShPtr & getRep() const
returns const pointer to the underlying TableExprNodeRep object.
Definition: ExprNode.h:689
Array< uInt > getColumnuInt(const RowNumbers &rownrs) const
Definition: ExprNode.h:672
TableExprNode(const Array< Short > &value)
TableExprNode(const MArray< Double > &value)
Array< Complex > getColumnComplex(const Vector< uInt > &rownrs) const
Definition: ExprNode.h:408
TableExprNode(const Bool &value)
Constructors to convert a constant value to a TableExprNode.
String getString(const TableExprId &id) const
Definition: ExprNode.h:635
DataType getColumnDataType() const
Get the data type for doing a getColumn on the expression.
Array< Bool > getArrayBool(const TableExprId &id) const
Definition: ExprNode.h:637
TableExprNode(const char *)
TableExprNode(const uInt64 &value)
void show(ostream &) const
Show the tree.
Definition: ExprNode.h:687
TableExprNode(const MArray< uShort > &value)
TableExprNode(const TaqlRegex &value)
MVTime getDate(const TableExprId &id) const
Definition: ExprNode.h:633
void applySelection(const Vector< rownr_t > &rownrs)
Re-create the column object for a selection of rows.
Definition: ExprNode.h:281
TableExprNode(const uInt &value)
TENShPtr newNE(const TENShPtr &right) const
static std::vector< TENShPtr > convertBlockTEN(Block< TableExprNode > &nodes)
convert Block of TableExprNode to vector of TENShPtr.
TableExprNode in(const TableExprNodeSet &set, const TaQLStyle &=TaQLStyle(0)) const
DComplex getDComplex(const TableExprId &id) const
Definition: ExprNode.h:631
TableExprNode(const Array< DComplex > &value)
TENShPtr setBinaryNodeInfo(TableExprNodeBinary *tsnptr, const TENShPtr &right=TENShPtr()) const
Put the new binary node object in a shared pointer.
this file contains all the compiler specific defines
Definition: mainpage.dox:28
TableExprNode runningAny(const TableExprNode &array, const TableExprNodeSet &halfBoxWidth)
Definition: ExprNode.h:1857
TableExprNode rmss(const TableExprNode &array, const TableExprNodeSet &collapseAxes)
Definition: ExprNode.h:1766
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.
TableExprNode pattern(const TableExprNode &node)
Definition: ExprNode.h:1487
TableExprNode sums(const TableExprNode &array, const TableExprNodeSet &collapseAxes)
The partial version of the functions above.
Definition: ExprNode.h:1712
TableExprNode maxs(const TableExprNode &array, const TableExprNodeSet &collapseAxes)
Definition: ExprNode.h:1736
TableExprNode medians(const TableExprNode &array, const TableExprNodeSet &collapseAxes)
Definition: ExprNode.h:1772
TableExprNode boxedAny(const TableExprNode &node, const TableExprNodeSet &halfBoxWidth)
Definition: ExprNode.h:1917
TableExprNode boxedAll(const TableExprNode &node, const TableExprNodeSet &halfBoxWidth)
Definition: ExprNode.h:1923
TableExprNode sumSquares(const TableExprNode &array, const TableExprNodeSet &collapseAxes)
Definition: ExprNode.h:1724
LatticeExprNode exp(const LatticeExprNode &expr)
TableExprNode runningMin(const TableExprNode &array, const TableExprNodeSet &halfBoxWidth)
Functions operating for each element on a box around that element.
Definition: ExprNode.h:1809
LatticeExprNode isNaN(const LatticeExprNode &expr)
Test if a value is a NaN.
TableExprNode runningMean(const TableExprNode &array, const TableExprNodeSet &halfBoxWidth)
Definition: ExprNode.h:1821
TableExprNode operator|(const TableExprNode &left, const TableExprNode &right)
Definition: ExprNode.h:1186
TableExprNode substr(const TableExprNode &str, const TableExprNode &pos)
Definition: ExprNode.h:1596
TableExprNode boxedVariance(const TableExprNode &node, const TableExprNodeSet &halfBoxWidth)
Definition: ExprNode.h:1887
TableExprNode angdist(const TableExprNode &pos1, const TableExprNode &pos2)
Angular distance between positions.
Definition: ExprNode.h:1263
LatticeExprNode operator&&(const LatticeExprNode &left, const LatticeExprNode &right)
Logical binary operators.
TableExprNode cones(const TableExprNode &sourcePos, const TableExprNode &cones)
Cone search; test if the position of a source is inside a cone.
Definition: ExprNode.h:1275
LatticeExprNode asin(const LatticeExprNode &expr)
TableExprNode means(const TableExprNode &array, const TableExprNodeSet &collapseAxes)
Definition: ExprNode.h:1742
LatticeExprNode fmod(const LatticeExprNode &left, const LatticeExprNode &right)
TableExprNode boxedAvdev(const TableExprNode &node, const TableExprNodeSet &halfBoxWidth)
Definition: ExprNode.h:1899
LatticeExprNode operator>(const LatticeExprNode &left, const LatticeExprNode &right)
LatticeExprNode acos(const LatticeExprNode &expr)
LatticeExprNode ndim(const LatticeExprNode &expr)
1-argument function to get the dimensionality of a lattice.
LatticeExprNode replace(const LatticeExprNode &arg1, const LatticeExprNode &arg2)
This function replaces every masked-off element in the first argument with the corresponding element ...
TableExprNode datetime(const TableExprNode &node)
Functions for date-values.
Definition: ExprNode.h:1497
TableExprNode upcase(const TableExprNode &node)
Definition: ExprNode.h:1468
LatticeExprNode mean(const LatticeExprNode &expr)
LatticeExprNode max(const LatticeExprNode &left, const LatticeExprNode &right)
TableExprNode isFinite(const TableExprNode &node)
Function to test if a scalar or array is finite.
Definition: ExprNode.h:1630
LatticeExprNode cosh(const LatticeExprNode &expr)
LatticeExprNode atan(const LatticeExprNode &expr)
TableExprNode mjdtodate(const TableExprNode &node)
Definition: ExprNode.h:1502
TableExprNode cmonth(const TableExprNode &node)
Definition: ExprNode.h:1527
TableExprNode operator&(const TableExprNode &left, const TableExprNode &right)
Definition: ExprNode.h:1181
LatticeExprNode tanh(const LatticeExprNode &expr)
TableExprNode time(const TableExprNode &node)
Definition: ExprNode.h:1580
LatticeExprNode sign(const LatticeExprNode &expr)
LatticeExprNode arg(const LatticeExprNode &expr)
LatticeExprNode log10(const LatticeExprNode &expr)
TableExprNode cdow(const TableExprNode &node)
Definition: ExprNode.h:1537
TableExprNode transpose(const TableExprNode &array)
Transpose all axes of a (masked) array.
Definition: ExprNode.h:1956
LatticeExprNode conj(const LatticeExprNode &expr)
LatticeExprNode formComplex(const LatticeExprNode &left, const LatticeExprNode &right)
Form a complex number from two real numbers.
TableExprNode ctime(const TableExprNode &node)
Definition: ExprNode.h:1549
LatticeExprNode operator%(const LatticeExprNode &left, const LatticeExprNode &right)
LatticeExprNode sinh(const LatticeExprNode &expr)
LatticeExprNode sum(const LatticeExprNode &expr)
TableExprNode nearAbs(const TableExprNode &left, const TableExprNode &right)
Definition: ExprNode.h:1250
LatticeExprNode operator+(const LatticeExprNode &expr)
Global functions operating on a LatticeExprNode.
MVBaseline operator*(const RotMatrix &left, const MVBaseline &right)
Rotate a Baseline vector with rotation matrix and other multiplications.
TableExprNode sumSquare(const TableExprNode &array)
Definition: ExprNode.h:1655
unsigned int uInt
Definition: aipstype.h:51
TableExprNode boxedRms(const TableExprNode &node, const TableExprNodeSet &halfBoxWidth)
Definition: ExprNode.h:1905
TableExprNode weekday(const TableExprNode &node)
Definition: ExprNode.h:1532
LatticeExprNode stddev(const LatticeExprNode &expr)
TableExprNode isInf(const TableExprNode &node)
Definition: ExprNode.h:1626
LatticeExprNode min(const LatticeExprNode &left, const LatticeExprNode &right)
LatticeExprNode abs(const LatticeExprNode &expr)
Numerical 1-argument functions which result in a real number regardless of input expression type.
TableExprNode amplitude(const TableExprNode &node)
The amplitude (i.e.
Definition: ExprNode.h:1440
T norm(const TableVector< T > &tv)
Definition: TabVecMath.h:414
TableExprNode phase(const TableExprNode &node)
The phase (i.e.
Definition: ExprNode.h:1448
TableExprNode boxedStddev(const TableExprNode &node, const TableExprNodeSet &halfBoxWidth)
Definition: ExprNode.h:1893
LatticeExprNode operator-(const LatticeExprNode &expr)
TableExprNode anys(const TableExprNode &array, const TableExprNodeSet &collapseAxes)
Definition: ExprNode.h:1785
TableExprNode isdefined(const TableExprNode &array)
Function operating on a field resulting in a bool scalar.
Definition: ExprNode.h:1975
TableExprNode shape(const TableExprNode &array)
Function operating on any scalar or array resulting in a Double array containing the shape.
Definition: ExprNode.h:1987
LatticeExprNode tan(const LatticeExprNode &expr)
TableExprNode day(const TableExprNode &node)
Definition: ExprNode.h:1523
TableExprNode anyCone(const TableExprNode &sourcePos, const TableExprNode &cones)
The result is always a Bool scalar telling if any cone contains the source.
Definition: ExprNode.h:1281
TableExprNode nfalses(const TableExprNode &array, const TableExprNodeSet &collapseAxes)
Definition: ExprNode.h:1803
TableExprNode dms(const TableExprNode &node)
Definition: ExprNode.h:1557
TableExprNode array(const TableExprNode &values, const TableExprNodeSet &shape)
Create an array of the given shape and fill it with the values.
Definition: ExprNode.h:1929
bool operator==(const casacore_allocator< T, ALIGNMENT > &, const casacore_allocator< T, ALIGNMENT > &)
Definition: Allocator.h:129
LatticeExprNode mask(const LatticeExprNode &expr)
This function returns the mask of the given expression.
TableExprNode angdistx(const TableExprNode &pos1, const TableExprNode &pos2)
Angular distance as above, but only pair-wise enties are used if both arguments are arrays.
Definition: ExprNode.h:1269
LatticeExprNode sin(const LatticeExprNode &expr)
Numerical 1-argument functions.
bool operator!=(const casacore_allocator< T, ALIGNMENT > &, const casacore_allocator< T, ALIGNMENT > &)
Definition: Allocator.h:135
LatticeExprNode operator/(const LatticeExprNode &left, const LatticeExprNode &right)
TableExprNode ltrim(const TableExprNode &node)
Definition: ExprNode.h:1588
LatticeExprNode atan2(const LatticeExprNode &left, const LatticeExprNode &right)
Numerical 2-argument functions.
LatticeExprNode variance(const LatticeExprNode &expr)
long long Int64
Define the extra non-standard types used by Casacore (like proposed uSize, Size)
Definition: aipsxtype.h:38
TableExprNode month(const TableExprNode &node)
Definition: ExprNode.h:1519
TableExprNode capitalize(const TableExprNode &node)
Definition: ExprNode.h:1478
TableExprNode downcase(const TableExprNode &node)
Definition: ExprNode.h:1473
TableExprNode runningStddev(const TableExprNode &array, const TableExprNodeSet &halfBoxWidth)
Definition: ExprNode.h:1833
TableExprNode square(const TableExprNode &node)
Definition: ExprNode.h:1346
LatticeExprNode any(const LatticeExprNode &expr)
Functions operating on a logical expression resulting in a scalar; Functions "any" (are any pixels "T...
TableExprNode year(const TableExprNode &node)
Definition: ExprNode.h:1515
LatticeExprNode sqrt(const LatticeExprNode &expr)
TableExprNode date(const TableExprNode &node)
Definition: ExprNode.h:1511
TableExprNode rtrim(const TableExprNode &node)
Definition: ExprNode.h:1592
float Float
Definition: aipstype.h:54
TableExprNode runningAll(const TableExprNode &array, const TableExprNodeSet &halfBoxWidth)
Definition: ExprNode.h:1863
TableExprNode arrayFlatten(const TableExprNode &array)
Flatten a masked array (get unmasked elements).
Definition: ExprNode.h:1951
LatticeExprNode ntrue(const LatticeExprNode &expr)
TableExprNode findCone(const TableExprNode &sourcePos, const TableExprNode &cones)
The sourcePos can contain multiple sources.
Definition: ExprNode.h:1287
CountedPtr< TableExprNodeRep > TENShPtr
Definition: ExprNodeRep.h:57
T product(const TableVector< T > &tv)
Definition: TabVecMath.h:385
TableExprNode cdate(const TableExprNode &node)
Definition: ExprNode.h:1545
TableExprNode boxedMedian(const TableExprNode &node, const TableExprNodeSet &halfBoxWidth)
Definition: ExprNode.h:1911
TableExprNode fractiles(const TableExprNode &array, const TableExprNode &fraction, const TableExprNodeSet &collapseAxes)
Definition: ExprNode.h:1778
TableExprNode boolean(const TableExprNode &node)
Convert numeric or string value to bool (0, no, false, - means false)
Definition: ExprNode.h:1432
LatticeExprNode operator<(const LatticeExprNode &left, const LatticeExprNode &right)
TableExprNode stddevs(const TableExprNode &array, const TableExprNodeSet &collapseAxes)
Definition: ExprNode.h:1754
TableExprNode cube(const TableExprNode &node)
Definition: ExprNode.h:1351
TableExprNode mjd(const TableExprNode &node)
Definition: ExprNode.h:1507
LatticeExprNode avdev(const LatticeExprNode &expr)
LatticeExprNode operator>=(const LatticeExprNode &left, const LatticeExprNode &right)
String toString(const SubScanKey &subScanKey)
TableExprNode sqlpattern(const TableExprNode &node)
Definition: ExprNode.h:1492
LatticeExprNode pow(const LatticeExprNode &left, const LatticeExprNode &right)
TableExprNode avdevs(const TableExprNode &array, const TableExprNodeSet &collapseAxes)
Definition: ExprNode.h:1760
TableExprNode runningMax(const TableExprNode &array, const TableExprNodeSet &halfBoxWidth)
Definition: ExprNode.h:1815
TableExprNode products(const TableExprNode &array, const TableExprNodeSet &collapseAxes)
Definition: ExprNode.h:1718
TableExprNode integer(const TableExprNode &node)
Convert double, bool, or string to int (using floor).
Definition: ExprNode.h:1428
LatticeExprNode log(const LatticeExprNode &expr)
TableExprNode boxedMean(const TableExprNode &node, const TableExprNodeSet &halfBoxWidth)
Definition: ExprNode.h:1881
LatticeExprNode iif(const LatticeExprNode &condition, const LatticeExprNode &arg1, const LatticeExprNode &arg2)
Function resembling the ternary ?: construct in C++.
TableExprNode regex(const TableExprNode &node)
Functions for regular expression matching and pattern matching.
Definition: ExprNode.h:1483
int Int
Definition: aipstype.h:50
TableExprNode variances(const TableExprNode &array, const TableExprNodeSet &collapseAxes)
Definition: ExprNode.h:1748
bool Bool
Define the standard types used by Casacore.
Definition: aipstype.h:42
LatticeExprNode operator^(const LatticeExprNode &left, const LatticeExprNode &right)
TableExprNode week(const TableExprNode &node)
Definition: ExprNode.h:1576
LatticeExprNode value(const LatticeExprNode &expr)
This function returns the value of the expression without a mask.
TableExprNode alls(const TableExprNode &array, const TableExprNodeSet &collapseAxes)
Definition: ExprNode.h:1791
TableExprNode boxedMin(const TableExprNode &node, const TableExprNodeSet &halfBoxWidth)
Definition: ExprNode.h:1869
TableExprNode marray(const TableExprNode &array, const TableExprNode &mask)
Form a masked array.
Definition: ExprNode.h:1935
TableExprNode trim(const TableExprNode &node)
Definition: ExprNode.h:1584
TableExprNode boxedMax(const TableExprNode &node, const TableExprNodeSet &halfBoxWidth)
Definition: ExprNode.h:1875
TableExprNode ctodt(const TableExprNode &node)
Definition: ExprNode.h:1541
TableExprNode ntrues(const TableExprNode &array, const TableExprNodeSet &collapseAxes)
Definition: ExprNode.h:1797
LatticeExprNode cos(const LatticeExprNode &expr)
LatticeExprNode floor(const LatticeExprNode &expr)
TableExprNode mins(const TableExprNode &array, const TableExprNodeSet &collapseAxes)
Definition: ExprNode.h:1730
TableExprNode runningVariance(const TableExprNode &array, const TableExprNodeSet &halfBoxWidth)
Definition: ExprNode.h:1827
TableExprNode diagonal(const TableExprNode &array)
Get the diagonal of a (masked) array; If the array is not a Matrix, it will take the diagonals of the...
Definition: ExprNode.h:1969
double Double
Definition: aipstype.h:55
Bool near(const GaussianBeam &left, const GaussianBeam &other, const Double relWidthTol, const Quantity &absPaTol)
LatticeExprNode median(const LatticeExprNode &expr)
LatticeExprNode all(const LatticeExprNode &expr)
LatticeExprNode nelements(const LatticeExprNode &expr)
1-argument function to get the number of elements in a lattice.
LatticeExprNode round(const LatticeExprNode &expr)
LatticeExprNode operator<=(const LatticeExprNode &left, const LatticeExprNode &right)
LatticeExprNode ceil(const LatticeExprNode &expr)
LatticeExprNode real(const LatticeExprNode &expr)
LatticeExprNode operator||(const LatticeExprNode &left, const LatticeExprNode &right)
TableExprNode runningRms(const TableExprNode &array, const TableExprNodeSet &halfBoxWidth)
Definition: ExprNode.h:1845
LatticeExprNode nfalse(const LatticeExprNode &expr)
uInt64 rownr_t
Define the type of a row number in a table.
Definition: aipsxtype.h:46
LatticeExprNode imag(const LatticeExprNode &expr)
TableExprNode hdms(const TableExprNode &node)
Definition: ExprNode.h:1561
TableExprNode strlength(const TableExprNode &node)
String functions on scalars or arrays.
Definition: ExprNode.h:1463
TableExprNode runningMedian(const TableExprNode &array, const TableExprNodeSet &halfBoxWidth)
Definition: ExprNode.h:1851
TableExprNode hms(const TableExprNode &node)
Functions for angle-values.
Definition: ExprNode.h:1553
unsigned long long uInt64
Definition: aipsxtype.h:39
TableExprNode runningAvdev(const TableExprNode &array, const TableExprNodeSet &halfBoxWidth)
Definition: ExprNode.h:1839
TableExprNode arrayData(const TableExprNode &array)
Get the data array of a masked array.
Definition: ExprNode.h:1941
TableExprNode arrayMask(const TableExprNode &array)
Get the mask of a masked array.
Definition: ExprNode.h:1946
TableExprNode rms(const TableExprNode &array)
Definition: ExprNode.h:1680