#if (!defined(__misc_h))

#include <iostream>
#include <iomanip>
#include <stdlib.h>
#include <string>
#include <string.h>
#include <vector>
#include <sstream>
#include <fstream>
#include <vector>
#include <ctype.h>
#include "capd/capdlib.h"
#include "capd/mpcapdlib.h"

using namespace std;
using namespace capd;

string HostName();
string CurrentDayHour();
string CurrentDay();
string CurrentHour();
string itos(int i);

template <typename T> void Swap(T &a, T &b){
  T temp=a;
  a=b;
  b=temp;
}

template <typename T> T &Max(const T &a, const T &b){
  return (T &)(a>b?a:b);
}

template <typename T> T &Min(const T &a, const T &b){
  return (T &)((a<b)?a:b);
}

template <typename T> bool Sort(unsigned long n, T ra[]){
  // from Numerical Recipes in C (modified qcsort.C
  // sorts array ra[0],...ra[n-1]
  unsigned long i,ir,j,l;
  T rra;

  if (n <= 1) return false;
  l=(n >> 1)+1;
  ir=n;
  for (;;) {
    if (l > 1) {
      rra=ra[--l-1];
    } else {
      rra=ra[ir-1];
      ra[ir-1]=ra[0];
      if (--ir == 1) {
        ra[0]=rra;
        break;
      }
    }
    i=l;
    j=l+l;
    while (j <= ir) {
      if (j < ir && ra[j-1] < ra[j]) j++;
      if (rra < ra[j-1]) {
        ra[i-1]=ra[j-1];
        i=j;
        j <<= 1;
      } else j=ir+1;
    }
    ra[i-1]=rra;
  }
  return true;
}

bool FileRemove(const char *filename);
bool FileExists(const char *filename);
int FileSize(const char* FileName);
void FileCopy(const char* From, const char* To);
string dirname(const char* FileName);
long GetMemAvail();
long GetMemMax();
int Execute(const char *Command, bool disp=true);
int Execute(const char *Command, const char *FileName, bool disp=true);
void ViewTempFile(const char *PrintCommand, const char *FileName);
int exec(char *argv[]);
int execwait(char *argv[]);
int execwait(vector <string> argstring);
int execwait(const char *arg);

class TimeCount {
  long TicksComp;	// keeps start of computation time 
  long TicksElapsed;	// keeps start of elapsed time
			// usually elapsed time > computation time
			// may not be true for small elapsed time
public:
  void Reset();
  long GetCompTime();
  long GetElapsedTime();
  TimeCount(){Reset();};
  string ElapsedTimeString();
  void Print();
  void PrintElapsed(int w=0);
  friend ostream& operator<<(ostream& s, TimeCount & TC);
};

/************* SAVE OPTIONS **************/

class OptItem{
 public:
  string typ;
  string info;
  OptItem(string atyp, string ainfo){typ=atyp; info=ainfo;};
  virtual void SetValue(ifstream & InFile)=0;
  virtual void SetValue(const char *val)=0;
  virtual void Print(ostream& s)=0;
  virtual ~OptItem(){};
  //  virtual friend ostream& operator<<(ostream& s, const IntItem & OI)=0;
};

class CommentItem: public OptItem{
 public:
  CommentItem(string ainfo): OptItem("CommentType",ainfo){;};
  void SetValue(ifstream & InFile){};
  void SetValue(const char *val){};
  void Print(ostream& s){};
};

class IntItem: public OptItem{
 public:
  int *pvalue;
  IntItem(string ainfo, int *apvalue): OptItem("IntType",ainfo), pvalue(apvalue){;};
  void SetValue(ifstream & InFile){ InFile >> *pvalue;};
  void SetValue(const char *val){ *pvalue=atoi(val);};
  void Print(ostream& s){ s << *pvalue;}
  //  friend ostream& operator<<(ostream& s, const IntItem & OI){return s << *(OI.pvalue);};
};

class LongLongIntItem: public OptItem{
 public:
  long long int *pvalue;
  LongLongIntItem(string ainfo, long long int *apvalue): OptItem("IntType",ainfo), pvalue(apvalue){;};
  void SetValue(ifstream & InFile){ InFile >> *pvalue;};
  void SetValue(const char *val){ *pvalue=atoll(val);};
  void Print(ostream& s){ s << *pvalue;}
  //  friend ostream& operator<<(ostream& s, const IntItem & OI){return s << *(OI.pvalue);};
};

