/* ordinamento dei lati dal maggiore al minore e "riconoscimento" del grado di "regolarità" del triangolo */ void ordinalati()

Transcript

1 Una possibile soluzione, molto più esauriente rispetto alle richieste stesse del problema è la seguente (è stata ragionevolmente controllata, ma se qualcuno trovasse dei difetti di funzionamento è pregato di segnalarlo) #include <iostream> #include <iomanip> #include <math.h> #define ORTHO 0 #define BARIC 1 #define CIRCO 2 #define INCEN 3 #define PERIMETRO UNITARIO 1 #define AREA UNITARIA 2 using namespace std; /* questa funzione non è membro della classe e serve a convertire i tre angoli di un triangolo da radianti a gradi sessagesimali, primi, secondi */ int ** converti(double a[]) {int ** i; double dumm, domm; i = new int*[3]; for(int j=0; j < 3; j++) i[j] = new int[3], domm = a[j]*180.0/m PI, i[j][0] = static cast<int>(floor(domm)), dumm = (domm - static cast<double>(i[j][0]))*60.0, i[j][1] = static cast<int>(floor(dumm)), domm = (dumm - static cast<double>(i[j][1]))*60.0, i[j][2] = static cast<int>(floor(domm)); if(i[0][2]+i[1][2]+i[2][2]) i[2][2]++; return i;} /* qui inizia la classe dei triangoli */ class Triangolo { /* la variabile booleana "fatto" indica se è stato possibile costruire effettivamente il triangolo*/ bool fatto; // verifica delle disuguaglianze triangolari bool testcongruenzalati(double l[], char q) {bool r = true; for(char c=0; c < q; c++) r = r && l[c] > 0.0; if(q == 2) return r; return r && l[0] < l[1]+l[2] && l[1] < l[2]+l[0] && l[2] < l[0]+l[1] && l[0] >= fabs(l[1]-l[2]) && l[1] >= fabs(l[2]-l[0]) && l[2] >= fabs(l[0]-l[1]);} /* ordinamento dei lati dal maggiore al minore e "riconoscimento" del grado di "regolarità" del triangolo */ void ordinalati()

