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 (http://www.bluej.org/) 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 :D.

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 :D.

[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... :D

Solo mi sembrava strano che chiedesse una cosa del genere :mc: