#include <iostream>
#include <cmath>
#include <assert.h>

typedef float Scalar;

const Scalar EPSILON = 1e-4; 

class Vector {
public:
    Scalar x, y, z;

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

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

	// empty constructor
    Vector() : x(0), y(0), z(0) {}

    // Vector sum
    Vector sum(const Vector& b) const {
        Vector result;
        result.x = x + b.x;
        result.y = y + b.y;
        result.z = z + b.z;

        return result;
    }

    // Same as above, but defined as the overloading of operator "+"
    // Vector sum out of place
    Vector operator +(const Vector& b) const {
        return Vector(x + b.x, y + b.y,z + b.z);
    }

    // overloading of the binary "-" operator: 
    // Vector difference
    Vector operator -(const Vector& b) const {
        return Vector(x - b.x, y - b.y,z - b.z);
    }

    // overloading of the uniary "-" operator: 
	// Vector flip
    Vector operator -() const {
        return Vector(-x, -y, -z);
    }

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

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

    Vector operator /(Scalar k) const{
        return Vector(x/k, y/k, z/k);
    }

};

Vector operator *(Scalar x, const Vector& v){
    return v*x;
}

Scalar dot(const Vector& v, const Vector& w){
    return v.dot(w);
}

Scalar squaredLength(const Vector& v){
    return dot(v, v);
}

Scalar length(const Vector& v){
    return std::sqrt(squaredLength(v));
}

Vector normalized(const Vector& v){
    return v/length(v);
}

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

bool isZero(Scalar k){
    return (std::abs(k) < EPSILON);
}

bool isZero(const Vector& v){
    return isZero(v.x) && isZero(v.y) && isZero(v.z);
}

void unitTestCrossAndDot(){
    Vector a(5, 3, -6);
    Vector b(1, 1, 1);

    Vector c = cross(a, b);
    
    if(!isZero(dot(a, c))){
        std::cerr << "Error: cross(a,b) not orthogonal to a " << std::endl;
    }

    if(!isZero(dot(b, c))){
        std::cerr << "Error: cross(a,b) not orthogonal to b " << std::endl;
    }

    Vector d = cross(a,b) + cross(b,a);
    
    if(!isZero(d)){
        std::cerr << "Error: cross(a,b) not anticommutative " << std::endl;
        assert(false);
    }

    /*OPPURE: 
    assert(isZero(d) && "Error: cross(a,b) not anticommutative");*/
}

int main() {
    Vector a(5, 3, -6);
    Vector b(1, 1, 1);
    Vector c(6, -3, 5.0);
    // Vector t = v.sum(w);
    Vector d = a + b - c;

    d = -a;

    d.print();

    unitTestCrossAndDot();

    return 0;
}