Implementáld az alábbi 2ds matematikai vektor osztályt:

------------------------------------------------|
|  class Vector2                                |
|-----------------------------------------------|
| + x : float                                   |  -> Nincs getter, és szetter, mert azok lassítanának. (Függvényhívásnak van minimális erőforrás igénye) 
| + y : float                                   |  -> Ilyen matematikai osztályoknál, érdemes ilyeneket kioptimalizálni. PLussz leírni is sok. getx(), setx() etc.
| + abs() : Vector2                             |  -> visszaadja egy új vektorba ennek a vektornak az abszolút értékét. (x, y abszolút értékét veszi)
|                                               |      Abszolút érték képlet:  ha egy a < 0 ret -a, else ret a;
| + angle() float                               |  -> atan2(x, y)
| + angle_to(b : Vector2) : float               |  -> atan2(cross(b), dot(b));
| + cross(b : Vector2) : float                  |  -> Cross product -> x * b.y - y * b.x;
| + clamped(len : float) : Vector2              |  -> normalized() * len
| + direction_to(b : Vector2) : Vector2         |  -> Visszaad egy normalizált vektort ami ebből b be mutat. (A képlet: (b - a).normalized()) (operator-)
| + distance_to_squared(b : Vector2) : float    |  -> (x - b.x) * (x - b.x) + (y - b.y) * (y - b.y);
| + distance_to(b : Vector2) : float            |  -> sqrt((x - b.x) * (x - b.x) + (y - b.y) * (y - b.y));
| + dot(b : Vector2) : float                    |  -> dot product -> Ha a 2 vektor 90 fokosz szöget zár be, akkor 0.
|                                               |         Pozitív, ha a 2 vektor által bezárt szög kisebb mint 90 fok, negatív, ha nagyobb.
|                                               |         képlet: x * b.x + y * b.y.
| + is_equal_approx(b : Vector2) : bool         |  -> nagyjából egyenlőek-e a vektorok. A max különbség legyen 0.00001 (Epszilon).
| + length() : float                            |  -> sqrt(x * x + y * y)
| + length_squared() : float                    |  -> A hossz a gyökvonás nélkül. (A gyökvonás relatíve lassú, és ha csak össze kell 
|                                               |                         hasonlítani hosszakat, akkor elég így)
| + lerp(b : Vector2, t : float) : Vector2      |  -> Linear interpolate -> a jelenlegi vektor és b közötti átmenetvektort adja vissza t paraméter felhasználásával.
|                                               |     A t 0 és 1 közötti. Képlet: newx = x + (t * (b.x - x)); és newy = y + (t * (b.y - y));
| + normalized() : Vector2                      |  -> A vektor normalizálva. Normalizált vektor = a hossza 1. 
|                                               |     float l = length_squared(); ha nem 0, gyököt kell vonni belőle, és le kell osztani x, y-t is vele
| + normalize()                                 |  -> Maga a vektor normalizálódik.
| + add(b: Vector2)                             |  -> x += b.x, y += b.y
| + sub(b: Vector2)                             |  -> x -= b.x, y -= b.y
| + operator+=(b: Vector2)                      |     etc
| + operator-=(b: Vector2)                      |
| + operator+(a: Vector2, b: Vector2) : Vector2 |
| + operator-(a: Vector2, b: Vector2) : Vector2 |
| + operator*=(b: float)                        |  -> x és y-t is megszorozzuk b-vel.
| + operator*(Vector2 a, float b) : Vector2     |  -> x és y-t is megszorozzuk b-vel.
| + operator==(b: Vector2, b: Vector2) : bool   |
| + operator!=(b: Vector2, b: Vector2) : bool   |
| + Vector2()                                   |
| + Vector2(b : Vector2)                        |
| + Vector2(x : float, y : float)               |
------------------------------------------------|