C'est pas trop mal

.gitignore

@@ -1,2 +1,3 @@
 .vscode
-.DS_Store
+.DS_Store
+OpenGL

Dessin.cc

@@ -0,0 +1,49 @@
+#include "Dessin.h"
+#include <vector>
+
+using namespace std;
+
+/****************************************************************
+ **                                                            **
+ **                    Fonctions de tracé                      **
+ **                                                            **
+ ****************************************************************/
+
+// Trace un point à partir de coordonnées
+void trace_point(double x, double y, double red, double green, double blue, double size)
+{
+    glColor3f(red, green, blue); // initialisation de la couleur
+    glPointSize(size);           // initialisation de la taille
+    glBegin(GL_POINTS);          // on trace un point
+    glVertex2f(x, y);            // coordonnees du point
+    glEnd();                     // fin de glBegin
+}
+
+// Trace un point à partir d'un objet Point
+void trace_point(Point p, double red, double green, double blue, double size)
+{
+    trace_point(p.getX(), p.getY(), red, green, blue, size);
+}
+
+// Trace un segement à partir des coordonnées des points
+void trace_segment(double x0, double y0, double x1, double y1, double red, double green, double blue, double size)
+{
+    glColor3f(red, green, blue); // initialisation de la couleur
+    glLineWidth(size);           // initialisation de la taille
+    glBegin(GL_LINES);           // on trace un segment
+    glVertex2f(x0, y0);          // coordonnees du premier point
+    glVertex2f(x1, y1);          // coordonnees du dernier point
+    glEnd();                     // fin de glBegin
+}
+
+// Trace un segment à partir de deux objets points
+void trace_segment(Point p0, Point p1, double red, double green, double blue, double size)
+{
+    trace_segment(p0.getX(), p0.getY(), p1.getX(), p1.getY(), red, green, blue, size);
+}
+
+// Trace un segment à partir d'un objet segment
+void trace_segment(Segment s, double red, double green, double blue, double size)
+{
+    trace_segment(s.getA(), s.getB(), red, green, blue, size);
+}

Dessin.h

@@ -0,0 +1,28 @@
+#ifndef __APPLE__
+#include <GL/glut.h>
+#else
+#include <GLUT/glut.h>
+#endif
+#include "Point.h"
+#include "Segment.h"
+
+/****************************************************************
+ **                                                            **
+ **                    Fonctions de tracé                      **
+ **                                                            **
+ ****************************************************************/
+
+// Trace un point à partir de coordonnées
+void trace_point(double x, double y, double red, double green, double blue, double size);
+
+// Trace un point à partir d'un objet Point
+void trace_point(Point p, double red, double green, double blue, double size);
+
+// Trace un segement à partir des coordonnées des points
+void trace_segment(double x0, double y0, double x1, double y1, double red, double green, double blue, double size);
+
+// Trace un segment à partir de deux objets points
+void trace_segment(Point p0, Point p1, double red, double green, double blue, double size);
+
+// Trace un segment à partir d'un objet segment
+void trace_segment(Segment s, double red, double green, double blue, double size);

FractionRationnelle.cc

@@ -1,96 +1,67 @@
 #include "FractionRationnelle.h"
+#include "Dessin.h"
 #include <cmath>
 #include <vector>
 #include <iostream>
 
+class Polynome;
+
 using namespace std;
 
 FractionRationnelle::FractionRationnelle()
 {
-    numerateur.push_back(1);
-    denominateur.push_back(1);
+    m_numerateur = Polynome();
+    m_denominateur = Polynome();
 }
 
-FractionRationnelle::FractionRationnelle(double num[], size_t taille_num, double denom[], size_t taille_denom)
+FractionRationnelle::FractionRationnelle(Polynome numerateur, Polynome denominateur)
 {
-    for (int i = 0; i < taille_num; i++)
-        numerateur.push_back(num[i]);
-
-    for (int i = 0; i < taille_denom; i++)
-        denominateur.push_back(denom[i]);
+    m_numerateur = numerateur;
+    m_denominateur = denominateur;
 }
 
