//<APPLET WIDTH=387 HEIGHT=395 CODE="QuadForm.class"></APPLET>
import java.io.*;
import java.awt.*;
import java.applet.*;
import java.math.*;

public class QuadForm extends Applet {
	Image title;
	final Color back = new Color(178,221,238);

///////// Global Panels //////////
	TextField tfa, tfb, tfc, tf1, tf2, tf11, tf12, tf21, tf22;
	Choice ch;
	Calculations c1;
	ExactCalc c2;
//////////////////////////////////
	static boolean aiszero, biszero, ciszero;

	public void init(){
		title = getImage(getCodeBase(),"title.gif");
		setBackground(back);
		c1 = new Calculations();
		c2 = new ExactCalc();
		initPanels();
		aiszero = false;
		ciszero =false;
		biszero = false;
	}

	public void initPanels(){
		setLayout(new BorderLayout());

		tfa = new TextField(9);
		tfb = new TextField(9);
		tfc = new TextField(9);

		Panel c = new Panel();
		c.setLayout(new BorderLayout(10,10));

	
		Panel p5 = new Panel();
		p5.setLayout(new BorderLayout(5,5));
	
		Panel p = new Panel();
		p.setLayout(new BorderLayout(5,5));

		Panel b_out= new Panel();
		b_out.add(new Label(" a:"));
		b_out.add(tfa);
		b_out.add(new Label(" b:"));
		b_out.add(tfb);
		b_out.add(new Label(" c:"));
		b_out.add(tfc);
		c.add("North",b_out);
	
		Panel c_Pan= new Panel();
		c_Pan.add(new Label("Precision:"));
		ch = new Choice();
		ch.addItem("1");
		ch.addItem("2");
		ch.addItem("3");
		ch.addItem("4");
		ch.addItem("5");
		ch.addItem("6");
		ch.addItem("7");
		ch.addItem("8");
		ch.addItem("9");
		ch.addItem("10");
		ch.select(3);
		c_Pan.add(ch);


		Panel b_Pan= new Panel();
		b_Pan.setLayout(new GridLayout(5,1));
		b_Pan.add(new Button("Choose Random"));
		b_Pan.add(new Button("Choose Example"));
		b_Pan.add(new Button("Scale by Largest"));
		b_Pan.add(new Button("Calculate"));
		b_Pan.add(c_Pan);
		p.add("West",b_Pan);

		p5.add("South",c2);

		p.add("Center",c1);
		c.add("Center",p);
		p5.add("Center",c);
		add("South",p5);
	}

	public void paint(Graphics g){
		g.drawImage(title,12,15,this);
	}

