Loading...
Searching...
No Matches
IPosition.h
Go to the documentation of this file.
//# IPosition.h: A vector of integers, used to index into arrays.
//# Copyright (C) 1994,1995,1996,1997,1998,1999,2000,2001,2002
//# Associated Universities, Inc. Washington DC, USA.
//#
//# This library is free software; you can redistribute it and/or modify it
//# under the terms of the GNU Library General Public License as published by
//# the Free Software Foundation; either version 2 of the License, or (at your
//# option) any later version.
//#
//# This library is distributed in the hope that it will be useful, but WITHOUT
//# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
//# FITNESS FOR A PARTICULAR PURPOSE. See the GNU Library General Public
//# License for more details.
//#
//# You should have received a copy of the GNU Library General Public License
//# along with this library; if not, write to the Free Software Foundation,
//# Inc., 675 Massachusetts Ave, Cambridge, MA 02139, USA.
//#
//# Correspondence concerning AIPS++ should be addressed as follows:
//# Internet email: casa-feedback@nrao.edu.
//# Postal address: AIPS++ Project Office
//# National Radio Astronomy Observatory
//# 520 Edgemont Road
//# Charlottesville, VA 22903-2475 USA
#ifndef CASA_IPOSITION_2_H
#define CASA_IPOSITION_2_H
//# Includes
#include "ArrayFwd.h"
#include <vector>
#include <cstddef> // for ptrdiff_t
#include <initializer_list>
#include <sys/types.h>
namespace casacore { //# NAMESPACE CASACORE - BEGIN
//# Forward Declarations
class AipsIO;
class LogIO;
// <summary> A Vector of integers, for indexing into Array<T> objects. </summary>
// <use visibility=export>
// <reviewed reviewer="UNKNOWN" date="before2004/08/25" tests="">
// </reviewed>
//# <prerequisite>
//# Classes you should understand before using this one.
//# </prerequisite>
// <etymology>
// IPosition is an Index Position in an n-dimensional array.
// </etymology>
// <synopsis>
// IPosition is "logically" a Vector<int> constrained so that its origin
// is zero-based, and in fact that used to be the way it was implemented.
// It was split out into a separate class to make the inheritance from
// Arrays simpler (since Arrays use IPositions). The
// template instantiation mechanism is complicated enough that this
// simplification was felt to be a good idea.
// <p>
// IPosition objects are normally used to index into, and define the shapes
// of, multi-dimensional arrays. For example, if you have a 5 dimensional
// array, you need an IPosition of length 5 to index into the array (or
// to define its shape, etc.).
// <p>
// Unlike Vectors, IPositions always use copy semantics.
// <srcblock>
// IPosition ip1(5); // An IPosition of length 5
// ip1(0) = 11; ip1(1) = 5; ... ip1(4) = 6; // Indices 0-based
// IPosition ip2(ip1); // Copy constructor; a COPY
// </srcblock>
//
// Binary operations must take place either with a conformnat (same size)
// IPosition or with an integer, which behaves as if it was an IPosition
// of the same size (i.e., length). All the usual binary arithmetic
// operations are available, as well as logical operations, which return
// Booleans. These all operate "element-by-element".
// <p>
// All non-inlined member functions of IPosition check invariants if the
// preprocessor symbol AIPS_DEBUG is defined.
// That is, the member functions check that ok() is true (constructors
// check after construction, other functions on entry to the function).
// If these tests fail, an AipsError exception is thrown; its message
// contains the line number and source file of the failure (it is thrown
// by the lAssert macro defined in aips/Assert.h).
//
// Constructors and functions exist to construct an IPosition directly from
// a Vector or std::vector object or to convert to it. Furthermore the
// <src>fill</src> and <src>copy</src> can be used to fill from or copy to
// any STL-type iterator.
//
// <example>
// <srcblock>
// IPosition blc(5), trc(5,1,2,3,4,5);
// blc = 0; // OR IPosition blc(5,0);
// //...
// if (blc > trc) {
// IPosition tmp;
// tmp = trc; // Swap
// trc = blc;
// blc = tmp;
// }
// //...
// trc += 5; // make the box 5 larger in all dimensions
// std::vector<int> vec(trc.toStdVector());
// </srcblock>
// </example>
class IPosition
{
friend class IPositionComparator;
public:
// A zero-length IPosition.
IPosition() noexcept;
// An IPosition of size "length." The values in the object are uninitialized.
explicit IPosition(size_t length);
// An IPosition initialized from the given list
IPosition(std::initializer_list<ssize_t> list);
// An IPosition of size "length." All values in the object are
// initialized to val.
IPosition(size_t length, ssize_t val);
// An IPosition initialized from a variable number of parameters.
// The first parameter should specify the size, but the actual
// size of the resulting IPosition is determined from the number
// of parameters (the first argument is ignored).
//
// This constructor should be disfavoured, because i) of the
// dummy parameter and ii) because it may narrow the
// specified parameter without a warning.
//
// Instead, use an initializer list constructor whenever possible.
// If an IPosition is created inside a macro, an initializer list
// is not possible. In those cases, use the Make(Vals...) factory
// method. Both of those methods do not have the above issues.
template<typename... Vals>
//[[ deprecated("Use the initializer list constructor or Make() method") ]]
IPosition (size_t /*dummy*/, ssize_t val1, ssize_t val2, Vals... vals) :
IPosition{val1, val2, static_cast<ssize_t>(vals)...} { }
// Makes a copy (copy, NOT reference, semantics) of source.
IPosition(const IPosition& source);
IPosition(IPosition&& source) noexcept;
~IPosition();
// Construct an IPosition that is initialized from a variable number of parameter.
// The resulting size of the IPosition will equal the number of parameters specified.
//
// In general, using the initializer list constructor should be preferred. Defining
// an initializer list inside macros is however not possible. In those cases, this
// method can be used to construct the IPosition.
//
// Example: IPosition::Make(3, 5) creates an IPosition of size 2, with values 3 and 5.
// It is identical to IPosition{3, 5}. A program is ill-formed when narrowing of
// a parameter is required, causing a compiler warning or error.
template<typename... Vals>
static IPosition Make (Vals... vals) {
return IPosition{vals...};
}
// Makes this a copy of other. When the dest is not of the same
// size, it will resize itself to be the same length as the source.
IPosition& operator=(const IPosition& source);
IPosition& operator=(IPosition&& source);
// Copy "value" into every position of this IPosition.
IPosition& operator=(ssize_t value);
// Construct a default axis path consisting of the values 0 .. nrdim-1.
static IPosition makeAxisPath (size_t nrdim);
// Construct a full axis path from a (partially) given axis path.
// It fills the path with the non-given axis.
// It is checked if the given axis path is valid (i.e. if the axis are
// < nrdim and if they are not doubly defined).
// E.g.: in the 4D case an axis path [0,2] is returned as [0,2,1,3].
static IPosition makeAxisPath (size_t nrdim, const IPosition& partialPath);
// Make a list of axes which are the axes not given in <src>axes</src>
// up to the given dimension
static IPosition otherAxes (size_t nrdim, const IPosition& axes);
// Convert an IPosition to and from an Array<int/int64>. In either case, the
// array must be one dimensional.
// <group>
IPosition(const Array<int>& other);
IPosition(const Array<long long>& other);
Vector<int> asVector() const;
Vector<long long> asVector64() const;
// </group>
// Convert an IPosition to and from an Array<int/int64>. In either case, the
// array must be one dimensional.
// <group>
IPosition(const std::vector<int>& other);
IPosition(const std::vector<long long>& other);
std::vector<int> asStdVector() const;
std::vector<long long> asStdVector64() const;
// </group>
// Resize and fill this IPosition object.
template<typename InputIterator>
void fill (size_t size, InputIterator iter)
{
resize (size);
for (size_t i=0; i<size; ++i, ++iter) {
data_p[i] = *iter;
}
}
// Copy the contents of this IPosition object to the output iterator.
// The size of the output must be sufficient.
template<typename OutputIterator>
void copy (OutputIterator iter) const
{
for (size_t i=0; i<size_p; ++i, ++iter) {
*iter = data_p[i];
}
}
// This member functions return an IPosition which has
// degenerate (length==1) axes removed and the dimensionality reduced
// appropriately.
// Only axes greater than startingAxis are considered (normally one
// wants to remove trailing axes.
// <br>
// The functions with argument <src>ignoreAxes</src> do
// not consider the axes given in that argument.
// <group>
IPosition nonDegenerate(size_t startingAxis=0) const;
IPosition nonDegenerate(const IPosition& ignoreAxes) const;
// </group>
// Old values are copied on resize if copy==true.
// If the size increases, values beyond the former size are undefined.
void resize(size_t newSize, bool copy=true);
// Index into the IPosition. Indices are zero-based. If the preprocessor
// symbol AIPS_ARRAY_INDEX_CHECK is defined, operator() will check
// "index" to ensure it is not out of bounds. If this check fails, an
// AipsError will be thrown.
// <group>
ssize_t& operator[] (size_t index);
ssize_t operator[] (size_t index) const;
ssize_t& operator() (size_t index);
ssize_t operator() (size_t index) const;
// </group>
// Make an IPosition by using only the specified elements of the current
// IPosition. All values of <src>axes</src> must be less than
// the number of elements of the current object.
// <example>
// IPosition ipos(4, 11, 12, 13, 14);
// // ex1 is IPosition(3, 11, 12, 13);
// IPosition ex1 = ipos(IPosition(3,0,1,2);
// // ex2 is IPosition(3, 12, 11)
// IPosition ex2 = ipos(IPosition(2,2,1);
// // ex3 is IPosition(4,14,14,14,14)
// IPosition ex3 = ipos(IPosition(4,3,3,3,3);
// </example>
IPosition operator() (const IPosition& axes) const;
// Index into the IPosition from the end.
// By default the last value is returned.
// If the preprocessor symbol AIPS_ARRAY_INDEX_CHECK is defined, it will
// check if the index is not out of bounds.
// <group>
ssize_t& last (size_t index=0);
ssize_t last (size_t index=0) const;
// </group>
// Get the storage.
const ssize_t *storage() const;
// Append this IPosition with another one (causing a resize).
void append (const IPosition& other);
// Prepend this IPosition with another one (causing a resize).
void prepend (const IPosition& other);
// Return an IPosition as the concetanation of this and another IPosition.
IPosition concatenate (const IPosition& other) const;
// Set the first values of this IPosition to another IPosition.
// An exception is thrown if the other IPosition is too long.
void setFirst (const IPosition& other);
// Set the last values of this IPosition to another IPosition.
// An exception is thrown if the other IPosition is too long.
void setLast (const IPosition& other);
// Construct an IPosition from the first <src>n</src> values of this
// IPosition.
// An exception is thrown if <src>n</src> is too high.
IPosition getFirst (size_t n) const;
// Construct an IPosition from the last <src>n</src> values of this
// IPosition.
// An exception is thrown if <src>n</src> is too high.
IPosition getLast (size_t n) const;
// Return an IPosition where the given axes are reoved.
IPosition removeAxes (const IPosition& axes) const;
// Return an IPosition containing the given axes only.
IPosition keepAxes (const IPosition& axes) const;
// The number of elements in this IPosition. Since IPosition
// objects use zero-based indexing, the maximum available index is
// nelements() - 1.
// <group>
size_t nelements() const;
size_t size() const;
// </group>
// Is the IPosition empty (i.e. no elements)?
bool empty() const;
// conform returns true if nelements() == other.nelements().
bool conform(const IPosition& other) const;
// Element-by-element arithmetic.
// <group>
void operator += (const IPosition& other);
void operator -= (const IPosition& other);
void operator *= (const IPosition& other);
void operator /= (const IPosition& other);
void operator += (ssize_t val);
void operator -= (ssize_t val);
void operator *= (ssize_t val);
void operator /= (ssize_t val);
// </group>
// Returns 0 if nelements() == 0, otherwise it returns the product of
// its elements.
long long product() const;
// Are all elements equal to 1?
// Useful to check if a given stride is really a stride.
bool allOne() const;
// Element-by-element comparison for equality.
// It returns true if the lengths and all elements are equal.
// <br>
// Note that an important difference between this function and operator==()
// is that if the two IPositions have different lengths, this function
// returns false, instead of throwing an exception as operator==() does.
bool isEqual (const IPosition& other) const;
// Element-by-element comparison for equality.
// It returns true if all elements are equal.
// When <src>skipDegeneratedAxes</src> is true, axes with
// length 1 are skipped in both operands.
bool isEqual (const IPosition& other, bool skipDegeneratedAxes) const;
// Element-by-element comparison for (partial) equality.
// It returns true if the lengths and the first <src>nrCompare</src>
// elements are equal.
bool isEqual (const IPosition& other, size_t nrCompare) const;
// Is the other IPosition a subset of (or equal to) this IPosition?
// It is a subset if zero or more axes of this IPosition do not occur
// or are degenerated in the other and if the remaining axes are
// in the same order.
bool isSubSet (const IPosition& other) const;
// Write the IPosition into a string.
// TODO deprecate in favour of to_string(const IPosition&)
std::string toString() const;
// Write an IPosition to an ostream in a simple text form.
friend std::ostream& operator<<(std::ostream& os, const IPosition& ip);
// Is this IPosition consistent?
bool ok() const;
// Define the STL-style iterators.
// It makes it possible to iterate through all data elements.
// <srcblock>
// IPosition shp(2,0);
// for (IPosition::iterator iter=shp.begin(); iter!=shp.end(); iter++) {
// *iter += 1;
// }
// </srcblock>
// <group name=STL-iterator>
// STL-style typedefs.
// <group>
typedef ssize_t value_type;
typedef ssize_t* iterator;
typedef const ssize_t* const_iterator;
typedef value_type* pointer;
typedef const value_type* const_pointer;
typedef value_type& reference;
typedef const value_type& const_reference;
typedef size_t size_type;
typedef ptrdiff_t difference_type;
// </group>
// Get the begin and end iterator object for this object.
// <group>
iterator begin()
{ return data_p; }
const_iterator begin() const
{ return data_p; }
iterator end()
{ return data_p + size_p; }
const_iterator end() const
{ return data_p + size_p; }
// </group>
// </group>
private:
// Allocate a buffer with length size_p.
void allocateBuffer();
// Throw an index error exception.
void throwIndexError() const;
enum { BufferLength = 4 };
size_t size_p;
ssize_t buffer_p[BufferLength];
// When the iposition is length BufferSize or less data is just buffer_p,
// avoiding calls to new and delete.
ssize_t *data_p;
};
// Allows a way for IPosition to be used as keys in a std::map
class IPositionComparator {
public:
// if sizes aren't equal, returns true if lhs.size() < rhs.size(), false
// otherwise. If sizes are equal, does an element by element comparison. The first
// corresponding elements that are not equal, returns true if the rhs element is
// less than the lhs element, false otherwise. Returns false if all elements are
// equal.
bool operator()(const IPosition& lhs, const IPosition& rhs) const;
};
// <summary>Arithmetic Operations for IPosition's</summary>
// Element by element arithmetic on IPositions.
// <group name="IPosition Arithmetic">
// Each operation is done on corresponding elements of the IPositions. The
// two IPositions must have the same number of elements otherwise an
// exception (ArrayConformanceError) will be thrown.
// <group>
IPosition operator + (const IPosition& left, const IPosition& right);
IPosition operator - (const IPosition& left, const IPosition& right);
IPosition operator * (const IPosition& left, const IPosition& right);
IPosition operator / (const IPosition& left, const IPosition& right);
// </group>
// Each operation is done by appliying the integer argument to all elements
// of the IPosition argument.
// <group>
IPosition operator + (const IPosition& left, ssize_t val);
IPosition operator - (const IPosition& left, ssize_t val);
IPosition operator * (const IPosition& left, ssize_t val);
IPosition operator / (const IPosition& left, ssize_t val);
// </group>
// Same functions as above but with with the int argument on the left side.
// <group>
IPosition operator + (ssize_t val, const IPosition& right);
IPosition operator - (ssize_t val, const IPosition& right);
IPosition operator * (ssize_t val, const IPosition& right);
IPosition operator / (ssize_t val, const IPosition& right);
// </group>
// Returns the element by element minimum or maximum.
// <group>
IPosition max (const IPosition& left, const IPosition& right);
IPosition min (const IPosition& left, const IPosition& right);
// </group>
// </group>
// <summary>Logical operations for IPosition's</summary>
// Element by element boolean operations on IPositions. The result is true
// only if the operation yields true for every element of the IPosition.
// <group name="IPosition Logical">
// Each operation is done on corresponding elements of the IPositions. The
// two IPositions must have the same number of elements otherwise an
// exception (ArrayConformanceError) will be thrown.
// <group>
bool operator == (const IPosition& left, const IPosition& right);
bool operator != (const IPosition& left, const IPosition& right);
bool operator < (const IPosition& left, const IPosition& right);
bool operator <= (const IPosition& left, const IPosition& right);
bool operator > (const IPosition& left, const IPosition& right);
bool operator >= (const IPosition& left, const IPosition& right);
// </group>
// Each operation is done by appliying the integer argument to all elements
// <group>
bool operator == (const IPosition& left, ssize_t val);
bool operator != (const IPosition& left, ssize_t val);
bool operator < (const IPosition& left, ssize_t val);
bool operator <= (const IPosition& left, ssize_t val);
bool operator > (const IPosition& left, ssize_t val);
bool operator >= (const IPosition& left, ssize_t val);
// </group>
// Same functions as above but with with the int argument on the left side.
// <group>
bool operator == (ssize_t val, const IPosition& right);
bool operator != (ssize_t val, const IPosition& right);
bool operator < (ssize_t val, const IPosition& right);
bool operator <= (ssize_t val, const IPosition& right);
bool operator > (ssize_t val, const IPosition& right);
bool operator >= (ssize_t val, const IPosition& right);
// </group>
// </group>
// <summary>Indexing functions for IPosition's</summary>
// Convert between IPosition and offset in an array.
//
// The offset of an element in an array is the number of elements from the
// origin that the element would be if the array were arranged linearly.
// The origin of the array has an offset equal to 0, while the
// "top right corner" of the array has an offset equal to one less than the
// total number of elements in the array.
//
// Two examples of offset would be the index in a carray and the seek position
// in a file.
// <group name="IPosition Indexing">
// Convert from offset to IPosition in an array.
IPosition toIPositionInArray (long long offset, const IPosition& shape);
// Convert from IPosition to offset in an array.
long long toOffsetInArray (const IPosition& iposition, const IPosition& shape);
// Determine if the given offset or IPosition is inside the array. Returns
// true if it is inside the Array.
// <thrown>
// <li> ArrayConformanceError: If all the IPositions are not the same length
// </thrown>
// <group>
bool isInsideArray (const long long offset, const IPosition& shape);
bool isInsideArray (const IPosition& iposition, const IPosition& shape);
// </group>
// </group>
std::string to_string(const IPosition& ip);
//# Inlined member functions for IPosition
inline IPosition::IPosition() noexcept
: size_p (0),
data_p (buffer_p)
{}
inline IPosition IPosition::makeAxisPath (size_t nrdim)
{
return makeAxisPath (nrdim, IPosition());
}
inline size_t IPosition::nelements() const
{
return size_p;
}
inline size_t IPosition::size() const
{
return size_p;
}
inline bool IPosition::empty() const
{
return size_p == 0;
}
inline ssize_t& IPosition::operator[](size_t index)
{
return data_p[index];
}
inline ssize_t IPosition::operator[](size_t index) const
{
return data_p[index];
}
inline ssize_t& IPosition::operator()(size_t index)
{
#if defined(AIPS_ARRAY_INDEX_CHECK)
if (index >= nelements()) {
throwIndexError();
}
#endif
return data_p[index];
}
inline ssize_t IPosition::operator()(size_t index) const
{
#if defined(AIPS_ARRAY_INDEX_CHECK)
if (index >= nelements()) {
throwIndexError();
}
#endif
return data_p[index];
}
inline ssize_t& IPosition::last (size_t index)
{
#if defined(AIPS_ARRAY_INDEX_CHECK)
if (size_p - index <= 0) {
throwIndexError();
}
#endif
return data_p[size_p-index-1];
}
inline ssize_t IPosition::last (size_t index) const
{
#if defined(AIPS_ARRAY_INDEX_CHECK)
if (size_p - index <= 0) {
throwIndexError();
}
#endif
return data_p[size_p-index-1];
}
inline const ssize_t *IPosition::storage() const
{
return data_p;
}
inline bool IPosition::conform(const IPosition& other) const
{
return (size_p == other.size_p);
}
} //# NAMESPACE CASACORE - END
#endif
ArrayFwd.h
casacore::AipsIO
Definition AipsIO.h:167
casacore::Array
Definition Array.h:155
casacore::IPositionComparator
Allows a way for IPosition to be used as keys in a std::map.
Definition IPosition.h:442
casacore::IPositionComparator::operator()
bool operator()(const IPosition &lhs, const IPosition &rhs) const
if sizes aren't equal, returns true if lhs.size() < rhs.size(), false otherwise.
casacore::IPosition
Definition IPosition.h:117
casacore::IPosition::operator[]
ssize_t & operator[](size_t index)
Index into the IPosition.
Definition IPosition.h:579
casacore::IPosition::difference_type
ptrdiff_t difference_type
Definition IPosition.h:411
casacore::IPosition::size_p
size_t size_p
Definition IPosition.h:434
casacore::IPosition::operator*=
void operator*=(const IPosition &other)
casacore::IPosition::operator<<
friend std::ostream & operator<<(std::ostream &os, const IPosition &ip)
Write an IPosition to an ostream in a simple text form.
casacore::IPosition::const_pointer
const value_type * const_pointer
Definition IPosition.h:407
casacore::IPosition::IPosition
IPosition(const Array< long long > &other)
casacore::IPosition::isEqual
bool isEqual(const IPosition &other, size_t nrCompare) const
Element-by-element comparison for (partial) equality.
casacore::IPosition::size
size_t size() const
Definition IPosition.h:570
casacore::IPosition::operator=
IPosition & operator=(IPosition &&source)
casacore::IPosition::IPosition
IPosition(const Array< int > &other)
Convert an IPosition to and from an Array<int/int64>.
casacore::IPosition::operator()
ssize_t & operator()(size_t index)
Definition IPosition.h:589
casacore::IPosition::end
const_iterator end() const
Definition IPosition.h:421
casacore::IPosition::nonDegenerate
IPosition nonDegenerate(const IPosition &ignoreAxes) const
casacore::IPosition::keepAxes
IPosition keepAxes(const IPosition &axes) const
Return an IPosition containing the given axes only.
casacore::IPosition::value_type
ssize_t value_type
Define the STL-style iterators.
Definition IPosition.h:403
casacore::IPosition::asStdVector64
std::vector< long long > asStdVector64() const
casacore::IPosition::copy
void copy(OutputIterator iter) const
Copy the contents of this IPosition object to the output iterator.
Definition IPosition.h:228
casacore::IPosition::setLast
void setLast(const IPosition &other)
Set the last values of this IPosition to another IPosition.
casacore::IPosition::product
long long product() const
Returns 0 if nelements() == 0, otherwise it returns the product of its elements.
casacore::IPosition::operator-=
void operator-=(const IPosition &other)
casacore::IPosition::getFirst
IPosition getFirst(size_t n) const
Construct an IPosition from the first n values of this IPosition.
casacore::IPosition::removeAxes
IPosition removeAxes(const IPosition &axes) const
Return an IPosition where the given axes are reoved.
casacore::IPosition::operator=
IPosition & operator=(ssize_t value)
Copy "value" into every position of this IPosition.
casacore::IPosition::operator+=
void operator+=(const IPosition &other)
Element-by-element arithmetic.
casacore::IPosition::IPosition
IPosition() noexcept
A zero-length IPosition.
Definition IPosition.h:556
casacore::IPosition::asVector64
Vector< long long > asVector64() const
casacore::IPosition::IPosition
IPosition(IPosition &&source) noexcept
casacore::IPosition::resize
void resize(size_t newSize, bool copy=true)
Old values are copied on resize if copy==true.
casacore::IPosition::toString
std::string toString() const
Write the IPosition into a string.
casacore::IPosition::isEqual
bool isEqual(const IPosition &other) const
Element-by-element comparison for equality.
casacore::IPosition::ok
bool ok() const
Is this IPosition consistent?
casacore::IPosition::IPosition
IPosition(const IPosition &source)
Makes a copy (copy, NOT reference, semantics) of source.
casacore::IPosition::prepend
void prepend(const IPosition &other)
Prepend this IPosition with another one (causing a resize).
casacore::IPosition::isEqual
bool isEqual(const IPosition &other, bool skipDegeneratedAxes) const
Element-by-element comparison for equality.
casacore::IPosition::makeAxisPath
static IPosition makeAxisPath(size_t nrdim)
Construct a default axis path consisting of the values 0.
Definition IPosition.h:561
casacore::IPosition::nonDegenerate
IPosition nonDegenerate(size_t startingAxis=0) const
This member functions return an IPosition which has degenerate (length==1) axes removed and the dimen...
casacore::IPosition::nelements
size_t nelements() const
The number of elements in this IPosition.
Definition IPosition.h:566
casacore::IPosition::size_type
size_t size_type
Definition IPosition.h:410
casacore::IPosition::iterator
ssize_t * iterator
Definition IPosition.h:404
casacore::IPosition::IPosition
IPosition(const std::vector< long long > &other)
casacore::IPosition::empty
bool empty() const
Is the IPosition empty (i.e.
Definition IPosition.h:574
casacore::IPosition::makeAxisPath
static IPosition makeAxisPath(size_t nrdim, const IPosition &partialPath)
Construct a full axis path from a (partially) given axis path.
casacore::IPosition::allOne
bool allOne() const
Are all elements equal to 1?
casacore::IPosition::asStdVector
std::vector< int > asStdVector() const
casacore::IPosition::pointer
value_type * pointer
Definition IPosition.h:406
casacore::IPosition::IPositionComparator
friend class IPositionComparator
Definition IPosition.h:118
casacore::IPosition::concatenate
IPosition concatenate(const IPosition &other) const
Return an IPosition as the concetanation of this and another IPosition.
casacore::IPosition::begin
iterator begin()
Get the begin and end iterator object for this object.
Definition IPosition.h:415
casacore::IPosition::asVector
Vector< int > asVector() const
casacore::IPosition::allocateBuffer
void allocateBuffer()
Allocate a buffer with length size_p.
casacore::IPosition::data_p
ssize_t * data_p
When the iposition is length BufferSize or less data is just buffer_p, avoiding calls to new and dele...
Definition IPosition.h:438
casacore::IPosition::Make
static IPosition Make(Vals... vals)
Construct an IPosition that is initialized from a variable number of parameter.
Definition IPosition.h:170
casacore::IPosition::storage
const ssize_t * storage() const
Get the storage.
Definition IPosition.h:629
casacore::IPosition::conform
bool conform(const IPosition &other) const
conform returns true if nelements() == other.nelements().
Definition IPosition.h:634
casacore::IPosition::BufferLength
@ BufferLength
Definition IPosition.h:433
casacore::IPosition::getLast
IPosition getLast(size_t n) const
Construct an IPosition from the last n values of this IPosition.
casacore::IPosition::append
void append(const IPosition &other)
Append this IPosition with another one (causing a resize).
casacore::IPosition::operator=
IPosition & operator=(const IPosition &source)
Makes this a copy of other.
casacore::IPosition::begin
const_iterator begin() const
Definition IPosition.h:417
casacore::IPosition::last
ssize_t & last(size_t index=0)
Index into the IPosition from the end.
Definition IPosition.h:609
casacore::IPosition::buffer_p
ssize_t buffer_p[BufferLength]
Definition IPosition.h:435
casacore::IPosition::const_reference
const value_type & const_reference
Definition IPosition.h:409
casacore::IPosition::~IPosition
~IPosition()
casacore::IPosition::fill
void fill(size_t size, InputIterator iter)
Resize and fill this IPosition object.
Definition IPosition.h:217
casacore::IPosition::operator/=
void operator/=(const IPosition &other)
casacore::IPosition::reference
value_type & reference
Definition IPosition.h:408
casacore::IPosition::otherAxes
static IPosition otherAxes(size_t nrdim, const IPosition &axes)
Make a list of axes which are the axes not given in axes up to the given dimension.
casacore::IPosition::IPosition
IPosition(const std::vector< int > &other)
Convert an IPosition to and from an Array<int/int64>.
casacore::IPosition::throwIndexError
void throwIndexError() const
Throw an index error exception.
casacore::IPosition::const_iterator
const ssize_t * const_iterator
Definition IPosition.h:405
casacore::IPosition::end
iterator end()
Definition IPosition.h:419
casacore::IPosition::isSubSet
bool isSubSet(const IPosition &other) const
Is the other IPosition a subset of (or equal to) this IPosition?
casacore::IPosition::setFirst
void setFirst(const IPosition &other)
Set the first values of this IPosition to another IPosition.
casacore::LogIO
Definition LogIO.h:165
casacore::Vector
Definition Vector.h:82
casacore
this file contains all the compiler specific defines
Definition mainpage.dox:28
casacore::operator<=
Bool operator<=(const MVTime &lh, const MVTime &rh)
Definition MVTime.h:468
casacore::offset
int offset(int, int) const
compute a linear offset from array indicies
casacore::operator+
LatticeExprNode operator+(const LatticeExprNode &expr)
Global functions operating on a LatticeExprNode.
casacore::operator-
LatticeExprNode operator-(const LatticeExprNode &expr)
casacore::operator==
bool operator==(const casacore_allocator< T, ALIGNMENT > &, const casacore_allocator< T, ALIGNMENT > &)
Definition Allocator.h:122
casacore::operator!=
bool operator!=(const casacore_allocator< T, ALIGNMENT > &, const casacore_allocator< T, ALIGNMENT > &)
Definition Allocator.h:128
casacore::operator/
LatticeExprNode operator/(const LatticeExprNode &left, const LatticeExprNode &right)
casacore::shape
IPosition shape(const RecordFieldId &) const
Get the actual shape of this field.
casacore::operator<
Bool operator<(const MVTime &lh, const MVTime &rh)
Definition MVTime.h:466
casacore::to_string
std::string to_string(const IPosition &ip)
casacore::length
LatticeExprNode length(const LatticeExprNode &expr, const LatticeExprNode &axis)
2-argument function to get the length of an axis.
casacore::operator*
T & operator*()
Provide access to the field's value.
Definition RecordField.h:142
casacore::operator>=
Bool operator>=(const MVTime &lh, const MVTime &rh)
Definition MVTime.h:472
casacore::operator>
Bool operator>(const MVTime &lh, const MVTime &rh)
Definition MVTime.h:470
casacore::value
NewDelAllocator< T > NewDelAllocator< T >::value
Definition Allocator.h:368
std
Define real & complex conjugation for non-complex types and put comparisons into std namespace.
Definition Complex.h:350
casacore::IPosition_global_functions_IPosition_Arithmetic
Arithmetic Operations for IPosition's Element by element arithmetic on IPositions.
Definition IPosition.h:456
casacore::IPosition_global_functions_IPosition_Arithmetic::operator/
IPosition operator/(const IPosition &left, const IPosition &right)
casacore::IPosition_global_functions_IPosition_Arithmetic::operator-
IPosition operator-(const IPosition &left, const IPosition &right)
casacore::IPosition_global_functions_IPosition_Arithmetic::operator+
IPosition operator+(const IPosition &left, const IPosition &right)
Each operation is done on corresponding elements of the IPositions.
casacore::IPosition_global_functions_IPosition_Arithmetic::min
IPosition min(const IPosition &left, const IPosition &right)
casacore::IPosition_global_functions_IPosition_Arithmetic::max
IPosition max(const IPosition &left, const IPosition &right)
Returns the element by element minimum or maximum.
casacore::IPosition_global_functions_IPosition_Indexing
Indexing functions for IPosition's Convert between IPosition and offset in an array.
Definition IPosition.h:535
casacore::IPosition_global_functions_IPosition_Indexing::toIPositionInArray
IPosition toIPositionInArray(long long offset, const IPosition &shape)
Convert from offset to IPosition in an array.
casacore::IPosition_global_functions_IPosition_Indexing::toOffsetInArray
long long toOffsetInArray(const IPosition &iposition, const IPosition &shape)
Convert from IPosition to offset in an array.
casacore::IPosition_global_functions_IPosition_Indexing::isInsideArray
bool isInsideArray(const long long offset, const IPosition &shape)
Determine if the given offset or IPosition is inside the array.
casacore::IPosition_global_functions_IPosition_Indexing::isInsideArray
bool isInsideArray(const IPosition &iposition, const IPosition &shape)
casacore::IPosition_global_functions_IPosition_Logical
Logical operations for IPosition's Element by element boolean operations on IPositions.
Definition IPosition.h:492
casacore::IPosition_global_functions_IPosition_Logical::operator>
bool operator>(const IPosition &left, const IPosition &right)
casacore::IPosition_global_functions_IPosition_Logical::operator<
bool operator<(const IPosition &left, const IPosition &right)
casacore::IPosition_global_functions_IPosition_Logical::operator!=
bool operator!=(const IPosition &left, const IPosition &right)
casacore::IPosition_global_functions_IPosition_Logical::operator==
bool operator==(const IPosition &left, const IPosition &right)
Each operation is done on corresponding elements of the IPositions.
casacore::IPosition_global_functions_IPosition_Logical::operator<=
bool operator<=(const IPosition &left, const IPosition &right)
casacore::IPosition_global_functions_IPosition_Logical::operator>=
bool operator>=(const IPosition &left, const IPosition &right)