/*
realmp inttomp(int)                                   //1
realmp inttomp(unsigned int)                          //1.5
void printmp(realmp)                                  //2
realmp operator+(realmp,realmp)                       //3
realmp operator+(int,realmp)                          //4
realmp operator+(realmp,int)                          //5
realmp operator-(realmp,realmp)                       //6
realmp operator-(realmp)                              //7
realmp operator-(int,realmp)                          //8
realmp operator-(realmp,int)                          //9
realmp operator/(realmp,unsigned int)                 //10
realmp operator/(realmp,int);                         //10.5
realmp operator/(int,realmp)    //changed             //11
realmp operator/(unsigned int,realmp)                 //11.5
realmp operator/(realmp,realmp)                       //12
realmp operator*(realmp,realmp)                       //13
realmp operator*(realmp,unsigned int)                 //14
realmp operator*(unsigned int,realmp)                 //15
realmp operator*(int,realmp)                          //16
void operator<(realmp,realmp)                         //17
void operator<(realmp,int)                            //18
realmp operator^(realmp,int)                          //19
realmp operator^(int,realmp)                          //20
realmp operator^(realmp,realmp)                       //21
realmp sqrt(realmp)                                   //22
realmp sin(realmp)                                    //23
realmp cos(realmp)                                    //24
realmp exp(realmp)                                    //25
realmp log(realmp)                                    //26
realmp arcsin(realmp)                                 //27
realmp arctan(realmp)                                 //28
realmp zinputtomp(unsigned int *zinput)               //29
float zconmptof(realmp)                               //30
realmp abs(realmp)                                    //31
realmp pi_mp(void)                                    //32
realmp e_mp(void)                                     //33
realmp log10(realmp)                                  //34
realmp conftomp(double)                               //35                           
char *compare(realmp,realmp)                          //36
void writetofile(realmp,char *)                       //37
void readfromfile(realmp,char *)                      //38
void write1Darraytofile(realmp x[zmaxsizepad], char *)      //39
void read1Darrayfromfile(realmp x[zmaxsizepad], char *)     //40
void write2Darraytofile(realmp x[zmaxsizepad][zmaxsizepad],char *)  //41
void read2Darrayfromfile(realmp x[zmaxsizepad][zmaxsizepad],char *) //42
confloattomp()
*/

#include "zclasses.new"

#include <fstream.h>   
ifstream zfilein;   //need these when working with disk files
ofstream zfileout;

realmp wwreturn[depthcountmax];
realmp ww10;          //used internal to compare

char *resultofcompare;

realmp inttomp(int wwkk)                               //1
{
   int zi;
   zconinttomp(wwkk);
   depthcount++;
   for (zi=0;zi<prec+2;zi++) wwreturn[depthcount].sv(zi,z[zi]);
   return wwreturn[depthcount];
}

realmp inttomp(unsigned int wwkk)                       //1.5
{
   int zi;
   zconinttomp(wwkk);
   depthcount++;
   for (zi=0;zi<prec+2;zi++) wwreturn[depthcount].sv(zi,z[zi]);
   return wwreturn[depthcount];
}

void printmp(realmp ww4prnt)                           //2
{int zi;
 for (zi=0;zi<prec+2;zi++) z4prnt[zi]=ww4prnt.gv(zi);
 zprnt(z4prnt);
 depthcount=2;  //after all, print is same as <
}               

realmp operator+(realmp ww8,realmp ww9)               //3
{int zi;
 for (zi=0;zi<prec+2;zi++) 
  {z8[zi]=ww8.gv(zi);
   z9[zi]=ww9.gv(zi);}
 zadd(z8,z9);
 depthcount++;
 for (zi=0;zi<prec+2;zi++) wwreturn[depthcount].sv(zi,z[zi]);
 return wwreturn[depthcount];
}

realmp operator+(int iop,realmp ww9)                 //4
{int zi;
 zconinttomp(iop);
 zstore(z8);
 for (zi=0;zi<prec+2;zi++)
  {z9[zi]=ww9.gv(zi);}
 zadd(z8,z9);
 depthcount++;
 for (zi=0;zi<prec+2;zi++) wwreturn[depthcount].sv(zi,z[zi]);
 return wwreturn[depthcount];
}