2 {if(fabs(lati[0] - lati[1]) > 1.e-8*lati[0] && fabs(lati[0] - lati[2]) > 1.e-8*lati[0] && fabs(lati[1] - lati[2]) > 1.e-8*lati[1]) regolarita = scaleno; if(fabs(lati[0] - lati[1]) <= 1.e-8*lati[0] fabs(lati[0] - lati[2]) <= 1.e-8*lati[0]) {if(fabs(lati[1] - lati[2]) <= 1.e-8*lati[1]) lati[2] = lati[1] = lati[0], regolarita = equilatero; lati[1] = lati[0], regolarita = isoscele;} i[0] = ((lati[0] >= lati[1])? ((lati[0] >= lati[2])? 0 : 2) : ((lati[1] >= lati[2])? 1 : 2)), i[2] = ((lati[0] < lati[1])? ((lati[0] < lati[2])? 0 : 2) : ((lati[1] < lati[2])? 1 : 2)); i[1] = 3 - i[0] - i[2];} /* calcolo del punto d incontro di due rette */ double * incrociarette(double * r1, double *r2) {double d; if((d = r1[0]*r2[1] - r1[1]*r2[0]) == 0.0) return 0; double *xy = new double[2]; xy[0] = (r1[1]*r2[2]-r1[2]*r2[1]) / d, xy[1] = (r1[2]*r2[0]-r1[0]*r2[2]) / d; return xy;} /* calcolo dei coefficienti dell equazione della retta bisettrice dell angolo numero a */ double * rettabisettrice(int a) {double * c = new double[3]; c[1] = 1.0; switch(a) {case 0: c[0] = tan(angoli[2]+0.5*angoli[a]), c[2] = -vertici[2][1] -vertici[2][0]*c[0]; case 1: c[0] = -tan(0.5*angoli[a]), c[2] = 0.0; case 2: c[0] = tan(0.5*angoli[a]), c[2] = lati[0]*c[0];} return c;} /* calcolo dei coefficienti dell equazione della retta che porta l altezza relativa al lato numero a */ double * rettaaltezza(int a) {double * c = new double[3]; switch(a) {case 0: c[1] = 0.0, c[0] = 1.0, c[2] = -vertici[2][0]; case 1: if(rette[1][1] == 0.0) c[0] = c[2] = 0.0, c[1] = 1.0; c[0] = -rette[1][1]/rette[1][0], c[1] = 1.0, c[2] = 0.0; case 2: if(rette[2][1] == 0.0) c[0] = c[2] = 0.0, c[1] = 1.0;

3 c[0] = -rette[2][1]/rette[2][0], c[1] = 1.0, c[2] = 0.0;} return c;} /* calcolo dei coefficienti dell equazione della retta che porta l asse del lato numero a */ double * rettaasse(int a) {double * c = new double[3]; switch(a) {case 0: c[0] = 1.0, c[1] = 0.0, c[2] = -0.5*lati[0]; case 1: if(rette[1][1] == 0.0) c[0] = 0.0, c[1] = 1.0, c[2] = -0.5*lati[1]; c[0] = -rette[1][1]/rette[1][0], c[1] = 1.0, c[2] = 0.5*lati[1]*(c[0]*cos(angoli[2])-sin(angoli[2])) -c[0]*lati[0]; case 2: if(rette[2][1] == 0.0) c[0] = 0.0, c[1] = 1.0, c[2] = -0.5*lati[2]; c[0] = -rette[2][1]/rette[2][0], c[1] = 1.0, c[2] = -0.5*lati[2]*(c[0]*cos(angoli[1])+sin(angoli[1]));} return c;} /* calcolo dei coefficienti dell equazione della retta che porta la mediana relativa al lato numero a */ double * rettamediana(int a) {double * c = new double[3]; switch(a) {case 0: if(vertici[2][0] == 0.5*lati[0]) c[0] = 1.0, c[1] = 0.0, c[2] = -vertici[2][0]; c[0] = 1.0/(0.5*lati[0] - vertici[2][0]), c[1] = 1.0/vertici[2][1], c[2] = vertici[2][0]/(0.5*lati[0] - vertici[2][0]); case 1: c[2] = 0.0; if(vertici[2][0] == -lati[0]) c[0] = 1.0, c[1] = 0.0; c[0] = 2.0/(vertici[2][0]+lati[0]), c[1] = -2.0/vertici[2][1]; case 2: if(vertici[2][0] == 2.0*lati[0]) c[0] = 1.0, c[1] = 0.0, c[2] = -lati[0]; c[0] = 1.0/(0.5*vertici[2][0]-lati[0]), c[1] = -2.0/vertici[2][1], c[2] = -lati[0]/(0.5*vertici[2][0]-lati[0]);} return c;} /* attribuzione delle coordinate ai vertici del triangolo: il primo vertice sta nell origine, il secondo lungo l asse orizzontale, il terzo di conseguenza...; sono anche determinate le equazioni delle rette che portano i tre lati.*/ void calcolavertici()

