/*************************************************************************/
/* Seminarni prace - vedecka kalkulacka, Jan Dvorak 1        STROM.CPP   */
/*************************************************************************/
#ifndef _ZASOBNIK_H
#define _ZASOBNIK_H
/*************************************************************************/

#include <cmath>
#include <string>
using namespace std;
/*************************************************************************/
double faktorial(int);
double mocnina(double, double);
static double pi = 3.1415926535897932384626433832795;                     
/*************************************************************************/
class Prvek 
{
protected:       
       
       void zobrazChybu(string x)
       {
          //Zobrazeni chybove hlasky, ukonceni vypoctu
	      cerr << "\n\nChyba:\n" << x << "\n";                          
       }
public:
       virtual ~Prvek(){};
       virtual double vratHodnotu()=0;
};
/*************************************************************************/
class Cislo: public Prvek
{
      
private:
      double hodnota;      
      
public:      
      Cislo(double x){hodnota = x;}   
      virtual double vratHodnotu(){return hodnota;}
};
/*************************************************************************/
class Opr1par: public Prvek //operator s jednim parametrem (Cislem)
{
      
protected: //ma se dedit...   
      Prvek *opr;

public:
      Opr1par(Prvek *h){opr = h;}   
      virtual ~Opr1par(){delete opr;}    
};
/*************************************************************************/
class Opr2par: public Prvek //operator s dvemi parametry (Cisly)
{
      
protected: //ma se dedit...   
      Prvek *levy;
      Prvek *pravy;

public:             
      Opr2par(Prvek *l, Prvek *p){levy = l; pravy = p;}       
      virtual ~Opr2par(){delete levy; delete pravy;}
};
/*************************************************************************/
/*                            x operator y                               */
/*************************************************************************/
class Plus: public Opr2par
{
      //x + y
public:
      Plus(Prvek *l, Prvek *p): Opr2par(l, p) {} 
      virtual double vratHodnotu()
      {
              bool a = true;
              if(levy == 0){zobrazChybu("Funkce plus x p y neprijala levy parametr!"); a = false;}
              if(pravy == 0){zobrazChybu("Funkce plus x p y neprijala pravy parametr!"); a = false;}
              if(a)return (levy->vratHodnotu()) + (pravy->vratHodnotu());else return 0;
      }
};
/*************************************************************************/
class Minus: public Opr2par
{
      //x - y
public:
      Minus(Prvek *l, Prvek *p): Opr2par(l, p) {} 
      virtual double vratHodnotu()
      {
              bool a = true;
              if(levy == 0){zobrazChybu("Funkce minus x m y neprijala levy parametr!"); a = false;}
              if(pravy == 0){zobrazChybu("Funkce minus x m y neprijala pravy parametr!"); a = false;}
              if(a)return (levy->vratHodnotu()) - (pravy->vratHodnotu());else return 0;
      }
};
/*************************************************************************/
class Krat: public Opr2par
{
      //x * y
public:
      Krat(Prvek *l, Prvek *p): Opr2par(l, p) {}
      virtual double vratHodnotu()
      {
              bool a = true;
              if(levy ==0 ){zobrazChybu("Funkce krat x * y neprijala levy parametr!"); a = false;}
              if(pravy == 0){zobrazChybu("Funkce krat x * y neprijala pravy parametr!"); a = false;}
              if(a)return (levy->vratHodnotu()) * (pravy->vratHodnotu());else return 0;
      }

};
/*************************************************************************/
class Deleno: public Opr2par
{
      //x / y
public:
      Deleno(Prvek *l, Prvek *p): Opr2par(l, p) {} 
      virtual double vratHodnotu()
      {
              bool a = true;
              if(levy == 0){zobrazChybu("Funkce deleno x / y neprijala levy parametr!"); a = false;}
              if(pravy == 0){zobrazChybu("Funkce deleno x / y neprijala pravy parametr!"); a = false;}
              double b = pravy->vratHodnotu();
              if(b==0){zobrazChybu("Nelze delit nulou!"); return 0;}
                else if(a)return (levy->vratHodnotu()) / b;
                   else return 0;
      }
};
/*************************************************************************/
class Kombinace: public Opr2par
{
      //x K y
public:
      Kombinace(Prvek *l, Prvek *p): Opr2par(l, p) {}
      virtual double vratHodnotu()
      {
              bool b = true;
              if(levy == 0){zobrazChybu("Funkce kombinace x K y neprijala levy parametr!"); b = false;}
              if(pravy == 0){zobrazChybu("Funkce kombinace x K y neprijala pravy parametr!"); b = false;}
              if(!b)return 0;else
              {
                 double a = levy->vratHodnotu();
                 double b = pravy->vratHodnotu();
    		     //kontrola celého čísla
                 int cisloa = (int)a; 
                 int cislob = (int)b;
                 if(cisloa < 0 || cisloa != a){zobrazChybu("Funkce kombinace x K y prijala neodpovidajici levy parametr. x >= 0 z N"); b = false;}
                 if(cislob < 0 || cislob != b){zobrazChybu("Funkce kombinace x P y prijala neodpovidajici pravy parametr. y >= 0 z N"); b = false;}
                 if(cislob > cisloa){zobrazChybu("Funkce kombinace x K y je definova pouze pro y <= x"); b = false;}                 
                 if(b)return faktorial(cisloa) / faktorial(cislob) / faktorial(cisloa - cislob); 
                    else return 0;
              }
      }
};
/*************************************************************************/
class Permutace: public Opr2par
{
      //x P y
public:
      Permutace(Prvek *l, Prvek *p): Opr2par(l, p) {}
      virtual double vratHodnotu()
      {
              bool b = true;
              if(levy == 0){zobrazChybu("Funkce permutace x P y neprijala levy parametr!"); b = false;}
              if(pravy == 0){zobrazChybu("Funkce permutace x P y neprijala pravy parametr!"); b = false;}
              if(!b)return 0;else
              {
                 double a = levy->vratHodnotu();
                 double b = pravy->vratHodnotu();
    		     //kontrola celého čísla
                 int cisloa = (int)a; 
                 int cislob = (int)b;
                 if(cisloa < 0 || cisloa != a){zobrazChybu("Funkce permutace x P y prijala neodpovidajici levy parametr. x >= 0 z N"); b = false;}
                 if(cislob < 0 || cislob != b){zobrazChybu("Funkce permutace x P y prijala neodpovidajici pravy parametr. y >= 0 z N"); b = false;}
                 if(cislob > cisloa){zobrazChybu("Funkce permutace permutace x P y je definova pouze pro y <= x"); b = false;}                 
                 if(b)return faktorial(cisloa) / faktorial(cisloa - cislob); 
                    else return 0;
              }
      }
};
/*************************************************************************/
class XnaY: public Opr2par
{
      //x ^ y
public:
      XnaY(Prvek *l, Prvek *p): Opr2par(l, p) {}
      virtual double vratHodnotu()
      {
              bool b = true;
              if(levy == 0){zobrazChybu("Funkce x na y-tou x ^ y neprijala levy parametr!"); b = false;}
              if(pravy == 0){zobrazChybu("Funkce x na y-tou x ^ y neprijala pravy parametr!"); b = false;}
              if(!b)return 0;else
              {
                 double a = levy->vratHodnotu();
                 double b = pravy->vratHodnotu();
                 if(a == 0 && b == 0) return 1;       
                 if(a == 0 && b < 0){zobrazChybu("Funkce 0 ^ y, pro y < 0, neni definovana!"); b = false;}
                 if(b)return mocnina(a,b); 
                    else return 0;
              }
      }
};
/*************************************************************************/
class YodmocninaX: public Opr2par
{
      //x i y
public:
      YodmocninaX(Prvek *l, Prvek *p): Opr2par(l, p) {}
      virtual double vratHodnotu()
      {
              bool b = true;
              if(levy == 0){zobrazChybu("Funkce y-tá odmocnina z x   x i y neprijala levy parametr!"); b = false;}
              if(pravy == 0){zobrazChybu("Funkce y-tá odmocnina z x   x i y neprijala pravy parametr!"); b = false;}
              if(!b)return 0;else
              {
                 double a = levy->vratHodnotu();
                 double b = pravy->vratHodnotu();    
                 if(b < 0){zobrazChybu("Funkce y-tá odmocnina z x   x i y  není pro y < 0 neni definovana!"); b = false;}
                 if(b)return mocnina(b,1/a); 
                    else return 0;
              }
      }
};
/*************************************************************************/
/*                            x operator                                 */
/*************************************************************************/
class Faktorial: public Opr1par
{
      //x !
public:
      Faktorial(Prvek *l): Opr1par(l) {} 
      virtual double vratHodnotu()
      {
              bool b = true;
              if(opr == 0){zobrazChybu("Funkce faktorial x ! neprijala parametr!"); b = false;}
              if(!b)return 0;else
              {
                 double a = opr->vratHodnotu();
    		     //kontrola celého čísla
                 int cisloa = (int)a; 
                 if(cisloa < 0 || cisloa != a){zobrazChybu("Funkce faktorial x! prijala neodpovidajici parametr. x >= 0 z N"); b = false;}
                 if(b)return faktorial(cisloa);
                      else return 0;
              }
      }
};
/*************************************************************************/
class Stupen: public Opr1par
{
      //x O
public:
      Stupen(Prvek *l): Opr1par(l) {} 
      virtual double vratHodnotu()
      {
              bool b = true;
              if(opr == 0){zobrazChybu("Funkce stupen x O neprijala parametr!"); b = false;}
              if(!b)return 0;else
              {
                 double a = opr->vratHodnotu();
                 return pi / 180 * a;
              }
      }
};
/*************************************************************************/
class NaDruhou: public Opr1par
{
      //x q
public:
      NaDruhou(Prvek *l): Opr1par(l) {} 
      virtual double vratHodnotu()
      {
              bool b = true;
              if(opr == 0){zobrazChybu("Funkce na druhou x q neprijala parametr!"); b = false;}
              if(!b)return 0;else
              {
                 double a = opr->vratHodnotu();
                 return a * a;
              }
      }
};
/*************************************************************************/
class NaTreti: public Opr1par
{
      //x h
public:
      NaTreti(Prvek *l): Opr1par(l) {} 
      virtual double vratHodnotu()
      {
              bool b = true;
              if(opr == 0){zobrazChybu("Funkce na treti x h neprijala parametr!"); b = false;}
              if(!b)return 0;else
              {
                 double a = opr->vratHodnotu();
                 return a * a * a;
              }
      }
};
/*************************************************************************/
class NaMinusPrvou: public Opr1par
{
      //x v
public:
      NaMinusPrvou(Prvek *l): Opr1par(l) {} 
      virtual double vratHodnotu()
      {
              bool b = true;
              if(opr == 0){zobrazChybu("Funkce na minus prvnou x v neprijala parametr!"); b = false;}
              if(!b)return 0;else
              {
                 double a = opr->vratHodnotu();
                 if(a == 0){zobrazChybu("Funkce na minus prvnou x v neni definovana pro x = 0!"); b = false;}
                 if(b)return 1 / a; else return 0;
              }
      }
};
/*************************************************************************/
/*                             operator x                                */
/*************************************************************************/
class Odmocnina: public Opr1par
{
      //o x      
public:
      Odmocnina(Prvek *l): Opr1par(l) {} 
      virtual double vratHodnotu()
      {
              bool b = true;
              if(opr == 0){zobrazChybu("Funkce odmocnina o x neprijala parametr!"); b = false;}
              if(!b)return 0;else
              {
                 double a = opr->vratHodnotu();
                 if(a < 0){zobrazChybu("Funkce odmocnina o x neni definovana pro x < 0!"); b = false;}
                 if(b)return mocnina(a, 0.5); else return 0;
              }
      }
};
/*************************************************************************/
class TretiOdmocnina: public Opr1par
{
      //r x      
public:
      TretiOdmocnina(Prvek *l): Opr1par(l) {} 
      virtual double vratHodnotu()
      {
              bool b = true;
              if(opr == 0){zobrazChybu("Funkce treti odmocnina r x neprijala parametr!"); b = false;}
              if(!b)return 0;else
              {
                 double a = opr->vratHodnotu();
                 return mocnina(a, 1.0 / 3);
              }
      }
};
/*************************************************************************/
class Log10: public Opr1par
{
      //l x      
public:
      Log10(Prvek *l): Opr1par(l) {} 
      virtual double vratHodnotu()
      {
              bool b = true;
              if(opr == 0){zobrazChybu("Funkce logaritmus (10) l x neprijala parametr!"); b = false;}
              if(!b)return 0;else
              {
                 double a = opr->vratHodnotu();
                 if(a < 0){zobrazChybu("Funkce logaritmus (10) l x neni definovana pro x <0!"); b = false;}
                 if(b)return log10(a); else return 0;
              }
      }
};
/*************************************************************************/
class LogE: public Opr1par
{
      //n x      
public:
      LogE(Prvek *l): Opr1par(l) {} 
      virtual double vratHodnotu()
      {
              bool b = true;
              if(opr == 0){zobrazChybu("Funkce logaritmus (e) n x neprijala parametr!"); b = false;}
              if(!b)return 0;else
              {
                 double a = opr->vratHodnotu();
                 if(a < 0){zobrazChybu("Funkce logaritmus (e) n x neni definovana pro x <0!"); b = false;}
                 if(b)return log(a); else return 0;
              }
      }
};
/*************************************************************************/
class DesetNaX: public Opr1par
{
      //d x      
public:
      DesetNaX(Prvek *l): Opr1par(l) {} 
      virtual double vratHodnotu()
      {
              bool b = true;
              if(opr == 0){zobrazChybu("Funkce 10 na x-tou d x neprijala parametr!"); b = false;}
              if(!b)return 0;else
              {
                 double a = opr->vratHodnotu();
                 return mocnina(10.0, a);
              }
      }
};
/*************************************************************************/
class EnaX: public Opr1par
{
      //u x      
public:
      EnaX(Prvek *l): Opr1par(l) {} 
      virtual double vratHodnotu()
      {
              bool b = true;
              if(opr == 0){zobrazChybu("Funkce e na x-tou u x neprijala parametr!"); b = false;}
              if(!b)return 0;else
              {
                 double a = opr->vratHodnotu();
                 return mocnina(2.718281828459045235360287471352, a);
              }
      }
};
/*************************************************************************/
class Sin: public Opr1par
{
      //s x      
public:
      Sin(Prvek *l): Opr1par(l) {} 
      virtual double vratHodnotu()
      {
              bool b = true;
              if(opr == 0){zobrazChybu("Funkce sinus s x neprijala parametr!"); b = false;}
              if(!b)return 0;else
              {
                 double a = opr->vratHodnotu();
                 return sin(a);
              }
      }
};
/*************************************************************************/
class Cos: public Opr1par
{
      //c x      
public:
      Cos(Prvek *l): Opr1par(l) {} 
      virtual double vratHodnotu()
      {
              bool b = true;
              if(opr == 0){zobrazChybu("Funkce cosinus c x neprijala parametr!"); b = false;}
              if(!b)return 0;else
              {
                 double a = opr->vratHodnotu();
                 return cos(a);
              }
      }
};
/*************************************************************************/
class Tan: public Opr1par
{
      //t x      
public:
      Tan(Prvek *l): Opr1par(l) {} 
      virtual double vratHodnotu()
      {
              bool b = true;
              if(opr == 0){zobrazChybu("Funkce tangens t x neprijala parametr!"); b = false;}
              if(!b)return 0;else
              {                           
                 double a = opr->vratHodnotu();
             	 while(a<0){a+=pi;}
                 while(a>=pi){a-=pi;}
                 if(a == pi / 2){zobrazChybu("Funkce tangens t x neni definovana pro x = pi / 2!"); b = false; return 0;}
                 return tan(a);
              }
      }
};
/*************************************************************************/
class Cotan: public Opr1par
{
      //g x      
public:
      Cotan(Prvek *l): Opr1par(l) {} 
      virtual double vratHodnotu()
      {
              bool b = true;
              if(opr == 0){zobrazChybu("Funkce cotangens g x neprijala parametr!"); b = false;}
              if(!b)return 0;else
              {
             	 double a = opr->vratHodnotu();
                 while(a<0){a+=pi;}
                 while(a>=pi){a-=pi;}
                 if(a == 0){zobrazChybu("Funkce cotangens g x neni definovana pro x = 0!"); b = false; return 0;}
                 if(a != pi / 2) return 1 / tan(a); else return 0;
              }
      }
};
/*************************************************************************/
class ASin: public Opr1par
{
      //S x      
public:
      ASin(Prvek *l): Opr1par(l) {} 
      virtual double vratHodnotu()
      {
              bool b = true;
              if(opr == 0){zobrazChybu("Funkce arkussinus S x neprijala parametr!"); b = false;}
              if(!b)return 0;else
              {
                 double a = opr->vratHodnotu();
                 if(a < -1 || a > 1){zobrazChybu("Funkce arkussinus S x neni definovana pro x < -1 a x > 1!"); b = false; return 0;}
                 return asin(a);
              }
      }
};
/*************************************************************************/
class ACos: public Opr1par
{
      //C x      
public:
      ACos(Prvek *l): Opr1par(l) {} 
      virtual double vratHodnotu()
      {
              bool b = true;
              if(opr == 0){zobrazChybu("Funkce arkuscosinus C x neprijala parametr!"); b = false;}
              if(!b)return 0;else
              {
                 double a = opr->vratHodnotu();
                 if(a < -1 || a > 1){zobrazChybu("Funkce arkuscosinus C x neni definovana pro x < -1 a x > 1!"); b = false; return 0;}
                 return acos(a);
              }
      }
};
/*************************************************************************/
class ATan: public Opr1par
{
      //T x      
public:
      ATan(Prvek *l): Opr1par(l) {} 
      virtual double vratHodnotu()
      {
              bool b = true;
              if(opr == 0){zobrazChybu("Funkce arkustanges T x neprijala parametr!"); b = false;}
              if(!b)return 0;else
              {
                 double a = opr->vratHodnotu();
                 return atan(a);
              }
      }
};
/*************************************************************************/
class ACotan: public Opr1par
{
      //G x      
public:
      ACotan(Prvek *l): Opr1par(l) {} 
      virtual double vratHodnotu()
      {
              bool b = true;
              if(opr == 0){zobrazChybu("Funkce arkuscotanges G x neprijala parametr!"); b = false;}
              if(!b)return 0;else
              {
                 double a = opr->vratHodnotu();
                 if(a == 0) return pi / 2; else return atan(1 / a);
              }
      }
};
/*************************************************************************/
double faktorial(int x)
{
	double vysl=1;
	for(int i=2;i<=x;i++)vysl*=i;
	return vysl;       
}
/*************************************************************************/
double mocnina(double zaklad,double exponent)
{
	return pow(zaklad,exponent);
}
/*************************************************************************/
#endif