/***************************************************************************/
/* GAUSS Benchmark program version 5.0                                     */
/* Author : Stefan Steinhaus                                               */
/* EMAIL  : stefan@steinhaus-net.de                                        */
/* This program is public domain. Feel free to copy it freely.             */
/***************************************************************************/

/* Test of IO function - Reading of data from ASCII file */
/* Test of Extraction of submatrices and calculation of descriptive stats */
/* Doing the whole process 2000 times do get higher timings                */

proc 1 = IOTestASCII(runs);
  local result,zeit,timing,i,j,k;
  local fname,datmat,ColName;
  local Year_Data, Limits_Area;
  local Min_Year,Max_Year,Mean_Year,GainLoss_Year;
  result=0;
  Limits_Area={1,261,522,784,1045,1305,1565,1827,2088,2349,2610,2871,3131,3158};
  fname="d:\\mathematik\\ncrunch5\\currency2.txt";
  _dxaschdr=1; _dxprint=0;
  for i (1,runs,1);
    timing=0; zeit=hsec;
    {datmat,ColName}=import(fname,0,0);
    for k (1,2000,1);
      for j (1,13,1);
        Year_Data=datmat[Limits_Area[j]:Limits_Area[j+1]-1,4:37];
        Min_Year=minc(Year_Data);
        Max_Year=maxc(Year_Data);
        Mean_Year=meanc(Year_Data);
        GainLoss_Year=100-(Year_Data[1,.]+0.00000001)./(Year_Data[rows(Year_Data),.]+0.00000001)*100;
      endfor;
    endfor;
    timing=(hsec-zeit)/100;
    result=result+timing;
  endfor;
  retp(result/runs);
endp;

/* Test of 2 loops 15000x15000 */

proc 1 = LoopTest(runs);
  local a,b,result,i,timing,zeit;
  result=0;
  for i (1,runs,1);
    a=1;
    timing=0; 
    zeit=hsec;
    for x (1,15000,1);
        for y (1,15000,1);
            a=a+x+y;
        endfor;
    endfor;
    timing=(hsec-zeit)/100;
    result=result+timing;
  endfor;
  retp(result/runs);
endp;

/* 2000x2000 normal distributed random matrix^1000 */

proc 1 = CreationMatrix(runs);
  local a,b,result,i,j,timing,t;
  result=0;
  for i (1,runs,1);
    timing=0; 
    for j (1,200,1);
        b=1+(rndu(2000,2000)/100);
        t=hsec;
        a=b^1000; 
        timing=timing+hsec-t;
    endfor;
    timing=timing/100;
    result=result+timing;
  endfor;
  retp(result/runs);
endp;

/* 100 x Sorting of 1000000 values */

proc 1 = SortFunc(runs);
  local a,b,result,i,j,timing,t;
  result=0;
  for i (1,runs,1);
    timing=0; 
    for j (1,100,1);
        a=rndu(1000000,1);
        t=hsec;
        b=sortc(a,1); 
        timing=timing+hsec-t;
    endfor;
    timing=timing/100;
    result=result+timing;
  endfor;
  retp(result/runs);
endp;

/* 100 x FFT of 1048576 random values (2^20) */

proc 1 = FFTFunc(runs);
  local a,b,result,i,j,timing,t;
  result=0;
  for i (1,runs,1);
    timing=0; 
    for j (1,100,1);
        a=rndu(1048576,1); 
        t=hsec;
        b=fft(a); 
        timing=timing+hsec-t;
    endfor;
    timing=timing/100;
    result=result+timing;
  endfor;
  retp(result/runs);
endp;

/* 100 x Determinant of a 1500x1500 matrix */

proc 1 = Determinant(runs);
  local a,b,result,i,j,timing,t;
  result=0;
  for i (1,runs,1);
    timing=0; 
    for j (1,100,1); 
        a=rndu(1500,1500); 
        t=hsec;
        b=det(a); 
        timing=timing+hsec-t;
    endfor;
    timing=timing/100;
    result=result+timing;
  endfor;
  retp(result/runs);
endp;

/* 100 x Inverse of a 1500x1500 matrix */

proc 1 = InverseFunc(runs);
  local a,b,result,i,j,timing,t;
  result=0;
  for i (1,runs,1);
    timing=0; 
    for j (1,100,1);
        a=rndu(1500,1500); 
        t=hsec;
        b=inv(a); 
        timing=timing+hsec-t;
    endfor;
    timing=timing/100;
    result=result+timing;
  endfor;
  retp(result/runs);
endp;

/* Eigenvalues of a 1200x1200 matrix */

proc 1 = EigenvaluesFunc(runs);
  local a,b,result,i,timing,zeit;
  result=0;
  for i (1,runs,1);
    timing=0;
    a=rndu(1200,1200);
    zeit=hsec; 
    b=eig(a); 
    timing=(hsec-zeit)/100;
    result=result+timing;
  endfor;
  retp(result/runs);
endp;

/* 100 x Cholesky decomposition of a 1500x1500-matrix */

proc 1 = CholeskyFunc(runs);
  local a,b,result,i,j,timing,t;
  result=0;
  for i (1,runs,1);
    timing=0; 
    for j (1,100,1);
        a=moment(rndu(1500,1500),0); 
        t=hsec;
        b=chol(a); 
        timing=timing+hsec-t;
    endfor;
    timing=timing/100;
    result=result+timing;
  endfor;
  retp(result/runs);
endp;