4 {vertici[0][0] = vertici[0][1] = 0.0, vertici[1][0] = lati[0], vertici[1][1] = 0.0, vertici[2][0] = lati[2] * cos(angoli[1]), vertici[2][1] = lati[2] * sin(angoli[1]), rette[0][0] = rette[0][2] = 0.0, rette[0][1] = 1.0, rette[1][0] = (vertici[2][0]!= vertici[1][0])? 1.0 /(vertici[2][0] - vertici[1][0]) : 1.0, rette[1][1] = (vertici[2][0]!= vertici[1][0])? -1.0 /(vertici[2][1] - vertici[1][1]) : 0.0, rette[1][2] = rette[1][0] == 1.0? 0.0 : vertici[1][1] / (vertici[2][1] - vertici[1][1]) - vertici[1][0] / (vertici[2][0] - vertici[1][0]); rette[2][0] = (vertici[2][0]!= vertici[0][0])? 1.0 /(vertici[2][0] - vertici[0][0]) : 1.0, rette[2][1] = (vertici[2][0]!= vertici[0][0])? -1.0 /(vertici[2][1] - vertici[0][1]) : 0.0, rette[2][2] = rette[2][0] == 1.0? 0.0 : vertici[0][1] / (vertici[2][1] - vertici[0][1]) - vertici[0][0] / (vertici[2][0] - vertici[0][0]);} static enum regolarita {equilatero, isoscele, scaleno}regolarita; static enum forma {Equilatero, acutangolo, rettangolo, ottusangolo}forma; static const char * descrizioni regolarita[]; static const char * descrizioni forma[]; char * caratteristiche[2], i[3]; double lati[3], angoli[3], vertici[3][2], centri[4][2], rette[3][3]; /* "amicizia" con l operatore << */ friend ostream & operator << (ostream &, Triangolo); /* un metodo per la creazione di un triangolo equilatero */ void faiequilatero(double l) {lati[0] = lati[1] = lati[2] = l, angoli[0] = angoli[1] = angoli[2] = M PI/3.0, regolarita = equilatero, forma = Equilatero, /* un metodo che calcola tutti i centri di un triangolo */ void calcolacentri() {double *xy, *r, *s; xy = incrociarette(r = rettaaltezza(0), s = rettaaltezza(1)), centri[ortho][0] = xy[0], centri[ortho][1] = xy[1], delete[] r, delete[] s, delete [] xy, xy = incrociarette(r = rettamediana(0), s = rettamediana(1)), centri[baric][0] = xy[0], centri[baric][1] = xy[1], delete[] r, delete[] s, delete [] xy, xy = incrociarette(r = rettaasse(0), s = rettaasse(1)), centri[circo][0] = xy[0], centri[circo][1] = xy[1], delete[] r, delete[] s, delete [] xy,

5 xy = incrociarette(r = rettabisettrice(0), s = rettabisettrice(1)), centri[incen][0] = xy[0], centri[incen][1] = xy[1], delete[] r, delete[] s, delete [] xy;} /* un metodo che "riconosce" la forma di un triangolo */ void determinaforma() {if(fabs(2.0*angoli[i[0]]-m PI) < 1.e-9) forma = rettangolo; if(2.0*angoli[i[0]] > M PI) forma = ottusangolo; if(regolarita!= equilatero) forma = acutangolo; forma = Equilatero;} public: /* metodi PUBBLICI (significato ovvio)*/ bool malriuscito() {return!fatto;} double * Lati() {return lati;} double Lati(int i) {return lati[i];} double * Angoli() {return angoli;} double Angoli(int i) {return angoli[i];} double Perimetro() {return lati[0]+lati[1]+lati[2];} double Area() {double p = Perimetro(); return 0.25*sqrt(p*(p-2.0*lati[0])*(p-2.0*lati[1])*(p-2.0*lati[2]));} /* costruttore default: costruisce un triangolo equilatero di lato 1 */ Triangolo() {faiequilatero(1.0), fatto = true;} /* costruttore parametrico num. 1: costruisce un triangolo equilatero di lato l */ Triangolo(double l) {faiequilatero(l), fatto = true;} /* costruttore parametrico num. 2: costruisce un triangolo (se possibile) assegnati i tre lati */ Triangolo(double l[]) {fatto = testcongruenzalati(l, 3); if(!fatto) {cerr << "questi lati: " << l[0] << ", " << l[1] << ", " << l[2] << " non possono formare un triangolo\n"; return;} lati[0] = l[0], lati[1] = l[1], lati[2] = l[2], ordinalati(), angoli[i[0]] = acos((l[i[1]]*l[i[1]]+l[i[2]]*l[i[2]] -l[i[0]]*l[i[0]])/(2.0*l[i[1]]*l[i[2]])); determinaforma(), angoli[i[1]] = asin(sin(angoli[i[0]])*l[i[1]]/l[i[0]]), angoli[i[2]] = asin(sin(angoli[i[0]])*l[i[2]]/l[i[0]]), /* costruttore parametrico num. 3: costruisce un triangolo assegnati due lati e l angolo compreso (sempre possibile... salvo patologie) */ Triangolo(double l[], double a) {fatto = testcongruenzalati(l, 2); if(!fatto) {cerr << "questi lati: " << l[0] << ", " << l[1]

6 << " non possono formare un triangolo\n"; return;} if(!(fatto && a > 0.0 && a < M PI)) {fatto = false; cerr << "quest angolo: " << a << " non può stare in un triangolo\n"; return;} lati[0] = l[0], lati[1] = l[1], lati[2] = sqrt(l[0]*l[0]+l[1]*l[1]-2.0*l[0]*l[1]*cos(a)), ordinalati(), angoli[2] = a, angoli[0] = asin(sin(angoli[2])*lati[0]/lati[2]), angoli[1] = asin(sin(angoli[2])*lati[1]/lati[2]), determinaforma(), /* costruttore parametrico num. 4: costruisce un triangolo assegnato un lato e i due angoli adiacenti */ Triangolo(double l, double a[]) {fatto = a[0] > 0.0 && a[1] > 0.0 && a[0] + a[1] < M PI; if(!fatto) {cout<< "\n...\n\" O cara piota mia che sì t insusi\n\ che, come veggion le terrene menti\n\ non càpere in trïangol due ottusi,\n\n\ così vedi le cose contingenti\n\ anzi che sieno in sé, mirando il punto\n\ a cui tutti li tempi son presenti\n...\"\n"; return;} if(!(fatto && l > 0)) {fatto = false; cerr << "questo lato: " << l << " non può appartenere a un triangolo\n"; return;} angoli[1] = a[0], angoli[2] = a[1], angoli[0] = M PI - a[0] - a[1], lati[0] = l, lati[1] = l * sin(angoli[1]) / sin(angoli[0]), lati[2] = l * sin(angoli[2]) / sin(angoli[0]), ordinalati(), determinaforma(), /* costruttore parametrico num. 5: costruisce un triangolo assegnati due lati, un angolo e un criterio di scelta nel caso esistano due triangoli compatibili (triangolo NON rettangolo) */ Triangolo(double l[], double a, char c) {fatto = a > 0.0 && a < M PI && l[0] > 0. && l[1] >= l[0] * sin(a); if(!fatto) {cerr << "la configurazione fornita (lati: " << l[0] <<", " << l[1] << "); angolo = " << a << " non può sussistere\n"; return;} angoli[2] = a; if(l[1] == l[0] * sin(a)) angoli[1] = 0.5*M PI, forma = rettangolo; {angoli[1] = asin(sin(a)*l[0]/l[1]), forma = acutangolo; if(c == O ) forma = ottusangolo, angoli[1] = M PI - angoli[1];} angoli[0] = M PI - angoli[1] - angoli[2],

7 lati[1] = l[0], lati[2] = l[1], lati[0] = lati[1] * sin(angoli[0]) / sin(angoli[1]), ordinalati(), /* costruttore parametrico num. 6: costruisce un triangolo assegnati i tre angoli e un criterio di scelta tra gli infiniti triangoli della data forma */ Triangolo(double a[], char c) {double p = 1.0; fatto = a[0] > 0.0 && a[1] > 0.0 && a[2] > 0.0 && fabs(a[0]+a[1]+a[2] - M PI) < 1.e-12; if(!fatto) {cerr << "gli angoli assegnati: " << a[0] << << a[1] << << a[2] << " (la cui somma vale " << a[0]+a[1]+a[2] <<") non possono appartenere a un triangolo\n"; return;} angoli[0] = a[0], angoli[1] = a[1], angoli[2] = a[2], determinaforma(), lati[0] = 1.0, lati[1] = sin(angoli[1])/sin(angoli[0]), lati[2] = sin(angoli[2])/sin(angoli[0]), ordinalati(); switch(c) {case PERIMETRO UNITARIO: p = Perimetro(), lati[0] /= p, lati[1] /= p, lati[2] /= p; case AREA UNITARIA: p = sqrt(area()), lati[0] /= p, lati[1] /= p, lati[2] /= p;} /* overload dell operator []: restituisce uno dei centri di un triangolo, secondo il valore trasferito come argomento e dichiarato in direttive define */ double * operator[](char c) {double * r; switch(c) {case ORTHO: case BARIC: case CIRCO: case INCEN: r = centri[c]; default: r = 0;} return r;}}; /* FINE DELLA CLASSE PER I TRIANGOLI */ /* variabili statiche */ enum Triangolo :: regolarita Triangolo :: regolarita; enum Triangolo :: forma Triangolo :: forma; const char * Triangolo :: descrizioni regolarita[] = {" equilatero ", " isoscele ", " scaleno "}; const char * Triangolo :: descrizioni forma[] = {" ", " acutangolo ", " rettangolo ", " ottusangolo "};

8 /* friend operator di output: modificabile a piacimento */ ostream & operator << (ostream & stream, Triangolo t) { int ** gradi minuti secondi = converti(t.angoli); char l; stream << setiosflags(ios::fixed) << setprecision(3) << "informazioni relative a un triangolo" << t.caratteristiche[0] << \b << t.caratteristiche[1] << "\b:\n"; switch(t.regolarita) {case Triangolo :: equilatero: stream << "lato = " << t.lati[0]<<endl, stream << "angolo = \n"; case Triangolo :: isoscele: switch(t.forma) { case Triangolo :: ottusangolo: case Triangolo :: acutangolo: l = 2 * (t.forma == Triangolo :: acutangolo), stream << "base = " << t.lati[t.i[l]] << endl, stream << "lato obliquo = " << t.lati[t.i[2-l]] << endl, stream << "angolo al vertice = " << gradi minuti secondi[t.i[l]][0] << << gradi minuti secondi[t.i[l]][1] << << gradi minuti secondi[t.i[l]][2]<< endl, stream << "angolo alla base = " << gradi minuti secondi[t.i[2-l]][0] << << gradi minuti secondi[t.i[2-l]][1] << << gradi minuti secondi[t.i[2-l]][2]<< endl; case Triangolo :: rettangolo: stream << "ipotenusa = " << t.lati[t.i[0]] << endl, stream << "cateto = " << t.lati[t.i[1]] << endl, stream << "angolo acuto = \n";} case Triangolo :: scaleno: switch(t.forma) { case Triangolo :: ottusangolo: case Triangolo :: acutangolo: stream << "lati: " << t.lati[0] << << t.lati[1] << << t.lati[2] << endl, stream << "angoli:" << gradi minuti secondi[t.i[0]][0] << << gradi minuti secondi[t.i[0]][1] << << gradi minuti secondi[t.i[0]][2] << "; " << gradi minuti secondi[t.i[1]][0] << << gradi minuti secondi[t.i[1]][1] << << gradi minuti secondi[t.i[1]][2] << "; " << gradi minuti secondi[t.i[2]][0] << << gradi minuti secondi[t.i[2]][1] << << gradi minuti secondi[t.i[2]][2] << \n ; case Triangolo :: rettangolo: stream << "ipotenusa = " << t.lati[t.i[0]] << endl, stream << "cateti: " << t.lati[t.i[1]] << << t.lati[t.i[2]] << endl, stream << "angoli acuti:" << gradi minuti secondi[t.i[1]][0] <<

9 << gradi minuti secondi[t.i[1]][1] << << gradi minuti secondi[t.i[1]][2] << "; " << gradi minuti secondi[t.i[2]][0] << << gradi minuti secondi[t.i[2]][1] << << gradi minuti secondi[t.i[2]][2] << \n ;}} stream << "il perimetro del triangolo vale " << t.perimetro()<<"\ne l area vale " << t.area() << endl; return stream;}