structures.hpp

Go to the documentation of this file.

/*****************************************************************************
    NumeRe: Framework fuer Numerische Rechnungen
    Copyright (C) 2017  Erik Haenel et al.
 
    This program is free software: you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation, either version 3 of the License, or
    (at your option) any later version.
 
    This program 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 General Public License for more details.
 
    You should have received a copy of the GNU General Public License
    along with this program.  If not, see <http://www.gnu.org/licenses/>.
******************************************************************************/
 
 
#ifndef STRUCTURES_HPP
#define STRUCTURES_HPP
 
#include <string>
#include <stdexcept>
#include <vector>
#include <cmath>
#include <algorithm>
#include "interval.hpp"
 
long long int intCast(const std::complex<double>&);
std::string toString(int);
std::string toString(long long int);
 
 
class VectorIndex
{
    private:
        mutable std::vector<int> vStorage;
        bool expand;
 
        inline int getIndex(size_t n) const
        {
            // If single indices are used, they will be expanded
            // into virtual vectors
            if (expand)
            {
                // If the second index has not been defined,
                // we'll expand the index using no end
                if (vStorage.back() == OPEN_END)
                {
                    if (vStorage.size() == 2)
                        return vStorage.front() + n;
                    else if (vStorage.size() > n+1)
                        return vStorage[n];
                    else
                        return vStorage[vStorage.size()-1] + n - (vStorage.size()-1);
                }
 
                // Consider the case that the order of the indices
                // could be inverted
                if (vStorage.front() <= vStorage.back() && (int)n + vStorage.front() <= vStorage.back())
                    return vStorage.front() + n;
                else if (vStorage.front() > vStorage.back() && vStorage.front() - (int)n >= vStorage.back()) // >= because vStorage.back() was not decremented first
                    return vStorage.front() - n;
            }
            else if (n < vStorage.size())
                return vStorage[n];
 
            return INVALID;
        }
 
    public:
        enum
        {
            INVALID = -1,
            OPEN_END = -2,
            STRING = -3
        };
 
        VectorIndex()
        {
            vStorage.assign({INVALID, INVALID});
            expand = true;
        }
 
        VectorIndex(const VectorIndex& vIndex) : vStorage(vIndex.vStorage), expand(vIndex.expand)
        {
        }
 
        VectorIndex(VectorIndex&& vIndex) : expand(std::move(vIndex.expand))
        {
            std::swap(vStorage, vIndex.vStorage);
        }
 
        VectorIndex(const mu::value_type* indices, int nResults, int unused)
        {
            // Store the indices and convert them to integers
            // using the intCast() function
            for (int i = 0; i < nResults; i++)
            {
                if (!std::isnan(indices[i].real()) && !std::isinf(indices[i].real()))
                    vStorage.push_back(intCast(indices[i]) - 1);
            }
 
            expand = false;
        }
 
        VectorIndex(int nStart, int nEnd = INVALID)
        {
            vStorage.assign({nStart, nEnd});
            expand = true;
        }
 
        VectorIndex(const std::vector<int>& vIndex)
        {
            if (vIndex.size())
            {
                vStorage = vIndex;
                expand = false;
            }
            else
            {
                vStorage.assign({INVALID, INVALID});
                expand = true;
            }
        }
 
        VectorIndex& operator=(const VectorIndex& vIndex)
        {
            vStorage = vIndex.vStorage;
            expand = vIndex.expand;
            return *this;
        }
 
        VectorIndex& operator=(const std::vector<int>& vIndex)
        {
            if (vIndex.size())
            {
                vStorage = vIndex;
                expand = false;
            }
 
            return *this;
        }
 
