TriangularMatrix.h

#ifndef TRIANGULARMATRIX_HPP
#define TRIANGULARMATRIX_HPP
#include <vector>
#include <cstdlib>

template <typename T> class TriangularMatrix
{
private:
    std::vector<T> stuff;
    size_t width;
public:
    struct Position {
        size_t x;
        size_t y;
        Position(size_t nx, size_t ny) {
        x = ny;
        y = ny;
        }
    };
    size_t getWidth() const { return width; }
    size_t absolutePosition(Position& pos);
    size_t absolutePosition(size_t x, size_t y);
    TriangularMatrix(size_t x);
    T& at(size_t x, size_t y);
    T& operator()(size_t x, size_t y);
    void resize(size_t newwidth);
    std::vector<T>& getRawVector();
};

template <typename T> TriangularMatrix<T>::TriangularMatrix(size_t x)
    : stuff( (x + 1)*x/2  )
{
    width = x;
}
#define TRIANGLE_MATRIX_FUNC(ret,name) template <typename T> ret TriangularMatrix<T>::name

TRIANGLE_MATRIX_FUNC(std::vector<T>&,getRawVector)()
{
    return stuff;
}
TRIANGLE_MATRIX_FUNC(size_t,absolutePosition)(Position& pos)
{
    //return pos.x*(pos.x+1)/2+pos.y;
    if(pos.y >= pos.x) return pos.x + (pos.y+1)*pos.y/2;
    else return pos.y + (pos.x+1)*pos.x/2;
}
TRIANGLE_MATRIX_FUNC(size_t,absolutePosition)(size_t x, size_t y)
{
    if(y >= x) return x + (y+1)*y/2;
    else return y + (x+1)*x/2;
}
TRIANGLE_MATRIX_FUNC(T&,at)(size_t x, size_t y)
{
    return stuff[absolutePosition(x,y) ];
}
TRIANGLE_MATRIX_FUNC(T&,operator())(size_t x, size_t y)
{
    return stuff[absolutePosition(x,y) ];
}
void resize(size_t newwidth);
TRIANGLE_MATRIX_FUNC(void,resize)(size_t newwidth)
{
    stuff.resize( (newwidth + 1)*newwidth/2 );
}

#undef TRIANGLE_MATRIX_FUNC
#endif // TRIANGULARMATRIX_HPP