API tools faq
paste
Advertisement
Guest User

Untitled

a guest
May 25th, 2016
53
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
text 9.49 KB | None | 0 0
raw download clone embed print report
  1. #include "Litterale.h"
  2.  
  3.  
  4.  
  5. void Rationnelle::simplification() {
  6. // si le numerateur est 0, le denominateur prend la valeur 1
  7. if (num.getVal() == 0) {
  8. den = 1;
  9. return;
  10. }
  11. /* un denominateur ne devrait pas être 0;
  12. si c’est le cas, on sort de la méthode */
  13. if (num.getVal() == 0)
  14. return;
  15. /* utilisation de l’algorithme d’Euclide pour trouver le Plus Grand Commun
  16. Denominateur (PGCD) entre le numerateur et le denominateur */
  17. Entiere a(num);
  18. Entiere b(den);
  19. // on ne travaille qu’avec des valeurs positives...
  20. if (a.getVal() < 0)
  21. a.neg();
  22. if (b.getVal() < 0)
  23. b.neg();
  24. while (a.getVal() != b.getVal()) {
  25. if (a.getVal() > b.getVal())
  26. a.setVal(a.getVal() - b.getVal());
  27. else
  28. b.setVal(b.getVal() - a.getVal());
  29. }
  30. // on divise le numerateur et le denominateur par le PGCD=a
  31. num.setVal(num.getVal() / a.getVal());
  32. den.setVal(den.getVal() / a.getVal());
  33. // si le denominateur est négatif, on fait passer le signe - au denominateur
  34. if (den.getVal()<0) {
  35. den.neg();
  36. num.neg();
  37. }
  38. }
  39.  
  40.  
  41. // OPERATION SUR LITTERALE ENTIERE
  42.  
  43. Reelle operator+(Entiere e, Reelle r) {
  44. return Reelle((double)e.getVal() + r.getVal());
  45. }
  46.  
  47. Entiere operator+(Entiere e1, Entiere e2) {
  48. return Entiere(e1.getVal() + e2.getVal());
  49. }
  50.  
  51. Rationnelle operator+(Entiere e, Rationnelle r) {
  52. return Rationnelle(e.getVal()*r.getDen().getVal() + r.getNum().getVal(), r.getDen().getVal());
  53. }
  54.  
  55.  
  56. // OPERATION SUR LITTERALE RATIONNELLE
  57.  
  58. Reelle operator+(Rationnelle ra, Reelle re) {
  59. return Reelle(ra.toReelle().getVal() + re.getVal());
  60. }
  61.  
  62. Rationnelle operator+(Rationnelle r1, Rationnelle r2) {
  63. return Rationnelle(r1.getNum().getVal()*r2.getDen().getVal() + r2.getNum().getVal()*r1.getDen().getVal(), r1.getDen().getVal()*r2.getDen().getVal());
  64. }
  65.  
  66. Rationnelle operator+(Rationnelle r, Entiere e) {
  67. return Rationnelle(e.getVal()*r.getDen().getVal() + r.getNum().getVal(), r.getDen().getVal());
  68. }
  69.  
  70.  
  71. // OPERATION SUR LITTERALE REELLE
  72.  
  73. Reelle operator+(Reelle r1, Reelle r2) {
  74. return Reelle(r1.getVal() + r2.getVal());
  75. }
  76.  
  77. Reelle operator+(Reelle re, Rationnelle ra) {
  78. return Reelle(ra.toReelle().getVal() + re.getVal());
  79. }
  80.  
  81. Reelle operator+(Reelle r, Entiere e) {
  82. return Reelle((double)e.getVal() + r.getVal());
  83. }
  84.  
  85. // OPERATION SUR LITTERALE COMPLEXE
  86.  
  87. Complexe operator+(Complexe& c, Entiere e) {
  88. return c;
  89. }
  90.  
  91.  
  92.  
  93.  
  94. Litterale* operator+(Litterale& l1, Litterale& l2) {
  95.  
  96. // Recherche du type de la première litterale
  97. TypeLitterale type1 = l1.getType();
  98. // Recherche du type de la deuxieme litterale
  99. TypeLitterale type2 = l2.getType();
  100.  
  101. /*****************************************************************************************/
  102.  
  103. // Si la première litterale est un entier
  104. if (type1 == tEntiere) {
  105. Entiere* pt1 = dynamic_cast<Entiere*>(&l1);
  106. // Et que la deuxième est un entier
  107. if (type2 == tEntiere) {
  108. Entiere* pt2 = dynamic_cast<Entiere*>(&l2);
  109. return (new Entiere(pt1->getVal() + pt2->getVal()));
  110. }
  111. // Et que la deuxième est un reel
  112. if (type2 == tReelle) {
  113. Reelle* pt2 = dynamic_cast<Reelle*>(&l2);
  114. return (new Reelle((double)pt1->getVal() + pt2->getVal()));
  115. }
  116. // Et que la deuxième est un rationnel
  117. if (type2 == tRationnelle) {
  118. Rationnelle* pt2 = dynamic_cast<Rationnelle*>(&l2);
  119. return (new Rationnelle(pt1->getVal()*pt2->getDen().getVal() + pt2->getNum().getVal(), +pt2->getDen().getVal()));
  120. }
  121. // Et que la deuxième est un complexe
  122. if (type2 == tComplexe) {
  123. Complexe* pt2 = dynamic_cast<Complexe*>(&l2);
  124. Numerique* pRe = pt2->getRe();
  125. // Et que la partie réelle du complexe est un entier
  126. if (pRe->getType() == tEntiere) {
  127. Entiere* pt3 = dynamic_cast<Entiere*>(pRe);
  128. Entiere* newpRe = new Entiere(pt1->getVal() + pt3->getVal());
  129. return (new Complexe(newpRe, pt2->getIm()));
  130. }
  131. // Et que la partie réelle du complexe est un reel
  132. if (pRe->getType() == tReelle) {
  133. Reelle* pt3 = dynamic_cast<Reelle*>(pRe);
  134. Reelle* newpRe = new Reelle((double)pt1->getVal() + pt3->getVal());
  135. return (new Complexe(newpRe, pt2->getIm()));
  136. }
  137. // Et que la partie réelle du complexe est un rationnel
  138. if (pRe->getType() == tRationnelle) {
  139. Rationnelle* pt3 = dynamic_cast<Rationnelle*>(pRe);
  140. Rationnelle* newpRe = new Rationnelle(pt1->getVal()*pt3->getDen().getVal() + pt3->getNum().getVal(), +pt3->getDen().getVal());
  141. return (new Complexe(newpRe, pt2->getIm()));
  142. }
  143. }
  144. }
  145.  
  146. /*****************************************************************************************/
  147.  
  148. // Si la première litterale est un reel
  149. if (type1 == tReelle) {
  150. Reelle* pt1 = dynamic_cast<Reelle*>(&l1);
  151. // Et que la deuxième est un entier
  152. if (type2 == tEntiere) {
  153. Entiere* pt2 = dynamic_cast<Entiere*>(&l2);
  154. return (new Reelle(pt1->getVal() + (double)pt2->getVal()));
  155. }
  156. // Et que la deuxième est un reel
  157. if (type2 == tReelle) {
  158. Reelle* pt2 = dynamic_cast<Reelle*>(&l2);
  159. return (new Reelle(pt1->getVal() + pt2->getVal()));
  160. }
  161. // Et que la deuxième est un rationnel
  162. if (type2 == tRationnelle) {
  163. Rationnelle* pt2 = dynamic_cast<Rationnelle*>(&l2);
  164. return (new Reelle(pt1->getVal() + pt2->toReelle().getVal()));
  165. }
  166. // Et que la deuxième est un complexe
  167. if (type2 == tComplexe) {
  168. Complexe* pt2 = dynamic_cast<Complexe*>(&l2);
  169. Numerique* pRe = pt2->getRe();
  170. // Et que la partie réelle du complexe est un entier
  171. if (pRe->getType() == tEntiere) {
  172. Entiere* pt3 = dynamic_cast<Entiere*>(pRe);
  173. Reelle* newpRe = new Reelle(pt1->getVal() + (double)pt3->getVal());
  174. return (new Complexe(newpRe, pt2->getIm()));
  175. }
  176. // Et que la partie réelle du complexe est un reel
  177. if (pRe->getType() == tReelle) {
  178. Reelle* pt3 = dynamic_cast<Reelle*>(pRe);
  179. Reelle* newpRe = new Reelle(pt1->getVal() + pt3->getVal());
  180. return (new Complexe(newpRe, pt2->getIm()));
  181. }
  182. // Et que la partie réelle du complexe est un rationnel
  183. if (pRe->getType() == tRationnelle) {
  184. Rationnelle* pt3 = dynamic_cast<Rationnelle*>(pRe);
  185. Reelle* newpRe = new Reelle(pt1->getVal() + pt3->toReelle().getVal());
  186. return (new Complexe(newpRe, pt2->getIm()));
  187. }
  188. }
  189. }
  190.  
  191.  
  192. /*****************************************************************************************/
  193.  
  194. // Si la première litterale est un rationnel
  195. if (type1 == tRationnelle) {
  196. Rationnelle* pt1 = dynamic_cast<Rationnelle*>(&l1);
  197. // Et que la deuxième est un entier
  198. if (type2 == tEntiere) {
  199. Entiere* pt2 = dynamic_cast<Entiere*>(&l2);
  200. return (new Rationnelle(pt2->getVal()*pt1->getDen().getVal() + pt1->getNum().getVal(), pt1->getDen().getVal()));
  201. }
  202. // Et que la deuxième est un reel
  203. if (type2 == tReelle) {
  204. Reelle* pt2 = dynamic_cast<Reelle*>(&l2);
  205. return (new Reelle(pt1->toReelle().getVal() + pt2->getVal()));
  206. }
  207. // Et que la deuxième est un rationnel
  208. if (type2 == tRationnelle) {
  209. Rationnelle* pt2 = dynamic_cast<Rationnelle*>(&l2);
  210. return (new Rationnelle(pt1->getNum().getVal()*pt2->getDen().getVal() + pt2->getNum().getVal()*pt1->getDen().getVal(), pt1->getDen().getVal()*pt2->getDen().getVal()));
  211. }
  212. // Et que la deuxième est un complexe
  213. if (type2 == tComplexe) {
  214. Complexe* pt2 = dynamic_cast<Complexe*>(&l2);
  215. Numerique* pRe = pt2->getRe();
  216. // Et que la partie réelle du complexe est un entier
  217. if (pRe->getType() == tEntiere) {
  218. Entiere* pt3 = dynamic_cast<Entiere*>(pRe);
  219. Rationnelle* newpRe = new Rationnelle(pt3->getVal()*pt1->getDen().getVal() + pt1->getNum().getVal(), pt1->getDen().getVal());
  220. return (new Complexe(newpRe, pt2->getIm()));
  221. }
  222. // Et que la partie réelle du complexe est un reel
  223. if (pRe->getType() == tReelle) {
  224. Reelle* pt3 = dynamic_cast<Reelle*>(pRe);
  225. Reelle* newpRe = new Reelle(pt1->toReelle().getVal() + pt3->getVal());
  226. return (new Complexe(newpRe, pt2->getIm()));
  227. }
  228. // Et que la partie réelle du complexe est un rationnel
  229. if (pRe->getType() == tRationnelle) {
  230. Rationnelle* pt3 = dynamic_cast<Rationnelle*>(pRe);
  231. Rationnelle* newpRe = new Rationnelle(pt1->getNum().getVal()*pt3->getDen().getVal() + pt3->getNum().getVal()*pt1->getDen().getVal(), pt1->getDen().getVal()*pt3->getDen().getVal());
  232. return (new Complexe(newpRe, pt2->getIm()));
  233. }
  234. }
  235. }
  236.  
  237.  
  238. /*****************************************************************************************/
  239.  
  240. // Si la première litterale est un complexe
  241. if (type1 == tComplexe) {
  242. Complexe* pt1 = dynamic_cast<Complexe*>(&l1);
  243. // On récupère le type de la partie réelle
  244. Numerique* pRe1 = pt1->getRe();
  245. // Si la partie réelle est un entier
  246. if (pRe1->getType() == tEntiere) {
  247. Entiere* ptx1 = dynamic_cast<Entiere*>(pRe1);
  248. // et que la deuxième est un entier
  249. if (type2 == tEntiere) {
  250. Entiere* pt2 = dynamic_cast<Entiere*>(&l2);
  251. Entiere* newpRe = new Entiere(ptx1->getVal() + pt2->getVal());
  252. return (new Complexe(newpRe, pt1->getIm()));
  253. }
  254. // Et que la deuxième est un reel
  255. if (type2 == tReelle) {
  256. Reelle* pt2 = dynamic_cast<Reelle*>(&l2);
  257. Reelle* newpRe = new Reelle((double)ptx1->getVal() + pt2->getVal());
  258. return (new Complexe(newpRe, pt1->getIm()));
  259. }
  260. // Et que la deuxième est un rationnel
  261. if (type2 == tRationnelle) {
  262. Rationnelle* pt2 = dynamic_cast<Rationnelle*>(&l2);
  263. Rationnelle* newpRe = new Rationnelle(ptx1->getVal()*pt2->getDen().getVal() + pt2->getNum().getVal(), +pt2->getDen().getVal());
  264. return (new Complexe(newpRe, pt1->getIm()));
  265. }
  266. // Et que la deuxième est un complexe
  267. }
  268. }
  269.  
  270. }
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement
Public Pastes
Advertisement
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!