realmp operator+(realmp ww8,int iop)                 //5
{int zi;
 zconinttomp(iop);
 zstore(z9);
 for (zi=0;zi<prec+2;zi++)
  {z8[zi]=ww8.gv(zi);}
 zadd(z8,z9);
 depthcount++;
 for (zi=0;zi<prec+2;zi++) wwreturn[depthcount].sv(zi,z[zi]);
 return wwreturn[depthcount];
}

realmp operator-(realmp ww8,realmp ww9)             //6
{int zi;
 for (zi=0;zi<prec+2;zi++)
  {z8[zi]=ww8.gv(zi);
   z9[zi]=ww9.gv(zi);}
 zsub(z8,z9);
 depthcount++;
 for (zi=0;zi<prec+2;zi++) wwreturn[depthcount].sv(zi,z[zi]);
 return wwreturn[depthcount];
}

realmp operator-(realmp ww9)  //a=-b does not change sign of b   //7
 {int zi;                            //a=-a changes sign of a
  depthcount++;
  for (zi=0;zi<prec+1;zi++) wwreturn[depthcount].sv(zi,ww9.gv(zi));
  wwreturn[depthcount].sv(prec+1,2-ww9.gv(prec+1));
  return wwreturn[depthcount];
}

realmp operator-(int iop,realmp ww9)                  //8
{int zi;
 zconinttomp(iop);
 zstore(z8);
 for (zi=0;zi<prec+2;zi++)
  {z9[zi]=ww9.gv(zi);}
 zsub(z8,z9);
 depthcount++;
 for (zi=0;zi<prec+2;zi++) wwreturn[depthcount].sv(zi,z[zi]);
 return wwreturn[depthcount];
}

realmp operator-(realmp ww8,int iop)                //9
{int zi;
 zconinttomp(iop);
 zstore(z9);
 for (zi=0;zi<prec+2;zi++)
  {z8[zi]=ww8.gv(zi);}
 zsub(z8,z9);
 depthcount++;
 for (zi=0;zi<prec+2;zi++) wwreturn[depthcount].sv(zi,z[zi]);
 return wwreturn[depthcount];
}

realmp operator/(realmp ww8,unsigned int wkk)       //10
{int zi;
 for (zi=0;zi<prec+2;zi++)
  {z8[zi]=ww8.gv(zi);}
 zdivint(z8,wkk);                                    //was uint
 depthcount++;
 for (zi=0;zi<prec+2;zi++) wwreturn[depthcount].sv(zi,z[zi]);
 return wwreturn[depthcount];
}

realmp operator/(int wkk,realmp ww8)       //11
{int zi;                  //this could have been int
 zconinttomp(wkk);
 for (zi=0;zi<prec+2;zi++)
  {z8[zi]=ww8.gv(zi);}
 zdiv(z,z8);
 depthcount++;
 for (zi=0;zi<prec+2;zi++) wwreturn[depthcount].sv(zi,z[zi]);
 return wwreturn[depthcount];
}

realmp operator/(unsigned int wkk,realmp ww8)  //11.5 Nov27,99
{int zi;                  //this could have been int
 zconinttomp(wkk);
 for (zi=0;zi<prec+2;zi++)
  {z8[zi]=ww8.gv(zi);}
 zdiv(z,z8);
 depthcount++;
 for (zi=0;zi<prec+2;zi++) wwreturn[depthcount].sv(zi,z[zi]);
 return wwreturn[depthcount];
}

realmp operator/(realmp ww8,int wkk)       //10.5
{int zi;
 for (zi=0;zi<prec+2;zi++)
  {z8[zi]=ww8.gv(zi);}
 zdivint(z8,wkk);        //zdivint now has int also
 depthcount++;
 for (zi=0;zi<prec+2;zi++) wwreturn[depthcount].sv(zi,z[zi]);
 return wwreturn[depthcount];
}


realmp operator/(realmp ww8,realmp ww9)           //12
{int zi;
 for (zi=0;zi<prec+2;zi++)
  {z8[zi]=ww8.gv(zi);
   z9[zi]=ww9.gv(zi);}
 zdiv(z8,z9);
 depthcount++;
 for (zi=0;zi<prec+2;zi++) wwreturn[depthcount].sv(zi,z[zi]);
 return wwreturn[depthcount];
}
 