	public boolean action(Event evt, Object arg){
		String s = (String)arg;
		ciszero = false;
		aiszero = false;
		biszero = false;

		if (s.equals("Choose Example")) 
			setText(new BigDecimal("0.05010"),new BigDecimal("-98.78"),
				  new BigDecimal("5.015"));
	
		if (s.equals("Choose Random")) 
			fixRandom();

		if (s.equals("Scale by Largest")) 
			scaleLargest();

		if (!s.equals("Calculate")){
			c1.show = false;
			c2.show = false;
		} else
			calculate(new BigDecimal(tfa.getText()),new BigDecimal(tfb.getText()),
				  new BigDecimal(tfc.getText()));

		c1.repaint();
		c2.repaint();
		return true;
	}
//
//////////////////////////////////// Action Functions ////////////////////////
//
public void calculate(BigDecimal a, BigDecimal b, BigDecimal c){
	setText(a,b,c);
	a = correctScale(a);
	b = correctScale(b);
	c = correctScale(c);
	if (noZero(a,b,c)) {
		aiszero = false;
		ciszero = false;
		c1.set(quad(a,b,c),b.multiply(new BigDecimal("-1")));
		c2.set(quadExact(a,b,c)[0],quadExact(a,b,c)[1]);
	} 
}

public void setText(BigDecimal a, BigDecimal b, BigDecimal c){
	a = correctScale(a);
	b = correctScale(b);
	c = correctScale(c);

	tfa.setText(a.toString());
	tfb.setText(b.toString());
	tfc.setText(c.toString());
}

public void calculateImagine(BigDecimal a,BigDecimal b, BigDecimal c){
	BigDecimal discriminant = getDiscriminantExact(a,b,c);
	BigDecimal two = new BigDecimal("2.0");
	BigDecimal x = (b.negate()).divide(a.multiply(two),30,BigDecimal.ROUND_HALF_UP);
	BigDecimal y = sqrt(discriminant.negate()).divide(a.multiply(two),30,BigDecimal.ROUND_HALF_UP);
	c2.setSpecial(correctScale(x.negate()).toString()+"+i*"+correctScale(y.negate()).toString(),
	correctScale(x.negate()).toString()+"-i*"+correctScale(y.negate()).toString());
}
//
//////////////////////////////////// Math Functions ////////////////////////
//
public boolean noZero(BigDecimal a,BigDecimal b, BigDecimal c){
	boolean stat = true;
	BigDecimal zero = new BigDecimal("0");
	System.out.println("here: "+zero.toString() +" "+ a.toString());
	if (b.compareTo(zero) == 0 && a.compareTo(zero)==0){
		stat = false;
		c1.show = false;
		biszero = true;
		ciszero = false;
		aiszero = false;
		c2.setSpecial("Division by zero",", there are no roots.");
		repaint();
	} else
	if (a.compareTo(zero) == 0){
		stat = false;
		c1.show = false;
		aiszero = true;
		ciszero = false;
		biszero = false;
		c2.setSpecial(correctScale(c.negate().divide(b,30,BigDecimal.ROUND_HALF_UP)).toString()," there is only 1 root.");
	} else
	if (c.compareTo(zero) == 0){
		stat = false;
		c1.show = false;
		ciszero = true;
		aiszero = false;
		biszero = false;
		c2.setSpecial(correctScale(b.negate().divide(a,30,BigDecimal.ROUND_HALF_UP)).toString()," there is only 1 root.");
	} else 
	if (getDiscriminantExact(a,b,c).compareTo(zero) < 0){
		stat = false;
		repaint();
		calculateImagine(a,b,c);		
	}
	return stat;
}

public BigDecimal sqrt(BigDecimal b){
	BigDecimal a = new BigDecimal(".5");
	BigDecimal prev = b.multiply(a);
	for (int i=0;i<25;i++)
		prev = a.multiply(prev.add(b.divide(prev,30,BigDecimal.ROUND_HALF_EVEN)));
	return prev;
}

public void fixRandom(){
	BigDecimal a,b,c;
	a = new BigDecimal(""+(Math.random()-.5)*2000);
	b = new BigDecimal(""+(Math.random()-.5)*2000);
	c = new BigDecimal(""+(Math.random()-.5)*2000);
	setText(a,b,c);
}

public void scaleLargest(){
	int pr = 1+ ch.getSelectedIndex();
	BigDecimal a,b,c,a1,b1,c1;
	a = new BigDecimal(tfa.getText());
	b = new BigDecimal(tfb.getText());
	c = new BigDecimal(tfc.getText());

	a1 = a.abs();
	b1 = b.abs();
	c1 = c.abs();
	if (a1.compareTo(b1)>=0 && a1.compareTo(c1) >= 0) {
		b = b.divide(a,30,BigDecimal.ROUND_HALF_DOWN);
		c = c.divide(a,30,BigDecimal.ROUND_HALF_DOWN);
		a = new BigDecimal("1.0");
	} else if (b1.compareTo(a1)>=0 && b1.compareTo(c1) >= 0) {
		a = a.divide(b,30,BigDecimal.ROUND_HALF_DOWN);
		c = c.divide(b,30,BigDecimal.ROUND_HALF_DOWN);
		b = new BigDecimal("1.0");
	} else if (c1.compareTo(b1)>=0 && c1.compareTo(a1) >= 0) {
		a = a.divide(c,30,BigDecimal.ROUND_HALF_DOWN);
		b = b.divide(c,30,BigDecimal.ROUND_HALF_DOWN);
		c = new BigDecimal("1.0");
	}
	setText(a,b,c);
}

public BigDecimal getDiscriminantExact(BigDecimal a, BigDecimal b, BigDecimal c){
	BigDecimal discriminant = b.multiply(b);
	BigDecimal part2 = a.multiply(c);
	part2 = part2.multiply(new BigDecimal("4"));
	return discriminant.subtract(part2);
}

public BigDecimal[] quadExact(BigDecimal a, BigDecimal b, BigDecimal c){
	int pr = 25;
	BigDecimal discriminant = sqrt(getDiscriminantExact(a,b,c));

	BigDecimal x[] = new BigDecimal[2];
	b = b.negate();
	c = c.multiply(new BigDecimal("2"));
	a = a.multiply(new BigDecimal("2"));

	x[0] = b.add(discriminant);
	x[0] = x[0].divide(a,pr,BigDecimal.ROUND_HALF_EVEN);

	x[1] = b.subtract(discriminant);
	x[1] = x[1].divide(a,pr,BigDecimal.ROUND_HALF_EVEN);

	x[0] = correctScale(x[0]);
	x[1] = correctScale(x[1]);

	return x;
}

public BigDecimal getDiscriminant(BigDecimal a, BigDecimal b, BigDecimal c){
	BigDecimal discriminant = correctScale(b.multiply(b));
	BigDecimal part2 = correctScale(a.multiply(c));
	part2 = correctScale(part2.multiply(new BigDecimal("4")));
	return correctScale(discriminant.subtract(part2));
}

public BigDecimal[] quad(BigDecimal a, BigDecimal b, BigDecimal c){
	BigDecimal discriminant = correctScale(sqrt(getDiscriminant(a,b,c)));

	BigDecimal x[] = new BigDecimal[7];
	b = b.negate();
	c = correctScale(c.multiply(new BigDecimal("2")));
	a = correctScale(a.multiply(new BigDecimal("2")));

	x[0] = b.add(discriminant);
	try {
	x[0] = x[0].divide(a,30,BigDecimal.ROUND_HALF_DOWN);
	}catch(ArithmeticException e){ x[0] = new BigDecimal("0");}

	x[1] = b.subtract(discriminant);
	try {
	x[1] = x[1].divide(a,30,BigDecimal.ROUND_HALF_DOWN);
	}catch(ArithmeticException e){ x[1] = new BigDecimal("0");}

	x[2] = b.subtract(discriminant);
	try {
	x[2] = c.divide(x[2],30,BigDecimal.ROUND_HALF_DOWN);
	}catch(ArithmeticException e){ x[2] = new BigDecimal("0");}

	x[3] = b.add(discriminant);
	try{
	x[3] = c.divide(x[3],30,BigDecimal.ROUND_HALF_DOWN);	//x[0] = (-b+discriminant)/(2*a);
	}catch(ArithmeticException e){ x[3] = new BigDecimal("0");}

	x[0] = correctScale(x[0]);
	x[1] = correctScale(x[1]);
	x[2] = correctScale(x[2]);
	x[3] = correctScale(x[3]);

	x[4] = discriminant;
	x[5] = a;
	x[6] = c;

	return x;
}

public BigDecimal correctScale(BigDecimal b){
	int sc = 1+ch.getSelectedIndex();
	boolean stillZero = true;
	int x = b.toString().indexOf('.');
	if (x < 0)
		x = b.toString().length();

	b = b.movePointLeft(x);
		int ggg = slide(b);
		b = b.movePointRight(ggg);
	b = b.setScale(sc,BigDecimal.ROUND_HALF_EVEN);
		b = b.movePointLeft(ggg);
	b = b.movePointRight(x);
	return b;
}


public int slide(BigDecimal b){
	int slideRight = 0;
	boolean stillZero = true;
	for (int i=b.toString().indexOf('.')+1;i<b.toString().length();i++){
		if (b.toString().charAt(i)=='0' && stillZero)
			slideRight++;
		else
			stillZero = false;
	}	
	return slideRight;
}
} // End class
//
////////////////////////////////////////////////////////////////////////////
//
class Calculations extends Panel {
	int w = 250,
	    h = 200;
	Dimension size = new Dimension(w,h);
	BigDecimal a,b,c,d,e,f,g,h1;
	static Font ff = new Font("TimesRoman", Font.PLAIN,36);
	FontMetrics fm;
	boolean show;

public Calculations(){
	a = new BigDecimal("0.0");
	b = new BigDecimal("0.0");
	c = new BigDecimal("0.0");
	d = new BigDecimal("0.0");
	e = new BigDecimal("0.0");
	f = new BigDecimal("0.0");
	g = new BigDecimal("0.0");
	h1 = new BigDecimal("0.0");
	show = false;
}

public void paint(Graphics g1){
///////////////// Draw Box /////////////////////
	g1.setColor(Color.white);
	g1.fillRect(5,5,w-10,h-10);
	g1.setColor(Color.black);
	g1.drawRect(5,5,w-10,h-10);
////////////////////////////////////////////////

	fm = getFontMetrics(getFont());
	if (show)
		drawSolution(g1);
	else 
		drawFormulas(g1);
}

public void drawSolution(Graphics g1){
	g1.drawString("Formula 1:",10,20);
	g1.drawString("Formula 2:",10,115);

	String numerator = ""+e.toString()+" + "+e.toString();
	String a1 = "x = ";

	int right = fm.stringWidth(e.toString()+e.toString()+" + ");
	int mid = fm.stringWidth(f.toString());
	mid = (right)/2 - mid/2;

	g1.drawString(a1, 15,45);
	g1.drawString(h1.toString(),fm.stringWidth(a1)+15,40);
	g1.drawString(" + ",fm.stringWidth(a1+e.toString())+17,38);
	g1.drawString(" _ ",fm.stringWidth(a1+e.toString())+17,37);
	g1.drawString(e.toString(),fm.stringWidth(a1+e.toString()+" + ")+15,40);
	g1.drawLine(fm.stringWidth(a1)+15,41,right+fm.stringWidth(a1)+15,41);
	g1.drawString(f.toString(),mid+15+fm.stringWidth(a1),53);
	g1.drawString("= "+a.toString()+" and "+b.toString(),fm.stringWidth("x ")+15,75);

	g1.drawString(a1, 15,140);
	g1.drawString(h1.toString(),fm.stringWidth(a1)+15,148);
	g1.drawString(" + ",fm.stringWidth(a1+e.toString())+17,149);
	g1.drawString(" _ ",fm.stringWidth(a1+e.toString())+17,140);
	g1.drawString(e.toString(),fm.stringWidth(a1+e.toString()+" + ")+15,148);//85

	g1.drawLine(fm.stringWidth(a1)+15,136,right+fm.stringWidth(a1)+15,136);
	g1.drawString(g.toString(),mid+15+fm.stringWidth(a1),135);//98
	g1.drawString("= "+c.toString()+" and "+d.toString(),fm.stringWidth("x ")+15,170);
}

public void drawFormulas(Graphics g){
	String a1 = "x = ";
	g.drawString(a1, 15,45);

	if (QuadForm.aiszero) {
		g.drawString("Special Case Formula:",10,20);
		drawMathDivide("-c", "b", 15+fm.stringWidth(a1), 45, g); 
	} else
	if (QuadForm.biszero) {
		g.drawString("Division by zero:",10,20);
		drawMathDivide("-c", "0", 15+fm.stringWidth(a1), 45, g); 
	} else
	if (QuadForm.ciszero) {
		g.drawString("Special Case Formula:",10,20);
		drawMathDivide("-b", "a", 15+fm.stringWidth(a1), 45, g); 
	} else {
	g.drawString("Formula 1:",10,20);
	g.drawString("Formula 2:",10,115);
	String numerator = "-b + or - sqrt(b^2 - 4ac)";
	drawMathDivide(numerator, "2*a", 15+fm.stringWidth(a1), 45, g); 

	String numerator1 = "-b - or + sqrt(b^2 - 4ac)";
	g.drawString(a1, 15,140);
	drawMathDivide("2*c", numerator1, 15+fm.stringWidth(a1), 140, g); 
	}
}

public int drawMathDivide(String top, String bot, int x, int y, Graphics g){
	int tl = fm.stringWidth(top);
	int bl = fm.stringWidth(bot);
	int h  = fm.getHeight();
	if (bl > tl) {
		g.drawString(top,x+bl/2-tl/2,y-h/2);
		g.drawString(bot,x,y+h/2);
		g.drawLine(x,y-h/2+2,x+bl,y-h/2+2);
	} else {
		//center bottom
		g.drawString(top,x,y-h/2);
		g.drawString(bot,x+tl/2-bl/2,y+h/2);
		g.drawLine(x,y-h/2+2,x+tl,y-h/2+2);
	}
	// Return end position
	return (bl > tl) ? bl+x: tl+y;
}
///////////////////////////

