#include <iostream>

using namespace std;
/*
  Definicja typu wyliczeniowego "Symbol" dla symboli e, a, b, c, d.
*/
enum Symbol{ e,a,b,c,d,k=-1 };
Symbol TabSymboli[5]={e,a,b,c,d};
Symbol Przeciwny(Symbol y); //deklaracja funkcji
/**********************/
/** DEFINICJE TABLIC **/
/**********************/
Symbol TablicaDodawania[5][5] = { { e,a,b,c,d },
                                  { a,d,e,b,c },
                                  { b,e,c,d,a },
                                  { c,b,d,a,e },
                                  { d,c,a,e,b } };

Symbol TablicaMnozen[5][5] ={ { e,e,e,e,e },
                              { e,a,b,c,d },
                              { e,b,a,d,c },
                              { e,c,d,b,a },
                              { e,d,c,a,b } };



/***************/
/** DODAWANIE **/
/***************/
Symbol Dodaj(Symbol y, Symbol x) //Funkcja typu symbol obsługująca dodawanie symboli
{
    return TablicaDodawania[y][x];
}
Symbol operator + ( Symbol y, Symbol x) //przeciazenie operator dodawania
{
  return TablicaDodawania[y][x];
}
/**************/
/** MNOZENIE **/
/**************/
Symbol Mnoz(Symbol y, Symbol x) //Funkcja typu symbol obsługująca mnozenie symboli
{
    return TablicaMnozen[y][x];
}
Symbol operator * (Symbol y, Symbol x) //przeciazenie operator mnozenia
{
    return TablicaMnozen[y][x];
}
/*****************/
/** ODEJMOWANIE **/
/*****************/
Symbol Odejmij(Symbol y, Symbol x) //Funkcja typu symbol obsługująca odejmowanie symboli
{
  x=Przeciwny(x);
  return TablicaDodawania[y][x];
}

Symbol operator - (Symbol y, Symbol x) //przeciazenie operator odejmowania
{
  x=Przeciwny(x);
  return TablicaDodawania[y][x];
}

/***************/
/** DZIELENIE **/
/***************/
Symbol Dziel(Symbol y, Symbol x) //Funkcja typu symbol obsługująca dzielenie symboli
{

 x=Przeciwny(x);
  return TablicaMnozen[y][x];
}

Symbol operator / (Symbol y, Symbol x) //przeciazenie operator dzielenia
{
  x=Przeciwny(x);
  return TablicaMnozen[y][x];
}

/*****************/
/** POTEGOWANIE **/
/*****************/
Symbol Poteguj (Symbol y, int n) //Funkcja typu symbol obsługująca potegowanie symboli
{
    Symbol wynik = y;
    if (n <= 0)
    {
        cout << "Bledna wartosc potegi" << endl;
        return e;
    }
    else
    {
        for (int i=1; i<n; i++)
        {
            wynik = Mnoz (y, wynik);
        }
    }
    return wynik;
}

operator ^ (Symbol y, int n) //przeciazenie operator potegowania
{
    return Poteguj (y, n);
}

/********************************/
/** ZAMIANA NA PRZECIWY SYMBOL **/
/********************************/
Symbol Przeciwny(Symbol y)  // algorytm zamieniania znaku na przeciwny ( to działa tak wysylamy Znak do funkcji i szukamy drugiego znaku dla ktorego ich suma rowna sie E, i zwracamy drugi znak )
{
  Symbol tymczasowy; //tworzy tymczasowa zmienna do porownywania wartosci
  for (int i=0; i<5; i++) //wykonaj sie 5 razy
    {
      tymczasowy=Dodaj(y,TabSymboli[i]); //Jezeli Suma znaku wprowadzonego i ktoregokolwiek z tablicy bedzie rowna E to znaczy ze ten znak jest znakiem przeciwnym
      if(tymczasowy==e) return TabSymboli[i]; //zwraca symbol przeciwny jesli znalazlo
    }
  return e;
}

/***********************/
/** WCZYTANIE SYMBOLU **/
/***********************/

bool WczytajSymbol(Symbol & x) //Wewnatrz funkcji wprowadzamy znak i sprawdzamy czy nalezy do TablicyCharow jezeli tak to przypisujemy ten znak, do zmiennej X typu Symbol
{
  char znak;
  char TabCharow[5]={ 'e','a','b','c','d'}; //tablicaCharow identyczna jak tablicaSymboli
  cin>>znak; // wprowadz znak typu char
  for (int i=0; i<5; i++) //  wykonaj sie 5 razy, przejdz po calej tablicy charow
    {
      if( znak==TabCharow[i]) //jezeli wprowadzony znak jest w tablicy to przypisz do X ten znak ale typu Symbol
        {
        x=TabSymboli[i]; //przypisanie do X wprowadzonego znaku ale typu Symbol
        return true;
        }
     }
    return false;
}

/************************/
/** POROWNANIE WYNIKOW **/
/************************/

void Porownaj(Symbol wynik_alg, Symbol wynik_ope, Symbol wynik_fun)
{
    if(wynik_alg == wynik_fun) cout << "Wyniki wyrazanie algebraicznego i funkcyjnego Identyczne= " << wynik_alg <<endl;
    else
        cout <<"Wyniki Rozne, Wynik_alg= "<<wynik_alg<<" Wynik_fun= "<<wynik_fun<<endl;
    if(wynik_ope == wynik_fun) cout << "Wyniki wyrazanie operatorowego i funkcyjnego Identyczne= " << wynik_ope <<endl;
    else
        cout <<"Wyniki Rozne, Wynik_ope "<<wynik_ope<<" Wynik_fun= "<<wynik_fun<<endl;
    if(wynik_ope == wynik_alg) cout << "Wyniki wyrazanie operatorowego i algebraicznego Identyczne= " << wynik_ope <<endl;
    else
        cout <<"Wyniki Rozne, Wynik_alg "<<wynik_ope<<" Wynik_fun= "<<wynik_alg<<endl;
}

/**************************************/
/**  Definicje przeciazen operatorow **/
/**************************************/

Symbol operator -(Symbol y)
{
  y=Przeciwny(y);
  return y;
}

/*Symbol operator /(Symbol y)
{
  y=Przeciwny(y);
  return y;
  }*/
Symbol operator +(Symbol y)
{
  return y;
}

Symbol operator *(Symbol y)
{
  return y;
}
/*****************************************************/



int main()
{
  Symbol x=b, wynik;
  Symbol wynik_alg, wynik_ope, wynik_fun;

 cout << operator ^ (x,3) ;



    /* wynik_alg=y*x;
    wynik_fun=Mnoz(y,x);
    wynik_ope= operator * (y,x);
    cout << " przeprowadzam porownanie dla operacji Mnozenia "<<endl;
    Porownaj(wynik_alg,wynik_fun,wynik_ope);
    */

}