class BoolItem: public OptItem{
 public:
  bool *pvalue;
  BoolItem(string ainfo, bool *apvalue): OptItem("BoolType",ainfo), pvalue(apvalue){;};
  void SetValue(ifstream & InFile){ string str; InFile >> str; *(pvalue)=(str=="true");};
  void SetValue(const char *val){ *(pvalue)=(val[0]=='t'); if (val[0]=='n' || val[0]=='f') *(pvalue)=false; };
  void Print(ostream& s){ s << (*pvalue?"true":"false");};
};

class DoubleItem: public OptItem{
 public:
  double *pvalue;
  DoubleItem(string ainfo, double *apvalue): OptItem("DoubleType",ainfo), pvalue(apvalue){;};
  void SetValue(ifstream & InFile){ InFile >> *pvalue;};
  void SetValue(const char *val){ *pvalue=atof(val);};
  void Print(ostream& s){ s << *pvalue;};
};

class StringItem: public OptItem{
 public:
  string *pvalue;
  StringItem(string ainfo, string *apvalue): OptItem("StringType",ainfo), pvalue(apvalue){;};
  void SetValue(ifstream & InFile){ char ch; char WS[256]; InFile.get(ch);/*while (InFile.get(ch) && isspace(ch)); InFile.putback(ch); */ InFile.getline(WS,255); *pvalue=WS; InFile.putback('\n');};
  void SetValue(const char *val){ *pvalue=val; };
  void Print(ostream& s){ s << *pvalue;};
};

class ColorItem: public OptItem{
 public:
  double *pvalue;
  ColorItem(string ainfo, double *apvalue): OptItem("ColorType",ainfo), pvalue(apvalue){;};
  void SetValue(ifstream & InFile){ InFile >> pvalue[0] >> pvalue[1]>> pvalue[2];};
  void SetValue(const char *val){};
  void Print(ostream& s){ s << pvalue[0] << " " << pvalue[1] << " " << pvalue[2];};
};

class VectorItem: public OptItem{
 public:
  DVector *pvalue;
  VectorItem(string ainfo, DVector *apvalue): OptItem("VectorType",ainfo), pvalue(apvalue){;};
  void SetValue(ifstream & InFile){ int d; InFile >> d; (*pvalue).resize(d); for (int i=1;i<=d;i++) InFile >> (*pvalue)(i); };
  void SetValue(const char *val);
  void Print(ostream& s){ s << (*pvalue).dimension(); for (int i=1;i<=(*pvalue).dimension();i++) s << " " << (*pvalue)(i); };
};

class ConfigFile {
public:
  OptItem *Item[1000];
  string DefaultFileName;
  bool Defined;
  int ItemNum;
  void AddComment(const char *info)                                 {Item[ItemNum++] = new CommentItem(info);}
  void AddInt(const char *info, int *pvalue)                        {Item[ItemNum++] = new IntItem(info,pvalue);}
  void AddLongLongInt(const char *info, long long int *pvalue)      {Item[ItemNum++] = new LongLongIntItem(info,pvalue);}
  void AddBool(const char *info, bool *pvalue)                      {Item[ItemNum++] = new BoolItem(info,pvalue);}
  void AddDouble(const char *info, double *pvalue)                  {Item[ItemNum++] = new DoubleItem(info,pvalue);}
  void AddString(const char *info, string *pvalue)                  {Item[ItemNum++] = new StringItem(info,pvalue);}
  void AddVector(const char *info, DVector *pvalue)                 {Item[ItemNum++] = new VectorItem(info,pvalue);}
  void AddColor(const char *info, double *pvalue)                   {Item[ItemNum++] = new ColorItem(info,pvalue);}
  ConfigFile(string aDefaultFileName){ItemNum=0; Defined=false; DefaultFileName=aDefaultFileName;}
  virtual ~ConfigFile(){while (ItemNum>0) delete Item[--ItemNum];};
  virtual void Init()=0;
  void Define(){ if (Defined) return; Defined=true; Init();};
  virtual void Read(string FN);
  void ReadDefault(){Read(DefaultFileName);};
  virtual void Save(string FN);
  void SaveDefault(){Save(DefaultFileName);};
  bool GetValue(const char *info, const char *val);
};

string ScalarToLatexString(double x, int width1=5, int width2=3);

#define __misc_h __misc_h
#endif