| casa::Aberration | Aberration class and calculations |
| casa::AbortError | Exception which halts execution |
| casa::Abs< T, RES > | Functor to apply abs |
| casa::ACG | Additive number generator |
| casa::Acos< T, RES > | Functor to apply acos |
| casa::AipsError | Base class for all AIPS++ library errors |
| casa::AipsIO | AipsIO is the object persistency mechanism of AIPS++ |
| casa::AipsIOCarray_global_functions_AipsIOCarray | Templated functions to get/put a C-style array from/into AipsIO |
| casa::AipsIOReaderWriter | Implementation of CASA region AipsIO file reader and writer |
| casa::Aipsrc | Class to read the casa general resource files |
| casa::AipsrcValue< T > | Class to read values from the Aipsrc general resource files |
| casa::AipsrcValue_Bool< Bool > | Specialization of AipsrcValue for Bool |
| casa::AipsrcVector< T > | Read multiple values from the Aipsrc resource files |
| casa::AipsrcVector_Bool< Bool > | Specialization of AipsrcVector for Bool |
| casa::AipsrcVector_String< String > | Specialization of AipsrcVector for String |
| casa::AllFunc | Define logical Functors |
| casa::AllocError | Allocation errors |
| casa::AntennaResponses | AntennaResponses provides access to antenna response data |
| casa::AnyFunc | |
| casa::AppInfo | General information for applications |
| casa::Array< T > | Template <class T, class U> class vector; |
| casa::Array< T >::BaseIteratorSTL | See the function begin() and end() for a detailed description of the STL iterator capability |
| casa::Array< T >::ConstIteratorSTL | |
| casa::Array< T >::IteratorSTL | |
| casa::ArrayAccessor< T, Axis< U > > | Fast 1D accessor/iterator for nD array classes |
| casa::ArrayAccessor_RT< T, AxisN > | Specialization for run-time axes |
| casa::ArrayBase | Non-templated base class for templated Array class |
| casa::ArrayBase_global_functions_Array_general_global_functions | General global functions for Arrays |
| casa::ArrayBaseAccessor< T > | Axis independent base for the ArrayAccessor classes |
| casa::ArrayColumn< T > | Read/write access to an array table column with arbitrary data type |
| casa::ArrayColumnData< T > | Access to a table column containing arrays |
| casa::ArrayColumnDesc< T > | Templated class for description of table array columns |
| casa::ArrayConformanceError | An error thrown when two arrays do not conform |
| casa::ArrayError | The base class for all Array exception classes |
| casa::ArrayFITSFieldCopier< recordType, fitsType > | A FITSFieldCopier for copying Array RecordFields to FitsFields |
| casa::ArrayIndexError | An error thrown when an index is out of range |
| casa::ArrayIO_global_functions_Array_Ascii_IO | Global functions for Matrix/Vector input/output using ASCII format |
| casa::ArrayIO_global_functions_Array_binary_IO | Global functions to read/write binary arrays from/to a file |
| casa::ArrayIO_global_functions_Array_IO | Input/output operators for Arrays |
| casa::ArrayIterator< T > | Iterate an Array cursor through another Array |
| casa::ArrayIteratorError | An error thrown by an ArrayIterator |
| casa::ArrayLattice< T > | A memory resident Lattice |
| casa::ArrayLogical_global_functions_Array_logical_operations | Logical operations for Arrays |
| casa::ArrayMath_global_functions_Array_mathematical_operations | Mathematical operations for Arrays |
| casa::ArrayMeasColumn< M > | Read write access to table array Measure columns |
| casa::ArrayNDimError | Thrown when two arrays have different dimensionality |
| casa::ArrayOpsDiffShapes_global_functions_OpsDiff_functions | Operations for 2 Arrays with possibly different shapes |
| casa::ArrayPartMath_global_functions_Array_partial_operations | Mathematical and logical operations for Array parts |
| casa::ArrayPartMath_global_functions_Array_partial_operations::AvdevFunc< T > | |
| casa::ArrayPartMath_global_functions_Array_partial_operations::FractileFunc< T > | |
| casa::ArrayPartMath_global_functions_Array_partial_operations::MaxFunc< T > | |
| casa::ArrayPartMath_global_functions_Array_partial_operations::MeanFunc< T > | |
| casa::ArrayPartMath_global_functions_Array_partial_operations::MedianFunc< T > | |
| casa::ArrayPartMath_global_functions_Array_partial_operations::MinFunc< T > | |
| casa::ArrayPartMath_global_functions_Array_partial_operations::ProductFunc< T > | |
| casa::ArrayPartMath_global_functions_Array_partial_operations::RmsFunc< T > | |
| casa::ArrayPartMath_global_functions_Array_partial_operations::StddevFunc< T > | |
| casa::ArrayPartMath_global_functions_Array_partial_operations::SumFunc< T > | |
| casa::ArrayPartMath_global_functions_Array_partial_operations::VarianceFunc< T > | |
| casa::ArrayPositionIterator | Iterate an IPosition through the shape of an Array |
| casa::ArrayQuantColumn< T > | Provides read/write access to Array Quantum columns in Tables |
| casa::ArraySampledFunctional< T > | Index into an array using the longest axis |
| casa::ArrayShapeError | An error thrown when two arrays have different shapes |
| casa::ArraySlicerError | An error thrown by an Slicer member function |
| casa::ArrayUtil_global_functions_concatenateArray | Concatenate two Arrays |
| casa::ArrayUtil_global_functions_partialFuncHelper | Helper function for partialX functions |
| casa::ArrayUtil_global_functions_reorderArray | Reorder the axes of an array |
| casa::ArrayUtil_global_functions_reorderArrayHelper | Helper function for function reorderArray |
| casa::ArrayUtil_global_functions_stringToVector | Split a String into its elements |
| casa::AsciiTableExtension | (ascii) TABLE extension |
| casa::Asin< T, RES > | Functor to apply asin |
| casa::assert_< t > | Utility class for Assert macros |
| casa::Atan< T, RES > | Functor to apply atan |
| casa::Atan2< L, R, RES > | Functor to apply atan2 |
| casa::AutoDiff< T > | Class that computes partial derivatives by automatic differentiation |
| casa::AutoDiffA< T > | Class that computes partial derivatives by automatic differentiation |
| casa::AutoDiffIO_global_functions_AutoDiff_IO_operations | Implements all IO operators and functions for AutoDiff |
| casa::AutoDiffMath_global_functions_AutoDiff_mathematical_operations | Implements all mathematical operators and functions for AutoDiff |
| casa::AutoDiffRep< T > | Representation of an automatic differential class data |
| casa::AutoDiffX< T > | Class that computes partial derivatives by automatic differentiation |
| casa::AxesMapping | Info about mapping array axes to another order |
| casa::AxesSpecifier | Specification of axes to keep or remove |
| casa::AzElColumn | Azimuth/elevation derived from TIME, etc |
| casa::BaseColumn | Abstract base class for a table column |
| casa::BaseColumnDesc | An abstract base class for table column descriptions |
| casa::BaseCompare | Abstract base class for comparing two objects |
| casa::BaseMappedArrayEngine< VirtualType, StoredType > | Templated virtual column engine for a table array of any type |
| casa::BaseSinkSource | Shared base class for ByteSink and ByteSource |
| casa::BaseSlicesFunctor< T > | Abstract baseclass for slices functors |
| casa::BaseTable | Abstract base class for tables |
| casa::BaseTableIterator | Base class for table iterator |
| casa::BasicFITS_global_functions_ReadFITS | Read a FITS file from an AIPS++ array |
| casa::BasicFITS_global_functions_WriteFITS | Write a FITS file to an AIPS++ array |
| casa::BFEngineMask | Non-templated Helper class to handle the mask |
| casa::BinarySearch_global_functions_binarysearch | Binary search a sorted, linear, data structure |
| casa::BinaryTable | BinaryTable is used to translate a FITS binary table to an aips++ Table |
| casa::BinaryTableExtension | BINTABLE extension |
| casa::Binomial | Binomial distribution |
| casa::BitAnd< T > | Functor for bitwise and of (integer) values |
| casa::BitFlagsEngine< StoredType > | Templated virtual column engine to map bit flags to a Bool |
| casa::BitFlagsEngine< StoredType >::BoolToFlags | Functor to convert Bools to flags using a mask |
| casa::BitFlagsEngine< StoredType >::FlagsToBool | Functor to and an array and mask and convert to Bool |
| casa::BitNegate< T > | Functor for bitwise negate of (integer) values |
| casa::BitOr< T > | Functor for bitwise or of (integer) values |
| casa::BitVector | Bit vectors of any size |
| casa::BitVectorHelper | Helper class for BitVector |
| casa::BitXor< T > | Functor for bitwise xor of (integer) values |
| casa::Block< T > | Simple 1-D array |
| casa::BlockInput | Fixed-length blocked sequential input base class |
| casa::BlockIO | ---------------------------------------------------------------------------- |
| casa::BlockIO_global_functions_BlockIO | IO functions for Block |
| casa::BlockOutput | Fixed-length blocked sequential output base class |
| casa::BucketBase | Abstract base class for Bucket classes |
| casa::BucketBuffered | Use buffered file IO for buckets in a part of a file |
| casa::BucketCache | Cache for buckets in a part of a file |
| casa::BucketCache_global_functions_BucketCache_CallBack | Define the type of the static read and write function |
| casa::BucketFile | File object for the bucket cache |
| casa::BucketMapped | Use file mapping for buckets in a part of a file |
| casa::ByteIO | Abstract base class for IO on a byte stream |
| casa::ByteSink | Class for write-only access to data in a given format |
| casa::ByteSinkSource | Class for read/write access to data in a given format |
| casa::ByteSource | Class for read-only access to data in a given format |
| casa::CAbs< T, RES > | Functor to apply complex function fabs |
| casa::CanonicalConversion | LDOUBLE is 8 bytes on SUN, but 16 bytes canonical |
| casa::CanonicalDataConversion | A class with virtual functions to convert canonical format |
| casa::CanonicalIO | Class for IO in canonical format |
| casa::CArg< T, RES > | Functor to apply complex function arg |
| casa::Casarc | |
| casa::Casarc::meta_entry_ | |
| casa::CasarcCleanup | |
| casa::CASATask | Task interface |
| casa::Ceil< T, RES > | Functor to apply ceil |
| casa::Chebyshev< T > | A function class that defines a Chebyshev polynomial |
| casa::ChebyshevEnums | Define enums for Chebyshev classes |
| casa::ChebyshevParam< T > | Parameter handling for Chebyshev polynomial parameters |
| casa::ChebyshevParamModeImpl< T > | A ChebyshevParam with the get/setMode implementation |
| casa::ChebyshevParamModeImpl_PS< AutoDiff< T > > | Partial specialization of ChebyshevParamModeImpl for AutoDiff |
| casa::ChebyshevParamModeImpl_PSA< AutoDiffA< T > > | Partial specialization of ChebyshevParamModeImpl for AutoDiff |
| casa::Choice | Class to ask a user a choice |
| casa::CleanEnums | Lists the different types of Convolutions that can be done |
| casa::CLInterpolator2D< T > | Abstract base class for interpolator used by CurvedLattice2D |
| casa::CLIPNearest2D< T > | Arbitrarily shaped 1-dim lattice crosscut |
| casa::ColumnCache | A caching object for a table column |
| casa::ColumnDesc | Envelope class for the description of a table column |
| casa::ColumnDescSet | Set of table column descriptions |
| casa::ColumnSet | Class to manage a set of table columns |
| casa::ColumnsIndex | Index to one or more columns in a table |
| casa::ColumnsIndexArray | Index to an array column in a table |
| casa::CombiFunction< T > | Form a linear combination of function objects |
| casa::CombiFunction_PS< AutoDiff< T > > | Partial specialization of CombiFunction for AutoDiff |
| casa::Combinatorics | Combinatorics related functions |
| casa::CombiParam< T > | Parameters for a linear combination of function objects |
| casa::Compare_global_functions_ObjCompareFunc | Signature of comparison functions |
| casa::CompiledFunction< T > | Form a linear combination of function objects |
| casa::CompiledParam< T > | Parameters for a compiled string function object |
| casa::CompiledSpectralElement | Describes a compiled function for describing a spectral profile |
| casa::Complex_global_functions_Complex_desc | Single and double precision complex numbers |
| Complexfwd_global_functions_Complexfwd | Forward declaration complex classes |
| casa::ComponentImager | |
| casa::ComponentList | A class for manipulating groups of components |
| casa::ComponentShape | Base class for component shapes |
| casa::ComponentType | Enumerators common to the ComponentsModels module |
| casa::ComponentUpdate | This class updates components in UV plane |
| casa::CompositeNumber | This class generates composite numbers |
| casa::CompoundFunction< T > | Sum of a collection of Functions which behaves as one Function object |
| casa::CompoundFunction_PS< AutoDiff< T > > | Partial AutoDiff specialization of CompoundFunction |
| casa::CompoundParam< T > | Parameters for sum of parameterized Functions |
| casa::CompressComplex | Virtual column engine to scale a table Complex array |
| casa::CompressComplexSD | Virtual column engine to scale a table Complex array for Single Dish data |
| casa::CompressFloat | Virtual column engine to scale a table float array |
| casa::ConcatColumn | A column in a concatenated table |
| casa::ConcatRows | Class holding the row numbers in a ConcatTable |
| casa::ConcatRowsIter | Class to iterate through a ConcatRows object |
| casa::ConcatScalarColumn< T > | A typed column in a concatenated table |
| casa::ConcatTable | Class to view a concatenation of tables as a single table |
| casa::Conj< T, RES > | Functor to apply complex function conj |
| casa::ConstantND< T > | A constant function |
| casa::ConstantND_PS< AutoDiff< T > > | Partial specialization of ConstantND for AutoDiff |
| casa::ConstantNDParam< T > | Parameter handling for a constant function in a space of arbitrary dimensionality |
| casa::ConstantSpectrum | Model the spectral variation with a constant |
| casa::ConstFitsKeywordList | List of read-only FITS keywords |
| casa::ConstHashMapIter< key, val > | |
| casa::ConstListIter< t > | Doubly linked constant list iterator |
| casa::ConstMapIter< key, value > | Const associative array iterator |
| casa::ConvEnums | Lists the different types of Convolutions that can be done |
| casa::Conversion | A class with general conversion definitions |
| casa::ConversionIO | Class for IO in a converted format |
| casa::ConvertScalar_global_functions_Scalar_conversion | Templated functions to convert scalars from one type to another |
| casa::ConvolveGridder< Domain, Range > | Does convolutional gridding |
| casa::Convolver< FType > | A class for doing multi-dimensional convolution |
| casa::Coordinate | Interface for converting between world and pixel coordinates |
| casa::CoordinateSystem | Interconvert pixel and world coordinates |
| casa::CoordinateUtil | Functions for creating default CoordinateSystems |
| casa::Copy_global_functions_copy | Copy methods |
| casa::Copy_global_functions_test | Test routines |
| casa::Copy_global_functions_throw | Copy objects from one C-style array to another |
| casa::CopyRecordToRecord | Copies fields between Records, possibly to fields with another name |
| casa::CopyRecordToTable | Copies fields from a Record to columns of a Table |
| casa::Cos< T, RES > | Functor to apply cos |
| casa::Cosh< T, RES > | Functor to apply cosh |
| casa::CountedConstPtr< t > | Regular referenced counted pointer for constant data |
| casa::CountedPtr< t > | Regular referenced counted pointer for non-constant data |
| casa::CountedPtr_global_functions_dereference_error | Act on dereference error |
| casa::COWPtr< T > | Copy-On-Write-Pointer class - allows control of copy based on constness |
| casa::Cube< T > | A 3-D Specialization of the Array class |
| casa::CurvedImage2D< T > | An image crosscut based on a curve in a plane |
| casa::CurvedLattice2D< T > | A lattice crosscut based on a curve in a plane |
| casa::DataConversion | Abstract base class with functions to convert any format |
| casa::DataManager | Abstract base class for a data manager |
| casa::DataManager_global_functions_DataManagerCtor | Define the type of the static "constructor" function |
| casa::DataManagerColumn | Abstract base class for a column in a data manager |
| casa::DataManError | Base error class for table data manager |
| casa::DataManInfo | Class with static functions to manipulate a datamanager record |
| casa::DataManInternalError | Internal table data manager error |
| casa::DataManInvDT | Table DataManager error; invalid data type |
| casa::DataManInvOper | Table DataManager error; invalid operation |
| casa::DataManUnknownCtor | Table DataManager error; invalid data manager |
| casa::DataManUnknownVirtualColumn | Table DataManager error; unknown virtual column |
| casa::DataType_global_functions_DataType | Data types (primarily) in the table system |
| casa::DefaultValue_global_functions_defval | A templated function which sets a variable to a default value |
| casa::DerivedMSCal | Virtual column engine to return derived MS values |
| casa::DFTError | Error class for DFTServer class |
| casa::DFTServer< T > | Class containing methods for doing n-D slow Fourier transforms |
| casa::DiracDFunction< T > | A one dimensional Dirac delta function |
| casa::DiracDParam< T > | A one dimensional Dirac delta function |
| casa::DirectionCoordinate | Interconvert pixel positions and directions (e.g. RA/DEC) |
| casa::DirectionEngine | Engine for TaQL UDF Direction conversions |
| casa::DirectionUDF | TaQL UDFs for Direction conversions |
| casa::Directory | Get information about, and manipulate directories |
| casa::DirectoryIterator | Traverse the contents of a directory |
| casa::DiscreteUniform | Discrete uniform distribution |
| casa::DiskShape | A disk model for the spatial distribution of emission |
| casa::Divides< L, R, RES > | Functor to divide variables of possible different types |
| casa::DOos | DO for accessing os-specific functions |
| casa::Dummy_Constants_class | Mathematical and numerical constants |
| casa::duplError< t > | Duplicate key errors where the bad key is returned |
| casa::DuplError | Duplicate key errors |
| casa::DynBuffer | Store data in dynamically allocated buffers |
| casa::DynLib | Class to handle loadig of dynamic libraries |
| casa::EarthField | EarthField class model calculations |
| casa::EarthMagneticMachine | Calculates magnetic field in a direction |
| casa::EclecticFunctionFactory< T > | |
| casa::EmptyStackError | Error class for the Stack class |
| casa::EnvironmentVariable | This class allows for getting enviroment variables |
| casa::EpochEngine | Engine for TaQL UDF Epoch conversions |
| casa::EpochUDF | TaQL UDFs for Epoch conversions |
| casa::Erlang | Erlang distribution |
| casa::Euler | Vector of Euler rotation angles |
| casa::EvenPolynomial< T > | A one dimensional odd polynomial class |
| casa::EvenPolynomial_PS< AutoDiff< T > > | Partial specialization of EvenPolynomial for AutoDiff |
| casa::EvenPolynomialParam< T > | Parameter handling for even polynomials |
| casa::Exp< T, RES > | Functor to apply exp |
| casa::ExpSincConv< T > | Exponential times a Sinc |
| casa::ExtendImage< T > | An extension of an ImageInterface object |
| casa::ExtendLattice< T > | An extension of a Lattice or MaskedLattice |
| casa::ExtendSpecifier | Specification of new and stretched lattice axes |
| casa::ExtensionHeaderDataUnit | Base class for generalized exentensions HDU |
| casa::ExternalLockSync | Class to hold table lock data |
| casa::Fallible< T > | Mark a value as valid or invalid |
| casa::Fallible_global_functions_invalid_access | Throw exception on access of an invalid object This function gets called when an invalid object is accessed. It just throws an exception. Since we have inline functions, let's keep the throw out of them to keep them from moving out of line |
| casa::FFTEnums | Lists the different types of FFT's that can be done |
| casa::FFTPack | C++ interface to the Fortran FFTPACK library |
| casa::FFTServer< T, S > | A class with methods for Fast Fourier Transforms |
| casa::FFTW | C++ interface to the FFTWw library |
| casa::FieldNotFoundError | |
| casa::File | Class to get file information and a base for other file classes |
| casa::FilebufIO | Class for buffered file IO |
| casa::FiledesIO | Class for IO on a file descriptor |
| casa::FileLocker | Class to handle file locking |
| casa::Fit2D | Fit 2-D objects to 2-D Lattices or Arrays |
| casa::FitGaussian< T > | Multidimensional fitter class for Gaussians |
| casa::FITS | Static functions and enumerations |
| casa::FITS2_global_functions_ReadFITSin | Helper function for ReadFITS and WriteFITS |
| casa::FitsArray< TYPE > | FITS array of given type |
| casa::FitsArray< FitsBit > | FITS array of FitsBit type |
| casa::FitsBase | Helper class |
| casa::FitsBit | Helper class for FITS Binary Tables |
| casa::FITSCoordinateUtil | |
| casa::FITSDateUtil | A class with static functions to help deal with FITS dates |
| casa::FitsDiskInput | FITS input from disk |
| casa::FitsDiskOutput | FITS output to disk |
| casa::FITSError | Default FITS error handling function, typdef, and enumeration |
| casa::FITSExtInfo | Class for storing FITS Image extension information |
| casa::FitsField< TYPE > | Helper class Note: Note that FitsField does not allocate space for the data; Space is external to FitsField and its address is set via the setaddr function; |
| casa::FitsField< FitsBit > | Helper class |
| casa::FITSFieldCopier | Virtual base class for copying RORecordFields to FitsFields |
| casa::FitsFPUtil | Utility functions for floating point values |
| casa::FITSGroupWriter | Simplified interface to create and write to FITS random groups |
| casa::FITSHistoryUtil | A class with static functions to help deal with FITS History cards |
| casa::FITSIDItoMS1 | FITSIDItoMS converts a FITS-IDI file to a CASA Measurement Set |
| casa::FITSImage | Class providing native access to FITS images |
| casa::FITSImgParser | Class for handling FITS Image extensions |
| casa::FitsInput | Fixed-length sequential blocked FITS input |
| casa::FitsIO | Sequential FITS I/O |
| casa::FitsKeyCardTranslator | Translator between Keyword lists and fixed FITS cars |
| casa::FitsKeyword | FITS keyword |
| casa::FitsKeywordList | Linked list of FITS keywords |
| casa::FITSKeywordUtil | A class with static functions to help deal with FITS Keywords |
| casa::FitsLogical | FITS helper class |
| casa::FITSMask | Provides an on-the-fly mask for FITS images |
| casa::FITSMultiTable | View multiple FITS files as a single table |
| casa::FitsNameResult | Analyse the name of a header card |
| casa::FitsOutput | Fixed-length sequential blocked FITS output |
| casa::FitsParse | Parse a header card |
| casa::FITSSpectralUtil | A class with static functions to help deal with FITS spectral axes |
| casa::FitsStdInput | FITS input from standard input |
| casa::FitsStdOutput | FITS output to standard output |
| casa::FITSTable | Attach a FITSTabular to a binary or ASCII table |
| casa::FITSTableWriter | Simplified interface to create and write to a FITS Binary Table |
| casa::FITSTabular | Simplified interface to FITS tables with AIPS++ Look and Feel |
| casa::FitsTape9Input | FITS input from 9-track tape |
| casa::FitsTape9Output | FITS output to 9-track tape |
| casa::FITSTimedTable | |
| casa::FitsVADesc | Variable Length Array Descriptor |
| casa::FitsValueResult | Analyse the value of a header card |
| FittingProxy | This class gives Proxy to Fitting connection |
| FittingProxy::FitType | Class to aid in distributing different fitters |
| casa::Floor< T, RES > | Functor to apply floor |
| casa::Flux< T > | A class that represents the Flux (reference semantics) |
| casa::FluxCalc_SS_JPL_Butler | Class ROScalarColumn<Double>; There doesn't seem to be a way to forward declare a template |
| casa::FluxCalcLogFreqBrokenPolynomial | FluxCalcLogFreqBrokenPolynomial: Implementation base class for flux standards which are broken polynomials of log10(frequency) |
| casa::FluxCalcLogFreqPolynomial | FluxCalcLogFreqPolynomial: Implementation base class for flux standards which are polynomials of log10(frequency) |
| casa::FluxCalcQS | Class Vector; |
| casa::FluxRep< T > | A class that represents the Flux (copy semantics) |
| casa::FluxStandard | FluxStandard: Compute flux densities for standard reference sources |
| casa::FluxStdBaars | FluxStdBaars: The Baars flux standard |
| casa::FluxStdPerley90 | FluxStdPerley90: The Perley90 flux standard |
| casa::FluxStdPerleyButler2010 | FluxStdPerleyButler2010: The PerleyButler2010 flux standard |
| casa::FluxStdPerleyTaylor95 | FluxStdPerleyTaylor95: The PerleyTaylor95 flux standard |
| casa::FluxStdPerleyTaylor99 | FluxStdPerleyTaylor99: The PerleyTaylor99 flux standard |
| casa::Fmod< L, R, RES > | Functor to apply fmod |
| casa::ForwardColumn | Virtual column forwarding to another column |
| casa::ForwardColumnEngine | Virtual column engine forwarding to other columns |
| casa::ForwardColumnIndexedRow | Virtual column forwarding to another row/column |
| casa::ForwardColumnIndexedRowEngine | Virtual column engine forwarding to other columns/rows |
| casa::FrequencyAligner< T > | Aligns spectra in frequency space |
| casa::FuncExprData | Data and enumerations for functional expressions |
| casa::FuncExprData::ExprCompState | The compilation state descriptor |
| casa::FuncExprData::ExprOperator | The operator description: code; priority; # of arguments; # of arguments used up (or produced for functions) |
| casa::FuncExprData_global_functions_output | Output function |
| casa::FuncExpression | An expression executable as function |
| casa::FuncExpression_global_functions_execute | Execute function |
| casa::FuncExpression_global_functions_output | Output function |
| casa::FuncId | Function ID, for use by MathFunc class |
| casa::Function< T, U > | Numerical functional interface class |
| casa::Function1D< T, U > | Numerical functional interface class for 1 dimension |
| casa::Function_global_functions_Output | Global functions |
| casa::Functional< Domain, Range > | Map a domain object into a range object via operator() |
| casa::FunctionalProxy | |
| casa::FunctionFactory< T > | Class for creating Function objects from Records |
| casa::FunctionFactoryError | |
| casa::FunctionHolder< T > | A holder for Functions to enable record conversions |
| casa::FunctionHolder< T >::FuncStat | Structure to hold functional status |
| casa::FunctionMarshallable | Class for serializing/reconstituting Function objects to/from Records |
| casa::FunctionOrder< T > | Container of function description details |
| casa::FunctionOrder_global_functions_Output | Global functions |
| casa::FunctionParam< T > | Container of function parameters with masking flags |
| casa::FunctionParam_global_functions_Output | Global functions |
| casa::FunctionTraits< T > | Function data types for parameters and arguments |
| casa::FunctionTraits_P< AutoDiff< T > > | FunctionTraits specialization for AutoDiff |
| casa::FunctionTraits_PA< AutoDiffA< T > > | FunctionTraits specialization for AutoDiffA |
| casa::FunctionTraits_PX< AutoDiffX< T > > | FunctionTraits specialization for AutoDiffX |
| casa::FunctionWrapper< T > | Construct nD function objects from C++ functions |
| casa::Gaussian1D< T > | A one dimensional Gaussian class |
| casa::Gaussian1D_PS< AutoDiff< T > > | Partial specialization of Gaussian1D for AutoDiff |
| casa::Gaussian1DParam< T > | Parameter handling for one dimensional Gaussian class |
| casa::Gaussian2D< T > | A two dimensional Gaussian class |
| casa::Gaussian2D_PS< AutoDiff< T > > | Partial specialization of Gaussian2D for AutoDiff |
| casa::Gaussian2DParam< T > | Parameter handling for 2 dimensional Gaussian class |
| casa::Gaussian3D< T > | A three dimensional Gaussian class |
| casa::Gaussian3D_PS< AutoDiff< T > > | Partial specialization of Gaussian3D for AutoDiff |
| casa::Gaussian3DParam< Type > | Parameter handling for 3 dimensional Gaussian class |
| casa::GaussianConv< T > | Gaussian |
| casa::GaussianConvert | Converts Gaussian parameters between pixel and world |
| casa::GaussianMultipletSpectralElement | Describes a multiplet of Gaussian shaped spectral lines |
| casa::GaussianND< T > | A Multi-dimensional Gaussian functional |
| casa::GaussianNDParam< T > | A Multi-dimensional Gaussian parameter handling |
| casa::GaussianShape | A Gaussian model for the spatial distribution of emission |
| casa::GaussianSpectralElement | Describes a Gaussian spectral line |
| casa::generic_global_functions_def | Generic gnu macros |
| casa::GenericL2Fit< T > | Generic base class for least-squares fit |
| casa::GenSort< T > | General in-place sort functions |
| casa::GenSort_global_functions_genSortIndirect | Global indirect sort functions The following global functions easier to use than the static GenSortIndirect member functions |
| casa::GenSort_global_functions_genSortInPlace | Global in-place sort functions The following global functions are easier to use than the static GenSort member functions |
| casa::GenSortIndirect< T > | General indirect sort functions |
| casa::Geometric | Discrete geometric distribution |
| casa::GetCellSlices< T > | Functor to get irregular array slices from a cell |
| casa::GetColumnSlices< T > | Functor to get irregular array slices from a column |
| casa::GNoiseFunction< T > | A one dimensional normal distribution |
| casa::GNoiseParam< T > | A one dimensional normal distribution |
| casa::Gridder< Domain, Range > | A base class for gridding |
| casa::HaDecColumn | Hourangle/declination derived from TIME, etc |
| casa::HashClass< key > | Hash function with state |
| casa::HashMap< key, val > | Associative Array with a hash table implementation |
| casa::HashMap_global_functions_defaulthashvalue | Specify the default values for HashMap keys |
| casa::HashMap_global_functions_hashfunc | Hash functions for standard types |
| casa::HashMapIO_global_functions_hashmapio | HashMap/HashMapIter IO functions |
| casa::HashMapIter< key, val > | Step through a non-const HashMap |
| casa::HDF5DataSet | A class representing an HDF5 data set |
| casa::HDF5DataType | A class representing an HDF5 data type |
| casa::HDF5Error | Base error class for HDF5 wrapper classes |
| casa::HDF5File | A class representing an HDF5 file |
| casa::HDF5Group | A class representing an HDF5 group |
| casa::HDF5HidAttribute | A class representing an HDF5 attribute hid |
| casa::HDF5HidDataSpace | A class representing an HDF5 dataspace hid |
| casa::HDF5HidDataType | A class representing an HDF5 datatype hid |
| casa::HDF5HidProperty | A class representing an HDF5 property hid |
| casa::HDF5Image< T > | Read, store, and manipulate astronomical images in HDF5 format |
| casa::HDF5Lattice< T > | A Lattice that is read from or written to an HDF5 dataset |
| casa::HDF5LattIter< T > | A read/write Lattice iterator for PagedArrays |
| casa::HDF5Object | An abstract base class representing an HDF5 object |
| casa::HDF5Record | A class to write/read a record into HDF5 |
| casa::HeaderDataUnit | Base class that defines a HDU |
| casa::HistAcc< T > | Makes a histogram from input values |
| casa::HistTiledCollapser< T > | Generate histograms, tile by tile, from a masked lattice |
| casa::HostInfo | Miscellaneous information about this host and process |
| casa::HourangleColumn | Hourangle derived from TIME, etc |
| casa::HyperGeometric | Hypergeometric distribution |
| casa::HyperPlane< T > | A hyper plane function |
| casa::HyperPlane_PS< AutoDiff< T > > | Partial specialization of HyperPlane for AutoDiff |
| casa::HyperPlaneParam< T > | Parameter handling for a hyper plane function |
| casa::IBMConversion | A class with static functions to convert IBM format |
| casa::IBMDataConversion | A class with virtual functions to convert IBM format |
| casa::IComplex | Integer complex numbers |
| casa::Imag< T, RES > | Functor to apply complex function imag |
| casa::Image2DConvolver< T > | This class does 2D convolution of an image by a functional form |
| casa::ImageAttrGroup | Abstract base class for an image attributes group |
| casa::ImageAttrGroupCasa | Attribute group for a CASA image |
| casa::ImageAttrGroupHDF5 | Attribute group for a HDF5 image |
| casa::ImageAttrHandler | Abstract base class for an image attributes handler |
| casa::ImageAttrHandlerCasa | Abstract base class for an image attributes handler |
| casa::ImageAttrHandlerHDF5 | Abstract base class for an image attributes handler |
| casa::ImageConcat< T > | Concatenates images along a specified axis |
| casa::ImageConvolver< T > | This class does convolution of an image by an Array or Lattice |
| casa::ImageDecomposer< T > | A tool to separate a complex image into individual components |
| casa::ImageExpr< T > | Hold mathematical expressions involving ImageInterface objects |
| casa::ImageExprGram_global_functions_ImageExprGramFunctions | Global functions for flex/bison scanner/parser for ImageExprGram |
| casa::ImageExprParse | Class to hold values from image expression parser |
| casa::ImageExtension< TYPE > | IMAGE extension of given type |
| casa::ImageFFT | FFT an image |
| casa::ImageFit1D< T > | Fit spectral components to a Vector of data from an image |
| casa::ImageFITSConverter | Interconvert between AIPS++ Images and FITS files |
| casa::ImageFITSConverterImpl< HDUType > | This class is an internal class for ImageFITSConverter |
| casa::ImageHistograms< T > | Displays histograms of regions from an image |
| casa::ImageInfo | Miscellaneous information related to an image |
| casa::ImageInfo_global_functions_Output | Global functions |
| casa::ImageInterface< T > | A base class for astronomical images |
| casa::ImageMetaData | A class in which to store and allow read-only access to image metadata |
| casa::ImageMoments< T > | This class generates moments from an image |
| casa::ImageMomentsProgress | Provides a progress meter for the ImageMoments class |
| casa::ImageOpener | Definition of image types and handlers |
| casa::ImagePol | Implementation of the image polarimetry functionality available from casapy |
| casa::ImagePolarimetry | Polarimetric analysis of images |
| casa::ImageProxy | |
| casa::ImageRegion | Class to hold a region of interest in an image |
| casa::ImageRegrid< T > | This regrids one image to match the coordinate system of another |
| casa::ImageReorderer | |
| casa::ImageSourceFinder< T > | Provides functionality to find sources in an image |
| casa::ImageStatistics< T > | Displays various statistics from an image |
| casa::ImageSummary< T > | Provides and lists information about the header of an image |
| casa::ImageTwoPtCorr< T > | Compute two point correlation functions from images |
| casa::ImageUtilities | Utility functions for Image manipulation |
| casa::IncrementalStMan | The Incremental Storage Manager |
| casa::indexError< t > | Index errors returning the bad index |
| casa::IndexError | Base class for all indexing errors |
| casa::Input | Input.h: A simple command-line argument method for applications |
| casa::Interpolate1D< Domain, Range > | Interpolate in one dimension |
| casa::Interpolate2D | A two dimension interpolator for Matrices or Arrays |
| casa::InterpolateArray1D< Domain, Range > | Interpolate in one dimension |
| casa::InvalidIterError | Invalide iteration error class |
| casa::InvalidSerializationError | |
| casa::IPosition | A Vector of integers, for indexing into Array<T> objects |
| casa::IPosition_global_functions_IPosition_Arithmetic | Arithmetic Operations for IPosition's Element by element arithmetic on IPositions |
| casa::IPosition_global_functions_IPosition_Indexing | Indexing functions for IPosition's Convert between IPosition and offset in an array |
| casa::IPosition_global_functions_IPosition_Logical | Logical operations for IPosition's Element by element boolean operations on IPositions |
| casa::IsFinite< T > | Functor to test for finiteness |
| casa::IsInf< T > | Functor to test for infinity |
| casa::ISMBase | Base class of the Incremental Storage Manager |
| casa::ISMBucket | A bucket in the Incremental Storage Manager |
| casa::ISMColumn | A Column in the Incremental Storage Manager |
| casa::ISMIndColumn | A column of Incremental storage manager for indirect arrays |
| casa::ISMIndex | The Index of the Incremental Storage Manager |
| casa::IsNaN< T > | Functor to test for NaN |
| casa::IterBoundaryError | Iteration Boundary error class |
| casa::IterError | Iteration error class |
| casa::IterInitError | Iteration initialization error |
| casa::KaiserBFunction< T > | A one dimensional Kaiser-Bessel function |
| casa::KaiserBParam< T > | A one dimensional Kaiser-Bessel function |
| casa::KB_Conv< T > | A Kaiser-Bessel function |
| casa::LargeFilebufIO | Class for buffered IO on a large file |
| casa::LargeFiledesIO | Class for IO on a large file descriptor |
| casa::LargeRegularFileIO | Class for IO on a regular large file |
| casa::LASTColumn | Local sidereal time derived from TIME, etc |
| casa::Lattice< T > | A templated, abstract base class for array-like objects |
| casa::LatticeAddNoise | Add noise from specified distribution to a lattice |
| casa::LatticeApply< T, U > | Optimally iterate through a Lattice and apply provided function object |
| casa::LatticeBase | A non-templated, abstract base class for array-like objects |
| casa::LatticeCache< T > | Class for caching image access via tiles |
| casa::LatticeCleaner< T > | A class for doing multi-dimensional cleaning |
| casa::LatticeCleanProgress | Abstract base class to monitor progress in lattice operations |
| casa::LatticeConcat< T > | Concatenates lattices along a specified axis |
| casa::LatticeConvolver< T > | A class for doing multi-dimensional convolution |
| casa::LatticeExpr< T > | Class to allow C++ expressions involving lattices |
| casa::LatticeExprNode | Bridging class to allow C++ expressions involving lattices |
| casa::LatticeFFT | Functions for Fourier transforming Lattices |
| casa::LatticeFit | Fit every line of pixels parallel to any axis in a Lattice |
| casa::LatticeFractile< T > | Static functions to get median and fractiles of a lattice |
| casa::LatticeHistograms< T > | Displays histograms of regions from a lattice |
| casa::LatticeHistProgress | Provides a progress meter for the LatticeHistograms class |
| casa::LatticeHistSpecialize | Specialized functions for LatticeHistograms |
| casa::LatticeIndexer | A helper class for stepping through Lattices |
| casa::LatticeIterator< T > | A read/write lattice iterator |
| casa::LatticeIterInterface< T > | A base class for Lattice iterators |
| casa::LatticeLocker | Class to hold a (user) lock on a lattice |
| casa::LatticeNavigator | Abstract base class to steer lattice iterators |
| casa::LatticeProgress | Abstract base class to monitor progress in lattice operations |
| casa::LatticeRegion | An optionally strided region in a Lattice |
| casa::LatticeSlice1D< T > | Extract a 1-D slice from a Lattice |
| casa::LatticeStatistics< T > | Compute and display various statistics from a lattice |
| casa::LatticeStatsBase | Base class for LatticeStatistics class |
| casa::LatticeStepper | Traverse a Lattice by cursor shape |
| casa::LatticeTwoPtCorr< T > | Compute two point auto-correlation functions from a lattice |
| casa::LatticeUtilities | Static functions for Lattices |
| casa::LatticeUtilities_global_functions_LatticeUtilities | Global functions on Lattices |
| casa::LattRegionHolder | Class to hold a region of interest in an image |
| casa::LattStatsProgress | Provides a progress meter for the LatticeStatistics class |
| casa::LattStatsSpecialize | |
| casa::LCBox | Class to define a rectangular box of interest |
| casa::LCComplement | Make the complement of a region |
| casa::LCConcatenation | Combine multiple LCRegion's into a new dimension |
| casa::LCDifference | Make the difference of 2 regions |
| casa::LCEllipsoid | Define an N-dimensional ellipsoidal region of interest |
| casa::LCExtension | Extend an LCRegion along straight lines to other dimensions |
| casa::LCHDF5Mask | Class to define a rectangular mask as a region |
| casa::LCIntersection | Make the intersection of 2 or more regions |
| casa::LCLELMask | Class to define a mask as a LEL expression |
| casa::LCMask | Class to define a rectangular mask as a temporary region |
| casa::LCPagedMask | Class to define a rectangular mask as a region |
| casa::LCPixelSet | Class to define a rectangular mask as a region |
| casa::LCPolygon | Define a 2-dimensional region by a polygon |
| casa::LCRegion | Abstract base class to define a region of interest in lattice coordinates |
| casa::LCRegionFixed | Abstract base class to define a fixed region |
| casa::LCRegionMulti | Make the intersection of 2 or more regions |
| casa::LCRegionSingle | Abstract base class to define a single region |
| casa::LCSlicer | Class to define a rectangular box of interest with strides |
| casa::LCStretch | Stretch length 1 axes in an LCRegion along straight lines |
| casa::LCUnion | Make the union of 2 or more regions |
| casa::LECanonicalConversion | A class with static functions to convert little endian canonical format |
| casa::LECanonicalDataConversion | A class with virtual functions to convert little endian canonical format |
| casa::LECanonicalIO | Class for IO in little endian canonical format |
| casa::LELArray< T > | This LEL class holds an array with a mask |
| casa::LELArrayBase | Base class for LELArray holding the mask |
| casa::LELArrayRef< T > | This LEL class holds a possible referenced array with a mask |
| casa::LELAttribute | Ancillary information for the LEL letter classes |
| casa::LELBinary< T > | This LEL class handles numerical binary operators |
| casa::LELBinaryBool | This LEL class handles logical binary operators |
| casa::LELBinaryCmp< T > | This LEL class handles relational binary numerical operators |
| casa::LELBinaryEnums | Each LEL binary operation is described in this enum |
| casa::LELCondition< T > | Class to make a mask from a condition |
| casa::LELConvert< T, F > | Class to convert a LEL node from one numerical type to another |
| casa::LELCoordinates | Envelope class to handle Lattice Coordinates in LEL |
| casa::LELFunction1D< T > | This LEL class handles numerical (real and complex) 1-argument functions |
| casa::LELFunctionBool | This LEL class handles logical functions |
| casa::LELFunctionComplex | This LEL class handles complex numerical functions |
| casa::LELFunctionDComplex | This LEL class handles double complex numerical functions |
| casa::LELFunctionDouble | This LEL class handles numerical functions whose return type is a Double |
| casa::LELFunctionEnums | Each LEL function is described in this enum |
| casa::LELFunctionFloat | This LEL class handles numerical functions whose return type is a Float |
| casa::LELFunctionND< T > | This LEL class handles functions with a variable number of arguments |
| casa::LELFunctionReal1D< T > | This LEL class handles numerical (real only) 1-argument functions |
| casa::LELImageCoord | The letter class for image coordinates |
| casa::LELInterface< T > | This base class provides the interface for Lattice expressions |
| casa::LELLattCoord | The base letter class for lattice coordinates in LEL |
| casa::LELLattCoordBase | The base letter class for lattice coordinates in LEL |
| casa::LELLattice< T > | This LEL class handles access to Lattices |
| casa::LELRegion | Class to hold a region as a LEL node |
| casa::LELRegionAsBool | Class to convert a region to a boolean node |
| casa::LELScalar< T > | This LEL class holds a scalar with a mask |
| casa::LELSpectralIndex< T > | This LEL class handles calculation of the spectral index |
| casa::LELUnary< T > | This LEL class handles numerical unary operators |
| casa::LELUnaryBool | This LEL class handles logical unary operators |
| casa::LELUnaryConst< T > | This LEL class handles scalar (unary) constants |
| casa::LELUnaryEnums | Each LEL unary operation is described in this enum |
| casa::LinearCoordinate | Interconvert between pixel and a linear world coordinate |
| casa::LinearFit< T > | Class for linear least-squares fit |
| casa::LinearFitSVD< T > | Linear least-squares fit using Singular Value Decomposition method |
| casa::LinearSearch_global_functions_linearsearch | Linear search a linear data structure |
| casa::LinearXform | Perform a linear transform between input and output vectors |
| casa::LineCollapser< T, U > | Abstract base class for LatticeApply function signatures |
| casa::Link< t > | Doubly linked list primitive |
| casa::List< t > | Doubly linked list |
| casa::ListIO_global_functions_List_IO | Input/output operators for Lists |
| casa::ListIter< t > | Doubly linked non-constant list iterator The List class above only provides for the list framework |
| casa::ListNotice< t > | Linked list update notice |
| casa::LittleEndianConversion | A class with static functions to convert littleEndian format |
| casa::LockFile | Class to handle file locking and synchronization |
| casa::Log< T, RES > | Functor to apply log |
| casa::Log10< T, RES > | Functor to apply log10 |
| casa::LogFilter | Filter LogMessages on message priority |
| casa::LogFilterExpr | Class to deal with a TaQL expression to filter messages |
| casa::LogFilterInterface | Abstract base class for filtering LogMessages |
| casa::LogFilterTaql | Filter LogMessages using a TaQL expression |
| casa::LoggerHolder | Class holding a hierarchy of loggers |
| casa::LoggerHolderIterator | Class to iterate through an LoggerHolder |
| casa::LoggerHolderRep | Representation of the class holding a hierarchy of loggers |
| casa::LogHolderIter | Class doing the actual iteration through an LoggerHolder |
| casa::LogHolderIterEntry | Class representing an entry in a LoggerHolder |
| casa::LogiArray_global_functions_LogicalArray | Logical valued Arrays |
| casa::LogiArrayFwd_global_functions_LogicalArray_forwards | Forward declarations for LogicalArrays |
| casa::LogiCube_global_functions_LogicalCube | Logical valued Cubes |
| casa::LogiMatrix_global_functions_LogicalMatrix | Logical valued Matrices |
| casa::LogIO | Ostream-like interface to creating log messages |
| casa::LogIO_global_functions_command | Functions to send commands to a LogIO object |
| casa::LogIO_global_functions_output | Functions to accumulate text in the output message |
| casa::LogiVector_global_functions_LogicalVector | Logical valued Vectors |
| casa::LogMessage | Informational log messages with with time, priority, and origin |
| casa::LogMessage_global_functions_LogMessage_ostream | Write a LogMessage to an ostream |
| casa::LogNormal | Logarithmic normal distribution |
| casa::LogOrigin | LogOrigin: The source code location of the originator of a LogMessage |
| casa::LogOrigin_global_functions_LogOrigin_ostream | Write a LogOrigin to an ostream |
| casa::LogOrigin_global_functions_SourceLocation | Helper struct to get the source line |
| casa::LogOrigin_global_functions_SourceLocation::SourceLocation | |
| casa::LogSink | Distribute LogMessages to their destination(s) |
| casa::LogSinkInterface | Accepts LogMessages and posts them to some destination |
| casa::Lorentzian1D< T > | A one dimensional Lorentzian class |
| casa::Lorentzian1D_PS< AutoDiff< T > > | Partial specialization of Lorentzian1D for AutoDiff |
| casa::Lorentzian1DParam< T > | Parameter handling for one dimensional Lorentzian class |
| casa::LorentzianSpectralElement | Describes a single Lorentzian spectral profile |
| casa::LSQaips | Interface for aips++ Vectors in least squares fitting |
| casa::LSQComplex | Type of complex numeric class indicator |
| casa::LSQFit | Basic class for the least squares fitting |
| casa::LSQFit::AsReal | |
| casa::LSQFit::Complex | |
| casa::LSQFit::Conjugate | |
| casa::LSQFit::Real | Simple classes to overload templated memberfunctions |
| casa::LSQFit::Separable | |
| casa::LSQMatrix | Support class for the LSQ package |
| casa::LSQNull | Non relevant class indicator |
| casa::LSQReal | Typing support classes for LSQ classes |
| casa::LSQTraits< T > | Traits for numeric classes used |
| casa::LSQTraits_CD< std::complex< Double > > | LSQTraits specialization for DComplex |
| casa::LSQTraits_CF< std::complex< Float > > | LSQTraits specialization for Complex |
| casa::LSQTraits_D< Double > | LSQTraits specialization for Double |
| casa::LSQTraits_F< Float > | LSQTraits specialization for Float |
| casa::LSQType< T > | Determine if pointer type |
| casa::LSQType< T >::PointerTraits< U > | |
| casa::LSQType< T >::PointerTraits< U * > | |
| casa::MakeComplex< L, R, RES > | Functor to form a complex number from the left and right value |
| casa::MakeComplexImag< L, R, RES > | Functor to form a complex number from the left value and the imaginary part of the right value |
| casa::MakeComplexReal< L, R, RES > | Functor to form a complex number from the real part of the left value and the right value |
| casa::MakeComplexRealImag< L, R, RES > | Functor to form a complex number from the real part of the left value and the imaginary part of the right value |
| mallinfo | |
| casa::Map< key, value > | Abstract base class for associative arrays |
| casa::MapIO_global_functions_Map_IO | Input/output operators for Maps |
| casa::MapIter< key, value > | Associative array iterator |
| casa::MapIterRep< key, value > | Abstract base class for associative array iterators |
| casa::MappedArrayEngine< VirtualType, StoredType > | Templated virtual column engine to map the data type of a table array |
| casa::MapRep< key, value > | Map representation class |
| casa::MarshallableChebyshev< T > | A Chebyshev function class that supports serialization |
| casa::MarshButterworthBandpass< T > | A Butterworth function class that supports serialization |
| casa::MaskArrIO_global_functions_MaskedArray_IO | Ascii input/output operations for MaskedArrays |
| casa::MaskArrLogi_global_functions_MaskedArray_logical_operations | Logical operations for MaskedArrays, and between MaskedArrays and Arrays |
| casa::MaskArrMath_global_functions_MaskedArray_mathematical_operations | Mathematical operations for MaskedArrays (and with Arrays) |
| casa::MaskedArray< T > | Class for masking an Array for operations on that Array |
| casa::MaskedArray_global_functions_MaskedArray_general_global_functions | General global functions for MaskedArrays, and MaskedArrays and Arrays |
| casa::MaskedAvdevFunc< T > | |
| casa::MaskedLattice< T > | A templated, abstract base class for array-like objects with masks |
| casa::MaskedMaxFunc< T > | |
| casa::MaskedMeanFunc< T > | |
| casa::MaskedMedianFunc< T > | |
| casa::MaskedMinFunc< T > | |
| casa::MaskedProductFunc< T > | |
| casa::MaskedRmsFunc< T > | |
| casa::MaskedStddevFunc< T > | |
| casa::MaskedSumFunc< T > | |
| casa::MaskedVarianceFunc< T > | |
| casa::MaskLogiArr_global_functions_MaskedLogicalArray | Masked LogicalArrays |
| casa::MaskLogiArrFwd_global_functions_MaskedLogicalArray_forwards | Forward declarations for MaskedLogicalArrays |
| casa::MaskSpecifier | Class to specify which mask to use in an image |
| casa::Math_global_functions_Math_interface_for_casacore | AIPS++ interface to math.h and other scalar math functions |
| casa::MathFunc< T > | A class to generate values of mathematical functions |
| casa::MathFunc_global_functions_FUNCTYPE_enum | Enum used to identify function type for MathFunc class |
| casa::MathFunc_global_functions_spheriodal_functions | Fred Schwab function to calculate spheriodal functions |
| casa::MathFuncError | Error class for MathFunc class |
| casa::Matrix< T > | A 2-D Specialization of the Array class |
| casa::MatrixIterator< T > | Iterate a Matrix cursor through another Array |
| casa::MatrixMath_global_functions_Linear_Algebra | Linear algebra functions on Vectors and Matrices |
| casa::MatrixMathLA_global_functions_Linear_Algebra | Linear algebra functions on Vectors and Matrices |
| casa::MatrixSolver | MatrixSolver.h: the base class for solvers of linear equations AX=B |
| casa::Max< L, R, RES > | Functor to get maximum of two values |
| casa::MBaseline | A Measure: Baseline on Earth |
| casa::MCBase | Base for specific measure conversions |
| casa::MCBaseline | MBaseline conversion routines |
| casa::MCDirection | MDirection conversion routines |
| casa::MCDoppler | MDoppler conversion routines |
| casa::MCEarthMagnetic | MEarthMagnetic conversion routines |
| casa::MCEpoch | MEpoch conversion routines |
| casa::MCFrame | Measure frame calculations proxy |
| casa::MCFrequency | MFrequency conversion routines |
| casa::MConvertBase | Conversion of Measures Base |
| casa::MConvertBase_global_functions_Output | Global functions |
| casa::MCPosition | MPosition conversion routines |
| casa::MCRadialVelocity | MRadialVelocity conversion routines |
| casa::MCuvw | Muvw conversion routines |
| casa::MDirection | A Measure: astronomical direction |
| casa::MDoppler | A Measure: Doppler shift |
| casa::MEarthMagnetic | A Measure: Magnetic field on Earth |
| casa::MeasBase< Mv, Mr > | Base class for all measures |
| casa::MeasComet | Position for comets and other solar system bodies |
| casa::MeasConvert< M > | Conversion of Measures |
| casa::MeasData | MeasData provides Measure computing data |
| casa::MeasFrame | Container for Measure frame |
| casa::MeasFrame_global_functions_Output | Global functions |
| casa::MeasIERS | Interface to IERS tables |
| casa::MeasJPL | Interface to JPL DE tables |
| casa::MeasMath | Measure conversion aid routines |
| casa::MeasRef< Ms > | Reference frame for physical measures |
| casa::MeasRef< Ms >::RefRep | Representation class |
| casa::MeasTable | MeasTable provides Measure computing database data |
| casa::Measure | Physical quantities within reference frame |
| casa::Measure_global_functions_Output | Global functions |
| casa::MeasureHolder | A holder for Measures to enable record conversions |
| casa::MeasurementSet | A Table intended to hold astronomical data (a set of Measurements) |
| MeasuresProxy | |
| casa::MeasValue | Base class for values in a Measure |
| casa::MeasValue_global_functions_Output | Global functions |
| casa::MedianSlider | Class to compute sliding median |
| casa::Memory | Memory related information and utilities. use visibility=export> |
| casa::MemoryIO | Class for IO to a memory buffer |
| casa::MemoryLogSink | Save log messages in memory |
| casa::MemoryStMan | Memory-based table storage manager class |
| casa::MemoryTable | Class for a table held in memory |
| casa::MEpoch | A Measure: instant in time |
| casa::MFrequency | A Measure: wave characteristics |
| casa::Min< L, R, RES > | Functor to get minimum of two values |
| casa::Minus< L, R, RES > | Functor to subtract variables of possible different types |
| casa::MIRIADImage | Class providing native access to MIRIAD images |
| casa::MLCG | Multiplicative linear congruential generator |
| casa::MMapfdIO | Memory-mapped IO on a file |
| casa::MMapIO | Memory-mapped IO on a file |
| casa::Mod_KB_Conv< T > | A Kaiser-Bessel function multiplied by a Gaussian |
| casa::ModcompConversion | Static functions to convert Modcomp numeric formats |
| casa::ModcompDataConversion | A DataConversion class to convert between Modcomp format |
| casa::Modulo< L, R, RES > | Functor to take modulo of (integer) variables of possible different types |
| casa::MomentCalcBase< T > | Abstract base class for moment calculator classes |
| casa::MomentClip< T > | Computes simple clipped, and masked moments |
| casa::MomentFit< T > | Compute moments from a Gaussian fitted to a profile |
| casa::MomentsBase< T > | This class is a base class for generating moments from an image or a spectral data |
| casa::MomentWindow< T > | Computes moments from a windowed profile |
| casa::MPosition | A Measure: position on Earth |
| casa::MRadialVelocity | A Measure: radial velocity |
| casa::MRBase | Base for Reference frame for physical measures |
| casa::MRBase_global_functions_Output | Global functions |
| casa::MS1ToMS2Converter | Class to convert a MeasurementSet v1 to v2 |
| casa::MSAntenna | A Table intended to hold a MeasurementSet ANTENNA table |
| casa::MSAntennaColumns | A class to provide easy read-write access to MSAntenna columns |
| casa::MSAntennaEnums | Enums for the MeasurementSet ANTENNA table |
| casa::MSAntennaGram_global_functions_MSAntennaGramFunctions | Global functions for flex/bison scanner/parser for MSAntennaGram |
| casa::MSAntennaIndex | Class to handle lookup or indexing into a MS ANTENNA subtable |
| casa::MSAntennaParse | Class to hold values from antenna grammar parser |
| casa::MSArrayGram_global_functions_MSArrayGramFunctions | Global functions for flex/bison scanner/parser for MSArrayGram |
| casa::MSArrayParse | Class to hold values from scan grammar parser |
| casa::MSCalEngine | Engine to calculate derived MS values |
| casa::MSColumns | A class to provide easy read-write access to MeasurementSet columns |
| casa::MSConcat | A class with functions for concatenating MeasurementSets |
| casa::MSCorrGram_global_functions_MSCorrGramFunctions | Global functions for flex/bison scanner/parser for MSCorrGram |
| casa::MSCorrParse | Class to hold values from UV dist grammar parser |
| casa::MSDataDescColumns | A class to provide easy read-write access to MSDataDescription columns |
| casa::MSDataDescIndex | Class to handle lookup or indexing into a MS DATA_DESC subtable |
| casa::MSDataDescription | A Table intended to hold a MeasurementSet DATADESCRIPTION table |
| casa::MSDataDescriptionEnums | Enums for the MeasurementSet DATA_DESCRIPTION table |
| casa::MSDerivedValues | MSDerivedValues calculates values derived from a MS |
| casa::MSDoppler | A Table intended to hold a MeasurementSet DOPPLER table |
| casa::MSDopplerColumns | A class to provide easy read-write access to MSDoppler columns |
| casa::MSDopplerEnums | Enums for the MeasurementSet DOPPLER table |
| casa::MSDopplerIndex | |
| casa::MSDopplerUtil | A utility class for MS Doppler tracking information |
| casa::MSFeed | A Table intended to hold a MeasurementSet FEED table |
| casa::MSFeedColumns | A class to provide easy read-write access to MSFeed columns |
| casa::MSFeedEnums | Enums for the MeasurementSet FEED table |
| casa::MSFeedIndex | |
| casa::MSField | A Table intended to hold a MeasurementSet FIELD table |
| casa::MSFieldColumns | A class to provide easy read-write access to MSField columns |
| casa::MSFieldEnums | Enums for the MeasurementSet FIELD table |
| casa::MSFieldGram_global_functions_MSFieldGramFunctions | Global functions for flex/bison scanner/parser for MSFieldGram |
| casa::MSFieldIndex | Class to handle lookup or indexing into a MS FIELD subtable |
| casa::MSFieldParse | Class to hold values from field grammar parser |
| casa::MSFitsIDI | MSFitsIDI: Convert FITS-IDI data to MS format |
| casa::MSFitsInput | UV FITS to MeasurementSet filler |
| casa::MSFitsOutput | Write a MeasurementSet to a random group uvfits file |
| casa::MSFitsOutputAstron | Write a MeasurementSet to a random group uvfits file |
| casa::MSFlagCmd | A Table intended to hold a MeasurementSet FLAG_CMD table |
| casa::MSFlagCmdColumns | A class to provide easy read-write access to MSFlagCmd columns |
| casa::MSFlagCmdEnums | Enums for the MeasurementSet FLAG_CMD table |
| casa::MSFlagger | MSFlagger specifies selections on a MeasurementSet |
| casa::MSFreqOffIndex | |
| casa::MSFreqOffset | A Table intended to hold a MeasurementSet FREQ_OFFSET table |
| casa::MSFreqOffsetColumns | A class to provide easy read-write access to MSFreqOffset columns |
| casa::MSFreqOffsetEnums | Enums for the MeasurementSet FREQ_OFFSET table |
| casa::MSHistory | A Table intended to hold a MeasurementSet OBSERVATIONLOG table |
| casa::MSHistoryColumns | A class to provide easy read-write access to MSHistory columns |
| casa::MSHistoryEnums | Enums for the MeasurementSet HISTORY table |
| casa::MSHistoryHandler | A class to provide a simple interface to history writing |
| casa::MSInterval | Small helper class to specify an 'interval' comparison |
| casa::MSIter | An iterator class for MeasurementSets |
| casa::MSLister | List visibility records from a Measurement Set |
| casa::MSMainColumns | A class for easy read-write access to MeasurementSet main table columns |
| casa::MSMainEnums | Enums for the MeasurementSet main table |
| casa::MSMBase | Base class for memory-based table storage manager class |
| casa::MSMColumn | Column in the Memory table storage manager class |
| casa::MSMDirColumn | Memory storage manager for table arrays |
| casa::MSMIndColumn | Mmeory storage manager for variable shaped table arrays |
| casa::MSMIndColumn::Data | |
| casa::MSObservation | A Table intended to hold a MeasurementSet OBSERVATION table |
| casa::MSObservationColumns | A class to provide easy read-write access to MSObservation columns |
| casa::MSObservationEnums | Enums for the MeasurementSet OBSERVATION table |
| casa::MSObservationIndex | Class to handle lookup or indexing into an MS OBSERVATION subtable |
| casa::MSParse | Class to hold values from an ms grammar parser |
| casa::MSPointing | A Table intended to hold a MeasurementSet POINTING table |
| casa::MSPointingColumns | A class to provide easy read-write access to MSPointing columns |
| casa::MSPointingEnums | Enums for the MeasurementSet POINTING table |
| casa::MSPointingIndex | |
| casa::MSPolarization | A Table intended to hold a MeasurementSet POLARIZATION table |
| casa::MSPolarizationColumns | A class to provide easy read-write access to MSPolarization columns |
| casa::MSPolarizationEnums | Enums for the MeasurementSet POLARIZATION table |
| casa::MSPolarizationIndex | Class to handle lookup or indexing into an MS POLARIZATION subtable |
| casa::MSPolnGram_global_functions_MSPolnGramFunctions | Global functions to drive the MSPolnParse class. These, for Polarization selection, need not be global functions, but are done this way to keep the interface uniform for the various selection expressions |
| casa::MSPolnParse | Class to hold values from field grammar parser |
| casa::MSPrimaryGroupHolder | A helper class for MSFitsInput |
| casa::MSProcessor | A Table intended to hold a MeasurementSet PROCESSOR table |
| casa::MSProcessorColumns | A class to provide easy read-write access to MSProcessor columns |
| casa::MSProcessorEnums | Enums for the MeasurementSet PROCESSER table |
| casa::MSRange | MSRange determines ranges of values in a MeasurementSet |
| casa::MSReader | Read from an MS, coordinating all of the subtables in the process |
| casa::MSScanGram_global_functions_MSScanGramFunctions | Global functions for flex/bison scanner/parser for MSScanGram |
| casa::MSScanParse | Class to hold values from scan grammar parser |
| casa::MSSelection | MSSelection: Class to represent a selection on an MS |
| casa::MSSelectionAntennaError | ------------------------------------------------------------------- |
| casa::MSSelectionAntennaParseError | ------------------------------------------------------------------- |
| casa::MSSelectionArrayError | ------------------------------------------------------------------- |
| casa::MSSelectionArrayParseError | |
| casa::MSSelectionArrayWarning | |
| casa::MSSelectionError | |
| casa::MSSelectionFieldError | ------------------------------------------------------------------- |
| casa::MSSelectionFieldParseError | ------------------------------------------------------------------- |
| casa::MSSelectionKeywords | MSSelectionKeywords specifies selection keywords for the MeasurementSet |
| casa::MSSelectionPolnError | ------------------------------------------------------------------- |
| casa::MSSelectionPolnParseError | |
| casa::MSSelectionPolnWarning | |
| casa::MSSelectionScanError | ------------------------------------------------------------------- |
| casa::MSSelectionScanParseError | |
| casa::MSSelectionScanWarning | |
| casa::MSSelectionSpwError | ------------------------------------------------------------------- |
| casa::MSSelectionSpwParseError | |
| casa::MSSelectionSpwWarning | |
| casa::MSSelectionStateError | ------------------------------------------------------------------- |
| casa::MSSelectionStateParseError | |
| casa::MSSelectionStateWarning | |
| casa::MSSelectionTimeError | ------------------------------------------------------------------- |
| casa::MSSelectionTimeParseError | |
| casa::MSSelectionUvDistError | ------------------------------------------------------------------- |
| casa::MSSelectionUvDistParseError | |
| casa::MSSelector | MSSelector specifies selections on a MeasurementSet |
| casa::MSSelUtil< T > | Helper class for MSFlagger with templated static function |
| casa::MSSelUtil2< T > | |
| casa::MSSimulator | Create an empty MeasurementSet from observation and telescope descriptions |
| casa::MSSource | A Table intended to hold a MeasurementSet SOURCE table |
| casa::MSSourceColumns | A class to provide easy read-write access to MSSource columns |
| casa::MSSourceEnums | Enums for the MeasurementSet SOURCE table |
| casa::MSSourceIndex | |
| casa::MSSpectralWindow | A Table intended to hold a MeasurementSet SPECTRAL_WINDOW table |
| casa::MSSpectralWindowEnums | Enums for the MeasurementSet SPECTRAL_WINDOW table |
| casa::MSSpwGram_global_functions_MSSpwGramFunctions | Global functions for flex/bison scanner/parser for MSSpwGram |
| casa::MSSpwIndex | Class to handle lookup or indexing into a MS Data_Desc_ID and SpectralWindow subtables |
| casa::MSSpWindowColumns | A class to provide easy read-write access to MSSpectralWindow columns |
| casa::MSSpWindowIndex | Class to handle lookup or indexing into a MS SPECTRAL_WINDOW subtable |
| casa::MSSpwParse | Class to hold values from field grammar parser |
| casa::MSState | A Table intended to hold a MeasurementSet STATE table |
| casa::MSStateColumns | A class to provide easy read-write access to MSState columns |
| casa::MSStateEnums | Enums for the MeasurementSet STATE table |
| casa::MSStateGram_global_functions_MSStateGramFunctions | Global functions for flex/bison scanner/parser for MSStateGram |
| casa::MSStateIndex | Class to handle lookup or indexing into a MS FIELD subtable |
| casa::MSStateParse | Class to hold values from field grammar parser |
| casa::MSSummary | Provides and lists information about the header of an image |
| casa::MSSysCal | A Table intended to hold a MeasurementSet SYSCAL table |
| casa::MSSysCalColumns | A class to provide easy read-write access to MSSysCal columns |
| casa::MSSysCalEnums | Enums for the MeasurementSet SYSCAL table |
| casa::MSSysCalIndex | |
| casa::MSTable< ColEnum, KeyEnum > | A Table intended to hold astronomical data |
| casa::MSTableImpl | An implementation class for the MeasurementSet to share code |
| casa::MSTableIndex | |
| casa::MSTileLayout | An helper class for deciding on tile shapes in MeasurementSets |
| casa::MSTimeGram_global_functions_MSTimeGramFunctions | Global functions for flex/bison scanner/parser for MSTimeGram |
| casa::MSTimeParse | Class to hold values from time grammar parser |
| casa::MSUvDistGram_global_functions_MSUvDistGramFunctions | Global functions for flex/bison scanner/parser for MSUvDistGram |
| casa::MSUvDistParse | Class to hold values from UV dist grammar parser |
| casa::MSValidIds | |
| casa::MSWeather | A Table intended to hold a MeasurementSet WEATHER table |
| casa::MSWeatherColumns | A class to provide easy read-write access to MSWeather columns |
| casa::MSWeatherEnums | Enums for the MeasurementSet WEATHER table |
| casa::MSWeatherIndex | |
| casa::Multiplies< L, R, RES > | Functor to multiply variables of possible different types |
| casa::MultiRecordFieldWriter | Multi field writer |
| casa::MultiTermLatticeCleaner< T > | |
| casa::MUString | Pointed String class to aid analysis of quantity strings |
| casa::MUString_global_functions_output | Global functions |
| casa::Mutex | Wrapper around a pthreads mutex |
| casa::MutexedInit | Thread-safe initialization of global variables |
| casa::Muvw | A Measure: uvw on Earth |
| casa::MVAngle | Class to handle angle type conversions and I/O |
| casa::MVAngle::Format | Format structure |
| casa::MVAngle_global_functions_output | Global functions |
| casa::MVBaseline | A 3D vector on Earth |
| casa::MVDirection | Vector of three direction cosines |
| casa::MVDoppler | Internal value for MDoppler |
| casa::MVDouble | Class to distinguish external and Measure internal Double |
| casa::MVEarthMagnetic | A 3D Earth magnetic field vector |
| casa::MVEpoch | A class for high precision time |
| casa::MVFrequency | Internal value for MFrequency |
| casa::MVPosition | A 3D vector in space |
| casa::MVRadialVelocity | Internal value for MRadialVelocity |
| casa::MVTime | Class to handle date/time type conversions and I/O |
| casa::MVTime::Format | Format structure |
| casa::MVuvw | A 3D vector on Earth |
| casa::Near< L, R > | Functor to test if two values are relatively near each other |
| casa::NearAbs< L, R > | Functor to test for if two values are absolutely near each other |
| casa::NegativeExpntl | Negative exponential distribution |
| casa::NewFile | Do checks for a new (non-existent) file |
| casa::NewMSSimulator | Create an empty MeasurementSet from observation and telescope descriptions |
| casa::NFalseFunc< T > | |
| casa::NNGridder< Domain, Range > | A non-negative gridding class |
| casa::NNLSMatrixSolver | NNLSMatrixSolver.h: the base class for NNLS solvers of linear equations AX=B |
| casa::NoConvert< TYPE > | FITS templated helper class |
| casa::NonLinearFit< T > | Class for non-linear least-squares fit |
| casa::NonLinearFitLM< T > | Solve non-linear fit with Levenberg-Marquardt method |
| casa::Normal | Normal or Gaussian distribution |
| casa::Notice | Abstract base class for notices |
| casa::NoticeSource | Base class for notice originators |
| casa::NoticeTarget | Abstract base class for notice receptors |
| casa::NTrueFunc< T > | |
| casa::NullLogSink | Throw away all messages |
| casa::NullTable | Class indicating a null Table object |
| casa::NumericTraits< T > | Relationships between numeric data types |
| casa::NumericTraits< Complex > | A specialisation for T=Complex of the NumericTraits class |
| casa::NumericTraits< DComplex > | A specialisation for T=DComplex of the NumericTraits class |
| casa::NumericTraits< Double > | A specialisation for T=Double of the NumericTraits class |
| casa::NumericTraits< Float > | A specialisation for T=Float of the NumericTraits class |
| casa::NumericTraits_C< Complex > | NumericTraits specialization for Complex |
| casa::NumericTraits_D< Double > | NumericTraits specialization for Double |
| casa::NumericTraits_DC< DComplex > | NumericTraits specialization for DComplex |
| casa::NumericTraits_F< Float > | NumericTraits specialization for Float |
| casa::Nutation | Nutation class and calculations |
| casa::ObjCompare< T > | Compare two objects |
| casa::ObjectID | ObjectID: A unique identifier for distributed and other objects |
| casa::ObjectPool< T, Key > | A parameterized stack of re-usable objects |
| casa::ObjectStack< T > | A stack of re-usable objects |
| casa::ObsInfo | Store miscellaneous information related to an observation |
| casa::OddPolynomial< T > | A one dimensional odd polynomial class |
| casa::OddPolynomial_PS< AutoDiff< T > > | Partial specialization of OddPolynomial for AutoDiff |
| casa::OddPolynomialParam< T > | Parameter handling for odd polynomials |
| casa::OrderedMap< key, value > | Map with keys ordered |
| casa::OrderedMapIterRep< key, value > | OrderedMap iterator "letter" |
| casa::OrderedMapNotice< t, v > | Message used for OrderedMap notification |
| casa::OrderedMapRep< key, value > | Representation class for an Ordered Map |
| casa::OrderedPair< K, V > | Ordered pair class |
| OrdMapIO_global_functions_OrderedMap_IO | Input/output operators for OrderedMaps |
| casa::OrdPairIO_global_functions_inoutput | These need to be left out **SUN BUG** |
| casa::PagedArray< T > | A Lattice that is read from or written to disk |
| casa::PagedArrIter< T > | A read/write Lattice iterator for PagedArrays |
| casa::PagedImage< T > | Read, store, and manipulate astronomical images |
| casa::Param | A simple keyword/value pair with internal help Strings |
| casa::ParAngleColumn | Parallactic angle derived from TIME, etc |
| casa::ParAngleMachine | Converts a direction into parallactic angle |
| casa::Path | Path name of a file |
| casa::PCFSpectralElement | Abstract base class that describes a spectral profile that can be parameterized by a peak value (amplitude), center, and FWHM |
| casa::PGPlotter | Standard plotting object for application programmers |
| casa::PGPlotterInterface | Abstract base class for PGPLOT style plotting |
| casa::PGPlotterNull | Plot to a PGPLOT device "local" to this process |
| casa::PixelCurve1D | Arbitrary 1-dim curve in a lattice plane |
| casa::PlainColumn | Base class for a column in a plain table |
| casa::PlainTable | Class defining a plain regular table |
| casa::Plus< L, R, RES > | Functor to add variables of possible different types |
| casa::PointShape | A shape where emission comes from only one direction |
| casa::Poisson | Poisson distribution |
| casa::Polynomial< T > | A one dimensional polynomial class |
| casa::Polynomial_PS< AutoDiff< T > > | Partial specialization of Polynomial for AutoDiff |
| casa::PolynomialParam< T > | Parameter handling for one-dimensional polynomials |
| casa::PolynomialSpectralElement | Describes a polynomial spectral profile |
| casa::PolynomialSpectralElement_global_functions_Output | Global functions |
| casa::PoolStack< T, Key > | A parameterized stack of re-usable objects |
| casa::PositionEngine | Engine for TaQL UDF Position conversions |
| casa::PositionUDF | TaQL UDFs for Position conversions |
| casa::Pow< T, E, RES > | Functor to apply pow |
| casa::Pow3< T, RES > | Functor to apply a power of 3 |
| casa::Precession | Precession class and calculations |
| casa::PrecTimer | Precision timer to measure elapsed times in a cumulative way |
| casa::PrecTimer::TimeStruct | |
| casa::PrecTimer::Union1 | |
| casa::PrecTimer::Union2 | |
| casa::PrimaryArray< TYPE > | Templated primary array base class of given type |
| casa::PrimaryGroup< TYPE > | Random Group datastructure |
| casa::Primes | Creates a reference table of prime numbers, and some functions |
| casa::ProfileFit1D< T > | Fit spectral components to a Vector of data |
| casa::ProgressMeter | Visual indication of a tasks progress |
| casa::Projection | Geometric parameters needed for a sky projection to a plane |
| casa::PtrBlock< T > | A drop-in replacement for Block<T*> |
| casa::PtrHolder< T > | Hold and delete pointers not deleted by object destructors |
| casa::PtrRep< t > | Internal representation for CountedPtr |
| casa::PutCellSlices< T > | Functor to put irregular array slices into a cell |
| casa::PutColumnSlices< T > | Functor to get irregular array slices from a column |
| casa::QBase | Base for Quantities (i.e. dimensioned values) |
| casa::QBase_global_functions_Output | Global functions |
| casa::QC | Physical constants (i.e. dimensioned values) |
| casa::QC_global_functions_QC_initialization_object | Object used to force construction of QC |
| casa::QC_init | Class used to force construction of QC |
| casa::QLogical_global_functions_Quantum_logical_operations | Logical operations for the Quantum class |
| casa::QMath_global_functions_Quantum_mathematical_operations | Mathematical operations for the Quantum class |
| casa::Quantum< Qtype > | Quantities (i.e. dimensioned values) |
| casa::Quantum_global_functions_output | Global functions |
| casa::QuantumHolder | A holder for Quantums to enable record conversions |
| casa::QuantumType_global_functions_QuantumType | Get an integer type for a Qunatum<T> |
| casa::Queue< T > | A First-In-First-Out (FIFO) data structure |
| casa::Random | Base class for random number distributions |
| casa::RawDataConversion | A class with virtual functions to copy without conversion |
| casa::RawIO | Class for IO in local format |
| casa::re_pattern_buffer | This data structure is used to represent a compiled pattern |
| casa::re_registers | Data structure to store register contents data in |
| casa::ReadAsciiTable | Helper class for readAsciiTable |
| casa::ReadAsciiTable_global_functions_readAsciiTable | Filling a table from an Ascii file |
| casa::ReadOnlyArrayIterator< T > | Iterate a const Array cursor through a const Array |
| casa::ReadOnlyMatrixIterator< T > | Iterate a Matrix cursor through a R/O Array |
| casa::ReadOnlyVectorIterator< T > | Iterate a Vector cursor through another Array |
| casa::Real< T, RES > | Functor to apply complex function real |
| casa::RebinImage< T > | Rebin an image |
| casa::RebinLattice< T > | Rebin a masked lattice |
| casa::Record | A hierarchical collection of named fields of various types |
| casa::RecordDesc | Description of the fields in a record object |
| casa::RecordDescRep | Representation of a RecordDesc |
| casa::RecordExpr_global_functions_RecordExpr | Global functions to make a expression node for a record field |
| casa::RecordFieldCopier< outType, inType > | Record field copier |
| casa::RecordFieldId | The identification of a record field |
| casa::RecordFieldPtr< T > | Access to an individual field in a record |
| casa::RecordFieldWriter | Record field writer. Base class for the copiers |
| casa::RecordGram | Select-class for flex/bison scanner/parser for RecordGram |
| casa::RecordGram_global_functions_RecordGramFunctions | Global functions for flex/bison scanner/parser for RecordGram |
| casa::RecordGramVal | Helper class for values in RecordGram |
| casa::RecordInterface | Abstract base class for Record classes |
| casa::RecordNotice | Helper class to notify class Record about changes |
| casa::RecordRep | The representation of a Record |
| casa::RecordTransformable | Interface class for converting to/from records |
| casa::RefColumn | A column in a reference table |
| casa::RefRows | Class holding the row numbers in a RefTable |
| casa::RefRowsSliceIter | Class to iterate through a RefRows object |
| casa::RefTable | Class for a table as a view of another table |
| casa::Regex | Regular expression class |
| casa::RegexBase | Abstract interface class to regular expressions for String |
| casa::RegionHandler | Base class for handling regions in images |
| casa::RegionHandlerHDF5 | Class for keeping regions in an HDF5 file |
| casa::RegionHandlerMemory | Class for keeping regions in memory |
| casa::RegionHandlerTable | Class for keeping regions in memory |
| casa::RegionManager | |
| casa::RegionType | Define the various region types |
| casa::Register_global_functions_register | Primitive Run Time Type Information (RTTI) |
| casa::RegSequence | Sequence for the Register() template functions |
| casa::RegularFile | Manipulate and get information about regular files |
| casa::RegularFileIO | Class for IO on a regular file |
| casa::ReservedFitsKeyword | Reserved FITS keyword |
| casa::ReservedFitsKeywordCollection | Collection of reserved FITS keywords |
| casa::RetypedArrayEngine< VirtualType, StoredType > | Virtual column engine to retype and reshape arrays |
| casa::RetypedArraySetGet_global_functions_RetypedArrayEngineSetGet | Helper functions for users of RetypedArrayEngine |
| casa::RFError | Convenience class for a String/bool pair |
| casa::RFReader | Abstract superclass for any class that reads a format that produces Regions from a file |
| casa::RFReaderWriter | Superclass for readers and writers containing common definitions and operations |
| casa::RFWriter | Abstract superclass for any class that writes Regions to a region file format |
| casa::RigidVector< T, n > | Fast Vector classes with fixed (templated) length |
| casa::RigidVector_global_functions_math | Mathematical operations involving RigidVectors |
| casa::RNG | Base class for random number generators |
| casa::RO_LatticeIterator< T > | A readonly iterator for Lattices |
| casa::RO_MaskedLatticeIterator< T > | A readonly iterator for masked Lattices |
| casa::ROArrayColumn< T > | Readonly access to an array table column with arbitrary data type |
| casa::ROArrayMeasColumn< M > | Read only access to table array Measure columns |
| casa::ROArrayQuantColumn< T > | Provides read-only access to Array Quantum columns in Tables |
| casa::RODataManAccessor | Base class for the Data Manager Accessor classes |
| casa::ROIncrementalStManAccessor | Give access to some IncrementalStMan functions |
| casa::ROMSAntennaColumns | A class to provide easy read-only access to MSAntenna columns |
| casa::ROMSColumns | A class to provide easy read-only access to MeasurementSet columns |
| casa::ROMSDataDescColumns | A class to provide easy read-only access to MSDataDesc columns |
| casa::ROMSDopplerColumns | A class to provide easy read-only access to MSDoppler columns |
| casa::ROMSFeedColumns | A class to provide easy read-only access to MSFeed columns |
| casa::ROMSFieldColumns | A class to provide easy access to MSField columns |
| casa::ROMSFlagCmdColumns | A class to provide easy read-only access to MSFlagCmd columns |
| casa::ROMSFreqOffsetColumns | A class to provide easy read-only access to MSFreqOffset columns |
| casa::ROMSHistoryColumns | A class to provide easy read-only access to MSHistory columns |
| casa::ROMSMainColumns | A class for easy read-only access to MeasurementSet main table columns |
| casa::ROMSObservationColumns | A class to provide easy read-only access to MSObservation columns |
| casa::ROMSPointingColumns | A class to provide easy read-only access to MSPointing columns |
| casa::ROMSPolarizationColumns | A class to provide easy read-only access to MSPolarization columns |
| casa::ROMSProcessorColumns | A class to provide easy read-only access to MSProcessor columns |
| casa::ROMSSourceColumns | A class to provide easy read-only access to MSSource columns |
| casa::ROMSSpWindowColumns | A class to provide easy read-only access to MSASpectralWindow columns |
| casa::ROMSStateColumns | A class to provide easy read-only access to MSState columns |
| casa::ROMSSysCalColumns | A class to provide easy read-only access to MSSysCal columns |
| casa::ROMSWeatherColumns | A class to provide easy read-only access to MSWeather columns |
| casa::RORecordFieldPtr< T > | Read-Only access to an individual field from a Record |
| casa::ROScalarColumn< T > | Readonly access to a scalar table column with arbitrary data type |
| casa::ROScalarMeasColumn< M > | Read only access to table scalar Measure columns |
| casa::ROScalarQuantColumn< T > | Provides read-only access to Scalar Quantum Columns in Tables |
| casa::ROStandardStManAccessor | Give access to some StandardStMan functions |
| casa::ROTableColumn | Readonly access to a table column |
| casa::ROTableMeasColumn | Read only access to table scalar Measure columns |
| casa::ROTableRow | Readonly access to a table row |
| casa::ROTableVector< T > | Templated readonly table column vectors |
| casa::ROTiledStManAccessor | Give access to some TiledStMan functions |
| casa::RotMatrix | A 3x3 rotation matrix |
| casa::Round< T, RES > | Functor to apply round (e.g |
| casa::RowCopier | RowCopier copies all or part of a row from one table to another |
| casa::SampledFunctional< Range > | A base class for indexing into arbitrary data types |
| casa::ScalarColumn< T > | Read/write access to a scalar table column with arbitrary data type |
| casa::ScalarColumnData< T > | Access to a table column containing scalars |
| casa::ScalarColumnDesc< T > | Templated class to define columns of scalars in tables |
| casa::ScalarFITSFieldCopier< recordType, fitsType > | A FITSFieldCopier for copying scalar non-string RecordFields to FitsFields |
| casa::ScalarMeasColumn< M > | Read write access to table scalar Measure columns |
| casa::ScalarQuantColumn< T > | Provides read/write access to Scalar Quantum Columns in Tables |
| casa::ScalarRecordColumnData | Access to a table column containing scalar records |
| casa::ScalarRecordColumnDesc | Class to define columns of scalar records in tables |
| casa::ScalarSampledFunctional< T > | A unified interface for indexing into Vectors or Blocks |
| casa::ScaledArrayEngine< VirtualType, StoredType > | Templated virtual column engine to scale a table array |
| casa::ScaledComplexData< VirtualType, StoredType > | Templated virtual column engine to scale a complex table array |
| casa::ScopedMutexLock | Exception-safe lock/unlock of a mutex |
| casa::SCSL | C++ Interface to the Sgi/Cray Scientific Library (SCSL) |
| casa::SDAntennaHandler | |
| casa::SDDataDescHandler | |
| casa::SDFeedHandler | |
| casa::SDFieldHandler | |
| casa::SDFITSHandler | |
| casa::SDFITSTable | SDFITSTable is a FITSTable which follows the Single Dish FITS Convention |
| casa::SDHistoryHandler | |
| casa::SDMainHandler | |
| casa::SDObservationHandler | |
| casa::SDPointingHandler | |
| casa::SDPolarizationHandler | |
| casa::SDSourceHandler | |
| casa::SDSpWindowHandler | |
| casa::SDSysCalHandler | |
| casa::SDWeatherHandler | |
| casa::SepImageConvolver< T > | This class does separable convolution of an image |
| casa::Sequence< t > | Virtual templated base class for sequences |
| casa::SerialHelper | |
| casa::SetupNewTable | Create a new table - define shapes, data managers, etc |
| casa::SetupNewTableRep | Representation for handle class SetupNewTable |
| casa::Sign< T, RES > | Functor to apply sign (result is -1, 0, or 1) |
| casa::SimButterworthBandpass< T > | Class for evaluating a Butterworth filter transfer function |
| casa::SimOrdMapIO_global_functions_inoutput | Global IO functions |
| casa::SimpleCountedConstPtr< t > | Simple referenced counted pointer for constant data |
| casa::SimpleCountedPtr< t > | Simple referenced counted pointer to non-constant data |
| casa::SimpleOrderedMap< K, V > | Simple map with keys ordered |
| casa::Sin< T, RES > | Functor to apply sin |
| casa::Sinc_Conv< T > | Sine x / x function |
| casa::SincFunction< T > | A one dimensional sin(x)/x |
| casa::SincParam< T > | A one dimensional sin(x)/x |
| casa::Sinh< T, RES > | Functor to apply sinh |
| casa::Sinusoid1D< T > | A one dimensional Sinusoid class |
| casa::Sinusoid1D_PS< AutoDiff< T > > | Partial specialization of Sinusoid1D for AutoDiff |
| casa::Sinusoid1DParam< T > | Parameter handling for one dimensional Sinusoid class |
| casa::SkyCompBase | Base class for model components of the sky brightness |
| casa::SkyComponent | A component of a model of the sky |
| casa::SkyCompRep | A model component of the sky brightness |
| casa::Slice | Define a (start,length,increment) along an axis |
| casa::Slicer | Specify which elements to extract from an n-dimensional array |
| casa::Slicer_global_functions_Slicer_IO | IO functions for Slicer's |
| casa::Smooth< T > | Smooth a Vector or the rows of a 2D Array taking into account flags which are supplied in a Vector/Array of the same shape. Modify the flags as necessary to mark channels for which the smoothing could not be done because needed channels were flagged |
| casa::SofaTest | Wrapping of IAU SOFA Fortran routines and test class |
| casa::SofaTest_global_functions_IAU_SOFA | Global Fortran function wraps |
| casa::SolarPos | Solar position class and calculations |
| casa::Sort | Sort on one or more keys, ascending and/or descending |
| casa::SortError | Generic Sort exception |
| casa::SortInvDT | Invalid data type used for this sort key |
| casa::SortInvIncr | Invalid increment used for this sort key |
| casa::SortInvOpt | Invalid sort option given to routine dosort |
| casa::SortKey | Define a Sort key |
| casa::SortNoData | No data array given to Sort constructor |
| casa::SparseDiff< T > | Class that computes partial derivatives by automatic differentiation |
| casa::SparseDiffA< T > | Class that computes partial derivatives by automatic differentiation |
| casa::SparseDiffIO_global_functions_SparseDiff_IO_operations | Implements all IO operators and functions for SparseDiff |
| casa::SparseDiffMath_global_functions_SparseDiff_mathematical_operations | Implements all mathematical operators and functions for SparseDiff |
| casa::SparseDiffRep< T > | Representation of data for the spare automatic differentiation calss |
| casa::SparseDiffX< T > | Class that computes partial derivatives by automatic differentiation |
| casa::SpecificFunctionFactory< T, F > | |
| casa::SpectralCoordinate | Interconvert pixel and frequency values |
| casa::SpectralElement | Describes (a set of related) spectral lines |
| casa::SpectralElementFactory | FIXME fix documentation |
| casa::SpectralEstimate | Get an initial estimate for spectral lines |
| casa::SpectralFit | Least Squares fitting of spectral elements to spectrum |
| casa::SpectralIndex | Models the spectral variation with a spectral index |
| casa::SpectralList | A set of SpectralElements |
| casa::SpectralList_global_functions_Output | Global functions |
| casa::SpectralModel | Base class for spectral models |
| casa::Sph_Conv< T > | Spheroidal function |
| casa::SPolynomial< T > | A one dimensional scaled polynomial class |
| casa::SPolynomialParam< T > | Parameter handling for scaled 1-D polynomials |
| casa::SPtrHolder< T > | Hold and delete pointers not deleted by object destructors |
| casa::Sqr< T, RES > | Functor to apply sqr (power of 2) |
| casa::Sqrt< T, RES > | Functor to apply sqrt |
| casa::SquareMatrix< T, n > | Fast Square Matrix class with fixed (templated) size |
| casa::SquareMatrix_global_functions_SqM_global_functions | Various global math and IO functions |
| casa::SSMBase | Base class of the Standard Storage Manager |
| casa::SSMColumn | A Column in the Standard Storage Manager |
| casa::SSMDirColumn | A Direct Array Column in the Standard Storage Manager |
| casa::SSMIndColumn | A column of Standard storage manager for indirect arrays |
| casa::SSMIndex | The bucket index for a group of columns in the Standard Storage Manager |
| casa::SSMIndStringColumn | An Indirect String Array Column in the Standard Storage Manager |
| casa::SSMStringHandler | Store strings in the Standard Storage Manager |
| casa::Stack< elem > | This class, Stack<t>, defines an implementation of a stack using the doubly linked list primitive, Link<t> |
| casa::StandardStMan | The Standard Storage Manager |
| casa::StatAcc< T > | A statistics accumulator |
| casa::StatsTiledCollapser< T, U > | Generate statistics, tile by tile, from a masked lattice |
| casa::StIndArray | Read/write indirect arrays |
| casa::StManAipsIO | AipsIO table storage manager class |
| casa::StManArrayFile | Read/write array in external format for a storage manager |
| casa::StManColumn | Base table column storage manager class |
| casa::StManColumnAipsIO | AipsIO table column storage manager class |
| casa::StManColumnArrayAipsIO | AipsIO storage manager for direct table arrays |
| casa::StManColumnIndArrayAipsIO | AipsIO storage manager for indirect table arrays |
| casa::Stokes | Stokes parameter definitions for interface to table data |
| casa::StokesConverter | StokesConverter converts any set of polarizations into any other one |
| casa::StokesCoordinate | Interconvert between pixel and Stokes value |
| casa::StreamIO | Class for IO on connection oriented socket |
| casa::StreamLogSink | Send log messages to an ostream |
| casa::String | String: the storage and methods of handling collections of characters |
| casa::String_global_functions_case | Casing and related functions Case conversion and rearrangement functions |
| casa::String_global_functions_common | Some general functions Functions to find special patterns, join and replicate |
| casa::String_global_functions_comparitor | Global comparison operators |
| casa::String_global_functions_concatenator | Global concatenation operators |
| casa::String_global_functions_io | IO |
| casa::String_global_functions_split | Splitting Global function which splits the String into string array res at separator and returns the number of elements |
| casa::StringDistance | Class to deal with Levensthein distance of strings |
| casa::StringFITSFieldCopier | A FITSFieldCopier for copying String RecordFields to FitsFields |
| casa::SubImage< T > | A (masked) subset of an ImageInterface object |
| casa::SubLattice< T > | A subset of a Lattice or MaskedLattice |
| casa::SubString | SubString help class to be used in at, before, ..\ |
| casa::SubTableDesc | Description of columns containing tables |
| casa::SumAbsDiff< T, Accum > | Functor to add absolute diff of right and base value to left |
| casa::SumSqr< T, Accum > | Functor to add square of right to left |
| casa::SumSqrDiff< T, Accum > | Functor to add squared diff of right and base value to left |
| casa::SymLink | Get information about, and manipulate symbolic links |
| casa::SystemCallError | Exception for an error in a system call |
| casa::Table | Main interface class to a read/write table |
| casa::TableArrayConformanceError | Table error; non-conformant array |
| casa::TableAttr | Some attributes of a table |
| casa::TableCache | Cache of open tables |
| casa::TableColumn | Non-const access to a table column |
| casa::TableConformanceError | Table error; table length conformance error |
| casa::TableCopy | Class with static functions for copying a table |
| casa::TableDesc | Define the structure of an AIPS++ table |
| casa::TableDescNoName | Table error; no name given to table description |
| casa::TableDuplFile | Table error; table (description) already exists |
| casa::TableError | Base error class for storage manager |
| casa::TableExprConeNode | Class representing a cone search in table select expression |
| casa::TableExprData | Abstract base class for data object in a TaQL expression |
| casa::TableExprFuncNode | Class representing a function in table select expression |
| casa::TableExprFuncNodeArray | Class representing an array function in table select expression |
| casa::TableExprId | The identification of a TaQL selection subject |
| casa::TableExprJoin | |
| casa::TableExprJoinColumn | |
| casa::TableExprJoinKeys | |
| casa::TableExprNode | Handle class for a table column expression tree |
| casa::TableExprNodeAND | Logical and in table select expression tree |
| casa::TableExprNodeArray | Base class for arrays in table select expression |
| casa::TableExprNodeArrayAND | Logical and in table select expression tree |
| casa::TableExprNodeArrayBitAndInt | Int Array bitwise and in table select expression tree |
| casa::TableExprNodeArrayBitNegate | Bitwise negate in table select expression tree |
| casa::TableExprNodeArrayBitOrInt | Int Array bitwise or in table select expression tree |
| casa::TableExprNodeArrayBitXorInt | Int Array bitwise xor in table select expression tree |
| casa::TableExprNodeArrayColumn | Base class for Array column in table select expression |
| casa::TableExprNodeArrayColumnBool | Bool array column in table select expression |
| casa::TableExprNodeArrayColumnComplex | Complex array column in table select expression |
| casa::TableExprNodeArrayColumnDComplex | DComplex array column in table select expression |
| casa::TableExprNodeArrayColumnDouble | Double array column in table select expression |
| casa::TableExprNodeArrayColumnFloat | Float array column in table select expression |
| casa::TableExprNodeArrayColumnInt | Int array column in table select expression |
| casa::TableExprNodeArrayColumnShort | Short array column in table select expression |
| casa::TableExprNodeArrayColumnString | String array column in table select expression |
| casa::TableExprNodeArrayColumnuChar | UChar array column in table select expression |
| casa::TableExprNodeArrayColumnuInt | UInt array column in table select expression |
| casa::TableExprNodeArrayColumnuShort | UShort array column in table select expression |
| casa::TableExprNodeArrayConstBool | Bool Array constant in table select expression tree |
| casa::TableExprNodeArrayConstDate | Date Array constant in table select expression tree |
| casa::TableExprNodeArrayConstDComplex | DComplex Array constant in table select expression tree |
| casa::TableExprNodeArrayConstDouble | Double Array constant in table select expression tree |
| casa::TableExprNodeArrayConstInt | Int Array constant in table select expression tree |
| casa::TableExprNodeArrayConstString | String Array constant in table select expression tree |
| casa::TableExprNodeArrayDivide | Array addition in table select expression tree |
| casa::TableExprNodeArrayDivideDComplex | DComplex Array division in table select expression tree |
| casa::TableExprNodeArrayDivideDouble | Double Array division in table select expression tree |
| casa::TableExprNodeArrayEQBool | Bool Array comparison == in table select expression tree |
| casa::TableExprNodeArrayEQDate | Date Array comparison == in table select expression tree |
| casa::TableExprNodeArrayEQDComplex | DComplex Array comparison == in table select expression tree |
| casa::TableExprNodeArrayEQDouble | Double Array comparison == in table select expression tree |
| casa::TableExprNodeArrayEQInt | Int Array comparison == in table select expression tree |
| casa::TableExprNodeArrayEQRegex | Regex Array comparison == in table select expression tree |
| casa::TableExprNodeArrayEQString | String Array comparison == in table select expression tree |
| casa::TableExprNodeArrayGEDate | Date Array comparison >= in table select expression tree |
| casa::TableExprNodeArrayGEDComplex | DComplex Array comparison >= in table select expression tree |
| casa::TableExprNodeArrayGEDouble | Double Array comparison >= in table select expression tree |
| casa::TableExprNodeArrayGEInt | Int Array comparison >= in table select expression tree |
| casa::TableExprNodeArrayGEString | String Array comparison >= in table select expression tree |
| casa::TableExprNodeArrayGTDate | Date Array comparison > in table select expression tree |
| casa::TableExprNodeArrayGTDComplex | DComplex Array comparison > in table select expression tree |
| casa::TableExprNodeArrayGTDouble | Double Array comparison > in table select expression tree |
| casa::TableExprNodeArrayGTInt | Int Array comparison > in table select expression tree |
| casa::TableExprNodeArrayGTString | String Array comparison > in table select expression tree |
| casa::TableExprNodeArrayINDate | Date Array comparison IN in table select expression tree |
| casa::TableExprNodeArrayINDComplex | DComplex Array comparison IN in table select expression tree |
| casa::TableExprNodeArrayINDouble | Double Array comparison IN in table select expression tree |
| casa::TableExprNodeArrayINInt | Int Array comparison IN in table select expression tree |
| casa::TableExprNodeArrayINString | String Array comparison IN in table select expression tree |
| casa::TableExprNodeArrayMIN | Unary minus in table select expression tree |
| casa::TableExprNodeArrayMinus | Array addition in table select expression tree |
| casa::TableExprNodeArrayMinusDate | Date Array subtraction in table select expression tree |
| casa::TableExprNodeArrayMinusDComplex | DComplex Array subtraction in table select expression tree |
| casa::TableExprNodeArrayMinusDouble | Double Array subtraction in table select expression tree |
| casa::TableExprNodeArrayMinusInt | Int Array subtraction in table select expression tree |
| casa::TableExprNodeArrayModulo | Array addition in table select expression tree |
| casa::TableExprNodeArrayModuloDouble | Double Array modulo in table select expression tree |
| casa::TableExprNodeArrayModuloInt | Int Array modulo in table select expression tree |
| casa::TableExprNodeArrayNEBool | Bool Array comparison != in table select expression tree |
| casa::TableExprNodeArrayNEDate | Date Array comparison != in table select expression tree |
| casa::TableExprNodeArrayNEDComplex | DComplex Array comparison != in table select expression tree |
| casa::TableExprNodeArrayNEDouble | Double Array comparison != in table select expression tree |
| casa::TableExprNodeArrayNEInt | Int Array comparison != in table select expression tree |
| casa::TableExprNodeArrayNERegex | Regex Array comparison != in table select expression tree |
| casa::TableExprNodeArrayNEString | String Array comparison != in table select expression tree |
| casa::TableExprNodeArrayNOT | Logical not in table select expression tree |
| casa::TableExprNodeArrayOR | Logical or in table select expression tree |
| casa::TableExprNodeArrayPart | Array column part in table select expression |
| casa::TableExprNodeArrayPlus | Array addition in table select expression tree |
| casa::TableExprNodeArrayPlusDate | Date Array addition in table select expression tree |
| casa::TableExprNodeArrayPlusDComplex | DComplex Array addition in table select expression tree |
| casa::TableExprNodeArrayPlusDouble | Double Array addition in table select expression tree |
| casa::TableExprNodeArrayPlusInt | Int Array addition in table select expression tree |
| casa::TableExprNodeArrayPlusString | String Array addition in table select expression tree |
| casa::TableExprNodeArrayTimes | Array addition in table select expression tree |
| casa::TableExprNodeArrayTimesDComplex | DComplex Array multiplication in table select expression tree |
| casa::TableExprNodeArrayTimesDouble | Double Array multiplication in table select expression tree |
| casa::TableExprNodeArrayTimesInt | Int Array multiplication in table select expression tree |
| casa::TableExprNodeArrayUnit | Unit for array values in a table select expression tree |
| casa::TableExprNodeBinary | Abstract base class for a node having 0, 1, or 2 child nodes |
| casa::TableExprNodeBitAndInt | Bitwise and in table select expression tree |
| casa::TableExprNodeBitNegate | Bitwise negate in table select expression tree |
| casa::TableExprNodeBitOrInt | Bitwise or in table select expression tree |
| casa::TableExprNodeBitXorInt | Bitwise xor in table select expression tree |
| casa::TableExprNodeColumn | Scalar column in table select expression tree |
| casa::TableExprNodeConstBool | Constant Bool in table select expression tree |
| casa::TableExprNodeConstDate | Constant Date in table select expression tree |
| casa::TableExprNodeConstDComplex | Constant DComplex in table select expression tree |
| casa::TableExprNodeConstDouble | Constant Double in table select expression tree |
| casa::TableExprNodeConstInt | Constant Int64 in table select expression tree |
| casa::TableExprNodeConstRegex | Constant Regex or StringDistance in table select expression tree |
| casa::TableExprNodeConstString | Constant String in table select expression tree |
| casa::TableExprNodeDivide | Division in table select expression tree |
| casa::TableExprNodeDivideDComplex | DComplex division in table select expression tree |
| casa::TableExprNodeDivideDouble | Double division in table select expression tree |
| casa::TableExprNodeEQBool | Bool comparison == in table select expression tree |
| casa::TableExprNodeEQDate | Date comparison == in table select expression tree |
| casa::TableExprNodeEQDComplex | DComplex comparison == in table select expression tree |
| casa::TableExprNodeEQDouble | Double comparison == in table select expression tree |
| casa::TableExprNodeEQInt | Int comparison == in table select expression tree |
| casa::TableExprNodeEQRegex | Regex comparison == in table select expression tree |
| casa::TableExprNodeEQString | String comparison == in table select expression tree |
| casa::TableExprNodeGEDate | Date comparison >= in table select expression tree |
| casa::TableExprNodeGEDComplex | DComplex comparison >= in table select expression tree |
| casa::TableExprNodeGEDouble | Double comparison >= in table select expression tree |
| casa::TableExprNodeGEInt | Int comparison >= in table select expression tree |
| casa::TableExprNodeGEString | String comparison >= in table select expression tree |
| casa::TableExprNodeGTDate | Date comparison > in table select expression tree |
| casa::TableExprNodeGTDComplex | DComplex comparison > in table select expression tree |
| casa::TableExprNodeGTDouble | Double comparison > in table select expression tree |
| casa::TableExprNodeGTInt | Int comparison > in table select expression tree |
| casa::TableExprNodeGTString | String comparison > in table select expression tree |
| casa::TableExprNodeINDate | Date comparison IN in table select expression tree |
| casa::TableExprNodeINDComplex | DComplex comparison IN in table select expression tree |
| casa::TableExprNodeIndex | The index of an array element in a table select expression |
| casa::TableExprNodeINDouble | Double comparison IN in table select expression tree |
| casa::TableExprNodeINInt | Int comparison IN in table select expression tree |
| casa::TableExprNodeINString | String comparison IN in table select expression tree |
| casa::TableExprNodeMIN | Unary minus in table select expression tree |
| casa::TableExprNodeMinus | Subtraction in table select expression tree |
| casa::TableExprNodeMinusDate | Date subtraction in table select expression tree |
| casa::TableExprNodeMinusDComplex | DComplex subtraction in table select expression tree |
| casa::TableExprNodeMinusDouble | Double subtraction in table select expression tree |
| casa::TableExprNodeMinusInt | Int subtraction in table select expression tree |
| casa::TableExprNodeModulo | Modulo in table select expression tree |
| casa::TableExprNodeModuloDouble | Double modulo in table select expression tree |
| casa::TableExprNodeModuloInt | Int modulo in table select expression tree |
| casa::TableExprNodeMulti | Abstract base class for a node having multiple child nodes |
| casa::TableExprNodeNEBool | Bool comparison != in table select expression tree |
| casa::TableExprNodeNEDate | Date comparison != in table select expression tree |
| casa::TableExprNodeNEDComplex | DComplex comparison != in table select expression tree |
| casa::TableExprNodeNEDouble | Double comparison != in table select expression tree |
| casa::TableExprNodeNEInt | Int comparison != in table select expression tree |
| casa::TableExprNodeNERegex | Regex comparison != in table select expression tree |
| casa::TableExprNodeNEString | String comparison != in table select expression tree |
| casa::TableExprNodeNOT | Logical not in table select expression tree |
| casa::TableExprNodeOR | Logical or in table select expression tree |
| casa::TableExprNodePlus | Addition in table select expression tree |
| casa::TableExprNodePlusDate | Date addition in table select expression tree |
| casa::TableExprNodePlusDComplex | DComplex addition in table select expression tree |
| casa::TableExprNodePlusDouble | Double addition in table select expression tree |
| casa::TableExprNodePlusInt | Int addition in table select expression tree |
| casa::TableExprNodePlusString | String addition in table select expression tree |
| casa::TableExprNodeRandom | Random number in table select expression tree |
| casa::TableExprNodeRecordField | Scalar field in record select expression tree |
| casa::TableExprNodeRecordFieldArray | Array field in record select expression tree |
| casa::TableExprNodeRep | Abstract base class for a node in a table column expression tree |
| casa::TableExprNodeRowid | Rowid in table select expression tree |
| casa::TableExprNodeRownr | Rownumber in table select expression tree |
| casa::TableExprNodeSet | Class to hold multiple table expression nodes |
| casa::TableExprNodeSetElem | Class to hold the table expression nodes for an element in a set |
| casa::TableExprNodeTimes | Multiplication in table select expression tree |
| casa::TableExprNodeTimesDComplex | DComplex multiplication in table select expression tree |
| casa::TableExprNodeTimesDouble | Double multiplication in table select expression tree |
| casa::TableExprNodeTimesInt | Int multiplication in table select expression tree |
| casa::TableExprNodeUnit | Unit for scalar values in a table select expression tree |
| casa::TableExprRange | Select range of a column in an select expression |
| casa::TableExprUDFNode | Class representing a function in table select expression |
| casa::TableExprUDFNodeArray | Class representing a function in table select expression |
| casa::TableGram_global_functions_TableGramFunctions | Global functions for flex/bison scanner/parser for TableGram |
| casa::TableIndexProxy | Proxy for table index access |
| casa::TableInfo | Table type, subtype and further info |
| casa::TableInternalError | Internal table error |
| casa::TableInvColumnDesc | Table error; invalid column description |
| casa::TableInvDT | Table error; invalid data type |
| casa::TableInvExpr | Table error; invalid select expression |
| casa::TableInvHyperDesc | Table error; invalid hypercolumn description |
| casa::TableInvLogic | Table error; invalid logical operation |
| casa::TableInvOper | Table error; invalid operation |
| casa::TableInvOpt | Table error; invalid table (description) option |
| casa::TableInvSort | Table error; invalid sort |
| casa::TableInvType | Table error; table type mismatch |
| casa::TableIterator | Iterate through a Table |
| casa::TableIterProxy | Proxy for table iterator access |
| casa::TableKeyword | Keyword value representing a table |
| casa::TableLock | Class to hold table lock options |
| casa::TableLockData | Class to hold table lock data |
| casa::TableLocker | Class to hold a (user) lock on a table |
| casa::TableLogSink | Save log messages in an AIPS++ Table |
| casa::TableMeasDesc< M > | Definition of a Measure column in a Table |
| casa::TableMeasDescBase | Definition of a Measure in a Table |
| casa::TableMeasOffsetDesc | Definition of a Measure Offset in a Table |
| casa::TableMeasRefDesc | Definition of a Measure Reference in a Table |
| casa::TableMeasType | Definition of a Measure column in a Table |
| casa::TableMeasValueDesc | Definition of a Measure Value in a Table |
| casa::TableNoDatFile | Table error; table.dat file not found |
| casa::TableNoDir | Table error; path is not a directory |
| casa::TableNoFile | Table error; table (description) not found |
| casa::TableParse | Class to hold values from table grammar parser |
| casa::TableParseError | Table error; invalid table command |
| casa::TableParseSelect | Select-class for flex/bison scanner/parser for TableParse |
| casa::TableParseSort | Helper class for sort keys in TableParse |
| casa::TableParseUpdate | Helper class for updates in TableParse |
| casa::TableProxy | High-level interface to tables |
| casa::TableQuantumDesc | A class for defining Quantum columns in Tables |
| casa::TableRecord | A hierarchical collection of named fields of various types |
| casa::TableRecordRep | The representation of a TableRecord |
| casa::TableRow | Read/write access to a table row |
| casa::TableRowProxy | Proxy for table row access |
| casa::TableSyncData | Class to hold table synchronization data |
| casa::TableUnknownDesc | Table error; unknown column description |
| casa::TableVector< T > | Templated read/write table column vectors |
| casa::TableVectorNonConform | Table error; non-conformant table vectors |
| casa::TabPath | Search path for table files |
| casa::TabularCoordinate | Table lookup 1-D coordinate, with interpolation |
| casa::TabularSpectrum | Models the spectral variation with a spectral index |
| casa::TabVecLogic_global_functions_scalarComparison | Comparison between a table vector and a scalar |
| casa::TabVecLogic_global_functions_vectorComparison | Comparison between two table vectors |
| casa::TabVecMath_global_functions_advTransMath | Further transcendental math for table vectors |
| casa::TabVecMath_global_functions_basicMath | Basic math for table vectors |
| casa::TabVecMath_global_functions_basicTransMath | Transcendental math for table vectors |
| casa::TabVecMath_global_functions_miscellaneous | Miscellaneous table vector operations |
| casa::TabVecMath_global_functions_vectorMath | Vector operations on a table vector |
| casa::TabVecRep< T > | Templated base class for table vectors |
| casa::TabVecScaCol< T > | Templated table scalar column vectors |
| casa::TabVecTemp< T > | Templated table vectors held in memory as a temporary |
| casa::Tan< T, RES > | Functor to apply tan |
| casa::Tanh< T, RES > | Functor to apply tanh |
| casa::TapeIO | Class for IO on a tape device |
| casa::TaQLBinaryNodeRep | Raw TaQL parse tree node defining a binary operator |
| casa::TaQLCalcNodeRep | Raw TaQL parse tree node defining a calc command |
| casa::TaQLColNodeRep | Raw TaQL parse tree node defining a select column expression |
| casa::TaQLColSpecNodeRep | Raw TaQL parse tree node defining a create column specification |
| casa::TaQLColumnsNodeRep | Raw TaQL parse tree node defining a select column list |
| casa::TaQLConstNode | Envelope class for a node containing a constant value |
| casa::TaQLConstNodeRep | Raw TaQL parse tree node defining a constant value |
| casa::TaQLCountNodeRep | Raw TaQL parse tree node defining a count command |
| casa::TaQLCreTabNodeRep | Raw TaQL parse tree node defining a create table command |
| casa::TaQLDeleteNodeRep | Raw TaQL parse tree node defining a delete command |
| casa::TaQLFuncNodeRep | Raw TaQL parse tree node defining a function |
| casa::TaQLGivingNodeRep | Raw TaQL parse tree node defining a giving expression list |
| casa::TaQLIndexNodeRep | Raw TaQL parse tree node defining an index in a array |
| casa::TaQLInsertNodeRep | Raw TaQL parse tree node defining an insert command |
| casa::TaQLJoinNodeRep | Raw TaQL parse tree node defining a join operation |
| casa::TaQLKeyColNodeRep | Raw TaQL parse tree node defining a keyword or column name |
| casa::TaQLLimitOffNodeRep | Raw TaQL parse tree node defining a limit/offset expression |
| casa::TaQLMultiNode | Envelope class for a node containing a select command |
| casa::TaQLMultiNodeRep | Raw TaQL parse tree node defining a list of nodes |
| casa::TaQLNode | Envelope class for a node in the raw TaQL parse tree |
| casa::TaQLNodeHandler | Class to handle the nodes in the raw TaQL parse tree |
| casa::TaQLNodeHRValue | Class containing the result value of the handling of a TaQLNode |
| casa::TaQLNodeRep | Representation of a node in the raw TaQL parse tree |
| casa::TaQLNodeResult | Envelope class to hold the result of a visit to the node tree |
| casa::TaQLNodeResultRep | Abstract base class to hold the result of a visit to the node tree |
| casa::TaQLNodeVisitor | Class to visit the nodes in the raw TaQL parse tree |
| casa::TaQLQueryNode | Envelope class for a node containing a selection command |
| casa::TaQLQueryNodeRep | Raw TaQL parse tree node defining a selection command |
| casa::TaQLRangeNodeRep | Raw TaQL parse tree node defining a range |
| casa::TaQLRecFldNodeRep | Raw TaQL parse tree node defining a record field |
| casa::TaqlRegex | Class to handle a Regex or StringDistance |
| casa::TaQLRegexNode | Envelope class for a node containing a constant regex value |
| casa::TaQLRegexNodeRep | Raw TaQL parse tree node defining a constant regex value |
| casa::TaQLResult | Class to hold the result of a TaQL command |
| casa::TaQLSelectNodeRep | Raw TaQL parse tree node defining a select command |
| casa::TaQLSortKeyNodeRep | Raw TaQL parse tree node defining a sort key |
| casa::TaQLSortNodeRep | Raw TaQL parse tree node defining a sort list |
| casa::TaQLStyle | Class with static members defining the TaQL style |
| casa::TaQLTableNodeRep | Raw TaQL parse tree node defining a table |
| casa::TaQLUnaryNodeRep | Raw TaQL parse tree node defining a unary operator |
| casa::TaQLUnitNodeRep | Raw TaQL parse tree node defining a unit |
| casa::TaQLUpdateNodeRep | Raw TaQL parse tree node defining an update command |
| casa::TaQLUpdExprNodeRep | Raw TaQL parse tree node defining a column update expression |
| casa::TempImage< T > | Temporary astronomical images |
| casa::Template | Canonicalise, format and other actions on aips++ template definitions |
| casa::TempLattice< T > | A Lattice that can be used for temporary storage |
| casa::TiledCellStMan | Tiled Cell Storage Manager |
| casa::TiledCollapser< T, U > | Abstract base class to collapse chunks for LatticeApply |
| casa::TiledColumnStMan | Tiled Column Storage Manager |
| casa::TiledDataStMan | Tiled Data Storage Manager |
| casa::TiledDataStManAccessor | Give access to some TiledDataStMan functions |
| casa::TiledFileAccess | Tiled access to an array in a file |
| casa::TiledFileHelper | Helper class for tiled access to an array in a file |
| casa::TiledLineStepper | Step a Vector cursor optimally through a tiled Lattice |
| casa::TiledShape | Define the shape and tile shape |
| casa::TiledShapeStMan | Tiled Data Storage Manager using the shape as id |
| casa::TiledStMan | Base class for Tiled Storage Manager classes |
| casa::TileStepper | Traverse a tiled Lattice optimally with a tile cursor |
| casa::Time | Date and time enquiry functions, with some operations |
| casa::TimeFields | |
| casa::Timer | Measure the time it takes to execute parts of a program |
| casa::TSMColumn | A column in the Tiled Storage Manager |
| casa::TSMCoordColumn | A coordinate column in Tiled Storage Manager |
| casa::TSMCube | Tiled hypercube in a table |
| casa::TSMCubeBuff | Tiled hypercube in a table |
| casa::TSMCubeMMap | Tiled hypercube in a table |
| casa::TSMDataColumn | A data column in Tiled Storage Manager |
| casa::TSMError | Table DataManager error; error in TiledStMan |
| casa::TSMFile | File object for Tiled Storage Manager |
| casa::TSMIdColumn | An id column in Tiled Storage Manager |
| casa::TSMOption | Options for the Tiled Storage Manager Access |
| casa::TSMShape | Expanded IPosition for shapes |
| casa::TVec_global_functions_enum | Enumeration of possible table vectors |
| casa::TVecLogic_global_functions_scalarComparison | Comparison between a table vector and a scalar |
| casa::TVecLogic_global_functions_vectorComparison | Comparison between two table vectors |
| casa::TVecMath_global_functions_advTransMath | Further transcendental math for table vectors |
| casa::TVecMath_global_functions_basicMath | Basic math for table vectors |
| casa::TVecMath_global_functions_basicTransMath | Transcendental math for table vectors |
| casa::TVecMath_global_functions_miscellaneous | Miscellaneous table vector operations |
| casa::TVecMath_global_functions_vectorMath | Vector operations on a table vector |
| casa::TwoSidedShape | Base class for component shapes with two sides |
| casa::TypeIO | Abstract base class for IO of data in a type-dependent format |
| casa::UDFBase | Abstract base class for a user-defined TaQL function |
| casa::UDFMSCal | TaQL UDFs to calculate derived MS values |
| casa::uIntSequence | UInt sequence for general use |
| casa::Unary< T > | Unary |
| casa::UnaryFunction< T > | A one dimensional unary function |
| casa::UnaryParam< T > | Parameter handling for one dimensional unary function |
| casa::UnequalShapeCopier< T > | Unequal shape copier |
| casa::Uniform | Uniform distribution |
| casa::Unit | Defines physical units |
| casa::UnitDim | Describes a unit in basic SI unit dimensions |
| casa::UnitMap | All simple known physical units |
| casa::UnitName | Handles physical units |
| casa::UnitVal | Describes any valid unit as a factor and a dimenion of SI units |
| casa::UnitVal_global_functions_output | Global output function |
| casa::UnitVal_static_initializer | Static initialisation of UnitVal constants |
| casa::UnrecognizedFunctionError | |
| casa::UVWJ2000Column | UVW J2000 derived from TIME, etc |
| casa::UVWMachine | Converts UVW coordinates between coordinate systems |
| casa::ValType | Data types and their undefined values |
| casa::ValTypeId_global_functions_typeid | The id-string of a value type |
| casa::ValueHolder | A holder for a value of any basic AIPS++ data type |
| casa::ValueHolderRep | A holder for a value of any basic type |
| casa::VanVleck | A class of static functions to aid with vanVleck corrections of lag data |
| casa::VariableArrayFITSFieldCopier< recordType, fitsType > | |
| casa::VAXConversion | A class with static functions to convert VAX format |
| casa::VAXDataConversion | A class with virtual functions to convert VAX format |
| casa::Vector< T > | A 1-D Specialization of the Array class |
| casa::VectorIterator< T > | Iterate an Vector cursor through another Array |
| casa::VectorKernel | Make a Vector smoothing kernel from a kernel specification |
| casa::VectorSTLIterator< T > | AIPS++ Vector iterator |
| casa::VelocityMachine | Converts between velocities and frequencies |
| casa::VirtScaCol_global_functions_getVirtualScalarColumn | Global functions to get or put data of a virtual column |
| casa::VirtualArrayColumn< T > | Templated base class for virtual array column |
| casa::VirtualColumnEngine | Abstract base class for virtual column handling |
| casa::VirtualScalarColumn< T > | Templated base class for virtual scalar column |
| casa::VirtualTaQLColumn | Virtual scalar column using TaQL |
| casa::VSCEngine< T > | Base virtual column for a scalar column with any type |
| casa::WCBox | Class to define a world coordinate box region of interest in an image |
| casa::WCComplement | Make the complement of an image region |
| casa::WCCompound | Base class for compound WCRegion objects |
| casa::WCConcatenation | Combine multiple ImageRegion's into a new dimension |
| casa::WCDifference | Make the difference of 2 image regions |
| casa::WCExtension | Make the extension of an image region |
| casa::WCIntersection | Make the intersection of 2 or more image regions |
| casa::WCLELMask | Class to define a mask as a LEL expression |
| casa::WCPolygon | Class to define a 2-D polygonal world coordinate region in an image |
| casa::WCRegion | Base class to define world coordinate regions of interest in an image |
| casa::WCUnion | Make the union of 2 or more image regions |
| casa::Weibull | Weibull distribution |
| casa::WrapperBase< T > | Aid in constructing function objects from C++ functions |
| casa::WrapperData< T, U, V, hasX, hasParam > | Aid in constructing function objects from C++ functions |
| casa::WrapperData_FF< T, T, T, False, False > | Specialization for calls with no arguments and no parameters |
| casa::WrapperData_FT< T, T, T, False, True > | Specialization for calls with no arguments and parameter |
| casa::WrapperData_FV< T, T, Vector< T >, False, True > | Specialization for calls with no arguments and parameters |
| casa::WrapperData_TF< T, T, T, True, False > | Specialization for calls with argument and no parameters |
| casa::WrapperData_TT< T, T, T, True, True > | Specialization for calls with argument and parameter |
| casa::WrapperData_TV< T, T, Vector< T >, True, True > | Specialization for calls with argument and parameters |
| casa::WrapperData_VF< T, Vector< T >, T, True, False > | Specialization for calls with argument and no parameters |
| casa::WrapperData_VT< T, Vector< T >, T, True, True > | Specialization for calls with argument and parameter |
| casa::WrapperData_VV< T, Vector< T >, Vector< T >, True, True > | Specialization for calls with argument and parameters |
| casa::WrapperParam< T > | Parameter handling for wrapped function objects |
1.5.7