realmp operator*(realmp ww8,realmp ww9)          //13
{int zi;
 for (zi=0;zi<prec+2;zi++)
  {z8[zi]=ww8.gv(zi);
   z9[zi]=ww9.gv(zi);}
 zmult(z8,z9);
 depthcount++;
 for (zi=0;zi<prec+2;zi++) wwreturn[depthcount].sv(zi,z[zi]);
 return wwreturn[depthcount]; 
}

realmp operator*(realmp ww8,unsigned int wkk)    //14
{int zi;
 for (zi=0;zi<prec+2;zi++)
  {z8[zi]=ww8.gv(zi);}
 zmultint(z8,wkk);                               //was uint
 depthcount++;
 for (zi=0;zi<prec+2;zi++) wwreturn[depthcount].sv(zi,z[zi]);
 return wwreturn[depthcount];
}

/*   //the following two ambiguate operator*  (int and float)
realmp operator*(realmp ww8,float zewok)
{int zi;
 for (zi=0;zi<prec+2;zi++)
  {z8[zi]=ww8.gv(zi);}
 zconftomp(zewok);
 zmult(z8,z);
 depthcount++;
 for (zi=0;zi<prec+2;zi++) wwreturn[depthcount].sv(zi,z[zi]);
 return wwreturn[depthcount];
}

realmp operator*(float zewok,realmp ww8)
{int zi;
 for (zi=0;zi<prec+2;zi++)
  {z8[zi]=ww8.gv(zi);}
 zconftomp(zewok);
 zmult(z8,z);
 depthcount++;
 for (zi=0;zi<prec+2;zi++) wwreturn[depthcount].sv(zi,z[zi]);
 return wwreturn[depthcount];
}
*/

realmp operator*(unsigned int wkk,realmp ww8)    //15
{int zi;
 for (zi=0;zi<prec+2;zi++)
  {z8[zi]=ww8.gv(zi);}
 zmultint(z8,wkk);                                 //was uint
 depthcount++;
 for (zi=0;zi<prec+2;zi++) wwreturn[depthcount].sv(zi,z[zi]);
 return wwreturn[depthcount];    
}


realmp operator*(int wkk,realmp ww8)            //16
{int zi;
 for (zi=0;zi<prec+2;zi++)
  {z8[zi]=ww8.gv(zi);}
 zmultint(z8,wkk);
 depthcount++;
 for (zi=0;zi<prec+2;zi++) wwreturn[depthcount].sv(zi,z[zi]);
 return wwreturn[depthcount];    
}

realmp operator*(realmp ww8,int wkk)            //16.5
{int zi;
 for (zi=0;zi<prec+2;zi++)
  {z8[zi]=ww8.gv(zi);}
 zmultint(z8,wkk);
 depthcount++;
 for (zi=0;zi<prec+2;zi++) wwreturn[depthcount].sv(zi,z[zi]);
 return wwreturn[depthcount];    
}

void operator<(realmp ww9,realmp ww10)         //17
{ int zi;
  for (zi=0;zi<prec+2;zi++)
    {ww9.sv(zi,ww10.gv(zi));}
  depthcount=2;
}

void operator<(realmp ww9,int iop)            //18
{ int zi;
  zconinttomp(iop);                  
  for (zi=0;zi<prec+2;zi++)          
    {ww9.sv(zi,z[zi]);}
  depthcount=2;
}

realmp operator^(realmp ww8,int zip)  //this is x^n  //19
 {int zi;
  for (zi=0;zi<prec+2;zi++) zzz1[zi]=ww8.gv(zi);
  zxtonth(zzz1,zip);
  depthcount++;
  for (zi=0;zi<prec+2;zi++) wwreturn[depthcount].sv(zi,z[zi]);
  return wwreturn[depthcount];    
 }

realmp operator^(int zip,realmp ww9)  //this is n^x   //20
 {int zi;
  for (zi=0;zi<prec+2;zi++) z2[zi]=ww9.gv(zi);
  zconinttomp(zip);
  zlog(z);
  zmult(z,z2);
  zexp(z);
  depthcount++;
  for (zi=0;zi<prec+2;zi++) wwreturn[depthcount].sv(zi,z[zi]);
  return wwreturn[depthcount];
 }

