SEXP R_split_up_2sample(SEXP scores, SEXP m, SEXP obs, SEXP tol) {
/*
R interface to the split-up algorithm.
'scores' is a REAL vector giving the scores of the total sample
and 'm' is a scalar integer with the sample size of one group.
'obs' is the scalar observed test statistic, namely the
sum of the 'm' scores measured in one group.
*/
int b, c, u;
double tot, bino, prob;
double ob;
SEXP ans;
celW **W1;
celW **W2;
double *rs;
b = LENGTH(scores);
rs = REAL(scores);
c = INTEGER(m)[0];
/* d = b - INTEGER(m)[0]; not used */
ob = REAL(obs)[0];
/* total number of possible permutations */
bino = binomi(b, c);
/* allocate and initialise memory */
W1 = reserveW(c, (b+1)/2);
initW(c, (b+1)/2, W1);
W2 = reserveW(c, (b+1)/2);
initW(c, (b+1)/2, W2);
makeW(W1, c, b/2, 0, rs, REAL(tol)[0]);
makeW(W2, c, (b+1)/2, b/2, rs, REAL(tol)[0]);
for (u = 0; u <= c; u++) cumulcoef(W2, u, (b+1)/2);
/* number of permutations <= ob */
tot = numbersmall(c, b, ob, W1, W2, REAL(tol)[0]);
/* probability */
prob = tot/bino;
/* free memory: this will _not_ take place
in case of an error */
FreeW(c, W1);
FreeW(c, W2);
/* return to R */
PROTECT(ans = allocVector(REALSXP, 1));
REAL(ans)[0] = prob;
UNPROTECT(1);
return(ans);
}
FFT::FFT(int32 _N, int32 _R[MAX_RANKS])
{
int32 lcv;
for(lcv = 0; lcv < MAX_RANKS; lcv++)
R[lcv] = _R[lcv];
N = _N;
M = 0;
/* Get the number of ranks */
while(_N > 1)
{
M++;
_N >>= 1;
}
W = (MIX *)malloc(N/2*sizeof(MIX)); // Forward twiddle lookup
iW = (MIX *)malloc(N/2*sizeof(MIX)); // Inverse twiddle lookup
BR = (int32 *)malloc(N*sizeof(int32)); // Bit reverse lookup
BRX = (int32 *)malloc(N*sizeof(CPX)); // Shuffle temp array
initW();
initBR();
}
Status XvMCCreateContext (
Display *display,
XvPortID port,
int surface_type_id,
int width,
int height,
int flags,
XvMCContext * context
)
{
if (!wrapperInit) initW(display, port);
if (!xW.initialised) return BadValue;
return (*xW.XvMCCreateContext)(display, port, surface_type_id,
width, height, flags, context);
}
// X: a MxD matrix, Y: a M vector, W: a M vector
// W0: a M vector
int main(int argc, char ** argv){
if (argc>1 && argv[1][0]=='h') {
printf ("Usage: parSymSGD M D T C lamda r\n");
printf (" M: number of data points, D: dimensions, T: time iterations, C: cores;\n");
printf (" lamda: learning rate, r: panel size in unit of C.\n");
return 1;
}u
// read in the arguments: M, D, I (time iterations), C (cores), r (each panel contains r*C points)
int M = argc>1?atoi(argv[1]):32;
int D = argc>2?atoi(argv[2]):4;
T = argc>3?atoi(argv[3]):10;
int C = argc>4?atoi(argv[4]):4;
float lamda = argc>5?atof(argv[5]):0.01;
int r = argc>6?atoi(argv[6]):1;
///printf("M=%d, D=%d, T=%d, C=%d, lamda=%8.6f, r=%d\n",M,D,T,C,lamda,r);
int max_threads = mkl_get_max_threads(); // get the max number of threads
int rep;
mkl_set_num_threads(1); // set the number of threads to use by mkl
panelSz = C*r;
panels = M/panelSz;
int i,j,k,p,t;
float *Y, *Wreal, *W, *X;
Y = (float *) mkl_malloc(M*sizeof(float),PAGESIZE);
Wreal = (float *) mkl_malloc(D*sizeof(float),PAGESIZE);
W = (float *) mkl_malloc(D*sizeof(float),PAGESIZE);
X = (float *) mkl_malloc(M*D*sizeof(float),PAGESIZE);
float *Ypred = (float*)mkl_malloc(M*sizeof(float),PAGESIZE);
float *Ytmp = (float*)mkl_malloc(M*sizeof(float),PAGESIZE);
float *I = (float*)mkl_malloc(D*D*sizeof(float),PAGESIZE);
float *Z = (float*)mkl_malloc(M*D*sizeof(float),PAGESIZE);
float *B = (float*)mkl_malloc(panels*D*sizeof(float),PAGESIZE);
if (Y==NULL | Wreal==NULL | W==NULL | X==NULL | Ypred==NULL || Ytmp==NULL || Z==NULL || B==NULL || I== NULL){
printf("Memory allocation error.\n");
return 2;
}
initData(Wreal,W,X,Y, M, D,I);
///printf("panelSz=%d, panels=%d\n", panelSz, panels);
for (nt=1; nt<=max_threads && nt<=panelSz; nt*=2){
omp_set_num_threads(nt);// set the number of openMP threads
for (rep=0; rep<REPEATS; rep++){//repeat measurements
double prepTime, gdTime, sInit;
// preprocessing
sInit=dsecnd();
//preprocessSeq(X, Y, Z, B, panelSz, panels, M, D, lamda);
preprocessPar(X, Y, Z, B, panelSz, panels, M, D, lamda);
prepTime = (dsecnd() - sInit);
///dump2("Z",Z,M,D);
///dump2("B",B,panels,D);
// GD
initW(W,D);
///dump1("W (initial)", W, D);
sInit=dsecnd();
float err;
float fixpoint = 0.0;
for (t=0;t<T;t++){
for (p=0;p<panels;p++){
gd(&(X[p*panelSz*D]),&(Z[p*panelSz*D]), &(B[p*D]), panelSz, D, lamda, W, I);
///printf("(t=%d, p=%d) ",t,p);
///dump1("W", W, D);
///err=calErr(X, Ypred, Ytmp, Y, W, M, D);
printf("finish one panels ............................ \n");
}
}
gdTime = (dsecnd() - sInit);
err=calErr(X, Ypred, Ytmp, Y, W, M, D);
fixpoint = err - prev_err;
// print final err. time is in milliseconds
printf("nt=%d\t ttlTime=%.5f\t prepTime=%.5f\t gdTime=%.5f\t error=%.5f\n", nt, (gdTime+prepTime)*1000, prepTime*1000, gdTime*1000, err);
}
}
if (B) mkl_free(B);
if (Z) mkl_free(Z);
if (Ytmp) mkl_free(Ytmp);
if (Ypred) mkl_free(Ypred);
if (Y) mkl_free(Y);
if (Wreal) mkl_free(Wreal);
if (W) mkl_free(W);
if (X) mkl_free(X);
if (I) mkl_free(I);
return 0;
}
XvMCSurfaceInfo * XvMCListSurfaceTypes(Display *dpy, XvPortID port, int *num)
{
if (!wrapperInit) initW( dpy, port);
if (!xW.initialised) return NULL;
return (*xW.XvMCListSurfaceTypes)(dpy, port, num);
}
