Equazione 2° grado con bluej

[niky89]

Ciao a tutti vorrei sapere come programmare la risoluzione di una equazione di secondo grado con bluej... grazie ciao

[PGI-Bis]

Se per BlueJ intendi questo IDE Java qui allora immagino che il problema si risolva come con un comune programma Java.

Frazioni e -B + 2AC x HK radice del pim pum pam.

Armato di google ho prodotto la seguente immondizia che non userei per risolvere un compito di matematica neanche alle elementari MA è molto divertente .

import java.util.*;
import java.io.*;

public class Main {

	public static void main(String[] args) {
		PrintStream out = System.out;
		out.println("Inserire i valori dei coefficienti A, B e C separati da uno spazio");
		out.println("Es: 1 -4 5/7");
		out.println("Es: 3/2 0 0");
		String line = new Scanner(System.in).nextLine();
		StringTokenizer tk = new StringTokenizer(line);
		Fraction a = toFraction(tk.nextToken());
		Fraction b = toFraction(tk.nextToken());
		Fraction c = toFraction(tk.nextToken());
		Biqua qua = new Biqua(a, b, c);
		qua.solve();
		qua.dumpSolution();
	}
	
	private static Fraction toFraction(String token) {
		StringTokenizer tk = new StringTokenizer(token, "/");
		int num = Integer.parseInt(tk.nextToken());
		int den = 1;
		if(tk.hasMoreTokens()) {
			den = Integer.parseInt(tk.nextToken());
		}
		return new Fraction(num, den);
	}
}

/** Rappresentazione di un'equazioned di secondo grado */
class Biqua {
	/* coefficienti dell'equazione */
	private Fraction a, b, c;
	/* risultati dell'equazione */
	private Number solutionOne, solutionTwo;
	/* true se l'equazione sia stata risolta */
	private boolean solved = false;
	
	/** Crea un'equazione con i coefficienti a, b e c (forma
	normale Ax^2 + Bx + C = 0) */
	public Biqua(Fraction a, Fraction b, Fraction c) {
		this.a = a;
		this.b = b;
		this.c = c;
	}
	
	public Number getX1() {
		return solutionOne;
	}
	
	public Number getX2() {
		return solutionTwo;
	}
	
	public void dumpSolution() {
		if(!solved) {
			solve();
		}
		if(solutionOne == null && solutionTwo == null) {
			System.out.println("Nessuna soluzione");
		} else if(solutionOne != null && solutionTwo == null) {
			System.out.println("Una soluzione: x = " + solutionOne);
		} else {
			System.out.println("Due soluzioni: x1 = " + solutionOne + " x2 = " + solutionTwo);
		}
	}
	
	/** Restituisce una rappresentazione testuale di
	questa equazione */
	public String toString() {
		return a + " " + b + " " + c;
	}
	
	/** Risolve l'equazione */
	public void solve() {
		if(b.equals(0) && c.equals(0)) {
			monoSolve();
		} else if(c.equals(0)) {
			spuriousSolve();
		} else if(b.equals(0)) {
			pureSolve();
		} else {
			completeSolve();
		}
		solved = true;
	}
	
	private void monoSolve() {
		//Ax^2 = 0
		solutionOne = 0;
	}
	
	private void spuriousSolve() {
		//Ax^2 + B = 0
		Fraction x2 = b.clone().multiply(-1).divide(a);
		solutionOne = 0;
		solutionTwo = x2;
	}
	
	private void pureSolve() {
		//x^2 = -C/A
		if(c.signum() == a.signum()) {
			System.out.println("Nessuna soluzione");
		} else {
			Fraction ca = c.clone().divide(a).multiply(-1);
			boolean sqr = ca.squareRoot();
			if(sqr) {
				Fraction x1 = ca.clone().multiply(-1);
				Fraction x2 = ca;
				solutionOne = x1;
				solutionTwo = x2;
				//System.out.println("Due soluzioni, x1 = " + x1 + " x2 = " + x2);
			} else {
				double doubleSqr = ca.squareRootAsDouble();
				double x1 = -1 * doubleSqr;
				double x2 = +1 * doubleSqr;
				solutionOne = x1;
				solutionTwo = x2;
				//System.out.println("Due soluzioni \"irrazionali\", x1 = " + x1 + " x2 = " + x2);
			}
		}
	}
	
	private void completeSolve() {
		//Ax^2 + Bx + C
		Fraction disc = b.clone().pow(2).sum(a.clone().multiply(c).multiply(-4));
		if(disc.signum() < 0) {
			System.out.println("Discriminante negativo.");
		} else {
			boolean sqr = disc.squareRoot();
			if(sqr) {
				Fraction a2 = a.clone().multiply(2);
				Fraction x1 = b.clone().multiply(-1).sum(disc).divide(a2);
				Fraction x2 = b.clone().multiply(-1).subtract(disc).divide(a2);
				solutionOne = x1;
				solutionTwo = x2;
				//System.out.println("Due soluzioni, x1 = " + x1 + " x2 = " + x2);
			} else {
				double squareRoot = disc.squareRootAsDouble();
				double bDouble = -1 * b.doubleValue();
				double a2 = a.doubleValue() * 2;
				double x1 = (bDouble + squareRoot) / a2;
				double x2 = (bDouble - squareRoot) / a2;
				solutionOne = x1;
				solutionTwo = x2;
				//System.out.println("Due soluzioni \"irrazionali\", x1 = " + x1 + " x2 = "+ x2); 
			}
		}
	}
}

/** Una frazione */
class Fraction extends Number {
	/* den sta per denominatore, num sta per numeratore, come
	in 2/4, 2 = numeratore, 4 = denominatore */
	private int den, num;
	
