filename stringlengths 19 182 | omp_pragma_line stringlengths 24 416 | context_chars int64 100 100 | text stringlengths 152 177k |
|---|---|---|---|
SebKrantz/collapse/misc/legacy/sorted out 1.8.9 - 1.9.0/fnth_fmedian.cpp | #pragma omp parallel for num_threads(nthreads) | 100 | IntegerVector gsv = gs;
if(ng != gsv.size()) stop("ng must match length(gs)");
<LOOP-START>for(int i = 0; i < ng; ++i) {
// if(gsv[i] == 0) stop("Group size of 0 encountered. This is probably because of unused factor levels. Use fdroplevels(f) to drop them.");
if(gsv[i] > 0) gmap[i+1] = std::vector<double> (gsv[i]);
}<LOOP-END> <OMP-START>#pragma omp parallel for num_threads(nthreads)<OMP-END> |
SebKrantz/collapse/misc/legacy/sorted out 1.8.9 - 1.9.0/fnth_fmedian.cpp | #pragma omp parallel for num_threads(nthreads) | 100 | r(int i = 0; i != lx1; ++i) if(nisnan(column[i])) gmap[g[i]][gcount[g[i]]++] = column[i];
<LOOP-START>for(int i = 1; i < ngp; ++i) {
if(gcount[i] != 0) {
int n = gcount[i], nth = lower ? (n-1)*Q : n*Q;
auto begin = gmap[i].begin(), mid = begin + nth, end = begin + n;
std::nth_element(begin, mid, end);
nthj[i-1] = (tiesmean && n%2 == 0) ? (*(mid) + *(std::min_element(mid+1, end)))*0.5 : *(mid);
}
}<LOOP-END> <OMP-START>#pragma omp parallel for num_threads(nthreads)<OMP-END> |
SebKrantz/collapse/misc/legacy/sorted out 1.8.9 - 1.9.0/fnth_fmedian.cpp | #pragma omp parallel for num_threads(nthreads) | 100 | } else {
gmap[g[i]][gcount[g[i]]++] = column[i];
}
}
<LOOP-START>for(int i = 0; i < ng; ++i) {
if(isnan2(nthj[i]) || gcount[i+1] == 0) continue;
int n = gcount[i+1], nth = lower ? (n-1)*Q : n*Q;
auto begin = gmap[i+1].begin(), mid = begin + nth, end = begin + n;
std::nth_element(begin, mid, end);
nthj[i] = (tiesmean && n%2 == 0) ? (*(mid) + *(std::min_element(mid+1, end)))*0.5 : *(mid);
}<LOOP-END> <OMP-START>#pragma omp parallel for num_threads(nthreads)<OMP-END> |
SebKrantz/collapse/misc/legacy/sorted out 1.7.6 - 1.8.0/fmode.cpp | #pragma omp parallel for num_threads(nthreads) | 100 |
}
for(int i = 0; i != l; ++i) gmap[pg[i]][n[pg[i]]++] = x[i];
if(narm) {
<LOOP-START>for(int gr = 0; gr < ng; ++gr) {
// const std::vector<storage_t>& temp = gmap[gr]; // wrap() // good ? // const Vector<RTYPE>& // better for character strings
sugar::IndexHash<RTYPE> hash(wrap(gmap[gr+1])); // wrap(temp)
int i = 0, s = hash.n, end = s-1, max = 1, index; // n[s+1] // fastest ? use n ?
while(isnanT(hash.src[i]) && i!=end) ++i;
out[gr] = hash.src[i]; // good
if(i!=end) {
std::vector<int> n(s+1); // = no_init_vector // better for valgrind
for( ; i != s; ++i) {
storage_t val = hash.src[i];
if(isnanT(val)) continue;
addr = hash.get_addr(val);
index = hash.data[addr];
while(index && hash.not_equal(hash.src[index - 1], val)) {
++addr;
if(addr == static_cast<unsigned int>(hash.m)) addr = 0;
index = hash.data[addr];
}
if(!index) {
hash.data[addr] = i+1;
++hash.size_;
n[i+1] = 1;
if(nfirstm && max == 1) { // Could also do this at the end in a separate loop. What is faster ? -> This seems better !
if(lastm) out[gr] = val;
else if(minm) {
if(out[gr] > val) out[gr] = val;
} else {
if(out[gr] < val) out[gr] = val;
}
}
} else {
// if(++n[hash.data[addr]] > max) { // good, or create int index
// max = n[hash.data[addr]];
// out[gr] = val;
// }
// index = hash.data[addr];
if(++n[index] >= max) {
if(lastm || n[index] > max) {
max = n[index];
out[gr] = val;
} else if(nfirstm) {
if(minm) {
if(out[gr] > val) out[gr] = val;
} else {
if(out[gr] < val) out[gr] = val;
}
}
}
}
}
// if(nfirstm && max == 1) { // Above seems better !
// if(minm) {
// for(int i = 1; i != s; ++i) if(out[gr] > hash.src[i]) out[gr] = hash.src[i];
// } else {
// for(int i = 1; i != s; ++i) if(out[gr] < hash.src[i]) out[gr] = hash.src[i];
// }
// }
}
}<LOOP-END> <OMP-START>#pragma omp parallel for num_threads(nthreads)<OMP-END> |
SebKrantz/collapse/misc/legacy/sorted out 1.7.6 - 1.8.0/fmode.cpp | #pragma omp parallel for num_threads(nthreads) | 100 | gr] = hash.src[i];
// }
// }
}
}
} else {
<LOOP-START>for(int gr = 0; gr < ng; ++gr) {
// const std::vector<storage_t>& temp = gmap[gr]; // good ? // const Vector<RTYPE>& // wrap()
sugar::IndexHash<RTYPE> hash(wrap(gmap[gr+1])); // wrap(temp)
out[gr] = hash.src[0];
int s = hash.n, max = 1, index; // n[s+1] // fastest ? use n ? and reset partially ?
std::vector<int> n(s+1); // = no_init_vector // better for valgrind
for(int i = 0; i != s; ++i) {
storage_t val = hash.src[i];
addr = hash.get_addr(val);
index = hash.data[addr];
while(index && hash.not_equal(hash.src[index - 1], val)) {
++addr;
if(addr == static_cast<unsigned int>(hash.m)) addr = 0;
index = hash.data[addr];
}
if(!index) {
hash.data[addr] = i+1;
++hash.size_;
n[i+1] = 1;
if(nfirstm && max == 1) { // Could also do this at the end in a separate loop. What is faster ? -> This seems better !
if(lastm) out[gr] = val;
else if(minm) {
if(out[gr] > val) out[gr] = val;
} else {
if(out[gr] < val) out[gr] = val;
}
}
} else {
// if(++n[hash.data[addr]] > max) { // good, or create int index
// max = n[hash.data[addr]];
// out[gr] = val;
// }
if(++n[index] >= max) {
if(lastm || n[index] > max) {
max = n[index];
out[gr] = val;
} else if(nfirstm) {
if(minm) {
if(out[gr] > val) out[gr] = val;
} else {
if(out[gr] < val) out[gr] = val;
}
}
}
}
}
// if(nfirstm && max == 1) { // Above seems better !
// if(minm) {
// for(int i = 1; i != s; ++i) if(out[gr] > hash.src[i]) out[gr] = hash.src[i];
// } else {
// for(int i = 1; i != s; ++i) if(out[gr] < hash.src[i]) out[gr] = hash.src[i];
// }
// }
}<LOOP-END> <OMP-START>#pragma omp parallel for num_threads(nthreads)<OMP-END> |
SebKrantz/collapse/misc/legacy/sorted out 1.7.6 - 1.8.0/fmode.cpp | #pragma omp parallel for num_threads(nthreads) | 100 | gmap[gi][n[gi]] = x[i];
wmap[gi][n[gi]++] = pwg[i];
}
if(narm) {
<LOOP-START>for(int gr = 0; gr < ng; ++gr) {
// const std::vector<storage_t>& temp = gmap[gr]; // good ? // const Vector<RTYPE>& // wrap()
const std::vector<double>& wtemp = wmap[gr+1];
sugar::IndexHash<RTYPE> hash(wrap(gmap[gr+1])); // wrap(temp)
int i = 0, s = hash.n, end = s-1, index;
double max = DBL_MIN; // n[s+1]
while((isnanT(hash.src[i]) || std::isnan(wtemp[i])) && i!=end) ++i;
out[gr] = hash.src[i]; // good !
if(i!=end) {
std::vector<double> n(s+1); // = no_init_vector // better for valgrind
for( ; i != s; ++i) {
storage_t val = hash.src[i];
if(isnanT(val) || std::isnan(wtemp[i])) continue;
addr = hash.get_addr(val);
index = hash.data[addr];
while(index && hash.not_equal(hash.src[index - 1], val)) {
++addr;
if(addr == static_cast<unsigned int>(hash.m)) addr = 0;
index = hash.data[addr];
}
if(!index) {
hash.data[addr] = i+1;
++hash.size_;
n[i+1] = wtemp[i];
if(wtemp[i] >= max) { // necessary, because second loop only entered for more than one occurrence of the same value
if(lastm || wtemp[i] > max) {
max = wtemp[i];
out[gr] = val;
} else if(nfirstm) { // Could also do this at the end in a separate loop. What is faster ??
if(minm) {
if(out[gr] > val) out[gr] = val;
} else {
if(out[gr] < val) out[gr] = val;
}
}
}
} else {
n[index] += wtemp[i];
// if(n[index] > max) {
// max = n[index];
// out[gr] = val;
// }
if(n[index] >= max) {
if(lastm || n[index] > max) {
max = n[index];
out[gr] = val;
} else if(nfirstm) {
if(minm) {
if(out[gr] > val) out[gr] = val;
} else {
if(out[gr] < val) out[gr] = val;
}
}
}
}
}
}
}<LOOP-END> <OMP-START>#pragma omp parallel for num_threads(nthreads)<OMP-END> |
SebKrantz/collapse/misc/legacy/sorted out 1.7.6 - 1.8.0/fmode.cpp | #pragma omp parallel for num_threads(nthreads) | 100 | }
}
}
}
}
}
} else {
<LOOP-START>for(int gr = 0; gr < ng; ++gr) {
// const std::vector<storage_t>& temp = gmap[gr]; // good ? // const Vector<RTYPE>& // wrap()
const std::vector<double>& wtemp = wmap[gr+1];
sugar::IndexHash<RTYPE> hash(wrap(gmap[gr+1])); // wrap(temp)
out[gr] = hash.src[0];
int s = hash.n, index; // fastest ? use n ? and reset partially ?
double max = DBL_MIN; // n[s+1];
std::vector<double> n(s+1); // = no_init_vector // better for valgrind
for(int i = 0; i != s; ++i) {
if(std::isnan(wtemp[i])) continue;
storage_t val = hash.src[i];
addr = hash.get_addr(val);
index = hash.data[addr];
while(index && hash.not_equal(hash.src[index - 1], val)) {
++addr;
if(addr == static_cast<unsigned int>(hash.m)) addr = 0;
index = hash.data[addr];
}
if(!index) {
hash.data[addr] = i+1;
++hash.size_;
n[i+1] = wtemp[i];
if(wtemp[i] >= max) { // necessary, because second loop only entered for more than one occurrence of the same value
if(lastm || wtemp[i] > max) {
max = wtemp[i];
out[gr] = val;
} else if(nfirstm) { // Could also do this at the end in a separate loop. What is faster ??
if(minm) {
if(out[gr] > val) out[gr] = val;
} else {
if(out[gr] < val) out[gr] = val;
}
}
}
} else {
n[index] += wtemp[i];
// if(n[index] > max) {
// max = n[index];
// out[gr] = val;
// }
if(n[index] >= max) {
if(lastm || n[index] > max) {
max = n[index];
out[gr] = val;
} else if(nfirstm) {
if(minm) {
if(out[gr] > val) out[gr] = val;
} else {
if(out[gr] < val) out[gr] = val;
}
}
}
}
}
}<LOOP-END> <OMP-START>#pragma omp parallel for num_threads(nthreads)<OMP-END> |
SebKrantz/collapse/misc/legacy/sorted out 1.7.6 - 1.8.0/fmode.cpp | #pragma omp parallel for num_threads(nthreads) | 100 |
}
for(int i = 0; i != l; ++i) gmap[pg[i]][n[pg[i]]++] = x[i];
if(narm) {
<LOOP-START>for(int gr = 0; gr < ng; ++gr) {
const std::vector<int>& temp = gmap[gr+1];
int i = 0, s = temp.size(), end = s-1, max = 1;
while(temp[i] == NA_INTEGER && i!=end) ++i;
out[gr] = temp[i];
if(i!=end) {
std::vector<int> n(nlevp);
for( ; i != s; ++i) {
val = temp[i];
if(val == NA_INTEGER) continue;
if(++n[val] >= max) {
if(lastm || n[val] > max) {
max = n[val];
out[gr] = val;
} else if(nfirstm) {
if(minm) {
if(out[gr] > val) out[gr] = val;
} else {
if(out[gr] < val) out[gr] = val;
}
}
}
}
}
}<LOOP-END> <OMP-START>#pragma omp parallel for num_threads(nthreads)<OMP-END> |
SebKrantz/collapse/misc/legacy/sorted out 1.7.6 - 1.8.0/fmode.cpp | #pragma omp parallel for num_threads(nthreads) | 100 | }
}
}
}
}
}
} else {
<LOOP-START>for(int gr = 0; gr < ng; ++gr) {
const std::vector<int>& temp = gmap[gr+1];
int tl = temp.size(), max = 1;
std::vector<int> n(nlevp);
out[gr] = temp[0];
for(int i = 0; i != tl; ++i) {
val = temp[i];
if(val == NA_INTEGER) val = 0;
if(++n[val] >= max) {
if(lastm || n[val] > max) {
max = n[val];
out[gr] = val;
} else if(nfirstm) {
if(minm) {
if(out[gr] > val) out[gr] = val;
} else {
if(out[gr] < val) out[gr] = val;
}
}
}
}
if(out[gr] == 0) out[gr] = NA_INTEGER;
}<LOOP-END> <OMP-START>#pragma omp parallel for num_threads(nthreads)<OMP-END> |
SebKrantz/collapse/misc/legacy/sorted out 1.7.6 - 1.8.0/fmode.cpp | #pragma omp parallel for num_threads(nthreads) | 100 | gmap[gi][n[gi]] = x[i];
wmap[gi][n[gi]++] = pwg[i];
}
if(narm) {
<LOOP-START>for(int gr = 0; gr < ng; ++gr) {
const std::vector<int>& temp = gmap[gr+1];
const std::vector<double>& wtemp = wmap[gr+1];
int i = 0, s = temp.size(), end = s-1;
double max = DBL_MIN;
while((temp[i] == NA_INTEGER || std::isnan(wtemp[i])) && i!=end) ++i;
out[gr] = temp[i];
if(i!=end) {
std::vector<double> n(nlevp);
for( ; i != s; ++i) {
val = temp[i];
if(val == NA_INTEGER || std::isnan(wtemp[i])) continue;
n[val] += wtemp[i];
if(n[val] >= max) {
if(lastm || n[val] > max) {
max = n[val];
out[gr] = val;
} else if(nfirstm) {
if(minm) {
if(out[gr] > val) out[gr] = val;
} else {
if(out[gr] < val) out[gr] = val;
}
}
}
}
}
}<LOOP-END> <OMP-START>#pragma omp parallel for num_threads(nthreads)<OMP-END> |
SebKrantz/collapse/misc/legacy/sorted out 1.7.6 - 1.8.0/fmode.cpp | #pragma omp parallel for num_threads(nthreads) | 100 | }
}
}
}
}
}
} else {
<LOOP-START>for(int gr = 0; gr < ng; ++gr) {
const std::vector<int>& temp = gmap[gr+1];
const std::vector<double>& wtemp = wmap[gr+1];
int tl = temp.size();
double max = DBL_MIN;
std::vector<double> n(nlevp);
out[gr] = temp[0];
for(int i = 0; i != tl; ++i) {
if(std::isnan(wtemp[i])) continue;
val = temp[i];
if(val == NA_INTEGER) val = 0;
n[val] += wtemp[i];
if(n[val] >= max) {
if(lastm || n[val] > max) {
max = n[val];
out[gr] = val;
} else if(nfirstm) {
if(minm) {
if(out[gr] > val) out[gr] = val;
} else {
if(out[gr] < val) out[gr] = val;
}
}
}
}
if(out[gr] == 0) out[gr] = NA_INTEGER;
}<LOOP-END> <OMP-START>#pragma omp parallel for num_threads(nthreads)<OMP-END> |
SebKrantz/collapse/misc/legacy/sorted out 1.7.6 - 1.8.0/fmode.cpp | #pragma omp parallel for num_threads(nthreads) | 100 | = x.size();
List out(l);
if(ng == 0 && nthreads > 1) {
if(nthreads > l) nthreads = l;
<LOOP-START>for(int j = 0; j < l; ++j) out[j] = fmodeCpp(x[j], ng, g, gs, w, narm, ret, 1);
} else {
for(int j = l; j--; ) out[j] = fmodeCpp(x[j], ng, g, gs, w, narm, ret, nthreads);
}<LOOP-END> <OMP-START>#pragma omp parallel for num_threads(nthreads)<OMP-END> |
SebKrantz/collapse/misc/legacy/sorted out 1.7.6 - 1.8.0/fmode.cpp | #pragma omp parallel for num_threads(nthreads) | 100 | o_init_matrix(ng, col);
if(ng == 0 && nthreads > 1) {
if(nthreads > col) nthreads = col;
<LOOP-START>for(int j = 0; j < col; ++j) out(_, j) = fmodeImpl<RTYPE>(x(_, j), ng, g, gs, w, narm, ret, 1);
} else {
for(int j = col; j--; ) out(_, j) = fmodeImpl<RTYPE>(x(_, j), ng, g, gs, w, narm, ret, nthreads);
}<LOOP-END> <OMP-START>#pragma omp parallel for num_threads(nthreads)<OMP-END> |
SebKrantz/collapse/misc/legacy/sorted out 1.7.6 - 1.8.0/fndistinct.cpp | #pragma omp parallel for num_threads(nthreads) | 100 | tm1 = out.begin()-1;
if(Rf_isNull(gs)) {
for(int i = 0; i != l; ++i) ++outm1[g[i]];
<LOOP-START>for(int i = 0; i < ng; ++i) {
// if(out[i] == 0) stop("Group size of 0 encountered. This is probably due to unused factor levels. Use fdroplevels(f) to drop them.");
if(out[i] > 0) {
gmap[i+1] = std::vector<storage_t> (out[i]);
out[i] = 0;
}
}<LOOP-END> <OMP-START>#pragma omp parallel for num_threads(nthreads)<OMP-END> |
SebKrantz/collapse/misc/legacy/sorted out 1.7.6 - 1.8.0/fndistinct.cpp | #pragma omp parallel for num_threads(nthreads) | 100 | {
IntegerVector gsv = gs;
if(ng != gsv.size()) stop("ng must match length(gs)");
<LOOP-START>for(int i = 0; i < ng; ++i) {
// if(gsv[i] == 0) stop("Group size of 0 encountered. This is probably due to unused factor levels. Use fdroplevels(f) to drop them.");
if(gsv[i] > 0) gmap[i+1] = std::vector<storage_t> (gsv[i]);
}<LOOP-END> <OMP-START>#pragma omp parallel for num_threads(nthreads)<OMP-END> |
SebKrantz/collapse/misc/legacy/sorted out 1.7.6 - 1.8.0/fndistinct.cpp | #pragma omp parallel for num_threads(nthreads) | 100 | }
}
for(int i = 0; i != l; ++i) gmap[g[i]][outm1[g[i]]++] = x[i];
if(narm) {
<LOOP-START>for(int gr = 0; gr < ng; ++gr) {
if(out[gr] == 0) continue;
// const std::vector<storage_t>& temp = gmap[gr+1]; // good ? // const Vector<RTYPE>& // wrap()
sugar::IndexHash<RTYPE> hash(wrap(gmap[gr+1])); // temp
for(int i = hash.n; i--; ) {
storage_t val = hash.src[i];
if(isnanT(val)) continue;
addr = hash.get_addr(val);
while(hash.data[addr] && hash.not_equal(hash.src[hash.data[addr] - 1], val)) {
++addr;
if(addr == static_cast<unsigned int>(hash.m)) addr = 0;
}
if(!hash.data[addr]) {
hash.data[addr] = i+1;
++hash.size_;
}
}
out[gr] = hash.size_;
}<LOOP-END> <OMP-START>#pragma omp parallel for num_threads(nthreads)<OMP-END> |
SebKrantz/collapse/misc/legacy/sorted out 1.7.6 - 1.8.0/fndistinct.cpp | #pragma omp parallel for num_threads(nthreads) | 100 | ++hash.size_;
}
}
out[gr] = hash.size_;
}
} else {
<LOOP-START>for(int gr = 0; gr < ng; ++gr) {
if(out[gr] == 0) continue;
sugar::IndexHash<RTYPE> hash(wrap(gmap[gr+1]));
hash.fill();
out[gr] = hash.size_;
}<LOOP-END> <OMP-START>#pragma omp parallel for num_threads(nthreads)<OMP-END> |
SebKrantz/collapse/misc/legacy/sorted out 1.7.6 - 1.8.0/fndistinct.cpp | #pragma omp parallel for num_threads(nthreads) | 100 | out.begin()-1;
if(Rf_isNull(gs)) {
for(int i = 0; i != l; ++i) ++outm1[g[i]];
<LOOP-START>for(int i = 0; i < ng; ++i) {
// if(out[i] == 0) stop("Group size of 0 encountered. This is probably due to unused factor levels. Use fdroplevels(f) to drop them.");
if(out[i] > 0) {
gmap[i+1] = std::vector<int> (out[i]);
out[i] = 0;
}
}<LOOP-END> <OMP-START>#pragma omp parallel for num_threads(nthreads)<OMP-END> |
SebKrantz/collapse/misc/legacy/sorted out 1.7.6 - 1.8.0/fndistinct.cpp | #pragma omp parallel for num_threads(nthreads) | 100 | IntegerVector gsv = gs;
if(ng != gsv.size()) stop("ng must match length(gs)");
<LOOP-START>for(int i = 0; i < ng; ++i) {
// if(gsv[i] == 0) stop("Group size of 0 encountered. This is probably due to unused factor levels. Use fdroplevels(f) to drop them.");
if(gsv[i] > 0) gmap[i+1] = std::vector<int> (gsv[i]);
}<LOOP-END> <OMP-START>#pragma omp parallel for num_threads(nthreads)<OMP-END> |
SebKrantz/collapse/misc/legacy/sorted out 1.7.6 - 1.8.0/fndistinct.cpp | #pragma omp parallel for num_threads(nthreads) | 100 | }
for(int i = 0; i != l; ++i) gmap[g[i]][outm1[g[i]]++] = x[i];
if(narm) {
<LOOP-START>for(int gr = 0; gr < ng; ++gr) {
if(out[gr] == 0) continue;
const std::vector<int>& temp = gmap[gr+1];
n = 1;
std::vector<bool> uxp(nlevp, true);
for(int i = temp.size(); i--; ) {
if(temp[i] != NA_INTEGER && uxp[temp[i]]) { // save xi = x[i] ? Faster ?
uxp[temp[i]] = false;
if(++n == nlevp) break;
}
}
out[gr] = n - 1;
}<LOOP-END> <OMP-START>#pragma omp parallel for num_threads(nthreads)<OMP-END> |
SebKrantz/collapse/misc/legacy/sorted out 1.7.6 - 1.8.0/fndistinct.cpp | #pragma omp parallel for num_threads(nthreads) | 100 | nlevp) break;
}
}
out[gr] = n - 1;
}
} else {
<LOOP-START>for(int gr = 0; gr < ng; ++gr) {
if(out[gr] == 0) continue;
const std::vector<int>& temp = gmap[gr+1];
bool anyNA = false;
n = 1;
std::vector<bool> uxp(nlevp, true);
for(int i = temp.size(); i--; ) {
if(temp[i] == NA_INTEGER) {
anyNA = true;
continue;
}
if(uxp[temp[i]]) { // save xi = x[i] ? Faster ?
uxp[temp[i]] = false;
if(++n == nlevp && anyNA) break;
}
}
out[gr] = n + anyNA - 1;
}<LOOP-END> <OMP-START>#pragma omp parallel for num_threads(nthreads)<OMP-END> |
SebKrantz/collapse/misc/legacy/sorted out 1.7.6 - 1.8.0/fndistinct.cpp | #pragma omp parallel for num_threads(nthreads) | 100 | > 1 && ((ng == 0 && l > 1) || (ng != 0 && nthreads < l))) {
if(nthreads > l) nthreads = l;
<LOOP-START>for(int j = 0; j < l; ++j) out[j] = fndistinctCpp(x[j], ng, g, gs, narm, 1);
} else {
for(int j = l; j--; ) out[j] = fndistinctCpp(x[j], ng, g, gs, narm, nthreads);
}<LOOP-END> <OMP-START>#pragma omp parallel for num_threads(nthreads)<OMP-END> |
SebKrantz/collapse/misc/legacy/sorted out 1.7.6 - 1.8.0/fndistinct.cpp | #pragma omp parallel for num_threads(nthreads) | 100 | ntegerVector out = no_init_vector(col);
if(nthreads > col) nthreads = col;
if(narm) {
<LOOP-START>for(int j = 0; j < col; ++j) {
// ConstMatrixColumn<RTYPE> column = x(_ , j);
sugar::IndexHash<RTYPE> hash(wrap(x(_ , j))); // wrap(column) // why wrap needed ?
for(int i = 0; i != l; ++i) {
storage_t val = hash.src[i];
if(isnanT(val)) continue;
addr = hash.get_addr(val);
while(hash.data[addr] && hash.not_equal(hash.src[hash.data[addr] - 1], val)) {
++addr;
if(addr == static_cast<unsigned int>(hash.m)) addr = 0;
}
if(!hash.data[addr]) {
hash.data[addr] = i+1;
++hash.size_;
}
}
out[j] = hash.size_;
}<LOOP-END> <OMP-START>#pragma omp parallel for num_threads(nthreads)<OMP-END> |
SebKrantz/collapse/misc/legacy/sorted out 1.7.6 - 1.8.0/fndistinct.cpp | #pragma omp parallel for num_threads(nthreads) | 100 | ++hash.size_;
}
}
out[j] = hash.size_;
}
} else {
<LOOP-START>for(int j = 0; j < col; ++j) {
// ConstMatrixColumn<RTYPE> column = x(_ , j);
sugar::IndexHash<RTYPE> hash(wrap(x(_ , j))); // wrap(column) // why wrap needed ?
hash.fill();
out[j] = hash.size_;
}<LOOP-END> <OMP-START>#pragma omp parallel for num_threads(nthreads)<OMP-END> |
SebKrantz/collapse/misc/legacy/sorted out 1.7.6 - 1.8.0/fndistinct.cpp | #pragma omp parallel for num_threads(nthreads) | 100 | ll(gs)) {
// memset(n, 0, sizeof(int)*ng);
for(int i = 0; i != l; ++i) ++n[g[i]];
<LOOP-START>for(int i = 1; i < ngp; ++i) {
// if(n[i] == 0) stop("Group size of 0 encountered. This is probably because of unused factor levels. Use fdroplevels(f) to drop them.");
if(n[i] > 0) gmap[i] = std::vector<storage_t> (n[i]);
}<LOOP-END> <OMP-START>#pragma omp parallel for num_threads(nthreads)<OMP-END> |
SebKrantz/collapse/misc/legacy/sorted out 1.7.6 - 1.8.0/fndistinct.cpp | #pragma omp parallel for num_threads(nthreads) | 100 | {
IntegerVector gsv = gs;
if(ng != gsv.size()) stop("ng must match length(gs)");
<LOOP-START>for(int i = 0; i < ng; ++i) {
// if(gsv[i] == 0) stop("Group size of 0 encountered. This is probably because of unused factor levels. Use fdroplevels(f) to drop them.");
if(gsv[i] > 0) gmap[i+1] = std::vector<storage_t> (gsv[i]);
}<LOOP-END> <OMP-START>#pragma omp parallel for num_threads(nthreads)<OMP-END> |
SebKrantz/collapse/misc/legacy/sorted out 1.7.6 - 1.8.0/fndistinct.cpp | #pragma omp parallel for num_threads(nthreads) | 100 | i != l; ++i) gmap[g[i]][n[g[i]]++] = column[i]; // reading in all the values. Better way ?
<LOOP-START>for(int gr = 0; gr < ng; ++gr) {
if(n[gr+1] == 0) continue;
// const std::vector<storage_t>& temp = gmap[gr+1]; // good ? // const Vector<RTYPE>& // wrap()
sugar::IndexHash<RTYPE> hash(wrap(gmap[gr+1])); // wrap(temp)
for(int i = hash.n; i--; ) {
storage_t val = hash.src[i];
if(isnanT(val)) continue;
addr = hash.get_addr(val);
while(hash.data[addr] && hash.not_equal(hash.src[hash.data[addr] - 1], val)) {
++addr;
if(addr == static_cast<unsigned int>(hash.m)) addr = 0;
}
if(!hash.data[addr]) {
hash.data[addr] = i+1;
++hash.size_;
}
}
outj[gr] = hash.size_;
}<LOOP-END> <OMP-START>#pragma omp parallel for num_threads(nthreads)<OMP-END> |
SebKrantz/collapse/misc/legacy/sorted out 1.7.6 - 1.8.0/fndistinct.cpp | #pragma omp parallel for num_threads(nthreads) | 100 | i != l; ++i) gmap[g[i]][n[g[i]]++] = column[i]; // reading in all the values. Better way ?
<LOOP-START>for(int gr = 0; gr < ng; ++gr) {
if(n[gr+1] == 0) continue;
sugar::IndexHash<RTYPE> hash(wrap(gmap[gr+1]));
hash.fill();
outj[gr] = hash.size_;
}<LOOP-END> <OMP-START>#pragma omp parallel for num_threads(nthreads)<OMP-END> |
SebKrantz/collapse/misc/legacy/sorted out 1.1.0 - 1.2.0/data.table_forder.c | #pragma omp parallel for num_threads(getDTthreads()) | 100 | ing range_str"); // # nocov
// savetl_init() has already been called at the start of forder
// <LOOP-START>for(int i=0; i<n; i++) {
SEXP s = x[i];
if (s==NA_STRING) {
// #pragma omp atomic update
na_count++;
continue;
}
if (TRUELENGTH(s)<0) continue; // seen this group before
// #pragma omp critical
if (TRUELENGTH(s)>=0) { // another thread may have set it while I was waiting, so check it again
if (TRUELENGTH(s)>0) // save any of R's own usage of tl (assumed positive, so we can both count and save in one scan), to restore
savetl(s); // afterwards. From R 2.14.0, tl is initialized to 0, prior to that it was random so this step saved too much.
// now save unique SEXP in ustr so i) we can loop through them afterwards and reset TRUELENGTH to 0 and ii) sort uniques when sorting too
if (ustr_alloc<=ustr_n) {
ustr_alloc = (ustr_alloc==0) ? 16384 : ustr_alloc*2; // small initial guess, negligible time to alloc 128KB (32 pages)
if (ustr_alloc>n) ustr_alloc = n; // clamp at n. Reaches n when fully unique (no dups)
ustr = realloc(ustr, ustr_alloc * sizeof(SEXP));
if (ustr==NULL) STOP("Unable to realloc %d * %d bytes in range_str", ustr_alloc, (int)sizeof(SEXP)); // # nocov
}
ustr[ustr_n++] = s;
SET_TRUELENGTH(s, -ustr_n); // unique in any order is fine. first-appearance order is achieved later in count_group
if (LENGTH(s)>ustr_maxlen) ustr_maxlen=LENGTH(s);
if (!anyneedutf8 && NEED2UTF8(s)) anyneedutf8=true;
}
}<LOOP-END> <OMP-START>#pragma omp parallel for num_threads(getDTthreads())<OMP-END> |
SebKrantz/collapse/misc/legacy/sorted out 1.1.0 - 1.2.0/data.table_forder.c | #pragma omp parallel for num_threads(getDTthreads()) | 100 | SEXP ans = PROTECT(allocVector(INTSXP, nrow)); n_protect++;
anso = INTEGER(ans);
TEND(0)
// <LOOP-START>for (int i=0; i<nrow; i++) anso[i]=i+1; // gdb 8.1.0.20180409-git very slow here, oddly
TEND(1)
savetl_init(); // from now on use Error not error
int ncol=length(by);
int keyAlloc = (ncol+n_cplx)*8 + 1; // +1 for NULL to mark end; calloc to initialize with NULLs
key = calloc(keyAlloc, sizeof(uint8_t *)); // needs to be before loop because part II relies on part I, column-by-column.
if (!key)
STOP("Unable to allocate %llu bytes of working memory", (unsigned long long)(keyAlloc*sizeof(uint8_t *))); // # nocov
nradix=0; // the current byte we're writing this column to; might be squashing into it (spare>0)
int spare=0; // the amount of bits remaining on the right of the current nradix byte
bool isReal=false;
bool complexRerun = false; // see comments below in CPLXSXP case
SEXP CplxPart = R_NilValue;
if (n_cplx) { CplxPart=PROTECT(allocVector(REALSXP, nrow)); n_protect++; }<LOOP-END> <OMP-START>#pragma omp parallel for num_threads(getDTthreads())<OMP-END> |
SebKrantz/collapse/misc/legacy/sorted out 1.1.0 - 1.2.0/data.table_forder.c | #pragma omp parallel for num_threads(getDTthreads()) | 100 |
switch(TYPEOF(x)) {
case INTSXP : case LGLSXP : {
int32_t *xd = INTEGER(x);
// <LOOP-START>for (int i=0; i<nrow; i++) {
uint64_t elem=0;
if (xd[i]==NA_INTEGER) { // TODO: go branchless if na_count==0
if (nalast==-1) anso[i]=0;
elem = naval;
} else {
elem = xd[i] ^ 0x80000000u;
}
WRITE_KEY
}<LOOP-END> <OMP-START>#pragma omp parallel for num_threads(getDTthreads())<OMP-END> |
SebKrantz/collapse/misc/legacy/sorted out 1.1.0 - 1.2.0/data.table_forder.c | #pragma omp parallel for num_threads(getDTthreads()) | 100 | EALSXP :
if (inherits(x, "integer64")) {
int64_t *xd = (int64_t *)REAL(x);
// <LOOP-START>for (int i=0; i<nrow; i++) {
uint64_t elem=0;
if (xd[i]==INT64_MIN) {
if (nalast==-1) anso[i]=0;
elem = naval;
} else {
elem = xd[i] ^ 0x8000000000000000u;
}
WRITE_KEY
}<LOOP-END> <OMP-START>#pragma omp parallel for num_threads(getDTthreads())<OMP-END> |
SebKrantz/collapse/misc/legacy/sorted out 1.1.0 - 1.2.0/data.table_forder.c | #pragma omp parallel for num_threads(getDTthreads()) | 100 | ion (skip bytes/mult by 10,100 etc) as currently it's often 6-8 bytes even for 3.14,3.15
// <LOOP-START>for (int i=0; i<nrow; i++) {
uint64_t elem=0;
if (!R_FINITE(xd[i])) {
if (isinf(xd[i])) elem = signbit(xd[i]) ? min-1 : max+1;
else {
if (nalast==-1) anso[i]=0; // for both NA and NaN
elem = ISNA(xd[i]) ? naval : nanval;
}
} else {
elem = dtwiddle(xd, i); // TODO: could avoid twiddle() if all positive finite which could be known from range_d.
// also R_FINITE is repeated within dtwiddle() currently, wastefully given the if() above
}
WRITE_KEY
}<LOOP-END> <OMP-START>#pragma omp parallel for num_threads(getDTthreads())<OMP-END> |
SebKrantz/collapse/misc/legacy/sorted out 1.1.0 - 1.2.0/data.table_forder.c | #pragma omp parallel for num_threads(getDTthreads()) | 100 | ITE_KEY
}
}
break;
case STRSXP : {
SEXP *xd = STRING_PTR(x);
// <LOOP-START>for (int i=0; i<nrow; i++) {
uint64_t elem=0;
if (xd[i]==NA_STRING) {
if (nalast==-1) anso[i]=0;
elem = naval;
} else {
elem = -TRUELENGTH(xd[i]);
}
WRITE_KEY
}<LOOP-END> <OMP-START>#pragma omp parallel for num_threads(getDTthreads())<OMP-END> |
SebKrantz/collapse/misc/legacy/sorted out 1.1.0 - 1.2.0/data.table_forder.c | #pragma omp parallel for num_threads(getDTthreads()) | 100 | anso will contain 0's for the NAs and will be considered not-sorted.
bool stop = false;
// <LOOP-START>for (int i=0; i<nrow; i++) {
if (stop) continue;
if (anso[i]!=i+1) stop=true;
}<LOOP-END> <OMP-START>#pragma omp parallel for num_threads(getDTthreads())<OMP-END> |
SebKrantz/collapse/misc/legacy/sorted out 1.1.0 - 1.2.0/data.table_forder.c | #pragma omp parallel for num_threads(getDTthreads()) | 100 | if (!TMP) STOP("Unable to allocate TMP for my_n=%d items in parallel batch counting", my_n);
// <LOOP-START>for (int batch=0; batch<nBatch; batch++) {
const int *restrict my_starts = starts + batch*256;
const uint16_t *restrict my_counts = counts + batch*256;
const int *restrict osub = anso + from + batch*batchSize; // the groups sit here contiguously
const uint8_t *restrict byte = ugrps + batch*256; // in appearance order always logged here in ugrps
const int my_ngrp = ngrps[batch];
for (int i=0; i<my_ngrp; i++, byte++) {
const uint16_t len = my_counts[*byte];
memcpy(TMP+my_starts[*byte], osub, len*sizeof(int));
osub += len;
}
}<LOOP-END> <OMP-START>#pragma omp parallel for num_threads(getDTthreads())<OMP-END> |
SebKrantz/collapse/misc/legacy/sorted out 1.1.0 - 1.2.0/data.table_forder.c | #pragma omp parallel for num_threads(getDTthreads()) | 100 | int currently (in future 8). To save team startup cost (but unlikely significant anyway)
// <LOOP-START>for (int batch=0; batch<nBatch; batch++) {
const int *restrict my_starts = starts + batch*256;
const uint16_t *restrict my_counts = counts + batch*256;
const uint8_t *restrict ksub = key[radix+1+r] + from + batch*batchSize; // the groups sit here contiguosly
const uint8_t *restrict byte = ugrps + batch*256; // in appearance order always logged here in ugrps
const int my_ngrp = ngrps[batch];
for (int i=0; i<my_ngrp; i++, byte++) {
const uint16_t len = my_counts[*byte];
memcpy((uint8_t *)TMP + my_starts[*byte], ksub, len);
ksub += len;
}
}<LOOP-END> <OMP-START>#pragma omp parallel for num_threads(getDTthreads())<OMP-END> |
SebKrantz/collapse/misc/legacy/sorted out 1.1.0 - 1.2.0/data.table_forder.c | #pragma omp parallel for ordered schedule(dynamic) num_threads(getDTthreads()) | 100 | o start a parallel team and there will be no nestedness here either.
if (retgrp) {
// <LOOP-START>for (int i=0; i<ngrp; i++) {
int start = from + starts[ugrp[i]];
radix_r(start, start+my_gs[i]-1, radix+1);
// #pragma omp ordered
flush();
}<LOOP-END> <OMP-START>#pragma omp parallel for ordered schedule(dynamic) num_threads(getDTthreads())<OMP-END> |
SebKrantz/collapse/misc/legacy/sorted out 1.1.0 - 1.2.0/data.table_forder.c | #pragma omp parallel for schedule(dynamic) num_threads(getDTthreads()) | 100 | // flush() is only relevant when retgrp==true so save the redundant ordered clause
// <LOOP-START>for (int i=0; i<ngrp; i++) {
int start = from + starts[ugrp[i]];
radix_r(start, start+my_gs[i]-1, radix+1);
}<LOOP-END> <OMP-START>#pragma omp parallel for schedule(dynamic) num_threads(getDTthreads())<OMP-END> |
SebKrantz/collapse/src/fnth_fmedian_fquantile.c | #pragma omp parallel for num_threads(nthreads) | 100 | tithreaded...
switch(TYPEOF(x)) {
case REALSXP: {
double *px = REAL(x)-1;
<LOOP-START>for(int gr = 0; gr < ng; ++gr)
pres[gr] = nth_double(px + pst[gr], po, pgs[gr], 1, narm, ret, Q);
break;
}
case INTSXP:
case LGLSXP: {
int *px = INTEGER(x)-1;
#pragma omp parallel for num_threads(nthreads)
for(int gr = 0; gr < ng; ++gr)
pres[gr] = nth_int(px + pst[gr], po, pgs[gr], 1, narm, ret, Q);
break;
}<LOOP-END> <OMP-START>#pragma omp parallel for num_threads(nthreads)<OMP-END> |
SebKrantz/collapse/src/fnth_fmedian_fquantile.c | #pragma omp parallel for num_threads(nthreads) | 100 | break;
}
case INTSXP:
case LGLSXP: {
int *px = INTEGER(x)-1;
<LOOP-START>for(int gr = 0; gr < ng; ++gr)
pres[gr] = nth_int(px + pst[gr], po, pgs[gr], 1, narm, ret, Q);
break;
}
default: error("Not Supported SEXP Type: '%s'", type2char(TYPEOF(x)));
}
} else { // Not sorted. Perhaps reordering x is faster?
switch(TYPEOF(x)) {
case REALSXP: {
double *px = REAL(x);
#pragma omp parallel for num_threads(nthreads)
for(int gr = 0; gr < ng; ++gr)
pres[gr] = nth_double(px, po + pst[gr], pgs[gr], 0, narm, ret, Q);
break;
}
case INTSXP:
case LGLSXP: {
int *px = INTEGER(x);
#pragma omp parallel for num_threads(nthreads)
for(int gr = 0; gr < ng; ++gr)
pres[gr] = nth_int(px, po + pst[gr], pgs[gr], 0, narm, ret, Q);
break;
}
default: error("Not Supported SEXP Type: '%s'", type2char(TYPEOF(x)));
}
}<LOOP-END> <OMP-START>#pragma omp parallel for num_threads(nthreads)<OMP-END> |
SebKrantz/collapse/src/fnth_fmedian_fquantile.c | #pragma omp parallel for num_threads(nthreads) | 100 | ng x is faster?
switch(TYPEOF(x)) {
case REALSXP: {
double *px = REAL(x);
<LOOP-START>for(int gr = 0; gr < ng; ++gr)
pres[gr] = nth_double(px, po + pst[gr], pgs[gr], 0, narm, ret, Q);
break;
}
case INTSXP:
case LGLSXP: {
int *px = INTEGER(x);
#pragma omp parallel for num_threads(nthreads)
for(int gr = 0; gr < ng; ++gr)
pres[gr] = nth_int(px, po + pst[gr], pgs[gr], 0, narm, ret, Q);
break;
}<LOOP-END> <OMP-START>#pragma omp parallel for num_threads(nthreads)<OMP-END> |
SebKrantz/collapse/src/fnth_fmedian_fquantile.c | #pragma omp parallel for num_threads(nthreads) | 100 | break;
}
case INTSXP:
case LGLSXP: {
int *px = INTEGER(x);
<LOOP-START>for(int gr = 0; gr < ng; ++gr)
pres[gr] = nth_int(px, po + pst[gr], pgs[gr], 0, narm, ret, Q);
break;
}
default: error("Not Supported SEXP Type: '%s'", type2char(TYPEOF(x)));
}
}
if(ATTRIB(x) != R_NilValue && !(isObject(x) && inherits(x, "ts"))) copyMostAttrib(x, res);
UNPROTECT(1);
return res;
}
// Expects pointer po to be decremented by 1
SEXP nth_g_impl_noalloc(SEXP x, int ng, int *pgs, int *po, int *pst, int sorted, int narm, int ret, double Q, void* x_cc) {
SEXP res = PROTECT(allocVector(REALSXP, ng));
double *pres = REAL(res);
if(sorted) {
switch(TYPEOF(x)) {
case REALSXP: {
double *px = REAL(x)-1;
for(int gr = 0; gr != ng; ++gr) pres[gr] = nth_double_noalloc(px + pst[gr], po, x_cc, pgs[gr], 1, narm, ret, Q);
break;
}
case INTSXP:
case LGLSXP: {
int *px = INTEGER(x)-1;
for(int gr = 0; gr != ng; ++gr) pres[gr] = nth_int_noalloc(px + pst[gr], po, x_cc, pgs[gr], 1, narm, ret, Q);
break;
}
default: error("Not Supported SEXP Type: '%s'", type2char(TYPEOF(x)));
}
} else {
switch(TYPEOF(x)) {
case REALSXP: {
double *px = REAL(x);
for(int gr = 0; gr != ng; ++gr) pres[gr] = nth_double_noalloc(px, po + pst[gr], x_cc, pgs[gr], 0, narm, ret, Q);
break;
}
case INTSXP:
case LGLSXP: {
int *px = INTEGER(x);
for(int gr = 0; gr != ng; ++gr) pres[gr] = nth_int_noalloc(px, po + pst[gr], x_cc, pgs[gr], 0, narm, ret, Q);
break;
}
default: error("Not Supported SEXP Type: '%s'", type2char(TYPEOF(x)));
}
}
if(ATTRIB(x) != R_NilValue && !(isObject(x) && inherits(x, "ts"))) copyMostAttrib(x, res);
UNPROTECT(1);
return res;
}<LOOP-END> <OMP-START>#pragma omp parallel for num_threads(nthreads)<OMP-END> |
SebKrantz/collapse/src/fnth_fmedian_fquantile.c | #pragma omp parallel for num_threads(nthreads) | 100 | e *pres = REAL(res);
switch(TYPEOF(x)) {
case REALSXP: {
double *px = REAL(x)-1;
<LOOP-START>for(int gr = 0; gr < ng; ++gr)
pres[gr] = nth_double_ord(px, po + pst[gr], pgs[gr], narm, ret, Q);
break;
}
case INTSXP:
case LGLSXP: {
int *px = INTEGER(x)-1;
#pragma omp parallel for num_threads(nthreads)
for(int gr = 0; gr < ng; ++gr)
pres[gr] = nth_int_ord(px, po + pst[gr], pgs[gr], narm, ret, Q);
break;
}<LOOP-END> <OMP-START>#pragma omp parallel for num_threads(nthreads)<OMP-END> |
SebKrantz/collapse/src/fnth_fmedian_fquantile.c | #pragma omp parallel for num_threads(nthreads) | 100 | ret, Q);
break;
}
case INTSXP:
case LGLSXP: {
int *px = INTEGER(x)-1;
<LOOP-START>for(int gr = 0; gr < ng; ++gr)
pres[gr] = nth_int_ord(px, po + pst[gr], pgs[gr], narm, ret, Q);
break;
}
default: error("Not Supported SEXP Type: '%s'", type2char(TYPEOF(x)));
}
if(ATTRIB(x) != R_NilValue && !(isObject(x) && inherits(x, "ts"))) copyMostAttrib(x, res);
UNPROTECT(1);
return res;
}
// Expects pointers pw and po to be decremented by 1
SEXP w_nth_g_ord_impl(SEXP x, double *pw, int ng, int *pgs, int *po, int *pst, int narm, int ret, double Q, int nthreads) {
if(nthreads > ng) nthreads = ng;
SEXP res = PROTECT(allocVector(REALSXP, ng));
double *pres = REAL(res);
switch(TYPEOF(x)) {
case REALSXP: {
double *px = REAL(x)-1;
#pragma omp parallel for num_threads(nthreads)
for(int gr = 0; gr < ng; ++gr)
pres[gr] = w_nth_double_ord(px, pw, po + pst[gr], DBL_MIN, pgs[gr], narm, ret, Q);
break;
}
case INTSXP:
case LGLSXP: {
int *px = INTEGER(x)-1;
#pragma omp parallel for num_threads(nthreads)
for(int gr = 0; gr < ng; ++gr)
pres[gr] = w_nth_int_ord(px, pw, po + pst[gr], DBL_MIN, pgs[gr], narm, ret, Q);
break;
}
default: error("Not Supported SEXP Type: '%s'", type2char(TYPEOF(x)));
}
if(ATTRIB(x) != R_NilValue && !(isObject(x) && inherits(x, "ts"))) copyMostAttrib(x, res);
UNPROTECT(1);
return res;
}<LOOP-END> <OMP-START>#pragma omp parallel for num_threads(nthreads)<OMP-END> |
SebKrantz/collapse/src/fnth_fmedian_fquantile.c | #pragma omp parallel for num_threads(nthreads) | 100 | e *pres = REAL(res);
switch(TYPEOF(x)) {
case REALSXP: {
double *px = REAL(x)-1;
<LOOP-START>for(int gr = 0; gr < ng; ++gr)
pres[gr] = w_nth_double_ord(px, pw, po + pst[gr], DBL_MIN, pgs[gr], narm, ret, Q);
break;
}
case INTSXP:
case LGLSXP: {
int *px = INTEGER(x)-1;
#pragma omp parallel for num_threads(nthreads)
for(int gr = 0; gr < ng; ++gr)
pres[gr] = w_nth_int_ord(px, pw, po + pst[gr], DBL_MIN, pgs[gr], narm, ret, Q);
break;
}<LOOP-END> <OMP-START>#pragma omp parallel for num_threads(nthreads)<OMP-END> |
SebKrantz/collapse/src/fnth_fmedian_fquantile.c | #pragma omp parallel for num_threads(nthreads) | 100 | ret, Q);
break;
}
case INTSXP:
case LGLSXP: {
int *px = INTEGER(x)-1;
<LOOP-START>for(int gr = 0; gr < ng; ++gr)
pres[gr] = w_nth_int_ord(px, pw, po + pst[gr], DBL_MIN, pgs[gr], narm, ret, Q);
break;
}
default: error("Not Supported SEXP Type: '%s'", type2char(TYPEOF(x)));
}
if(ATTRIB(x) != R_NilValue && !(isObject(x) && inherits(x, "ts"))) copyMostAttrib(x, res);
UNPROTECT(1);
return res;
}
// Expects pointers pw and po to be decremented by 1
SEXP w_nth_g_qsort_impl(SEXP x, double *pw, int ng, int *pgs, int *po, int *pst, int sorted, int narm, int ret, double Q, int nthreads) {
if(nthreads > ng) nthreads = ng;
SEXP res = PROTECT(allocVector(REALSXP, ng));
double *pres = REAL(res);
if(sorted) { // sorted by groups: need to offset both px and pw
switch(TYPEOF(x)) {
case REALSXP: {
double *px = REAL(x)-1;
#pragma omp parallel for num_threads(nthreads)
for(int gr = 0; gr < ng; ++gr)
pres[gr] = w_nth_double_qsort(px + pst[gr], pw + pst[gr], po, DBL_MIN, pgs[gr], 1, narm, ret, Q);
break;
}
case INTSXP:
case LGLSXP: {
int *px = INTEGER(x)-1;
#pragma omp parallel for num_threads(nthreads)
for(int gr = 0; gr < ng; ++gr)
pres[gr] = w_nth_int_qsort(px + pst[gr], pw + pst[gr], po, DBL_MIN, pgs[gr], 1, narm, ret, Q);
break;
}
default: error("Not Supported SEXP Type: '%s'", type2char(TYPEOF(x)));
}
} else {
switch(TYPEOF(x)) {
case REALSXP: {
double *px = REAL(x);
#pragma omp parallel for num_threads(nthreads)
for(int gr = 0; gr < ng; ++gr)
pres[gr] = w_nth_double_qsort(px, pw, po + pst[gr], DBL_MIN, pgs[gr], 0, narm, ret, Q);
break;
}
case INTSXP:
case LGLSXP: {
int *px = INTEGER(x);
#pragma omp parallel for num_threads(nthreads)
for(int gr = 0; gr < ng; ++gr)
pres[gr] = w_nth_int_qsort(px, pw, po + pst[gr], DBL_MIN, pgs[gr], 0, narm, ret, Q);
break;
}
default: error("Not Supported SEXP Type: '%s'", type2char(TYPEOF(x)));
}
}
if(ATTRIB(x) != R_NilValue && !(isObject(x) && inherits(x, "ts"))) copyMostAttrib(x, res);
UNPROTECT(1);
return res;
}<LOOP-END> <OMP-START>#pragma omp parallel for num_threads(nthreads)<OMP-END> |
SebKrantz/collapse/src/fnth_fmedian_fquantile.c | #pragma omp parallel for num_threads(nthreads) | 100 | oth px and pw
switch(TYPEOF(x)) {
case REALSXP: {
double *px = REAL(x)-1;
<LOOP-START>for(int gr = 0; gr < ng; ++gr)
pres[gr] = w_nth_double_qsort(px + pst[gr], pw + pst[gr], po, DBL_MIN, pgs[gr], 1, narm, ret, Q);
break;
}
case INTSXP:
case LGLSXP: {
int *px = INTEGER(x)-1;
#pragma omp parallel for num_threads(nthreads)
for(int gr = 0; gr < ng; ++gr)
pres[gr] = w_nth_int_qsort(px + pst[gr], pw + pst[gr], po, DBL_MIN, pgs[gr], 1, narm, ret, Q);
break;
}<LOOP-END> <OMP-START>#pragma omp parallel for num_threads(nthreads)<OMP-END> |
SebKrantz/collapse/src/fnth_fmedian_fquantile.c | #pragma omp parallel for num_threads(nthreads) | 100 | break;
}
case INTSXP:
case LGLSXP: {
int *px = INTEGER(x)-1;
<LOOP-START>for(int gr = 0; gr < ng; ++gr)
pres[gr] = w_nth_int_qsort(px + pst[gr], pw + pst[gr], po, DBL_MIN, pgs[gr], 1, narm, ret, Q);
break;
}
default: error("Not Supported SEXP Type: '%s'", type2char(TYPEOF(x)));
}
} else {
switch(TYPEOF(x)) {
case REALSXP: {
double *px = REAL(x);
#pragma omp parallel for num_threads(nthreads)
for(int gr = 0; gr < ng; ++gr)
pres[gr] = w_nth_double_qsort(px, pw, po + pst[gr], DBL_MIN, pgs[gr], 0, narm, ret, Q);
break;
}
case INTSXP:
case LGLSXP: {
int *px = INTEGER(x);
#pragma omp parallel for num_threads(nthreads)
for(int gr = 0; gr < ng; ++gr)
pres[gr] = w_nth_int_qsort(px, pw, po + pst[gr], DBL_MIN, pgs[gr], 0, narm, ret, Q);
break;
}
default: error("Not Supported SEXP Type: '%s'", type2char(TYPEOF(x)));
}
}<LOOP-END> <OMP-START>#pragma omp parallel for num_threads(nthreads)<OMP-END> |
SebKrantz/collapse/src/fnth_fmedian_fquantile.c | #pragma omp parallel for num_threads(nthreads) | 100 | }
} else {
switch(TYPEOF(x)) {
case REALSXP: {
double *px = REAL(x);
<LOOP-START>for(int gr = 0; gr < ng; ++gr)
pres[gr] = w_nth_double_qsort(px, pw, po + pst[gr], DBL_MIN, pgs[gr], 0, narm, ret, Q);
break;
}
case INTSXP:
case LGLSXP: {
int *px = INTEGER(x);
#pragma omp parallel for num_threads(nthreads)
for(int gr = 0; gr < ng; ++gr)
pres[gr] = w_nth_int_qsort(px, pw, po + pst[gr], DBL_MIN, pgs[gr], 0, narm, ret, Q);
break;
}<LOOP-END> <OMP-START>#pragma omp parallel for num_threads(nthreads)<OMP-END> |
SebKrantz/collapse/src/fnth_fmedian_fquantile.c | #pragma omp parallel for num_threads(nthreads) | 100 | break;
}
case INTSXP:
case LGLSXP: {
int *px = INTEGER(x);
<LOOP-START>for(int gr = 0; gr < ng; ++gr)
pres[gr] = w_nth_int_qsort(px, pw, po + pst[gr], DBL_MIN, pgs[gr], 0, narm, ret, Q);
break;
}
default: error("Not Supported SEXP Type: '%s'", type2char(TYPEOF(x)));
}
}
if(ATTRIB(x) != R_NilValue && !(isObject(x) && inherits(x, "ts"))) copyMostAttrib(x, res);
UNPROTECT(1);
return res;
}
// Functions for Export --------------------------------------------------------
int Rties2int(SEXP x) {
int tx = TYPEOF(x);
if(tx == INTSXP || tx == REALSXP || tx == LGLSXP) {
int ret = asInteger(x);
if(ret < 1 || ret > 9 || ret == 4) error("ties must be 1, 2, 3 or 5-9, you supplied: %d", ret);
return ret;
}
if(tx != STRSXP) error("ties must be integer or character");
const char * r = CHAR(STRING_ELT(x, 0)); // translateCharUTF8()
if(strcmp(r, "mean") == 0) return 1;
if(strcmp(r, "min") == 0) return 2;
if(strcmp(r, "max") == 0) return 3;
if(strcmp(r, "q5") == 0) return 5;
if(strcmp(r, "q6") == 0) return 6;
if(strcmp(r, "q7") == 0) return 7;
if(strcmp(r, "q8") == 0) return 8;
if(strcmp(r, "q9") == 0) return 9;
error("Unknown ties option: %s", r);
}<LOOP-END> <OMP-START>#pragma omp parallel for num_threads(nthreads)<OMP-END> |
SebKrantz/collapse/src/fnth_fmedian_fquantile.c | #pragma omp parallel for num_threads(nthreads) | 100 | \
}
/* Multithreading: does not work with radixorder
* } else {
<LOOP-START>for(int j = 0; j < l; ++j) {
int *pxo = (int *) Calloc(nrx, int);
// num1radixsort(pxo, TRUE, FALSE, px[j]); // Probably cannot be parallelized, can try R_orderVector1()
// R_orderVector1(pxo, nrx, px[j], TRUE, FALSE); // Also not thread safe, and also 0-indexed.
// for(int i = 0; i < nrx; ++i) pxo[i] += 1;
pout[j] = w_nth_ord_impl_dbl(px[j], pxo, pw, narm, ret, Q, h);
Free(pxo);
}<LOOP-END> <OMP-START>#pragma omp parallel for num_threads(nthreads)<OMP-END> |
SebKrantz/collapse/src/fsum.c | #pragma omp parallel for simd num_threads(nthreads) reduction(+:sum) | 100 | int j = 1;
sum = px[0];
while(ISNAN(sum) && j != l) sum = px[j++];
if(j != l) {
<LOOP-START>for(int i = j; i < l; ++i) sum += NISNAN(px[i]) ? px[i] : 0.0;
} else if(narm == 2) sum = 0.0;
} else {
sum = 0;
#pragma omp parallel for simd num_threads(nthreads) reduction(+:sum)
for(int i = 0; i < l; ++i) sum += px[i]; // Cannot have break statements in OpenMP for loop
}<LOOP-END> <OMP-START>#pragma omp parallel for simd num_threads(nthreads) reduction(+:sum)<OMP-END> |
SebKrantz/collapse/src/fsum.c | #pragma omp parallel for simd num_threads(nthreads) reduction(+:sum) | 100 | sum += NISNAN(px[i]) ? px[i] : 0.0;
} else if(narm == 2) sum = 0.0;
} else {
sum = 0;
<LOOP-START>for(int i = 0; i < l; ++i) sum += px[i]; // Cannot have break statements in OpenMP for loop
}
return sum;
}
// This is unsafe...
// void fsum_double_g_omp_impl(double *restrict pout, double *restrict px, int ng, int *restrict pg, int narm, int l, int nthreads) {
// if(narm) {
// for(int i = ng; i--; ) pout[i] = NA_REAL;
// #pragma omp parallel for num_threads(nthreads) reduction(+:pout[:ng])
// for(int i = 0; i < l; ++i) {
// if(!ISNAN(px[i])) {
// if(ISNAN(pout[pg[i]-1])) pout[pg[i]-1] = px[i];
// else pout[pg[i]-1] += px[i];
// }
// }
// } else {
// memset(pout, 0, sizeof(double) * ng);
// #pragma omp parallel for num_threads(nthreads) reduction(+:pout[:ng]) // shared(pout)
// for(int i = 0; i < l; ++i) {
// // #pragma omp atomic
// pout[pg[i]-1] += px[i]; // Used to stop loop when all groups passed with NA, but probably no speed gain since groups are mostly ordered.
// }
// }
// }<LOOP-END> <OMP-START>#pragma omp parallel for simd num_threads(nthreads) reduction(+:sum)<OMP-END> |
SebKrantz/collapse/src/fsum.c | #pragma omp parallel for num_threads(nthreads) reduction(+:pout[:ng]) | 100 | arm, int l, int nthreads) {
// if(narm) {
// for(int i = ng; i--; ) pout[i] = NA_REAL;
// <LOOP-START>// for(int i = 0; i < l; ++i) {
// if(!ISNAN(px[i])) {
// if(ISNAN(pout[pg[i]-1])) pout[pg[i]-1] = px[i];
// else pout[pg[i]-1] += px[i];
// }
// }<LOOP-END> <OMP-START>#pragma omp parallel for num_threads(nthreads) reduction(+:pout[:ng])<OMP-END> |
SebKrantz/collapse/src/fsum.c | #pragma omp parallel for num_threads(nthreads) reduction(+:pout[:ng]) | 100 | -1] += px[i];
// }
// }
// } else {
// memset(pout, 0, sizeof(double) * ng);
// <LOOP-START>// for(int i = 0; i < l; ++i) {
// // #pragma omp atomic
// pout[pg[i]-1] += px[i]; // Used to stop loop when all groups passed with NA, but probably no speed gain since groups are mostly ordered.
// }<LOOP-END> <OMP-START>#pragma omp parallel for num_threads(nthreads) reduction(+:pout[:ng]) <OMP-END> |
SebKrantz/collapse/src/fsum.c | #pragma omp parallel for simd num_threads(nthreads) reduction(+:sum) | 100 | hile(j!=l && (ISNAN(px[j]) || ISNAN(pw[j]))) ++j;
if(j != l) {
sum = px[j] * pw[j];
<LOOP-START>for(int i = j+1; i < l; ++i) sum += (NISNAN(px[i]) && NISNAN(pw[i])) ? px[i] * pw[i] : 0.0;
} else sum = narm == 1 ? NA_REAL : 0.0;
} else {
sum = 0;
#pragma omp parallel for simd num_threads(nthreads) reduction(+:sum)
for(int i = 0; i < l; ++i) sum += px[i] * pw[i];
}<LOOP-END> <OMP-START>#pragma omp parallel for simd num_threads(nthreads) reduction(+:sum)<OMP-END> |
SebKrantz/collapse/src/fsum.c | #pragma omp parallel for simd num_threads(nthreads) reduction(+:sum) | 100 | i])) ? px[i] * pw[i] : 0.0;
} else sum = narm == 1 ? NA_REAL : 0.0;
} else {
sum = 0;
<LOOP-START>for(int i = 0; i < l; ++i) sum += px[i] * pw[i];
}
return sum;
}
// This is unsafe...
// void fsum_weights_g_omp_impl(double *restrict pout, double *restrict px, int ng, int *restrict pg, double *restrict pw, int narm, int l, int nthreads) {
// if(narm) {
// for(int i = ng; i--; ) pout[i] = NA_REAL;
// #pragma omp parallel for num_threads(nthreads) reduction(+:pout[:ng])
// for(int i = 0; i < l; ++i) {
// if(ISNAN(px[i]) || ISNAN(pw[i])) continue;
// if(ISNAN(pout[pg[i]-1])) pout[pg[i]-1] = px[i] * pw[i];
// else pout[pg[i]-1] += px[i] * pw[i];
// }
// } else {
// memset(pout, 0, sizeof(double) * ng);
// #pragma omp parallel for num_threads(nthreads) reduction(+:pout[:ng])
// for(int i = 0; i < l; ++i) pout[pg[i]-1] += px[i] * pw[i]; // Used to stop loop when all groups passed with NA, but probably no speed gain since groups are mostly ordered.
// }
// }<LOOP-END> <OMP-START>#pragma omp parallel for simd num_threads(nthreads) reduction(+:sum)<OMP-END> |
SebKrantz/collapse/src/fsum.c | #pragma omp parallel for num_threads(nthreads) reduction(+:pout[:ng]) | 100 | arm, int l, int nthreads) {
// if(narm) {
// for(int i = ng; i--; ) pout[i] = NA_REAL;
// <LOOP-START>// for(int i = 0; i < l; ++i) {
// if(ISNAN(px[i]) || ISNAN(pw[i])) continue;
// if(ISNAN(pout[pg[i]-1])) pout[pg[i]-1] = px[i] * pw[i];
// else pout[pg[i]-1] += px[i] * pw[i];
// }<LOOP-END> <OMP-START>#pragma omp parallel for num_threads(nthreads) reduction(+:pout[:ng])<OMP-END> |
SebKrantz/collapse/src/fsum.c | #pragma omp parallel for num_threads(nthreads) reduction(+:pout[:ng]) | 100 | [i]-1] += px[i] * pw[i];
// }
// } else {
// memset(pout, 0, sizeof(double) * ng);
// <LOOP-START>// for(int i = 0; i < l; ++i) pout[pg[i]-1] += px[i] * pw[i]; // Used to stop loop when all groups passed with NA, but probably no speed gain since groups are mostly ordered.
// }
// }
// using long long internally is substantially faster than using doubles !!
double fsum_int_impl(const int *restrict px, const int narm, const int l) {
long long sum;
if(narm) {
int j = l-1;
while(px[j] == NA_INTEGER && j!=0) --j;
sum = (long long)px[j];
if(j == 0 && px[j] == NA_INTEGER) return narm == 1 ? NA_REAL : 0;
for(int i = j; i--; ) if(px[i] != NA_INTEGER) sum += (long long)px[i];
} else {
sum = 0;
for(int i = 0; i != l; ++i) {
if(px[i] == NA_INTEGER) return NA_REAL; // Need this, otherwise result is incorrect !!
sum += (long long)px[i];
}
}
return (double)sum;
}<LOOP-END> <OMP-START>#pragma omp parallel for num_threads(nthreads) reduction(+:pout[:ng])<OMP-END> |
SebKrantz/collapse/src/fsum.c | #pragma omp parallel for simd num_threads(nthreads) reduction(+:sum) | 100 | if(j == l && px[j-1] == NA_INTEGER) return narm == 1 ? NA_REAL : 0;
sum = (long long)px[j];
<LOOP-START>for(int i = j+1; i < l; ++i) sum += px[i] != NA_INTEGER ? (long long)px[i] : 0;
} else {
if(px[0] == NA_INTEGER || px[l-1] == NA_INTEGER) return NA_REAL;
sum = 0;
#pragma omp parallel for simd num_threads(nthreads) reduction(+:sum)
for(int i = 0; i < l; ++i) sum += (long long)px[i]; // Need this, else wrong result
}<LOOP-END> <OMP-START>#pragma omp parallel for simd num_threads(nthreads) reduction(+:sum)<OMP-END> |
SebKrantz/collapse/src/fsum.c | #pragma omp parallel for simd num_threads(nthreads) reduction(+:sum) | 100 | 0;
} else {
if(px[0] == NA_INTEGER || px[l-1] == NA_INTEGER) return NA_REAL;
sum = 0;
<LOOP-START>for(int i = 0; i < l; ++i) sum += (long long)px[i]; // Need this, else wrong result
}
return (double)sum;
}
// This is unsafe...
// void fsum_int_g_omp_impl(int *restrict pout, int *restrict px, int ng, int *restrict pg, int narm, int l, int nthreads) {
// long long ckof;
// if(narm) {
// for(int i = ng; i--; ) pout[i] = NA_INTEGER;
// int lsi;
// #pragma omp parallel for num_threads(nthreads) reduction(+:pout[:ng])
// for(int i = 0; i < l; ++i) {
// if(px[i] != NA_INTEGER) {
// lsi = pout[pg[i]-1];
// if(lsi == NA_INTEGER) pout[pg[i]-1] = px[i];
// else {
// ckof = (long long)lsi + px[i];
// if(ckof > INT_MAX || ckof <= INT_MIN) error("Integer overflow in one or more groups. Integers in R are bounded between 2,147,483,647 and -2,147,483,647. The sum within each group should be in that range.");
// pout[pg[i]-1] = (int)ckof;
// }
// }
// }
// } else {
// memset(pout, 0, sizeof(int) * ng);
// int lsi;
// #pragma omp parallel for num_threads(nthreads) reduction(+:pout[:ng])
// for(int i = 0; i < l; ++i) {
// if(px[i] == NA_INTEGER) {
// pout[pg[i]-1] = NA_INTEGER;
// continue;
// }
// lsi = pout[pg[i]-1];
// if(lsi != NA_INTEGER) { // Used to stop loop when all groups passed with NA, but probably no speed gain since groups are mostly ordered.
// ckof = (long long)lsi + px[i];
// if(ckof > INT_MAX || ckof <= INT_MIN) error("Integer overflow in one or more groups. Integers in R are bounded between 2,147,483,647 and -2,147,483,647. The sum within each group should be in that range.");
// pout[pg[i]-1] = (int)ckof;
// }
// }
// }
// }<LOOP-END> <OMP-START>#pragma omp parallel for simd num_threads(nthreads) reduction(+:sum)<OMP-END> |
SebKrantz/collapse/src/fsum.c | #pragma omp parallel for num_threads(nthreads) reduction(+:pout[:ng]) | 100 | ng ckof;
// if(narm) {
// for(int i = ng; i--; ) pout[i] = NA_INTEGER;
// int lsi;
// <LOOP-START>// for(int i = 0; i < l; ++i) {
// if(px[i] != NA_INTEGER) {
// lsi = pout[pg[i]-1];
// if(lsi == NA_INTEGER) pout[pg[i]-1] = px[i];
// else {
// ckof = (long long)lsi + px[i];
// if(ckof > INT_MAX || ckof <= INT_MIN) error("Integer overflow in one or more groups. Integers in R are bounded between 2,147,483,647 and -2,147,483,647. The sum within each group should be in that range.");
// pout[pg[i]-1] = (int)ckof;
// }
// }
// }<LOOP-END> <OMP-START>#pragma omp parallel for num_threads(nthreads) reduction(+:pout[:ng])<OMP-END> |
SebKrantz/collapse/src/fsum.c | #pragma omp parallel for num_threads(nthreads) reduction(+:pout[:ng]) | 100 |
// }
// }
// } else {
// memset(pout, 0, sizeof(int) * ng);
// int lsi;
// <LOOP-START>// for(int i = 0; i < l; ++i) {
// if(px[i] == NA_INTEGER) {
// pout[pg[i]-1] = NA_INTEGER;
// continue;
// }
// lsi = pout[pg[i]-1];
// if(lsi != NA_INTEGER) { // Used to stop loop when all groups passed with NA, but probably no speed gain since groups are mostly ordered.
// ckof = (long long)lsi + px[i];
// if(ckof > INT_MAX || ckof <= INT_MIN) error("Integer overflow in one or more groups. Integers in R are bounded between 2,147,483,647 and -2,147,483,647. The sum within each group should be in that range.");
// pout[pg[i]-1] = (int)ckof;
// }
// }<LOOP-END> <OMP-START>#pragma omp parallel for num_threads(nthreads) reduction(+:pout[:ng])<OMP-END> |
SebKrantz/collapse/src/fsum.c | #pragma omp parallel for num_threads(nthreads) | 100 | ) pout[j] = fsum_double_impl(px + j*l, narm, l);
} else if(col >= nthreads) {
<LOOP-START>for(int j = 0; j < col; ++j) pout[j] = fsum_double_impl(px + j*l, narm, l);
} else {
for(int j = 0; j != col; ++j) pout[j] = fsum_double_omp_impl(px + j*l, narm, l, nthreads);
}<LOOP-END> <OMP-START>#pragma omp parallel for num_threads(nthreads)<OMP-END> |
SebKrantz/collapse/src/fsum.c | #pragma omp parallel for num_threads(nthreads) | 100 | *l, ng, pg, narm, l);
} else {
if(nthreads > col) nthreads = col;
<LOOP-START>for(int j = 0; j < col; ++j) fsum_double_g_impl(pout + j*ng, px + j*l, ng, pg, narm, l);
}
}
break;
}
case INTSXP: {
int *px = INTEGER(x);
if(ng > 0) {
int *pout = INTEGER(out);
if(nthreads <= 1 || col == 1) {
for(int j = 0; j != col; ++j) fsum_int_g_impl(pout + j*ng, px + j*l, ng, pg, narm, l);
} else {
if(nthreads > col) nthreads = col;
#pragma omp parallel for num_threads(nthreads)
for(int j = 0; j < col; ++j) fsum_int_g_impl(pout + j*ng, px + j*l, ng, pg, narm, l);
}
} else {
double *restrict pout = REAL(out);
int anyoutl = 0;
if(nthreads <= 1) {
for(int j = 0; j != col; ++j) {
double sumj = fsum_int_impl(px + j*l, narm, l);
if(sumj > INT_MAX || sumj <= INT_MIN) anyoutl = 1;
pout[j] = sumj;
}
} else if(col >= nthreads) { // If high-dimensional: column-level parallelism
#pragma omp parallel for num_threads(nthreads)
for(int j = 0; j < col; ++j) {
double sumj = fsum_int_impl(px + j*l, narm, l);
if(sumj > INT_MAX || sumj <= INT_MIN) anyoutl = 1;
pout[j] = sumj;
}
} else {
for(int j = 0; j != col; ++j) {
double sumj = fsum_int_omp_impl(px + j*l, narm, l, nthreads);
if(sumj > INT_MAX || sumj <= INT_MIN) anyoutl = 1;
pout[j] = sumj;
}
}
if(anyoutl == 0) {
out = PROTECT(coerceVector(out, INTSXP));
matCopyAttr(out, x, Rdrop, ng);
UNPROTECT(nprotect + 1);
return out;
}
}
break;
}<LOOP-END> <OMP-START>#pragma omp parallel for num_threads(nthreads)<OMP-END> |
SebKrantz/collapse/src/fsum.c | #pragma omp parallel for num_threads(nthreads) | 100 | *l, ng, pg, narm, l);
} else {
if(nthreads > col) nthreads = col;
<LOOP-START>for(int j = 0; j < col; ++j) fsum_int_g_impl(pout + j*ng, px + j*l, ng, pg, narm, l);
}
} else {
double *restrict pout = REAL(out);
int anyoutl = 0;
if(nthreads <= 1) {
for(int j = 0; j != col; ++j) {
double sumj = fsum_int_impl(px + j*l, narm, l);
if(sumj > INT_MAX || sumj <= INT_MIN) anyoutl = 1;
pout[j] = sumj;
}
} else if(col >= nthreads) { // If high-dimensional: column-level parallelism
#pragma omp parallel for num_threads(nthreads)
for(int j = 0; j < col; ++j) {
double sumj = fsum_int_impl(px + j*l, narm, l);
if(sumj > INT_MAX || sumj <= INT_MIN) anyoutl = 1;
pout[j] = sumj;
}
} else {
for(int j = 0; j != col; ++j) {
double sumj = fsum_int_omp_impl(px + j*l, narm, l, nthreads);
if(sumj > INT_MAX || sumj <= INT_MIN) anyoutl = 1;
pout[j] = sumj;
}
}
if(anyoutl == 0) {
out = PROTECT(coerceVector(out, INTSXP));
matCopyAttr(out, x, Rdrop, ng);
UNPROTECT(nprotect + 1);
return out;
}
}<LOOP-END> <OMP-START>#pragma omp parallel for num_threads(nthreads)<OMP-END> |
SebKrantz/collapse/src/fsum.c | #pragma omp parallel for num_threads(nthreads) | 100 | } else if(col >= nthreads) { // If high-dimensional: column-level parallelism
<LOOP-START>for(int j = 0; j < col; ++j) {
double sumj = fsum_int_impl(px + j*l, narm, l);
if(sumj > INT_MAX || sumj <= INT_MIN) anyoutl = 1;
pout[j] = sumj;
}<LOOP-END> <OMP-START>#pragma omp parallel for num_threads(nthreads)<OMP-END> |
SebKrantz/collapse/src/fsum.c | #pragma omp parallel for num_threads(nthreads) | 100 | ++j) pout[j] = fsum_weights_impl(px + j*l, pw, narm, l);
} else if(col >= nthreads) {
<LOOP-START>for(int j = 0; j < col; ++j) pout[j] = fsum_weights_impl(px + j*l, pw, narm, l);
} else {
for(int j = 0; j != col; ++j) pout[j] = fsum_weights_omp_impl(px + j*l, pw, narm, l, nthreads);
}<LOOP-END> <OMP-START>#pragma omp parallel for num_threads(nthreads)<OMP-END> |
SebKrantz/collapse/src/fsum.c | #pragma omp parallel for num_threads(nthreads) | 100 | , px + j*l, ng, pg, pw, narm, l);
} else {
if(nthreads > col) nthreads = col;
<LOOP-START>for(int j = 0; j < col; ++j) fsum_weights_g_impl(pout + j*ng, px + j*l, ng, pg, pw, narm, l);
}
}
}
matCopyAttr(out, x, Rdrop, ng);
UNPROTECT(nprotect);
return out;
}
// For safe multithreading across data frame columns
double fsum_impl_dbl(SEXP x, int narm, int nthreads) {
int l = length(x);
if(l < 1) return NA_REAL;
if(nthreads <= 1) switch(TYPEOF(x)) {
case REALSXP: return fsum_double_impl(REAL(x), narm, l);
case LGLSXP:
case INTSXP: return fsum_int_impl(INTEGER(x), narm, l);
default: error("Unsupported SEXP type: '%s'", type2char(TYPEOF(x)));
}
switch(TYPEOF(x)) {
case REALSXP: return fsum_double_omp_impl(REAL(x), narm, l, nthreads);
case LGLSXP:
case INTSXP: return fsum_int_omp_impl(INTEGER(x), narm, l, nthreads);
default: error("Unsupported SEXP type: '%s'", type2char(TYPEOF(x)));
}
}<LOOP-END> <OMP-START>#pragma omp parallel for num_threads(nthreads)<OMP-END> |
SebKrantz/collapse/src/fsum.c | #pragma omp parallel for num_threads(nthreads) | 100 | != R_NilValue && !(isObject(xj) && inherits(xj, "ts"))) copyMostAttrib(xj, outj);
}
<LOOP-START>for(int j = 0; j < l; ++j) fsum_g_omp_impl(px[j], DATAPTR(pout[j]), ng, pg, narm);
} else {
for(int j = 0; j != l; ++j) pout[j] = fsum_g_impl(px[j], ng, pg, narm);
}<LOOP-END> <OMP-START>#pragma omp parallel for num_threads(nthreads)<OMP-END> |
SebKrantz/collapse/src/fsum.c | #pragma omp parallel for num_threads(nthreads) | 100 | up = 1;}
SET_VECTOR_ELT(x, j, coerceVector(xj, REALSXP));
}
}
<LOOP-START>for(int j = 0; j < l; ++j) fsum_weights_g_impl(REAL(pout[j]), REAL(px[j]), ng, pg, pw, narm, nrx);
} else {
for(int j = 0; j != l; ++j) pout[j] = fsum_wg_impl(px[j], ng, pg, pw, narm);
}<LOOP-END> <OMP-START>#pragma omp parallel for num_threads(nthreads)<OMP-END> |
SebKrantz/collapse/src/fsum.c | #pragma omp parallel for num_threads(nthreads) | 100 | / if(ng == 0) {
// if(cmth) { // If high-dimensional: column-level parallelism
// <LOOP-START>// for(int j = 0; j < col; ++j) fsum_double_impl(pout + j, px + j*l, narm, l);
// } else {
// for(int j = 0; j != col; ++j) fsum_double_omp_impl(pout + j, px + j*l, narm, l, nthreads);
// }<LOOP-END> <OMP-START>#pragma omp parallel for num_threads(nthreads)<OMP-END> |
SebKrantz/collapse/src/fsum.c | #pragma omp parallel for num_threads(nthreads) | 100 | }
// } else {
// if(cmth) { // If high-dimensional: column-level parallelism
// <LOOP-START>// for(int j = 0; j < col; ++j) fsum_double_g_impl(pout + j*ng, px + j*l, ng, pg, narm, l);
// } else {
// for(int j = 0; j != col; ++j) fsum_double_g_omp_impl(pout + j*ng, px + j*l, ng, pg, narm, l, nthreads);
// }<LOOP-END> <OMP-START>#pragma omp parallel for num_threads(nthreads)<OMP-END> |
SebKrantz/collapse/src/fsum.c | #pragma omp parallel for num_threads(nthreads) | 100 | ng, pg, narm, l);
// } else if(cmth) { // If high-dimensional: column-level parallelism
// <LOOP-START>// for(int j = 0; j < col; ++j) fsum_int_g_impl(pout + j*ng, px + j*l, ng, pg, narm, l);
// } else {
// for(int j = 0; j != col; ++j) fsum_int_g_omp_impl(pout + j*ng, px + j*l, ng, pg, narm, l, nthreads);
// }<LOOP-END> <OMP-START>#pragma omp parallel for num_threads(nthreads)<OMP-END> |
SebKrantz/collapse/src/fsum.c | #pragma omp parallel for num_threads(nthreads) | 100 | mj;
// }
// } else if(cmth) { // If high-dimensional: column-level parallelism
// <LOOP-START>// for(int j = 0; j < col; ++j) {
// double sumj = fsum_int_impl(px + j*l, narm, l);
// if(sumj > INT_MAX || sumj <= INT_MIN) anyoutl = 1;
// pout[j] = sumj;
// }<LOOP-END> <OMP-START>#pragma omp parallel for num_threads(nthreads)<OMP-END> |
SebKrantz/collapse/src/fsum.c | #pragma omp parallel for num_threads(nthreads) | 100 | ol; ++j) fsum_weights_impl(pout + j*ng, px + j*l, ng, pg, pw, narm, l);
// } else if(cmth) {
// <LOOP-START>// for(int j = 0; j < col; ++j) fsum_weights_impl(pout + j*ng, px + j*l, ng, pg, pw, narm, l);
// } else {
// for(int j = 0; j != col; ++j) fsum_weights_omp_impl(pout + j*ng, px + j*l, ng, pg, pw, narm, l, nthreads);
// }<LOOP-END> <OMP-START>#pragma omp parallel for num_threads(nthreads)<OMP-END> |
SebKrantz/collapse/src/fsum.c | #pragma omp parallel for num_threads(nthreads) | 100 | uble *pout = REAL(out);
// if(cmth) { // If high-dimensional: column-level parallelism
// <LOOP-START>// for(int j = 0; j < l; ++j) pout[j] = asReal(fsumC(px[j], Rng, g, w, Rnarm, Rnthreads1));
// } else {
// for(int j = 0; j != l; ++j) pout[j] = asReal(fsumC(px[j], Rng, g, w, Rnarm, Rnthreads));
// }<LOOP-END> <OMP-START>#pragma omp parallel for num_threads(nthreads)<OMP-END> |
SebKrantz/collapse/src/fsum.c | #pragma omp parallel for num_threads(nthreads) | 100 | t = PROTECT(allocVector(VECSXP, l)), *pout = SEXPPTR(out), *px = SEXPPTR(x);
// if(cmth) {
// <LOOP-START>// for(int j = 0; j < l; ++j) pout[j] = fsumC(px[j], Rng, g, w, Rnarm, Rnthreads1);
// } else {
// for(int j = 0; j != l; ++j) pout[j] = fsumC(px[j], Rng, g, w, Rnarm, Rnthreads);
// }<LOOP-END> <OMP-START>#pragma omp parallel for num_threads(nthreads)<OMP-END> |
SebKrantz/collapse/src/fmean.c | #pragma omp parallel for simd num_threads(nthreads) reduction(+:mean,n) | 100 | nst int narm, const int l, const int nthreads) {
double mean = 0;
if(narm) {
int n = 0;
<LOOP-START>for(int i = 0; i < l; ++i) {
int tmp = NISNAN(px[i]);
mean += tmp ? px[i] : 0.0;
n += tmp ? 1 : 0;
}<LOOP-END> <OMP-START>#pragma omp parallel for simd num_threads(nthreads) reduction(+:mean,n)<OMP-END> |
SebKrantz/collapse/src/fmean.c | #pragma omp parallel for simd num_threads(nthreads) reduction(+:mean) | 100 | n += tmp ? px[i] : 0.0;
n += tmp ? 1 : 0;
}
return n == 0 ? NA_REAL : mean / n;
}
<LOOP-START>for(int i = 0; i < l; ++i) mean += px[i];
return mean / l;
}
void fmean_double_g_impl(double *restrict pout, const double *restrict px, const int ng, const int *restrict pg, const int *restrict pgs, const int narm, const int l) {
memset(pout, 0, sizeof(double) * ng);
if(narm) {
int *restrict n = (int*)Calloc(ng, int);
for(int i = 0, gi; i != l; ++i) {
if(ISNAN(px[i])) continue;
gi = pg[i]-1;
pout[gi] += px[i];
++n[gi];
}
for(int i = ng; i--; ) {
if(n[i] == 0) pout[i] = NA_REAL;
else pout[i] /= n[i];
}
Free(n);
} else {
--pout;
for(int i = l; i--; ) pout[pg[i]] += px[i]; // Used to stop loop when all groups passed with NA, but probably no speed gain since groups are mostly ordered.
++pout;
for(int i = ng; i--; ) pout[i] /= pgs[i];
}
}<LOOP-END> <OMP-START>#pragma omp parallel for simd num_threads(nthreads) reduction(+:mean)<OMP-END> |
SebKrantz/collapse/src/fmean.c | #pragma omp parallel for simd num_threads(nthreads) reduction(+:mean,sumw) | 100 | w, const int narm, const int l, const int nthreads) {
double mean = 0, sumw = 0;
if(narm) {
<LOOP-START>for(int i = 0; i < l; ++i) {
int tmp = NISNAN(px[i]) + NISNAN(pw[i]) == 2; // && doesn't vectorize for some reason
mean += tmp ? px[i] * pw[i] : 0.0;
sumw += tmp ? pw[i] : 0.0;
}<LOOP-END> <OMP-START>#pragma omp parallel for simd num_threads(nthreads) reduction(+:mean,sumw)<OMP-END> |
SebKrantz/collapse/src/fmean.c | #pragma omp parallel for simd num_threads(nthreads) reduction(+:mean,sumw) | 100 | sumw += tmp ? pw[i] : 0.0;
}
if(mean == 0 && sumw == 0) sumw = NA_REAL;
} else {
<LOOP-START>for(int i = 0; i < l; ++i) {
mean += px[i] * pw[i];
sumw += pw[i];
}<LOOP-END> <OMP-START>#pragma omp parallel for simd num_threads(nthreads) reduction(+:mean,sumw)<OMP-END> |
SebKrantz/collapse/src/fmean.c | #pragma omp parallel for simd num_threads(nthreads) reduction(+:mean,n) | 100 | int l, const int nthreads) {
long long mean = 0;
double dmean;
if(narm) {
int n = 0;
<LOOP-START>for(int i = 0; i < l; ++i) {
int tmp = px[i] != NA_INTEGER;
mean += tmp ? px[i] : 0;
n += tmp ? 1 : 0;
}<LOOP-END> <OMP-START>#pragma omp parallel for simd num_threads(nthreads) reduction(+:mean,n)<OMP-END> |
SebKrantz/collapse/src/fmean.c | #pragma omp parallel for simd num_threads(nthreads) reduction(+:mean) | 100 | ouble)mean / n;
} else {
if(px[0] == NA_INTEGER || px[l-1] == NA_INTEGER) return NA_REAL;
<LOOP-START>for(int i = 0; i < l; ++i) mean += px[i];
dmean = (double)mean / l;
}
return dmean;
}
void fmean_int_g_impl(double *restrict pout, const int *restrict px, const int ng, const int *restrict pg, const int *restrict pgs, const int narm, const int l) {
memset(pout, 0, sizeof(double) * ng);
if(narm) {
int *restrict n = (int*)Calloc(ng, int);
for(int i = 0, gi; i != l; ++i) {
if(px[i] == NA_INTEGER) continue;
gi = pg[i]-1;
pout[gi] += px[i];
++n[gi];
}
for(int i = ng; i--; ) {
if(n[i] == 0) pout[i] = NA_REAL;
else pout[i] /= n[i];
}
Free(n);
} else {
--pout;
for(int i = l; i--; ) pout[pg[i]] += px[i]; // Used to stop loop when all groups passed with NA, but probably no speed gain since groups are mostly ordered.
++pout;
for(int i = ng; i--; ) pout[i] /= pgs[i];
}
}<LOOP-END> <OMP-START>#pragma omp parallel for simd num_threads(nthreads) reduction(+:mean)<OMP-END> |
SebKrantz/collapse/src/fmean.c | #pragma omp parallel for num_threads(nthreads) | 100 | pout[j] = fmean_double_impl(px + j*l, narm, l);
} else if(col >= nthreads) {
<LOOP-START>for(int j = 0; j < col; ++j) pout[j] = fmean_double_impl(px + j*l, narm, l);
} else {
for(int j = 0; j != col; ++j) pout[j] = fmean_double_omp_impl(px + j*l, narm, l, nthreads);
}<LOOP-END> <OMP-START>#pragma omp parallel for num_threads(nthreads)<OMP-END> |
SebKrantz/collapse/src/fmean.c | #pragma omp parallel for num_threads(nthreads) | 100 | g, pg, pgs, narm, l);
} else {
if(nthreads > col) nthreads = col;
<LOOP-START>for(int j = 0; j < col; ++j) fmean_double_g_impl(pout + j*ng, px + j*l, ng, pg, pgs, narm, l);
}
}
break;
}
case INTSXP: {
const int *px = INTEGER(x);
if(ng > 0) {
if(nthreads <= 1 || col == 1) {
for(int j = 0; j != col; ++j) fmean_int_g_impl(pout + j*ng, px + j*l, ng, pg, pgs, narm, l);
} else {
if(nthreads > col) nthreads = col;
#pragma omp parallel for num_threads(nthreads)
for(int j = 0; j < col; ++j) fmean_int_g_impl(pout + j*ng, px + j*l, ng, pg, pgs, narm, l);
}
} else {
if(nthreads <= 1) {
for(int j = 0; j != col; ++j) pout[j] = fmean_int_impl(px + j*l, narm, l);
} else if(col >= nthreads) {
#pragma omp parallel for num_threads(nthreads)
for(int j = 0; j < col; ++j) pout[j] = fmean_int_impl(px + j*l, narm, l);
} else {
for(int j = 0; j != col; ++j) pout[j] = fmean_int_omp_impl(px + j*l, narm, l, nthreads);
}
}
break;
}<LOOP-END> <OMP-START>#pragma omp parallel for num_threads(nthreads)<OMP-END> |
SebKrantz/collapse/src/fmean.c | #pragma omp parallel for num_threads(nthreads) | 100 | g, pg, pgs, narm, l);
} else {
if(nthreads > col) nthreads = col;
<LOOP-START>for(int j = 0; j < col; ++j) fmean_int_g_impl(pout + j*ng, px + j*l, ng, pg, pgs, narm, l);
}
} else {
if(nthreads <= 1) {
for(int j = 0; j != col; ++j) pout[j] = fmean_int_impl(px + j*l, narm, l);
} else if(col >= nthreads) {
#pragma omp parallel for num_threads(nthreads)
for(int j = 0; j < col; ++j) pout[j] = fmean_int_impl(px + j*l, narm, l);
} else {
for(int j = 0; j != col; ++j) pout[j] = fmean_int_omp_impl(px + j*l, narm, l, nthreads);
}
}<LOOP-END> <OMP-START>#pragma omp parallel for num_threads(nthreads)<OMP-END> |
SebKrantz/collapse/src/fmean.c | #pragma omp parallel for num_threads(nthreads) | 100 | +j) pout[j] = fmean_int_impl(px + j*l, narm, l);
} else if(col >= nthreads) {
<LOOP-START>for(int j = 0; j < col; ++j) pout[j] = fmean_int_impl(px + j*l, narm, l);
} else {
for(int j = 0; j != col; ++j) pout[j] = fmean_int_omp_impl(px + j*l, narm, l, nthreads);
}<LOOP-END> <OMP-START>#pragma omp parallel for num_threads(nthreads)<OMP-END> |
SebKrantz/collapse/src/fmean.c | #pragma omp parallel for num_threads(nthreads) | 100 | +j) pout[j] = fmean_weights_impl(px + j*l, pw, narm, l);
} else if(col >= nthreads) {
<LOOP-START>for(int j = 0; j < col; ++j) pout[j] = fmean_weights_impl(px + j*l, pw, narm, l);
} else {
for(int j = 0; j != col; ++j) pout[j] = fmean_weights_omp_impl(px + j*l, pw, narm, l, nthreads);
}<LOOP-END> <OMP-START>#pragma omp parallel for num_threads(nthreads)<OMP-END> |
SebKrantz/collapse/src/fmean.c | #pragma omp parallel for num_threads(nthreads) | 100 | , px + j*l, ng, pg, pw, narm, l);
} else {
if(nthreads > col) nthreads = col;
<LOOP-START>for(int j = 0; j < col; ++j) fmean_weights_g_impl(pout + j*ng, px + j*l, ng, pg, pw, narm, l);
}
}
}
matCopyAttr(out, x, Rdrop, ng);
UNPROTECT(nprotect);
return out;
}
// For safe multithreading across data frame columns
double fmean_impl_dbl(SEXP x, int narm, int nthreads) {
int l = length(x);
if(l < 1) return NA_REAL;
if(nthreads <= 1) switch(TYPEOF(x)) {
case REALSXP: return fmean_double_impl(REAL(x), narm, l);
case LGLSXP:
case INTSXP: return fmean_int_impl(INTEGER(x), narm, l);
default: error("Unsupported SEXP type: '%s'", type2char(TYPEOF(x)));
}
switch(TYPEOF(x)) {
case REALSXP: return fmean_double_omp_impl(REAL(x), narm, l, nthreads);
case LGLSXP:
case INTSXP: return fmean_int_omp_impl(INTEGER(x), narm, l, nthreads);
default: error("Unsupported SEXP type: '%s'", type2char(TYPEOF(x)));
}
}<LOOP-END> <OMP-START>#pragma omp parallel for num_threads(nthreads)<OMP-END> |
SebKrantz/collapse/src/fmean.c | #pragma omp parallel for num_threads(nthreads) | 100 | != R_NilValue && !(isObject(xj) && inherits(xj, "ts"))) copyMostAttrib(xj, outj);
}
<LOOP-START>for(int j = 0; j < l; ++j) fmean_g_omp_impl(px[j], DATAPTR(pout[j]), ng, pg, pgs, narm);
} else {
for(int j = 0; j != l; ++j) pout[j] = fmean_g_impl(px[j], ng, pg, pgs, narm);
}<LOOP-END> <OMP-START>#pragma omp parallel for num_threads(nthreads)<OMP-END> |
SebKrantz/collapse/src/fmean.c | #pragma omp parallel for num_threads(nthreads) | 100 | up = 1;}
SET_VECTOR_ELT(x, j, coerceVector(xj, REALSXP));
}
}
<LOOP-START>for(int j = 0; j < l; ++j) fmean_weights_g_impl(REAL(pout[j]), REAL(px[j]), ng, pg, pw, narm, nrx);
} else {
for(int j = 0; j != l; ++j) pout[j] = fmean_wg_impl(px[j], ng, pg, pw, narm);
}<LOOP-END> <OMP-START>#pragma omp parallel for num_threads(nthreads)<OMP-END> |
SebKrantz/collapse/src/data.table_subset.c | #pragma omp parallel for num_threads(getDTthreads()) | 100 | int *idxp = INTEGER(idx);
bool stop = false;
// <LOOP-START>#pragma omp simd reduction(|:stop)
for (int i = 0; i < n; ++i) {
int elem = idxp[i];
stop |= (elem<1 && elem!=NA_INTEGER) || elem>max;
}<LOOP-END> <OMP-START>#pragma omp parallel for num_threads(getDTthreads())<OMP-END> |
SebKrantz/collapse/src/programming.c | #pragma omp parallel for num_threads(nthreads) | 100 | // Full distance matrix
if(nthreads > 1) {
if(nthreads > nrow-1) nthreads = nrow-1;
<LOOP-START>for(int k = 1; k < nrow; ++k) { // Row vectors to compute distances with
int nmk = nrow - k;
double *presk = pres + l - nmk*(nmk+1)/2, // https://en.wikipedia.org/wiki/1_%2B_2_%2B_3_%2B_4_%2B_%E2%8B%AF
*pxj = px + k, v;
for(int j = 0; j != ncol; ++j) { // Elements of the row vector at hand
v = pxj[-1];
#pragma omp simd
for(int i = 0; i < nmk; ++i) { // All remaining rows to compute the distance to
double tmp = pxj[i] - v;
presk[i] += tmp * tmp;
}
pxj += nrow;
}
}<LOOP-END> <OMP-START>#pragma omp parallel for num_threads(nthreads)<OMP-END> |
SebKrantz/collapse/src/programming.c | #pragma omp parallel for simd num_threads(nthreads) | 100 | for (int j = 0; j < ncol; ++j) {
double *pxj = px + j * nrow, v = pv[j];
<LOOP-START>for (int i = 0; i < nrow; ++i) {
double tmp = pxj[i] - v;
pres[i] += tmp * tmp;
}<LOOP-END> <OMP-START>#pragma omp parallel for simd num_threads(nthreads)<OMP-END> |
SebKrantz/collapse/src/programming.c | #pragma omp parallel for num_threads(nthreads) reduction(+:dres) | 100 | double dres = 0.0;
if(nthreads > 1) {
if(nthreads > ncol) nthreads = ncol;
<LOOP-START>for (int i = 0; i < ncol; ++i) {
double tmp = px[i] - pv[i];
dres += tmp * tmp;
}<LOOP-END> <OMP-START>#pragma omp parallel for num_threads(nthreads) reduction(+:dres)<OMP-END> |
SebKrantz/collapse/src/programming.c | #pragma omp parallel for simd num_threads(nthreads) | 100 | he square root loop below
}
}
// Square Root
if(ret == 1) {
if(nthreads > 1) {
<LOOP-START>for (size_t i = 0; i < l; ++i) pres[i] = sqrt(pres[i]);
} else {
#pragma omp simd
for (size_t i = 0; i < l; ++i) pres[i] = sqrt(pres[i]);
}<LOOP-END> <OMP-START>#pragma omp parallel for simd num_threads(nthreads)<OMP-END> |
SebKrantz/collapse/src/fndistinct.c | #pragma omp parallel for num_threads(nthreads) | 100 | readed...
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 + pst[gr]-1, po, pgs[gr], 1, 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 + pst[gr]-1, po, pgs[gr], M, 1, 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 + 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 | 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 + pst[gr]-1, po, pgs[gr], M, 1, 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 + pst[gr]-1, po, pgs[gr], 1, narm);
}<LOOP-END> <OMP-START>#pragma omp parallel for num_threads(nthreads)<OMP-END> |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.