#include <iostream.h>
#include "quad.h"

quadratic::quadratic()
{
	myA=1;
	myB=0;
	myC=0;
}

quadratic::quadratic(double a, double b, double c)
{
	myA = a;
	myB = b;
	myC = c;
}

quadratic::quadratic(const quadratic &a)
{
	myA = a.myA;
	myB = a.myB;
	myC = a.myC;
}

double quadratic::get_a()
{
	return myA;
}

double quadratic::get_b()
{
	return myB;
}

double quadratic::get_c()
{
	return myC;
}

double quadratic::discriminant()
{
	return myB*myB - (4 * (myA*myC));
}

int quadratic::numxintercept()
{
	if (sqrt(discriminant()) > 0)
		return 2;
	else if (sqrt(discriminant()) == 0)
		return 1;
	else
		return 0;
}

double quadratic::xint1()
{
	return (-myB + sqrt(discriminant()))/(2 * myA);
}

double quadratic::xint2()
{
	return (-myB - sqrt(discriminant()))/(2 * myA);
}

double quadratic::fun_of_x(double x)
{
	return myA*x*x + myB*x + myC;
}

double quadratic::deriv_of_x(double x)
{
	return (2*myA*x) + myB;
}

double quadratic::xvertex()
{
	return -myB/(2*myA);
}

double quadratic::yvertex()
{
	return fun_of_x(xvertex());
}

bool quadratic::hasmaxvalue()
{
	if (yvertex() > fun_of_x(xvertex()+1))
		return true;
	else
		return false;
}

bool quadratic::hasintercepts(quadratic &a)
{
	double temp1 = a.deriv_of_x(a.xvertex()+.5), temp2 = deriv_of_x(a.xvertex()+.5);
	double temp3 = xvertex() - ((xvertex() - a.xvertex())/2);
	if ((get_a() == a.get_a()) && (get_b() == a.get_b()) && (get_c() == a.get_c()))
		return false; // Gets rid of congruent entries
	if (!hasmaxvalue() && a.hasmaxvalue())
		if (yvertex() < a.yvertex())
			if (fun_of_x(temp3) > a.fun_of_x(temp3))
				return false;
			else
				return true;
	if (hasmaxvalue() && !a.hasmaxvalue())
		if (a.yvertex() < yvertex())
			if (a.fun_of_x(temp3) > fun_of_x(temp3))
				return false;
			else
				return true;
	if (!hasmaxvalue() && !a.hasmaxvalue())
		if (yvertex() > a.yvertex())
			if (temp2 > temp1)
				return false;
			else
				return true;
	if (!hasmaxvalue() && !a.hasmaxvalue())
		if (a.yvertex() > yvertex())
			if (temp1 > temp2)
				return false;
			else
				return true;
	if (hasmaxvalue() && a.hasmaxvalue())
		if (yvertex() < a.yvertex())
			if (temp2 < temp1)
				return false;
			else
				return true;
	if (hasmaxvalue() && a.hasmaxvalue())
		if (a.yvertex() < yvertex())
			if (temp1 < temp2)
				return false;
			else
				return true;
	return true;
}

double quadratic::xintercept1(const quadratic &a)
{
	double n1 = (myA - a.myA), n2 = (myB - a.myB), n3 = (myC - a.myC);
	if (n1 == 0)
		return (a.myC - myC)/(n1+n2);
	return (-n2 - sqrt(n2*n2 - (4 * (n1*n3))))/(2 * n1);
}

double quadratic::xintercept2(const quadratic &a)
{
	double n1 = (myA - a.myA), n2 = (myB - a.myB), n3 = (myC - a.myC);
	if (n1 == 0)
		return (a.myC - myC)/(n1+n2);
	return (-n2 + sqrt(n2*n2 - (4 * (n1*n3))))/(2 * n1);
}

double quadratic::yintercept1(const quadratic &a)
{
	return fun_of_x(xintercept1(a));
}

double quadratic::yintercept2(const quadratic &a)
{
	return fun_of_x(xintercept2(a));
}

string quadratic::min_or_max()
{
	if (hasmaxvalue())
		return "MAX";
	else
		return "MIN";
}