        VectorIndex subidx(size_t pos, size_t nLen = std::string::npos) const
        {
            // Consider some strange border cases
            if (pos >= size())
                return VectorIndex();
 
            if (nLen > size() - pos)
                nLen = size() - pos;
 
            // Return a single index
            if (nLen <= 1)
                return VectorIndex(getIndex(pos));
 
            // Calculate the starting and ending indices for
            // single indices. The last index is decremented,
            // because the first and the last index already
            // count as two indices.
            if (expand)
                return VectorIndex(getIndex(pos), getIndex(pos+nLen-1));
 
            // Return a copy of the internal storage, if it is already
            // expanded. The last index is not decremented, because
            // terminating iterator always points after the last
            // element in the list
            return VectorIndex(std::vector<int>(vStorage.begin()+pos, vStorage.begin()+pos+nLen));
        }
 
        void linearize()
        {
            if (!expand)
            {
                int nMin = min();
                int nMax = max();
 
                vStorage.clear();
                vStorage.assign({nMin, nMax});
                expand = true;
            }
        }
 
        inline int operator[](size_t n) const
        {
            return getIndex(n);
        }
 
        size_t size() const
        {
            if (vStorage.size() == 2 && !isValid())
                return 0;
            else if (vStorage.back() == INVALID)
                return 1;
            else if (vStorage.back() == OPEN_END)
                return -1;
            else if (vStorage.size() == 2 && expand)
                return abs(vStorage.back() - vStorage.front()) + 1;
            else
                return vStorage.size();
        }
 
        size_t numberOfNodes() const
        {
            if (!isValid())
                return 0;
            else if (vStorage.size() == 2 && ((vStorage.back() == INVALID) xor (vStorage.front() == INVALID)))
                return 1;
            else
                return vStorage.size();
        }
 
        bool isOrdered() const
        {
            if (isValid())
                return vStorage.front() <= vStorage.back() || vStorage.back() == INVALID || vStorage.back() == OPEN_END;
 
            return false;
        }
 
        bool isExpanded() const
        {
            return expand;
        }
 
        void setIndex(size_t nthIndex, int nVal)
        {
            // If the size is large enough, simply store
            // the passed index. Otherwise expand the
            // index using invalid values and store it
            // afterwards
            if (nthIndex < vStorage.size())
            {
                vStorage[nthIndex] = nVal;
            }
            else
            {
                // increase the size by using invalid values
                while (vStorage.size() <= nthIndex)
                    vStorage.push_back(INVALID);
 
                vStorage[nthIndex] = nVal;
 
                // If the last value is not an open end
                // value and the size of the internal storage
                // is larger than two, deactivate the expanding
                if (vStorage.size() > 2 && vStorage.back() != OPEN_END)
                    expand = false;
            }
        }
 
        void push_back(int nVal)
        {
            if (expand)
            {
                vStorage = getVector();
                expand = false;
            }
 
            vStorage.push_back(nVal);
        }
 
        void append(const std::vector<int>& vVector)
        {
            if (expand)
            {
                vStorage = getVector();
                expand = false;
            }
 
            vStorage.insert(vStorage.end(), vVector.begin(), vVector.end());
        }
 
        void append(const VectorIndex& vIndex)
        {
            if (vIndex.expand)
                append(vIndex.getVector());
            else
                append(vIndex.vStorage);
        }
 
        void prepend(const std::vector<int>& vVector)
        {
            if (expand)
            {
                vStorage = getVector();
                expand = false;
            }
 
            vStorage.insert(vStorage.begin(), vVector.begin(), vVector.end());
        }
 
        void prepend(const VectorIndex& vIndex)
        {
            if (vIndex.expand)
                prepend(vIndex.getVector());
            else
                prepend(vIndex.vStorage);
        }
 
        std::vector<int> getVector() const
        {
            // Expand the single indices stored internally
            // if needed
            if (expand)
            {
                std::vector<int> vReturn;
 
                for (size_t i = 0; i < size(); i++)
                {
                    vReturn.push_back(getIndex(i));
                }
 
                return vReturn;
            }
 
            return vStorage;
        }
 
        int max() const
        {
            if (isOpenEnd())
                return OPEN_END;
            else if (expand)
                return std::max(vStorage.front(), vStorage.back());
 
            return *std::max_element(vStorage.begin(), vStorage.end());
        }
 
