#include <stdio.h>
#include <stdlib.h>
#include <math.h>

typedef struct _complex {
  double real;
  double imag;
} complex;

complex *inputComplex ()
{
  complex *c = (complex *)malloc(sizeof(complex));
  printf("Enter Real Part: "); scanf ("%lf", &(c->real));
  printf("Enter Imaginary Part: "); scanf ("%lf", &(c->imag));
  return c;
}

void printComplex ( complex *c )
{
  printf("(%lf) + (%lf)i", c->real, c->imag);
}

double modulusComplex ( complex *c )
{
  return sqrt(c->real * c->real + c->imag * c->imag);
}

complex *conjugateComplex ( complex *c )
{
  complex *d = (complex *)malloc(sizeof(complex));
  d->real = c->real;
  d->imag = - c->imag;
  return d;
}

double argumentComplex ( complex *c )
{
  return atan(c->imag/c->real);
}

complex *addComplex ( complex *a, complex *b )
{
  complex *c = (complex *)malloc(sizeof(complex));
  c->real = a->real + b->real;
  c->imag = a->imag + b->imag;
  return c;
}

complex *subtractComplex ( complex *a, complex *b )
{
  complex *c = (complex *)malloc(sizeof(complex));
  c->real = (a->real) - (b->real);
  c->imag = (a->imag) - b->imag;
  return c;
}

complex *multiplyComplex ( complex *a, complex *b )
{
  complex *c = (complex *)malloc(sizeof(complex));
  c->real = a->real * b->real - a->imag * b->imag;
  c->imag = a->imag * b->real + a ->real * b->imag;
  return c;
}

complex *divideComplex ( complex *a, complex *b )
{
  complex *c = (complex *)malloc(sizeof(complex));
  c->real = (a->real * b->real + a->imag * b->imag) / (b->real * b->real + b->imag * b->imag);
  c->imag = (b->real * a->imag - a->real * b->imag) / (b->real * b->real + b->imag * b->imag);
  return c;
}

complex *squareComplex ( complex *c )
{
  complex *d = (complex *)malloc(sizeof(complex));
  d->real = c->real * c->real - c->imag * c->imag;
  d->imag = 2 * c->real * c -> imag;
  return d;
}

complex *cubeComplex ( complex *c )
{
  complex *d = (complex *)malloc(sizeof(complex));
  d->real = c->real * c->real * c->real - 3 * c->real * c->imag * c->imag;
  d->imag = 3 * c->real * c->real * c->imag - c->imag * c->imag * c->imag;
  return d;
}

complex *sqrootComplex ( complex *c )
{
  complex *d = (complex *)malloc(sizeof(complex));
  d->real = sqrt((c->real + sqrt(c->real * c->real + c->imag * c->imag))/2);
  d->imag = ((c->imag >= 0) - (c->imag < 0)) *
            sqrt((- c->real + sqrt(c->real * c->real + c->imag * c->imag))/2);
  return d;
}

complex *reciprocalComplex ( complex *c )
{
  complex *d = (complex *)malloc(sizeof(complex));
  d->real = c->real / (c->real * c->real + c->imag * c->imag);
  d->imag = - c -> imag / (c->real * c->real + c->imag * c->imag);
  return d;
}

complex *exponentialComplex ( complex *c )
{
  complex *d = (complex *)malloc(sizeof(complex));
  d->real = exp(c->real) * cos(c->imag);
  d->imag = exp(c->real) * sin(c->imag);
  return d;
}

int main ()
{
  complex *p, *q;

  /* taking real and imaginary parts of a complex number from user as inputs */
  printf("++ Enter Complex Number C1 ++\n");
  p = inputComplex();
  printf("++ Enter Complex Number C2 ++\n");
  q = inputComplex();

  /* printing the two complex numbers in (a+bi) format */
  printf("\n** Complex Number C1: ");
  printComplex(p);
  printf("\n** Complex Number C2: ");
  printComplex(q);

  /* computing the modulus of two complex numbers */
  printf("\n** MODULUS of C1: |C1| = %lf", modulusComplex(p));
  printf("\n** MODULUS of C2: |C2| = %lf", modulusComplex(q));
    
  /* computing the conjugate of two complex numbers */
  printf("\n** CONJUGATE of C1: ~C1 = ");
  printComplex(conjugateComplex(p));
  printf("\n** CONJUGATE of C2: ~C2 = ");
  printComplex(conjugateComplex(q));
    
  /* computing the argument of two complex numbers */
  printf("\n** ARGUMENT of C1: arg(C1) = %lf", argumentComplex(p));
  printf("\n** ARGUMENT of C2: arg(C2) = %lf", argumentComplex(q));
    
  /* adding two complex numbers */
  printf("\n** Complex Number after ADDITION: (C1 + C2) = ");
  printComplex(addComplex(p, q));
    
  /* subtracting two complex numbers */
  printf("\n** Complex Number after SUBTRACTION: (C1 - C2) = ");
  printComplex(subtractComplex(p, q));
    
  /* multiplying two complex numbers */
  printf("\n** Complex Number after MULTIPLICATION: (C1 x C2) = ");
  printComplex(multiplyComplex(p, q));
    
  /* dividing two complex numbers */
  printf("\n** Complex Number after DIVISION: (C1 / C2) = ");
  printComplex(divideComplex(p, q));
    
  /* computing the squares of two complex numbers */
  printf("\n** SQUARE of C1: C1^2 = ");
  printComplex(squareComplex(p));
  printf("\n** SQUARE of C2: C2^2 = ");
  printComplex(squareComplex(q));
    
  /* computing the cubes of two complex numbers */
  printf("\n** CUBE of C1: C1^3 = ");
  printComplex(cubeComplex(p));
  printf("\n** CUBE of C2: C2^3 = ");
  printComplex(cubeComplex(q));
    
  /* computing the square-roots of two complex numbers */
  printf("\n** SQUARE ROOT of C1: SQRT(C1) = (+/-) [ ");
  printComplex(sqrootComplex(p)); printf(" ]");
  printf("\n** SQUARE ROOT of C2: SQRT(C2) = (+/-) [ ");
  printComplex(sqrootComplex(q)); printf(" ]");
    
  /* computing the reciprocals of two complex numbers */
  printf("\n** RECIPROCAL of C1: 1/C1 = ");
  printComplex(reciprocalComplex(p));
  printf("\n** RECIPROCAL of C2: 1/C2 = ");
  printComplex(reciprocalComplex(q));
    
  /* computing the exponentiation of two complex numbers (with respect to 'e') */
  printf("\n** EXPONENTIATION of C1: e^C1 = ");
  printComplex(exponentialComplex(p));
  printf("\n** EXPONENTIATION of C2: e^C2 = ");
  printComplex(exponentialComplex(q));

  printf("\n");

  return 0;
}