/* routine for the "iran[low,high]" ascanf syntax */
int dm_example_irandom ( ASCB_ARGLIST )
{ ASCB_FRAME
int r;
int av= ascanf_verbose;
double rnd;
ascanf_verbose= 1;
r= ascanf_random( ASCB_ARGUMENTS );
rnd= *result;
*result= Entier( *result );
if( av ){
fputc( '\n', StdErr );
}
fprintf( StdErr, "#I%d: \tEnt[ ran", *level );
if( ascanf_arguments ){
int i;
fputc( '[', StdErr );
fprintf( StdErr, "%s", ad2str( args[0], d3str_format, 0) );
for( i= 1; i< ascanf_arguments; i++ ){
fprintf( StdErr, ",%s", ad2str( args[i], d3str_format, 0) );
}
fputc( ']', StdErr );
}
fprintf( StdErr, "== %s ]== ", ad2str( rnd, d3str_format,0) );
if( !av ){
fprintf( StdErr, "%s\n", ad2str( *result, d3str_format,0) );
}
ascanf_verbose= av;
return(r);
}
Nombre& Entier::division(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 : division : Impossible d'effectuer le dynamic cast!");
} else { // Entier / Rationnel
if (ptRationnel->getNum().getX()/ptRationnel->getDen().getX()==0) {
throw CalculatriceException("Entier : division : Division par 0");
}
Entier num = Entier(mX * ptRationnel->getDen().getX());
Entier den = Entier(ptRationnel->getNum().getX());
Rationnel* res= new Rationnel(num.toEntier(), den.toEntier());
res->simplifier();
Nombre& ref = *res;
return(ref);
}
} else { // Entier / Reel
if (ptReel->getX()==0) {
throw CalculatriceException("Entier : division : Division par 0");
}
Nombre& ref = this->division(ptReel->toRationnel());
return(ref);
}
} else { // Entier / Entier
if (ptEntier->getX()==0) {
throw CalculatriceException("Entier : division : Division par 0");
}
Reel* res = new Reel(mX / ptEntier->getX());
Nombre& ref = *res;
return(ref);
}
}
Expression::operator Complexe()const
{
//exception
return Complexe(&Entier(0), &Entier(0));
}
Expression::operator Entier()const
{
//exception
return Entier(0);
}
void OperateurBinaire::Calculer(Pile* stack){
Donnee* dB= stack->depiler(); // On commence par depiler les 2 dernieres donnees entrees. B est la derniere donne empile, donc le second membre de l'operation. La seconde donne empile est le premier membre, A.
Donnee* dA= stack->depiler();
Expression* testExA =dynamic_cast<Expression*>(dA); // On verifie d'abord si l'une des 2 donnees n'est pas une expression. Il faudra alors cancatener l'expression avec l'autre donnee et l'operateur.
Expression* testExB =dynamic_cast<Expression*>(dB);
if (testExA) {
testExA->enfiler_fin(dB);
testExA->enfiler_fin(this); // Si le premier membre est une expression, il faut enfiler le second membre et l'operateur à la fin successivement.
stack->empiler(testExA);
}
else if (testExB) {
testExB->enfiler_debut(dA);
testExB->enfiler_fin(this); // Si le second membre est une expression et que le premier ne l'est pas, il faut enfiler le premier membre au début de B, et l'operateur à la fin.
stack->empiler(testExB);
}
else {
Complexe* testC1 = dynamic_cast< Complexe*>(dA);
Complexe* testC2 = dynamic_cast< Complexe*>(dB);
Reel* test1 = dynamic_cast< Reel*>(dA);
Reel* test2 = dynamic_cast< Reel*>(dB);
Rationnel* test3 = dynamic_cast< Rationnel*>(dA);
Rationnel* test4 = dynamic_cast< Rationnel*>(dB);
Entier* testE1 = dynamic_cast< Entier*>(dA);
Entier* testE2 = dynamic_cast< Entier*>(dB);
if ( testC1 || testC2){ //On a au moins un complexe. On travaille donc avec des complexes.
Complexe A= Complexe(dA); // constructeur de complexe a partir de donnee.
Complexe B= Complexe(dB);
switch (typeoperation) { // Switch selon le type de l'operation, attribut de l'operateurBinaire.
case (PLUS):
{
Complexe *X= new Complexe(A+B);
stack->empiler(X);
}
break;
case(MINUS):
{
Complexe *X= new Complexe(A-B);
stack->empiler(X);
}
break;
case(DIV):
{
if (B.CNull()){ // Cas ou une division par zero est tentée.
stack->empiler(dA);
stack->empiler(dB);
throw CalculException("Division par zero impossible.");
}
else {
Complexe *X= new Complexe(A/B);
stack->empiler(X);
}
}
break;
case (MULT):
{
Complexe *X= new Complexe(A*B);
stack->empiler(X);
}
break;
case(MODULO):
{
stack->empiler(dA); // Modulo inappliquable sur complexes. On re-empile donc les donnees dans le bon ordre.
stack->empiler(dB);
throw CalculException("Modulo inappliquable pour Complexe.\nFonction utilisable avec Entier uniquement.");
}
break;
case (POW):
{
stack->empiler(dA);
stack->empiler(dB);
throw CalculException("POW inappliquable pour Complexe.");
}
break;
}
}
else if ( test1 || test2 ) { //Au moins un reel
Reel A=Reel(dA);
Reel B=Reel(dB);
Reel* dC = new Reel;
switch (typeoperation) {
case (PLUS):
{
*dC=(A+B);
stack->empiler(dC);
}
break;
case(MINUS):
{
*dC=(A-B);
stack->empiler(dC);
}
break;
case(DIV):
{
if (B.getVal()==0){ //Cas ou une division par zero est tentée.
stack->empiler(dA);
stack->empiler(dB);
throw CalculException("Division par zero impossible.");
}
else {
*dC=(A/B);
stack->empiler(dC);
}
}
break;
case (MULT):
{
*dC=(A*B);
stack->empiler(dC);
}
break;
case(MODULO):
{
stack->empiler(dA);
stack->empiler(dB);
throw CalculException("Modulo inappliquable pour Reel.\nFonction utilisable avec Entier uniquement.");
}
break;
case (POW):
{
*dC=(A*B);
*dC=Reel(pow(A.getVal(),B.getVal()));
stack->empiler(dC);
}
break;
}
}
else if ( test3 || test4 ) { //Au moins un rationnel
Rationnel A=Rationnel(dA);
Rationnel B=Rationnel(dB);
Rationnel* dC = new Rationnel;
switch (typeoperation) {
case (PLUS):
{
*dC=(A+B);
stack->empiler(dC);
}
break;
case(MINUS):
{
*dC=(A-B);
stack->empiler(dC);
}
break;
case(DIV):
{
if (B.getNumerateur().getVal()==0){
stack->empiler(dA);
stack->empiler(dB);
throw CalculException("Division par zero impossible.");
}
else {
*dC=(A/B);
stack->empiler(dC);
}
}
break;
case (MULT):
{
*dC=(A*B);
stack->empiler(dC);
}
break;
case(MODULO):
{
stack->empiler(dA);
stack->empiler(dB);
throw CalculException("Modulo inappliquable pour Rationnel.\nFonction utilisable avec Entier uniquement.");
}
break;
case (POW):
{
*dC=Rationnel(pow(A.getNumerateur(),float(B)),pow(A.getDenumerateur(),float(B)));
stack->empiler(dC);
}
break;
}
}
else if ( testE1 || testE2){ //On a forcément deux entiers
Entier* C = new Entier;
// Il est inutile de creer des variables locales entieres et de proceder a une conversion a partir de donnee, puisque testE1 et testE2 sont tout les 2 forcéments des entiers. Nous pouvons donc les utiliser dans le calcul.
switch (typeoperation) {
case (PLUS):
{
*C = *testE1 + *testE2;
stack->empiler(C);
}
break;
case(MINUS):
{
*C = *testE1 - *testE2;
stack->empiler(C);
}
break;
case(DIV):
{
if (testE2->getVal()==0){
stack->empiler(testE1);
stack->empiler(testE2);
throw CalculException("Division par zero impossible.");
}
else {
*C = *testE1 / *testE2;
stack->empiler(C);
}
}
break;
case (MULT):
{
*C = *testE1 * *testE2;
stack->empiler(C);
}
break;
case(MODULO):
{
if (testE2->getVal()==0){
stack->empiler(testE1);
stack->empiler(testE2);
throw CalculException("Modulo: Division par zero impossible.");
}
else {
*C = *testE1 % *testE2;
stack->empiler(C);
}
}
break;
case (POW):
{
*C = Entier(pow(testE1->getVal(),testE2->getVal()));
stack->empiler(C);
}
break;
}
}
else throw CalculException("Echec de la reconnaissance du type de 2 variables entrees.\nSource: Operateurbinaire.cpp. ");
}
}
/*! \sa Entier */
Rationnel::operator Entier()const
{
return Entier(num/den);
}
Constante* CUBE::application(const Constante& c1){
return POW::application(c1,Entier(3));
}
Rationnel::operator Complexe()const
{
return Complexe(&Rationnel(num, den), &Entier(0));
}
Constante* Analyseur::ToConstante(QString s) const
{
Historique* h =Historique::GetInstance();
if (EstConstante(s))
{
if (!(h->ModeComplexe()))//Dans ce cas, il ne faut pas utiliser les complexes
{
if (EstExpression(s))
{
/* Il faut retirer les '*/
s=s.left(s.length()-1);
s=s.right(s.length()-1);
return new Expression(s);
}
if (EstComplexe(s))
{
Reel temp(0);
Reel temp2(0);
QStringList list=s.split("$", QString::SkipEmptyParts);
if (EstRationnel(list[0]))
{
QStringList tempList=list[0].split("/", QString::SkipEmptyParts);
Rationnel rat(tempList[0].toInt(),tempList[1].toInt());
temp=Reel(rat);
}
else
{
temp=Reel(VirguleToPoint(list[0]).toDouble());
}
if (EstRationnel(list[1]))
{
QStringList tempList2=list[1].split("/", QString::SkipEmptyParts);
Rationnel rat(tempList2[0].toInt(),tempList2[1].toInt());
temp2=Reel(rat);
}
else
{
temp2=Reel(VirguleToPoint(list[1]).toDouble());
}
return new Complexe(temp,temp2);
}
if (EstReel(s))
{
return new Reel(VirguleToPoint(s).toDouble());
}
if (EstRationnel(s))
{
QStringList list=s.split("/", QString::SkipEmptyParts);
Entier temp=list[0].toInt();
Entier temp2=list[1].toInt();
return new Rationnel(temp,temp2);
}
if (EstEntier(s))
{
return new Entier(s.toInt());
}
}
else//Il faut tout couvertir en Complexe!!!
{
Entier entierNull(0);
if (EstExpression(s))
{
/* Il faut retirer les '*/
s=s.left(s.length()-1);
s=s.right(s.length()-1);
return new Expression(s);
}
if (EstComplexe(s))
{
Reel temp(0);
Reel temp2(0);
QStringList list=s.split("$", QString::SkipEmptyParts);
if (EstRationnel(list[0]))
{
QStringList tempList=list[0].split("/", QString::SkipEmptyParts);
Rationnel rat(tempList[0].toInt(),tempList[1].toInt());
temp=Reel(rat);
}
else
{
temp=Reel(VirguleToPoint(list[0]).toDouble());
}
if (EstRationnel(list[1]))
{
QStringList tempList2=list[1].split("/", QString::SkipEmptyParts);
Rationnel rat(tempList2[0].toInt(),tempList2[1].toInt());
temp2=Reel(rat);
}
else
{
temp2=Reel(VirguleToPoint(list[1]).toDouble());
}
return new Complexe(temp,temp2);
}
if (EstReel(s))
{
return new Complexe(Reel(VirguleToPoint(s).toDouble()),entierNull);
}
if (EstRationnel(s))
{
QStringList list=s.split("/", QString::SkipEmptyParts);
Entier temp=list[0].toInt();
Entier temp2=list[1].toInt();
return new Complexe(temp/temp2,entierNull);
}
if (EstEntier(s))
{
return new Complexe(Entier(s.toInt()),entierNull);
}
}
}
else
{
throw Exception("Ce n'est pas une instruction !");
}
return 0;
}
