wxrange.h

Go to the documentation of this file.

#ifndef wxrange_h
#define wxrange_h
 
// WarpX includes
#include "wxbox.h"
#include "wxexcept.h"
 
// std includes
#include <algorithm>
#include <limits>
 
class WxRange : protected WxBox<int>
{
 
public:
    WxRange() = default;
 
    WxRange(unsigned ndims) : WxBox<int>(ndims)
    {
    }
 
    WxRange(unsigned ndims, const int* lower, const int* upper)
        : WxBox<int>(ndims, lower, upper)
    {
    }
 
    WxRange(const std::vector<int>& lower, const std::vector<int>& extent)
        : WxBox<int>(lower.size())
    {
        for (unsigned int i = 0; i < ndims(); ++i)
        {
            WxBox<int>::lower(i, lower[i]);
            WxBox<int>::upper(i, lower[i] + extent[i] - 1);
        }
    }
 
    WxRange(unsigned ndims, const int* length) : WxBox<int>(ndims)
    {
        for (unsigned int i = 0; i < ndims; ++i)
        {
            int newLength = length[i] - 1;
            WxBox<int>::resize(i, newLength);
        }
    }
 
    WxRange(const WxBox<int>& templateBox) : WxBox<int>(templateBox)
    {
    }
 
    WxRange(const WxRange& b) : WxBox<int>(b)
    {
    }
 
    WxRange& operator=(const WxRange& b)
    {
        WxBox<int>::operator=(b);
        return *this;
    }
 
    using WxBox<int>::max_dims;
 
    using WxBox<int>::ndims;
    using WxBox<int>::setup;
    using WxBox<int>::upper;
    using WxBox<int>::lower;
    using WxBox<int>::extDim;
    using WxBox<int>::reduceDim;
    using WxBox<int>::boundsPair;
    using WxBox<int>::coordinateString;
 
    // TODO: lookup how Doxygen handles these 'using' cases
    using WxBox<int>::contains;
 
    // TODO:  uhg, I don't understand why 'using' the base function generates the error:
    // 'WxBox<int>' is an inaccessible base of 'WxRange' but it has something to do with
    // my protected inheritance and that the function argument is a reference to the base
    // class.
    // using WxBox<int>::encloses;
    // so I redefine here and have no problem.
    bool encloses(const WxRange& candidateRange) const
    {
        return WxBox<int>::encloses(candidateRange);
    }
 
    bool compareShape(const WxRange& candidateRange) const
    {
        return WxBox<int>::compareShape(candidateRange);
    }
 
    // overloaded functions that now include extremum
 
    // extend functions need to return WxRange not WxBox
    WxRange extend(const int low[], const int upp[]) const
    {
        return WxRange(this->WxBox<int>::extend(low, upp));
    }
 
    WxRange extend(const int uniformPad[]) const
    {
        return WxRange(this->WxBox<int>::extend(uniformPad));
    }
    WxRange extend(int uniformPad) const
    {
        return WxRange(this->WxBox<int>::extend(uniformPad));
    }
 
    void extrude(const WxRange& range)
    {
        this->WxBox<int>::extrude(range);
    }
 
    WxRange intersect(const WxRange& otherRange) const
    {
        // we override the parent WxBox::intersect because for range, the same coordinate
        // point for lower and upper means length 1, not length 0. so we can never really
        // have an empty range, just a negative range.  isEmpty provides for checking
        if (ndims() != otherRange.ndims())
        {
            return WxRange();
        }
        int lowerAdj[max_dims], upperAdj[max_dims];
        for (unsigned j = 0; j < _ndims; ++j)
        {
            lowerAdj[j] = std::max(_lower[j], otherRange._lower[j]);
            upperAdj[j] = std::min(_upper[j], otherRange._upper[j]);
            if (lowerAdj[j] > upperAdj[j])
                return WxRange(); // non-intersection in dim j
        }
 
        return WxRange(_ndims, lowerAdj, upperAdj);
    }
 
    WxRange getShiftedRange(const std::vector<int>& newLowerCornerCoordinates) const
    {
        int upperAdj[max_dims];
        int lowerAdj[max_dims];
        size_t j;
        for (j = 0;
             j < std::min(static_cast<size_t>(_ndims), newLowerCornerCoordinates.size());
             ++j)
        {
            lowerAdj[j] = newLowerCornerCoordinates[j];
            upperAdj[j] = newLowerCornerCoordinates[j] + (_upper[j] - _lower[j]);
        }
        for (; j < _ndims; ++j)
        {
            lowerAdj[j] = _lower[j];
            upperAdj[j] = _upper[j];
        }
        return WxRange(_ndims, lowerAdj, upperAdj);
    }
 
    bool isEmpty() const
    {
        if (_ndims <= 0)
            return true; // rank < 1 implies empty.
        for (unsigned i = 0; i < _ndims; ++i)
            if (_length[i] + 1 <= 0)
                return true;
        return false;
    }
 
    int length(unsigned dim) const
    {
        return _length[dim] + 1;
    }
 
    int size() const
    {
        if (_ndims == 0)
            return 0;
        int ar = 1;
        for (unsigned i = 0; i < _ndims; ++i)
            ar *= _length[i] + 1;
        return ar;
    }
 
    bool operator==(const WxRange& r) const
    {
        return WxBox<int>::operator==(r);
    }
 
    bool operator!=(const WxRange& r) const
    {
        return !WxRange::operator==(r);
    }
 
    friend std::ostream& operator<<(std::ostream& out, const WxRange& range)
    {
        out << "Range ndims " << range._ndims << ", length[";
        for (unsigned i = 0; i < range._ndims; i++)
        {
            out << range.length(i);
            if (i != range._ndims - 1)
            {
                out << ", ";
            }
        }
        out << "], lower[";
        for (unsigned i = 0; i < range._ndims; i++)
        {
            out << range.lower(i);
            if (i != range._ndims - 1)
            {
                out << ", ";
            }
        }
        out << "], upper[";
        for (unsigned i = 0; i < range._ndims; i++)
        {
            out << range.upper(i);
            if (i != range._ndims - 1)
            {
                out << ", ";
            }
        }
        out << "]";
        return out;
    }
};
 
#endif // wxrange_h