filename stringlengths 19 182 | omp_pragma_line stringlengths 24 416 | context_chars int64 100 100 | text stringlengths 152 177k |
|---|---|---|---|
SebKrantz/collapse/src/fndistinct.c | #pragma omp parallel for num_threads(nthreads) | 100 | s[gr] == 0 ? 0 : ndistinct_fct(px + pst[gr]-1, po, pgs[gr], M, 1, narm);
} else {
<LOOP-START>for(int gr = 0; gr < ng; ++gr)
pres[gr] = pgs[gr] == 0 ? 0 : ndistinct_int(px + pst[gr]-1, po, pgs[gr], 1, narm);
}
break;
}
case LGLSXP: {
const int *px = LOGICAL(x);
#pragma omp parallel for num_threads(nthreads)
for(int gr = 0; gr < ng; ++gr)
pres[gr] = pgs[gr] == 0 ? 0 : ndistinct_logi(px + pst[gr]-1, po, pgs[gr], 1, narm);
break;
}<LOOP-END> <OMP-START>#pragma omp parallel for num_threads(nthreads)<OMP-END> |
SebKrantz/collapse/src/fndistinct.c | #pragma omp parallel for num_threads(nthreads) | 100 | ;
}
break;
}
case LGLSXP: {
const int *px = LOGICAL(x);
<LOOP-START>for(int gr = 0; gr < ng; ++gr)
pres[gr] = pgs[gr] == 0 ? 0 : ndistinct_logi(px + pst[gr]-1, po, pgs[gr], 1, narm);
break;
}
case STRSXP: {
const SEXP *px = SEXPPTR(x);
#pragma omp parallel for num_threads(nthreads)
for(int gr = 0; gr < ng; ++gr)
pres[gr] = pgs[gr] == 0 ? 0 : ndistinct_string(px + pst[gr]-1, po, pgs[gr], 1, narm);
break;
}<LOOP-END> <OMP-START>#pragma omp parallel for num_threads(nthreads)<OMP-END> |
SebKrantz/collapse/src/fndistinct.c | #pragma omp parallel for num_threads(nthreads) | 100 | 1, narm);
break;
}
case STRSXP: {
const SEXP *px = SEXPPTR(x);
<LOOP-START>for(int gr = 0; gr < ng; ++gr)
pres[gr] = pgs[gr] == 0 ? 0 : ndistinct_string(px + pst[gr]-1, po, pgs[gr], 1, narm);
break;
}
default: error("Not Supported SEXP Type!");
}
} else { // Not sorted. Perhaps reordering x is faster??
switch(TYPEOF(x)) {
case REALSXP: {
const double *px = REAL(x);
#pragma omp parallel for num_threads(nthreads)
for(int gr = 0; gr < ng; ++gr)
pres[gr] = pgs[gr] == 0 ? 0 : ndistinct_double(px, po + pst[gr]-1, pgs[gr], 0, narm);
break;
}
case INTSXP: {
const int *px = INTEGER(x);
if(isFactor(x) && nlevels(x) < l / ng * 3) {
int M = nlevels(x);
#pragma omp parallel for num_threads(nthreads)
for(int gr = 0; gr < ng; ++gr)
pres[gr] = pgs[gr] == 0 ? 0 : ndistinct_fct(px, po + pst[gr]-1, pgs[gr], M, 0, narm);
} else {
#pragma omp parallel for num_threads(nthreads)
for(int gr = 0; gr < ng; ++gr)
pres[gr] = pgs[gr] == 0 ? 0 : ndistinct_int(px, po + pst[gr]-1, pgs[gr], 0, narm);
}
break;
}
case LGLSXP: {
const int *px = LOGICAL(x);
#pragma omp parallel for num_threads(nthreads)
for(int gr = 0; gr < ng; ++gr)
pres[gr] = pgs[gr] == 0 ? 0 : ndistinct_logi(px, po + pst[gr]-1, pgs[gr], 0, narm);
break;
}
case STRSXP: {
const SEXP *px = SEXPPTR(x);
#pragma omp parallel for num_threads(nthreads)
for(int gr = 0; gr < ng; ++gr)
pres[gr] = pgs[gr] == 0 ? 0 : ndistinct_string(px, po + pst[gr]-1, pgs[gr], 0, narm);
break;
}
default: error("Not Supported SEXP Type!");
}
}<LOOP-END> <OMP-START>#pragma omp parallel for num_threads(nthreads)<OMP-END> |
SebKrantz/collapse/src/fndistinct.c | #pragma omp parallel for num_threads(nthreads) | 100 | faster??
switch(TYPEOF(x)) {
case REALSXP: {
const double *px = REAL(x);
<LOOP-START>for(int gr = 0; gr < ng; ++gr)
pres[gr] = pgs[gr] == 0 ? 0 : ndistinct_double(px, po + pst[gr]-1, pgs[gr], 0, narm);
break;
}
case INTSXP: {
const int *px = INTEGER(x);
if(isFactor(x) && nlevels(x) < l / ng * 3) {
int M = nlevels(x);
#pragma omp parallel for num_threads(nthreads)
for(int gr = 0; gr < ng; ++gr)
pres[gr] = pgs[gr] == 0 ? 0 : ndistinct_fct(px, po + pst[gr]-1, pgs[gr], M, 0, narm);
} else {
#pragma omp parallel for num_threads(nthreads)
for(int gr = 0; gr < ng; ++gr)
pres[gr] = pgs[gr] == 0 ? 0 : ndistinct_int(px, po + pst[gr]-1, pgs[gr], 0, narm);
}
break;
}<LOOP-END> <OMP-START>#pragma omp parallel for num_threads(nthreads)<OMP-END> |
SebKrantz/collapse/src/fndistinct.c | #pragma omp parallel for num_threads(nthreads) | 100 | ER(x);
if(isFactor(x) && nlevels(x) < l / ng * 3) {
int M = nlevels(x);
<LOOP-START>for(int gr = 0; gr < ng; ++gr)
pres[gr] = pgs[gr] == 0 ? 0 : ndistinct_fct(px, po + pst[gr]-1, pgs[gr], M, 0, narm);
} else {
#pragma omp parallel for num_threads(nthreads)
for(int gr = 0; gr < ng; ++gr)
pres[gr] = pgs[gr] == 0 ? 0 : ndistinct_int(px, po + pst[gr]-1, pgs[gr], 0, narm);
}<LOOP-END> <OMP-START>#pragma omp parallel for num_threads(nthreads)<OMP-END> |
SebKrantz/collapse/src/fndistinct.c | #pragma omp parallel for num_threads(nthreads) | 100 | s[gr] == 0 ? 0 : ndistinct_fct(px, po + pst[gr]-1, pgs[gr], M, 0, narm);
} else {
<LOOP-START>for(int gr = 0; gr < ng; ++gr)
pres[gr] = pgs[gr] == 0 ? 0 : ndistinct_int(px, po + pst[gr]-1, pgs[gr], 0, narm);
}
break;
}
case LGLSXP: {
const int *px = LOGICAL(x);
#pragma omp parallel for num_threads(nthreads)
for(int gr = 0; gr < ng; ++gr)
pres[gr] = pgs[gr] == 0 ? 0 : ndistinct_logi(px, po + pst[gr]-1, pgs[gr], 0, narm);
break;
}<LOOP-END> <OMP-START>#pragma omp parallel for num_threads(nthreads)<OMP-END> |
SebKrantz/collapse/src/fndistinct.c | #pragma omp parallel for num_threads(nthreads) | 100 | ;
}
break;
}
case LGLSXP: {
const int *px = LOGICAL(x);
<LOOP-START>for(int gr = 0; gr < ng; ++gr)
pres[gr] = pgs[gr] == 0 ? 0 : ndistinct_logi(px, po + pst[gr]-1, pgs[gr], 0, narm);
break;
}
case STRSXP: {
const SEXP *px = SEXPPTR(x);
#pragma omp parallel for num_threads(nthreads)
for(int gr = 0; gr < ng; ++gr)
pres[gr] = pgs[gr] == 0 ? 0 : ndistinct_string(px, po + pst[gr]-1, pgs[gr], 0, narm);
break;
}<LOOP-END> <OMP-START>#pragma omp parallel for num_threads(nthreads)<OMP-END> |
SebKrantz/collapse/src/fndistinct.c | #pragma omp parallel for num_threads(nthreads) | 100 | 0, narm);
break;
}
case STRSXP: {
const SEXP *px = SEXPPTR(x);
<LOOP-START>for(int gr = 0; gr < ng; ++gr)
pres[gr] = pgs[gr] == 0 ? 0 : ndistinct_string(px, po + pst[gr]-1, pgs[gr], 0, narm);
break;
}
default: error("Not Supported SEXP Type!");
}
}
UNPROTECT(1);
return res;
}
// Functions for Export --------------------------------------------------------
SEXP fndistinctC(SEXP x, SEXP g, SEXP Rnarm, SEXP Rnthreads) {
if(isNull(g)) return ndistinct_impl(x, asLogical(Rnarm));
if(TYPEOF(g) != VECSXP || !inherits(g, "GRP")) error("g needs to be an object of class 'GRP', see ?GRP");
const SEXP *restrict pg = SEXPPTR_RO(g), o = pg[6];
SEXP res;
int sorted = LOGICAL(pg[5])[1] == 1, ng = INTEGER(pg[0])[0], *restrict pgs = INTEGER(pg[2]), *restrict po, *restrict pst,
l = length(x), nthreads = asInteger(Rnthreads);
if(l != length(pg[1])) error("length(g) must match length(x)");
if(isNull(o)) {
int *cgs = (int *) R_alloc(ng+2, sizeof(int)), *restrict pgv = INTEGER(pg[1]); cgs[1] = 1;
for(int i = 0; i != ng; ++i) cgs[i+2] = cgs[i+1] + pgs[i];
pst = cgs + 1;
if(sorted) po = &l;
else {
int *restrict count = (int *) Calloc(ng+1, int);
po = (int *) R_alloc(l, sizeof(int)); --po;
for(int i = 0; i != l; ++i) po[cgs[pgv[i]] + count[pgv[i]]++] = i+1;
++po; Free(count);
}
} else {
po = INTEGER(o);
pst = INTEGER(getAttrib(o, install("starts")));
}
if(nthreads > max_threads) nthreads = max_threads;
PROTECT(res = ndistinct_g_impl(x, ng, pgs, po, pst, sorted, asLogical(Rnarm), nthreads));
if(OBJECT(x) == 0) copyMostAttrib(x, res);
else {
SEXP sym_label = install("label");
setAttrib(res, sym_label, getAttrib(x, sym_label));
}
UNPROTECT(1);
return res;
}<LOOP-END> <OMP-START>#pragma omp parallel for num_threads(nthreads)<OMP-END> |
SebKrantz/collapse/src/fndistinct.c | #pragma omp parallel for num_threads(nthreads) | 100 | pout[j] = ndistinct_impl_int(px[j], narm);
} else {
if(nthreads > l) nthreads = l;
<LOOP-START>for(int j = 0; j < l; ++j) pout[j] = ndistinct_impl_int(px[j], narm);
}
setAttrib(out, R_NamesSymbol, getAttrib(x, R_NamesSymbol));
UNPROTECT(1);
return out;
} else {
SEXP out = PROTECT(allocVector(VECSXP, l)), sym_label = PROTECT(install("label")), *restrict pout = SEXPPTR(out);
const SEXP *restrict px = SEXPPTR_RO(x);
if(isNull(g)) {
if(nthreads <= 1) {
for(int j = 0; j != l; ++j) pout[j] = ndistinct_impl(px[j], narm);
} else {
if(nthreads > l) nthreads = l;
#pragma omp parallel for num_threads(nthreads)
for(int j = 0; j < l; ++j) pout[j] = ndistinct_impl(px[j], narm);
}
// Not thread safe and thus taken out
for(int j = 0; j != l; ++j) {
SEXP xj = px[j];
if(OBJECT(xj) == 0) copyMostAttrib(xj, pout[j]);
else setAttrib(pout[j], sym_label, getAttrib(xj, sym_label));
}
DFcopyAttr(out, x, /*ng=*/0);
} else {
if(TYPEOF(g) != VECSXP || !inherits(g, "GRP")) error("g needs to be an object of class 'GRP', see ?GRP");
const SEXP *restrict pg = SEXPPTR_RO(g), o = pg[6];
int sorted = LOGICAL(pg[5])[1] == 1, ng = INTEGER(pg[0])[0], *restrict pgs = INTEGER(pg[2]), *restrict po, *restrict pst, gl = length(pg[1]);
if(isNull(o)) {
int *cgs = (int *) R_alloc(ng+2, sizeof(int)), *restrict pgv = INTEGER(pg[1]); cgs[1] = 1;
for(int i = 0; i != ng; ++i) cgs[i+2] = cgs[i+1] + pgs[i];
pst = cgs + 1;
if(sorted) po = &l;
else {
int *restrict count = (int *) Calloc(ng+1, int);
po = (int *) R_alloc(gl, sizeof(int)); --po;
for(int i = 0; i != gl; ++i) po[cgs[pgv[i]] + count[pgv[i]]++] = i+1;
++po; Free(count);
}
} else {
po = INTEGER(o);
pst = INTEGER(getAttrib(o, install("starts")));
}
for(int j = 0; j != l; ++j) {
SEXP xj = px[j];
if(length(xj) != gl) error("length(g) must match nrow(x)");
pout[j] = ndistinct_g_impl(xj, ng, pgs, po, pst, sorted, narm, nthreads);
if(OBJECT(xj) == 0) copyMostAttrib(xj, pout[j]);
else setAttrib(pout[j], sym_label, getAttrib(xj, sym_label));
}
DFcopyAttr(out, x, ng);
}
UNPROTECT(2);
return out;
}<LOOP-END> <OMP-START>#pragma omp parallel for num_threads(nthreads)<OMP-END> |
SebKrantz/collapse/src/fndistinct.c | #pragma omp parallel for num_threads(nthreads) | 100 | out[j] = ndistinct_impl(px[j], narm);
} else {
if(nthreads > l) nthreads = l;
<LOOP-START>for(int j = 0; j < l; ++j) pout[j] = ndistinct_impl(px[j], narm);
}
// Not thread safe and thus taken out
for(int j = 0; j != l; ++j) {
SEXP xj = px[j];
if(OBJECT(xj) == 0) copyMostAttrib(xj, pout[j]);
else setAttrib(pout[j], sym_label, getAttrib(xj, sym_label));
}<LOOP-END> <OMP-START>#pragma omp parallel for num_threads(nthreads)<OMP-END> |
SebKrantz/collapse/src/fndistinct.c | #pragma omp parallel for num_threads(nthreads) | 100 | col) nthreads = col;
switch(tx) {
case REALSXP: {
double *px = REAL(x);
<LOOP-START>for(int j = 0; j < col; ++j)
pres[j] = ndistinct_double(px + j*l, &l, l, 1, narm);
break;
}
case INTSXP: { // Factor matrix not well defined object...
int *px = INTEGER(x);
#pragma omp parallel for num_threads(nthreads)
for(int j = 0; j < col; ++j)
pres[j] = ndistinct_int(px + j*l, &l, l, 1, narm);
break;
}<LOOP-END> <OMP-START>#pragma omp parallel for num_threads(nthreads)<OMP-END> |
SebKrantz/collapse/src/fndistinct.c | #pragma omp parallel for num_threads(nthreads) | 100 | case INTSXP: { // Factor matrix not well defined object...
int *px = INTEGER(x);
<LOOP-START>for(int j = 0; j < col; ++j)
pres[j] = ndistinct_int(px + j*l, &l, l, 1, narm);
break;
}
case LGLSXP: {
int *px = INTEGER(x);
#pragma omp parallel for num_threads(nthreads)
for(int j = 0; j < col; ++j)
pres[j] = ndistinct_logi(px + j*l, &l, l, 1, narm);
break;
}<LOOP-END> <OMP-START>#pragma omp parallel for num_threads(nthreads)<OMP-END> |
SebKrantz/collapse/src/fndistinct.c | #pragma omp parallel for num_threads(nthreads) | 100 | &l, l, 1, narm);
break;
}
case LGLSXP: {
int *px = INTEGER(x);
<LOOP-START>for(int j = 0; j < col; ++j)
pres[j] = ndistinct_logi(px + j*l, &l, l, 1, narm);
break;
}
case STRSXP: {
SEXP *px = SEXPPTR(x);
#pragma omp parallel for num_threads(nthreads)
for(int j = 0; j < col; ++j)
pres[j] = ndistinct_string(px + j*l, &l, l, 1, narm);
break;
}<LOOP-END> <OMP-START>#pragma omp parallel for num_threads(nthreads)<OMP-END> |
SebKrantz/collapse/src/fndistinct.c | #pragma omp parallel for num_threads(nthreads) | 100 | &l, l, 1, narm);
break;
}
case STRSXP: {
SEXP *px = SEXPPTR(x);
<LOOP-START>for(int j = 0; j < col; ++j)
pres[j] = ndistinct_string(px + j*l, &l, l, 1, narm);
break;
}
default: error("Not Supported SEXP Type!");
}
matCopyAttr(res, x, Rdrop, /*ng=*/0);
UNPROTECT(1);
return res;
} else { // With groups
if(TYPEOF(g) != VECSXP || !inherits(g, "GRP")) error("g needs to be an object of class 'GRP', see ?GRP");
const SEXP *restrict pg = SEXPPTR_RO(g), o = pg[6];
int sorted = LOGICAL(pg[5])[1] == 1, ng = INTEGER(pg[0])[0], *restrict pgs = INTEGER(pg[2]), *restrict po, *restrict pst, gl = length(pg[1]);
if(l != gl) error("length(g) must match nrow(x)");
SEXP res = PROTECT(allocVector(INTSXP, col * ng));
int *restrict pres = INTEGER(res);
if(nthreads > col) nthreads = col; // column-level sufficient? or do sub-column level??
if(isNull(o)) {
int *cgs = (int *) R_alloc(ng+2, sizeof(int)), *restrict pgv = INTEGER(pg[1]); cgs[1] = 1;
for(int i = 0; i != ng; ++i) cgs[i+2] = cgs[i+1] + pgs[i];
pst = cgs + 1;
if(sorted) po = &l;
else {
int *restrict count = (int *) Calloc(ng+1, int);
po = (int *) R_alloc(l, sizeof(int)); --po;
for(int i = 0; i != l; ++i) po[cgs[pgv[i]] + count[pgv[i]]++] = i+1;
++po; Free(count);
}
} else {
po = INTEGER(o);
pst = INTEGER(getAttrib(o, install("starts")));
}
if(sorted) { // Sorted
switch(TYPEOF(x)) {
case REALSXP: {
double *px = REAL(x);
#pragma omp parallel for num_threads(nthreads)
for(int j = 0; j < col; ++j) {
int jng = j * ng;
double *pxj = px + j * l;
for(int gr = 0; gr < ng; ++gr)
pres[jng + gr] = pgs[gr] == 0 ? 0 : ndistinct_double(pxj + pst[gr]-1, po, pgs[gr], 1, narm);
}
break;
}
case INTSXP: { // Factor matrix not well defined object...
int *px = INTEGER(x);
#pragma omp parallel for num_threads(nthreads)
for(int j = 0; j < col; ++j) {
int *pxj = px + j * l, jng = j * ng;
for(int gr = 0; gr < ng; ++gr)
pres[jng + gr] = pgs[gr] == 0 ? 0 : ndistinct_int(pxj + pst[gr]-1, po, pgs[gr], 1, narm);
}
break;
}
case LGLSXP: {
int *px = LOGICAL(x);
#pragma omp parallel for num_threads(nthreads)
for(int j = 0; j < col; ++j) {
int *pxj = px + j * l, jng = j * ng;
for(int gr = 0; gr < ng; ++gr)
pres[jng + gr] = pgs[gr] == 0 ? 0 : ndistinct_logi(pxj + pst[gr]-1, po, pgs[gr], 1, narm);
}
break;
}
case STRSXP: {
SEXP *px = SEXPPTR(x);
#pragma omp parallel for num_threads(nthreads)
for(int j = 0; j < col; ++j) {
int jng = j * ng;
SEXP *pxj = px + j * l;
for(int gr = 0; gr < ng; ++gr)
pres[jng + gr] = pgs[gr] == 0 ? 0 : ndistinct_string(pxj + pst[gr]-1, po, pgs[gr], 1, narm);
}
break;
}
default: error("Not Supported SEXP Type!");
}
} else { // Not sorted. Perhaps reordering x is faster??
// Todo: perhaps going first by groups, then by columns is better? saves zero group size checks...
switch(TYPEOF(x)) {
case REALSXP: {
double *px = REAL(x);
#pragma omp parallel for num_threads(nthreads)
for(int j = 0; j < col; ++j) {
int jng = j * ng;
double *pxj = px + j * l;
for(int gr = 0; gr < ng; ++gr)
pres[jng + gr] = pgs[gr] == 0 ? 0 : ndistinct_double(pxj, po + pst[gr]-1, pgs[gr], 0, narm);
}
break;
}
case INTSXP: { // Factor matrix not well defined object...
int *px = INTEGER(x);
#pragma omp parallel for num_threads(nthreads)
for(int j = 0; j < col; ++j) {
int jng = j * ng, *pxj = px + j * l;
for(int gr = 0; gr < ng; ++gr)
pres[jng + gr] = pgs[gr] == 0 ? 0 : ndistinct_int(pxj, po + pst[gr]-1, pgs[gr], 0, narm);
}
break;
}
case LGLSXP: {
int *px = LOGICAL(x);
#pragma omp parallel for num_threads(nthreads)
for(int j = 0; j < col; ++j) {
int jng = j * ng, *pxj = px + j * l;
for(int gr = 0; gr < ng; ++gr)
pres[jng + gr] = pgs[gr] == 0 ? 0 : ndistinct_logi(pxj, po + pst[gr]-1, pgs[gr], 0, narm);
}
break;
}
case STRSXP: {
SEXP *px = SEXPPTR(x);
#pragma omp parallel for num_threads(nthreads)
for(int j = 0; j < col; ++j) {
int jng = j * ng;
SEXP *pxj = px + j * l;
for(int gr = 0; gr < ng; ++gr)
pres[jng + gr] = pgs[gr] == 0 ? 0 : ndistinct_string(pxj, po + pst[gr]-1, pgs[gr], 0, narm);
}
break;
}
default: error("Not Supported SEXP Type!");
}
}
matCopyAttr(res, x, Rdrop, ng);
UNPROTECT(1);
return res;
}<LOOP-END> <OMP-START>#pragma omp parallel for num_threads(nthreads)<OMP-END> |
SebKrantz/collapse/src/fndistinct.c | #pragma omp parallel for num_threads(nthreads) | 100 | Sorted
switch(TYPEOF(x)) {
case REALSXP: {
double *px = REAL(x);
<LOOP-START>for(int j = 0; j < col; ++j) {
int jng = j * ng;
double *pxj = px + j * l;
for(int gr = 0; gr < ng; ++gr)
pres[jng + gr] = pgs[gr] == 0 ? 0 : ndistinct_double(pxj + pst[gr]-1, po, pgs[gr], 1, narm);
}<LOOP-END> <OMP-START>#pragma omp parallel for num_threads(nthreads)<OMP-END> |
SebKrantz/collapse/src/fndistinct.c | #pragma omp parallel for num_threads(nthreads) | 100 | ase INTSXP: { // Factor matrix not well defined object...
int *px = INTEGER(x);
<LOOP-START>for(int j = 0; j < col; ++j) {
int *pxj = px + j * l, jng = j * ng;
for(int gr = 0; gr < ng; ++gr)
pres[jng + gr] = pgs[gr] == 0 ? 0 : ndistinct_int(pxj + pst[gr]-1, po, pgs[gr], 1, narm);
}<LOOP-END> <OMP-START>#pragma omp parallel for num_threads(nthreads)<OMP-END> |
SebKrantz/collapse/src/fndistinct.c | #pragma omp parallel for num_threads(nthreads) | 100 | }
break;
}
case LGLSXP: {
int *px = LOGICAL(x);
<LOOP-START>for(int j = 0; j < col; ++j) {
int *pxj = px + j * l, jng = j * ng;
for(int gr = 0; gr < ng; ++gr)
pres[jng + gr] = pgs[gr] == 0 ? 0 : ndistinct_logi(pxj + pst[gr]-1, po, pgs[gr], 1, narm);
}<LOOP-END> <OMP-START>#pragma omp parallel for num_threads(nthreads)<OMP-END> |
SebKrantz/collapse/src/fndistinct.c | #pragma omp parallel for num_threads(nthreads) | 100 | }
break;
}
case STRSXP: {
SEXP *px = SEXPPTR(x);
<LOOP-START>for(int j = 0; j < col; ++j) {
int jng = j * ng;
SEXP *pxj = px + j * l;
for(int gr = 0; gr < ng; ++gr)
pres[jng + gr] = pgs[gr] == 0 ? 0 : ndistinct_string(pxj + pst[gr]-1, po, pgs[gr], 1, narm);
}<LOOP-END> <OMP-START>#pragma omp parallel for num_threads(nthreads)<OMP-END> |
SebKrantz/collapse/src/fndistinct.c | #pragma omp parallel for num_threads(nthreads) | 100 | ecks...
switch(TYPEOF(x)) {
case REALSXP: {
double *px = REAL(x);
<LOOP-START>for(int j = 0; j < col; ++j) {
int jng = j * ng;
double *pxj = px + j * l;
for(int gr = 0; gr < ng; ++gr)
pres[jng + gr] = pgs[gr] == 0 ? 0 : ndistinct_double(pxj, po + pst[gr]-1, pgs[gr], 0, narm);
}<LOOP-END> <OMP-START>#pragma omp parallel for num_threads(nthreads)<OMP-END> |
SebKrantz/collapse/src/fndistinct.c | #pragma omp parallel for num_threads(nthreads) | 100 | ase INTSXP: { // Factor matrix not well defined object...
int *px = INTEGER(x);
<LOOP-START>for(int j = 0; j < col; ++j) {
int jng = j * ng, *pxj = px + j * l;
for(int gr = 0; gr < ng; ++gr)
pres[jng + gr] = pgs[gr] == 0 ? 0 : ndistinct_int(pxj, po + pst[gr]-1, pgs[gr], 0, narm);
}<LOOP-END> <OMP-START>#pragma omp parallel for num_threads(nthreads)<OMP-END> |
SebKrantz/collapse/src/fndistinct.c | #pragma omp parallel for num_threads(nthreads) | 100 | }
break;
}
case LGLSXP: {
int *px = LOGICAL(x);
<LOOP-START>for(int j = 0; j < col; ++j) {
int jng = j * ng, *pxj = px + j * l;
for(int gr = 0; gr < ng; ++gr)
pres[jng + gr] = pgs[gr] == 0 ? 0 : ndistinct_logi(pxj, po + pst[gr]-1, pgs[gr], 0, narm);
}<LOOP-END> <OMP-START>#pragma omp parallel for num_threads(nthreads)<OMP-END> |
SebKrantz/collapse/src/fndistinct.c | #pragma omp parallel for num_threads(nthreads) | 100 | }
break;
}
case STRSXP: {
SEXP *px = SEXPPTR(x);
<LOOP-START>for(int j = 0; j < col; ++j) {
int jng = j * ng;
SEXP *pxj = px + j * l;
for(int gr = 0; gr < ng; ++gr)
pres[jng + gr] = pgs[gr] == 0 ? 0 : ndistinct_string(pxj, po + pst[gr]-1, pgs[gr], 0, narm);
}<LOOP-END> <OMP-START>#pragma omp parallel for num_threads(nthreads)<OMP-END> |
SebKrantz/collapse/src/fmode.c | #pragma omp parallel for num_threads(nthreads) | 100 | &l;
switch(tx) {
case REALSXP: {
double *px = REAL(x), *pres = REAL(res);
<LOOP-START>for(int gr = 0; gr < ng; ++gr)
pres[gr] = pgs[gr] == 0 ? NA_REAL : mode_double(px + pst[gr]-1, po, pgs[gr], 1, narm, ret);
break;
}
case INTSXP: {
int *px = INTEGER(x), *pres = INTEGER(res);
if(isFactor(x) && nlevels(x) < l / ng * 3) {
int M = nlevels(x);
#pragma omp parallel for num_threads(nthreads)
for(int gr = 0; gr < ng; ++gr)
pres[gr] = pgs[gr] == 0 ? NA_INTEGER : mode_fct_logi(px + pst[gr]-1, po, pgs[gr], M, 1, narm, ret);
} else {
#pragma omp parallel for num_threads(nthreads)
for(int gr = 0; gr < ng; ++gr)
pres[gr] = pgs[gr] == 0 ? NA_INTEGER : mode_int(px + pst[gr]-1, po, pgs[gr], 1, narm, ret);
}
break;
}<LOOP-END> <OMP-START>#pragma omp parallel for num_threads(nthreads)<OMP-END> |
SebKrantz/collapse/src/fmode.c | #pragma omp parallel for num_threads(nthreads) | 100 | (res);
if(isFactor(x) && nlevels(x) < l / ng * 3) {
int M = nlevels(x);
<LOOP-START>for(int gr = 0; gr < ng; ++gr)
pres[gr] = pgs[gr] == 0 ? NA_INTEGER : mode_fct_logi(px + pst[gr]-1, po, pgs[gr], M, 1, narm, ret);
} else {
#pragma omp parallel for num_threads(nthreads)
for(int gr = 0; gr < ng; ++gr)
pres[gr] = pgs[gr] == 0 ? NA_INTEGER : mode_int(px + pst[gr]-1, po, pgs[gr], 1, narm, ret);
}<LOOP-END> <OMP-START>#pragma omp parallel for num_threads(nthreads)<OMP-END> |
SebKrantz/collapse/src/fmode.c | #pragma omp parallel for num_threads(nthreads) | 100 | A_INTEGER : mode_fct_logi(px + pst[gr]-1, po, pgs[gr], M, 1, narm, ret);
} else {
<LOOP-START>for(int gr = 0; gr < ng; ++gr)
pres[gr] = pgs[gr] == 0 ? NA_INTEGER : mode_int(px + pst[gr]-1, po, pgs[gr], 1, narm, ret);
}
break;
}
case LGLSXP: {
int *px = LOGICAL(x), *pres = LOGICAL(res);
#pragma omp parallel for num_threads(nthreads)
for(int gr = 0; gr < ng; ++gr)
pres[gr] = pgs[gr] == 0 ? NA_LOGICAL : mode_fct_logi(px + pst[gr]-1, po, pgs[gr], 1, 1, narm, ret);
break;
}<LOOP-END> <OMP-START>#pragma omp parallel for num_threads(nthreads)<OMP-END> |
SebKrantz/collapse/src/fmode.c | #pragma omp parallel for num_threads(nthreads) | 100 | break;
}
case LGLSXP: {
int *px = LOGICAL(x), *pres = LOGICAL(res);
<LOOP-START>for(int gr = 0; gr < ng; ++gr)
pres[gr] = pgs[gr] == 0 ? NA_LOGICAL : mode_fct_logi(px + pst[gr]-1, po, pgs[gr], 1, 1, narm, ret);
break;
}
case STRSXP: {
SEXP *px = SEXPPTR(x), *pres = SEXPPTR(res);
#pragma omp parallel for num_threads(nthreads)
for(int gr = 0; gr < ng; ++gr)
pres[gr] = pgs[gr] == 0 ? NA_STRING : mode_string(px + pst[gr]-1, po, pgs[gr], 1, narm, ret);
break;
}<LOOP-END> <OMP-START>#pragma omp parallel for num_threads(nthreads)<OMP-END> |
SebKrantz/collapse/src/fmode.c | #pragma omp parallel for num_threads(nthreads) | 100 | break;
}
case STRSXP: {
SEXP *px = SEXPPTR(x), *pres = SEXPPTR(res);
<LOOP-START>for(int gr = 0; gr < ng; ++gr)
pres[gr] = pgs[gr] == 0 ? NA_STRING : mode_string(px + pst[gr]-1, po, pgs[gr], 1, narm, ret);
break;
}
default: error("Not Supported SEXP Type: '%s'", type2char(tx));
}
} else { // Not sorted. Perhaps reordering x is faster??
switch(tx) {
case REALSXP: {
double *px = REAL(x), *pres = REAL(res);
#pragma omp parallel for num_threads(nthreads)
for(int gr = 0; gr < ng; ++gr)
pres[gr] = pgs[gr] == 0 ? NA_REAL : mode_double(px, po + pst[gr]-1, pgs[gr], 0, narm, ret);
break;
}
case INTSXP: {
int *px = INTEGER(x), *pres = INTEGER(res);
if(isFactor(x) && nlevels(x) < l / ng * 3) {
int M = nlevels(x);
#pragma omp parallel for num_threads(nthreads)
for(int gr = 0; gr < ng; ++gr)
pres[gr] = pgs[gr] == 0 ? NA_INTEGER : mode_fct_logi(px, po + pst[gr]-1, pgs[gr], M, 0, narm, ret);
} else {
#pragma omp parallel for num_threads(nthreads)
for(int gr = 0; gr < ng; ++gr)
pres[gr] = pgs[gr] == 0 ? NA_INTEGER : mode_int(px, po + pst[gr]-1, pgs[gr], 0, narm, ret);
}
break;
}
case LGLSXP: {
int *px = LOGICAL(x), *pres = LOGICAL(res);
#pragma omp parallel for num_threads(nthreads)
for(int gr = 0; gr < ng; ++gr)
pres[gr] = pgs[gr] == 0 ? NA_LOGICAL : mode_fct_logi(px, po + pst[gr]-1, pgs[gr], 1, 0, narm, ret);
break;
}
case STRSXP: {
SEXP *px = SEXPPTR(x), *pres = SEXPPTR(res);
#pragma omp parallel for num_threads(nthreads)
for(int gr = 0; gr < ng; ++gr)
pres[gr] = pgs[gr] == 0 ? NA_STRING : mode_string(px, po + pst[gr]-1, pgs[gr], 0, narm, ret);
break;
}
default: error("Not Supported SEXP Type: '%s'", type2char(tx));
}
}<LOOP-END> <OMP-START>#pragma omp parallel for num_threads(nthreads)<OMP-END> |
SebKrantz/collapse/src/fmode.c | #pragma omp parallel for num_threads(nthreads) | 100 | r??
switch(tx) {
case REALSXP: {
double *px = REAL(x), *pres = REAL(res);
<LOOP-START>for(int gr = 0; gr < ng; ++gr)
pres[gr] = pgs[gr] == 0 ? NA_REAL : mode_double(px, po + pst[gr]-1, pgs[gr], 0, narm, ret);
break;
}
case INTSXP: {
int *px = INTEGER(x), *pres = INTEGER(res);
if(isFactor(x) && nlevels(x) < l / ng * 3) {
int M = nlevels(x);
#pragma omp parallel for num_threads(nthreads)
for(int gr = 0; gr < ng; ++gr)
pres[gr] = pgs[gr] == 0 ? NA_INTEGER : mode_fct_logi(px, po + pst[gr]-1, pgs[gr], M, 0, narm, ret);
} else {
#pragma omp parallel for num_threads(nthreads)
for(int gr = 0; gr < ng; ++gr)
pres[gr] = pgs[gr] == 0 ? NA_INTEGER : mode_int(px, po + pst[gr]-1, pgs[gr], 0, narm, ret);
}
break;
}<LOOP-END> <OMP-START>#pragma omp parallel for num_threads(nthreads)<OMP-END> |
SebKrantz/collapse/src/fmode.c | #pragma omp parallel for num_threads(nthreads) | 100 | (res);
if(isFactor(x) && nlevels(x) < l / ng * 3) {
int M = nlevels(x);
<LOOP-START>for(int gr = 0; gr < ng; ++gr)
pres[gr] = pgs[gr] == 0 ? NA_INTEGER : mode_fct_logi(px, po + pst[gr]-1, pgs[gr], M, 0, narm, ret);
} else {
#pragma omp parallel for num_threads(nthreads)
for(int gr = 0; gr < ng; ++gr)
pres[gr] = pgs[gr] == 0 ? NA_INTEGER : mode_int(px, po + pst[gr]-1, pgs[gr], 0, narm, ret);
}<LOOP-END> <OMP-START>#pragma omp parallel for num_threads(nthreads)<OMP-END> |
SebKrantz/collapse/src/fmode.c | #pragma omp parallel for num_threads(nthreads) | 100 | A_INTEGER : mode_fct_logi(px, po + pst[gr]-1, pgs[gr], M, 0, narm, ret);
} else {
<LOOP-START>for(int gr = 0; gr < ng; ++gr)
pres[gr] = pgs[gr] == 0 ? NA_INTEGER : mode_int(px, po + pst[gr]-1, pgs[gr], 0, narm, ret);
}
break;
}
case LGLSXP: {
int *px = LOGICAL(x), *pres = LOGICAL(res);
#pragma omp parallel for num_threads(nthreads)
for(int gr = 0; gr < ng; ++gr)
pres[gr] = pgs[gr] == 0 ? NA_LOGICAL : mode_fct_logi(px, po + pst[gr]-1, pgs[gr], 1, 0, narm, ret);
break;
}<LOOP-END> <OMP-START>#pragma omp parallel for num_threads(nthreads)<OMP-END> |
SebKrantz/collapse/src/fmode.c | #pragma omp parallel for num_threads(nthreads) | 100 | break;
}
case LGLSXP: {
int *px = LOGICAL(x), *pres = LOGICAL(res);
<LOOP-START>for(int gr = 0; gr < ng; ++gr)
pres[gr] = pgs[gr] == 0 ? NA_LOGICAL : mode_fct_logi(px, po + pst[gr]-1, pgs[gr], 1, 0, narm, ret);
break;
}
case STRSXP: {
SEXP *px = SEXPPTR(x), *pres = SEXPPTR(res);
#pragma omp parallel for num_threads(nthreads)
for(int gr = 0; gr < ng; ++gr)
pres[gr] = pgs[gr] == 0 ? NA_STRING : mode_string(px, po + pst[gr]-1, pgs[gr], 0, narm, ret);
break;
}<LOOP-END> <OMP-START>#pragma omp parallel for num_threads(nthreads)<OMP-END> |
SebKrantz/collapse/src/fmode.c | #pragma omp parallel for num_threads(nthreads) | 100 | break;
}
case STRSXP: {
SEXP *px = SEXPPTR(x), *pres = SEXPPTR(res);
<LOOP-START>for(int gr = 0; gr < ng; ++gr)
pres[gr] = pgs[gr] == 0 ? NA_STRING : mode_string(px, po + pst[gr]-1, pgs[gr], 0, narm, ret);
break;
}
default: error("Not Supported SEXP Type: '%s'", type2char(tx));
}
}
copyMostAttrib(x, res);
UNPROTECT(1);
return res;
}
SEXP w_mode_g_impl(SEXP x, double *pw, int ng, int *pgs, int *po, int *pst, int sorted, int narm, int ret, int nthreads) {
int l = length(x), tx = TYPEOF(x);
if(nthreads > ng) nthreads = ng;
SEXP res = PROTECT(allocVector(tx, ng));
if(sorted) { // Sorted: could compute cumulative group size (= starts) on the fly... but doesn't work multithreaded...
po = &l;
switch(tx) {
case REALSXP: {
double *px = REAL(x), *pres = REAL(res);
#pragma omp parallel for num_threads(nthreads)
for(int gr = 0; gr < ng; ++gr)
pres[gr] = pgs[gr] == 0 ? NA_REAL : w_mode_double(px + pst[gr]-1, pw + pst[gr]-1, po, pgs[gr], 1, narm, ret);
break;
}
case INTSXP: {
int *px = INTEGER(x), *pres = INTEGER(res);
if(isFactor(x) && nlevels(x) < l / ng * 3) {
int M = nlevels(x);
#pragma omp parallel for num_threads(nthreads)
for(int gr = 0; gr < ng; ++gr)
pres[gr] = pgs[gr] == 0 ? NA_INTEGER : w_mode_fct_logi(px + pst[gr]-1, pw + pst[gr]-1, po, pgs[gr], M, 1, narm, ret);
} else {
#pragma omp parallel for num_threads(nthreads)
for(int gr = 0; gr < ng; ++gr)
pres[gr] = pgs[gr] == 0 ? NA_INTEGER : w_mode_int(px + pst[gr]-1, pw + pst[gr]-1, po, pgs[gr], 1, narm, ret);
}
break;
}
case LGLSXP: {
int *px = LOGICAL(x), *pres = LOGICAL(res);
#pragma omp parallel for num_threads(nthreads)
for(int gr = 0; gr < ng; ++gr)
pres[gr] = pgs[gr] == 0 ? NA_LOGICAL : w_mode_fct_logi(px + pst[gr]-1, pw + pst[gr]-1, po, pgs[gr], 1, 1, narm, ret);
break;
}
case STRSXP: {
SEXP *px = SEXPPTR(x), *pres = SEXPPTR(res);
#pragma omp parallel for num_threads(nthreads)
for(int gr = 0; gr < ng; ++gr)
pres[gr] = pgs[gr] == 0 ? NA_STRING : w_mode_string(px + pst[gr]-1, pw + pst[gr]-1, po, pgs[gr], 1, narm, ret);
break;
}
default: error("Not Supported SEXP Type: '%s'", type2char(tx));
}
} else { // Not sorted. Perhaps reordering x is faster??
switch(tx) {
case REALSXP: {
double *px = REAL(x), *pres = REAL(res);
#pragma omp parallel for num_threads(nthreads)
for(int gr = 0; gr < ng; ++gr)
pres[gr] = pgs[gr] == 0 ? NA_REAL : w_mode_double(px, pw, po + pst[gr]-1, pgs[gr], 0, narm, ret);
break;
}
case INTSXP: {
int *px = INTEGER(x), *pres = INTEGER(res);
if(isFactor(x) && nlevels(x) < l / ng * 3) {
int M = nlevels(x);
#pragma omp parallel for num_threads(nthreads)
for(int gr = 0; gr < ng; ++gr)
pres[gr] = pgs[gr] == 0 ? NA_INTEGER : w_mode_fct_logi(px, pw, po + pst[gr]-1, pgs[gr], M, 0, narm, ret);
} else {
#pragma omp parallel for num_threads(nthreads)
for(int gr = 0; gr < ng; ++gr)
pres[gr] = pgs[gr] == 0 ? NA_INTEGER : w_mode_int(px, pw, po + pst[gr]-1, pgs[gr], 0, narm, ret);
}
break;
}
case LGLSXP: {
int *px = LOGICAL(x), *pres = LOGICAL(res);
#pragma omp parallel for num_threads(nthreads)
for(int gr = 0; gr < ng; ++gr)
pres[gr] = pgs[gr] == 0 ? NA_LOGICAL : w_mode_fct_logi(px, pw, po + pst[gr]-1, pgs[gr], 1, 0, narm, ret);
break;
}
case STRSXP: {
SEXP *px = SEXPPTR(x), *pres = SEXPPTR(res);
#pragma omp parallel for num_threads(nthreads)
for(int gr = 0; gr < ng; ++gr)
pres[gr] = pgs[gr] == 0 ? NA_STRING : w_mode_string(px, pw, po + pst[gr]-1, pgs[gr], 0, narm, ret);
break;
}
default: error("Not Supported SEXP Type: '%s'", type2char(tx));
}
}
copyMostAttrib(x, res);
UNPROTECT(1);
return res;
}<LOOP-END> <OMP-START>#pragma omp parallel for num_threads(nthreads)<OMP-END> |
SebKrantz/collapse/src/fmode.c | #pragma omp parallel for num_threads(nthreads) | 100 | &l;
switch(tx) {
case REALSXP: {
double *px = REAL(x), *pres = REAL(res);
<LOOP-START>for(int gr = 0; gr < ng; ++gr)
pres[gr] = pgs[gr] == 0 ? NA_REAL : w_mode_double(px + pst[gr]-1, pw + pst[gr]-1, po, pgs[gr], 1, narm, ret);
break;
}
case INTSXP: {
int *px = INTEGER(x), *pres = INTEGER(res);
if(isFactor(x) && nlevels(x) < l / ng * 3) {
int M = nlevels(x);
#pragma omp parallel for num_threads(nthreads)
for(int gr = 0; gr < ng; ++gr)
pres[gr] = pgs[gr] == 0 ? NA_INTEGER : w_mode_fct_logi(px + pst[gr]-1, pw + pst[gr]-1, po, pgs[gr], M, 1, narm, ret);
} else {
#pragma omp parallel for num_threads(nthreads)
for(int gr = 0; gr < ng; ++gr)
pres[gr] = pgs[gr] == 0 ? NA_INTEGER : w_mode_int(px + pst[gr]-1, pw + pst[gr]-1, po, pgs[gr], 1, narm, ret);
}
break;
}<LOOP-END> <OMP-START>#pragma omp parallel for num_threads(nthreads)<OMP-END> |
SebKrantz/collapse/src/fmode.c | #pragma omp parallel for num_threads(nthreads) | 100 | (res);
if(isFactor(x) && nlevels(x) < l / ng * 3) {
int M = nlevels(x);
<LOOP-START>for(int gr = 0; gr < ng; ++gr)
pres[gr] = pgs[gr] == 0 ? NA_INTEGER : w_mode_fct_logi(px + pst[gr]-1, pw + pst[gr]-1, po, pgs[gr], M, 1, narm, ret);
} else {
#pragma omp parallel for num_threads(nthreads)
for(int gr = 0; gr < ng; ++gr)
pres[gr] = pgs[gr] == 0 ? NA_INTEGER : w_mode_int(px + pst[gr]-1, pw + pst[gr]-1, po, pgs[gr], 1, narm, ret);
}<LOOP-END> <OMP-START>#pragma omp parallel for num_threads(nthreads)<OMP-END> |
SebKrantz/collapse/src/fmode.c | #pragma omp parallel for num_threads(nthreads) | 100 | _fct_logi(px + pst[gr]-1, pw + pst[gr]-1, po, pgs[gr], M, 1, narm, ret);
} else {
<LOOP-START>for(int gr = 0; gr < ng; ++gr)
pres[gr] = pgs[gr] == 0 ? NA_INTEGER : w_mode_int(px + pst[gr]-1, pw + pst[gr]-1, po, pgs[gr], 1, narm, ret);
}
break;
}
case LGLSXP: {
int *px = LOGICAL(x), *pres = LOGICAL(res);
#pragma omp parallel for num_threads(nthreads)
for(int gr = 0; gr < ng; ++gr)
pres[gr] = pgs[gr] == 0 ? NA_LOGICAL : w_mode_fct_logi(px + pst[gr]-1, pw + pst[gr]-1, po, pgs[gr], 1, 1, narm, ret);
break;
}<LOOP-END> <OMP-START>#pragma omp parallel for num_threads(nthreads)<OMP-END> |
SebKrantz/collapse/src/fmode.c | #pragma omp parallel for num_threads(nthreads) | 100 | break;
}
case LGLSXP: {
int *px = LOGICAL(x), *pres = LOGICAL(res);
<LOOP-START>for(int gr = 0; gr < ng; ++gr)
pres[gr] = pgs[gr] == 0 ? NA_LOGICAL : w_mode_fct_logi(px + pst[gr]-1, pw + pst[gr]-1, po, pgs[gr], 1, 1, narm, ret);
break;
}
case STRSXP: {
SEXP *px = SEXPPTR(x), *pres = SEXPPTR(res);
#pragma omp parallel for num_threads(nthreads)
for(int gr = 0; gr < ng; ++gr)
pres[gr] = pgs[gr] == 0 ? NA_STRING : w_mode_string(px + pst[gr]-1, pw + pst[gr]-1, po, pgs[gr], 1, narm, ret);
break;
}<LOOP-END> <OMP-START>#pragma omp parallel for num_threads(nthreads)<OMP-END> |
SebKrantz/collapse/src/fmode.c | #pragma omp parallel for num_threads(nthreads) | 100 | break;
}
case STRSXP: {
SEXP *px = SEXPPTR(x), *pres = SEXPPTR(res);
<LOOP-START>for(int gr = 0; gr < ng; ++gr)
pres[gr] = pgs[gr] == 0 ? NA_STRING : w_mode_string(px + pst[gr]-1, pw + pst[gr]-1, po, pgs[gr], 1, narm, ret);
break;
}
default: error("Not Supported SEXP Type: '%s'", type2char(tx));
}
} else { // Not sorted. Perhaps reordering x is faster??
switch(tx) {
case REALSXP: {
double *px = REAL(x), *pres = REAL(res);
#pragma omp parallel for num_threads(nthreads)
for(int gr = 0; gr < ng; ++gr)
pres[gr] = pgs[gr] == 0 ? NA_REAL : w_mode_double(px, pw, po + pst[gr]-1, pgs[gr], 0, narm, ret);
break;
}
case INTSXP: {
int *px = INTEGER(x), *pres = INTEGER(res);
if(isFactor(x) && nlevels(x) < l / ng * 3) {
int M = nlevels(x);
#pragma omp parallel for num_threads(nthreads)
for(int gr = 0; gr < ng; ++gr)
pres[gr] = pgs[gr] == 0 ? NA_INTEGER : w_mode_fct_logi(px, pw, po + pst[gr]-1, pgs[gr], M, 0, narm, ret);
} else {
#pragma omp parallel for num_threads(nthreads)
for(int gr = 0; gr < ng; ++gr)
pres[gr] = pgs[gr] == 0 ? NA_INTEGER : w_mode_int(px, pw, po + pst[gr]-1, pgs[gr], 0, narm, ret);
}
break;
}
case LGLSXP: {
int *px = LOGICAL(x), *pres = LOGICAL(res);
#pragma omp parallel for num_threads(nthreads)
for(int gr = 0; gr < ng; ++gr)
pres[gr] = pgs[gr] == 0 ? NA_LOGICAL : w_mode_fct_logi(px, pw, po + pst[gr]-1, pgs[gr], 1, 0, narm, ret);
break;
}
case STRSXP: {
SEXP *px = SEXPPTR(x), *pres = SEXPPTR(res);
#pragma omp parallel for num_threads(nthreads)
for(int gr = 0; gr < ng; ++gr)
pres[gr] = pgs[gr] == 0 ? NA_STRING : w_mode_string(px, pw, po + pst[gr]-1, pgs[gr], 0, narm, ret);
break;
}
default: error("Not Supported SEXP Type: '%s'", type2char(tx));
}
}<LOOP-END> <OMP-START>#pragma omp parallel for num_threads(nthreads)<OMP-END> |
SebKrantz/collapse/src/fmode.c | #pragma omp parallel for num_threads(nthreads) | 100 | r??
switch(tx) {
case REALSXP: {
double *px = REAL(x), *pres = REAL(res);
<LOOP-START>for(int gr = 0; gr < ng; ++gr)
pres[gr] = pgs[gr] == 0 ? NA_REAL : w_mode_double(px, pw, po + pst[gr]-1, pgs[gr], 0, narm, ret);
break;
}
case INTSXP: {
int *px = INTEGER(x), *pres = INTEGER(res);
if(isFactor(x) && nlevels(x) < l / ng * 3) {
int M = nlevels(x);
#pragma omp parallel for num_threads(nthreads)
for(int gr = 0; gr < ng; ++gr)
pres[gr] = pgs[gr] == 0 ? NA_INTEGER : w_mode_fct_logi(px, pw, po + pst[gr]-1, pgs[gr], M, 0, narm, ret);
} else {
#pragma omp parallel for num_threads(nthreads)
for(int gr = 0; gr < ng; ++gr)
pres[gr] = pgs[gr] == 0 ? NA_INTEGER : w_mode_int(px, pw, po + pst[gr]-1, pgs[gr], 0, narm, ret);
}
break;
}<LOOP-END> <OMP-START>#pragma omp parallel for num_threads(nthreads)<OMP-END> |
SebKrantz/collapse/src/fmode.c | #pragma omp parallel for num_threads(nthreads) | 100 | (res);
if(isFactor(x) && nlevels(x) < l / ng * 3) {
int M = nlevels(x);
<LOOP-START>for(int gr = 0; gr < ng; ++gr)
pres[gr] = pgs[gr] == 0 ? NA_INTEGER : w_mode_fct_logi(px, pw, po + pst[gr]-1, pgs[gr], M, 0, narm, ret);
} else {
#pragma omp parallel for num_threads(nthreads)
for(int gr = 0; gr < ng; ++gr)
pres[gr] = pgs[gr] == 0 ? NA_INTEGER : w_mode_int(px, pw, po + pst[gr]-1, pgs[gr], 0, narm, ret);
}<LOOP-END> <OMP-START>#pragma omp parallel for num_threads(nthreads)<OMP-END> |
SebKrantz/collapse/src/fmode.c | #pragma omp parallel for num_threads(nthreads) | 100 | GER : w_mode_fct_logi(px, pw, po + pst[gr]-1, pgs[gr], M, 0, narm, ret);
} else {
<LOOP-START>for(int gr = 0; gr < ng; ++gr)
pres[gr] = pgs[gr] == 0 ? NA_INTEGER : w_mode_int(px, pw, po + pst[gr]-1, pgs[gr], 0, narm, ret);
}
break;
}
case LGLSXP: {
int *px = LOGICAL(x), *pres = LOGICAL(res);
#pragma omp parallel for num_threads(nthreads)
for(int gr = 0; gr < ng; ++gr)
pres[gr] = pgs[gr] == 0 ? NA_LOGICAL : w_mode_fct_logi(px, pw, po + pst[gr]-1, pgs[gr], 1, 0, narm, ret);
break;
}<LOOP-END> <OMP-START>#pragma omp parallel for num_threads(nthreads)<OMP-END> |
SebKrantz/collapse/src/fmode.c | #pragma omp parallel for num_threads(nthreads) | 100 | break;
}
case LGLSXP: {
int *px = LOGICAL(x), *pres = LOGICAL(res);
<LOOP-START>for(int gr = 0; gr < ng; ++gr)
pres[gr] = pgs[gr] == 0 ? NA_LOGICAL : w_mode_fct_logi(px, pw, po + pst[gr]-1, pgs[gr], 1, 0, narm, ret);
break;
}
case STRSXP: {
SEXP *px = SEXPPTR(x), *pres = SEXPPTR(res);
#pragma omp parallel for num_threads(nthreads)
for(int gr = 0; gr < ng; ++gr)
pres[gr] = pgs[gr] == 0 ? NA_STRING : w_mode_string(px, pw, po + pst[gr]-1, pgs[gr], 0, narm, ret);
break;
}<LOOP-END> <OMP-START>#pragma omp parallel for num_threads(nthreads)<OMP-END> |
SebKrantz/collapse/src/fmode.c | #pragma omp parallel for num_threads(nthreads) | 100 | break;
}
case STRSXP: {
SEXP *px = SEXPPTR(x), *pres = SEXPPTR(res);
<LOOP-START>for(int gr = 0; gr < ng; ++gr)
pres[gr] = pgs[gr] == 0 ? NA_STRING : w_mode_string(px, pw, po + pst[gr]-1, pgs[gr], 0, narm, ret);
break;
}
default: error("Not Supported SEXP Type: '%s'", type2char(tx));
}
}
copyMostAttrib(x, res);
UNPROTECT(1);
return res;
}
// Functions for Export --------------------------------------------------------
SEXP fmodeC(SEXP x, SEXP g, SEXP w, SEXP Rnarm, SEXP Rret, SEXP Rnthreads) {
int nullg = isNull(g), nullw = isNull(w), l = length(x), nprotect = 0;
if(l <= 1) return x;
if(nullg && nullw) return mode_impl(x, asLogical(Rnarm), asInteger(Rret));
double tmp = 0.0, *restrict pw = &tmp;
if(!nullw) {
if(length(w) != l) error("length(w) must match length(x)");
if(TYPEOF(w) != REALSXP) {
if(!(TYPEOF(w) == INTSXP || TYPEOF(w) == LGLSXP)) error("weights need to be double or integer/logical (internally coerced to double)");
w = PROTECT(coerceVector(w, REALSXP)); ++nprotect;
}
pw = REAL(w);
}
if(nullg) {
// if(TYPEOF(w) != REALSXP)
UNPROTECT(nprotect);
return w_mode_impl(x, pw, asLogical(Rnarm), asInteger(Rret));
}
if(TYPEOF(g) != VECSXP || !inherits(g, "GRP")) error("g needs to be an object of class 'GRP', see ?GRP");
const SEXP *restrict pg = SEXPPTR_RO(g), o = pg[6];
int sorted = LOGICAL(pg[5])[1] == 1, ng = INTEGER(pg[0])[0], *restrict pgs = INTEGER(pg[2]), *restrict po, *restrict pst, nthreads = asInteger(Rnthreads);
if(l != length(pg[1])) error("length(g) must match length(x)");
if(isNull(o)) {
int *cgs = (int *) R_alloc(ng+2, sizeof(int)), *restrict pgv = INTEGER(pg[1]); cgs[1] = 1;
for(int i = 0; i != ng; ++i) cgs[i+2] = cgs[i+1] + pgs[i];
pst = cgs + 1;
if(sorted) po = &l;
else {
int *restrict count = (int *) Calloc(ng+1, int);
po = (int *) R_alloc(l, sizeof(int)); --po;
for(int i = 0; i != l; ++i) po[cgs[pgv[i]] + count[pgv[i]]++] = i+1;
++po; Free(count);
}
} else {
po = INTEGER(o);
pst = INTEGER(getAttrib(o, install("starts")));
}
// if(nullw) return mode_g_impl(x, ng, pgs, po, pst, sorted, asLogical(Rnarm), asInteger(Rret), asInteger(Rnthreads));
// if(TYPEOF(w) != REALSXP) UNPROTECT(nprotect);
// return w_mode_g_impl(x, pw, ng, pgs, po, pst, sorted, asLogical(Rnarm), asInteger(Rret), asInteger(Rnthreads));
// Thomas Kalibera Patch:
if(nthreads > max_threads) nthreads = max_threads;
SEXP res;
if(nullw) res = mode_g_impl(x, ng, pgs, po, pst, sorted, asLogical(Rnarm), asInteger(Rret), nthreads);
else res = w_mode_g_impl(x, pw, ng, pgs, po, pst, sorted, asLogical(Rnarm), asInteger(Rret), nthreads);
UNPROTECT(nprotect);
return res;
}<LOOP-END> <OMP-START>#pragma omp parallel for num_threads(nthreads)<OMP-END> |
SebKrantz/collapse/src/fmode.c | #pragma omp parallel for num_threads(nthreads) | 100 | <= 1) {
for(int j = 0; j != l; ++j) pout[j] = mode_impl(px[j], narm, ret);
} else {
<LOOP-START>for(int j = 0; j < l; ++j) pout[j] = mode_impl_plain(px[j], narm, ret);
for(int j = 0; j != l; ++j) copyMostAttrib(px[j], pout[j]); // Not thread safe and thus taken out...
}
} else {
int nrx = length(px[0]);
double tmp = 0.0, *restrict pw = &tmp;
if(!nullw) {
if(length(w) != nrx) error("length(w) must match nrow(x)");
if(TYPEOF(w) != REALSXP) {
if(!(TYPEOF(w) == INTSXP || TYPEOF(w) == LGLSXP)) error("weights need to be double or integer/logical (internally coerced to double)");
w = PROTECT(coerceVector(w, REALSXP)); ++nprotect;
}
pw = REAL(w);
}
if(nullg) {
if(nthreads <= 1) {
for(int j = 0; j != l; ++j) pout[j] = w_mode_impl(px[j], pw, narm, ret);
} else {
#pragma omp parallel for num_threads(nthreads)
for(int j = 0; j < l; ++j) pout[j] = w_mode_impl_plain(px[j], pw, narm, ret);
for(int j = 0; j != l; ++j) copyMostAttrib(px[j], pout[j]); // Not thread safe and thus taken out...
}
} else {
if(TYPEOF(g) != VECSXP || !inherits(g, "GRP")) error("g needs to be an object of class 'GRP', see ?GRP");
const SEXP *restrict pg = SEXPPTR_RO(g), o = pg[6];
ng = INTEGER(pg[0])[0];
int sorted = LOGICAL(pg[5])[1] == 1, *restrict pgs = INTEGER(pg[2]), *restrict po, *restrict pst;
if(nrx != length(pg[1])) error("length(g) must match nrow(x)");
if(isNull(o)) {
int *cgs = (int *) R_alloc(ng+2, sizeof(int)), *restrict pgv = INTEGER(pg[1]); cgs[1] = 1;
for(int i = 0; i != ng; ++i) cgs[i+2] = cgs[i+1] + pgs[i];
pst = cgs + 1;
if(sorted) po = &l;
else {
int *restrict count = (int *) Calloc(ng+1, int);
po = (int *) R_alloc(nrx, sizeof(int)); --po;
for(int i = 0; i != nrx; ++i) po[cgs[pgv[i]] + count[pgv[i]]++] = i+1;
++po; Free(count);
}
} else {
po = INTEGER(o);
pst = INTEGER(getAttrib(o, install("starts")));
}
if(nullw) { // Parallelism at sub-column level
for(int j = 0; j < l; ++j) pout[j] = mode_g_impl(px[j], ng, pgs, po, pst, sorted, narm, ret, nthreads);
} else { // Parallelism at sub-column level
for(int j = 0; j < l; ++j) pout[j] = w_mode_g_impl(px[j], pw, ng, pgs, po, pst, sorted, narm, ret, nthreads);
}
}
}<LOOP-END> <OMP-START>#pragma omp parallel for num_threads(nthreads)<OMP-END> |
SebKrantz/collapse/src/fmode.c | #pragma omp parallel for num_threads(nthreads) | 100 | for(int j = 0; j != l; ++j) pout[j] = w_mode_impl(px[j], pw, narm, ret);
} else {
<LOOP-START>for(int j = 0; j < l; ++j) pout[j] = w_mode_impl_plain(px[j], pw, narm, ret);
for(int j = 0; j != l; ++j) copyMostAttrib(px[j], pout[j]); // Not thread safe and thus taken out...
}
} else {
if(TYPEOF(g) != VECSXP || !inherits(g, "GRP")) error("g needs to be an object of class 'GRP', see ?GRP");
const SEXP *restrict pg = SEXPPTR_RO(g), o = pg[6];
ng = INTEGER(pg[0])[0];
int sorted = LOGICAL(pg[5])[1] == 1, *restrict pgs = INTEGER(pg[2]), *restrict po, *restrict pst;
if(nrx != length(pg[1])) error("length(g) must match nrow(x)");
if(isNull(o)) {
int *cgs = (int *) R_alloc(ng+2, sizeof(int)), *restrict pgv = INTEGER(pg[1]); cgs[1] = 1;
for(int i = 0; i != ng; ++i) cgs[i+2] = cgs[i+1] + pgs[i];
pst = cgs + 1;
if(sorted) po = &l;
else {
int *restrict count = (int *) Calloc(ng+1, int);
po = (int *) R_alloc(nrx, sizeof(int)); --po;
for(int i = 0; i != nrx; ++i) po[cgs[pgv[i]] + count[pgv[i]]++] = i+1;
++po; Free(count);
}
} else {
po = INTEGER(o);
pst = INTEGER(getAttrib(o, install("starts")));
}
if(nullw) { // Parallelism at sub-column level
for(int j = 0; j < l; ++j) pout[j] = mode_g_impl(px[j], ng, pgs, po, pst, sorted, narm, ret, nthreads);
} else { // Parallelism at sub-column level
for(int j = 0; j < l; ++j) pout[j] = w_mode_g_impl(px[j], pw, ng, pgs, po, pst, sorted, narm, ret, nthreads);
}
}<LOOP-END> <OMP-START>#pragma omp parallel for num_threads(nthreads)<OMP-END> |
SebKrantz/collapse/src/fmode.c | #pragma omp parallel for num_threads(nthreads) | 100 | REALSXP: {
double *px = REAL(x), *restrict pres = REAL(res);
if(nullw) {
<LOOP-START>for(int j = 0; j < col; ++j) pres[j] = mode_double(px + j*l, &l, l, 1, narm, ret);
} else {
#pragma omp parallel for num_threads(nthreads)
for(int j = 0; j < col; ++j) pres[j] = w_mode_double(px + j*l, pw, &l, l, 1, narm, ret);
}<LOOP-END> <OMP-START>#pragma omp parallel for num_threads(nthreads)<OMP-END> |
SebKrantz/collapse/src/fmode.c | #pragma omp parallel for num_threads(nthreads) | 100 | = 0; j < col; ++j) pres[j] = mode_double(px + j*l, &l, l, 1, narm, ret);
} else {
<LOOP-START>for(int j = 0; j < col; ++j) pres[j] = w_mode_double(px + j*l, pw, &l, l, 1, narm, ret);
}
break;
}
case INTSXP: { // Factor matrix not well defined object...
int *px = INTEGER(x), *restrict pres = INTEGER(res);
if(nullw) {
#pragma omp parallel for num_threads(nthreads)
for(int j = 0; j < col; ++j) pres[j] = mode_int(px + j*l, &l, l, 1, narm, ret);
} else {
#pragma omp parallel for num_threads(nthreads)
for(int j = 0; j < col; ++j) pres[j] = w_mode_int(px + j*l, pw, &l, l, 1, narm, ret);
}
break;
}<LOOP-END> <OMP-START>#pragma omp parallel for num_threads(nthreads)<OMP-END> |
SebKrantz/collapse/src/fmode.c | #pragma omp parallel for num_threads(nthreads) | 100 | bject...
int *px = INTEGER(x), *restrict pres = INTEGER(res);
if(nullw) {
<LOOP-START>for(int j = 0; j < col; ++j) pres[j] = mode_int(px + j*l, &l, l, 1, narm, ret);
} else {
#pragma omp parallel for num_threads(nthreads)
for(int j = 0; j < col; ++j) pres[j] = w_mode_int(px + j*l, pw, &l, l, 1, narm, ret);
}<LOOP-END> <OMP-START>#pragma omp parallel for num_threads(nthreads)<OMP-END> |
SebKrantz/collapse/src/fmode.c | #pragma omp parallel for num_threads(nthreads) | 100 | j = 0; j < col; ++j) pres[j] = mode_int(px + j*l, &l, l, 1, narm, ret);
} else {
<LOOP-START>for(int j = 0; j < col; ++j) pres[j] = w_mode_int(px + j*l, pw, &l, l, 1, narm, ret);
}
break;
}
case LGLSXP: {
int *px = LOGICAL(x), *restrict pres = LOGICAL(res);
if(nullw) {
#pragma omp parallel for num_threads(nthreads)
for(int j = 0; j < col; ++j) pres[j] = mode_fct_logi(px + j*l, &l, l, 1, 1, narm, ret);
} else {
#pragma omp parallel for num_threads(nthreads)
for(int j = 0; j < col; ++j) pres[j] = w_mode_fct_logi(px + j*l, pw, &l, l, 1, 1, narm, ret);
}
break;
}<LOOP-END> <OMP-START>#pragma omp parallel for num_threads(nthreads)<OMP-END> |
SebKrantz/collapse/src/fmode.c | #pragma omp parallel for num_threads(nthreads) | 100 | GLSXP: {
int *px = LOGICAL(x), *restrict pres = LOGICAL(res);
if(nullw) {
<LOOP-START>for(int j = 0; j < col; ++j) pres[j] = mode_fct_logi(px + j*l, &l, l, 1, 1, narm, ret);
} else {
#pragma omp parallel for num_threads(nthreads)
for(int j = 0; j < col; ++j) pres[j] = w_mode_fct_logi(px + j*l, pw, &l, l, 1, 1, narm, ret);
}<LOOP-END> <OMP-START>#pragma omp parallel for num_threads(nthreads)<OMP-END> |
SebKrantz/collapse/src/fmode.c | #pragma omp parallel for num_threads(nthreads) | 100 | j < col; ++j) pres[j] = mode_fct_logi(px + j*l, &l, l, 1, 1, narm, ret);
} else {
<LOOP-START>for(int j = 0; j < col; ++j) pres[j] = w_mode_fct_logi(px + j*l, pw, &l, l, 1, 1, narm, ret);
}
break;
}
case STRSXP: {
SEXP *px = SEXPPTR(x), *restrict pres = SEXPPTR(res);
if(nullw) {
#pragma omp parallel for num_threads(nthreads)
for(int j = 0; j < col; ++j) pres[j] = mode_string(px + j*l, &l, l, 1, narm, ret);
} else {
#pragma omp parallel for num_threads(nthreads)
for(int j = 0; j < col; ++j) pres[j] = w_mode_string(px + j*l, pw, &l, l, 1, narm, ret);
}
break;
}<LOOP-END> <OMP-START>#pragma omp parallel for num_threads(nthreads)<OMP-END> |
SebKrantz/collapse/src/fmode.c | #pragma omp parallel for num_threads(nthreads) | 100 | RSXP: {
SEXP *px = SEXPPTR(x), *restrict pres = SEXPPTR(res);
if(nullw) {
<LOOP-START>for(int j = 0; j < col; ++j) pres[j] = mode_string(px + j*l, &l, l, 1, narm, ret);
} else {
#pragma omp parallel for num_threads(nthreads)
for(int j = 0; j < col; ++j) pres[j] = w_mode_string(px + j*l, pw, &l, l, 1, narm, ret);
}<LOOP-END> <OMP-START>#pragma omp parallel for num_threads(nthreads)<OMP-END> |
SebKrantz/collapse/src/fmode.c | #pragma omp parallel for num_threads(nthreads) | 100 | = 0; j < col; ++j) pres[j] = mode_string(px + j*l, &l, l, 1, narm, ret);
} else {
<LOOP-START>for(int j = 0; j < col; ++j) pres[j] = w_mode_string(px + j*l, pw, &l, l, 1, narm, ret);
}
break;
}
default: error("Not Supported SEXP Type: '%s'", type2char(tx));
}
matCopyAttr(res, x, Rdrop, /*ng=*/0);
UNPROTECT(nprotect);
return res;
}
// With groups
if(TYPEOF(g) != VECSXP || !inherits(g, "GRP")) error("g needs to be an object of class 'GRP', see ?GRP");
const SEXP *restrict pg = SEXPPTR_RO(g), o = pg[6];
int sorted = LOGICAL(pg[5])[1] == 1, ng = INTEGER(pg[0])[0], *restrict pgs = INTEGER(pg[2]), *restrict po, *restrict pst, gl = length(pg[1]);
if(l != gl) error("length(g) must match nrow(x)");
SEXP res = PROTECT(allocVector(tx, ng * col));
if(isNull(o)) {
int *cgs = (int *) R_alloc(ng+2, sizeof(int)), *restrict pgv = INTEGER(pg[1]); cgs[1] = 1;
for(int i = 0; i != ng; ++i) cgs[i+2] = cgs[i+1] + pgs[i];
pst = cgs + 1;
if(sorted) po = &l;
else {
int *restrict count = (int *) Calloc(ng+1, int);
po = (int *) R_alloc(l, sizeof(int)); --po;
for(int i = 0; i != l; ++i) po[cgs[pgv[i]] + count[pgv[i]]++] = i+1;
++po; Free(count);
}
}<LOOP-END> <OMP-START>#pragma omp parallel for num_threads(nthreads)<OMP-END> |
SebKrantz/collapse/src/fmode.c | #pragma omp parallel for num_threads(nthreads) | 100 | REALSXP: {
double *px = REAL(x), *restrict pres = REAL(res);
if(nullw) {
<LOOP-START>for(int j = 0; j < col; ++j) {
int jng = j * ng;
double *pxj = px + j * l;
for(int gr = 0; gr < ng; ++gr) pres[jng + gr] = pgs[gr] == 0 ? NA_REAL : mode_double(pxj + pst[gr]-1, po, pgs[gr], 1, narm, ret);
}<LOOP-END> <OMP-START>#pragma omp parallel for num_threads(nthreads)<OMP-END> |
SebKrantz/collapse/src/fmode.c | #pragma omp parallel for num_threads(nthreads) | 100 | L : mode_double(pxj + pst[gr]-1, po, pgs[gr], 1, narm, ret);
}
} else {
<LOOP-START>for(int j = 0; j < col; ++j) {
int jng = j * ng;
double *pxj = px + j * l;
for(int gr = 0; gr < ng; ++gr) pres[jng + gr] = pgs[gr] == 0 ? NA_REAL : w_mode_double(pxj + pst[gr]-1, pw + pst[gr]-1, po, pgs[gr], 1, narm, ret);
}<LOOP-END> <OMP-START>#pragma omp parallel for num_threads(nthreads)<OMP-END> |
SebKrantz/collapse/src/fmode.c | #pragma omp parallel for num_threads(nthreads) | 100 | bject...
int *px = INTEGER(x), *restrict pres = INTEGER(res);
if(nullw) {
<LOOP-START>for(int j = 0; j < col; ++j) {
int *pxj = px + j * l, jng = j * ng;
for(int gr = 0; gr < ng; ++gr) pres[jng + gr] = pgs[gr] == 0 ? NA_INTEGER : mode_int(pxj + pst[gr]-1, po, pgs[gr], 1, narm, ret);
}<LOOP-END> <OMP-START>#pragma omp parallel for num_threads(nthreads)<OMP-END> |
SebKrantz/collapse/src/fmode.c | #pragma omp parallel for num_threads(nthreads) | 100 | EGER : mode_int(pxj + pst[gr]-1, po, pgs[gr], 1, narm, ret);
}
} else {
<LOOP-START>for(int j = 0; j < col; ++j) {
int *pxj = px + j * l, jng = j * ng;
for(int gr = 0; gr < ng; ++gr) pres[jng + gr] = pgs[gr] == 0 ? NA_INTEGER : w_mode_int(pxj + pst[gr]-1, pw + pst[gr]-1, po, pgs[gr], 1, narm, ret);
}<LOOP-END> <OMP-START>#pragma omp parallel for num_threads(nthreads)<OMP-END> |
SebKrantz/collapse/src/fmode.c | #pragma omp parallel for num_threads(nthreads) | 100 | GLSXP: {
int *px = LOGICAL(x), *restrict pres = LOGICAL(res);
if(nullw) {
<LOOP-START>for(int j = 0; j < col; ++j) {
int *pxj = px + j * l, jng = j * ng;
for(int gr = 0; gr < ng; ++gr) pres[jng + gr] = pgs[gr] == 0 ? NA_LOGICAL : mode_fct_logi(pxj + pst[gr]-1, po, pgs[gr], 1, 1, narm, ret);
}<LOOP-END> <OMP-START>#pragma omp parallel for num_threads(nthreads)<OMP-END> |
SebKrantz/collapse/src/fmode.c | #pragma omp parallel for num_threads(nthreads) | 100 | ode_fct_logi(pxj + pst[gr]-1, po, pgs[gr], 1, 1, narm, ret);
}
} else {
<LOOP-START>for(int j = 0; j < col; ++j) {
int *pxj = px + j * l, jng = j * ng;
for(int gr = 0; gr < ng; ++gr) pres[jng + gr] = pgs[gr] == 0 ? NA_LOGICAL : w_mode_fct_logi(pxj + pst[gr]-1, pw + pst[gr]-1, po, pgs[gr], 1, 1, narm, ret);
}<LOOP-END> <OMP-START>#pragma omp parallel for num_threads(nthreads)<OMP-END> |
SebKrantz/collapse/src/fmode.c | #pragma omp parallel for num_threads(nthreads) | 100 | RSXP: {
SEXP *px = SEXPPTR(x), *restrict pres = SEXPPTR(res);
if(nullw) {
<LOOP-START>for(int j = 0; j < col; ++j) {
int jng = j * ng;
SEXP *pxj = px + j * l;
for(int gr = 0; gr < ng; ++gr) pres[jng + gr] = pgs[gr] == 0 ? NA_STRING : mode_string(pxj + pst[gr]-1, po, pgs[gr], 1, narm, ret);
}<LOOP-END> <OMP-START>#pragma omp parallel for num_threads(nthreads)<OMP-END> |
SebKrantz/collapse/src/fmode.c | #pragma omp parallel for num_threads(nthreads) | 100 | G : mode_string(pxj + pst[gr]-1, po, pgs[gr], 1, narm, ret);
}
} else {
<LOOP-START>for(int j = 0; j < col; ++j) {
int jng = j * ng;
SEXP *pxj = px + j * l;
for(int gr = 0; gr < ng; ++gr) pres[jng + gr] = pgs[gr] == 0 ? NA_STRING : w_mode_string(pxj + pst[gr]-1, pw + pst[gr]-1, po, pgs[gr], 1, narm, ret);
}<LOOP-END> <OMP-START>#pragma omp parallel for num_threads(nthreads)<OMP-END> |
SebKrantz/collapse/src/fmode.c | #pragma omp parallel for num_threads(nthreads) | 100 | REALSXP: {
double *px = REAL(x), *restrict pres = REAL(res);
if(nullw) {
<LOOP-START>for(int j = 0; j < col; ++j) {
int jng = j * ng;
double *pxj = px + j * l;
for(int gr = 0; gr < ng; ++gr) pres[jng + gr] = pgs[gr] == 0 ? NA_REAL : mode_double(pxj, po + pst[gr]-1, pgs[gr], 0, narm, ret);
}<LOOP-END> <OMP-START>#pragma omp parallel for num_threads(nthreads)<OMP-END> |
SebKrantz/collapse/src/fmode.c | #pragma omp parallel for num_threads(nthreads) | 100 | L : mode_double(pxj, po + pst[gr]-1, pgs[gr], 0, narm, ret);
}
} else {
<LOOP-START>for(int j = 0; j < col; ++j) {
int jng = j * ng;
double *pxj = px + j * l;
for(int gr = 0; gr < ng; ++gr) pres[jng + gr] = pgs[gr] == 0 ? NA_REAL : w_mode_double(pxj, pw, po + pst[gr]-1, pgs[gr], 0, narm, ret);
}<LOOP-END> <OMP-START>#pragma omp parallel for num_threads(nthreads)<OMP-END> |
SebKrantz/collapse/src/fmode.c | #pragma omp parallel for num_threads(nthreads) | 100 | NTSXP: {
int *px = INTEGER(x), *restrict pres = INTEGER(res);
if(nullw) {
<LOOP-START>for(int j = 0; j < col; ++j) {
int jng = j * ng, *pxj = px + j * l;
for(int gr = 0; gr < ng; ++gr) pres[jng + gr] = pgs[gr] == 0 ? NA_INTEGER : mode_int(pxj, po + pst[gr]-1, pgs[gr], 0, narm, ret);
}<LOOP-END> <OMP-START>#pragma omp parallel for num_threads(nthreads)<OMP-END> |
SebKrantz/collapse/src/fmode.c | #pragma omp parallel for num_threads(nthreads) | 100 | EGER : mode_int(pxj, po + pst[gr]-1, pgs[gr], 0, narm, ret);
}
} else {
<LOOP-START>for(int j = 0; j < col; ++j) {
int jng = j * ng, *pxj = px + j * l;
for(int gr = 0; gr < ng; ++gr) pres[jng + gr] = pgs[gr] == 0 ? NA_INTEGER : w_mode_int(pxj, pw, po + pst[gr]-1, pgs[gr], 0, narm, ret);
}<LOOP-END> <OMP-START>#pragma omp parallel for num_threads(nthreads)<OMP-END> |
SebKrantz/collapse/src/fmode.c | #pragma omp parallel for num_threads(nthreads) | 100 | GLSXP: {
int *px = LOGICAL(x), *restrict pres = LOGICAL(res);
if(nullw) {
<LOOP-START>for(int j = 0; j < col; ++j) {
int jng = j * ng, *pxj = px + j * l;
for(int gr = 0; gr < ng; ++gr) pres[jng + gr] = pgs[gr] == 0 ? NA_LOGICAL : mode_fct_logi(pxj, po + pst[gr]-1, pgs[gr], 1, 0, narm, ret);
}<LOOP-END> <OMP-START>#pragma omp parallel for num_threads(nthreads)<OMP-END> |
SebKrantz/collapse/src/fmode.c | #pragma omp parallel for num_threads(nthreads) | 100 | ode_fct_logi(pxj, po + pst[gr]-1, pgs[gr], 1, 0, narm, ret);
}
} else {
<LOOP-START>for(int j = 0; j < col; ++j) {
int jng = j * ng, *pxj = px + j * l;
for(int gr = 0; gr < ng; ++gr) pres[jng + gr] = pgs[gr] == 0 ? NA_LOGICAL : w_mode_fct_logi(pxj, pw, po + pst[gr]-1, pgs[gr], 1, 0, narm, ret);
}<LOOP-END> <OMP-START>#pragma omp parallel for num_threads(nthreads)<OMP-END> |
SebKrantz/collapse/src/fmode.c | #pragma omp parallel for num_threads(nthreads) | 100 | RSXP: {
SEXP *px = SEXPPTR(x), *restrict pres = SEXPPTR(res);
if(nullw) {
<LOOP-START>for(int j = 0; j < col; ++j) {
int jng = j * ng;
SEXP *pxj = px + j * l;
for(int gr = 0; gr < ng; ++gr) pres[jng + gr] = pgs[gr] == 0 ? NA_STRING : mode_string(pxj, po + pst[gr]-1, pgs[gr], 0, narm, ret);
}<LOOP-END> <OMP-START>#pragma omp parallel for num_threads(nthreads)<OMP-END> |
SebKrantz/collapse/src/fmode.c | #pragma omp parallel for num_threads(nthreads) | 100 | G : mode_string(pxj, po + pst[gr]-1, pgs[gr], 0, narm, ret);
}
} else {
<LOOP-START>for(int j = 0; j < col; ++j) {
int jng = j * ng;
SEXP *pxj = px + j * l;
for(int gr = 0; gr < ng; ++gr) pres[jng + gr] = pgs[gr] == 0 ? NA_STRING : w_mode_string(pxj, pw, po + pst[gr]-1, pgs[gr], 0, narm, ret);
}<LOOP-END> <OMP-START>#pragma omp parallel for num_threads(nthreads)<OMP-END> |
dssgabriel/lattice-boltzmann-method/v5-openmp_parallel/src/lbm_comm.c | #pragma omp parallel for schedule(guided) | 100 | return;
}
MPI_Status status;
switch (comm_type) {
case COMM_SEND:
<LOOP-START>for (size_t x = 1; x < mesh_to_process->width - 2; x++) {
for (size_t k = 0; k < DIRECTIONS; k++) {
mesh->buffer[(x - 1) * DIRECTIONS + k] =
Mesh_get_cell(mesh_to_process, x, y)[k];
}
}<LOOP-END> <OMP-START>#pragma omp parallel for schedule(guided)<OMP-END> |
dssgabriel/lattice-boltzmann-method/v5-openmp_parallel/src/lbm_comm.c | #pragma omp parallel for schedule(guided) | 100 | >width - 2),
MPI_DOUBLE, target_rank, 0, MPI_COMM_WORLD, &status);
<LOOP-START>for (size_t x = 1; x < mesh_to_process->width - 2; x++) {
for (size_t k = 0; k < DIRECTIONS; k++) {
Mesh_get_cell(mesh_to_process, x, y)[k] =
mesh->buffer[(x - 1) * DIRECTIONS + k];
}
}<LOOP-END> <OMP-START>#pragma omp parallel for schedule(guided)<OMP-END> |
dssgabriel/lattice-boltzmann-method/v5-openmp_parallel/src/lbm_phys.c | #pragma omp parallel for collapse(2) schedule(static) | 100 | h_out->width);
assert(mesh_in->height == mesh_out->height);
// Loop on all inner cells
<LOOP-START>for (size_t j = 1; j < mesh_in->height - 1; j++) {
for (size_t i = 1; i < mesh_in->width - 1; i++) {
compute_cell_collision(Mesh_get_cell(mesh_out, i, j), Mesh_get_cell(mesh_in, i, j));
}
}<LOOP-END> <OMP-START>#pragma omp parallel for collapse(2) schedule(static)<OMP-END> |
dssgabriel/lattice-boltzmann-method/v5-openmp_parallel/src/lbm_phys.c | #pragma omp parallel for collapse(3) schedule(static) | 100 | }
}
}
void propagation(Mesh* mesh_out, Mesh const* mesh_in)
{
// Loop on all cells
<LOOP-START>for (size_t j = 0; j < mesh_out->height; j++) {
for (size_t i = 0; i < mesh_out->width; i++) {
// For all direction
for (size_t k = 0; k < DIRECTIONS; k++) {
// Compute destination point
ssize_t ii = (i + direction_matrix[k][0]);
ssize_t jj = (j + direction_matrix[k][1]);
// Propagate to neighboor nodes
if ((ii >= 0 && ii < mesh_out->width) &&
(jj >= 0 && jj < mesh_out->height))
{
Mesh_get_cell(mesh_out, ii, jj)[k] =
Mesh_get_cell(mesh_in, i, j)[k];
}
}
}
}<LOOP-END> <OMP-START>#pragma omp parallel for collapse(3) schedule(static)<OMP-END> |
dssgabriel/lattice-boltzmann-method/v6-fine_tuning/src/lbm_comm.c | #pragma omp parallel for schedule(guided) | 100 | eturn;
}
MPI_Status status;
switch (comm_type) {
case COMM_SEND:
//<LOOP-START>for (size_t x = 1; x < mesh_to_process->width - 2; x++) {
for (size_t k = 0; k < DIRECTIONS; k++) {
mesh->buffer[(x - 1) * DIRECTIONS + k] =
Mesh_get_cell(mesh_to_process, x, y)[k];
}
}<LOOP-END> <OMP-START>#pragma omp parallel for schedule(guided)<OMP-END> |
dssgabriel/lattice-boltzmann-method/v6-fine_tuning/src/lbm_comm.c | #pragma omp parallel for schedule(guided) | 100 | idth - 2),
MPI_DOUBLE, target_rank, 0, MPI_COMM_WORLD, &status);
//<LOOP-START>for (size_t x = 1; x < mesh_to_process->width - 2; x++) {
for (size_t k = 0; k < DIRECTIONS; k++) {
Mesh_get_cell(mesh_to_process, x, y)[k] =
mesh->buffer[(x - 1) * DIRECTIONS + k];
}
}<LOOP-END> <OMP-START>#pragma omp parallel for schedule(guided)<OMP-END> |
arneish/parallel-PCA-openmp/lab2_omp.c | #pragma omp parallel for num_threads(1) private(i, j) collapse(2) schedule(static) | 100 | l2_diff);
return l2_diff;
}
void transpose(float *M, int m, int n, float *M_T)
{
int i, j;
<LOOP-START>for (i = 0; i < m; i++)
{
for (j = 0; j < n; j++)
{
M_T[j * m + i] = M[i * n + j];
}
}<LOOP-END> <OMP-START>#pragma omp parallel for num_threads(1) private(i, j) collapse(2) schedule(static) <OMP-END> |
arneish/parallel-PCA-openmp/lab2_omp.c | #pragma omp parallel for private(i, j, k, sum, temp1, temp2) schedule(static) | 100 | t *) malloc(sizeof(float)*n2*m2);
transpose(M_2, m2, n2, M_2_T);
int i, j, k, temp1, temp2;
<LOOP-START>for (i = 0; i < m1; i++)
{
temp1 = i*n1;
for (j = 0; j < n2; j++)
{
sum = 0.0;
temp2 = j*m2;
for (k = 0; k < n1; k++)
{
sum += M_1[temp1 + k] * M_2_T[temp2 + k];
}
result[i * n2 + j] = sum;
}
}<LOOP-END> <OMP-START>#pragma omp parallel for private(i, j, k, sum, temp1, temp2) schedule(static)<OMP-END> |
arneish/parallel-PCA-openmp/lab2_omp.c | #pragma omp parallel for private(i, j) reduction(+: sum_sq) | 100 | + i] - A_current[i * P + i]);
}
if (sum_sq>TOLERANCE)
return norm = sqrtf(sum_sq);
<LOOP-START>for (i=0; i<P; i++)
{
for (j=0; j<P; j++)
{
//sum_sq+=fabs(E_next[i*P+j]-E_current[i*P+j]);
sum_sq+=(E_next[i*P+j]-E_current[i*P+j])*(E_next[i*P+j]-E_current[i*P+j]);
}
}<LOOP-END> <OMP-START>#pragma omp parallel for private(i, j) reduction(+: sum_sq)<OMP-END> |
arneish/parallel-PCA-openmp/lab2_omp.c | #pragma omp parallel for private(i, j) collapse(2) schedule(static) | 100 | float *D_T = (float *)malloc(sizeof(float) * P * N);
transpose(D, N, P, D_T);
int i, j;
<LOOP-START>for (i = 0; i < N; i++)
{
for (j = 0; j < P; j++)
{
D_T[j * N + i] = D[i * P + j];
}
}<LOOP-END> <OMP-START>#pragma omp parallel for private(i, j) collapse(2) schedule(static) <OMP-END> |
arneish/parallel-PCA-openmp/lab2_omp.c | #pragma omp parallel for private(i, j, k, sum, temp1, temp2) schedule(static) | 100 | K: %d, retention_: %f\n", *K, retention_);
*D_HAT = (float *)malloc(sizeof(float) * N * (*K));
<LOOP-START>for (i=0; i<N; i++)
{
temp1 = i*P;
for (j=0; j<(*K); j++)
{
sum = 0.0;
for (k=0; k<P; k++)
{
sum += D[temp1+k]*U[k*P+j];
}
(*D_HAT)[i*(*K)+j] = sum;
}
}<LOOP-END> <OMP-START>#pragma omp parallel for private(i, j, k, sum, temp1, temp2) schedule(static)<OMP-END> |
kianenigma/pmms-heat-dissipation/assignment_2/vecsort/vecsort.c | #pragma omp parallel for num_threads(DATA_THREADS) | 100 | ow], length * sizeof(int));
}
/* start sorting one by one */
gettimeofday(&tv1, NULL);
<LOOP-START>for (row = 0; row < rows; row++) {
long length = row_lengths[row];
split_seq(b[row], 0, length, vector[row]);
}<LOOP-END> <OMP-START>#pragma omp parallel for num_threads(DATA_THREADS)<OMP-END> |
kianenigma/pmms-heat-dissipation/assignment_2/heat_omp/compute.c | #pragma omp parallel for \ | 100 | tmp; }
/* initialize halo on source */
do_copy(h, w, src);
/* compute */
<LOOP-START>private(i, j)\
schedule(static)\
reduction(max: maxdiff)\
num_threads(p->nthreads)
for (i = 1; i < h - 1; ++i) {
for (j = 1; j < w - 1; ++j)
{
double w = (*c)[i][j];
double restw = 1.0 - w;
double v, v_old;
v_old = (*src)[i][j];
v = w * v_old +
((*src)[i+1][j ] + (*src)[i-1][j ] +
(*src)[i ][j+1] + (*src)[i ][j-1]) * (restw * c_cdir) +
((*src)[i-1][j-1] + (*src)[i-1][j+1] +
(*src)[i+1][j-1] + (*src)[i+1][j+1]) * (restw * c_cdiag);
double diff = fabs(v - v_old);
if (diff > maxdiff) maxdiff = diff;
(*dst)[i][j] = v;
}
}<LOOP-END> <OMP-START>#pragma omp parallel for \<OMP-END> |
maitreyeepaliwal/Solving-System-of-linear-equations-in-parallel-and-serial/random.c | #pragma omp parallel for num_threads(t) | 100 | umber of threads: ");
scanf("%d", &t);
double r[n];
double p[n];
double px[n];
<LOOP-START>for( int i = 0 ; i<n ; i++)
{
x[i] = 0;
p[i] = b[i];
r[i] = b[i];
px[i] = 0;
}<LOOP-END> <OMP-START>#pragma omp parallel for num_threads(t)<OMP-END> |
maitreyeepaliwal/Solving-System-of-linear-equations-in-parallel-and-serial/random.c | #pragma omp parallel for num_threads(t) | 100 | < n ; i++)
{
sum = r[i]*r[i] + sum;
}
double temp[n];
<LOOP-START>for( int i = 0; i<n ; i++ )
{
temp[i] = 0;
}<LOOP-END> <OMP-START>#pragma omp parallel for num_threads(t)<OMP-END> |
maitreyeepaliwal/Solving-System-of-linear-equations-in-parallel-and-serial/random.c | #pragma omp parallel for num_threads(t) | 100 | nt i = 0; i<n ; i++ )
{
temp[i] = 0;
}
double num = 0;
<LOOP-START>for(int i = 0 ; i < n ; i++)
{
#pragma omp parallel for reduction(+ : temp[i])
for(int j = 0 ; j < n ; j++ )
{
temp[i] = A[i*n+j]*p[j] + temp[i];
}
}<LOOP-END> <OMP-START>#pragma omp parallel for num_threads(t)<OMP-END> |
maitreyeepaliwal/Solving-System-of-linear-equations-in-parallel-and-serial/random.c | #pragma omp parallel for reduction(+ : temp[i]) | 100 | #pragma omp parallel for num_threads(t)
for(int i = 0 ; i < n ; i++)
{
<LOOP-START>for(int j = 0 ; j < n ; j++ )
{
temp[i] = A[i*n+j]*p[j] + temp[i];
}<LOOP-END> <OMP-START>#pragma omp parallel for reduction(+ : temp[i])<OMP-END> |
maitreyeepaliwal/Solving-System-of-linear-equations-in-parallel-and-serial/random.c | #pragma omp parallel for num_threads(t) reduction(+ : num) | 100 | )
{
temp[i] = A[i*n+j]*p[j] + temp[i];
}
}
<LOOP-START>for(int j = 0 ; j < n ; j++)
{
num = num + temp[j]*p[j];
}<LOOP-END> <OMP-START>#pragma omp parallel for num_threads(t) reduction(+ : num)<OMP-END> |
maitreyeepaliwal/Solving-System-of-linear-equations-in-parallel-and-serial/random.c | #pragma omp parallel for num_threads(t) | 100 | j++)
{
num = num + temp[j]*p[j];
}
alpha = sum / num;
<LOOP-START>for(int i = 0; i < n ; i++ )
{
px[i] = x[i];
x[i] = x[i] + alpha*p[i];
r[i] = r[i] - alpha*temp[i];
}<LOOP-END> <OMP-START>#pragma omp parallel for num_threads(t)<OMP-END> |
maitreyeepaliwal/Solving-System-of-linear-equations-in-parallel-and-serial/random.c | #pragma omp parallel for num_threads(t) reduction(+ : beta) | 100 | + alpha*p[i];
r[i] = r[i] - alpha*temp[i];
}
double beta = 0;
<LOOP-START>for(int i = 0 ; i < n ; i++)
{
beta = beta + r[i]*r[i];
}<LOOP-END> <OMP-START>#pragma omp parallel for num_threads(t) reduction(+ : beta)<OMP-END> |
maitreyeepaliwal/Solving-System-of-linear-equations-in-parallel-and-serial/random.c | #pragma omp parallel for num_threads(t) | 100 | i++)
{
beta = beta + r[i]*r[i];
}
beta = beta / sum;
<LOOP-START>for (int i = 0 ; i < n ; i++ )
{
p[i] = r[i] + beta*p[i];
}<LOOP-END> <OMP-START>#pragma omp parallel for num_threads(t)<OMP-END> |
maitreyeepaliwal/Solving-System-of-linear-equations-in-parallel-and-serial/random.c | #pragma omp parallel for num_threads(p) schedule(static, n) reduction(+:dxi) | 100 | ;
for(k=0; k<maxit; k++)
{
printf("\n%d th iteration => \n", k+1);
<LOOP-START>for(int i=0; i<n; i++)
{
dxi = b[i];
for(int j=0; j<n; j++)
{
if(j!=i)
{
dxi-=A[i*n + j] * x[j];
}
x[i] = dxi / A[i*n + i];
}
printf("x %d = %f \n", i+1, x[i]);
}<LOOP-END> <OMP-START>#pragma omp parallel for num_threads(p) schedule(static, n) reduction(+:dxi)<OMP-END> |
maitreyeepaliwal/Solving-System-of-linear-equations-in-parallel-and-serial/required.c | #pragma omp parallel for num_threads(t) | 100 | mber of threads: ");
scanf("%d", &t);
double r[n];
double p[n];
double px[n];
<LOOP-START>for( int i = 0 ; i<n ; i++)
{
x[i] = 0;
p[i] = b[i];
r[i] = b[i];
px[i] = 0;
}<LOOP-END> <OMP-START>#pragma omp parallel for num_threads(t)<OMP-END> |
maitreyeepaliwal/Solving-System-of-linear-equations-in-parallel-and-serial/required.c | #pragma omp parallel for num_threads(t) | 100 | < n ; i++)
{
sum = r[i]*r[i] + sum;
}
double temp[n];
<LOOP-START>for( int i = 0; i<n ; i++ )
{
temp[i] = 0;
}<LOOP-END> <OMP-START>#pragma omp parallel for num_threads(t)<OMP-END> |
maitreyeepaliwal/Solving-System-of-linear-equations-in-parallel-and-serial/required.c | #pragma omp parallel for num_threads(t) | 100 | nt i = 0; i<n ; i++ )
{
temp[i] = 0;
}
double num = 0;
<LOOP-START>for(int i = 0 ; i < n ; i++)
{
#pragma omp parallel for reduction(+ : temp[i])
for(int j = 0 ; j < n ; j++ )
{
temp[i] = A[i*n+j]*p[j] + temp[i];
}
}<LOOP-END> <OMP-START>#pragma omp parallel for num_threads(t)<OMP-END> |
maitreyeepaliwal/Solving-System-of-linear-equations-in-parallel-and-serial/required.c | #pragma omp parallel for reduction(+ : temp[i]) | 100 | #pragma omp parallel for num_threads(t)
for(int i = 0 ; i < n ; i++)
{
<LOOP-START>for(int j = 0 ; j < n ; j++ )
{
temp[i] = A[i*n+j]*p[j] + temp[i];
}<LOOP-END> <OMP-START>#pragma omp parallel for reduction(+ : temp[i])<OMP-END> |
maitreyeepaliwal/Solving-System-of-linear-equations-in-parallel-and-serial/required.c | #pragma omp parallel for num_threads(t) reduction(+ : num) | 100 | )
{
temp[i] = A[i*n+j]*p[j] + temp[i];
}
}
<LOOP-START>for(int j = 0 ; j < n ; j++)
{
num = num + temp[j]*p[j];
}<LOOP-END> <OMP-START>#pragma omp parallel for num_threads(t) reduction(+ : num)<OMP-END> |
maitreyeepaliwal/Solving-System-of-linear-equations-in-parallel-and-serial/required.c | #pragma omp parallel for num_threads(t) | 100 | j++)
{
num = num + temp[j]*p[j];
}
alpha = sum / num;
<LOOP-START>for(int i = 0; i < n ; i++ )
{
px[i] = x[i];
x[i] = x[i] + alpha*p[i];
r[i] = r[i] - alpha*temp[i];
}<LOOP-END> <OMP-START>#pragma omp parallel for num_threads(t)<OMP-END> |
maitreyeepaliwal/Solving-System-of-linear-equations-in-parallel-and-serial/required.c | #pragma omp parallel for num_threads(t) reduction(+ : beta) | 100 | + alpha*p[i];
r[i] = r[i] - alpha*temp[i];
}
double beta = 0;
<LOOP-START>for(int i = 0 ; i < n ; i++)
{
beta = beta + r[i]*r[i];
}<LOOP-END> <OMP-START>#pragma omp parallel for num_threads(t) reduction(+ : beta)<OMP-END> |
maitreyeepaliwal/Solving-System-of-linear-equations-in-parallel-and-serial/required.c | #pragma omp parallel for num_threads(t) | 100 | i++)
{
beta = beta + r[i]*r[i];
}
beta = beta / sum;
<LOOP-START>for (int i = 0 ; i < n ; i++ )
{
p[i] = r[i] + beta*p[i];
}<LOOP-END> <OMP-START>#pragma omp parallel for num_threads(t)<OMP-END> |
maitreyeepaliwal/Solving-System-of-linear-equations-in-parallel-and-serial/required.c | #pragma omp parallel for num_threads(p) schedule(static, n) reduction(+:dxi) | 100 | ;
for(k=0; k<maxit; k++)
{
printf("\n%d th iteration => \n", k+1);
<LOOP-START>for(int i=0; i<n; i++)
{
dxi = b[i];
for(int j=0; j<n; j++)
{
if(j!=i)
{
dxi-=A[i*n + j] * x[j];
}
x[i] = dxi / A[i*n + i];
}
printf("x %d = %f \n", i+1, x[i]);
}<LOOP-END> <OMP-START>#pragma omp parallel for num_threads(p) schedule(static, n) reduction(+:dxi)<OMP-END> |
Sitaras/Parallel-Systems-Project/HybridMPI/jacobi_hybrid.c | #pragma omp parallel for collapse(2) shared(size,src,dst,xStart,yStart,deltaX,deltaY,alpha,omega,cx,cy,cc),private(y,x,updateVal),reduction(+:temp_error) schedule(static) | 100 | double fx2,fy2;
double temp_error = 0.0;
double updateVal;
double f;
<LOOP-START>for (x = 2; x < (size-2); x++){
for (y = 2; y < (size-2); y++){
updateVal = ((SRC(x-1,y) + SRC(x+1,y))*cx + (SRC(x,y-1) + SRC(x,y+1))*cy + SRC(x,y)*cc - F(x,y))/cc;
DST(x,y) = SRC(x,y) - omega*updateVal;
temp_error += updateVal*updateVal;
}
}<LOOP-END> <OMP-START>#pragma omp parallel for collapse(2) shared(size,src,dst,xStart,yStart,deltaX,deltaY,alpha,omega,cx,cy,cc),private(y,x,updateVal),reduction(+:temp_error) schedule(static)<OMP-END> |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.