View difference between Paste ID: 3j6jj0n0 and p927WYUn

 #include <map>
 #include <iostream>
 #include <vector>
 #include <complex>
 #include <functional>
 
 using namespace std;
 class LINP
 {
-	typedef map<int/*pow*/, double/*num*/, greater<int> > value_type;
+
 	typedef map<int/*Index*/, double/*Coeff*/, greater<int> > value_type;
 
-	LINP(): cont()
+
-	{
+	LINP(): cont() {
 		cont[1] = 1;
 	};
-	LINP(int rhs): cont()
+	LINP(int rhs): cont() {
-	{
+
 	};
 
-	LINP operator [](int rhs) const//FIXME: Use operator *() to do this
+	LINP operator [](int rhs) const {
-	{
+
 		tmp.cont.clear();
 		tmp.cont[rhs] = getCoeffOfIndex(1);
-		tmp.cont[rhs] = getNumOfPow(1);
+
 	}
 
-	LINP operator *(double rhs) const
+	LINP& operator *=(double rhs) {
-	{
+		for (auto& v : cont)
 			v.second *= rhs;
-		for (value_type::iterator it=tmp.cont.begin(); it!=tmp.cont.end(); ++it)
+		return *this;
-			it->second *= rhs;
+
 	LINP operator *(double rhs) const {
 		LINP tmp(*this);
-	LINP operator +(const LINP& rhs) const
+		tmp *= rhs;
-	{
+
 	}
-		for (value_type::const_iterator it=rhs.cont.begin(); it!=rhs.cont.end(); ++it)
+
-			tmp.cont[it->first] += it->second;
+	LINP operator *=(const LINP& rhs) const {
 		// Unimplimented
 	}
-	LINP operator -() const
+	LINP operator *(const LINP& rhs) const {
-	{
+
 		tmp *= rhs;
-		for (value_type::iterator it=tmp.cont.begin(); it!=tmp.cont.end(); ++it)
+
-			it->second=-it->second;
+
 
 	LINP& operator +=(const LINP& rhs) {
-	LINP operator -(const LINP& rhs) const
+		for (auto& v : rhs.cont)
-	{
+			this->cont[v.first] += v.second;
-		return *this+(-rhs);
+		return *this;
 	}
-	friend ostream& operator <<(ostream& os, const LINP& rhs)
+
-	{
+	LINP operator +(const LINP& rhs) const {
 		LINP tmp(*this);
-			it!=rhs.cont.end(); ++it)
+		tmp += rhs;
 		return tmp;
 	}
 
 	LINP& operator -=(const LINP& rhs) {
 		for (auto& v : rhs.cont)
 			this->cont[v.first] -= v.second;
 		return *this;
 	}
 	LINP operator -(const LINP& rhs) const {
 		LINP tmp(*this);
 		tmp -= rhs;
 		return tmp;
 	}
 	LINP operator -() const {
 		LINP tmp(*this);
 		for (auto& v : tmp.cont)
 			v.second = -v.second;
 		return tmp;
 	}
 
 	friend ostream& operator <<(ostream& os, const LINP& rhs) {
 		for (value_type::const_iterator it=rhs.cont.begin();
-	int maxPow() const
+			it != rhs.cont.end(); ++it)
-	{
+
 			if (it->second != 0)
 			{
-	int minPow() const
+
-	{
+
 					if (it->second < 0)
 						cout << '-';
-	double getNumOfPow(int Pow) const
+
-	{
+
-		value_type::const_iterator it=cont.find(Pow);
+
-		return it!=cont.end()? it->second : 0;
+
 				{
-	vector<complex<double> > solve() const throw(exception)	//Solve: *this=0
+
-	{
+
-		if (maxPow()>2 || minPow()<0)
+
 				}
 			}
-		result.reserve(maxPow());
+
-		if (maxPow()==1)
+
-			result.push_back(-getNumOfPow(0)/getNumOfPow(1));
+
 		return os;
 	}
-			complex<double> delta=pow(getNumOfPow(1), 2)-4*getNumOfPow(2)*getNumOfPow(0);
+
-			result.push_back((-getNumOfPow(1)+sqrt(delta))/(2*getNumOfPow(2)));
+	int maxIndex() const {
-			result.push_back((-getNumOfPow(1)-sqrt(delta))/(2*getNumOfPow(2)));
+
 	}
 	int minIndex() const {
 		return cont.rbegin()->first;
 	}
 
 	double getCoeffOfIndex(int Index) const {
 		value_type::const_iterator it=cont.find(Index);
 		return it != cont.end() ? it->second : 0;
 	}
 
 	vector<complex<double> > solve() const throw(exception)	{
 		if (maxIndex()>2 || minIndex()<0)
 			throw std::exception();
 		vector<complex<double> > result;
 		result.reserve(maxIndex());
 		if (maxIndex()==1)
 			result.push_back(-getCoeffOfIndex(0)/getCoeffOfIndex(1));
 		else	// maxPow()==2
 		{
 			complex<double> delta=pow(getCoeffOfIndex(1), 2)-4*getCoeffOfIndex(2)*getCoeffOfIndex(0);
 			result.push_back((-getCoeffOfIndex(1)+sqrt(delta))/(2*getCoeffOfIndex(2)));
 			result.push_back((-getCoeffOfIndex(1)-sqrt(delta))/(2*getCoeffOfIndex(2)));
 		}
 		return result;
 	}
 
 private:
 	value_type cont;
 };
 
 int main()
 {
 	LINP linp=LINP()-(LINP()*0.5+1)-1;
 	cout << linp << " = 0" << endl;
 	cout << "X = " << linp.solve().front().real() << endl << endl;
 
 	LINP linp2=LINP()[2]+LINP()*2+1;
 	cout << linp2 << " = 0" << endl;
 	cout << "X1 = X2 = " << linp2.solve().front().real() << endl << endl;
 
 	LINP linp3=LINP()[2]+1;
 	cout << linp3 << " = 0" << endl;
 	vector<complex<double> > result=linp3.solve();
 	cout << "x1 = " << result[0].real() << " + " << result[0].imag() << 'i' << endl
 		<< "x2 = " << result[1].real() << " + " << result[1].imag() << 'i' << endl << endl;
 }