int main(int argc, char** argv)
{
sostituisci(atoi(argv[1]),atoi(argv[2]));
}
void main()
{
bool riesegui = false;
do
{
// Letting the user insert a string
cout << "Insert a string down here:\n";
// Catching the string
cin.getline(expression, 300);
// Rimuovo gli spazi
remove_spaces(expression);
// Checking expression
if (!CheckExpression(expression))
{
cout << "\nExpression syntax error...";
getch();
return;
}
parentesizza();
aggiorna_posizioni();
int max_level = 0;
do
{
// Finding max level
max_level = 0;
for (int i = 0; i <= max_record_number; i++)
{
if (par[i].level > max_level) max_level = par[i].level;
}
//cout << "\nMax reached level: " << max_level;
// Itering through the records with the higher level
// Questa variabile conterrà il numero di expressioni
// trovate in questo livello.
int expressionNumber = 0;
for (int a = 0; a <= max_record_number; a++)
{
// Entering here if we are enetering in the max level
if (par[a].level == max_level)
{
// Itering through the number of operators present
char tmp_expression[300];
int c = 0;
// Copying the string
for (int b = (par[a].pos_open + 1); b < par[a].pos_close; b++)
{
tmp_expression[c++] = expression[b];
}
tmp_expression[c] = '\0';
// Showing the string
cout << "\nExpression: " << tmp_expression;
// Copio la stringa in tmp_expression in splittedExpression
for (b = 0; b < DIM_STRINGA_FINALE; b++)
{
splittedExpression[expressionNumber][b] = tmp_expression[b];
}
// Incremento il numero di espressioni estrette dalle parentesi
// di livello maggiore nel ciclo corrente
expressionNumber++;
}
}
/*
A questo punto splittedExpression[][] avrà tutte le espressioni
contenute nelle parentesi più interne della prima espressione
che devo risolvere. Il numero di espressioni estratte è determinato
da (expressionNumber - 1).
*/
// Risolvo tutte le espressioni
// ============================
// Ciclo su tutte le expressioni
for (a = 0; a <= expressionNumber; a++)
{
// Ciclo su tutti gli elementi dell'array
// Prima controlla la presenza di radici
for (int b = 0; splittedExpression[a][b] != '\0';)
{
double secondoOperatore, risultato;
// Se c'è scritta la r e dopo la r c'è un numero allora svolgo la raltrimenti lascio che prima venga svolto il resto
if (splittedExpression[a][b] == 'r' && ((int)splittedExpression[a][b + 1] < 48 || (int)splittedExpression[a][b + 1] > 57) && splittedExpression[a][b + 1] != '+' && splittedExpression[a][b + 1] != '-')
{
riesegui = true;
break;
}
if (splittedExpression[a][b] == 'r' && (((int)splittedExpression[a][b + 1] >= 48 && (int)splittedExpression[a][b + 1] <= 57) || splittedExpression[a][b + 1] == '+' || splittedExpression[a][b + 1] == '-'))
{
// Ho trovato una radice
//find_first_second_operator(splittedExpression[a], b,
//primoOperatore, secondoOperatore);
secondoOperatore = find_argument(splittedExpression[a], b);
risultato = sqrt(secondoOperatore);
if (risultato < 0)
{
cout << "\nNo number to the power of 2 is negative.\nThe program is not yet able to handle complex number.\n";
return;
}
substitute_result(splittedExpression[a], b, risultato);
//b = 0;
cout << '\n' << splittedExpression[a];
continue;
}
b++;
}
// Controllo la presenza di funzione trigonometriche nell'espressione
for (b = 0; splittedExpression[a][b] != '\0';)
{
double risultato;
switch((char)splittedExpression[a][b])
{
// Se c'è scritta una di queste lettere controllo se è una funzione trigonometrica
case 's':
case 'c':
case 't':
case 'a':
{
double argomento = find_argument(splittedExpression[a], b);
short int tipo_trigonometrica = istrigonometric(b, splittedExpression[a]);
// So che è una trigonometrica, prima sapevo solamente che era una
// parola che cominciava per quella lettera.
if (tipo_trigonometrica)
{
switch(tipo_trigonometrica)
{
case 1: {risultato = sin(argomento); break;}
case 2: {risultato = cos(argomento); break;}
case 3: {risultato = tan(argomento); break;}
case 4: {risultato = asin(argomento); break;}
case 5: {risultato = acos(argomento); break;}
case 6: {risultato = atan(argomento); break;}
case 7: {risultato = 1/tan(argomento); break;}
case 8: {risultato = 1/cos(argomento); break;}
case 9: {risultato = 1/sin(argomento); break;}
}
substitute_result(splittedExpression[a], b, risultato);
b = 0;
//cout << '\n' << splittedExpression[a];
continue;
}
else
{
cout << "\nError! Not recognised symbol.";
getch();
return;
}
}
}
b++;
}
// e successivamente di potenze
for (b = 0; splittedExpression[a][b] != '\0';)
{
double primoOperatore, secondoOperatore, risultato;
if (splittedExpression[a][b] == '^')
{
// Ho trovato una potenza
find_first_second_operator(splittedExpression[a], b,
primoOperatore, secondoOperatore);
risultato = pow(primoOperatore, secondoOperatore);
sostituisci(a, b, risultato);
b = 0;
cout << '\n' << splittedExpression[a];
break;
}
b++;
}
for (b = 0; splittedExpression[a][b] != '\0';)
{
double primoOperatore, secondoOperatore, risultato;
switch((char)splittedExpression[a][b])
{
case '*':
{
find_first_second_operator(splittedExpression[a], b,
primoOperatore, secondoOperatore);
risultato = primoOperatore * secondoOperatore;
sostituisci(a, b, risultato);
b = 0;
cout << '\n' << splittedExpression[a];
break;
}
case '/':
{
find_first_second_operator(splittedExpression[a], b,
primoOperatore, secondoOperatore);
risultato = primoOperatore / secondoOperatore;
sostituisci(a, b, risultato);
b = 0;
cout << '\n' << splittedExpression[a];
break;
}
default: b++;
}
}
for (b = 0; splittedExpression[a][b] != '\0';)
{
/*
1. Trovo la posizione del simbolo
2. Trovo i valori che stanno prima e dopo
NOTA: Se non c'è ne sono allora visualizzo un msg d'errore
3. Eseguo l'operazione determinata dal simbolo tra le due variabili
contenenti i due valori.
4. Sostituisco il risultato al posto dell'operazione.
5. Continua il ciclo
*/
double primoOperatore, secondoOperatore, risultato;
// Se trovo un simbolo presente tra quelli consentiti
switch((char)splittedExpression[a][b])
{
// In caso il simbolo sia + ...
case '+':
{
// Trovo valore prima e dopo
find_first_second_operator(splittedExpression[a], b /* posizione dell'operatore */,
primoOperatore, secondoOperatore /*Passo l'indirizzo della variabile*/);
// Eseguo l'operazione
risultato = primoOperatore + secondoOperatore;
// Sostituisco il risultato al posto dell'operazione
sostituisci(a /* indice */, b /* posizione dell'operatore*/, risultato);
// Azzero b per ricominciare da capo l'itering della stringa
b = 0;
// Showing the result
cout << '\n' << splittedExpression[a];
// breaking della case
break;
}
case '-':
{
// Devo controllare che il segno sia inteso come operando
if (b == 0) {b++; break;}
// Controllo che prima ci sia un numero
if (splittedExpression[a][b - 1] < 48 || splittedExpression[a][b - 1] > 57) {b++; break;}
find_first_second_operator(splittedExpression[a], b,
primoOperatore, secondoOperatore);
risultato = primoOperatore - secondoOperatore;
sostituisci(a, b, risultato);
b = 0;
cout << '\n' << splittedExpression[a];
break;
}
default: b++;
}
}
if (riesegui == true) {a = -1; riesegui = false;}
}
// Dovrei aver ottenuto un numero di valori senza operatori pari a (expressionNumber - 1)
// Visualizzo i risultati di tutte le parentesi (quelle con il lvello più alto
/*for (int a = 0; a < expressionNumber; a++)
{
cout << splittedExpression[expressionNumber];
}*/
// Risolvo tutte le espressioni
// Riciclo sull'espressione iniziale (expression[])
// Quando incontro una parentesi di livello massimo
// sostituisco il contenuto con il suo risultato.
/*
NOTA: Se c'è un simbolo prima della parentesi allora lo
lascio, altrimenti metto il *
*/
/*
Vado a sostituire i valori risolti delle parentesi più interne all'interno
dell'espressione intera e ricomincia il ciclo.
max_record_number = numero di parentesi;
max_level = livello massimo;
splittedExpression[] = espressioni da sostituire;
expressionNumber = numero di espressioni da sostituire;
expression[] = espressione intera da risolvere;3.30
*/
int numero_parentesi = max_record_number;
int b = 0;
for (a = 0; a <= numero_parentesi; a++)
{
if (par[a].level == max_level)
{
double numero = atof(splittedExpression[b++]);
sostituisci_parentesi(par[a].pos_open, par[a].pos_close, numero);
a = 0;
}
}
}
while(max_level > 1);
cout << "\n\n";
}
while(1);
cout << '\n';
return;
}
