#include <bits/stdc++.h>
#include <boost/astronomy/coordinate/cartesian_representation.hpp>
#include <boost/geometry.hpp>
#include <boost/units/unit.hpp>
#include <boost/units/systems/si.hpp>

using namespace std;
namespace bu = boost::units;
namespace bg = boost::geometry;
namespace bac = boost::astronomy::coordinate;

// some quantity
typedef bu::quantity<bu::si::dimensionless, double> t;
typedef bu::quantity<bu::si::length, double> s;

/*
template class 
A : coordinate type
X : Xquantity
Y : Yquantity
Z : Zquantity
*/
template <class A, class X, class Y, class Z>
class affine
{
private:
    double tform[3][3]; // affine 3x3 matrix

public:
    //constructor initialises tform matrix
    affine(double tform[3][3]);

    // function that operates on cartesian representation vector and returns the answer
    bac::cartesian_representation<A, X, Y, Z> transform_affine(bac::cartesian_representation<A, X, Y, Z>);
};

// tform initialisation
template <class A, class X, class Y, class Z>
affine<A, X, Y, Z>::affine(double tform[3][3])
{
    for (int i = 0; i < 3; i++)
        for (int j = 0; j < 3; j++)
            this->tform[i][j] = tform[i][j];
}

// logic
template <class A, class X, class Y, class Z>
bac::cartesian_representation<A, X, Y, Z> affine<A, X, Y, Z>::transform_affine(bac::cartesian_representation<A, X, Y, Z> v)
{
    bac::cartesian_representation<A, X, Y, Z> res;
    X x;
    Y y;
    Z z;
    double r, temp[3], tres[3] = {0, 0, 0};
    temp[0] = v.get_x().value();
    temp[1] = v.get_y().value();
    temp[2] = v.get_z().value();
    v.get_x().value();
    for (int i = 0; i < 3; i++)
    {
        for (int j = 0; j < 3; j++)
            tres[i] += this->tform[i][j] * temp[j];
    }
    x = tres[0];
    res.set_x(x);
    return res;
}

int main()
{
    bac::cartesian_representation<int, t, t, t> x;
    double mat[3][3] = {
        {3, 0, 0},
        {0, 4, 0},
        {0, 0, 1}};

    affine<int, s, s, s> A(mat);
    A.transform_affine(x);
    return 0;
}