nombres rationnels

src/NR.cpp

@@ -0,0 +1,159 @@
+#include "NR.h"
+#include <iostream>
+
+int PGCD(int x, int y) {
+    if(x==0 || y==0)
+        return 1;
+    else if(x%y == 0)
+        return abs(y);
+    else
+        return PGCD(y, x%y);
+}
+
+NR::NR(int numerator, int denominator) {
+    NRset(numerator, denominator);
+}
+
+void NR::NRset(int numerator, int denominator) {
+    if(denominator > 0)
+        m_Numerator = numerator;
+    else
+        m_Numerator = (-1)*numerator;
+    if(denominator == 0) {
+        std::cout<<"Essaie de créer une fraction avec un dénominateur = 0, impossible"<<std::endl;
+        exit(EXIT_FAILURE);
+    }
+    else
+        m_Denominator = abs(denominator);
+}
+
+void NR::reduceNR() {
+    int divisor = PGCD(m_Denominator, m_Numerator);
+    m_Denominator /= divisor;
+    m_Numerator /= divisor;
+}
+
+void NR::invertNR() {
+    NRset(m_Denominator, m_Numerator);
+}
+
+int NR::NRgetNum() const {
+    return m_Numerator;
+}
+
+int NR::NRgetDen() const {
+    return m_Denominator;
+}
+
+NR& NR::operator =(const NR& opNR) {
+    NRset(opNR.NRgetNum(),opNR.NRgetDen());
+    return *this;
+}
+
+bool NR::operator ==(const NR& opNR) const {
+    return (m_Numerator * opNR.NRgetDen() == m_Denominator * opNR.NRgetNum());
+}
+
+bool NR::operator <(const NR& opNR) const {
+    return (m_Numerator * opNR.NRgetDen() < m_Denominator * opNR.NRgetNum());
+}
+
+bool NR::operator >(const NR& opNR) const {
+    return (m_Numerator * opNR.NRgetDen() > m_Denominator * opNR.NRgetNum());
+}
+
+bool NR::operator !=(const NR& opNR) const {
+    return (not (*this == opNR));
+}
+
+bool NR::operator <=(const NR& opNR) const {
+    return (not (*this > opNR));
+}
+
+bool NR::operator >=(const NR& opNR) const {
+    return (not (*this < opNR));
+}
+
+std::ostream& operator <<(std::ostream& os, const NR& opNR) {
+    os<<opNR.NRgetNum()<<"/"<<opNR.NRgetDen();
+    return os;
+}
+
+std::istream& operator >>(std::istream& is, NR& opNR) {
+    int num, den;
+    std::cout<<"Numerator: ";
+    is>>num;
+    std::cout<<"Denominator: ";
+    is>>den;
+    opNR.NRset(num, den);
+    return is;
+}
+
+NR NR::operator +(const NR& opNR) const {
+    int num, den;
+    num = m_Numerator * opNR.NRgetDen();
+    den = m_Denominator * opNR.NRgetDen();
+    num += (opNR.NRgetNum() *  m_Denominator);
+    NR result(num, den);
+    return result;
+}
+
+NR NR::operator -(const NR& opNR) const {
+    int num, den;
+    num = m_Numerator * opNR.NRgetDen();
+    den = m_Denominator * opNR.NRgetDen();
+    num -= (opNR.NRgetNum() *  m_Denominator);
+    NR result(num, den);
+    return result;
+}
+
+NR NR::operator *(const NR& opNR) const {
+    int num, den;
+    num = m_Numerator * opNR.NRgetNum();
+    den = m_Denominator * opNR.NRgetDen();
+    NR result(num, den);
+    return result;
+}
+
+NR NR::operator /(const NR& opNR) const {
+    int num, den;
+    num = m_Numerator * opNR.NRgetDen();
+    den = m_Denominator * opNR.NRgetNum();
+    NR result(num, den);
+    return result;
+}
+
+void NR::test() {
+    NR* frac = new NR;
+    NR frac2(3);
+    NR frac3(2,5);
+    int a, b;
+    std::cout<<"PGCD : entrez deux entiers"<<std::endl;
+    std::cin>>a>>b;
+    std::cout<<PGCD(a,b)<<std::endl;
+    std::cout<<"frac : entrez deux entiers"<<std::endl;
+    std::cin>>a>>b;
+    NR fractest(a, b);
+    std::cout<<fractest<<" + "<<frac3<<" = "<<std::endl;
+    std::cout<<">> "<<(fractest + frac3)<<std::endl;
+    std::cout<<">> "<<(fractest + frac3).NRgetNum()<<"/"<<(fractest + frac3).NRgetDen()<<std::endl;
+    fractest = fractest + frac3;
+    std::cout<<">> "<<fractest<<std::endl;
+    frac->NRset(2, 4);
+    NR anotherfrac;
+    std::cin>>anotherfrac;
+    std::cout<<"Compare "<<fractest<<" and "<<anotherfrac<<" : ==? "<<(fractest == anotherfrac)<<" <? "<<(fractest < anotherfrac)<<" >=? "<<(fractest >= anotherfrac)<< std::endl;
+    std::cout<<anotherfrac<<" - "<<*frac<<" = "<<anotherfrac - *frac<<std::endl;
+    std::cout<<anotherfrac<<" * "<<*frac<<" = "<<std::endl<<">> "<<anotherfrac * *frac<<std::endl;
+    fractest = anotherfrac * *frac;
+    std::cout<<">> "<<fractest<<std::endl;
+    fractest.reduceNR();
+    std::cout<<">> "<<fractest<<std::endl;
+    std::cout<<anotherfrac<<" / "<<frac2<<" = "<<anotherfrac / frac2<<std::endl;
+    NR numNR(2,4);
+    NR otherNR(3,1);
+    std::cout<<numNR<<" - "<<otherNR<<" = "<<std::endl;
+    NR subNR = numNR - otherNR;
+    std::cout<<">> "<<(numNR - otherNR)<<std::endl<<">> "<<subNR<<std::endl;
+    delete frac;
+}