        int min() const
        {
            if (expand && isOpenEnd())
                return vStorage.front();
            else if (expand)
                return std::min(vStorage.front(), vStorage.back());
 
            int nMin = vStorage.front();
 
            for (size_t i = 1; i < vStorage.size(); i++)
            {
                if (nMin < 0 || (vStorage[i] > 0 && vStorage[i] < nMin))
                    nMin = vStorage[i];
            }
 
            return nMin;
        }
 
        inline bool isValid() const
        {
            return vStorage.front() != INVALID || vStorage.back() != INVALID;
        }
 
        inline bool isOpenEnd() const
        {
            return vStorage.back() == OPEN_END;
        }
 
        inline bool isString() const
        {
            return vStorage.front() == STRING || vStorage.back() == STRING;
        }
 
        int& front()
        {
            return vStorage.front();
        }
 
        int& back()
        {
            return vStorage.back();
        }
 
        const int& front() const
        {
            return vStorage.front();
        }
 
        const int& back() const
        {
            return vStorage.back();
        }
 
        int last() const
        {
            if (expand && vStorage.back() == INVALID)
                return vStorage.front();
 
            return vStorage.back();
        }
 
        void setRange(int nMin, int nMax)
        {
            // Change the order of the minimal and
            // maximal value, if needed
            if (nMin > nMax)
            {
                int nTemp = nMin;
                nMin = nMax;
                nMax = nTemp;
            }
 
            // Compare all values to the defined
            // interval
            for (size_t i = 0; i < vStorage.size(); i++)
            {
                // Special cases: if the current value
                // is open end, use the maximal value
                // passed to this function
                if (vStorage[i] == OPEN_END)
                {
                    vStorage[i] = nMax;
                    continue;
                }
                else if (vStorage[i] == INVALID)
                    continue;
 
                if (vStorage[i] < nMin)
                    vStorage[i] = nMin;
 
                if (vStorage[i] > nMax)
                    vStorage[i] = nMax;
            }
        }
 
        void setOpenEndIndex(int nLast) const
        {
            if (vStorage.back() == OPEN_END)
                vStorage.back() = nLast;
        }
 
        std::string to_string() const
        {
            if (expand)
            {
                std::string sVect;
 
                if (vStorage.front() == INVALID)
                    sVect += "INVALID";
                else if (vStorage.front() == STRING)
                    sVect += "#";
                else
                    sVect += toString(vStorage.front()+1);
 
                // Do not present the second index if
                // it corresponds to an invalid value
                if (vStorage.back() == OPEN_END)
                    sVect += ":inf";
                else if (vStorage.back() == STRING)
                    sVect += ":#";
                else if (vStorage.back() != INVALID)
                    sVect += ":"+toString(vStorage.back()+1);
 
                return sVect;
            }
            else
            {
                std::string sVect = "{";
 
                for (size_t i = 0; i < size(); i++)
                {
                    // Jump over the middle section,
                    // if the vector length is larger
                    // than 5
                    if (size() >= 5u && i == 2)
                    {
                        sVect += "...,";
                        i = size() - 2;
                    }
 
                    if (getIndex(i) == INVALID)
                        sVect += "INVALID";
                    else if (getIndex(i) == OPEN_END)
                        sVect += "inf";
                    else if (getIndex(i) == STRING)
                        sVect += "#";
                    else
                        sVect += toString(getIndex(i)+1);
 
                    if (i + 1 < size())
                        sVect += ",";
                }
 
                return sVect + "}";
            }
        }
};
 
 
template<class T>
class EndlessVector : public std::vector<T>
{
    private:
        T m_fallback;
    public:
        EndlessVector() : std::vector<T>(), m_fallback() {}
 
        EndlessVector(const EndlessVector& vec) : std::vector<T>(vec), m_fallback() {}
 
        EndlessVector& operator=(const EndlessVector& vec)
        {
            std::vector<T>::operator=(vec);
            return *this;
        }
 
