Лабораторные работы №4 и №5 / gera / function

//#include "translator.h"
#include "vector.h"

//#define DLTX 0.00000001

class Stack
{
  private:
    double stack[100];
    int N;
  public:
    Stack(void);
    ~Stack(void);

    void   PUSH(double NewItem);
    double POP(void);
};

Stack::Stack(void)
{
  N=-1;
};

Stack::~Stack(void)
{
};

void Stack :: PUSH(double NewItem)
{
  stack[++N]=NewItem;
};

double Stack :: POP(void)
{
  return stack[N--];
};

class myFunction
{
  private:
    char *PolishString;

  public:
    double p;
    double Value;

    myFunction()
    {
      PolishString=NULL;
    }
    myFunction(const char *);
    ~myFunction();

    void SetDirection(double);
    double Calculate(TVector , char *);
    double Calculate(TVector, TVector, char *, double);
    double* FormGrad(TVector point);
    void Reload(char* string);
    double Derivative(TVector Direction, TVector point);
};

void myFunction::Reload(char* string)
{
    int i;

    for(i=0;string[i]!='\0';i++);
    if(PolishString) free(PolishString);
    PolishString=(char*)malloc(sizeof(char)*i);
    strncpy(PolishString,string,i);
    PolishString[i]='\0';
}

myFunction :: myFunction(const char *InitString)
{
  int i;
  for(i=0;InitString[i]!='\0';i++);
  PolishString=(char*)malloc(sizeof(char)*i);
  strncpy(PolishString,InitString,i);
  PolishString[i]='\0';
  i=0;
};

myFunction :: ~myFunction()
{
  if(PolishString)
  free(PolishString);
};

double myFunction :: Calculate(TVector A, char *VarNames)
{
  double *VarValues=A.Value();
  //int h;
  //for(h=0;h<vc;h++)
   // ShowMessage("Var "+IntToStr(h)+" has value "+FloatToStr(VarValues[h]));
  Stack Engine;
  unsigned int i=0,k=0;
  double op1=0,op2=0;
  double real=0;
//  bool FloatPointWas=false;
  for(i=0;PolishString[i]!='\0';i++)
  {
    if((PolishString[i]>='0')&&(PolishString[i]<='9'))
    {
/*       if(PolishString[i]=='.')
       {
         FloatPointWas=true;
         k=0;
       }
       else
       if(!FloatPointWas)
       {                 */
         real*=10;
         real+=(PolishString[i]-'0');
/*       }
       else
       {
         k++;
         real+=((PolishString[i]-'0')/pow(10,k));
       };*/
    }
    else
    {
      if(real)
        Engine.PUSH(real);
      real=0;
//      FloatPointWas=false;
      if((PolishString[i]>='a')&&(PolishString[i]<='z'))
      {
        for(k=0;VarNames[k]!=PolishString[i];k++);
        Engine.PUSH(VarValues[k]);
      }
      else
      {
        switch(PolishString[i])
        {
          case '+':
            op1=Engine.POP();
            op2=Engine.POP();
            op2+=op1;
            Engine.PUSH(op2);
          break;
	  case '-':
            op1=Engine.POP();
            op2=Engine.POP();
            op2-=op1;
            Engine.PUSH(op2);
          break;
	  case '/':
            op1=Engine.POP();
            op2=Engine.POP();
            op2/=op1;
            Engine.PUSH(op2);
          break;
	  case '*':
            op1=Engine.POP();
            op2=Engine.POP();
            op2*=op1;
            Engine.PUSH(op2);
          break;
	  case '^':
            op1=Engine.POP();
            op2=Engine.POP();
            op2=pow(op2,op1);
            Engine.PUSH(op2);
          break;
	  case '~':
            op2=Engine.POP();
            op2=log(op2);
            Engine.PUSH(op2);
          break;
        };
      };
    };
  };
  double d=Engine.POP();
  return d;
};

double myFunction :: Calculate(TVector StartPoint,TVector Direction, char *VarNames, double alpha)
{
  TVector A(Direction.Value(),Direction.Dimensions());

  A*=alpha;
  A+=StartPoint;
  return Calculate(A,VarNames);
};

      void myFunction :: SetDirection(double iP)
{
  p=iP;
};

double myFunction::Derivative(TVector Direction, TVector point)
{
  TVector Grd(FormGrad(point),vc);
  
  return Grd*Direction;
}

double* myFunction::FormGrad(TVector point)
{
  int i;
  double f1, f0,*grad_p;

  grad_p=new double[vc];
  for(i=0;i<vc;i++)
  {
  	f0=Calculate(point,vars);
  	point.coords[i]+=DLTX;
  	f1=Calculate(point,vars);
  	grad_p[i]=(f1-f0)/DLTX;
  	point.coords[i]-=DLTX;
  }

  return grad_p;
}