src/NR.h

@@ -1,12 +1,42 @@
 #pragma once
 
+#include <iostream>
+
 class NR {
   private:
 	int m_Numerator;
-	int m_Denominator;
+	int m_Denominator; //has to be > 0, sign is carried by the numerator
 
   public:
 	NR() : m_Numerator(0), m_Denominator(1) {}
 	NR(int entier) : m_Numerator(entier), m_Denominator(1) {}
-	NR(int numerator, int denominator) : m_Numerator(numerator), m_Denominator(denominator) {}
-};
+	NR(int numerator, int denominator); //check if denominator != 0
+	void NRset(int numerator, int denominator); //same
+
+	void reduceNR(); //divide by PGCD, not automatically called yet
+	void invertNR();
+
+	int NRgetNum() const;
+	int NRgetDen() const;
+	NR& operator =(const NR& opNR);
+
+	bool operator ==(const NR& opNR) const;
+	bool operator <(const NR& opNR) const;
+	bool operator >(const NR& opNR) const;
+
+	bool operator !=(const NR& opNR) const;
+	bool operator <=(const NR& opNR) const;
+	bool operator >=(const NR& opNR) const;
+
+	friend std::ostream& operator <<(std::ostream& os, const NR& opNR);
+	friend std::istream& operator >>(std::istream& os, NR& opNR);
+
+	NR operator +(const NR& opNR) const;
+	NR operator -(const NR& opNR) const;
+	NR operator *(const NR& opNR) const;
+	NR operator /(const NR& opNR) const;
+
+	static void test();
+};
+
+int PGCD(int x, int y);

src/main.cpp

@@ -1,4 +1,5 @@
 #include "Matrix.h"
+#include "NR.h"
 #include <iostream>
 
 void test() {
@@ -38,7 +39,8 @@ void prompt() {
 }
 
 int main(int argc, char** argv) {
-	test();
-	prompt();
+	//test();
+	//prompt();
+	NR::test();
 	return 0;
 }