Commits

Germano Gabbianelli committed 6aaaa2a

Modifiche finali.

  • Participants
  • Parent commits d1ec327

Comments (0)

Files changed (5)

Calcolatrice.java

+import fiji.io.*;
+
 class Calcolatrice {
+
+    public static void aggiungiDaTastiera() {
+        Numero risultato;
+        NumeroRelativo numero1, numero2;
+        int esponente;
+        String numero;
+        char aggiungi,operazione;
+        aggiungi = 's';
+        while(aggiungi == 's'){
+            System.out.print("\nScrivi un numero: ");
+            numero = Lettore.in.leggiString();
+            numero1 = new NumeroRelativo(numero);
+            System.out.println("Scegli l'operazione che vuoi eseguire");
+            System.out.print("Somma(+); Prodotto(*); Divisione(/); Fattoriale(!); Potenza(^): ");
+            operazione = Lettore.in.leggiChar();
+
+            // Se l'operazione richiesta è l'addizione
+            if(operazione == '+') {
+                System.out.print("Scrivi il numero che vuoi sommare: ");
+                numero = Lettore.in.leggiString();
+                numero2 = new NumeroRelativo(numero);
+                risultato = numero1.somma(numero2);
+                System.out.println(numero1 + " + " + numero2 + " == " + risultato);
+            }
+            // Se l'operazione richiesta è la moltiplicazione
+            else if(operazione == '*'){
+                System.out.print("Scrivi il numero che vuoi moltiplicare: ");
+                numero = Lettore.in.leggiString();
+                numero2 = new NumeroRelativo(numero);
+                risultato = numero1.moltiplica(numero2);
+                System.out.println(numero1 + " * " + numero2 + " == " + risultato);
+            }
+            // Se l'operazione richiesta è il fattoriale
+            else if(operazione == '!') {
+                risultato = numero1.fattoriale();
+                System.out.println(numero1 + " ! == " + risultato);
+            }
+            // Se l'operazione richiesta è l'elevamento a potenza
+            else if(operazione == '^') {
+                System.out.print("Scrivi l'esponente: ");
+                esponente = Lettore.in.leggiInt();
+                risultato = numero1.potenza(esponente);
+                System.out.println(numero1 + " ^ "+ esponente + " == " + risultato);
+            } else if (operazione == '/') {
+                System.out.print("Scrivi il numero che vuoi moltiplicare: ");
+                numero = Lettore.in.leggiString();
+                numero2 = new NumeroRelativo(numero);
+                risultato = numero1.dividi(numero2);
+                System.out.println(numero1 + " / " + numero2 + " == " + risultato);
+            }
+            // Se viene commesso un errore di battitura
+            else {
+                System.out.println("Error: operazione non riconosciuta");
+                aggiungi = 's';
+            }
+
+            System.out.print("Vuoi compiere una nuova operazione? [s/N]: ");
+            aggiungi = Lettore.in.leggiChar();
+        }
+
+    }
+
     public static void main(String[] args) {
-        Test.testNodoLista();
-        Test.testNumero();
-        Test.testNumeroRelativo();
+        char comando;
+        System.out.print("Premere T per eseguire i test, C per compiere operazioni: ");
+        comando = Lettore.in.leggiChar();
+
+        while(comando != 'T' && comando != 'C') {
+            System.out.println("Error: operazione non riconosciuta");
+            System.out.print("Premere T per eseguire i test, C per compiere operazioni: ");
+            comando = Lettore.in.leggiChar();
+        }
+        if (comando == 'T') {
+            Test.testNodoLista();
+            Test.testNumero();
+            Test.testNumeroRelativo();
+        } else if (comando == 'C') {
+            aggiungiDaTastiera();
+        }
+
     }
+
 }
     }
 
     public boolean equals(NodoLista nodo) {
+        boolean continua, uguali;
         NodoLista me = this;
+        continua = uguali = true;
 
-        while (me != null) {
-            if (nodo == null || me.info != nodo.info)
-                return false;
-            else if (me.next == nodo.next)
-                return true;
-            me = me.next;
-            nodo = nodo.next;
+        while (me != null && continua) {
+            if (nodo == null || me.info != nodo.info) {
+                continua = uguali = false;
+            } else if (me.next == nodo.next) {
+                continua = false;
+            } else {
+                me = me.next;
+                nodo = nodo.next;
+            }
         }
-        if (nodo != null)
-            return false;
-        else
-            return true;
+        if (me == null && nodo != null)
+            uguali = false;
 
+        return uguali;
     }
 
     public static NodoLista daArray(int[] cifre) {
     protected NodoLista cifre;
     protected int lunghezza;
 
+    // Costruttore vuoto, serve a java per la subclass.
     public Numero() {
         this.lunghezza = 0;
     }
 
+    // Costruttore che crea un numero da una stringa.
     public Numero(String numero) {
         this.daStringa(numero);
     }
         return this.lunghezza;
     }
 
+    // Metodo d'appoggio per il costruttore. Inizializza il numero a partire da
+    // una stringa.
     protected void daStringa(String numero) {
         int cifra = Character.getNumericValue(numero.charAt(0));
         NodoLista nodo = new NodoLista(cifra, null);
         return rappr;
     }
 
+    // Somma il numero corrente a quello passato come argomento, restituendo un
+    // nuovo numero (senza side-effects).
     public Numero somma(Numero numero) {
         NodoLista primo, risultato;
         int x = 0;
         return new Numero(primo.next, lunghezza);
     }
 
+    // Calcola la n-esima potenza del numero corrente.
     public Numero potenza(int esponente) {
         Numero risultato = this;
+        if (esponente == 0)
+            risultato = new Numero("1");
         while (esponente > 1) {
             risultato = risultato.moltiplica(this);
             esponente--;
         return risultato;
     }
 
+    // Moltiplica il numero corrente per il numero passato come argomento,
+    // restituendo un nuovo numero.
     public Numero moltiplica(Numero numero) {
         NodoLista risultato;
         int lunghezza = 1;
         return new Numero(risultato, lunghezza);
     }
 
+    // Restituisce "true" se il numero corrente è diverso da zero, altrimenti
+    // "false".
     public boolean nonZero() {
         return (this.cifre.info != 0 || this.lunghezza > 1);
     }
 
+    // Restituisce "true" se il numero corrente è uguale a quello passato come
+    // argomento (sfrutta NodoLista.equals).
     public boolean equals(Numero numero) {
         return this.cifre.equals(numero.cifre);
     }
 
+    // Restituisce zero se il numero corrente è uguale a quello passato come
+    // argomento, un intero maggiore di zero se è maggiore, o un intero minore
+    // di zero se è minore.
     public int compareTo(Numero numero) {
         int risultato = 1;
         if (this.lunghezza == numero.lunghezza) {

NumeroRelativo.java

+// Sottoclasse di Numero che rappresenta un numero relativo.
 class NumeroRelativo extends Numero {
     protected boolean positivo;
 
+    // Costruttore che crea un numero da una stringa.
     public NumeroRelativo(String numero) {
         this.daStringa(numero);
     }
         this.positivo = positivo;
     }
 
+    public boolean getPositivo() {
+        return this.positivo;
+    }
+
+    // Metodo che inizializza il numero a partire da una stringa
+    // (Sfrutta il metodo Numero.daStringa usando super).
     protected void daStringa(String numero) {
         this.positivo = true;
         if (numero.charAt(0) == '-') {
         super.daStringa(numero);
     }
 
+    // Somma di due numeri relativi, tiene conto del segno ed effettua una
+    // sottrazione dove necessario.
     public NumeroRelativo somma(NumeroRelativo numero) {
         // -5 + 4 => 4-5    5 + -4 => 5 - 4
         NumeroRelativo risultato;
         return risultato;
     }
 
-    // a - b == a + (-b)
+    // Sottrazione tra due numeri relativi, può essere ricondotta alla somma
+    // negando il secondo addendo: a - b == a + (-b)
     public NumeroRelativo sottrai(NumeroRelativo numero) {
         return somma(new NumeroRelativo(numero.cifre, numero.lunghezza, !numero.positivo));
     }
 
+    // Moltiplicazione tra numeri relativi, sfrutta Numero.moltiplicazione
+    // tenendo conto del segno.
+    public NumeroRelativo moltiplica(NumeroRelativo numero) {
+        Numero molt = super.moltiplica(numero);
+        NumeroRelativo risultato = new NumeroRelativo(molt.cifre, molt.lunghezza, true);
+        if (this.positivo != numero.positivo)
+            risultato.positivo = false;
+        return risultato;
+    }
+
+    // Metodo privato che effettua la sottrazione tra due numeri.
+    // Può essere richiamato sia da somma che da sottrai.
     private NumeroRelativo differenza(NumeroRelativo numero) {
         NodoLista nodo1, nodo2, appoggio, sott;
         int riporto, lunghezza;
         return rappr;
     }
 
+    // Calcola il fattoriale di un numero richiamando il metodo privato
+    public NumeroRelativo fattoriale() {
+        return fattoriale(this);
+    }
+
+    // Il metodo fattoriale richiamato
+    private NumeroRelativo fattoriale(NumeroRelativo numero) {
+        NumeroRelativo risultato, uno;
+        uno = new NumeroRelativo("1");
+        if (numero.nonZero())
+            risultato = fattoriale(numero.sottrai(uno)).moltiplica(numero);
+        else
+            risultato = uno;
+        return risultato;
+    }
+
+
+    // Bernardini:
+
+	private NumeroRelativo aggiungi(int k) {
+		NodoLista nodo,appoggio;
+		int lung;
+		NumeroRelativo result;
+		nodo = new NodoLista();
+		appoggio = nodo;
+		lung = 0;
+		appoggio.next = new NodoLista(k,null);
+		appoggio = appoggio.next;
+		lung = 1;
+		while(this.cifre!=null) {
+			appoggio.next = new NodoLista(this.cifre.info,null);
+			appoggio = appoggio.next;
+			this.cifre = this.cifre.next;
+			lung++;
+		}
+		result = new NumeroRelativo(nodo.next,lung,true);
+		return result;
+	}
+
+	private NumeroRelativo divisione(NumeroRelativo num) {
+			NumeroRelativo result,sottr,somm;
+			sottr = this;
+			NodoLista div,appoggio,dendo;
+			result = new NumeroRelativo(new NodoLista(0,null),1,true);
+			// while (sottr.maggiorUguale(num)) {
+            while (sottr.compareTo(num) >= 0) {
+				sottr = sottr.differenza(num);
+				result = result.somma(new NumeroRelativo(new NodoLista(1,null),1,true));
+			}
+			return result;
+		}
+
+	private NumeroRelativo resto(NumeroRelativo num) {
+		int lung;
+		lung = 0;
+		NumeroRelativo rest,div,quoz;
+		div = this;
+		// if (div.maggiorUguale(num))
+        if (div.compareTo(num) >= 0)
+			rest = div;
+		else {
+			quoz = div.divisione(num);
+			rest = div.differenza(quoz.moltiplica(num));
+		}
+		return rest;
+	}
+
+	public NumeroRelativo dividi(NumeroRelativo num) {
+		NumeroRelativo result,div,quoto;
+		NumeroRelativo copiaendo,copiadivis;
+		int k,j;
+		copiaendo = this;
+		copiadivis = num;
+		boolean ferma;
+		div = this;
+		quoto = new NumeroRelativo(new NodoLista(),0,true);
+		ferma = false;
+		k = this.getLunghezza();
+		result = new NumeroRelativo(new NodoLista(),0,true);
+		// if (div.maggiorUguale(num)) {
+        if (div.compareTo(num) >= 0) {
+			while (div.cifre.next!=null)
+				div.cifre = div.cifre.next;
+			while (!ferma && k!=0) {
+				//if (!quoto.maggiorUguale(num)) {
+                if (quoto.compareTo(num) < 0) {
+					quoto = quoto.aggiungi(div.cifre.info);
+					div = copiaendo;
+					k--;
+					j = k;
+					while (j!=1) {
+						div.cifre = div.cifre.next;
+						j--;
+					}
+				}
+				else {
+					result = result.aggiungi((quoto.divisione(num)).cifre.info);
+					quoto = quoto.resto(num);
+					ferma = true;
+				}
+			}
+			while (k!=0) {
+				quoto = quoto.aggiungi(div.cifre.info);
+				result = result.aggiungi((quoto.divisione(num)).cifre.info);
+				quoto = quoto.resto(num);
+				div = copiaendo;
+				k--;
+				j = k;
+				while (j!=1) {
+					div.cifre = div.cifre.next;
+					j--;
+				}
+			}
+		}
+		return result;
+	}
 
 }
         System.out.println(max_int.somma(c) + " == 2147722196");
 
         // test moltiplica
-        // XXX testare moltiplicazioni per numeri di una cifra
-        // XXX testare lunghezza
         System.out.println(zero.moltiplica(zero) + " == 0");
         System.out.println(b.moltiplica(c) + " == 27433135");
         System.out.println(c.moltiplica(b) + " == 27433135");