        T& operator[](size_t n)
        {
            if (n < std::vector<T>::size())
                return std::vector<T>::operator[](n);
 
            return m_fallback;
        }
};
 
 
class StringViewBase
{
    protected:
        size_t m_start;
        size_t m_len;
 
        inline size_t validizeLength(size_t pos, size_t len) const
        {
            if (len == std::string::npos || pos+len > m_len)
                len = m_len - pos;
 
            return len;
        }
 
        virtual inline void clear()
        {
            m_start = 0;
            m_len = 0;
        }
 
        inline bool validAbsolutePosition(size_t pos) const
        {
            return pos >= m_start && pos < m_start + m_len;
        }
 
    public:
 
        StringViewBase() : m_start(0), m_len(0) {}
 
        virtual inline const std::string* getData() const
        {
            return nullptr;
        }
 
        inline bool operator==(const StringViewBase& view) const
        {
            const std::string* thisString = getData();
            const std::string* viewString = view.getData();
            if (thisString && viewString)
                return thisString->compare(m_start, m_len, *viewString, view.m_start, view.m_len) == 0;
 
            return false;
        }
 
        inline bool operator==(const std::string& sString) const
        {
            const std::string* thisString = getData();
 
            if (thisString)
                return thisString->compare(m_start, m_len, sString) == 0;
 
            return false;
        }
 
        inline bool operator==(const char* sString) const
        {
            const std::string* thisString = getData();
 
            if (thisString)
                return thisString->compare(m_start, m_len, sString) == 0;
 
            return false;
        }
 
        inline bool operator!=(const StringViewBase& view) const
        {
            if (getData() && view.getData())
                return getData()->compare(m_start, m_len, *view.getData(), view.m_start, view.m_len) != 0;
 
            return false;
        }
 
        inline bool operator!=(const std::string& sString) const
        {
            if (getData())
                return getData()->compare(m_start, m_len, sString) != 0;
 
            return false;
        }
 
        inline bool operator!=(const char* sString) const
        {
            if (getData())
                return getData()->compare(m_start, m_len, sString) != 0;
 
            return false;
        }
 
        inline bool operator<(const StringViewBase& view) const
        {
            if (getData() && view.getData())
                return getData()->compare(m_start, m_len, *view.getData(), view.m_start, view.m_len) < 0;
 
            return false;
        }
 
        inline bool operator<(const std::string& sString) const
        {
            if (getData())
                return getData()->compare(m_start, m_len, sString) < 0;
 
            return false;
        }
 
        inline bool operator<=(const StringViewBase& view) const
        {
            if (getData() && view.getData())
                return getData()->compare(m_start, m_len, *view.getData(), view.m_start, view.m_len) <= 0;
 
            return false;
        }
 
        inline bool operator<=(const std::string& sString) const
        {
            if (getData())
                return getData()->compare(m_start, m_len, sString) <= 0;
 
            return false;
        }
 
        inline bool operator>(const StringViewBase& view) const
        {
            if (getData() && view.getData())
                return getData()->compare(m_start, m_len, *view.getData(), view.m_start, view.m_len) > 0;
 
            return false;
        }
 
        inline bool operator>(const std::string& sString) const
        {
            if (getData())
                return getData()->compare(m_start, m_len, sString) > 0;
 
            return false;
        }
 
        inline bool operator>=(const StringViewBase& view) const
        {
            if (getData() && view.getData())
                return getData()->compare(m_start, m_len, *view.getData(), view.m_start, view.m_len) >= 0;
 
            return false;
        }
 
        inline bool operator>=(const std::string& sString) const
        {
            if (getData())
                return getData()->compare(m_start, m_len, sString) >= 0;
 
            return false;
        }
 
        inline std::string operator+(const StringViewBase& view) const
        {
            if (getData() && view.getData())
                return std::string(begin(), end()).append(view.begin(), view.end());
 
            return "";
        }
 
