Добавил:
Upload
Опубликованный материал нарушает ваши авторские права? Сообщите нам.
Вуз:
Предмет:
Файл:
/*-------------------------------------------------------------------------------------*/
/* Библиотека VP/C++, mодуль SYST.H. Версия 1997.10_2009.08.14 */
/* Пинчук В.П. Запорожье, vpinchuk@zntu.edu.ua */
/* Печатать Courier New Cyr, Size = 10, Rihgt Margin = 89, Print Margin = 5 */
/*-------------------------------------------------------------------------------------*/
#ifndef _SYST_
#define _SYST_
#include <dos.h>
#include <stdio.h>
#include <stdlib.h>
#include <conio.h>
#include <time.h>
#include <math.h>
#include <string>
#include <fstream.h>
using namespace std;
#ifdef _STIMER_
double CPU_Frequency = 3000; // Тактовая частота по умолчанию, MГц
unsigned long STIME_1, STIME_2;
#endif
#define pi M_PI
#define ln(x) log(x)
#define lg(x) log10(x)
#define tg(x) tan(x)
#define arcsin(x) asin(x)
#define arccos(x) acos(x)
#define arctg(x) atan(x)
#define sh(x) sinh(x)
#define ch(x) cosh(x)
#define th(x) tanh(x)
#define pause getkey()
#define cls clrscr()
#define endline(f,x) endlin((f),(x),__FILE__)
typedef unsigned char byte;
typedef unsigned short word;
typedef unsigned int uint;
typedef unsigned long ulong;
typedef double (*funx)(double);
double INITDRAND = pi;
const ulong RAND_MAXL = 0x80000000;
clock_t START_TIME;
/*---------------------------- Прототипы функций и процедур ---------------------------*/
template <class TYPE>
inline TYPE abs(TYPE x); // абсолютная величина
template <class type>
int b_find(type* A, int n, const type& key);
// бинарный поиск в массиве А по ключу key
int arrang(int m, int n, int* p); // размещения по m элементов из массива p
char* binar(ulong x); // формирует строку - бинарный код значения x
// и возвращает указатель на нее
template <class TYPE>
void biread(FILE* f, TYPE& x); // чтение из бинарного файла
double bisect(funx F, double a, double b, double eps);
template <class TYPE>
void biwrite(FILE* f, TYPE& x); // запись в бинарный файл
ulong Cmb(int n, int r); // число сочетаний из n по r
template <class TYPE>
int cmp(int nx, int ny, TYPE* x, TYPE* y);
// лексикогр. сравнение двух массивов
template <class type>
inline type cub(type x); // cub(x) = x*x*x
double erfc(double x); // вычислить erfc(x)
void errhalt(int, char*); // обработка исключения
void errhalt(int, char*, FILE*); // обработка исключения с выводом сообщ. в файл
ulong fact(int n); // факториал от n
double factd(int n);
void endlin(FILE* f, char* label, char* file);
// вспомог. функция для endline(x)
void flushkey(); // очистить буфер клавиатуры
double frac(double x); // дробная часть х
double frand(); // случайное число из [0,1]
double frand(double a, double b); // случайное число из [a,b]
char getkey(); // получить код нажатой клавиши
int getline(istream& in, std::string& s); // прочитать строку из потока in
char getskey(); // буферизованый ввод символа с клав.
void gotox(int k); // установить курсор в позицию k тек. строки
template <class TYPE>
int hamdist(TYPE a, TYPE b); // расстояние Хэмминга для кодов a,b
double lanj(double x); // функция ланжевена
void linappr(int n, double* x, double* y, double& a0, double& a1);
// линейная аппроксимация данных
double log2(double x); // логарифм по основанию 2
template <class Type> // найти максимальный элемент
Type maxim(int, Type*);
template <class T>
inline T Max(const T& a, const T& b); // максим. из двух
ulong mcstimer(); // текущее значение mcs-таймера (микросекунды)
template <class T>
inline T Min(const T& a, const T& b); // миним. из двух
template <class Type> // найти минимальный элемент
Type minim(int, Type*);
template <class type> // наибольший общий делитель
type nod(type a, type b); // для целых типов
ulong numstr(ifstream& fin); // число строк в текстовом файле
double optima(funx f, double x, double eps); // Поиск минимума мет. Ньютона
int permut(int n, int* p); // генерация перестановок
int permut_rand(int n, int* p); // получить следующую перестановку
double polin(int n, double* a, double x);
// вычислить полином порядка n по схеме Горнера
void printr(char* S, FILE* f=stdout);
// вывод на экран строки (включ. кир.)
char* rdate(); // текущая дата в сокр. формате
void rewind(ifstream& f); // установить указатель потока в начало
void rewind(FILE* f); // установить указатель файла в начало
FILE* rfopen(char* fn); // открыть текстовый файл для чтения
int round(double x); // округлить х до целого
char* rtime(); // текущее время в сокр. формате
void runstimer(); // пуск микросекундного таймера
inline void runtimer(); // пуск таймера
void set_cpu_fr(); // установить значение CPU_Frequency
double simpson(double (*fun)(double), double a, double b, int N);
// вычисл. интеграла методом Симпсона
template <class type> // сортировка отрезка [i,k] массива p
void sortup(int i, int k, type* p); // по возрастающей
template <class type> // сортировка отрезка [i,k] массива p
void sortdown(int i, int k, type* p); // по убывающей
template <class type>
inline type sqr(type x); // sqr(x) = x*x
double stimer(); // текущее значение s-таймера (к-во
// тактов процессора в формате double)
int subsetnext(int n, int r, int* A);
// получить след. r-элементное подмножество из n-элементного множества А
template <class TYPE>
inline void swp(TYPE& a, TYPE& b); // парный обмен
void swp(char* s1, char* s2); // специальная реализация для строк вида char*
template <class TYPE>
void temprint(TYPE& A); // вывод на экран элементов структуры
// по итератору
float timer(); // текущее значение таймера
template <class TYPE>
int weight(TYPE x); // количество единичных битов в
// бинарном коде х
/*------------------------- Класс Spline: интерполяция сплайнами ----------------------*/
class Spline
{ int n;
double *x, *y, *M;
public:
Spline(int, double*, double*);
~Spline();
double operator()(double);
};
Spline::Spline(int N, double* xt, double* yt)
{ n=N;
x= new double[n]; y= new double[n]; M= new double[n];
int k;
for (k=0;k<n;k++) { x[k]=xt[k]; y[k]=yt[k]; }
double *L= new double[n], *R= new double[n], *S= new double[n];
double D,E,H,F,P;
D=x[1]-x[0]; E=(y[1]-y[0])/D;
L[0]=0; R[0]=0;
for (k=1;k<N-1;k++)
{ H=D; D=x[k+1]-x[k];
F=E; E=(y[k+1]-y[k])/D;
L[k]=D/(D+H);
R[k]=1.0-L[k];
S[k]=6.0*(E-F)/(H+D);
}
S[0]=0; S[N-1]=0;
for (k=1;k<N-1;k++)
{ P= 1.0/(R[k]*L[k-1]+2.0); L[k]=-L[k]*P;
S[k]=(S[k]-R[k]*S[k-1])*P;
}
M[N-1]=0; L[N-2]=S[N-2]; M[N-2]=L[N-2];
for (k=N-3;k>=0;k--) { L[k]=L[k]*L[k+1]+S[k];
M[k]=L[k];
}
delete[] L; delete[] R; delete[] S;
}
Spline::~Spline()
{ delete[] x; delete[] y; delete[] M;
}
double Spline::operator()(double t)
{ if (t<x[0])
{ printf("splfun: parameter t is below x[0]: t= %f x[0]=%f\n",t,x[0]);
return x[0];
}
if (t>x[n-1])
{ printf("splfun: parameter t is above x[n-1]: t= %f x[N-1]=%f\n",t,x[n-1]);
return x[n-1];
}
double D,F,H,P,R;
int i,j;
for (i=1;i<n;i++) if (t<=x[i]) break;
j= i-1;
D= x[i]-x[j];
H= t-x[j]; R= x[i]-t;
P= D*D/6.0;
F= (M[j]*R*R*R + M[i]*H*H*H)/(6.0*D);
return F+((y[j]-M[j]*P)*R+(y[i]-M[i]*P)*H)/D;
}
/*------------------------ Класс Linter: линейная интерполяция ------------------------*/
class Linter
{ int n;
double *x, *y;
public:
Linter(int, double*, double*);
~Linter();
double operator()(double);
};
Linter::Linter(int N, double* xt, double* yt)
{ n=N;
x= new double[n]; y= new double[n];
for (int k=0;k<n;k++) { x[k]=xt[k]; y[k]=yt[k]; }
}
Linter::~Linter()
{ delete[] x; delete[] y;
}
double Linter::operator()(double t)
{ if (t<x[0])
{ printf("Linter: parameter t is below x[0]: t= %f x[0]=%f\n",t,x[0]);
return x[0];
}
if (t>x[n-1])
{ printf("Linter: parameter t is above x[n-1]: t= %f x[N-1]=%f\n",t,x[n-1]);
return x[n-1];
}
int i;
for (i=0;i<n;i++) if (t<=x[i]) break;
i--;
return y[i]+(y[i+1]-y[i])/(x[i+1]-x[i])*(t-x[i]);
}
/*---------------------- Класс Randis: случайные числа по образцу ---------------------*/
class Randis
{ const int m;
double a,b;
int* f; // Интегральная ф-ция распределения. Нумерация интервалов с 1
public:
Randis(int M, int n, double* x);
~Randis() { delete[] f; }
double operator()();
};
Randis::Randis(int M, int n, double* x): m(M)
{ int i,j;
f= new int[m+1];
int* r= new int[m+1]; // Функция распределения
a=minim(n,x); b=maxim(n,x);
double dx=(b-a)/m;
for (j=0;j<=m;j++) r[j]=0;
for (i=0;i<n;i++) { j= (x[i]-a)/dx; if (j>=m) j=m-1;
r[j+1]++;
}
f[0]= 0.0;
for (j=1;j<=m;j++) f[j]= f[j-1]+r[j];
delete[] r;
}
double Randis::operator()()
{ int i;
double s= frand(0,f[m]);
for (i=1;i<=m;i++) if (s<=f[i]) break;
double Sf= (s-f[i-1])/(f[i]-f[i-1]) + i-1; // Лин. интерполяция, Sf = 0..m
return (Sf/m)*(b-a)+a; // Приведение к интервалу a..b
}
/***************************************************************************************/
/**************************** Реализация функций и процедур ****************************/
template <class TYPE>
inline TYPE abs(TYPE x)
{ if (x<0) return (TYPE)-x; else return x;
}
/*-------------------------------------------------------------------------------------*/
int arrang(int m, int n, int* p)
{ static int M=0;
M++; if (M==1) return M;
int i,j, q=0;
for (i=m-1;i>=0;i--)
{ for (j=i+1;j<n;j++) if (p[i]<p[j]) { swp(p[i],p[j]); q=1; break; }
if (j==n) { sortup(i,n-1,p); continue; }
sortup(i+1,n-1,p); break;
}
if (q==0) M=0;
return M;
}
/*-------------------------------------------------------------------------------------*/
template <class type>
int b_find(type* A, int n, const type& key)
{ int p=0,q=n-1,k;
while (q>=p) { k=p+(q-p+1)/2;
if (A[k]==key) return k;
if (A[k]<key) p=k+1;
else q=k-1;
}
return -1;
}
/*-------------------------------------------------------------------------------------*/
char* binar(ulong x)
{ static char B[33];
char i,s,q=0,j=0;
for (i=0;i<32;i++) { s= x & 0x80000000 ? '1' : '0' ;
if (s=='1') q=1;
if (q) B[j++]=s;
x<<=1;
}
if (j>0) B[j]=0;
else { B[0]='0'; B[1]=0; }
return B;
}
/*-------------------------------------------------------------------------------------*/
template <class TYPE>
void biread(FILE* f, TYPE& x)
{ fread(&x,sizeof(x),1,f);
}
/*-------------------------------------------------------------------------------------*/
double bisect(funx F, double a, double b, double eps)
{ double x;
while (b-a>eps) { x= (a+b)/2;
if (F(a)*F(x)<0) b=x;
else a=x;
}
x=(a+b)/2;
return x;
}
/*-------------------------------------------------------------------------------------*/
template <class TYPE>
void biwrite(FILE* f, TYPE& x)
{ fwrite(&x,sizeof(x),1,f);
}
/*-------------------------------------------------------------------------------------*/
ulong Cmb(int n, int r)
{ if (r>n) return 0;
if (r==0) return 1;
ulong C=n;
for (int k=1;k<r;k++) C=C*(n-k)/(k+1);
return C;
}
/*-------------------------------------------------------------------------------------*/
template <class TYPE>
int cmp(int nx, int ny, TYPE* x, TYPE* y)
{ int L= Min(nx,ny);
for (int i=0;i<L;i++)
{ if (x[i]>y[i]) return 1;
if (x[i]<y[i]) return -1; }
if (nx>ny) return 1;
if (nx<ny) return -1;
return 0;
}
/*-------------------------------------------------------------------------------------*/
template <class type>
inline type cub(type x)
{ return x*x*x;
}
/*-------------------------------------------------------------------------------------*/
void endlin(FILE* f, char* label, char* file)
{ fprintf(f,"%s, %s, %s, %s\n", label, rdate(), rtime(), file);
}
/*-------------------------------------------------------------------------------------*/
double erfc(double x)
{ const int N= 100;
const double p= 5;
int k;
if (x<p) { double t, h=x/N, S=1.0+exp(-x*x);
for (k=1;k<N ;k+=2) { t=k*h; S+=4.0*exp(-t*t); }
for (k=2;k<N-1;k+=2) { t=k*h; S+=2.0*exp(-t*t); }
S*=(h/3.0);
return 1-(2.0/sqrt(pi))*S;
}
else { double a= -0.5/(x*x), S= 1.0 + a;
for (k=2;k<=6;k++) { a= -a*(k+0.5)/(x*x); S+=a; }
return exp(-x*x)/(x*sqrt(pi))*S;
}
}
/*-------------------------------------------------------------------------------------*/
void errhalt(int q, char* mes)
{ if (q) { printr(mes); puts("\7\7"); pause;
exit(0);
}
}
/*-------------------------------------------------------------------------------------*/
void errhalt(int q, char* mes, FILE* f)
{ if (q) { printr(mes); printr(mes,f);
puts("\7\7");
exit(0); }
}
/*-------------------------------------------------------------------------------------*/
ulong fact(int N)
{ errhalt(N>12,"fact(N): N is over 12 !");
ulong P=N; int k;
if (N==0) return 1;
for (k=N-1; k>=2; k--) P*=k;
return P;
}
/*-------------------------------------------------------------------------------------*/
double factd(int N)
{ errhalt(N>170,"factd(N): N is over 170 !");
double P=N; int k;
if (N==0) return 1.0;
for (k=N-1; k>=2; k--) P*=k;
return P;
}
/*-------------------------------------------------------------------------------------*/
void flushkey()
{ if (kbhit()) getch();
}
/*-------------------------------------------------------------------------------------*/
double frac(double x)
{ static double p;
double f= modf(x,&p);
return f;
}
/*-------------------------------------------------------------------------------------*/
double frand()
{ return random(RAND_MAXL)/double(RAND_MAXL-1L);
}
/*-------------------------------------------------------------------------------------*/
double frand(double a, double b)
{ float x=random(RAND_MAXL)/double(RAND_MAXL-1L);
return a+x*(b-a);
}
/*-------------------------------------------------------------------------------------*/
char getkey()
{ flushkey();
int c=getch(); if (c==0) c=getch();
return (char)c;
}
/*-------------------------------------------------------------------------------------*/
int getline(istream& in, std::string& s)
{ char x; s=""; int q=0;
while(in.get(x)) { if (x=='\n') { q=1; break; }
s+=x; }
return q;
}
/*-------------------------------------------------------------------------------------*/
char getskey()
{ flushkey(); return (char)getche();
}
/*-------------------------------------------------------------------------------------*/
void gotox(int k)
{ gotoxy(k,wherey());
}
/*-------------------------------------------------------------------------------------*/
template <class TYPE>
int hamdist(TYPE a, TYPE b)
{ TYPE x= a^b;
int n=0;
while (x) { n++; x&=TYPE(x-1); }
return n;
}
/*-------------------------------------------------------------------------------------*/
double lanj(double x)
{ const int k= 13;
const double p= 2.0;
static double I= 1.0;
if (x<p) { int i;
double xx,z,zz;
xx=x*x;
z=xx/(2*k+1);
for (i=k;i>=2; i--) { if (i==2) xx=x;
zz=xx/((2*i-1)+z); z=zz;
}
return zz;
}
else return I/th(x)-I/x;
}
/*-------------------------------------------------------------------------------------*/
void linappr(int N, double* x, double* y, double& a0, double& a1)
{ double D, g01=0, g11=0, b0=0, b1=0;
int i;
for (i=0;i<N;i++) { g01+=x[i];
g11+=sqr(x[i]);
b0 +=y[i];
b1 +=x[i]*y[i]; }
D=N*g11-g01*g01;
a0=(b0*g11-b1*g01)/D;
a1=(N*b1-g01*b0)/D;
}
/*-------------------------------------------------------------------------------------*/
double log2(double x)
{ return M_LOG2E*ln(x);
}
/*-------------------------------------------------------------------------------------*/
template <class T>
inline T Min(const T& a, const T& b)
{ return a<b? a : b;
}
/*-------------------------------------------------------------------------------------*/
template <class Type> // найти максимальный элемент
Type maxim(int n, Type* A)
{ Type max= A[0];
for (int i=0;i<n;i++) if (A[i]>max) max=A[i];
return max;
}
/*-------------------------------------------------------------------------------------*/
template <class T>
inline T Max(const T& a, const T& b)
{ return a<b? b : a;
}
/*-------------------------------------------------------------------------------------*/
template <class Type> // найти минимальный элемент
Type minim(int n, Type* A)
{ Type min= A[0];
for (int i=0;i<n;i++) if (A[i]<min) min=A[i];
return min;
}
/*-------------------------------------------------------------------------------------*/
template <class type>
type nod(type a, type b)
{ type r=a%b; while (r!=0) { a=b; b=r; r=a%b; }
return b;
}
/*-------------------------------------------------------------------------------------*/
ulong numstr(ifstream& fin)
{ ulong n=0;
while(!fin.eof()) if ((char)fin.get()=='\n') n++;
rewind(fin);
return n;
}
/*-------------------------------------------------------------------------------------*/
double optima(funx f, double x, double eps)
{ double h,y;
h=eps/5;
for (;;) { y= x-(h/2)*(f(x+h)-f(x-h))/(f(x+h)+f(x-h)-2*f(x));
if (abs(y-x)<eps) break;
x=y;
}
return y;
}
/*-------------------------------------------------------------------------------------*/
int permut(int n, int* p)
{ static int M=0;
M++; if (M==1) return M;
int i,im,j,m;
for (i=n-2;i>=0;i--)
{ if (p[i]<p[i+1]) { m=p[i+1]; im=i+1;
for (j=i+1;j<n;j++)
if (p[j]>p[i] && p[j]<m) { m=p[j]; im=j; }
break;
}
}
if (i<0) return 0;
swp(p[i],p[im]);
sortup(i+1,n-1,p);
return M;
}
/*-------------------------------------------------------------------------------------*/
int permut_rand(int n, int* p)
{ static int M=0; M++;
int s;
while (n>1)
{ s= random(n-1);
swp(p[s],p[n-1]);
n--;
}
return M;
}
/*-------------------------------------------------------------------------------------*/
double polin(int n, double* a, double x)
{ double R= a[n];
for (int k=n-1;k>=0;k--) R=R*x+a[k];
return R;
}
/*-------------------------------------------------------------------------------------*/
void printr(char* S, FILE* f) // Требуется замена алгоритма на
{ char x, buf[128]; // табличный
int i, L=strlen(S);
for (i=0;i<L;i++) { x=0;
if (S[i]>=(char)0xF0) x=0x10;
else if (S[i]>=(char)0xC0) x=0x40;
buf[i]=(char)(S[i]-x);
}
for (i=0;i<L;i++) putc(buf[i],f);
}
/*-------------------------------------------------------------------------------------*/
char* rdate()
{ static char sd[11];
static date dat; getdate(&dat);
sprintf(sd,"%02d.%02d.%4d", dat.da_day, dat.da_mon, dat.da_year);
return sd;
}
/*-------------------------------------------------------------------------------------*/
void rewind(ifstream& f)
{ f.seekg(0); f.clear(0);
}
/*-------------------------------------------------------------------------------------*/
void rewind(FILE* f)
{ fseek(f,0,0);
}
/*-------------------------------------------------------------------------------------*/
FILE* rfopen(char* fn)
{ FILE* f= fopen(fn,"r");
char mes[120];
strcpy(mes,"rfopen(char*): File \"");
strcat(mes,fn);
strcat(mes,"\" could not found!");
errhalt(f==0,mes);
return f;
}
/*-------------------------------------------------------------------------------------*/
int round(double x)
{ return (int)floor(x+0.5);
}
/*-------------------------------------------------------------------------------------*/
char* rtime()
{ static char st[6];
static struct time t; gettime(&t);
sprintf(st,"%02d:%02d", t.ti_hour, t.ti_min);
return st;
}
/*-------------------------------------------------------------------------------------*/
#ifdef _STIMER_
void runstimer()
{ unsigned long t1,t2;
asm { DB 0Fh, 31h
mov t1, EDX
mov t2, EAX
}
STIME_1=t1; STIME_2=t2;
}
#endif
/*-------------------------------------------------------------------------------------*/
inline void runtimer()
{ START_TIME=clock();
}
/*-------------------------------------------------------------------------------------*/
double simpson(double (*fun)(double), double a, double b, int N)
{ int k;
double h=(b-a)/N, S=fun(a)+fun(b);
for (k=1;k<N ;k+=2) S+=4.0*fun(a+k*h);
for (k=2;k<N-1;k+=2) S+=2.0*fun(a+k*h);
return (h/3.0)*S;
}
/*-------------------------------------------------------------------------------------*/
#ifdef _STIMER_
unsigned long mcstimer()
{ static long double P= pow(2,32);
unsigned long t1,t2;
asm { DB 0Fh, 31h
mov t1, EDX
mov t2, EAX
}
long double x= STIME_1*P+STIME_2,
y= t1*P+t2;
return (unsigned long)((y-x)/CPU_Frequency);
}
/*-------------------------------------------------------------------------------------*/
void set_cpu_fr()
{ double t,st;
runtimer(); runstimer();
while (timer()<=10.0);
st=stimer(); t=timer();
CPU_Frequency=st/t/1e6;
}
/*-------------------------------------------------------------------------------------*/
double stimer()
{ static long double P= pow(2,32);
unsigned long t1,t2;
asm { DB 0Fh, 31h
mov t1, EDX
mov t2, EAX
}
long double x= STIME_1*P+STIME_2,
y= t1*P+t2;
return y-x;
}
#endif
/*-------------------------------------------------------------------------------------*/
template <class type>
void sortdown(int i, int k, type* p)
{ int j,q;
do { q=0; for (j=i;j<k;j++) if (p[j]<p[j+1]) { swp(p[j],p[j+1]); q=1; } }
while (q);
}
/*-------------------------------------------------------------------------------------*/
template <class type>
void sortup(int i, int k, type* p)
{ int j,q;
do { q=0; for (j=i;j<k;j++) if (p[j]>p[j+1]) { swp(p[j],p[j+1]); q=1; } }
while (q);
}
/*-------------------------------------------------------------------------------------*/
template <class type>
inline type sqr(type x)
{ return x*x;
}
/*-------------------------------------------------------------------------------------*/
int subsetnext(int n, int r, int* A)
{ int i,k,q=1;
static m; m++;
if (m==1) { for (i=0;i<r;i++) A[i]=i;
return m;
}
k=r-1;
while (q) { A[k]++;
if (A[k]+r-k-1<n) q=0;
else k--; if (k<0) { m=0; break; }
for (i=k+1;i<r;i++) A[i]=A[i-1]+1;
}
return m;
}
/*-------------------------------------------------------------------------------------*/
template <class TYPE>
inline void swp(TYPE& a, TYPE& b)
{ TYPE R=a; a=b; b=R;
}
/*-------------------------------------------------------------------------------------*/
void swp(char* s1, char* s2)
{ int len1= strlen(s1),
len2= strlen(s2);
int len= len1>len2? len1 : len2;
char* R= new char[len+1];
strcpy(R,s1);
strcpy(s1,s2);
strcpy(s2,R);
}
/*-------------------------------------------------------------------------------------*/
template <class TYPE>
void temprint(TYPE& A)
{ TYPE::iterator i;
cout << "{ ";
for (i=A.begin();i<A.end();i++) cout << *i << " ";
cout << "} ";
}
/*-------------------------------------------------------------------------------------*/
float timer()
{ static clock_t CURRENT_TIME;
CURRENT_TIME= clock();
return (CURRENT_TIME-START_TIME)/CLK_TCK;
}
/*-------------------------------------------------------------------------------------*/
template <class TYPE>
int weight(TYPE x)
{ int n=0;
while (x) { n++; x&=(TYPE)(x-1); }
return n;
}
/*-------------------------------------------------------------------------------------*/
#endif