void WebcamCapture::run()
{
Mat orig;
TimerCreate();
while (isRunning())
{
TimerUpdate();
vector<unsigned char> m_status;
vector<float> m_error;
vector<Point2f> trackedPts;
if (vc->isOpened())
{
if (vc->read(orig))
dh_out->WriteFrame(orig);
}
else
{
this->exit(-1);
}
TimerElapsed();
}
vc->release();
this->exit(0);
}
void WebcamCapture::run()
{
Mat orig;
// макрос для создания таймера
TimerCreate();
while (isRunning())
{
TimerUpdate();
vector<unsigned char> m_status;
vector<float> m_error;
vector<Point2f> trackedPts;
// если камера инициализирована и можно считать
// изображение, то добавляем в очередь на обработку
if (mVideoCapture->isOpened())
{
if (mVideoCapture->read(orig))
mDataHandler_out->Write(orig);
}
else
{
this->exit(-1);
}
TimerElapsed();
}
// освобождение ресурсов камеры
mVideoCapture->release();
this->exit(0);
}
/***********************
** DoEmFloatIteration **
************************
** Perform an iteration of the emulated floating-point
** benchmark. Note that "an iteration" can involve multiple
** loops through the benchmark.
*/
ulong DoEmFloatIteration(InternalFPF *abase,
InternalFPF *bbase,
InternalFPF *cbase,
ulong arraysize, ulong loops, double *wat_time)
{
ulong elapsed; /* For the stopwatch */
static uchar jtable[16] = {0,0,0,0,1,1,1,1,2,2,2,2,2,3,3,3};
ulong i;
/*
** Begin timing
*/
elapsed=StartStopwatch();
TimerOn();
/*
** Each pass through the array performs operations in
** the followingratios:
** 4 adds, 4 subtracts, 5 multiplies, 3 divides
** (adds and subtracts being nearly the same operation)
*/
while(loops--)
{
for(i=0;i<arraysize;i++)
switch(jtable[i % 16])
{
case 0: /* Add */
AddSubInternalFPF(0,abase+i,
bbase+i,
cbase+i);
break;
case 1: /* Subtract */
AddSubInternalFPF(1,abase+i,
bbase+i,
cbase+i);
break;
case 2: /* Multiply */
MultiplyInternalFPF(abase+i,
bbase+i,
cbase+i);
break;
case 3: /* Divide */
DivideInternalFPF(abase+i,
bbase+i,
cbase+i);
break;
}
}
TimerOff();
elapsed = StopStopwatch(elapsed);
if( wat_time ) {
*wat_time = TimerElapsed();
}
return(elapsed);
}
void ProcessingThread::run()
{
Mat orig, previmg, output, mask;
vector<Point2f> prev_pts, orig_pts;
vector<uchar> m_status;
Mat m_error;
TimerCreate();
while (isRunning())
{
while (dh_in->ReadFrame(orig))
{
TimerUpdate();
OpticalFlowHandle(previmg, orig, prev_pts, orig_pts);
TimerElapsed();
}
yieldCurrentThread();
}
}
void main()
{
#ifdef ROPT
register double s,u,v,w,x;
#else
double s,u,v,w,x;
#endif
long loops, NLimit;
register long i, m, n;
printf("\n");
printf(" FLOPS C Program (Double Precision), V2.0 18 Dec 1992\n\n");
/****************************/
loops = 15625; /* Initial number of loops. */
/* DO NOT CHANGE! */
/****************************/
/****************************************************/
/* Set Variable Values. */
/* T[1] references all timing results relative to */
/* one million loops. */
/* */
/* The program will execute from 31250 to 128000000 */
/* loops based on a runtime of Module 1 of at least */
/* TLimit = 3.0 seconds. That is, a runtime of 3 */
/* seconds for Module 1 is used to determine the */
/* number of loops to execute. */
/* */
/* No more than NLimit = 128000000 loops are allowed*/
/****************************************************/
T[1] = 1.0E+06/(double)loops;
TLimit = 3.0;
NLimit = 128000000;
piref = 3.14159265358979324;
one = 1.0;
two = 2.0;
three = 3.0;
four = 4.0;
five = 5.0;
scale = one;
printf(" Module Error RunTime MFLOPS\n");
printf(" (usec)\n");
/*************************/
/* Initialize the timer. */
/*************************/
/*******************************************************/
/* Module 1. Calculate integral of df(x)/f(x) defined */
/* below. Result is ln(f(1)). There are 14 */
/* double precision operations per loop */
/* ( 7 +, 0 -, 6 *, 1 / ) that are included */
/* in the timing. */
/* 50.0% +, 00.0% -, 42.9% *, and 07.1% / */
/*******************************************************/
n = loops;
sa = 0.0;
while ( sa < TLimit )
{
n = 2 * n;
x = one / (double)n; /*********************/
s = 0.0; /* Loop 1. */
v = 0.0; /*********************/
w = one;
TimerOn();
for( i = 1 ; i <= n-1 ; i++ )
{
v = v + w;
u = v * x;
s = s + (D1+u*(D2+u*D3))/(w+u*(D1+u*(E2+u*E3)));
}
TimerOff();
sa = TimerElapsed();
if ( n == NLimit ) break;
/* printf(" %10ld %12.5lf\n",n,sa); */
}
scale = 1.0E+06 / (double)n;
T[1] = scale;
/****************************************/
/* Estimate nulltime ('for' loop time). */
/****************************************/
TimerOn();
for( i = 1 ; i <= n-1 ; i++ )
{
}
TimerOff();
nulltime = T[1] * TimerElapsed();
if ( nulltime < 0.0 ) nulltime = 0.0;
T[2] = T[1] * sa - nulltime;
sa = (D1+D2+D3)/(one+D1+E2+E3);
sb = D1;
T[3] = T[2] / 14.0; /*********************/
sa = x * ( sa + sb + two * s ) / two; /* Module 1 Results. */
sb = one / sa; /*********************/
n = (long)( (double)( 40000 * (long)sb ) / scale );
sc = sb - 25.2;
T[4] = one / T[3];
/********************/
/* DO NOT REMOVE */
/* THIS PRINTOUT! */
/********************/
printf(" 1 %13.4le %10.4lf %10.4lf\n",sc,T[2],T[4]);
m = n;
/*******************************************************/
/* Module 2. Calculate value of PI from Taylor Series */
/* expansion of atan(1.0). There are 7 */
/* double precision operations per loop */
/* ( 3 +, 2 -, 1 *, 1 / ) that are included */
/* in the timing. */
/* 42.9% +, 28.6% -, 14.3% *, and 14.3% / */
/*******************************************************/
s = -five; /********************/
sa = -one; /* Loop 2. */
/********************/
TimerOn();
for ( i = 1 ; i <= m ; i++ )
{
s = -s;
sa = sa + s;
}
TimerOff();
T[5] = T[1] * TimerElapsed();
Report( "flops(1)", TimerElapsed() );
if ( T[5] < 0.0 ) T[5] = 0.0;
sc = (double)m;
u = sa; /*********************/
v = 0.0; /* Loop 3. */
w = 0.0; /*********************/
x = 0.0;
TimerOn();
for ( i = 1 ; i <= m ; i++)
{
s = -s;
sa = sa + s;
u = u + two;
x = x +(s - u);
v = v - s * u;
w = w + s / u;
}
TimerOff();
T[6] = T[1] * TimerElapsed();
Report( "flops(2)", TimerElapsed() );
T[7] = ( T[6] - T[5] ) / 7.0; /*********************/
m = (long)( sa * x / sc ); /* PI Results */
sa = four * w / five; /*********************/
sb = sa + five / v;
sc = 31.25;
piprg = sb - sc / (v * v * v);
pierr = piprg - piref;
T[8] = one / T[7];
/*********************/
/* DO NOT REMOVE */
/* THIS PRINTOUT! */
/*********************/
printf(" 2 %13.4le %10.4lf %10.4lf\n",pierr,T[6]-T[5],T[8]);
/*******************************************************/
/* Module 3. Calculate integral of sin(x) from 0.0 to */
/* PI/3.0 using Trapazoidal Method. Result */
/* is 0.5. There are 17 double precision */
/* operations per loop (6 +, 2 -, 9 *, 0 /) */
/* included in the timing. */
/* 35.3% +, 11.8% -, 52.9% *, and 00.0% / */
/*******************************************************/
x = piref / ( three * (double)m ); /*********************/
s = 0.0; /* Loop 4. */
v = 0.0; /*********************/
TimerOn();
for( i = 1 ; i <= m-1 ; i++ )
{
v = v + one;
u = v * x;
w = u * u;
s = s + u * ((((((A6*w-A5)*w+A4)*w-A3)*w+A2)*w+A1)*w+one);
}
TimerOff();
T[9] = T[1] * TimerElapsed() - nulltime;
Report( "flops(3)", TimerElapsed() );
u = piref / three;
w = u * u;
sa = u * ((((((A6*w-A5)*w+A4)*w-A3)*w+A2)*w+A1)*w+one);
T[10] = T[9] / 17.0; /*********************/
sa = x * ( sa + two * s ) / two; /* sin(x) Results. */
sb = 0.5; /*********************/
sc = sa - sb;
T[11] = one / T[10];
/*********************/
/* DO NOT REMOVE */
/* THIS PRINTOUT! */
/*********************/
printf(" 3 %13.4le %10.4lf %10.4lf\n",sc,T[9],T[11]);
/************************************************************/
/* Module 4. Calculate Integral of cos(x) from 0.0 to PI/3 */
/* using the Trapazoidal Method. Result is */
/* sin(PI/3). There are 15 double precision */
/* operations per loop (7 +, 0 -, 8 *, and 0 / ) */
/* included in the timing. */
/* 50.0% +, 00.0% -, 50.0% *, 00.0% / */
/************************************************************/
A3 = -A3;
A5 = -A5;
x = piref / ( three * (double)m ); /*********************/
s = 0.0; /* Loop 5. */
v = 0.0; /*********************/
TimerOn();
for( i = 1 ; i <= m-1 ; i++ )
{
u = (double)i * x;
w = u * u;
s = s + w*(w*(w*(w*(w*(B6*w+B5)+B4)+B3)+B2)+B1)+one;
}
TimerOff();
T[12] = T[1] * TimerElapsed() - nulltime;
Report( "flops(4)", TimerElapsed() );
u = piref / three;
w = u * u;
sa = w*(w*(w*(w*(w*(B6*w+B5)+B4)+B3)+B2)+B1)+one;
T[13] = T[12] / 15.0; /*******************/
sa = x * ( sa + one + two * s ) / two; /* Module 4 Result */
u = piref / three; /*******************/
w = u * u;
sb = u * ((((((A6*w+A5)*w+A4)*w+A3)*w+A2)*w+A1)*w+A0);
sc = sa - sb;
T[14] = one / T[13];
/*********************/
/* DO NOT REMOVE */
/* THIS PRINTOUT! */
/*********************/
printf(" 4 %13.4le %10.4lf %10.4lf\n",sc,T[12],T[14]);
/************************************************************/
/* Module 5. Calculate Integral of tan(x) from 0.0 to PI/3 */
/* using the Trapazoidal Method. Result is */
/* ln(cos(PI/3)). There are 29 double precision */
/* operations per loop (13 +, 0 -, 15 *, and 1 /)*/
/* included in the timing. */
/* 46.7% +, 00.0% -, 50.0% *, and 03.3% / */
/************************************************************/
x = piref / ( three * (double)m ); /*********************/
s = 0.0; /* Loop 6. */
v = 0.0; /*********************/
TimerOn();
for( i = 1 ; i <= m-1 ; i++ )
{
u = (double)i * x;
w = u * u;
v = u * ((((((A6*w+A5)*w+A4)*w+A3)*w+A2)*w+A1)*w+one);
s = s + v / (w*(w*(w*(w*(w*(B6*w+B5)+B4)+B3)+B2)+B1)+one);
}
TimerOff();
T[15] = T[1] * TimerElapsed() - nulltime;
Report( "flops(5)", TimerElapsed() );
u = piref / three;
w = u * u;
sa = u*((((((A6*w+A5)*w+A4)*w+A3)*w+A2)*w+A1)*w+one);
sb = w*(w*(w*(w*(w*(B6*w+B5)+B4)+B3)+B2)+B1)+one;
sa = sa / sb;
T[16] = T[15] / 29.0; /*******************/
sa = x * ( sa + two * s ) / two; /* Module 5 Result */
sb = 0.6931471805599453; /*******************/
sc = sa - sb;
T[17] = one / T[16];
/*********************/
/* DO NOT REMOVE */
/* THIS PRINTOUT! */
/*********************/
printf(" 5 %13.4le %10.4lf %10.4lf\n",sc,T[15],T[17]);
/************************************************************/
/* Module 6. Calculate Integral of sin(x)*cos(x) from 0.0 */
/* to PI/4 using the Trapazoidal Method. Result */
/* is sin(PI/4)^2. There are 29 double precision */
/* operations per loop (13 +, 0 -, 16 *, and 0 /)*/
/* included in the timing. */
/* 46.7% +, 00.0% -, 53.3% *, and 00.0% / */
/************************************************************/
x = piref / ( four * (double)m ); /*********************/
s = 0.0; /* Loop 7. */
v = 0.0; /*********************/
TimerOn();
for( i = 1 ; i <= m-1 ; i++ )
{
u = (double)i * x;
w = u * u;
v = u * ((((((A6*w+A5)*w+A4)*w+A3)*w+A2)*w+A1)*w+one);
s = s + v*(w*(w*(w*(w*(w*(B6*w+B5)+B4)+B3)+B2)+B1)+one);
}
TimerOff();
T[18] = T[1] * TimerElapsed() - nulltime;
Report( "flops(6)", TimerElapsed() );
u = piref / four;
w = u * u;
sa = u*((((((A6*w+A5)*w+A4)*w+A3)*w+A2)*w+A1)*w+one);
sb = w*(w*(w*(w*(w*(B6*w+B5)+B4)+B3)+B2)+B1)+one;
sa = sa * sb;
T[19] = T[18] / 29.0; /*******************/
sa = x * ( sa + two * s ) / two; /* Module 6 Result */
sb = 0.25; /*******************/
sc = sa - sb;
T[20] = one / T[19];
/*********************/
/* DO NOT REMOVE */
/* THIS PRINTOUT! */
/*********************/
printf(" 6 %13.4le %10.4lf %10.4lf\n",sc,T[18],T[20]);
/*******************************************************/
/* Module 7. Calculate value of the definite integral */
/* from 0 to sa of 1/(x+1), x/(x*x+1), and */
/* x*x/(x*x*x+1) using the Trapizoidal Rule.*/
/* There are 12 double precision operations */
/* per loop ( 3 +, 3 -, 3 *, and 3 / ) that */
/* are included in the timing. */
/* 25.0% +, 25.0% -, 25.0% *, and 25.0% / */
/*******************************************************/
/*********************/
s = 0.0; /* Loop 8. */
w = one; /*********************/
sa = 102.3321513995275;
v = sa / (double)m;
TimerOn();
for ( i = 1 ; i <= m-1 ; i++)
{
x = (double)i * v;
u = x * x;
s = s - w / ( x + w ) - x / ( u + w ) - u / ( x * u + w );
}
TimerOff();
T[21] = T[1] * TimerElapsed() - nulltime;
Report( "flops(7)", TimerElapsed() );
/*********************/
/* Module 7 Results */
/*********************/
T[22] = T[21] / 12.0;
x = sa;
u = x * x;
sa = -w - w / ( x + w ) - x / ( u + w ) - u / ( x * u + w );
sa = 18.0 * v * (sa + two * s );
m = -2000 * (long)sa;
m = (long)( (double)m / scale );
sc = sa + 500.2;
T[23] = one / T[22];
/********************/
/* DO NOT REMOVE */
/* THIS PRINTOUT! */
/********************/
printf(" 7 %13.4le %10.4lf %10.4lf\n",sc,T[21],T[23]);
/************************************************************/
/* Module 8. Calculate Integral of sin(x)*cos(x)*cos(x) */
/* from 0 to PI/3 using the Trapazoidal Method. */
/* Result is (1-cos(PI/3)^3)/3. There are 30 */
/* double precision operations per loop included */
/* in the timing: */
/* 13 +, 0 -, 17 * 0 / */
/* 46.7% +, 00.0% -, 53.3% *, and 00.0% / */
/************************************************************/
x = piref / ( three * (double)m ); /*********************/
s = 0.0; /* Loop 9. */
v = 0.0; /*********************/
TimerOn();
for( i = 1 ; i <= m-1 ; i++ )
{
u = (double)i * x;
w = u * u;
v = w*(w*(w*(w*(w*(B6*w+B5)+B4)+B3)+B2)+B1)+one;
s = s + v*v*u*((((((A6*w+A5)*w+A4)*w+A3)*w+A2)*w+A1)*w+one);
}
TimerOff();
T[24] = T[1] * TimerElapsed() - nulltime;
Report( "flops(8)", TimerElapsed() );
u = piref / three;
w = u * u;
sa = u*((((((A6*w+A5)*w+A4)*w+A3)*w+A2)*w+A1)*w+one);
sb = w*(w*(w*(w*(w*(B6*w+B5)+B4)+B3)+B2)+B1)+one;
sa = sa * sb * sb;
T[25] = T[24] / 30.0; /*******************/
sa = x * ( sa + two * s ) / two; /* Module 8 Result */
sb = 0.29166666666666667; /*******************/
sc = sa - sb;
T[26] = one / T[25];
/*********************/
/* DO NOT REMOVE */
/* THIS PRINTOUT! */
/*********************/
printf(" 8 %13.4le %10.4lf %10.4lf\n",sc,T[24],T[26]);
/**************************************************/
/* MFLOPS(1) output. This is the same weighting */
/* used for all previous versions of the flops.c */
/* program. Includes Modules 2 and 3 only. */
/**************************************************/
T[27] = ( five * (T[6] - T[5]) + T[9] ) / 52.0;
T[28] = one / T[27];
/**************************************************/
/* MFLOPS(2) output. This output does not include */
/* Module 2, but it still does 9.2% FDIV's. */
/**************************************************/
T[29] = T[2] + T[9] + T[12] + T[15] + T[18];
T[29] = (T[29] + four * T[21]) / 152.0;
T[30] = one / T[29];
/**************************************************/
/* MFLOPS(3) output. This output does not include */
/* Module 2, but it still does 3.4% FDIV's. */
/**************************************************/
T[31] = T[2] + T[9] + T[12] + T[15] + T[18];
T[31] = (T[31] + T[21] + T[24]) / 146.0;
T[32] = one / T[31];
/**************************************************/
/* MFLOPS(4) output. This output does not include */
/* Module 2, and it does NO FDIV's. */
/**************************************************/
T[33] = (T[9] + T[12] + T[18] + T[24]) / 91.0;
T[34] = one / T[33];
printf("\n");
printf(" Iterations = %10ld\n",m);
printf(" NullTime (usec) = %10.4lf\n",nulltime);
printf(" MFLOPS(1) = %10.4lf\n",T[28]);
printf(" MFLOPS(2) = %10.4lf\n",T[30]);
printf(" MFLOPS(3) = %10.4lf\n",T[32]);
printf(" MFLOPS(4) = %10.4lf\n\n",T[34]);
exit( EXIT_SUCCESS );
}
void main ()
{
static REAL aa[200][200],a[200][201],b[200],x[200];
REAL cray,ops,total,norma,normx;
REAL resid,residn,eps;
REAL epslon(),kf;
#if 0
double t1;
double tm;
#endif
double tm2;
double dtime();
static int ipvt[200],n,i,ntimes,info,lda,ldaa,kflops;
static user_timer second_timer;
lda = 201;
ldaa = 200;
cray = .056;
n = 100;
printf(ROLLING); printf(PREC);
printf("Precision Linpack\n\n");
ops = (2.0e0*(n*n*n))/3.0 + 2.0*(n*n);
matgen(a,lda,n,b,&norma);
TimerOn();
dgefa(a,lda,n,ipvt,&info);
TimerOff();
st[0][0] = TimerElapsed();
Report( "clinpack(dgefa#1)", st[0][0] );
TimerOn();
dgesl(a,lda,n,ipvt,b,0);
TimerOff();
st[1][0] = TimerElapsed();
Report( "clinpack(dgesl#1)", st[1][0] );
total = st[0][0] + st[1][0];
/* compute a residual to verify results. */
for (i = 0; i < n; i++)
{
x[i] = b[i];
}
matgen(a,lda,n,b,&norma);
for (i = 0; i < n; i++)
{
b[i] = -b[i];
}
dmxpy(n,b,n,lda,x,a);
resid = 0.0;
normx = 0.0;
for (i = 0; i < n; i++)
{
resid = (resid > fabs((double)b[i]))
? resid : fabs((double)b[i]);
normx = (normx > fabs((double)x[i]))
? normx : fabs((double)x[i]);
}
eps = epslon((REAL)ONE);
residn = resid/( n*norma*normx*eps );
printf(" norm. resid resid machep");
printf(" x[0]-1 x[n-1]-1\n");
printf("%8.1f %16.8e%16.8e%16.8e%16.8e\n",
(double)residn, (double)resid, (double)eps,
(double)x[0]-1, (double)x[n-1]-1);
printf(" times are reported for matrices of order %5d\n",n);
printf(" dgefa dgesl total kflops unit");
printf(" ratio\n");
st[2][0] = total;
st[3][0] = ops/(1.0e3*total);
st[4][0] = 2.0e3/st[3][0];
st[5][0] = total/cray;
printf(" times for array with leading dimension of%5d\n",lda);
print_time(0);
matgen(a,lda,n,b,&norma);
TimerOn();
dgefa(a,lda,n,ipvt,&info);
TimerOff();
st[0][1] = TimerElapsed();
Report( "clinpack(dgefa#2)", st[0][1] );
TimerOn();
dgesl(a,lda,n,ipvt,b,0);
TimerOff();
st[1][1] = TimerElapsed();
Report( "clinpack(dgesl#2)", st[1][1] );
total = st[0][1] + st[1][1];
st[2][1] = total;
st[3][1] = ops/(1.0e3*total);
st[4][1] = 2.0e3/st[3][1];
st[5][1] = total/cray;
matgen(a,lda,n,b,&norma);
TimerOn();
dgefa(a,lda,n,ipvt,&info);
TimerOff();
st[0][2] = TimerElapsed();
Report( "clinpack(dgefa#3)", st[0][2] );
TimerOn();
dgesl(a,lda,n,ipvt,b,0);
TimerOff();
st[1][2] = TimerElapsed();
Report( "clinpack(dgesl#3)", st[1][2] );
total = st[0][2] + st[1][2];
st[2][2] = total;
st[3][2] = ops/(1.0e3*total);
st[4][2] = 2.0e3/st[3][2];
st[5][2] = total/cray;
ntimes = NTIMES;
tm2 = 0.0;
UserTimerOn( &second_timer );
for (i = 0; i < ntimes; i++) {
TimerOn();
matgen(a,lda,n,b,&norma);
TimerOff();
tm2 = tm2 + TimerElapsed();
dgefa(a,lda,n,ipvt,&info);
}
UserTimerOff( &second_timer );
st[0][3] = ( UserTimerElapsed( &second_timer ) - tm2)/ntimes;
Report( "clinpack(dgefa#4)", st[0][3] );
TimerOn();
for (i = 0; i < ntimes; i++) {
dgesl(a,lda,n,ipvt,b,0);
}
TimerOff();
st[1][3] = TimerElapsed()/ntimes;
Report( "clinpack(dgesl#4)", st[1][3] );
total = st[0][3] + st[1][3];
st[2][3] = total;
st[3][3] = ops/(1.0e3*total);
st[4][3] = 2.0e3/st[3][3];
st[5][3] = total/cray;
print_time(1);
print_time(2);
print_time(3);
matgen(aa,ldaa,n,b,&norma);
TimerOn();
dgefa(aa,ldaa,n,ipvt,&info);
TimerOff();
st[0][4] = TimerElapsed();
Report( "clinpack(dgefa#5)", st[0][4] );
TimerOn();
dgesl(aa,ldaa,n,ipvt,b,0);
TimerOff();
st[1][4] = TimerElapsed();
Report( "clinpack(dgesl#5)", st[1][4] );
total = st[0][4] + st[1][4];
st[2][4] = total;
st[3][4] = ops/(1.0e3*total);
st[4][4] = 2.0e3/st[3][4];
st[5][4] = total/cray;
matgen(aa,ldaa,n,b,&norma);
TimerOn();
dgefa(aa,ldaa,n,ipvt,&info);
TimerOff();
st[0][5] = TimerElapsed();
Report( "clinpack(dgefa#6)", st[0][5] );
TimerOn();
dgesl(aa,ldaa,n,ipvt,b,0);
TimerOff();
st[1][5] = TimerElapsed();
Report( "clinpack(dgesl#6)", st[1][5] );
total = st[0][5] + st[1][5];
st[2][5] = total;
st[3][5] = ops/(1.0e3*total);
st[4][5] = 2.0e3/st[3][5];
st[5][5] = total/cray;
matgen(aa,ldaa,n,b,&norma);
TimerOn();
dgefa(aa,ldaa,n,ipvt,&info);
TimerOff();
st[0][6] = TimerElapsed();
Report( "clinpack(dgefa#7)", st[0][6] );
TimerOn();
dgesl(aa,ldaa,n,ipvt,b,0);
TimerOff();
st[1][6] = TimerElapsed();
Report( "clinpack(dgesl#7)", st[1][6] );
total = st[0][6] + st[1][6];
st[2][6] = total;
st[3][6] = ops/(1.0e3*total);
st[4][6] = 2.0e3/st[3][6];
st[5][6] = total/cray;
ntimes = NTIMES;
tm2 = 0;
UserTimerOn( &second_timer );
for (i = 0; i < ntimes; i++) {
TimerOn();
matgen(aa,ldaa,n,b,&norma);
TimerOff();
tm2 = tm2 + TimerElapsed();
dgefa(aa,ldaa,n,ipvt,&info);
}
UserTimerOff( &second_timer );
st[0][7] = ( UserTimerElapsed( &second_timer ) - tm2 ) / ntimes;
Report( "clinpack(dgefa#8)", st[0][7] );
TimerOn();
for (i = 0; i < ntimes; i++) {
dgesl(aa,ldaa,n,ipvt,b,0);
}
TimerOff();
st[1][7] = TimerElapsed()/ntimes;
Report( "clinpack(dgesl#8)", st[1][7] );
total = st[0][7] + st[1][7];
st[2][7] = total;
st[3][7] = ops/(1.0e3*total);
st[4][7] = 2.0e3/st[3][7];
st[5][7] = total/cray;
/* the following code sequence implements the semantics of
the Fortran intrinsics "nint(min(st[3][3],st[3][7]))" */
/*
kf = (st[3][3] < st[3][7]) ? st[3][3] : st[3][7];
kf = (kf > ZERO) ? (kf + .5) : (kf - .5);
if (fabs((double)kf) < ONE)
kflops = 0;
else {
kflops = floor(fabs((double)kf));
if (kf < ZERO) kflops = -kflops;
}
*/
if ( st[3][3] < ZERO ) st[3][3] = ZERO;
if ( st[3][7] < ZERO ) st[3][7] = ZERO;
kf = st[3][3];
if ( st[3][7] < st[3][3] ) kf = st[3][7];
kflops = (int)(kf + 0.5);
printf(" times for array with leading dimension of%4d\n",ldaa);
print_time(4);
print_time(5);
print_time(6);
print_time(7);
printf(ROLLING); printf(PREC);
printf(" Precision %5d Kflops ; %d Reps \n",kflops,NTIMES);
exit( EXIT_SUCCESS );
}