/* here we define the variables of the system which
   we want to keep for each time within one structure */

class vec {
public:
    double comp[3];

// Define some standard ways of initializing,
// which allows us to write
//   vec x(1,0,0);

    vec() : comp{} {
    }

    vec(double x, double y, double z) {//: comp{x, y, z}
        comp[0] = x;
        comp[1] = y;
        comp[2] = z;
    }

// Define some standard functions one would like to have for vectors,
// which allows to do
//   double len=x.abs();

    double abs() const {
        return (sqrt(comp[0] * comp[0] + comp[1] * comp[1] + comp[2] * comp[2]));
    }

    double abs2() const {
        return (comp[0] * comp[0] + comp[1] * comp[1] + comp[2] * comp[2]);
    }

    double dot(const vec &v) const {
        return (comp[0] * v.comp[0] + comp[1] * v.comp[1] + comp[2] * v.comp[2]);
    }

// Cross product can be written as
//   vec z=x.cross(y);
    vec cross(const vec &v) const {
        return (vec(comp[1] * v.comp[2] - comp[2] * v.comp[1],
                    comp[2] * v.comp[0] - comp[0] * v.comp[2],
                    comp[0] * v.comp[1] - comp[1] * v.comp[0]));
    }

// Define some simple mathematical operators,
// which allows us to write things like
//   vec y=x*3;
    vec operator*(double d) const {
        return (vec(comp[0] * d, comp[1] * d, comp[2] * d));
    }

    vec operator/(double d) const {
        return (vec(comp[0] / d, comp[1] / d, comp[2] / d));
    }

    vec operator+(const vec &v) const {
        return (vec(comp[0] + v.comp[0],
                    comp[1] + v.comp[1],
                    comp[2] + v.comp[2]));
    }

    vec &operator+=(const vec &v) {
        this->comp[0] += v.comp[0];
        this->comp[1] += v.comp[1];
        this->comp[2] += v.comp[2];
        return *this;
    }

    vec operator-(const vec &v) const {
        return (vec(comp[0] - v.comp[0],
                    comp[1] - v.comp[1],
                    comp[2] - v.comp[2]));
    }
};

std::ostream &operator<<(ostream &os, const vec &v) {
    os << ' ' << v.comp[0] << ' '
       << v.comp[1] << ' '
       << v.comp[2] << ' ';
}

vec operator*(double d, const vec &v) {
    return v * d;
}


struct state {
    vec x, v, a;
    double m, t;
};