Isometry object

.gitignore

@@ -32,4 +32,7 @@
 *.app
 
 # Build directory
-build/
+build/
+
+# vscode
+.vscode/

course/.gitignore

@@ -0,0 +1,2 @@
+/build
+/.vscode

course/.vscode/c_cpp_properties.json

@@ -0,0 +1,16 @@
+{
+    "configurations": [
+        {
+            "name": "Linux",
+            "includePath": [
+                "${workspaceFolder}/**"
+            ],
+            "defines": [],
+            "compilerPath": "/usr/bin/clang",
+            "cStandard": "c11",
+            "cppStandard": "c++17",
+            "intelliSenseMode": "clang-x64"
+        }
+    ],
+    "version": 4
+}

course/CMakeLists.txt

@@ -16,6 +16,9 @@ include_directories(
 # Library sources.
 set(LIBRARY_SOURCES
 	src/foo.cc
+	src/Vector3.cc
+	src/Matrix3.cc
+	src/isometry.cc
 )
 
 # Library creation.

course/include/Matrix3.h

@@ -0,0 +1,65 @@
+#pragma once
+#include <iostream>
+#include <cmath>
+#include "Vector3.h"
+
+namespace ekumen
+{
+
+    class Matrix3
+    {
+    public:
+        Matrix3();
+        explicit Matrix3(const Vector3 &f1, const Vector3 &f2, const Vector3 &f3);
+        Matrix3(const std::initializer_list<double> &list);
+        Matrix3(const std::initializer_list<double> &r1, const std::initializer_list<double> &r2, const std::initializer_list<double> &r3);
+        Matrix3(const Matrix3 &m);
+        Matrix3(Matrix3 &&m);
+
+        double det() const;
+        const Vector3 row(const int index) const;
+        Vector3 &row(const int index);
+        const Vector3 col(const int index) const;
+
+        Matrix3 mul(const Matrix3 &m2) const;
+        Matrix3 inverse() const;
+
+        Matrix3 &operator+=(const Matrix3 &q);
+        Matrix3 &operator-=(const Matrix3 &q);
+
+        Matrix3 &operator=(const Matrix3 &other);   // copy assignment
+        Matrix3 &operator=(Matrix3 &&other);    //move assignment
+
+        //operator overload
+        const Vector3 &operator[](const int &index) const;
+        Vector3 &operator[](const int &index);
+
+        friend bool operator==(const Matrix3 &p, const Matrix3 &q);
+        friend bool operator==(const Matrix3 &p, const std::initializer_list<double> &list);
+        friend bool operator==(const std::initializer_list<double> &list, const Matrix3 &p);
+
+        friend Matrix3 operator*(const double &cte, const Matrix3 &p);
+        friend Matrix3 operator*(const Matrix3 &p, const double &cte);
+        friend Matrix3 operator*(const Matrix3 &p, const Matrix3 &q);
+        friend Vector3 operator*(const Matrix3 &p, const Vector3 &v);
+
+        friend Matrix3 operator/(const Matrix3 &p, const Matrix3 &q);
+        friend Matrix3 operator/(const Matrix3 &p, const double &value);
+
+        friend bool operator!=(const Matrix3 &p, const Matrix3 &q);
+        friend bool operator!=(const Matrix3 &p, const std::initializer_list<double> &list);
+        friend bool operator!=(const std::initializer_list<double> &list, const Matrix3 &p);
+
+        friend std::ostream &operator<<(std::ostream &os, const Matrix3 &p);
+        static const Matrix3 kIdentity;
+        static const Matrix3 kZero;
+        static const Matrix3 kOnes;
+
+    private:
+        Vector3 *row_values = new Vector3[3];
+    };
+
+    Matrix3 operator+(const Matrix3 &p, const Matrix3 &q);
+    Matrix3 operator-(const Matrix3 &p, const Matrix3 &q);
+
+} // namespace ekumen

course/include/Vector3.h

@@ -0,0 +1,71 @@
+#pragma once
+#include <iostream>
+#include <cmath>
+#include <memory>
+#include <utility>
+
+namespace ekumen
+{
+
+    class Vector3
+    {
+    public:
+        Vector3();
+        explicit Vector3(const double x, const double y, const double z);
+        Vector3(const std::initializer_list<double> &list);
+        Vector3(const Vector3 &p2);     //copy constructor
+        Vector3(Vector3&& other);       //move constructor
+        ~Vector3();
+
+        const double &x() const { return values[0]; }
+        double &x() { return values[0]; }
+
+        const double &y() const { return values[1]; }
+        double &y() { return values[1]; }
+
+        const double &z() const { return values[2]; }
+        double &z() { return values[2]; }
+
+        double norm() const;
+        double dot(const Vector3 &q) const;
+        Vector3 cross(const Vector3 &q) const;
+        //operator overload
+        const double &operator[](const int index) const;
+        double &operator[](const int index);
+
+        Vector3 &operator+=(const Vector3 &q);
+        Vector3 &operator-=(const Vector3 &q);
+        Vector3 &operator=(const Vector3 &r);   // copy assignment
+        Vector3 &operator=(Vector3 &&other);    //move assignment
+
+        friend Vector3 operator*(const double &cte, const Vector3 &p);
+        friend Vector3 operator*(const Vector3 &p, const double &cte);
+        friend Vector3 operator*(const Vector3 &p, const Vector3 &q);
+        friend Vector3 operator/(const Vector3 &p, const Vector3 &q);
+
+        friend bool operator==(const Vector3 &p, const Vector3 &q);
+        friend bool operator==(const Vector3 &p, const std::initializer_list<double> &list);
+        friend bool operator==(const std::initializer_list<double> &list, const Vector3 &p);
+
+        friend bool operator!=(const Vector3 &p, const Vector3 &q);
+        friend bool operator!=(const Vector3 &p, const std::initializer_list<double> &list);
+        friend bool operator!=(const std::initializer_list<double> &list, const Vector3 &p);
+
+        friend std::ostream &operator<<(std::ostream &os, const Vector3 &p);
+
+        static const Vector3 kUnitX;
+        static const Vector3 kUnitY;
+        static const Vector3 kUnitZ;
+        static const Vector3 kZero;
+        static const Vector3 kOnes;
+
+    private:        
+        double *values;
+
+
+    };
+
+    Vector3 operator+(const Vector3 &p, const Vector3 &q);
+    Vector3 operator-(const Vector3 &p, const Vector3 &q);
+
+} // namespace ekumen

course/include/isometry.h

@@ -0,0 +1,39 @@
+#pragma once
+#include "Vector3.h"
+#include "Matrix3.h"
+#include <cmath>
+
+namespace ekumen
+{
+    class Isometry
+    {
+    public:
+        Isometry();
+        explicit Isometry(const Vector3 &v, const Matrix3 &m);
+        explicit Isometry(const std::initializer_list<double> &list, Matrix3 &m);
+
+        static Isometry FromTranslation(const std::initializer_list<double> &list);
+        static Isometry FromTranslation(const Vector3 &v);
+        static Isometry RotateAround(const Vector3 &v, const double &a);
+        static Isometry FromEulerAngles(const double &x, const double &y, const double &z);
+
+        Vector3 transform(const Vector3 &v) const;
+        Vector3 transform(const std::initializer_list<double> &list) const;
+        Isometry inverse() const;
+        Isometry compose(const Isometry &I1) const;
+        Vector3 translation() const;
+        Matrix3 rotation() const;
+
+        friend bool operator==(const Isometry &p, const Isometry &q);
+        friend bool operator!=(const Isometry &p, const Isometry &q);
+        friend std::ostream &operator<<(std::ostream &os, const Isometry &m);
+
+        friend Vector3 operator*(const Isometry &i, const Vector3 &v);
+        friend Isometry operator*(const Isometry &i, const Isometry &i2);
+
+    private:
+        Vector3 vector3_isometry;
+        Matrix3 matrix3_isometry;
+    };
+
+} // namespace ekumen