        inline std::string operator+(const std::string& sString) const
        {
            if (getData())
                return std::string(begin(), end()).append(sString);
 
            return "";
        }
 
        inline const char& front() const
        {
            if (getData())
                return getData()->at(m_start);
 
            throw std::out_of_range("StringView::front");
        }
 
        inline const char& back() const
        {
            if (getData())
                return getData()->at(m_start+m_len-1);
 
            throw std::out_of_range("StringView::back");
        }
 
        inline std::string::const_iterator begin() const
        {
            if (getData())
                return getData()->begin() + m_start;
 
            return std::string::const_iterator();
        }
 
        inline std::string::const_iterator end() const
        {
            if (getData())
                return getData()->begin() + m_start + m_len;
 
            return std::string::const_iterator();
        }
 
        inline void trim_front(size_t len)
        {
            if (len < m_len)
            {
                m_start += len;
                m_len -= len;
            }
            else
                clear();
        }
 
        inline void trim_back(size_t len)
        {
            if (len < m_len)
                m_len -= len;
            else
                clear();
        }
 
        inline void strip()
        {
            const std::string* data = getData();
 
            if (!data)
                return;
 
            // Strip leading
            while (m_len && isblank(data->operator[](m_start)))
            {
                m_start++;
                m_len--;
            }
 
            if (!m_len)
            {
                clear();
                return;
            }
 
            // Strip trailing
            while (m_len && isblank(data->operator[](m_start+m_len-1)))
            {
                m_len--;
            }
        }
 
        inline size_t length() const
        {
            return m_len;
        }
 
        inline std::string to_string() const
        {
            if (getData())
                return getData()->substr(m_start, m_len);
 
            return "";
        }
 
        size_t find(const std::string& findstr, size_t pos = 0) const
        {
            if (getData())
            {
                size_t fnd = getData()->find(findstr, m_start + pos);
 
                if (validAbsolutePosition(fnd))
                    return fnd-m_start;
            }
 
            return std::string::npos;
        }
 
        size_t find(char c, size_t pos = 0) const
        {
            if (getData())
            {
                size_t fnd = getData()->find(c, m_start + pos);
 
                if (validAbsolutePosition(fnd))
                    return fnd-m_start;
            }
 
            return std::string::npos;
        }
 
        size_t rfind(const std::string& findstr, size_t pos = std::string::npos) const
        {
            if (getData())
            {
                pos = validizeLength(m_start, pos);
                size_t fnd = getData()->rfind(findstr, m_start + pos);
 
                if (validAbsolutePosition(fnd))
                    return fnd-m_start;
            }
 
            return std::string::npos;
        }
 
        size_t rfind(char c, size_t pos = std::string::npos) const
        {
            if (getData())
            {
                pos = validizeLength(m_start, pos);
                size_t fnd = getData()->rfind(c, m_start + pos);
 
                if (validAbsolutePosition(fnd))
                    return fnd-m_start;
            }
 
            return std::string::npos;
        }
 
        size_t find_first_of(const std::string& findstr, size_t pos = 0) const
        {
            if (getData())
            {
                size_t fnd = getData()->find_first_of(findstr, m_start + pos);
 
                if (validAbsolutePosition(fnd))
                    return fnd-m_start;
            }
 
            return std::string::npos;
        }
 
        size_t find_first_of(char c, size_t pos = 0) const
        {
            if (getData())
            {
                size_t fnd = getData()->find_first_of(c, m_start + pos);
 
                if (validAbsolutePosition(fnd))
                    return fnd-m_start;
            }
 
            return std::string::npos;
        }
 
        size_t find_first_not_of(const std::string& findstr, size_t pos = 0) const
        {
            if (getData())
            {
                size_t fnd = getData()->find_first_not_of(findstr, m_start + pos);
 
                if (validAbsolutePosition(fnd))
                    return fnd-m_start;
            }
 
            return std::string::npos;
        }
 
