Complexe::Complexe(const QString& pRe, const QString& pIm){
if(typeLitteral(pRe)=="Entier")
a = new Entier(pRe);
else if(typeLitteral(pRe)=="Reel")
a = new Reel(pRe);
else if(typeLitteral(pRe)=="Rationnel"){
Rationnel* rat = new Rationnel(pRe);
rat->simplifier();
if(rat->getDenumerateur()->getVal() == 1 || rat->getNumerateur()->getVal() ==0){
Entier* e = new Entier(rat->getNumerateur()->getVal());
a = e;
}
else{
a = rat;
}
}
if(typeLitteral(pIm)=="Entier")
b = new Entier(pIm);
else if(typeLitteral(pIm)=="Reel")
b = new Reel(pIm);
else if(typeLitteral(pIm)=="Rationnel"){
Rationnel* rat = new Rationnel(pIm);
rat->simplifier();
if(rat->getDenumerateur()->getVal() == 1 || rat->getNumerateur()->getVal() ==0){
Entier* e = new Entier(rat->getNumerateur()->getVal());
b = e;
}
else{
b = rat;
}
}
}
/*! \sa Compexe */
Rationnel::operator Complexe()const
{
Rationnel* r = new Rationnel(num, den);
r->simplifier();
Rationnel* zero = new Rationnel(0, 1);
return Complexe(r, zero);
}
Nombre& Entier::soustraction(const Nombre& n) const {
// Nombre -> Entier
const Entier* ptEntier = dynamic_cast<const Entier*>(&n);
if (ptEntier == 0) {
// Nombre -> Reel
const Reel* ptReel = dynamic_cast<const Reel*>(&n);
if (ptReel == 0) {
// Nombre -> Rationnel
const Rationnel* ptRationnel = dynamic_cast<const Rationnel*>(&n);
if (ptRationnel == 0) {
throw CalculatriceException("Entier : soustraction : Impossible d'effectuer le dynamic cast!");
} else { // Entier - Rationnel
Entier num(mX * ptRationnel->getDen().getX() - ptRationnel->getNum().getX());
Entier den(ptRationnel->getDen().getX());
Rationnel* res = new Rationnel(num.toEntier(), den.toEntier());
res->simplifier();
Nombre& ref = *res;
return(ref);
}
} else { // Entier - Reel
Reel* res = new Reel(mX - ptReel->getX());
Nombre& ref = *res;
return(ref);
}
} else { // Entier - Entier
Entier* res = new Entier(mX - ptEntier->getX());
Nombre& ref = *res;
return(ref);
}
}
void Complexe::buildConstant(const std::string& val)
{
int i = val.find_first_of('$');
string temp1 = val.substr(0, i);
string temp2 = val.substr(i+1);
if(complexe_type_contenu == entier)
{
_reel = new Entier(temp1);
_img = new Entier(temp2);
}
else if(complexe_type_contenu == rationnel)
{
Rationnel* n = new Rationnel(temp1);
n->simplifier();
_reel = n;
Rationnel* n2 = new Rationnel(temp2);
n2->simplifier();
_img = n2;
}
else if(complexe_type_contenu == reel)
{
_reel = new Reel(temp1);
_img = new Reel(temp2);
}
}
/*!
On verifie que le numerateur de l'argument implicite soit differente de 0.
\return Une reference sur une Constante contenant notre nouveau Rationnel.
\sa CalcException
*/
Constante& Rationnel::inverse()const
{
try
{
if(num!=0)
{
Rationnel* res = new Rationnel(den, num);
res->simplifier();
return *res;
}
else
throw CalcException("L'opération d'inverse est impossible avec zéro");
}
catch (CalcException c)
{
c.alert();
}
}
/*!
\param c Une reference constante vers une Constante.
\return Une reference sur une Constante contenant notre nouveau Rationnel.
\sa CalcException
\sa <a href="http://www.cplusplus.com/reference/clibrary/cmath/pow/">pow</a>
*/
Constante& Rationnel::operator^(const Constante& c)const
{
try
{
const Rationnel* r = dynamic_cast<const Rationnel*>(&c);
if(r!=0)
{
Rationnel* res = new Rationnel((int)pow((float)num, (float)(r->GetNum()/r->GetDen())), (int)pow((float)den, (float)(r->GetNum()/r->GetDen())));
res->simplifier();
return *res;
}
else
throw CalcException("L'opération d'elevation à l'exposant nécessite que les deux opérandes soient de même type");
}
catch (CalcException c)
{
c.alert();
}
}
/*! A noter que l'on tente un dynamic cast sur l'argument qui est la seulement en cas d'un developpement futur
car toutes nos operandes sont castees avant d'effectuer n'importe quelle operation.
\param c Une reference constante vers une Constante.
\return Une reference sur une Constante contenant notre nouveau Rationnel.
\sa CalcException
*/
Constante& Rationnel::operator+(const Constante& c)const//ADAPTER A FAIRE
{
try
{
const Rationnel* r = dynamic_cast<const Rationnel*>(&c);
if(r!=0)
{
Rationnel* res = new Rationnel(num*r->GetDen() + r->GetNum()*den, den*r->GetDen());
res->simplifier();
return *res;
}
else
{
throw CalcException("L'opération d'addition nécessite que les deux opérateurs soient de même type");
}
}
catch (CalcException c)
{
c.alert();
}
}
/*!
\return Une reference sur une Constante contenant notre nouveau Rationnel.
\sa <a href = "http://www.cplusplus.com/reference/clibrary/cmath/pow/">pow</a>
*/
Constante& Rationnel::cube()const
{
Rationnel* res = new Rationnel((int)pow((float)num,3), (int)pow((float)den,3));
res->simplifier();
return *res;
}