Dual Quaternion project added

QuaternionDual/QuaternionDual.cpp

@@ -0,0 +1,123 @@
+/* En-tête pour les classes
+ * de quaternion dual.
+ */
+#include "QuaternionDual.hpp"
+/* Méthodes Dual. */
+/* Constructeur. */
+Dual::Dual(void)
+{
+  setReal(1) ;
+  setDual(1) ;
+}
+/* Constructeur. */
+Dual::Dual(double r, double d)
+{
+  setReal(r) ;
+  setDual(d) ;
+}
+/* Accesseurs. */
+double Dual::getReal(void)
+{
+  return __r ;
+}
+double Dual::getDual(void)
+{
+  return __d ;
+}
+/* Mutateur. */
+void Dual::setReal(double r)
+{
+  __r = r ;
+}
+void Dual::setDual(double d)
+{
+  __d = d ;
+}
+/* Affichage */
+void Dual::show(void)
+{
+  std::cout << "Dual[" << getReal() << "]"
+            << "[" << getDual() << "]]"
+            << std::endl ;
+}
+/* Méthodes Quaternion. */
+/* Constructeurs. */
+Quaternion::Quaternion(void)
+{
+  setScalar(1) ;
+  setX(1) ;
+  setY(1) ;
+  setZ(1) ;
+  setVector(1,1) ;
+}
+Quaternion::Quaternion(double t, double x, double y, double z)
+{
+  setScalar(t) ;
+  setX(x) ;
+  setY(y) ;
+  setZ(z) ;
+  setVector(1,1,1,1) ;
+}
+Quaternion::Quaternion(double v[4])
+{
+  setScalar(v[0]) ;
+  setX(v[1]) ;
+  setY(v[2]) ;
+  setZ(v[3]) ;
+  setVector(v) ;
+}
+Quaternion::Quaternion(vector4 vec)
+{
+  setScalar(vec[0]) ;
+  setX(vec[1]) ;
+  setY(vec[2]) ;
+  setZ(vec[3]) ;
+  setVector(vec) ;
+}
+/* Accesseurs */
+double Quaternion::getScalar(void)
+{
+  return __t
+}
+double Quaternion::getX(void)
+{
+  return __x
+}
+double Quaternion::getY(void)
+{
+  return __y
+}
+double Quaternion::getZ(void)
+{
+  return __z
+}
+vector4 Quaternion::getVector(void)
+{
+  return __vec
+}
+/* Mutateurs */
+void  setScalar(double t) ;
+{
+  __t = t ;
+}
+void setX(double x) ;
+{
+  __x = x ;
+}
+void setY(double y) ;
+{
+  __y = y ;
+}
+void setZ(double z) ;
+{
+  __z = z ;
+}
+void setVector(double t, double x, double y, double z) ;
+{
+  vector4 vec = {t, x, y, z} ;
+  __vec = vec ;
+}
+void setVector(double* v)
+{
+  vector4 vec(v) ;
+  __vec = vec ;

QuaternionDual/QuaternionDual.hpp

@@ -0,0 +1,112 @@
+/*************************\
+|  Quaternions            |
+\*************************/
+/*
+g++ -std=c++17 -o QuaternionDual main.cpp QuaternionDual.cpp
+*/
+#ifndef QUATERNIONS_HPP
+#define QUATERNIONS_HPP
+/* En-tête de la bibliothèque standard :
+ * Entrées et sortie en C++.
+ */
+#include <iostream>
+/* En-tête de la bibliothèque standard :
+ * Chaînes de caractère en C++.
+ */
+#include <string>
+/* 
+ * Vecteurs C++.
+ */
+#include <vector>
+/*
+ * Tableaux C++.
+ */
+#include <array>
+/* Header Guard.
+ * Pour éviter de redéfinir.
+ * Tout le code de l'en-tête est dedans.
+ */
+typedef std::array<double, 2> vector2;
+typedef std::array<double, 4> vector4 ;
+/* Classe 'Dual'. */
+class Dual
+{
+/* Partie verrouillée (héritable). */
+protected:
+  double __r ;// Réel.
+  double __d ;// Dual.
+/* Partie accessible (héritable). */
+public:
+  /* Constructeur. */
+  Dual(void) ;
+  Dual(double r, double d) ;
+  /* Destructeur. */
+  ~Dual(void) ;
+  /* Lecture. */
+  double getReal(void) ;
+  double getDual(void) ;
+  /* Écriture. */
+  void setReal(double r) ;
+  void setDual(double d) ;
+  /* Affichage. */
+  void show(void);
+};
+/* Header Guard.
+ * Pour éviter de redéfinir.
+ * Tout le code de l'en-tête est dedans.
+ */
+/* Classe 'Quaternion'. */
+class Quaternion
+{
+/* Partie protégée (héritable). */
+protected:
+  double __t ;// scalaire.
+  /* Éléments de vecteur. */
+  double __x ;
+  double __y ;
+  double __z ;
+  /* Vecteur. */
+  vector4 __vec ;
+public:
+/* Partie publique (accessible) */
+  /* Constructeurs. */
+  Quaternion(void) ;
+  Quaternion(double t, double x, double y, double z) ;
+  Quaternion(double* v) ;
+  Quaternion(vector4 vec) ;
+  /* Destructeur. */
+  ~Quaternion(void) ;
+  /* Accesseurs. */
+  double getScalar(void) ;
+  double getX(void) ;
+  double getY(void) ;
+  double getZ(void) ;
+  vector4 getVector(void) ;
+  /* Mutateurs. */
+  void setScalar( double t) ;
+  void setX(double x) ;
+  void setY(double y) ;
+  void setZ(double z) ;
+  void setVector(double t, double x, double y, double z) ;
+  void setVector(double *v) ;
+  void setVector(vector4 vec) ;
+  /* Affichage. */
+  void show(void) ;
+};
+/* Header Guard.
+ * Pour éviter de redéfinir.
+ * Tout le code de l'en-tête est dedans.
+ */
+/* Classe 'Quaternion dual'. */
+class QuaternionDual : protected Quaternion
+{
+/* Partie verrouillée (héritable). */
+protected:
+/* Partie accessible (héritable). */
+public:
+  /* Constructeur. */
+  QuaternionDual(void) ;
+  /* Destructeur. */
+  ~QuaternionDual(void) ;
+};
+#endif//QUATERNIONS_HPP

QuaternionDual/main.cpp

@@ -0,0 +1,18 @@
+/* Code principal. */
+/* Import de l'en-tête. */
+#include "QuaternionDual.hpp"
+/* Fonction principale. */
+int main(int argc, char** argv)
+{
+  std::cout << "Début";
+  Quaternion q();
+  q.setX(7);
+  std::cout << "Vecteur : ";
+  for(auto n : q.getVector())
+  {
+    std::cout << n << " ";
+  }
+  std::cout << ".\n";
+  std::cout << "Fin" << std::endl;
+  return EXIT_SUCCESS ;
+}