        size_t find_first_not_of(char c, size_t pos = 0) const
        {
            if (getData())
            {
                size_t fnd = getData()->find_first_not_of(c, m_start + pos);
 
                if (validAbsolutePosition(fnd))
                    return fnd-m_start;
            }
 
            return std::string::npos;
        }
 
        size_t find_last_of(const std::string& findstr, size_t pos = std::string::npos) const
        {
            if (getData())
            {
                pos = validizeLength(m_start, pos);
                size_t fnd = getData()->find_last_of(findstr, m_start + pos);
 
                if (validAbsolutePosition(fnd))
                    return fnd-m_start;
            }
 
            return std::string::npos;
        }
 
        size_t find_last_of(char c, size_t pos = std::string::npos) const
        {
            if (getData())
            {
                pos = validizeLength(m_start, pos);
                size_t fnd = getData()->find_last_of(c, m_start + pos);
 
                if (validAbsolutePosition(fnd))
                    return fnd-m_start;
            }
 
            return std::string::npos;
        }
 
        size_t find_last_not_of(const std::string& findstr, size_t pos = std::string::npos) const
        {
            if (getData())
            {
                pos = validizeLength(m_start, pos);
                size_t fnd = getData()->find_last_not_of(findstr, m_start + pos);
 
                if (validAbsolutePosition(fnd))
                    return fnd-m_start;
            }
 
            return std::string::npos;
        }
 
        size_t find_last_not_of(char c, size_t pos = std::string::npos) const
        {
            if (getData())
            {
                pos = validizeLength(m_start, pos);
                size_t fnd = getData()->find_last_not_of(c, m_start + pos);
 
                if (validAbsolutePosition(fnd))
                    return fnd-m_start;
            }
 
            return std::string::npos;
        }
 
};
 
 
inline std::string operator+(const std::string& sString, const StringViewBase& view)
{
    return sString + view.to_string();
}
 
 
// Forward declaration for friendship
class StringView;
 
 
class MutableStringView : public StringViewBase
{
    private:
        friend class StringView;
        std::string* m_data;
 
        MutableStringView(std::string* data, size_t start, size_t len) : StringViewBase(), m_data(data)
        {
            m_start = start;
            m_len = len;
        }
 
    protected:
        virtual inline const std::string* getData() const override
        {
            return m_data;
        }
 
        void assign(MutableStringView& view)
        {
            m_data = view.m_data;
            m_start = view.m_start;
            m_len = view.m_len;
        }
 
        void assign(std::string* data)
        {
            if (!data)
                return;
 
            m_data = data;
            m_start = 0;
            m_len = m_data->length();
        }
 
        virtual inline void clear() override
        {
            m_data = nullptr;
            m_start = 0;
            m_len = 0;
        }
 
    public:
        MutableStringView() : StringViewBase(), m_data(nullptr) {}
 
        MutableStringView(std::string* data) : MutableStringView()
        {
            assign(data);
        }
 
        MutableStringView(std::string& data) : MutableStringView()
        {
            assign(&data);
        }
 
        MutableStringView(MutableStringView& view) : MutableStringView()
        {
            assign(view);
        }
 
        MutableStringView(MutableStringView&& view)
        {
            m_data = std::move(view.m_data);
            m_start = std::move(view.m_start);
            m_len = std::move(view.m_len);
        }
 
        MutableStringView& operator=(MutableStringView& view)
        {
            assign(view);
            return *this;
        }
 
        MutableStringView& operator=(std::string* data)
        {
            assign(data);
            return *this;
        }
 
        MutableStringView& operator=(std::string& data)
        {
            assign(&data);
            return *this;
        }
 
        inline char& operator[](size_t pos)
        {
            return m_data->operator[](m_start+pos);
        }
 
        MutableStringView subview(size_t pos = 0, size_t len = std::string::npos) const
        {
            if (m_data && pos < m_len)
            {
                len = validizeLength(pos, len);
                return MutableStringView(m_data, m_start+pos, len);
            }
 
            return MutableStringView();
        }
 
