#include <iostream>

typedef float Scalar;

class Vector
{
public:
    Scalar x,y,z;
    Vector(): x(0),y(0),z(0)
    {
    }

    Vector(Scalar _x, Scalar _y, Scalar _z) : x(_x),y(_y),z(_z)
    {
    }

    Vector sum(const Vector& v) const
    {
        return Vector(x + v.x, y + v.y, z + v.z);
    }

    Vector operator +(const Vector& v) const
    {
        return Vector(x + v.x, y + v.y, z + v.z);
    }

    Vector operator *(Scalar a) const
    {
        return Vector(x * a, y * a, z * a);
    }

    // unitary minus (aka flip)
    Vector operator - () const{
        return Vector (-x, -y,-z);
    }

    // binary minus (aka vector difference)
    Vector operator - (const Vector& b) {
        return Vector( x - b.x, y - b.y, z - b.z );
    }

    void print() const
    {
        std::cout << "(" << x << ", " << y << ", " << z << ")" << std::endl;
    }
};

// commutative closure
inline Vector operator *( float k, const Vector& v){
    return v * k;
}

Vector mix (const Vector& a, const Vector& b, float t){
    return (1-t)*a + t*b;
}

Scalar dot (const Vector& a, const Vector& b){
    return a.x*b.x + a.y*b.y + a.z*b.z;
}

Vector cross (const Vector& a, const Vector& b){
    return Vector(
        a.y*b.z - a.z*b.y ,
        a.z*b.x - a.x*b.z ,
        a.x*b.y - a.y*b.x
    );
}

bool unitTestForCrossAndDot(){
    Vector a (3,-3,2);
    Vector b (0.5, -1, 6);

    Vector c = cross(a,b);

    Scalar k0 = dot(a,c);
    Scalar k1 = dot(b,c);

    std::cout << k0 << ',' << k1 << std::endl;

    return true;

}

int unitTest()
{
    std::cout << "Hello World!" << std::endl;
    Vector v;
    v.x = 4;
    v.y = -5;
    v.z = 0.5f;

    Vector w(1, -2, 0.3f);

    float d = dot( v , w );

    Vector r = v + w;
    Vector t = v.operator+(w);
    r.print();

    r = -r;
    r.print();
    Vector mv = mix(v,-v,0.5f);
    mv.print();
    return 0;
}

int main()
{
    unitTestForCrossAndDot();
}