Code:
// basic.h
// Purpose: Basic operations
// Language: C++
#ifndef basic_h
#define basic_h
#include <stdlib.h>
#include <stdio.h>
#include <float.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