//Updating to a class template ~jay //https://www.sololearn.com/Discuss/482706/?ref=app //note:: static_cast will probably be needed to guarantee return types in certain functions /////////////////////////////////////////// /// /// Complex Numbers in C++ /// /////////////////////////////////////////// /// Made By - Kinshuk Vasisht /// Version - 2.1.1 /// Status - 0xFFFFEE (Complete,addons /// possible...) /// Features - Complex Number Operations /// Radian-Degree Conversion /// Overloads - Templates & Declarations /// Functions - radtodeg(), degtorad(), /// Signum(), /// Complex Class Methods /// Main Type - Long Double (Alias - ld) /// Templates - typename Only. /// Macros - None. /// Classes - Complex /// *Features - /// # Functions - Get(),Print(),Re(), /// Im(),Root(), /// RaiseToComplex(), /// Log(),Modulus(), /// Argument(),Normal(), /// Conjugate(), /// GetPolar(), /// Print1Polar(), /// Print2Polar(), /// Inverse(),Polar(), /// Rotate(),Sin(), /// Cos(),Tan(),Sinh(), /// Cosh(),Tanh(), /// Exponent()... /// # Operators - +,-,*,/,2,+=,-=,*=,/=, /// ==,!=,^,^,>,<,~,-,<<, /// #defines - Pi(Pi),Eu(Euler's No.) /// Lines - 490 (No Extras) /// Headers - , , /// , /// Contribs - Thanks to JPM for his /// Contributions to the /// Complex Class' Math... /// - Modification Inspired /// by JPM's Program - /// - https://code.sololearn. /// com/ci2z3XExdMcE/#cpp /// - Only Signum Mod, /// Root Overload(nth Root), /// Friend Operators and /// bool Operators are /// inspired... /// /////////////////////////////////////////// /* Hello. The following is a simpler implementation of complex numbers in C++; Numbers of the form a + b i, where a and b are real and i = sqrt(-1). This class declaration allows the user to perform most of the possible operations as possible using complex numbers... The equations can be of any difficulty, as most of the functions are here. All depends on the user's imagination and knowledge of implementation... Also , I have left a simple program after the class declaration to demonstate how to use this class for calculations... If you have any queries or suggestions, please let me know in the comments... */ #include #include #include #include #define Pi 3.141592653589793 #define Eu 2.718281828459045 typedef long double ld; typedef long long int l; using namespace std; int signum(ld x) { return (0 class Complex { private: aType real; aType2 imag; public: Complex(aType re = 0, aType2 im = 0) :real(re), imag(im) {} ///Complex Constructor -- Assigns Real and Imaginary values... ///Complex(Complex& a){} ///Complex Copy Constructor -- @CurrentlyUnderConstruction... void Get() ///Gets the Real and Imaginary Parts of the Complex Number { cout << "Enter Real Value = "; cin >> real; cout << "Enter Imaginary Value = "; cin >> imag; cout << endl; } void Print() ///Prints the Complex Number { if (imag>0) { cout << "The Number is = " << real << " + " << imag << " i " << endl; } else if (imag == 0) { cout << "The Number is = " << real << endl; } else if (imag<0) { cout << "The Number is = " << real << " - " << abs(imag) << " i " << endl; } else { cout << "The Number is = " << imag << " i " << endl; } } void Re(aType re) ///Sets the Real Part to 're' { real = re; } void Im(aType im) ///Sets the Imaginary Part to 'im' { imag = im; } ld Re() ///Returns the Real Part of the Complex Number { return real; } ld Im() ///Returns the Imaginary Part of the Complex Number { return imag; } aType Modulus() ///Returns |z| for Complex z { ld term = pow(real, 2) + pow(imag, 2); return sqrt(term); } aType Normal() ///Returns |z|^2 for Complex z { ld term = pow(real, 2) + pow(imag, 2); return term; } Complex Conjugate() ///Returns Conj(z) of Complex z { Complex res; res.real = real; res.imag = -imag; return res; } ld Argument() ///Returns The Slope's Angle of Complex in Argand Plane { ld term; term = atan2(imag, real); return radtodeg(term); } void Inverse() ///Returns Inverse of the Complex Number { imag = -imag; ld a = Normal(); real /= a; imag /= a; } void GetPolar() ///Gets the Complex z in Polar Form { ld arg, mod; cout << "Enter the Argument - "; cin >> arg; cout << "Enter the Modulus - "; cin >> mod; cout << endl; ld newarg = degtorad(arg); real = mod*cos(newarg); imag = mod*sin(newarg); } void Polar1Print() ///Prints Polar form of z - r(cos(x)+isin(x)) { cout << "The Polar Form is = "; cout << Modulus() << "( cos(" << Argument() << ")+sin(" << Argument() << ") )" << endl; } void Polar2Print() ///Prints Polar form of z - re^ix { Complex term, t1(0, 1), t2; term.real = t1.real*degtorad(Argument()); term.imag = t1.imag*degtorad(Argument()); t2.RaiseToComplex(Eu, term); cout << "The Polar Form is = "; cout << Modulus() << "( e ^ " << degtorad(Argument()) << "i )" << endl; cout << " OR " << endl; cout << "The Polar Form is = "; cout << Modulus() << "( " << Eu << " ^ " << degtorad(Argument()) << "i )" << endl; cout << " OR " << endl; cout << "The Polar Form is = "; if (imag>0) cout << Modulus() << "( " << t2.real << " + " << t2.imag << " i )" << endl; else if (imag<0) cout << Modulus() << "( " << t2.real << " - " << abs(t2.imag) << " i )" << endl; } Complex Polar(ld mod, ld arg) ///Converts Polar Form of the Complex Number to Original Form { Complex res; ld newarg = degtorad(arg); res.real = mod*cos(newarg); res.imag = mod*sin(newarg); return res; } void Root(Complex& x1, Complex& x2) ///Returns Square Roots of Complex z in x1 and x2 { ld a = Modulus(); x1.real = sqrt((a + real) / 2); x1.imag = signum(imag)*sqrt((-real + a) / 2); x2.real = -(sqrt((a + real) / 2)); x2.imag = -(signum(imag)*sqrt((-real + a) / 2)); } Complex* Root(int m) ///Returns nth Roots of Complex z in Complex array { int n = abs(m); Complex *z = new Complex[n]; ld rn = pow(Modulus(), 1.0 / n); ld narg = (degtorad(Argument())) / n; ld npi = (2.0*Pi) / n; for (int i = 0; i0) z[k] = Complex(rn*cos(narg + k*npi), rn*sin(narg + k*npi)); else z[k] = Complex(rn*cos(narg + (-k)*npi), rn*sin(narg + (-k)*npi)); } return z; } void Rotate(ld angle) ///Rotates the Complex Number by 'angle' Degrees { ld a = Modulus(), b = Argument(); b += angle; ld bx = degtorad(b); real = a*cos(bx); imag = a*sin(bx); } void RaiseToComplex(ld a, Complex& z) ///Returns a raised to Complex z { cout.precision(8); cout.setf(ios::fixed); ld t1, t2, t3; t1 = pow(a, z.real); t2 = cos(z.imag*log(a)); t3 = sin(z.imag*log(a)); real = t1*t2; imag = t1*t3; } Complex Cos() ///Returns Cosine of Complex z { Complex res, t1(0, 1), t2(0, -1), t3, t4, t5, t6, t7; t3.real = (real*t1.real) - (imag*t1.imag); t3.imag = (real*t1.imag) + (imag*t1.real); t4.real = (real*t2.real) - (imag*t2.imag); t4.imag = (real*t2.imag) + (imag*t2.real); t5.RaiseToComplex(2.718281828459045, t3); t6.RaiseToComplex(2.718281828459045, t4); t7 = t5 + t6; res.real = t7.real / 2; res.imag = t7.imag / 2; return res; } Complex Cosh() ///Returns Hyperbolic Cosine of Complex z { Complex res, t1(real, imag), t2(-real, -imag), t3, t4, t5; t3.RaiseToComplex(2.718281828459045, t1); t4.RaiseToComplex(2.718281828459045, t2); t5 = t4 + t3; res.real = t5.real / 2; res.imag = t5.imag / 2; return res; } Complex Sin() ///Returns Sine of Complex z { Complex res, t(0, 1), t1(0, 1), t2(0, -1), t3, t4, t5, t6, t7, t8; t3.real = (real*t1.real) - (imag*t1.imag); t3.imag = (real*t1.imag) + (imag*t1.real); t4.real = (real*t2.real) - (imag*t2.imag); t4.imag = (real*t2.imag) + (imag*t2.real); t5.RaiseToComplex(2.718281828459045, t3); t6.RaiseToComplex(2.718281828459045, t4); t7 = t6 - t5; t8 = t7*t; res.real = t8.real / 2; res.imag = t8.imag / 2; return res; } Complex Sinh() ///Returns Hyperbolic Sine of Complex z { Complex res, t1(real, imag), t2(-real, -imag), t3, t4, t5; t3.RaiseToComplex(2.718281828459045, t1); t4.RaiseToComplex(2.718281828459045, t2); t5 = t3 - t4; res.real = t5.real / 2; res.imag = t5.imag / 2; return res; } Complex Tan() ///Returns Tangent of Complex z { Complex res, t1, t2; t1 = Sin(); t2 = Cos(); res = t1 / t2; return res; } Complex Tanh() ///Returns Hyperbolic Tangent of Complex z { Complex res, t1, t2; t1 = Sinh(); t2 = Cosh(); res = t1 / t2; return res; } Complex Exp() { Complex res; res.RaiseToComplex(Eu, *this); return res; } Complex Log(ld base) ///Returns Log of the Complex No. to the base { Complex res; res.real = log(Modulus()) / ((log(base))); res.imag = degtorad(Argument()) / ((log(base))); return res; } bool operator==(const Complex& rhs) ///Checks if the Complex Numbers are Equal { return(real == rhs.real&&imag == rhs.imag); } bool operator!=(const Complex& rhs) //Checks if the Complex Numbers are Unequal { return(real != rhs.real&&imag != rhs.imag); } Complex operator~() ///Returns Conjugate of the Complex Number { *this = Conjugate(); return *this; } Complex operator+(Complex rhs) ///Adds Two Complex Numbers { Complex res; res.real = real + rhs.real; res.imag = imag + rhs.imag; return res; } Complex operator+(ld rhs) ///Adds Constant to Complex Number { Complex res; res.real = real + rhs; res.imag = imag; return res; } Complex operator-(Complex rhs) ///Subtracts Two Complex Numbers { Complex res; res.real = real - rhs.real; res.imag = imag - rhs.imag; return res; } Complex operator-(ld rhs) ///Subtracts Constant from Complex Number { Complex res; res.real = real - rhs; res.imag = imag; return res; } Complex operator*(Complex rhs) ///Multiplies Two Complex Numbers { Complex res; res.real = (real*rhs.real) - (imag*rhs.imag); res.imag = (real*rhs.imag) + (imag*rhs.real); return res; } Complex operator*(ld rhs) ///Multiplies Complex z by a Constant { Complex res; res.real = real*rhs; res.imag = imag*rhs; return res; } Complex operator/(Complex rhs) ///Divides Two Complex Numbers { rhs.Inverse(); Complex res; res.real = (real*rhs.real) - (imag*rhs.imag); res.imag = (real*rhs.imag) + (imag*rhs.real); return res; } Complex operator/(ld rhs) ///Divides Complex z by a Constant { Complex res; res.real = real / rhs; res.imag = imag / rhs; return res; } void operator+=(Complex rhs) ///Adds z2 to z1 { real += rhs.real; imag += rhs.imag; } void operator-=(Complex rhs) ///Subtracts z2 from z1 { real -= rhs.real; imag -= rhs.imag; } void operator*=(Complex rhs) ///Multiplies z2 and z1 and returns to z1 { real = (real*rhs.real) - (imag*rhs.imag); imag = (real*rhs.imag) + (imag*rhs.real); } void operator/=(Complex rhs) ///Divides z2 and z1 and returns to z1 { rhs.Inverse(); real = (real*rhs.real) - (imag*rhs.imag); imag = (real*rhs.imag) + (imag*rhs.real); } void operator+=(ld rhs) ///Adds Constant to z1 { real += rhs; imag = imag; } void operator-=(ld rhs) ///Subtracts Constant from z1 { real -= rhs; imag = imag; } void operator*=(ld rhs) ///Multiplies z1 with a Constant and returns to z1 { real *= rhs; imag *= rhs; } void operator/=(ld rhs) ///Divides z1 with a Constant and returns to z1 { real /= rhs; imag /= rhs; } Complex operator^(ld power) ///Returns Complex z Raised to 'power' { ld a, b; a = Modulus(); b = pow(a, power); ld c, d; d = Argument(); c = degtorad(d); Complex res; res.real = b*cos(power*c); res.imag = b*sin(power*c); return res; } Complex operator^(Complex b) ///Returns Complex z1 raised to Complex z2 { Complex res, t1(0, 1), t2(b.real / 2, b.imag / 2), t3, t4, t5, t6; ld a1, a2; a1 = Normal(); a2 = degtorad(Argument()); t3.RaiseToComplex(a1, t2); t4 = t1*b; t5.real = t4.real*a2; t5.imag = t4.imag*a2; t6.RaiseToComplex(Eu, t5); res = t6*t3; return res; } ~Complex() {} ///Complex Destructor -- Does Nothing till now... ///Non - Member friend Overloads... friend Complex operator+(ld rhs, Complex c) { return(Complex(c.real + rhs, c.imag)); } friend Complex operator-(ld rhs, Complex c) { return(Complex(c.real - rhs, c.imag)); } friend Complex operator*(ld rhs, Complex c) { return(Complex(c.real*rhs, c.imag*rhs)); } friend Complex operator/(ld rhs, Complex c) { return(Complex(c.real / rhs, c.imag / rhs)); } friend Complex operator^(ld rhs, Complex c) { Complex res; ld t1, t2, t3; t1 = pow(rhs, c.real); t2 = cos(c.imag*log(rhs)); t3 = sin(c.imag*log(rhs)); res.real = t1*t2; res.imag = t1*t3; return res; } friend ostream& operator<<(ostream &output, Complex &c) { output << double(c.Re()) << ", " << double(c.Im()); return output; } }; /* Example Program 1 - Returns Orthocentre of 3 Complex Numbers z1, z2 and z3... Complex z1,z2,z3,t1,t2,t3,r1,r2,r3,res; ld a1,a2,a3; z1.Get(); z2.Get(); z3.Get(); t1=z1.Conjugate(); t2=z2.Conjugate(); t3=z3.Conjugate(); a1=z1.Normal(); a2=z2.Normal(); a3=z3.Normal(); r1=((z1^2)*(t2-t3))+((z2^2)*(t3-t1))+((z3^2)*(t1-t2)); r2=((z2-z3)*a1)+((z3-z1)*a2)+((z1-z2)*a3); r3=(z1*t2)-(z2*t1)+(z2*t3)-(z3*t2)+(z3*t1)-(z1*t3); res=(r1+r2)/r3; cout<<"Orthocentre - "<>no; cout<(4, 'A'); Complex a(42, 'A'); cout << "Complex: " << a << endl; cout << "Mod: " << a.Modulus() << endl; cout << "Normal: " << a.Normal() << endl; Complex b(44.5, 12.5); cout << b << endl; cout << b.Modulus() << endl; cout << b.Normal() << endl; cin.get(); }