	/** Inizializza una frazione con denominatore unitario */
	public Fraction(int num) {
		this(num, 1);
	}
	
	/** Inizializza una frazione con il numeratore num ed il denominatore
	den */
	public Fraction(int num, int den) throws IllegalArgumentException {
		if(den == 0) throw new IllegalArgumentException("Denominator cannot be 0");
		this.den = den;
		this.num = num;
		reduce();
	}
	
	public byte byteValue() {
		return (byte)doubleValue();
	}
	
	public short shortValue() {
		return (short)doubleValue();
	}
	
	public float floatValue() {
		return (float)doubleValue();
	}
	
	public int intValue() {
		return num / den;
	}
	
	public long longValue() {
		return intValue();
	}
	
	/** Restituisce il segno di questa frazione */
	public int signum() {
		return (int)(Math.signum(den) * Math.signum(num));
	}
	
	/* true se questa frazione abbia un valore pari
	all'intero in argomento */
	public boolean equals(int value) {
		if(value == 0) return num == 0;
		return equals(new Fraction(value, 1));
	}
	
	/* true se questa frazione abbia il valore della
	frazione in argomento */
	public boolean equals(Fraction that) {
		that.reduce();
		reduce();
		return
			den == that.den &&
			num == that.num;
	}
	
	/** Restituisce la radice quadrata di questa
	frazione in formato double */
	public double squareRootAsDouble() {
		return Math.sqrt(num) / Math.sqrt(den);
	}
	
	/** Restituisce il valore di questa frazione
	in formato double */
	public double doubleValue() {
		return (double)num / (double)den;
	}
	
	/** Trasforma questa frazione nella radice quadrata
	di sè stessa e restituisce true se tale radice sia un
	numero razionale (un numero che può essere espresso
	tramite una frazione). Altrimenti restituisce false. */
	public boolean squareRoot() {
		/* Molto finemente, se le radici del numeratore
		e del denominatore sono numeri interi, allora
		la radice della frazione è considerata
		razionale */
		boolean result = false;
		double denSqrt = Math.sqrt(den);
		double numSqrt = Math.sqrt(num);
		int intDenSqrt = (int)denSqrt;
		int intNumSqrt = (int)numSqrt;
		if(intDenSqrt == denSqrt && intNumSqrt == numSqrt) {
			result = true;
			den = intDenSqrt;
			num = intNumSqrt;
		}
		return result;
	}
	
	/** Trasforma questa frazione nell'elevamento
	a potenza factor di sè stessa */
	public Fraction pow(int factor) {
		den = (int)Math.pow(den, factor);
		num = (int)Math.pow(num, factor);
		reduce();
		return this;
	}
	
	/** Trasforma questa frazione nel risultato della
	moltiplicazione di questa frazione con l'intero
	factor */
	public Fraction multiply(int factor) {
		num *= factor;
		reduce();
		return this;
	}
	
	/* Trasforma questa frazione nel risultato della
	moltiplicazione tra questa frazione e la frazione
	in argomento */
	public Fraction multiply(Fraction that) {
		den *= that.den;
		num *= that.num;
		reduce();
		return this;
	}
	
	/** Trasforma questa frazione nel risultato della
	divisione di questa frazione per quella in
	argomento */
	public Fraction divide(Fraction that) {
		den *= that.num;
		num *= that.den;
		reduce();
		return this;
	}
	
	/** Trasforma questa frazione nel risultato
	della sottrazione della frazione in argomento
	a questa frazione */
	public Fraction subtract(Fraction that) {
		int newDen = den * that.den;
		int newNum = num * that.den - den * that.num;
		num = newNum;
		den = newDen;
		reduce();
		return this;
	}
	
	/** Trasforma questa frazione nel risultato
	della somma tra questa frazione e quella in
	argomento */
	public Fraction sum(Fraction that) {
		int newDen = den * that.den;
		int newNum = den * that.num + num * that.den;
		num = newNum;
		den = newDen;
		reduce();
		return this;
	}
	
	/** Crea un duplicato autonomo di questa
	frazione */
	public Fraction clone() {
		return new Fraction(num, den);
	}
	
	/** Riduce la frazione */
	private void reduce() {
		int div = maxCommonDivisor(Math.abs(num), Math.abs(den));
		if(div > 1) {
			num /= div;
			den /= div;
		}
		if(Math.signum(den) < 0) {
			num *= -1;
			den *= -1;
		}
	}
	
	/* Restituisce il massimo comune divisore dei numeri
	a e b */
	private int maxCommonDivisor(int a, int b) {
		if(b == 0) return a;
		return maxCommonDivisor(b, a % b);
	}
	
	/** Restituisce una rappresentazione in formato
	stringa di questa frazione */
	public String toString() {
		return 
			den == 1 ?
			String.valueOf(num) :
			"(" + num + "/" + den + ")";
	}
}

Molto teoricamente, dovrebbe maneggiare, finchè può, delle frazioni. Tipo:

due ics quadro meno cinque ics più due fa due e un mezzo

quattro noni ics quadro meno uno fa men tre mezzi e tre mezzi

mentre

ics quadro meno due fa meno 1.4142135623730951 e più 1.4142135623730951 perchè la radice di due è irrazionale.

Non garantisco neanche che parta .

[lovaz]

Scusa, ma...

...
float s1 = -b + pim pum pam,
s2 = -b - pim pum pam;

System.out.println("x1: " + s1 + "\nx2" + s2);
...

E poi basta 'na calcolatrice, o la console di python, o octave, o matlab, o C, o basic (!)...

[PGI-Bis]

A volte uno programma perchè è divertente.

[lovaz]

Certo, non era mica una critica a te...

Solo mi sembrava strano che chiedesse una cosa del genere