#include <cmath>
#include <complex>
#include <cstdio>
#include <cstdlib>
#include <iostream>

#if defined(_WIN32) || defined(WIN32) || defined(_WIN64) || defined(WIN64)
/* Sekcyjo `define` do przipodku kompilowanio pod VS2019 */

#define clear() system("cls")
#define pause() system("pause");

#elif defined(__unix__) || defined(linux)
/* jw. przi kompilowaniu pod linuxym */

#define clear() system("clear")
#define pause()                                                                \
  getchar();                                                                   \
  getchar();

#define printf_s printf
#define scanf_s scanf

#endif

/* defincyjo do skrocanio wzorow */
#define fe (double)(sqrt(3.0) / 2.0)

using namespace std;

void wypisz_zesp(char *tekst, complex<double> z) {
  printf_s("%s%lf", tekst, real(z));
  if (imag(z) >= 0) {
    printf_s(" + i%lf\n", abs(imag(z)));
  } else {
    printf_s(" - i%lf\n", abs(imag(z)));
  }

}

int main(void) {
  /*
   * Rownani we postaci ogolnej
   * [fa]x^3 + [fb]x^2 + [fc]x + [fd]
   *
   * Rownani we postaci kanonicznej
   * z^3 + [fp]z + [fnq]
   *
   * fD - wyroznik rownanio
   */
  double fa, fb, fc, fd, fnq, fp, fD;

  /* Zespolone pierwiastki rownanio */
  complex<double> z1, z2, z3;

  /* Czysci ekran przed zaczynciym */
  clear();
  printf_s("Elektrotechnika, grupa I, sekcja 1.1.9: Konrad Sowula, Bartosz "
           "Kowalczyk\nZagadnienie 1: Rozwiazania rownania szesciennego\n");

  printf_s("Podaj parametr a: ");
  scanf_s("%lf", &fa);

  /* kej a == 0, wyjdz z programu */
  if (fa == 0) {
    printf_s("a == 0\n");
    exit(-1);
  }

  printf_s("Podaj parametr b: ");
  scanf_s("%lf", &fb);

  printf_s("Podaj parametr c: ");
  scanf_s("%lf", &fc);

  printf_s("Podaj parametr d: ");
  scanf_s("%lf", &fd);

  /* fnq = (-[fb]^3 / 27*[fa]^3) + ([fb]*[fc] / 6*[fa]^2) + [fd]/2*[fa] */
  fnq = (-(fb * fb * fb) / (27 * fa * fa * fa)) + ((fb * fc) / (6 * fa * fa)) -
        (fd / (2 * fa));

  /* fp = ([fc]/3*[fa]) - ([fb]^2/9*[fa]^2) */
  fp = (fc / (3 * fa)) - ((fb * fb) / (9 * fa * fa));

  /* fD = [fnq]^2 + [fp]^3 */
  fD = (fnq * fnq) + (fp * fp * fp);

  if (fD >= 0) {
    (fD == 0) ? printf_s("\n+----------------------------+\n"
                         "| Dwa pierwiaski rzeczywiste |\n"
                         "| Jeden podwojny             |\n"
                         "+----------------------------+\n")
              : printf_s("\n+-------------------------------+\n"
                         "| Jeden pierwiastek rzeczywisty |\n"
                         "| Dwa zespolone                 |\n"
                         "+-------------------------------+\n");
    /*
     * jedyn rzeczywisty, dwa zespolone
     */
    double fu, fv, fx, fre_z, fim_z;

    fu = cbrt(fnq + sqrt(fD));
    fv = cbrt(fnq - sqrt(fD));

    /* fx - pierwiastek rzeczywisty */
    fx = fu + fv - (fb / (3 * fa));

    /* fre_z - rzeczywisto czynsc zespolonych pierwiastkow */
    fre_z = -((fu / 2.0) + (fv / 2.0) + (fb / (3.0 * fa)));

    /* fim_z - urojono czynsc zespolonych pierwiastkow */
    fim_z = (fu * fe) - (fv * fe);

    z1 = complex<double>(fx, 0);
    z2 = complex<double>(fre_z, fim_z);
    z3 = complex<double>(fre_z, -fim_z);

    wypisz_zesp("z1 = ", z1);
    wypisz_zesp("z2 = ", z2);
    wypisz_zesp("z3 = ", z3);
  } else {
    /*
     * trzi rzeczywiste
     */
    printf_s("\n+------------------------------+\n"
             "| Trzy pierwiastki rzeczywiste |\n"
             "+------------------------------+\n");

    double ff = (((3 * fc) / fa) - ((fb * fb) / (fa * fa))) / 3.0;
    double fg = (((2 * fb * fb * fb) / (fa * fa * fa)) -
                 ((9 * fb * fc) / (fa * fa)) + ((27 * fd) / fa)) /
                27.0;
    double fh = ((fg * fg) / 4.0) + ((ff * ff * ff) / 27.0);
    double fi = sqrt(((fg * fg) / 4) - fh);
    double fM = cos(acos(-(fg / (2 * fi))) / 3);
    double fN = sqrt(3.0) * sin(acos(-(fg / (2 * fi))) / 3);

    z1 = (2 * cbrt(fi) * fM) - (fb / (3 * fa));
    z2 = -cbrt(fi) * (fM + fN) - (fb / (3 * fa));
    z3 = -cbrt(fi) * (fM - fN) - (fb / (3 * fa));

    wypisz_zesp("z1 = ", z1);
    wypisz_zesp("z2 = ", z2);
    wypisz_zesp("z3 = ", z3);
  }

  printf_s("\nMetoda Hornera:\n");
  wypisz_zesp("W(z1) = ", ((fa * z1 + fb) * z1 + fc) * z1 + fd);
  wypisz_zesp("W(z2) = ", ((fa * z2 + fb) * z2 + fc) * z2 + fd);
  wypisz_zesp("W(z3) = ", ((fa * z3 + fb) * z3 + fc) * z3 + fd);

  printf_s("\nMetoda klasyczna:\n");
  wypisz_zesp("W(z_1) = ",
              fa * pow(z1, 3.0) + fb * pow(z1, 2.0) + fc * z1 + fd);
  wypisz_zesp("W(z_2) = ",
              fa * pow(z2, 3.0) + fb * pow(z2, 2.0) + fc * z2 + fd);
  wypisz_zesp("W(z_3) = ",
              fa * pow(z3, 3.0) + fb * pow(z3, 2.0) + fc * z3 + fd);
  /*
   * Zatrzymuje wykonani az do entera
   */
  pause();

  exit(0);
}