// basic.h
// Purpose:  Basic operations
// Language: C++
// Authors:  E.Mayoraz, S.Brover



#ifndef basic_h
#define basic_h 



#include <stdlib.h>
#include <stdio.h>
#include <nan.h>




/////////////////////////////////// General ////////////////////////////////

#define  ForEver   for (;;)
#define  For(i,N)  for (uint i = 0; i < (N); i++)    
#define  Case      break; case
#define  Default   break; default
#define  tcT 	   template <class T>

typedef  unsigned char     byte;
typedef  unsigned int      uint;
typedef  long int          lint;
typedef  long unsigned int luint;
typedef  long double       ldouble;

tcT void Exchange (T &X,
		   T &Y);
  // If (& X == & Y) then return




////////////////////////////////// Debugging ///////////////////////////////

#define  assert(Cond)                                     \
  if (Debug)                                              \
    {                                                     \
      if (! (Cond))                                       \
	{                                                 \
	  printf ("\n\"%s\", line %d:\nCheck fail: %s\n", \
                  __FILE__, __LINE__, #Cond);             \
	  exit (1);                                       \
	}                                                 \
    }

#define RunError assert(false)




/////////////////////////////////// boolean /////////////////////////////////

typedef  signed char    boolean;
  // "signed" - for downward cycles
enum     {false, true, BooleanDontKnow};
extern   const char  Bool2Char [3/*boolean*/];

inline boolean IsBoolean (int N)
  {
    return (N == false || 
	    N == true);  
  }

inline boolean IsExtBoolean (int N)
  {
    return (N == false || 
	    N == true  ||
	    N == BooleanDontKnow);  
  }

void Toggle (boolean &B);

inline int  Boolean2Sign (boolean B)
  { return B ? 1 : -1; }  
 
#define  ForBoolean(B)      for (boolean B = false; B <= true;  B++)
#define  ForBooleanDown(B)  for (boolean B = true;  B >= false; B--)
  



/////////////////////////////////// Array //////////////////////////////////

tcT T* ArrayInsert (uint Index, 
		    T*   &Data, 
		    uint &DataSize);
  // Insert 1 new element into Data at position Index
  // Return: pointer to the new element
  // DataSize++
  // Data != NULL

tcT T* ArrayAppend (T*   &Data,
		    uint &DataSize);
  // Invokes: ArrayInsert

tcT void ArrayAugment (T*   &Data,
		       uint &DataSize,
		       uint Inc);
  // DataSize += Inc
  // Data != NULL

tcT void ArrayDelete (uint Index,
		      T*   &Data,
		      uint &DataSize);
  // DataSize--
  // Data != NULL

tcT void ArrayReduce (T*   &Data,
		      uint &DataSize,
		      uint Dec);
  // DataSize -= Dec
  // Data != NULL




//////////////////////////////////// ROOT ///////////////////////////////////

class ROOT
{
public:  
  uint ErrorNum;  
    // 0 - no error
    // 1 - out of memory

  ROOT ()  { ErrorNum = 0; };
  virtual ~ROOT ()  {};
};




//////////////////////////////////// NAMED /////////////////////////////////

class NAMED: public ROOT
{
typedef ROOT inherited;

public:  
  char* Name;
  
  NAMED  (const char* initName);
  ~NAMED ();
};




/////////////////////////////////// String /////////////////////////////////

char*    StrNew (const char* S);

char*    StrRename (char* &S,
		    const char* NewS);

char*    StrEnd (char* S);

boolean  StrIsEmpty (const char* S);

boolean  StrIsBlank (const char* S);
  // true iff all characters in S are spaces

char*    StrChar (char  C,
		  uint  Len,
		  char* S);
  // Len - effective length of S

char*    StrBlank (uint  Len,
		   char* S);
  // Len - effective length of S

char*    Long2Str (lint  X,
		   char* S);

boolean  String2Boolean (const char *S);
  // Return: "1" - true, "0" - false, else BooleanDontKnow

char*    StrTrimLeading (char* S);
  // Delete leading blanks

char*    StrTrimTrailing (char* S);
  // Delete trailing blanks

char*    StrTrim (char* S);
  // Delete leading and trailing blanks

boolean  StrIsLeft (const char* S,
		    const char* Left);

char*    StrDeleteBlanks (char* S);

void     StrReplace (char* Target,
		     uint Len,
		     const char* Source);
  // Replace Len first characters of Target by Source

char*    StrVarIndex (const char* VarName,
		      uint Index,
		      uint Len,
		      char* Res);
  // Return: VarName + Index




////////////////////////////////////// I/O //////////////////////////////////

void PrintLn ();

void PrintLines (uint LineNum);

void SkipLine (FILE* F);

void SkipLines (FILE* F,
		uint LineNum);

char SkipBlanks (FILE* F);
  // Skips blanks, tabs
  // Return: first non-blank character
  // Current point is before the character returned

boolean ReadLine (FILE* F, 
		  char* S, 
		  uint  Len);
  // false iff EOF
 
boolean ReadDouble (FILE* F, 
		    double &N);
  // Return: FALSE if '\n'
  // Output: N 
  // If '\n' then SkipLine (F)

boolean ReadFloat (FILE* F, 
		   float &N);
  // Invokes: ReadDouble

boolean ReadInt (FILE* F, 
		 int &N);
  // Invokes: ReadDouble 

boolean ReadUint (FILE* F, 
		  uint &N);
  // Invokes: ReadDouble 

boolean ReadString (FILE* F,
		    char* S,
		    uint Len);
  // String is delimited by blanks (or \n, \t, \r)
  // Return: true if ! StrEmpty (S)

boolean FileExists (const char* FName);

lint FileSize (FILE* F);

boolean FileEmpty (FILE* F);




///////////////////////////////// Mathematics ///////////////////////////////

extern const int  MININT;
extern const uint MAXUINT;


boolean Between (lint N,
		 lint L, 
		 lint U);
  // true if L <= N < U 

boolean BetweenEqual (lint N,
		      lint L, 
		      lint U);
  // true if L <= N <= U 

lint nint (double X);
  // Missing in math.h -??

lint lceil (double f);

lint lfloor (double f);

tcT inline T absolute (const T a) 
  { return ( (a>0) ? a : -a ); }
  // Requires: T is integer class

tcT inline T minimum (const T a, 
		      const T b)
  { return ( (a<b) ? a : b ); }

tcT inline T maximum (const T a, 
		      const T b)
  { return ( (a<b) ? b : a ); }

tcT inline boolean minimize (T &a, 
			     const T b)
  // Reqturn: true iff a is changed
  { if ( a>b ) {a=b; return true;} else return false; }

tcT inline boolean maximize (T &a, 
			     const T b)
  // Reqturn: true iff a is changed
  { if ( a<b ) {a=b; return true;} else return false; }

tcT inline int sgn (const T a)
  { return ( (a>0) ? +1 : -1 ); }

tcT inline int tsgn (const T a)
  { return ( (a>0) ? +1 : ( (a<0) ? -1 : 0 ) ); }

tcT inline int tcomp (const T a, 
		      const T b)
  { return ( (a<b) ? +1 : ( (a>b) ? -1 : 0 ) ); }

inline boolean Even (lint X)
  { return X % 2 == 0; }


boolean EqualFloat (double X, double Y);
     
boolean NullFloat (double X);

boolean GreaterEqualFloat (double X, double Y);

boolean LessEqualFloat (double X, double Y);

inline boolean GreaterFloat (double X, double Y)
  { return  ! LessEqualFloat (X, Y); }

inline boolean LessFloat (double X, double Y)
  { return  ! GreaterEqualFloat (X, Y); }

inline boolean Positive (double X) 
  { return  GreaterFloat (X, 0); }
  
inline boolean Negative (double X) 
  { return  LessFloat (X, 0); }
  
inline boolean BetweenFloat (double X,
			     double L,
			     double U)
  { return  GreaterEqualFloat (X, L) && LessFloat (X, U); }

inline boolean BetweenEqualFloat (double X,
				  double L,
				  double U)
  { return  GreaterEqualFloat (X, L) && LessEqualFloat (X, U); }


double Sqr (double X);
  // Return: X * X 



// Infinities, NaN
extern const double INF;
extern const double NAN;

boolean IsNanOrInf (double X);
  // Inf - positive or negative

boolean IsInf (double X);
  // Inf - positive or negative



// Random
double  randomR ();
  // Return: 0..1
 
uint    randomI (uint n);
  // Return: 0..n-1

boolean flipAtail ();

void    fixSeed (lint SeedVal);

double  RandomExponential (double Mean);




#endif