        MutableStringView& replace(size_t pos, size_t len, const std::string& s)
        {
            if (m_data && pos < m_len)
            {
                len = validizeLength(pos, len);
                m_data->replace(m_start+pos, len, s);
                m_len += s.length() - len;
            }
 
            return *this;
        }
 
        MutableStringView& replace(size_t pos, size_t len, const std::string& s, size_t subpos, size_t sublen)
        {
            if (m_data && pos < m_len)
            {
                len = validizeLength(pos, len);
 
                if (subpos + sublen > s.length())
                    sublen = s.length() - subpos;
 
                m_data->replace(m_start+pos, len, s, subpos, sublen);
                m_len += sublen - len;
            }
 
            return *this;
        }
 
        MutableStringView& replace(size_t pos, size_t len, const StringViewBase& view)
        {
            return replace(pos, len, view.to_string());
        }
 
};
 
 
class StringView : public StringViewBase
{
    private:
        const std::string* m_data;
 
        StringView(const std::string* data, size_t start, size_t len) : StringViewBase(), m_data(data)
        {
            m_start = start;
            m_len = len;
        }
 
    protected:
        virtual inline const std::string* getData() const override
        {
            return m_data;
        }
 
        void assign(const StringView& view)
        {
            m_data = view.m_data;
            m_start = view.m_start;
            m_len = view.m_len;
        }
 
        void assign(const MutableStringView& view)
        {
            m_data = view.m_data;
            m_start = view.m_start;
            m_len = view.m_len;
        }
 
        void assign(const std::string* data)
        {
            if (!data)
                return;
 
            m_data = data;
            m_start = 0;
            m_len = m_data->length();
        }
 
        virtual inline void clear() override
        {
            m_data = nullptr;
            m_start = 0;
            m_len = 0;
        }
 
    public:
        StringView() : StringViewBase(), m_data(nullptr) {}
 
        StringView(const std::string* data) : StringView()
        {
            assign(data);
        }
 
        StringView(const std::string& data) : StringView()
        {
            assign(&data);
        }
 
        StringView(const std::string& data, size_t start, size_t len = std::string::npos) : StringView()
        {
            assign(&data);
 
            if (m_data && start < m_len)
            {
                len = validizeLength(start, len);
                m_start = start;
                m_len = len;
            }
        }
 
        StringView(const StringView& view) : StringView()
        {
            assign(view);
        }
 
        StringView(const MutableStringView& view) : StringView()
        {
            assign(view);
        }
 
        StringView(StringView&& view)
        {
            m_data = std::move(view.m_data);
            m_start = std::move(view.m_start);
            m_len = std::move(view.m_len);
        }
 
        StringView& operator=(const StringView& view)
        {
            assign(view);
            return *this;
        }
 
        StringView& operator=(const MutableStringView& view)
        {
            assign(view);
            return *this;
        }
 
        StringView& operator=(const std::string* data)
        {
            assign(data);
            return *this;
        }
 
        StringView& operator=(const std::string& data)
        {
            assign(&data);
            return *this;
        }
 
        inline const char& operator[](size_t pos) const
        {
            return m_data->operator[](m_start+pos);
        }
 
        StringView subview(size_t pos = 0, size_t len = std::string::npos) const
        {
            if (m_data && pos < m_len)
            {
                len = validizeLength(pos, len);
                return StringView(m_data, m_start+pos, len);
            }
 
            return StringView();
        }
 
        MutableStringView make_mutable() const
        {
            if (m_data)
                return MutableStringView(const_cast<std::string*>(m_data), m_start, m_len);
 
            return MutableStringView();
        }
 
};
 
 
struct Indices
{
    VectorIndex row;
    VectorIndex col;
    std::string sCompiledAccessEquation;
 