-int FractionRationnelle::solve_denom(double &x1, double &x2)
+FractionRationnelle::FractionRationnelle(const vector<double> &numerateur, const vector<double> &denominateur)
 {
-    int degre = FractionRationnelle::get_degre(true);
-
-    if(degre == 2)
-    {
-        double delta = pow(denominateur[1], 2) - 4 * denominateur[2] * denominateur[0];
-
-        if(delta < 0)
-            return 0;
-        else if(delta == 0)
-        {
-            x1 = x2 = -(denominateur[1] / (2 * denominateur[2]));
-            return 1;
-        }
-        else
-        {
-            x1 = (-denominateur[1] + sqrt(delta)) / (2 * denominateur[2]);
-            x2 = (-denominateur[1] - sqrt(delta)) / (2 * denominateur[2]);
-
-            return 2;
-        }
-    }
-    else if(degre == 1)
-    {
-        x1 = x2 = -denominateur[1] / denominateur[2];
-        return 1;
-    }
-
-    return -1;
+    m_numerateur = Polynome(numerateur);
+    m_denominateur = Polynome(denominateur);
 }
 
-double FractionRationnelle::assymptote_h()
+FractionRationnelle::FractionRationnelle(double num[], size_t taille_num, double denom[], size_t taille_denom)
 {
-    double res = 0;
-
-    if(get_degre() == get_degre(true))
-    {
-        res = numerateur.back() / denominateur.back();
-    }
-
-    return res;
+    m_numerateur = Polynome(num, taille_num);
+    m_denominateur = Polynome(denom, taille_denom);
 }
 
-void divisionEuclidienne(double &m, double &p)
+void FractionRationnelle::assymptote_h()
 {
-
+    double res = 0;
 }
 
-int FractionRationnelle::get_degre(bool select)
+void FractionRationnelle::trace_assymptotes()
 {
-    if(select)
+    // Assymptote verticale(s)
+    double x1(0), x2(0);
+    int nb_racine = m_denominateur.solve(x1, x2);
+    if(nb_racine == 1)
+        trace_segment(x1, -100000, x1, 100000, 0, 200, 0, 2);
+    else if(nb_racine == 2)
     {
-        return denominateur.size() - 1;
+        trace_segment(x1, -100000, x1, 100000, 0, 200, 0, 2);
+        trace_segment(x2, -100000, x2, 100000, 0, 200, 0, 2);
     }
-    else
+
+    // Assymptote horizontale
+    if (m_numerateur.get_degre() == m_denominateur.get_degre())
     {
-        return numerateur.size() - 1;
+        double y = m_numerateur.get_last_coef() / m_denominateur.get_last_coef();
+        trace_segment(-100000, y, 100000, y, 0, 100, 0, 2);
     }
 }
 
-
 string FractionRationnelle::to_s()
 {
-    string res = "numérateur : ";
-    for (int i = 0; i < numerateur.size(); i++)
-        res += std::to_string(numerateur[i]) + " ";
-
-    res += "\ndenominateur : ";
-    for (int i = 0; i < denominateur.size(); i++)
-        res += std::to_string(denominateur[i]) + " ";
+    string resultat = "";
+    resultat += m_numerateur.to_s() + " / " + m_denominateur.to_s();
 
-    return res;
+    return resultat;
 }

FractionRationnelle.h

@@ -3,26 +3,29 @@
 
 #include <string>
 #include <vector>
+#include "Polynome.h"
 
 class FractionRationnelle
 {
-    public:
-        FractionRationnelle();
-        FractionRationnelle(double num[], size_t taille_num, double denom[], size_t taille_denom);
-        double getNumerateur() const;
-        double getDenominateur() const;
-        int solve_denom(double &x1, double &x2);
-        double assymptote_h();
-        void divisionEuclidienne(double &m, double &p);
+  public:
+    // Constructeurs
+    FractionRationnelle();
+    FractionRationnelle(Polynome numerateur, Polynome denominateur);
+    FractionRationnelle(const std::vector<double> &numerateur, const std::vector<double> &denominateur);
+    FractionRationnelle(double num[], size_t taille_num, double denom[], size_t taille_denom);
 
-        std::string to_s();
+    // Méthodes
+    double get_numerateur() const;
+    double get_denominateur() const;
+    void assymptote_h();
+    void trace_assymptotes();
 
-    private:
-
-        int get_degre(bool select = false);
+    // Méthodes d'affichage
+    std::string to_s();
 
-        std::vector<double> numerateur;
-        std::vector<double> denominateur;
+  private:
+    Polynome m_numerateur;
+    Polynome m_denominateur;
 };
 
 #endif