Constante& Rationnel::operator^(const Constante& c)const//pas sûr
{
const Entier* e = dynamic_cast<const Entier*>(&c);
const Reel* r = dynamic_cast<const Reel*>(&c);
const Rationnel* f = dynamic_cast<const Rationnel*>(&c);
if(e!=0)
{
Rationnel* res = new Rationnel((int)pow((float)num, (int)*e), (int)pow((float)den, (int)*e));
return *res;
}
else if(r!=0)
{
Reel* res = new Reel(pow((float)num/den, (float)*r));
return *res;
}
else if(f!=0)
{
Reel* res = new Reel(pow(pow((float)num/den, f->GetNum()), -f->GetDen()));
return *res;
}
else
{
throw CalcException("L'opération de puissance nécessite que l'exposant soit un entier, un rationnel ou un réel");
}
}
void AtomeManager::removeAtome(Atome& e){
unsigned int i=0;
while(i<nb && ats[i]!=&e) i++;
if (i==nb) throw CalcException("elimination d'une Atome inexistante");
delete ats[i];
i++;
while(i<nb) { ats[i-1]=ats[i]; i++; }
nb--;
}
Constante& Rationnel::inverse()const
{
if(num!=0)
{
Rationnel* res = new Rationnel(den, num);
return *res;
}
else
throw CalcException("L'opération d'inverse est impossible avec zéro");
}
Constante& Rationnel::racine()const
{
if((num>0 && den>0) || (num<=0 && den<=0))
{
Reel* res = new Reel(sqrt((float)num/den));
return *res;
}
else
throw CalcException("L'opération de racine carrée nécessite une valeur positive");
}
Expression::operator Complexe()const
{
try
{
throw CalcException("Impossible de convertir une expression en un Complexe.");
}
catch (CalcException c)
{
c.alert();
}
}
Expression::operator Rationnel()const
{
try
{
throw CalcException("Impossible de convertir une expression en un Rationnel.");
}
catch (CalcException c)
{
c.alert();
}
}
Constante& Rationnel::lognep()const
{
if((num>0 && den>0) || (num<=0 && den<=0))
{
Reel* res = new Reel(log((float)num/den));
return *res;
}
else
{
throw CalcException("L'opération de logarithme nécessite que l'opérateur soit positif");
}
}
Constante& Rationnel::operator+(const Constante& c)const//ADAPTER A FAIRE
{
const Rationnel* r = dynamic_cast<const Rationnel*>(&c);
if(r!=0)
{
Rationnel* res = new Rationnel(num*r->GetDen() + r->GetNum()*den, den*r->GetDen());
return *res;
}
else
{
throw CalcException("L'opération d'addition nécessite que les deux opérateurs soient de même type");
}
}
Constante& Rationnel::operator/(const Constante& c)const
{
const Rationnel* r = dynamic_cast<const Rationnel*>(&c);
if(r!=0)
{
Rationnel* res = new Rationnel(num*r->GetDen(), den*r->GetNum());
return *res;
}
else
{
throw CalcException("L'opération de division nécessite que les deux opérateurs soient de même type");
}
}
// ----- Soustraction -----
LitteraleCalculable& Entier::diff(const LitteraleCalculable& l) const{
const Entier* ptEntier = dynamic_cast<const Entier*>(&l);
if (ptEntier != 0){
// Entier - Entier
Entier* res = new Entier(value - ptEntier->getValue());
LitteraleCalculable& ref = *res;
return ref;
}
else{
const Rationnel* ptRationnel = dynamic_cast<const Rationnel*>(&l);
if (ptRationnel!= 0){
// Entier - Rationnel
Entier num = (value*ptRationnel->getDen().getValue()-ptRationnel->getNum().getValue());
Entier den = (ptRationnel->getDen().getValue());
Rationnel* res = new Rationnel(num,den);
LitteraleCalculable& ref = *res;
return ref;
}
else {
const Reel* ptReel = dynamic_cast<const Reel*>(&l);
if (ptReel!=0){
// Entier - Reel
Reel* res= new Reel(value-ptReel->getValue());
LitteraleCalculable& ref = *res;
return ref;
}else{
const Expression* ptExpression=dynamic_cast<const Expression*>(&l);
if (ptExpression!=0){
// Entier + Expression
LitteraleCalculable& ref = ptExpression->diff(*this);
return ref;
}else{
const Complexe* ptComplexe = dynamic_cast<const Complexe*>(&l);
if (ptComplexe!=0){
// Entier / Complexe
LitteraleCalculable& ref = ptComplexe->diff(*this);
return ref;
}
}
}
}
}
throw CalcException("le type de l'argument 2 n'est pas reconnu");
Entier* res = new Entier();
LitteraleCalculable& ref = *res;
return ref;
}
/*!
On verifie que la valeur de l'argument implicite soit superieure a 0.
\return Une reference sur une Constante contenant notre nouveau Rationnel.
\sa CalcException
\sa Reel
\sa <a href = "http://www.cplusplus.com/reference/clibrary/cmath/log10/">log10</a>
*/
Constante& Rationnel::logdec()const
{
try {
if((num>0 && den>0) || (num<=0 && den<=0))
{
Reel* res = new Reel(log10((float)num/den));
return *res;
}
else
{
throw CalcException("L'opération de logarithme nécessite que l'opérateur soit positif");
}
}
catch (CalcException c)
{
c.alert();
}
}
/*!
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();
}
}
/*!
\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
{
try
{
const Rationnel* r = dynamic_cast<const Rationnel*>(&c);
if(r!=0)
{
Rationnel* res = new Rationnel(num*r->GetNum(), den*r->GetDen());
res->simplifier();
return *res;
}
else
{
throw CalcException("L'opération de multiplication nécessite que les deux opérateurs soient de même type");
}
}
catch (CalcException c)
{
c.alert();
}
}
Constante& Constante::operator*(const Constante&)const
{
throw CalcException("On ne peut pas multiplier deux expressions");
}
Constante& Constante::operator/(const Constante&)const
{
throw CalcException("On ne peut pas diviser deux expressions");
}
Constante& Constante::logdec()const
{
throw CalcException("On ne peut pas appliquer le logarithme décimal à une expression ou à un complexe");
}
LitteraleCalculable& Entier::quotient(const LitteraleCalculable& l) const{
const Entier* ptEntier = dynamic_cast<const Entier*>(&l);
if (ptEntier != 0){
// Entier / Entier
//if(ptEntier->getValue() == 0)
int type = simplifier(*this, *ptEntier);
if (type == 0){//non simplifiable
Rationnel* res = new Rationnel(value, ptEntier->getValue());
LitteraleCalculable& ref = *res;
return ref;
}
if (type == 1) {
Entier* res = new Entier(value / ptEntier->getValue());
LitteraleCalculable& ref = *res;
return ref;
}
}else{
const Rationnel* ptRationnel = dynamic_cast<const Rationnel*>(&l);
if (ptRationnel!= 0){
// Entier / Rationnel
if(ptRationnel->getNum().getValue() == 0) throw CalcException("dividion par 0 impossible");
Entier num = (value * ptRationnel->getDen().getValue());
Entier den = (ptRationnel->getNum().getValue());
Rationnel* res = new Rationnel(num, den);
// res->simplifier();
LitteraleCalculable& ref = *res;
return ref;
}
else {
const Reel* ptReel = dynamic_cast<const Reel*>(&l);
if (ptReel!=0){
// Entier / Reel
if(ptReel->getValue() == 0) throw CalcException("division par 0 impossible");
Reel* res = new Reel(value / ptReel->getValue());
LitteraleCalculable& ref = *res;
return ref;
}else{
const Expression* ptExpression=dynamic_cast<const Expression*>(&l);
if (ptExpression!=0){
// Entier + Expression
LitteraleCalculable& ref = ptExpression->quotient(*this);
return ref;
}else{
const Complexe* ptComplexe = dynamic_cast<const Complexe*>(&l);
if (ptComplexe!=0){
// Entier / Complexe
LitteraleCalculable& ref = ptComplexe->quotient(*this);
return ref;
}
}
}
}
}
throw CalcException("le type de l'argument 2 n'est pas reconnu");
Entier* res = new Entier();
LitteraleCalculable& ref = *res;
return ref;
}
Constante& Constante::operator^(const Constante&)const
{
throw CalcException("On ne peut pas élever à la puissance deux expressions ou deux complexes");
}
Constante& Constante::sinus()const
{
throw CalcException("On ne peut pas appliquer le sinus à une expression ou à un complexe");
}
Constante& Constante::cube()const
{
throw CalcException("On ne peut pas appliquer le cube à une expression");
}
Constante& Constante::cosinush()const
{
throw CalcException("On ne peut pas appliquer le cosinus hyperbolique à une expression ou à un complexe");
}
Constante& Constante::inverse()const
{
throw CalcException("On ne peut pas appliquer l'inverse à une expression ou à un complexe");
}
Constante& Constante::operator-(const Constante&)const
{
throw CalcException("On ne peut pas soustraire deux expressions");
}
Constante& Constante::lognep()const
{
throw CalcException("On ne peut pas appliquer le logarithme népérien à une expression ou à un complexe");
}
Constante& Constante::operator-()const
{
throw CalcException("On ne peut pas inverser le signe d'une expression");
}
LitteraleCalculable& Entier::mult(const LitteraleCalculable& l) const{
const Entier* ptEntier = dynamic_cast<const Entier*>(&l);
if (ptEntier != 0){
// Entier * Entier
Entier* res = new Entier(value * ptEntier->getValue());
LitteraleCalculable& ref = *res;
return ref;
}
else{
const Rationnel* ptRationnel = dynamic_cast<const Rationnel*>(&l);
if (ptRationnel!= 0){
// Entier * Rationnel
Entier num = (value * ptRationnel->getNum().getValue());
Entier den = (ptRationnel->getDen().getValue());
int type = simplifier(num, den);
if (type == 0){
Rationnel* res = new Rationnel(num,den);
LitteraleCalculable& ref = *res;
return ref;
}
if (type == 1) {
Entier v = num.div(den);
Entier* res = new Entier(v.getValue());
LitteraleCalculable& ref = *res;//spl->simplifier(res);
return ref;
}
}
else {
const Reel* ptReel = dynamic_cast<const Reel*>(&l);
if (ptReel!=0){
// Entier * Reel
Reel* res= new Reel(value * ptReel->getValue());
LitteraleCalculable& ref = *res;
return ref;
}else{
const Expression* ptExpression=dynamic_cast<const Expression*>(&l);
if (ptExpression!=0){
// Entier * Expression
LitteraleCalculable& ref = ptExpression->mult(*this);
return ref;
}else{
const Complexe* ptComplexe = dynamic_cast<const Complexe*>(&l);
if (ptComplexe!=0){
// Entier * Complexe
LitteraleCalculable& ref = ptComplexe->mult(*this);
return ref;
}
}
}
}
}
throw CalcException("le type de l'argument 2 n'est pas reconnu");
Entier* res = new Entier();
LitteraleCalculable& ref = *res;
return ref;
}
Constante& Constante::operator+(const Constante&)const
{
throw CalcException("On ne peut pas ajouter deux expressions");
}
Constante& Constante::racine()const
{
throw CalcException("On ne peut pas appliquer la racine carrée à une expression ou à un complexe");
}
Constante& Constante::tangenteh()const
{
throw CalcException("On ne peut pas appliquer la tangente hyperbolique à une expression ou à un complexe");
}