    Indices() { }
    Indices(const Indices& _idx) : row(_idx.row), col(_idx.col), sCompiledAccessEquation(_idx.sCompiledAccessEquation)
    {
    }
    Indices(Indices&& _idx)
    {
        std::swap(_idx.row, row);
        std::swap(_idx.col, col);
        std::swap(_idx.sCompiledAccessEquation, sCompiledAccessEquation);
    }
    Indices& operator=(const Indices& _idx)
    {
        row = _idx.row;
        col = _idx.col;
        sCompiledAccessEquation = _idx.sCompiledAccessEquation;
        return *this;
    }
};
 
 
struct Match
{
    std::string sString;
    unsigned int nPos;
};
 
 
struct Point
{
    double x;
    double y;
 
    Point(double _x, double _y) : x(_x), y(_y) {}
 
    void rotate90(int n, const Point& origin = Point(0, 0))
    {
        x -= origin.x;
        y -= origin.y;
 
        double x1 = x;
        double y1 = y;
 
        // Remove multiples of 360 degrees
        n = n % 4;
 
        // Move negative angles to the corresponding
        // positive value
        if (n < 0)
            n += 4;
 
        // We only have to consider the values 1-3
        switch (n)
        {
            case 1:
                x1 = -y;
                y1 = x;
                break;
            case 2:
                x1 = -x;
                y1 = -y;
                break;
            case 3:
                x1 = y;
                y1 = -x;
                break;
        }
 
        x = x1 + origin.x;
        y = y1 + origin.y;
    }
 
    void rotate(double dAlpha, const Point& origin = Point(0, 0))
    {
        // Use the 90 degree rotation optimisation
        if (abs(dAlpha / M_PI_2 - rint(dAlpha / M_PI_2)) < 1e-8)
        {
            rotate90(rint(dAlpha / M_PI_2), origin);
            return;
        }
 
        double x1 = (x - origin.x) * cos(dAlpha) - (y - origin.y) * sin(dAlpha) + origin.x;
        double y1 = (x - origin.x) * sin(dAlpha) + (y - origin.y) * cos(dAlpha) + origin.y;
 
        x = x1;
        y = y1;
    }
 
    Point operator+(const Point& a) const
    {
        return Point(x + a.x, y + a.y);
    }
 
    Point operator-(const Point& a) const
    {
        return Point(x - a.x, y - a.y);
    }
 
    Point operator*(double a) const
    {
        return Point(x*a, y*a);
    }
 
    Point operator/(double a) const
    {
        return Point(x/a, y/a);
    }
};
 
 
struct Returnvalue
{
    std::vector<mu::value_type> vNumVal;
    std::vector<std::string> vStringVal;
    std::string sReturnedTable;
    bool delayDelete;
 
    Returnvalue() : delayDelete(false) {}
 
    // clear method
    void clear()
    {
        vNumVal.clear();
        vStringVal.clear();
        sReturnedTable.clear();
        delayDelete = false;
    }
 
    // boolean checkers
    bool isString() const
    {
        return vStringVal.size();
    }
    bool isNumeric() const
    {
        return vNumVal.size() && !vStringVal.size();
    }
};
 
 
struct DefaultVariables
{
    std::string sName[4] = {"x", "y", "z", "t"};
    mu::value_type vValue[4][4];
};
 
 
struct ColumnKeys
{
    int nKey[2];
    // Contains a recursive pointer
    ColumnKeys* subkeys;
 
    // Default constructor
    ColumnKeys() : nKey{-1,-1}, subkeys(nullptr) {}
    // Destructor recursively deletes the stored pointers
    ~ColumnKeys()
        {
            if (subkeys)
                delete subkeys;
        }
};
 
 
struct Boundary
{
    long long int n;
    long long int m;
    size_t rows;
    size_t cols;
 
    Boundary(long long int i, long long int j, size_t _row, size_t _col) : n(i), m(j), rows(_row), cols(_col) {}
 
    long long int rf()
    {
        return n;
    }
 
    long long int re()
    {
        return n+rows;
    }
 
    long long int cf()
    {
        return m;
    }
 
    long long int ce()
    {
        return m+cols;
    }
};
 
#endif