Merge pull request #7 from medios-porosos-fiuba/removing-logs
Cecilia Hortas
3 years ago
committed by
GitHub
commit
35570fb088
@ -1,11 +1,8 @@
|
||||
#include "genlib.h"
|
||||
#include "log.h"
|
||||
#include <math.h>
|
||||
#include <stdio.h>
|
||||
|
||||
/*exponential covariance function*/
|
||||
double exponential(double h) {
|
||||
log_info("RESULT = in progress, h = %f", h);
|
||||
|
||||
return (exp(-3. * (double)h));
|
||||
}
|
||||
|
||||
@ -0,0 +1,645 @@
|
||||
#include <math.h>
|
||||
#include <stdio.h>
|
||||
#include <time.h>
|
||||
#include "chunk_array.h"
|
||||
|
||||
/*fast fourier transform */
|
||||
/* THE COOLEY-TUKEY FAST FOURIER TRANSFORM */
|
||||
/* EVALUATES COMPLEX FOURIER SERIES FOR COMPLEX OR REAL FUNCTIONS. */
|
||||
/* THAT IS, IT COMPUTES */
|
||||
/* FTRAN(J1,J2,...)=SUM(DATA(I1,I2,...)*W1**(I1-1)*(J1-1) */
|
||||
/* *W2**(I2-1)*(J2-1)*...), */
|
||||
/* WHERE W1=EXP(-2*PI*SQRT(-1)/NN(1)), W2=EXP(-2*PI*SQRT(-1)/NN(2)), */
|
||||
/* ETC. AND I1 AND J1 RUN FROM 1 TO NN(1), I2 AND J2 RUN FROM 1 TO */
|
||||
/* NN(2), ETC. THERE IS NO LIMIT ON THE DIMENSIONALITY (NUMBER OF */
|
||||
/* SUBSCRIPTS) OF THE ARRAY OF DATA. THE PROGRAM WILL PERFORM */
|
||||
/* A THREE-DIMENSIONAL FOURIER TRANSFORM AS EASILY AS A ONE-DIMEN- */
|
||||
/* SIONAL ONE, THO IN A PROPORTIONATELY GREATER TIME. AN INVERSE */
|
||||
/* TRANSFORM CAN BE PERFORMED, IN WHICH THE SIGN IN THE EXPONENTIALS */
|
||||
/* IS +, INSTEAD OF -. IF AN INVERSE TRANSFORM IS PERFORMED UPON */
|
||||
/* AN ARRAY OF TRANSFORMED DATA, THE ORIGINAL DATA WILL REAPPEAR, */
|
||||
/* MULTIPLIED BY NN(1)*NN(2)*... THE ARRAY OF INPUT DATA MAY BE */
|
||||
/* REAL OR COMPLEX, AT THE PROGRAMMERS OPTION, WITH A SAVING OF */
|
||||
/* ABOUT THIRTY PER CENT IN RUNNING TIME FOR REAL OVER COMPLEX. */
|
||||
/* (FOR FASTEST TRANSFORM OF REAL DATA, NN(1) SHOULD BE EVEN.) */
|
||||
/* THE TRANSFORM VALUES ARE ALWAYS COMPLEX, AND ARE RETURNED IN THE */
|
||||
/* ORIGINAL ARRAY OF DATA, REPLACING THE INPUT DATA. THE LENGTH */
|
||||
/* OF EACH DIMENSION OF THE DATA ARRAY MAY BE ANY INTEGER. THE */
|
||||
/* PROGRAM RUNS FASTER ON COMPOSITE INTEGERS THAN ON PRIMES, AND IS */
|
||||
/* PARTICULARLY FAST ON NUMBERS RICH IN FACTORS OF TWO. */
|
||||
/* TIMING IS IN FACT GIVEN BY THE FOLLOWING FORMULA. LET NTOT BE THE */
|
||||
/* TOTAL NUMBER OF POINTS (REAL OR COMPLEX) IN THE DATA ARRAY, THAT */
|
||||
/* IS, NTOT=NN(1)*NN(2)*... DECOMPOSE NTOT INTO ITS PRIME FACTORS, */
|
||||
/* SUCH AS 2**K2 * 3**K3 * 5**K5 * ... LET SUM2 BE THE SUM OF ALL */
|
||||
/* THE FACTORS OF TWO IN NTOT, THAT IS, SUM2 = 2*K2. LET SUMF BE */
|
||||
/* THE SUM OF ALL OTHER FACTORS OF NTOT, THAT IS, SUMF = 3*K3+5*K5+.. */
|
||||
/* THE TIME TAKEN BY A MULTIDIMENSIONAL TRANSFORM ON THESE NTOT DATA */
|
||||
/* IS T = T0 + T1*NTOT + T2*NTOT*SUM2 + T3*NTOT*SUMF. FOR THE PAR- */
|
||||
/* TICULAR IMPLEMENTATION FORTRAN 32 ON THE CDC 3300 (FLOATING POINT */
|
||||
/* ADD TIME = SIX MICROSECONDS), */
|
||||
/* T = 3000 + 600*NTOT + 50*NTOT*SUM2 + 175*NTOT*SUMF MICROSECONDS */
|
||||
/* ON COMPLEX DATA. */
|
||||
/* IMPLEMENTATION OF THE DEFINITION BY SUMMATION WILL RUN IN A TIME */
|
||||
/* PROPORTIONAL TO NTOT**2. FOR HIGHLY COMPOSITE NTOT, THE SAVINGS */
|
||||
/* OFFERED BY COOLEY-TUKEY CAN BE DRAMATIC. A MATRIX 100 BY 100 WILL */
|
||||
/* BE TRANSFORMED IN TIME PROPORTIONAL TO 10000*(2+2+2+2+5+5+5+5) = */
|
||||
/* 280,000 (ASSUMING T2 AND T3 TO BE ROUGHLY COMPARABLE) VERSUS */
|
||||
/* 10000**2 = 100,000,000 FOR THE STRAIGHTFORWARD TECHNIQUE. */
|
||||
/* THE COOLEY-TUKEY ALGORITHM PLACES TWO RESTRICTIONS UPON THE */
|
||||
/* NATURE OF THE DATA BEYOND THE USUAL RESTRICTION THAT */
|
||||
/* THE DATA FROM ONE CYCLE OF A PERIODIC FUNCTION. THEY ARE-- */
|
||||
/* 1. THE NUMBER OF INPUT DATA AND THE NUMBER OF TRANSFORM VALUES */
|
||||
/* MUST BE THE SAME. */
|
||||
/* 2. CONSIDERING THE DATA TO BE IN THE TIME DOMAIN, */
|
||||
/* THEY MUST BE EQUI-SPACED AT INTERVALS OF DT. FURTHER, THE TRANS- */
|
||||
/* FORM VALUES, CONSIDERED TO BE IN FREQUENCY SPACE, WILL BE EQUI- */
|
||||
/* SPACED FROM 0 TO 2*PI*(NN(I)-1)/(NN(I)*DT) AT INTERVALS OF */
|
||||
/* 2*PI/(NN(I)*DT) FOR EACH DIMENSION OF LENGTH NN(I). OF COURSE, */
|
||||
/* DT NEED NOT BE THE SAME FOR EVERY DIMENSION. */
|
||||
|
||||
/* THE CALLING SEQUENCE IS-- */
|
||||
/* CALL FOURT(DATAR,DATAI,NN,NDIM,IFRWD,ICPLX,WORKR,WORKI) */
|
||||
|
||||
/* DATAR AND DATAI ARE THE ARRAYS USED TO HOLD THE REAL AND IMAGINARY */
|
||||
/* PARTS OF THE INPUT DATA ON INPUT AND THE TRANSFORM VALUES ON */
|
||||
/* OUTPUT. THEY ARE FLOATING POINT ARRAYS, MULTIDIMENSIONAL WITH */
|
||||
/* IDENTICAL DIMENSIONALITY AND EXTENT. THE EXTENT OF EACH DIMENSION */
|
||||
/* IS GIVEN IN THE INTEGER ARRAY NN, OF LENGTH NDIM. THAT IS, */
|
||||
/* NDIM IS THE DIMENSIONALITY OF THE ARRAYS DATAR AND DATAI. */
|
||||
/* IFRWD IS AN INTEGER USED TO INDICATE THE DIRECTION OF THE FOURIER */
|
||||
/* TRANSFORM. IT IS NON-ZERO TO INDICATE A FORWARD TRANSFORM */
|
||||
/* (EXPONENTIAL SIGN IS -) AND ZERO TO INDICATE AN INVERSE TRANSFORM */
|
||||
/* (SIGN IS +). ICPLX IS AN INTEGER TO INDICATE WHETHER THE DATA */
|
||||
/* ARE REAL OR COMPLEX. IT IS NON-ZERO FOR COMPLEX, ZERO FOR REAL. */
|
||||
/* IF IT IS ZERO (REAL) THE CONTENTS OF ARRAY DATAI WILL BE ASSUMED */
|
||||
/* TO BE ZERO, AND NEED NOT BE EXPLICITLY SET TO ZERO. AS EXPLAINED */
|
||||
/* ABOVE, THE TRANSFORM RESULTS ARE ALWAYS COMPLEX AND ARE STORED */
|
||||
/* IN DATAR AND DATAI ON RETURN. WORKR AND WORKI ARE ARRAYS USED */
|
||||
/* FOR WORKING STORAGE. THEY ARE NOT NECESSARY IF ALL THE DIMENSIONS */
|
||||
/* OF THE DATA ARE POWERS OF TWO. IN THIS CASE, THE ARRAYS MAY BE */
|
||||
/* REPLACED BY THE NUMBER 0 IN THE CALLING SEQUENCE. THUS, USE OF */
|
||||
/* POWERS OF TWO CAN FREE A GOOD DEAL OF STORAGE. IF ANY DIMENSION */
|
||||
/* IS NOT A POWER OF TWO, THESE ARRAYS MUST BE SUPPLIED. THEY ARE */
|
||||
/* FLOATING POINT, ONE DIMENSIONAL OF LENGTH EQUAL TO THE LARGEST */
|
||||
/* ARRAY DIMENSION, THAT IS, TO THE LARGEST VALUE OF NN(I). */
|
||||
/* WORKR AND WORKI, IF SUPPLIED, MUST NOT BE THE SAME ARRAYS AS DATAR */
|
||||
/* OR DATAI. ALL SUBSCRIPTS OF ALL ARRAYS BEGIN AT 1. */
|
||||
|
||||
/* THERE ARE NO ERROR MESSAGES OR ERROR HALTS IN THIS PROGRAM. THE */
|
||||
/* PROGRAM RETURNS IMMEDIATELY IF NDIM OR ANY NN(I) IS LESS THAN ONE. */
|
||||
|
||||
/* PROGRAM MODIFIED FROM A SUBROUTINE OF BRENNER */
|
||||
/* 10-06-2000, MLR */
|
||||
|
||||
void fourt_covar(chunk_array_t* datar, double* datai, int nn[3], int ndim, int ifrwd, int icplx, double* workr, double* worki, int cores) {
|
||||
int ifact[21], ntot, idim, np1, n, np2, m, ntwo, iff, idiv, iquot, irem, inon2, non2p, np0, nprev, icase, ifmin, i, j, jmax, np2hf, i2, i1max, i3, j3, i1, ifp1, ifp2, i2max, i1rng, istep, imin, imax, mmax, mmin, mstep, j1, j2max, j2, jmin, j3max, nhalf;
|
||||
double theta, wstpr, wstpi, wminr, wmini, wr, wi, wtemp, thetm, wmstr, wmsti, twowr, sr, si, oldsr, oldsi, stmpr, stmpi, tempr, tempi, difi, difr, sumr, sumi, TWOPI = 6.283185307179586476925286766559;
|
||||
double value1, valuei, valuej, valuei1, valueimin, valuei3, valuej3;
|
||||
|
||||
ntot = 1;
|
||||
for (idim = 0; idim < ndim; idim++) {
|
||||
ntot *= nn[idim];
|
||||
}
|
||||
|
||||
chunk_array_read(datar);
|
||||
|
||||
/*main loop for each dimension*/
|
||||
np1 = 1;
|
||||
for (idim = 1; idim <= ndim; idim++) {
|
||||
n = nn[idim - 1];
|
||||
np2 = np1 * n;
|
||||
|
||||
if (n < 1) {
|
||||
goto L920;
|
||||
} else if (n == 1) {
|
||||
goto L900;
|
||||
}
|
||||
|
||||
/*is n a power of 2 and if not, what are its factors*/
|
||||
m = n;
|
||||
ntwo = np1;
|
||||
iff = 1;
|
||||
idiv = 2;
|
||||
|
||||
L10:
|
||||
iquot = m / idiv;
|
||||
irem = m - idiv * iquot;
|
||||
if (iquot < idiv)
|
||||
goto L50;
|
||||
if (irem == 0) {
|
||||
ntwo *= 2;
|
||||
ifact[iff] = idiv;
|
||||
iff++;
|
||||
m = iquot;
|
||||
goto L10;
|
||||
}
|
||||
idiv = 3;
|
||||
inon2 = iff;
|
||||
|
||||
L30:
|
||||
iquot = m / idiv;
|
||||
irem = m - idiv * iquot;
|
||||
if (iquot < idiv)
|
||||
goto L60;
|
||||
if (irem == 0) {
|
||||
ifact[iff] = idiv;
|
||||
iff++;
|
||||
m = iquot;
|
||||
goto L30;
|
||||
}
|
||||
|
||||
idiv += 2;
|
||||
goto L30;
|
||||
|
||||
L50:
|
||||
inon2 = iff;
|
||||
if (irem != 0)
|
||||
goto L60;
|
||||
ntwo *= 2;
|
||||
goto L70;
|
||||
|
||||
L60:
|
||||
ifact[iff] = m;
|
||||
|
||||
L70:
|
||||
non2p = np2 / ntwo;
|
||||
|
||||
/*SEPARATE FOUR CASES--
|
||||
1. COMPLEX TRANSFORM
|
||||
2. REAL TRANSFORM FOR THE 2ND, 3RD, ETC. DIMENSION. METHOD: TRANSFORM HALF THE DATA, SUPPLYING THE OTHER HALF BY CONJUGATE SYMMETRY.
|
||||
3. REAL TRANSFORM FOR THE 1ST DIMENSION, N ODD. METHOD: SET THE IMAGINARY PARTS TO ZERO.
|
||||
4. REAL TRANSFORM FOR THE 1ST DIMENSION, N EVEN. METHOD: TRANSFORM A COMPLEX ARRAY OF LENGTH N/2 WHOSE REAL PARTS ARE THE EVEN NUMBERED REAL VALUES AND WHOSE IMAGINARY PARTS ARE THE ODD-NUMBERED REAL VALUES. UNSCRAMBLE AND SUPPLY THE SECOND HALF BY CONJUGATE SYMMETRY. */
|
||||
|
||||
icase = 1;
|
||||
ifmin = 1;
|
||||
if (icplx != 0)
|
||||
goto L100;
|
||||
icase = 2;
|
||||
if (idim > 1)
|
||||
goto L100;
|
||||
icase = 3;
|
||||
if (ntwo <= np1)
|
||||
goto L100;
|
||||
icase = 4;
|
||||
ifmin = 2;
|
||||
ntwo /= 2;
|
||||
n /= 2;
|
||||
np2 /= 2;
|
||||
ntot /= 2;
|
||||
i = 1;
|
||||
for (j = 1; j <= ntot; j++) {
|
||||
chunk_array_get(datar, i, &valuei);
|
||||
chunk_array_get(datar, i, &valuei1);
|
||||
chunk_array_save(datar, j, valuei);
|
||||
|
||||
//datar[j] = datar[i];
|
||||
datai[j] = valuei1;
|
||||
i += 2;
|
||||
}
|
||||
|
||||
/*shuffle data by bit reversal, since n = 2^k. As the shuffling can be done by simple interchange, no working array is needed*/
|
||||
L100:
|
||||
if (non2p > 1)
|
||||
goto L200;
|
||||
np2hf = np2 / 2;
|
||||
j = 1;
|
||||
for (i2 = 1; i2 <= np2; i2 += np1) {
|
||||
if (j >= i2)
|
||||
goto L130;
|
||||
i1max = i2 + np1 - 1;
|
||||
for (i1 = i2; i1 <= i1max; i1++) {
|
||||
for (i3 = i1; i3 <= ntot; i3 += np2) {
|
||||
j3 = j + i3 - i2;
|
||||
//tempr = datar[i3];
|
||||
tempi = datai[i3];
|
||||
//datar[i3] = datar[j3];
|
||||
datai[i3] = datai[j3];
|
||||
//datar[j3] = tempr;
|
||||
datai[j3] = tempi;
|
||||
|
||||
chunk_array_get(datar, i3, &valuei3);
|
||||
chunk_array_get(datar, j3, &valuej3);
|
||||
chunk_array_save(datar, i3, valuej3);
|
||||
chunk_array_save(datar, j3, valuei3);
|
||||
}
|
||||
}
|
||||
|
||||
L130:
|
||||
m = np2hf;
|
||||
|
||||
L140:
|
||||
if (j <= m) {
|
||||
j += m;
|
||||
} else {
|
||||
j -= m;
|
||||
m /= 2;
|
||||
if (m >= np1)
|
||||
goto L140;
|
||||
}
|
||||
}
|
||||
goto L300;
|
||||
|
||||
/*shuffle data by digit reversal for general n*/
|
||||
L200:
|
||||
for (i1 = 1; i1 <= np1; i1++) {
|
||||
for (i3 = i1; i3 <= ntot; i3 += np2) {
|
||||
j = i3;
|
||||
for (i = 1; i <= n; i++) {
|
||||
if (icase != 3) {
|
||||
//workr[i] = datar[j];
|
||||
chunk_array_get(datar, j, &workr[i]);
|
||||
worki[i] = datai[j];
|
||||
} else {
|
||||
chunk_array_get(datar, j, &workr[i]);
|
||||
//workr[i] = datar[j];
|
||||
worki[i] = 0.;
|
||||
}
|
||||
ifp2 = np2;
|
||||
iff = ifmin;
|
||||
L250:
|
||||
ifp1 = ifp2 / ifact[iff];
|
||||
j += ifp1;
|
||||
if (j >= i3 + ifp2) {
|
||||
j -= ifp2;
|
||||
ifp2 = ifp1;
|
||||
iff += 1;
|
||||
if (ifp2 > np1)
|
||||
goto L250;
|
||||
}
|
||||
}
|
||||
i2max = i3 + np2 - np1;
|
||||
i = 1;
|
||||
for (i2 = i3; i2 <= i2max; i2 += np1) {
|
||||
chunk_array_save(datar, i2, workr[i]);
|
||||
//datar[i2] = workr[i];
|
||||
datai[i2] = worki[i];
|
||||
i++;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/*special case-- W=1*/
|
||||
L300:
|
||||
i1rng = np1;
|
||||
if (icase == 2)
|
||||
i1rng = np0 * (1 + nprev / 2);
|
||||
if (ntwo <= np1)
|
||||
goto L600;
|
||||
for (i1 = 1; i1 <= i1rng; i1++) {
|
||||
imin = np1 + i1;
|
||||
istep = 2 * np1;
|
||||
goto L330;
|
||||
|
||||
L310:
|
||||
j = i1;
|
||||
for (i = imin; i <= ntot; i += istep) {
|
||||
//tempr = datar[i];
|
||||
tempi = datai[i];
|
||||
//datar[i] = datar[j] - tempr;
|
||||
datai[i] = datai[j] - tempi;
|
||||
//datar[j] = datar[j] + tempr;
|
||||
datai[j] = datai[j] + tempi;
|
||||
|
||||
chunk_array_get(datar, i, &valuei);
|
||||
chunk_array_get(datar, j, &valuej);
|
||||
|
||||
chunk_array_save(datar, i, valuej - valuei);
|
||||
chunk_array_save(datar, j, valuej + valuei);
|
||||
|
||||
j += istep;
|
||||
}
|
||||
imin = 2 * imin - i1;
|
||||
istep *= 2;
|
||||
|
||||
L330:
|
||||
if (istep <= ntwo)
|
||||
goto L310;
|
||||
|
||||
/*special case-- W = -sqrt(-1)*/
|
||||
imin = 3 * np1 + i1;
|
||||
istep = 4 * np1;
|
||||
goto L420;
|
||||
|
||||
L400:
|
||||
j = imin - istep / 2;
|
||||
for (i = imin; i <= ntot; i += istep) {
|
||||
if (ifrwd != 0) {
|
||||
tempr = datai[i];
|
||||
//tempi = -datar[i];
|
||||
chunk_array_get(datar, i, &tempi);
|
||||
tempi = -tempi;
|
||||
} else {
|
||||
tempr = -datai[i];
|
||||
//tempi = datar[i];
|
||||
chunk_array_get(datar, i, &tempi);
|
||||
}
|
||||
|
||||
chunk_array_get(datar, j, &valuej);
|
||||
chunk_array_save(datar, i, valuej - tempr);
|
||||
chunk_array_save(datar, j, valuej - tempr);
|
||||
|
||||
//datar[i] = datar[j] - tempr;
|
||||
datai[i] = datai[j] - tempi;
|
||||
//datar[j] += tempr;
|
||||
datai[j] += tempi;
|
||||
j += istep;
|
||||
}
|
||||
|
||||
imin = 2 * imin - i1;
|
||||
istep *= 2;
|
||||
|
||||
L420:
|
||||
if (istep <= ntwo)
|
||||
goto L400;
|
||||
}
|
||||
|
||||
/*main loop for factors of 2. W=EXP(-2*PI*SQRT(-1)*m/mmax) */
|
||||
theta = -TWOPI / 8.;
|
||||
wstpr = 0.;
|
||||
wstpi = -1.;
|
||||
if (ifrwd == 0) {
|
||||
theta = -theta;
|
||||
wstpi = 1.;
|
||||
}
|
||||
mmax = 8 * np1;
|
||||
goto L540;
|
||||
|
||||
L500:
|
||||
wminr = cos(theta);
|
||||
wmini = sin(theta);
|
||||
wr = wminr;
|
||||
wi = wmini;
|
||||
mmin = mmax / 2 + np1;
|
||||
mstep = np1 * 2;
|
||||
for (m = mmin; m <= mmax; m += mstep) {
|
||||
for (i1 = 1; i1 <= i1rng; i1++) {
|
||||
istep = mmax;
|
||||
imin = m + i1;
|
||||
L510:
|
||||
j = imin - istep / 2;
|
||||
for (i = imin; i <= ntot; i += istep) {
|
||||
double valuei, valuej;
|
||||
chunk_array_get(datar, i, &valuei);
|
||||
chunk_array_get(datar, j, &valuej);
|
||||
tempr = valuei * wr - datai[i] * wi;
|
||||
tempi = valuei * wi + datai[i] * wr;
|
||||
chunk_array_save(datar, i, valuej - tempr);
|
||||
//datar[i] = valuej - tempr;
|
||||
datai[i] = datai[j] - tempi;
|
||||
chunk_array_save(datar, i, valuej + tempr);
|
||||
//datar[j] += tempr;
|
||||
datai[j] += tempi;
|
||||
j += istep;
|
||||
}
|
||||
imin = 2 * imin - i1;
|
||||
istep *= 2;
|
||||
if (istep <= ntwo)
|
||||
goto L510;
|
||||
}
|
||||
wtemp = wr * wstpi;
|
||||
wr = wr * wstpr - wi * wstpi;
|
||||
wi = wi * wstpr + wtemp;
|
||||
}
|
||||
wstpr = wminr;
|
||||
wstpi = wmini;
|
||||
theta /= 2.;
|
||||
mmax += mmax;
|
||||
L540:
|
||||
if (mmax <= ntwo)
|
||||
goto L500;
|
||||
|
||||
/*main loop for factors not equal to 2-- W=EXP(-2*PI*SQRT(-1)*(j2-i3)/ifp2)*/
|
||||
L600:
|
||||
if (non2p <= 1)
|
||||
goto L700;
|
||||
ifp1 = ntwo;
|
||||
iff = inon2;
|
||||
L610:
|
||||
ifp2 = ifact[iff] * ifp1;
|
||||
theta = -TWOPI / (double)ifact[iff];
|
||||
if (ifrwd == 0)
|
||||
theta = -theta;
|
||||
thetm = theta / (double)(ifp1 / np1);
|
||||
wstpr = cos(theta);
|
||||
wstpi = sin(theta);
|
||||
wmstr = cos(thetm);
|
||||
wmsti = sin(thetm);
|
||||
wminr = 1.;
|
||||
wmini = 0.;
|
||||
|
||||
for (j1 = 1; j1 <= ifp1; j1 += np1) {
|
||||
i1max = j1 + i1rng - 1;
|
||||
for (i1 = j1; i1 <= i1max; i1++) {
|
||||
for (i3 = i1; i3 <= ntot; i3 += np2) {
|
||||
i = 1;
|
||||
wr = wminr;
|
||||
wi = wmini;
|
||||
j2max = i3 + ifp2 - ifp1;
|
||||
for (j2 = i3; j2 <= j2max; j2 += ifp1) {
|
||||
twowr = 2. * wr;
|
||||
jmin = i3;
|
||||
j3max = j2 + np2 - ifp2;
|
||||
for (j3 = j2; j3 <= j3max; j3 += ifp2) {
|
||||
j = jmin + ifp2 - ifp1;
|
||||
//sr = datar[j];
|
||||
chunk_array_get(datar, j, &sr);
|
||||
si = datai[j];
|
||||
oldsr = 0.;
|
||||
oldsi = 0.;
|
||||
j -= ifp1;
|
||||
L620:
|
||||
stmpr = sr;
|
||||
stmpi = si;
|
||||
chunk_array_get(datar, j, &valuej);
|
||||
sr = twowr * sr - oldsr + valuej;
|
||||
si = twowr * si - oldsi + datai[j];
|
||||
oldsr = stmpr;
|
||||
oldsi = stmpi;
|
||||
j -= ifp1;
|
||||
if (j > jmin)
|
||||
goto L620;
|
||||
workr[i] = wr * sr - wi * si - oldsr + valuej;
|
||||
worki[i] = wi * sr + wr * si - oldsi + datai[j];
|
||||
jmin += ifp2;
|
||||
i++;
|
||||
}
|
||||
wtemp = wr * wstpi;
|
||||
wr = wr * wstpr - wi * wstpi;
|
||||
wi = wi * wstpr + wtemp;
|
||||
}
|
||||
i = 1;
|
||||
for (j2 = i3; j2 <= j2max; j2 += ifp1) {
|
||||
j3max = j2 + np2 - ifp2;
|
||||
for (j3 = j2; j3 <= j3max; j3 += ifp2) {
|
||||
//datar[j3] = workr[i];
|
||||
chunk_array_save(datar, j3, workr[i]);
|
||||
datai[j3] = worki[i];
|
||||
i++;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
wtemp = wminr * wmsti;
|
||||
wminr = wminr * wmstr - wmini * wmsti;
|
||||
wmini = wmini * wmstr + wtemp;
|
||||
}
|
||||
iff++;
|
||||
ifp1 = ifp2;
|
||||
if (ifp1 < np2)
|
||||
goto L610;
|
||||
|
||||
/*complete a real transform in the 1st dimension, n even, by conjugate symmetries*/
|
||||
L700:
|
||||
switch (icase) {
|
||||
case 1:
|
||||
goto L900;
|
||||
break;
|
||||
case 2:
|
||||
goto L800;
|
||||
break;
|
||||
case 3:
|
||||
goto L900;
|
||||
break;
|
||||
}
|
||||
|
||||
nhalf = n;
|
||||
n += n;
|
||||
theta = -TWOPI / (double)n;
|
||||
if (ifrwd == 0)
|
||||
theta = -theta;
|
||||
wstpr = cos(theta);
|
||||
wstpi = sin(theta);
|
||||
wr = wstpr;
|
||||
wi = wstpi;
|
||||
imin = 2;
|
||||
jmin = nhalf;
|
||||
goto L725;
|
||||
L710:
|
||||
j = jmin;
|
||||
for (i = imin; i <= ntot; i += np2) {
|
||||
double valuei, valuej;
|
||||
chunk_array_get(datar, i, &valuei);
|
||||
chunk_array_get(datar, j, &valuej);
|
||||
sumr = (valuei + valuej) / 2.;
|
||||
sumi = (datai[i] + datai[j]) / 2.;
|
||||
difr = (valuei - valuej) / 2.;
|
||||
difi = (datai[i] - datai[j]) / 2.;
|
||||
tempr = wr * sumi + wi * difr;
|
||||
tempi = wi * sumi - wr * difr;
|
||||
chunk_array_save(datar, i, sumr + tempr);
|
||||
//datar[i] = sumr + tempr;
|
||||
datai[i] = difi + tempi;
|
||||
chunk_array_save(datar, j, sumr - tempr);
|
||||
//datar[j] = sumr - tempr;
|
||||
datai[j] = tempi - difi;
|
||||
j += np2;
|
||||
}
|
||||
imin++;
|
||||
jmin--;
|
||||
wtemp = wr * wstpi;
|
||||
wr = wr * wstpr - wi * wstpi;
|
||||
wi = wi * wstpr + wtemp;
|
||||
L725:
|
||||
if (imin < jmin) {
|
||||
goto L710;
|
||||
} else if (imin > jmin) {
|
||||
goto L740;
|
||||
}
|
||||
if (ifrwd == 0)
|
||||
goto L740;
|
||||
for (i = imin; i <= ntot; i += np2) {
|
||||
datai[i] = -datai[i];
|
||||
}
|
||||
L740:
|
||||
np2 *= 2;
|
||||
ntot *= 2;
|
||||
j = ntot + 1;
|
||||
imax = ntot / 2 + 1;
|
||||
L745:
|
||||
imin = imax - nhalf;
|
||||
i = imin;
|
||||
goto L755;
|
||||
L750:
|
||||
//datar[j] = datar[i];
|
||||
chunk_array_get(datar, i, &valuei);
|
||||
chunk_array_save(datar, j, valuei);
|
||||
datai[j] = -datai[i];
|
||||
L755:
|
||||
i++;
|
||||
j--;
|
||||
if (i < imax)
|
||||
goto L750;
|
||||
|
||||
chunk_array_get(datar, imin, &valueimin);
|
||||
chunk_array_save(datar, j, valueimin - datai[imin]);
|
||||
//datar[j] = datar[imin] - datai[imin];
|
||||
datai[j] = 0.;
|
||||
if (i >= j) {
|
||||
goto L780;
|
||||
} else {
|
||||
goto L770;
|
||||
}
|
||||
L765:
|
||||
//datar[j] = datar[i];
|
||||
chunk_array_get(datar, i, &valuei);
|
||||
chunk_array_save(datar, j, valuei);
|
||||
datai[j] = datai[i];
|
||||
L770:
|
||||
i--;
|
||||
j--;
|
||||
if (i > imin)
|
||||
goto L765;
|
||||
//datar[j] = datar[imin] + datai[imin];
|
||||
chunk_array_get(datar, imin, &valueimin);
|
||||
chunk_array_save(datar, j, valueimin - datai[imin]);
|
||||
datai[j] = 0.;
|
||||
imax = imin;
|
||||
goto L745;
|
||||
L780:
|
||||
chunk_array_get(datar, 1, &value1);
|
||||
chunk_array_save(datar, 1, value1 + datai[1]);
|
||||
//datar[1] += datai[1];
|
||||
datai[1] = 0.;
|
||||
goto L900;
|
||||
|
||||
/*complete a real transform for the 2nd, 3rd, ... dimension by conjugate symmetries*/
|
||||
L800:
|
||||
if (nprev <= 2)
|
||||
goto L900;
|
||||
for (i3 = 1; i3 <= ntot; i3 += np2) {
|
||||
i2max = i3 + np2 - np1;
|
||||
for (i2 = i3; i2 <= i2max; i2 += np1) {
|
||||
imax = i2 + np1 - 1;
|
||||
imin = i2 + i1rng;
|
||||
jmax = 2 * i3 + np1 - imin;
|
||||
if (i2 > i3)
|
||||
jmax += np2;
|
||||
if (idim > 2) {
|
||||
j = jmax + np0;
|
||||
for (i = imin; i <= imax; i++) {
|
||||
//datar[i] = datar[j];
|
||||
chunk_array_get(datar, j, &valuej);
|
||||
chunk_array_save(datar, i, valuej);
|
||||
datai[i] = -datai[j];
|
||||
j--;
|
||||
}
|
||||
}
|
||||
j = jmax;
|
||||
for (i = imin; i <= imax; i += np0) {
|
||||
//datar[i] = datar[j];
|
||||
chunk_array_get(datar, j, &valuej);
|
||||
chunk_array_save(datar, i, valuej);
|
||||
datai[i] = -datai[j];
|
||||
j -= np0;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/*end of loop on each dimension*/
|
||||
L900:
|
||||
np0 = np1;
|
||||
np1 = np2;
|
||||
nprev = n;
|
||||
}
|
||||
L920: return;
|
||||
}
|
||||
@ -1,50 +1,15 @@
|
||||
#include "genlib.h"
|
||||
#include "log.h"
|
||||
#include "memory.h"
|
||||
#include <math.h>
|
||||
#include <stdio.h>
|
||||
#include <time.h>
|
||||
|
||||
/*gamma covariance function*/
|
||||
double gammf(double h, double alpha, int cores) {
|
||||
double* used_ram_t0 = malloc(sizeof(double));
|
||||
getVirtualMemUsed(used_ram_t0);
|
||||
|
||||
clock_t t = clock();
|
||||
|
||||
log_info("RESULT = in progress, h = %f, alpha = %f", h, alpha);
|
||||
|
||||
struct cpustat initial[cores];
|
||||
struct cpustat final[cores];
|
||||
|
||||
for (int i = 0; i < cores; i++) {
|
||||
get_stats(&initial[i], i - 1);
|
||||
}
|
||||
|
||||
float delta;
|
||||
double z;
|
||||
|
||||
delta = pow(20., 1. / alpha) - 1.;
|
||||
z = 1. / (double)(pow(1. + h * delta, alpha));
|
||||
|
||||
t = clock() - t;
|
||||
double time_taken = ((double)t)/CLOCKS_PER_SEC; // calculate the elapsed time
|
||||
|
||||
for (int i = 0; i < cores; i++) {
|
||||
get_stats(&final[i], i - 1);
|
||||
}
|
||||
|
||||
for (int i = 0; i < cores; i++) {
|
||||
log_info("CPU %d: %lf%%", i, calculate_load(&initial[i], &final[i]));
|
||||
}
|
||||
|
||||
double* used_ram_tf = malloc(sizeof(double));
|
||||
getVirtualMemUsed(used_ram_t0);
|
||||
|
||||
log_info("RESULT = success, delta = %f, z = %f, ELAPSED = %f seconds, DIF USED VIRTUAL MEM = %5.1f MB", delta, z, time_taken, *used_ram_tf - *used_ram_t0);
|
||||
|
||||
free(used_ram_t0);
|
||||
free(used_ram_tf);
|
||||
|
||||
return z;
|
||||
}
|
||||
|
||||
@ -1,10 +1,8 @@
|
||||
#include "genlib.h"
|
||||
#include "log.h"
|
||||
#include <math.h>
|
||||
#include <stdio.h>
|
||||
|
||||
/*gaussian covariance function*/
|
||||
double gaussian(double h) {
|
||||
log_info("RESULT = in progress, h = %f", h);
|
||||
return (exp(-3. * (double)(h * h)));
|
||||
}
|
||||
|
||||
@ -1,177 +0,0 @@
|
||||
/*
|
||||
* Copyright (c) 2020 rxi
|
||||
*
|
||||
* Permission is hereby granted, free of charge, to any person obtaining a copy
|
||||
* of this software and associated documentation files (the "Software"), to
|
||||
* deal in the Software without restriction, including without limitation the
|
||||
* rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
|
||||
* sell copies of the Software, and to permit persons to whom the Software is
|
||||
* furnished to do so, subject to the following conditions:
|
||||
*
|
||||
* The above copyright notice and this permission notice shall be included in
|
||||
* all copies or substantial portions of the Software.
|
||||
*
|
||||
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
||||
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
||||
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
||||
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
||||
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
|
||||
* FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
|
||||
* IN THE SOFTWARE.
|
||||
*/
|
||||
|
||||
#include <stdlib.h>
|
||||
#include "log.h"
|
||||
#include <string.h>
|
||||
|
||||
#define MAX_CALLBACKS 32
|
||||
|
||||
typedef struct {
|
||||
log_LogFn fn;
|
||||
void *udata;
|
||||
int level;
|
||||
} Callback;
|
||||
|
||||
static struct {
|
||||
void *udata;
|
||||
log_LockFn lock;
|
||||
int level;
|
||||
bool quiet;
|
||||
Callback callbacks[MAX_CALLBACKS];
|
||||
} L;
|
||||
|
||||
|
||||
static const char *level_strings[] = {
|
||||
"TRACE", "DEBUG", "INFO", "WARN", "ERROR", "FATAL"
|
||||
};
|
||||
|
||||
#ifdef LOG_USE_COLOR
|
||||
static const char *level_colors[] = {
|
||||
"\x1b[94m", "\x1b[36m", "\x1b[32m", "\x1b[33m", "\x1b[31m", "\x1b[35m"
|
||||
};
|
||||
#endif
|
||||
|
||||
|
||||
static void stdout_callback(log_Event *ev) {
|
||||
char buf[16];
|
||||
buf[strftime(buf, sizeof(buf), "%H:%M:%S", ev->time)] = '\0';
|
||||
#ifdef LOG_USE_COLOR
|
||||
fprintf(
|
||||
ev->udata, "%s %s%-5s\x1b[0m \x1b[0m%s:%d:\x1b[0m ",
|
||||
buf, level_colors[ev->level], level_strings[ev->level],
|
||||
ev->file, ev->line);
|
||||
#else
|
||||
fprintf(
|
||||
ev->udata, "%s %-5s %s:%d: ",
|
||||
buf, level_strings[ev->level], ev->file, ev->line);
|
||||
#endif
|
||||
vfprintf(ev->udata, ev->fmt, ev->ap);
|
||||
fprintf(ev->udata, "\n");
|
||||
fflush(ev->udata);
|
||||
}
|
||||
|
||||
|
||||
static void file_callback(log_Event *ev) {
|
||||
char buf[64];
|
||||
buf[strftime(buf, sizeof(buf), "%Y-%m-%d %H:%M:%S", ev->time)] = '\0';
|
||||
fprintf(
|
||||
ev->udata, "%s %-5s %s:%d: ",
|
||||
buf, level_strings[ev->level], ev->file, ev->line);
|
||||
vfprintf(ev->udata, ev->fmt, ev->ap);
|
||||
fprintf(ev->udata, "\n");
|
||||
fflush(ev->udata);
|
||||
}
|
||||
|
||||
|
||||
static void lock(void) {
|
||||
if (L.lock) { L.lock(true, L.udata); }
|
||||
}
|
||||
|
||||
|
||||
static void unlock(void) {
|
||||
if (L.lock) { L.lock(false, L.udata); }
|
||||
}
|
||||
|
||||
|
||||
const char* log_level_string(int level) {
|
||||
return level_strings[level];
|
||||
}
|
||||
|
||||
|
||||
void log_set_lock(log_LockFn fn, void *udata) {
|
||||
L.lock = fn;
|
||||
L.udata = udata;
|
||||
}
|
||||
|
||||
|
||||
void log_set_level(int level) {
|
||||
L.level = level;
|
||||
}
|
||||
|
||||
|
||||
void log_set_quiet(bool enable) {
|
||||
L.quiet = enable;
|
||||
}
|
||||
|
||||
|
||||
int log_add_callback(log_LogFn fn, void *udata, int level) {
|
||||
for (int i = 0; i < MAX_CALLBACKS; i++) {
|
||||
if (!L.callbacks[i].fn) {
|
||||
L.callbacks[i] = (Callback) { fn, udata, level };
|
||||
return 0;
|
||||
}
|
||||
}
|
||||
return -1;
|
||||
}
|
||||
|
||||
|
||||
int log_add_fp(FILE *fp, int level) {
|
||||
return log_add_callback(file_callback, fp, level);
|
||||
}
|
||||
|
||||
|
||||
static void init_event(log_Event *ev, void *udata) {
|
||||
if (!ev->time) {
|
||||
time_t t = time(NULL);
|
||||
ev->time = localtime(&t);
|
||||
}
|
||||
ev->udata = udata;
|
||||
}
|
||||
|
||||
|
||||
void log_log(int level, const char *file, int line, const char *fmt, ...) {
|
||||
log_Event ev = {
|
||||
.fmt = fmt,
|
||||
.file = file,
|
||||
.line = line,
|
||||
.level = level,
|
||||
};
|
||||
|
||||
char* env_var = getenv("ENV");
|
||||
if (env_var != NULL && strcmp("false", env_var) == 0) return;
|
||||
|
||||
char* substr_mem = strstr(fmt, "MEM");
|
||||
char* substr_cpu = strstr(fmt, "CPU");
|
||||
if (env_var != NULL && strcmp("analysis", env_var) == 0 && substr_mem == NULL && substr_cpu == NULL) return;
|
||||
|
||||
lock();
|
||||
|
||||
if (!L.quiet && level >= L.level) {
|
||||
init_event(&ev, stderr);
|
||||
va_start(ev.ap, fmt);
|
||||
stdout_callback(&ev);
|
||||
va_end(ev.ap);
|
||||
}
|
||||
|
||||
for (int i = 0; i < MAX_CALLBACKS && L.callbacks[i].fn; i++) {
|
||||
Callback *cb = &L.callbacks[i];
|
||||
if (level >= cb->level) {
|
||||
init_event(&ev, cb->udata);
|
||||
va_start(ev.ap, fmt);
|
||||
cb->fn(&ev);
|
||||
va_end(ev.ap);
|
||||
}
|
||||
}
|
||||
|
||||
unlock();
|
||||
}
|
||||
@ -1,49 +0,0 @@
|
||||
/**
|
||||
* Copyright (c) 2020 rxi
|
||||
*
|
||||
* This library is free software; you can redistribute it and/or modify it
|
||||
* under the terms of the MIT license. See `log.c` for details.
|
||||
*/
|
||||
|
||||
#ifndef LOG_H
|
||||
#define LOG_H
|
||||
|
||||
#include <stdio.h>
|
||||
#include <stdarg.h>
|
||||
#include <stdbool.h>
|
||||
#include <time.h>
|
||||
|
||||
#define LOG_VERSION "0.1.0"
|
||||
|
||||
typedef struct {
|
||||
va_list ap;
|
||||
const char *fmt;
|
||||
const char *file;
|
||||
struct tm *time;
|
||||
void *udata;
|
||||
int line;
|
||||
int level;
|
||||
} log_Event;
|
||||
|
||||
typedef void (*log_LogFn)(log_Event *ev);
|
||||
typedef void (*log_LockFn)(bool lock, void *udata);
|
||||
|
||||
enum { LOG_TRACE, LOG_DEBUG, LOG_INFO, LOG_WARN, LOG_ERROR, LOG_FATAL };
|
||||
|
||||
#define log_trace(...) log_log(LOG_TRACE, __FILE__, __LINE__, __VA_ARGS__)
|
||||
#define log_debug(...) log_log(LOG_DEBUG, __FILE__, __LINE__, __VA_ARGS__)
|
||||
#define log_info(...) log_log(LOG_INFO, __FILE__, __LINE__, __VA_ARGS__)
|
||||
#define log_warn(...) log_log(LOG_WARN, __FILE__, __LINE__, __VA_ARGS__)
|
||||
#define log_error(...) log_log(LOG_ERROR, __FILE__, __LINE__, __VA_ARGS__)
|
||||
#define log_fatal(...) log_log(LOG_FATAL, __FILE__, __LINE__, __VA_ARGS__)
|
||||
|
||||
const char* log_level_string(int level);
|
||||
void log_set_lock(log_LockFn fn, void *udata);
|
||||
void log_set_level(int level);
|
||||
void log_set_quiet(bool enable);
|
||||
int log_add_callback(log_LogFn fn, void *udata, int level);
|
||||
int log_add_fp(FILE *fp, int level);
|
||||
|
||||
void log_log(int level, const char *file, int line, const char *fmt, ...);
|
||||
|
||||
#endif
|
||||
@ -1,94 +0,0 @@
|
||||
#include <sys/types.h>
|
||||
#include <sys/sysinfo.h>
|
||||
#include <stdlib.h>
|
||||
#include <stdio.h>
|
||||
#include <string.h>
|
||||
#include <sys/times.h>
|
||||
#include <sys/vtimes.h>
|
||||
#include <unistd.h>
|
||||
#include "log.h"
|
||||
#include "memory.h"
|
||||
|
||||
static unsigned long long lastTotalUser, lastTotalUserLow, lastTotalSys, lastTotalIdle;
|
||||
static clock_t lastCPU, lastSysCPU, lastUserCPU;
|
||||
static int numProcessors;
|
||||
|
||||
void getTotalVirtualMem(double* total_ram) {
|
||||
const double megabyte = 1024 * 1024;
|
||||
struct sysinfo si;
|
||||
sysinfo(&si);
|
||||
*total_ram = si.totalram / megabyte;
|
||||
}
|
||||
|
||||
void getVirtualMemUsed(double* used_ram) {
|
||||
const double megabyte = 1024 * 1024;
|
||||
struct sysinfo si;
|
||||
sysinfo(&si);
|
||||
*used_ram = (si.totalram - si.freeram) / megabyte;
|
||||
}
|
||||
|
||||
int parseLine(char* line) {
|
||||
// This assumes that a digit will be found and the line ends in " Kb".
|
||||
int i = strlen(line);
|
||||
const char* p = line;
|
||||
while (*p <'0' || *p > '9') p++;
|
||||
line[i-3] = '\0';
|
||||
i = atoi(p);
|
||||
return i;
|
||||
}
|
||||
|
||||
int getVirtualMemUsedByCurrentProcess() {
|
||||
FILE* file = fopen("/proc/self/status", "r");
|
||||
int result = -1;
|
||||
char line[128];
|
||||
|
||||
while (fgets(line, 128, file) != NULL){
|
||||
if (strncmp(line, "VmSize:", 7) == 0){
|
||||
result = parseLine(line);
|
||||
break;
|
||||
}
|
||||
}
|
||||
fclose(file);
|
||||
return result / 1024;
|
||||
}
|
||||
|
||||
void skip_lines(FILE *fp, int numlines) {
|
||||
int cnt = 0;
|
||||
char ch;
|
||||
while ((cnt < numlines) && ((ch = getc(fp)) != EOF)) {
|
||||
if (ch == '\n') cnt++;
|
||||
}
|
||||
}
|
||||
|
||||
void get_stats(struct cpustat *st, int cpunum) {
|
||||
FILE *fp = fopen("/proc/stat", "r");
|
||||
int lskip = cpunum+1;
|
||||
skip_lines(fp, lskip);
|
||||
char cpun[255];
|
||||
fscanf(fp, "%s %d %d %d %d %d %d %d", cpun, &(st->t_user), &(st->t_nice),
|
||||
&(st->t_system), &(st->t_idle), &(st->t_iowait), &(st->t_irq),
|
||||
&(st->t_softirq));
|
||||
fclose(fp);
|
||||
return;
|
||||
}
|
||||
|
||||
double calculate_load(struct cpustat *prev, struct cpustat *cur) {
|
||||
int idle_prev = (prev->t_idle) + (prev->t_iowait);
|
||||
int idle_cur = (cur->t_idle) + (cur->t_iowait);
|
||||
|
||||
int nidle_prev = (prev->t_user) + (prev->t_nice) + (prev->t_system) + (prev->t_irq) + (prev->t_softirq);
|
||||
int nidle_cur = (cur->t_user) + (cur->t_nice) + (cur->t_system) + (cur->t_irq) + (cur->t_softirq);
|
||||
|
||||
int total_prev = idle_prev + nidle_prev;
|
||||
int total_cur = idle_cur + nidle_cur;
|
||||
|
||||
double totald = (double) total_cur - (double) total_prev;
|
||||
|
||||
double idled = (double) idle_cur - (double) idle_prev;
|
||||
|
||||
if (totald == 0 && idled == 0) return 0;
|
||||
|
||||
double cpu_perc = (1000 * (totald - idled) / totald + 1) / 10;
|
||||
|
||||
return cpu_perc;
|
||||
}
|
||||
@ -1,24 +0,0 @@
|
||||
#include "sys/types.h"
|
||||
#include "sys/sysinfo.h"
|
||||
#include "stdlib.h"
|
||||
#include "stdio.h"
|
||||
#include "string.h"
|
||||
#include "sys/times.h"
|
||||
#include "sys/vtimes.h"
|
||||
|
||||
void getTotalVirtualMem();
|
||||
void getVirtualMemUsed();
|
||||
int getVirtualMemUsedByCurrentProcess();
|
||||
|
||||
struct cpustat {
|
||||
unsigned long t_user;
|
||||
unsigned long t_nice;
|
||||
unsigned long t_system;
|
||||
unsigned long t_idle;
|
||||
unsigned long t_iowait;
|
||||
unsigned long t_irq;
|
||||
unsigned long t_softirq;
|
||||
};
|
||||
|
||||
void get_stats(struct cpustat *st, int cpunum);
|
||||
double calculate_load(struct cpustat *prev, struct cpustat *cur);
|
||||
@ -1,10 +1,8 @@
|
||||
#include "genlib.h"
|
||||
#include "log.h"
|
||||
#include <math.h>
|
||||
#include <stdio.h>
|
||||
|
||||
/*power covariance function*/
|
||||
double power(double h, double alpha) {
|
||||
log_info("RESULT = in progress, h = %f, alpha = %f", h, alpha);
|
||||
return pow(h, alpha);
|
||||
}
|
||||
|
||||
Loading…
Reference in New Issue