realmp operator^(realmp ww8,realmp ww9)  //this is x^y  //21
 {int zi;
  for (zi=0;zi<prec+2;zi++) z1[zi]=ww8.gv(zi);
  for (zi=0;zi<prec+2;zi++) z2[zi]=ww9.gv(zi);
  zlog(z1);
  zmult(z,z2);
  zexp(z);
  depthcount++;
  for (zi=0;zi<prec+2;zi++) wwreturn[depthcount].sv(zi,z[zi]);
  return wwreturn[depthcount];    
 }

realmp sqrt(realmp ww8)                              //22
{int zi;
 for (zi=0;zi<prec+2;zi++)
  {zz1[zi]=ww8.gv(zi);}
   zsqrt(zz1);
   depthcount++;
   for (zi=0;zi<prec+2;zi++) wwreturn[depthcount].sv(zi,z[zi]);
   return wwreturn[depthcount];    
}

realmp sin(realmp ww8)                            //23
{int zi;
 for (zi=0;zi<prec+2;zi++) zz4[zi]=ww8.gv(zi);
 zsin(zz4);
 depthcount++;
 for (zi=0;zi<prec+2;zi++) wwreturn[depthcount].sv(zi,z[zi]);
 return wwreturn[depthcount];    
}

realmp cos(realmp ww8)                           //24
{int zi;
 for (zi=0;zi<prec+2;zi++) zz3[zi]=ww8.gv(zi);
 zcos(zz3);
 depthcount++;
 for (zi=0;zi<prec+2;zi++) wwreturn[depthcount].sv(zi,z[zi]);
 return wwreturn[depthcount];    
}

realmp exp(realmp ww8)                           //25
{int zi;
 for (zi=0;zi<prec+2;zi++) zz4[zi]=ww8.gv(zi);
 zexp(zz4);
 depthcount++;
 for (zi=0;zi<prec+2;zi++) wwreturn[depthcount].sv(zi,z[zi]);
 return wwreturn[depthcount];    
}

realmp log(realmp ww8)                           //26
{int zi;
 for (zi=0;zi<prec+2;zi++) zz3[zi]=ww8.gv(zi);
 zlog(zz3);
 depthcount++;
 for (zi=0;zi<prec+2;zi++) wwreturn[depthcount].sv(zi,z[zi]);
 return wwreturn[depthcount];    
}

realmp arcsin(realmp zwwzz1)                   //27
{int zi;
 for (zi=0;zi<prec+2;zi++) zzz1[zi]=zwwzz1.gv(zi);
 zarcsin(zzz1);
 depthcount++;
 for (zi=0;zi<prec+2;zi++) wwreturn[depthcount].sv(zi,z[zi]);
 return wwreturn[depthcount];    
}

realmp arctan(realmp zwwz5)                           //28
{int zi;
 for (zi=0;zi<prec+2;zi++) zz5[zi]=zwwz5.gv(zi);
 zarctan(zz5);
 depthcount++;
 for (zi=0;zi<prec+2;zi++) wwreturn[depthcount].sv(zi,z[zi]);
 return wwreturn[depthcount];    
}

realmp zinputtomp(unsigned int *zinput)   //29
{int zi;
 zconinputtomp(zinput);
 depthcount++;
 for (zi=0;zi<prec+2;zi++) wwreturn[depthcount].sv(zi,z[zi]);
 return wwreturn[depthcount];    
}

float zconmptof(realmp zww1)              //30
{int zi;
 for (zi=0;zi<prec+2;zi++) z1[zi]=zww1.gv(zi);
 zconmptof(z1);
 return zf;               //this calculates zf
}

realmp abs(realmp ww8)                  //31
 {int zi;
  depthcount++;
  for (zi=0;zi<prec+1;zi++) wwreturn[depthcount].sv(zi,ww8.gv(zi));
  wwreturn[depthcount].sv(prec+1,2);
  return wwreturn[depthcount];
 }

realmp pi_mp(void)                     //32
 {int zi;
  zpi();
  depthcount++;
  for (zi=0;zi<prec+2;zi++) wwreturn[depthcount].sv(zi,z[zi]);
  return wwreturn[depthcount];
 }

realmp e_mp(void)                     //33
 {int zi;
  zee();
  depthcount++;
  for (zi=0;zi<prec+2;zi++) wwreturn[depthcount].sv(zi,z[zi]);
  return wwreturn[depthcount];
 }