	public void set(BigDecimal x[],BigDecimal h1){
		this.a = x[0];
		this.b = x[1];
		this.c = x[2];
		this.d = x[3];
		this.e = x[4];
		this.f = x[5];
		this.g = x[6];
		this.h1 = h1;
		show=true;
		repaint();
	}

	public Dimension getMinimumSize() {
		return size;
	}	// end of method minimumSize

	public Dimension getPreferredSize() {
		return size;
	}	// end of method preferredSize

public boolean mouseDown(Event evt,int x, int y){
	System.out.println("X: "+x+" Y: "+y);
	return true;
}

} // End Calculations
//
////////////////////////////////////////////////////////////////
//
class ExactCalc extends Panel {
	int w = 380,
	    h = 40;
	Dimension size = new Dimension(w,h);
	String root1, 
		 root2;
	boolean show = false;

	public ExactCalc(){
	
	}

	public void set(BigDecimal a, BigDecimal b){
		root1 = a.toString();
		root2 = b.toString();
		show = true;
	}

	public void setSpecial(String a, String b){
		root1 = a;
		root2 = b;
		show = true;
	}

	public void paint(Graphics g1){
		// Draw Box
		g1.setColor(Color.white);
		g1.fillRect(5,5,w-10,h-10);
		g1.setColor(Color.black);
		g1.drawRect(5,5,w-10,h-10);
		if (show)
			g1.drawString("Correctly rounded roots: "+root1+" and "+root2,10,25);
	}

	public Dimension getMinimumSize() {
		return size;
	}	// end of method minimumSize

	public Dimension getPreferredSize() {
		return size;
	}	// end of method preferredSize

	public boolean mouseDown(Event evt,int x, int y){
		System.out.println("X: "+x+" Y: "+y);
		return true;
	}
} // End ExactCalc
//
////////////////////////////////////////////////////////////////////////////
//public String drawSquareRoot();