#include <iostream>

/*
 * Vec3:
 * A class to represent a 3D VECTOR
 * (maybe also a 3D point and 3D versor? we'll see)
 */
struct Vec3{

    // fields (the 3 coordinates)
    double x;
    double y;
    double z;

    Vec3(double _x, double _y, double _z): x(_x), y(_y), z(_z){}

    Vec3():x(0), y(0), z(0) {} // by default, we use the degenerate vector (all zeros)


    /* vector algebra: scaling */

    // in-place (method)
    void scale(double k){
        x *= k;
        y *= k;
        z *= k;
    }

    // in-place (operator)
    void operator *=(double k){
        x *= k;
        y *= k;
        z *= k;
    }

    // out of place (method)
    Vec3 scaled(double k) const{
        return Vec3(x*k, y*k, z*k);
    }

    // out of place (operator)
    Vec3 operator *(double k) const{
        return Vec3(x*k, y*k, z*k);
    }


    /* vector algebra: vector sum */

    // out-of-place (method)
    Vec3 added(const Vec3 &b) const{
        return Vec3(x + b.x, y+ b.y, z + b.z );
    }

    // out-of-place (operator)
    Vec3 operator +(const Vec3 &b) const{
        return Vec3(x + b.x, y+ b.y, z + b.z );
    }

    // in-place (method)
    void add(const Vec3 &b) {
        x += b.x;
        y += b.y;
        z += b.z;
    }

    // in-place (operator)
    void operator += (const Vec3 &b) {
        x += b.x;
        y += b.y;
        z += b.z;
    }

    void debug_print() const{
        std::cout<<"X:" << x << " Y:" << y << " Z:" <<z <<std::endl;
    }
};

int main(){
    // code example 1
    Vec3 p(5.0, 6, 7);
    Vec3 q;

    p.scale(4.0);
    p.debug_print();

    q = p.scaled(5.0);
    q.debug_print();

    // code example 2: let's update a *position* by moving it *3.5* times in a given *direction* ...
    Vec3 position(5,5,5);
    Vec3 direction(0,1,2);

    // using methods:
    position = position.added(direction.scaled(3.5));

    // OR, equivalently, using operators:
    position = position + direction * 3.5;

    // OR, using in-place methods
    position.add(direction.scaled(3.5));

    // OR, using in-place operators
    position += direction * 3.5;

    return 0;
}