realmp log10(realmp ww9)   //just to have standard C  //34
 {int zi;
  zconinttomp(10);
  zlog(z);
  zstore(z8);
  for (zi=0;zi<prec+2;zi++) z9[zi]=ww9.gv(zi);
  zlog(z9);    //log base e of 10 = 1/ log base 10 of e
               //log base 10 of w9 = log base 10 of e x log base e of w9
               //so log base 10 of w9 = log base e of w9 / log base e of 10
  zdiv(z,z8);
  depthcount++;
  for (zi=0;zi<prec+2;zi++) wwreturn[depthcount].sv(zi,z[zi]);
  return wwreturn[depthcount];
 }

realmp conftomp(double zff)           //35                           
 {int zi;
  zconftomp(zff);
  depthcount++;
  for (zi=0;zi<prec+2;zi++) wwreturn[depthcount].sv(zi,z[zi]);
  return wwreturn[depthcount];
 }

char *compare(realmp ww8,realmp ww9)    //36
 {ww10=ww8-ww9;
  resultofcompare="error";
  if (ww10.gv(prec)==0)
    {resultofcompare="equal";
     goto zzarubbzz;
    }
  if (ww10.gv(prec+1)==2) resultofcompare="left largest";
  if (ww10.gv(prec+1)==0) resultofcompare="right largest"; 
  if (resultofcompare=="error")
    {zmessage="error in comparing left and right hand sides";
     zbreak();
    }
zzarubbzz: return resultofcompare;
 }    

void writetofile(realmp zwvariablename,char *zwtoit)   //37
  {int zi3;
   zfileout.open(zwtoit, ios::out);
   for (zi3=0;zi3<prec+2;zi3++) zfileout<<zwvariablename.gv(zi3)<<'\n';
   zfileout.close();
  }

void readfromfile(realmp zwvariablename,char *zwfromit)  //38
  {int zi3;
   zfilein.open(zwfromit, ios::in);
   for (zi3=0;zi3<prec+2;zi3++)
     {zfilein>>z[zi3];
      zwvariablename.sv(zi3,z[zi3]);
     }
   zfilein.close();
  }

void write1Darraytofile(realmp zwvariablename[zmaxsizepad], char *zwtoit)  //39
  {int zi3,zj3;
   zfileout.open(zwtoit, ios::out);
   for (zi3=0;zi3<zmaxsize+1;zi3++)
     {for (zj3=0;zj3<prec+2;zj3++) zfileout<<zwvariablename[zi3].gv(zj3)<<'\n';}
   zfileout.close();
  }

void read1Darrayfromfile(realmp zwvariablename[zmaxsizepad], char *zwfromit) //40
  {int zi3,zj3;
   zfilein.open(zwfromit, ios::in);
   for (zi3=0;zi3<zmaxsize+1;zi3++)
     {for (zj3=0;zj3<prec+2;zj3++)
        {zfilein>>z[zj3];
         zwvariablename[zi3].sv(zj3,z[zj3]);
        }
      }
   zfilein.close();
  }

void write2Darraytofile(realmp zwvariablename[zmaxsizepad][zmaxsizepad],char *zwtoit)  //41
  {int zi3,zj3,zk3;
   zfileout.open(zwtoit, ios::out);
   for (zi3=0;zi3<zmaxsize+1;zi3++)
    {for (zj3=0;zj3<zmaxsize+1;zj3++)
{for (zk3=0;zk3<prec+2;zk3++) zfileout<<zwvariablename[zi3][zj3].gv(zk3)<<'\n';}
    }
   zfileout.close();
  }
  
void read2Darrayfromfile(realmp zwvariablename[zmaxsizepad][zmaxsizepad],char *zwfromit) //42 
  {int zi3,zj3,zk3;
   zfilein.open(zwfromit, ios::in);
   for (zi3=0;zi3<zmaxsize+1;zi3++)
    {for (zj3=0;zj3<zmaxsize+1;zj3++)
       {for (zk3=0;zk3<prec+2;zk3++)
          {zfilein>>z[zk3];
           zwvariablename[zi3][zj3].sv(zk3,z[zk3]);
          }
       }
    }
   zfilein.close();
  }

realmp floattomp(int ziop)
  {int zi;
   zconftomp(ziop);
   depthcount++;
   for (zi=0;zi<prec+2;zi++) wwreturn[depthcount].sv(zi,z[zi]);
   return wwreturn[depthcount];
 }