/* 100 x 1500x1500 cross-product matrix */

proc 1 = CrossProductFunc(runs);
  local a,b,result,i,j,timing,t;
  result=0;
  for i (1,runs,1);
    timing=0; 
    for j (1,100,1);
        a=rndu(1500,1500); 
        t=hsec;
        b=moment(a,0); 
        timing=timing+hsec-t;
    endfor;
    timing=timing/100;
    result=result+timing;
  endfor;
  retp(result/runs);
endp;

/* Calculation of 10000000 fibonacci numbers */

proc 1 = FibonacciFunc(runs);
  local a,b,phi,result,i,timing,zeit;
  result=0;
  phi = 1.6180339887498949;
  for i (1,runs,1);
    timing=0; 
    a=floor(1000*rndu(10000000,1));
    zeit=hsec; 
    b=(phi^a-(-phi)^(-a))/sqrt(5); 
    timing=(hsec-zeit)/100;
    result=result+timing;
  endfor;
  retp(result/runs);
endp;

/* Principal Component Analysis over a 10000x1000 matrix */

proc 1 = PCAFunc(runs);
  local a,p,v,result,i,timing,zeit;
  result=0;
  for i (1,runs,1);
    a=rndu(10000,1000);
    timing=0;
    zeit=hsec;
    {p,v,a}=princomp(a,1000);
    timing=(hsec-zeit)/100;
    result=result+timing;
  endfor;
  retp(result/runs);
endp;

/* 100 x Gamma function over a 1500x1500 matrix */

proc 1 = GammaFunc(runs);
  local a,b,result,i,j,timing,t;
  result=0;
  for i (1,runs,1);
    timing=0; 
    for j (1,100,1);
        a=rndu(1500,1500);
        t=hsec;
        b=gamma(a); 
        timing=timing+hsec-t;
    endfor;
    timing=timing/100;
    result=result+timing;
  endfor;
  retp(result/runs);
endp;

/* 100 x Gaussian error function over a 1500x1500 matrix */

proc 1 = GaussianFunc(runs);
  local a,b,result,i,j,timing,t;
  result=0;
  for i (1,runs,1);
    timing=0;
    for j (1,100,1);
        a=rndu(1500,1500);
        t=hsec;
        b=erf(a); 
        timing=timing+hsec-t;
    endfor;
    timing=timing/100;
    result=result+timing;
  endfor;
  retp(result/runs);
endp;

/* 100 x Linear regression over 1000x1000 matrix */

proc 1 = LinearRegressionFunc(runs);
  local a,b,result,i,j,timing,t;
  result=0;
  for i (1,runs,1);
    timing=0; 
    for j (1,100,1);
        a=rndu(1000,1000); 
        b=seqa(1,1,1000);
        t=hsec;
        b=olsqr(b,a); 
        timing=timing+hsec-t;
    endfor;
    timing=timing/100;
    result=result+timing;
  endfor;
  retp(result/runs);
endp;



/* Main program */

cls;
format /RD 8,3;
runs=3;              /* Amount of runs for avg. timing -> suggestion at least 2 */
datmat=0;
ver=sysstate(1,0);
print; print; print;
print "                  !!! GAUSS - Benchmark program !!!";
print "                  ================================="; print; print;
print "Platform: GAUSS " ftos(ver[1],"%*lf",2,0) "." ftos(ver[2],"%*lf",1,0) "." ftos(ver[3],"%*lf",2,0);
print "Displaying the avg. timings over " runs " runs.";
print; print;
print "Function / timing [sec.]                                           result (sec.)";
print "--------------------------------------------------------------------------------";

{timing}=IOTestASCII(runs);
print /flush "IO test and descriptive statistics__________________________ : " timing;
{timing}=LoopTest(runs);
print /flush "Test of loops_______________________________________________ : " timing;
{timing}=CreationMatrix(runs);
print /flush "2000x2000 uniform distributed random matrix^1000____________ : " timing;
{timing}=SortFunc(runs);
print /flush "1000000 values sorted ascending_____________________________ : " timing;
{timing}=FFTFunc(runs);
print /flush "FFT over 1048576 values (2^20)______________________________ : " timing;
{timing}=Determinant(runs);
print /flush "Determinant of a 1500x1500 random matrix____________________ : " timing;
{timing}=InverseFunc(runs);
print /flush "Inverse of a 1500x1500 uniform distr. random matrix_________ : " timing;
{timing}=EigenvaluesFunc(runs);
print /flush "Eigenvalues of a uniform distr. 1200x1200 randommatrix______ : " timing;
{timing}=CholeskyFunc(runs);
print /flush "Cholesky decomposition of a 1500x1500-matrix________________ : " timing; 
{timing}=CrossProductFunc(runs);
print /flush "1500x1500 cross-product matrix______________________________ : " timing;
{timing}=FibonacciFunc(runs);
print /flush "Calculation of 10000000 fibonacci numbers___________________ : " timing;
{timing}=PCAFunc(runs);
print /flush "Principal component analysis over a 10000x1000 matrix_______ : " timing;
{timing}=GammaFunc(runs);
print /flush "Gamma function over a 1500x1500 matrix______________________ : " timing;
{timing}=GaussianFunc(runs);
print /flush "Gaussian error function over a 1500x1500 matrix_____________ : " timing;
{timing}=LinearRegressionFunc(runs);
print /flush "Linear regression over a 1000x1000 matrix___________________ : " timing;
end;