#ifndef __CUVECT3F_HPP__
#define __CUVECT3F_HPP__

namespace amscuda
{

    class cuvect3f
    {
        public:
        float x;
        float y;
        float z;

        __host__ __device__ cuvect3f();
        __host__ __device__ ~cuvect3f();
        __host__ __device__ cuvect3f(const float &_x, const float &_y, const float &_z);
        
        
        __host__ __device__ float& operator[](const int &I);
        __host__ __device__ const float& operator[](const int &I) const;

        __host__ __device__ cuvect3f operator+(const cuvect3f &rhs);
        __host__ __device__ cuvect3f operator-(const cuvect3f &rhs);
        __host__ __device__ cuvect3f operator*(const float &rhs);
        __host__ __device__ cuvect3f operator/(const float &rhs);
        __host__ __device__ friend cuvect3f operator-(const cuvect3f &rhs);

        __host__ __device__ cuvect3f& operator+=(const cuvect3f &rhs);
        __host__ __device__ cuvect3f& operator-=(const cuvect3f &rhs);
        __host__ __device__ cuvect3f& operator/=(const float &rhs);
        __host__ __device__ cuvect3f& operator*=(const float &rhs);

    };

    class cumat3f
    {
        public:
        float m00,m10,m20; //named references to force register use?
        float m01,m11,m21; //switched to column-major-order to match GLSL/lapack
        float m02,m12,m22;

        __host__ __device__ cumat3f();
        __host__ __device__ ~cumat3f();
        __host__ __device__ cumat3f(
            const float & _m00, const float & _m01, const float & _m02,
            const float & _m10, const float & _m11, const float & _m12,
            const float & _m20, const float & _m21, const float & _m22
        );

        __host__ __device__ float& operator[](const int &I);
        __host__ __device__ float& operator()(const int &I, const int &J);
        __host__ __device__ float& at(const int &I, const int &J);

        __host__ __device__ const float& operator[](const int &I) const;
        __host__ __device__ const float& operator()(const int &I, const int &J) const;
        __host__ __device__ const float& at(const int &I, const int &J) const;

        __host__ __device__ cumat3f operator+(const cumat3f &rhs);
        __host__ __device__ cumat3f operator-(const cumat3f &rhs);
        __host__ __device__ cumat3f operator*(const float &rhs);
        __host__ __device__ cumat3f operator/(const float &rhs);
        __host__ __device__ cuvect3f operator*(const cuvect3f &rhs);
        __host__ __device__ cumat3f operator*(const cumat3f &rhs);
        __host__ __device__ friend cumat3f operator-(const cumat3f &rhs);
        
        __host__ __device__ float det();
        __host__ __device__ cumat3f transpose();
        __host__ __device__ cumat3f inverse();

        __host__ __device__ float* data(); //pointer to float[9] representation of matrix
        __host__ __device__ const float* data() const; //pointer to float[9] representation of matrix

        //In place operations (to save GPU register use)
        __host__ __device__ cumat3f& operator+=(const cumat3f &rhs);
        __host__ __device__ cumat3f& operator-=(const cumat3f &rhs);
        __host__ __device__ cumat3f& operator/=(const float &rhs);
        __host__ __device__ cumat3f& operator*=(const float &rhs);
        __host__ __device__ cumat3f& operator*=(const cumat3f &rhs);
        
    };

    __host__ __device__ float cuvect3f_dot(const cuvect3f &a,const cuvect3f &b);
    __host__ __device__ cuvect3f cuvect3f_cross(const cuvect3f &a, const cuvect3f &b);
    __host__ __device__ float cuvect3f_norm(const cuvect3f &a);
    __host__ __device__ cuvect3f cuvect3f_normalize(const cuvect3f &a);
    __host__ __device__ cuvect3f cuvect3f_proj(const cuvect3f &a, const cuvect3f &b);

    __host__ __device__ cumat3f hodge_dual(const cuvect3f &vin);
    __host__ __device__ cuvect3f hodge_dual(const cumat3f &min);
    __host__ __device__ cumat3f rotmat_from_axisangle(const cuvect3f &axis, const float &angle);


    //3x3 matrix operations
    //matrix order is assumed to be mat[I,J] = mat[I+3*J]
    
    //transposes a 3x3 (9 element) matrix
    __host__ __device__ void mat3f_transpose(float *mat3inout);

    //copies src to dest
    __host__ __device__ void mat3f_copy(float *mat3f_dest, const float *mat3f_src);

    //returns determinant of 3x3 matrix
    __host__ __device__ float mat3f_det(float *mat3in);

    //inverts a 3x3 (9 element) matrix
    __host__ __device__ void mat3f_inverse(float *mat3inout);

    __host__ __device__ cuvect3f mat3f_mult(float *mat3in, const cuvect3f &cvin);
    __host__ __device__ void mat3f_mult(float *matina, float *matinb, float *matout);

    __host__ __device__ void mat3f_hodgedual(const cuvect3f &vecin, float *matout);
    __host__ __device__ void mat3f_hodgedual(float *matin, cuvect3f &vecout);

    //returns direction cosine rotation matrix from axis and angle
    __host__ __device__ void mat3f_rot_from_axisangle(cuvect3f axis, float angle, float *matout);

    __host__ void test_cudavectf_logic1();

};

#endif