//author: teluguboy
//date: 23-02-20

#include "polynomial.hpp"

using namespace std;

monomial operator * (const monomial& lhs, const monomial& rhs) {
	monomial res(lhs.coeff * rhs.coeff, lhs.vars_exps);
	for (const pair<const string, int>& vars : rhs.vars_exps) {
		if (res.vars_exps.count(vars.first)) {
			res.vars_exps[vars.first] += vars.second;
		}
		else {
			res.vars_exps[vars.first] = vars.second;
		}
	}
	return res;
}

monomial operator ^ (const monomial& base, int pow) {
	monomial res;
	res.coeff = 1;
	for (int i = 0; i < pow; i++) {
		res = res * res;
	}
	return res;
}

bool operator == (const monomial& lhs, const monomial& rhs) {
	if (lhs.vars_exps == rhs.vars_exps && lhs.coeff == rhs.coeff) {
		return true;
	}
	else {
		return false;
	}
}

bool operator != (const monomial& lhs, const monomial& rhs) {
	return !(lhs == rhs);
}

polynomial operator + (const monomial& lhs, const monomial& rhs)
{
	polynomial res;
	res.expression.push_back(lhs);
	res.expression.push_back(rhs);
	res.simplify();
	return res;
}

polynomial operator + (const monomial& lhs, const polynomial& rhs) {
	polynomial res(rhs);
	res.expression.push_back(lhs);
	res.simplify();
	return res;
}

polynomial operator + (const polynomial& lhs, const monomial& rhs) {
	return rhs + lhs;
}

polynomial operator + (const polynomial& lhs, const polynomial& rhs)
{
	polynomial res(lhs);
	for (const monomial& mono : rhs.expression) {
		res.expression.push_back(mono);
	}
	res.simplify();
	return res;
}

polynomial operator - (const polynomial&lhs, const polynomial&rhs) {
	polynomial res(lhs);
	vector<monomial> tmp = rhs.expression;
	for (monomial& mono : tmp) {
		mono.coeff *= -1;
		res.expression.push_back(mono);
		mono.coeff *= -1;
	}
	res.simplify();
	return res;
}

polynomial operator - (const monomial& lhs, const polynomial& rhs) {
	return rhs - vector<monomial>({ lhs });
}

polynomial operator - (const polynomial& lhs, const monomial& rhs) {
	return rhs - lhs;
}

polynomial operator * (const monomial& lhs, const polynomial& rhs) {
	polynomial res(rhs);
	for (monomial& mono_ : res.expression) {
		mono_ = mono_ * lhs;
	}
	res.simplify();
	return res;
}

polynomial operator * (const polynomial& lhs, const monomial& rhs) {
	return rhs * lhs;
}

polynomial operator * (const polynomial& lhs, const polynomial& rhs)
{
	polynomial res;
	for (const monomial& mono1 : lhs.expression) {
		for (const monomial& mono2 : rhs.expression) {
			res.expression.push_back(mono1 * mono2);
		}
	}
	res.simplify();
	if (res.str() == "0") {
		return polynomial();
	}
	return res;
}

polynomial operator ^ (const polynomial& poly, int pow) {
	polynomial res("1");
	for (int i = 0; i < pow; i++) {
		res = res * poly;
		res.simplify();
	}
	return res;
}

bool operator == (const polynomial& lhs, const polynomial& rhs) {
	if (lhs.expression.size() != rhs.expression.size()) {
		return false;
	}
	for (size_t i = 0; i < lhs.expression.size(); i++) {
		if (lhs.expression[i] != rhs.expression[i]) {
			return false;
		}
	}
	return true;
}

bool operator != (const polynomial& lhs, const polynomial& rhs) {
	return !(lhs == rhs);
}