110 std::size_t num_groups,
111 const Index_* group_size,
112 Output_* output_means,
113 Output_* output_variances,
115 Index_* valid_group_size)
117 std::fill_n(output_means, num_groups, 0);
118 std::fill_n(output_variances, num_groups, 0);
120 ::tatami_stats::internal::nanable_ifelse<Value_>(
123 std::fill_n(valid_group_size, num_groups, 0);
125 for (Index_ j = 0; j < num; ++j) {
127 if (!std::isnan(x)) {
129 output_means[b] += x;
130 ++valid_group_size[b];
133 internal::finish_means(num_groups, valid_group_size, output_means);
135 for (Index_ j = 0; j < num; ++j) {
137 if (!std::isnan(x)) {
139 auto delta = x - output_means[b];
140 output_variances[b] += delta * delta;
143 internal::finish_variances(num_groups, valid_group_size, output_variances);
146 for (Index_ j = 0; j < num; ++j) {
147 output_means[group[j]] += ptr[j];
149 internal::finish_means(num_groups, group_size, output_means);
151 for (Index_ j = 0; j < num; ++j) {
153 auto delta = ptr[j] - output_means[b];
154 output_variances[b] += delta * delta;
156 internal::finish_variances(num_groups, group_size, output_variances);
199 std::size_t num_groups,
200 const Index_* group_size,
201 Output_* output_means,
202 Output_* output_variances,
203 Index_* output_nonzero,
205 Index_* valid_group_size)
207 std::fill_n(output_means, num_groups, 0);
208 std::fill_n(output_nonzero, num_groups, 0);
209 std::fill_n(output_variances, num_groups, 0);
211 ::tatami_stats::internal::nanable_ifelse<Value_>(
214 std::copy_n(group_size, num_groups, valid_group_size);
216 for (Index_ j = 0; j < num_nonzero; ++j) {
218 auto b = group[index[j]];
219 if (!std::isnan(x)) {
220 output_means[b] += x;
221 ++(output_nonzero[b]);
223 --(valid_group_size[b]);
226 internal::finish_means(num_groups, valid_group_size, output_means);
228 for (Index_ j = 0; j < num_nonzero; ++j) {
230 if (!std::isnan(x)) {
231 auto b = group[index[j]];
232 auto delta = x - output_means[b];
233 output_variances[b] += delta * delta;
236 for (
decltype(num_groups) b = 0; b < num_groups; ++b) {
237 output_variances[b] += output_means[b] * output_means[b] * (valid_group_size[b] - output_nonzero[b]);
239 internal::finish_variances(num_groups, valid_group_size, output_variances);
242 for (Index_ j = 0; j < num_nonzero; ++j) {
243 auto b = group[index[j]];
244 output_means[b] += value[j];
247 internal::finish_means(num_groups, group_size, output_means);
249 for (Index_ j = 0; j < num_nonzero; ++j) {
250 auto b = group[index[j]];
251 auto delta = value[j] - output_means[b];
252 output_variances[b] += delta * delta;
254 for (
decltype(num_groups) b = 0; b < num_groups; ++b) {
255 output_variances[b] += output_means[b] * output_means[b] * (group_size[b] - output_nonzero[b]);
257 internal::finish_variances(num_groups, group_size, output_variances);
286 Index_ dim = (row ? mat.
nrow() : mat.
ncol());
287 Index_ otherdim = (row ? mat.
ncol() : mat.
nrow());
296 auto tmp_means = sanisizer::create<std::vector<Output_> >(num_groups);
297 auto output_variances = sanisizer::create<std::vector<Output_> >(num_groups);
298 auto tmp_nonzero = sanisizer::create<std::vector<Index_> >(num_groups);
299 auto valid_group_size = sanisizer::create<std::vector<Index_> >(sopt.
skip_nan ? num_groups : 0);
301 for (Index_ i = 0; i < len; ++i) {
302 auto range = ext->fetch(xbuffer.data(), ibuffer.data());
311 output_variances.data(),
314 valid_group_size.data()
317 for (
decltype(num_groups) g = 0; g < num_groups; ++g) {
318 output[g][i + start] = output_variances[g];
331 std::vector<variances::RunningSparse<Output_, Value_, Index_> > runners;
332 runners.reserve(num_groups);
333 std::vector<LocalOutputBuffer<Output_> > local_var_output;
334 local_var_output.reserve(num_groups);
335 std::vector<std::vector<Output_> > local_mean_output;
336 local_mean_output.reserve(num_groups);
338 for (
decltype(num_groups) g = 0; g < num_groups; ++g) {
339 local_var_output.emplace_back(thread, start, len, output[g]);
340 local_mean_output.emplace_back(len);
341 runners.emplace_back(len, local_mean_output.back().data(), local_var_output.back().data(), sopt.
skip_nan, start);
348 for (
int i = 0; i < otherdim; ++i) {
349 auto range = ext->fetch(xbuffer.data(), ibuffer.data());
350 runners[group[i]].add(range.value, range.index, range.number);
353 for (
decltype(num_groups) g = 0; g < num_groups; ++g) {
355 local_var_output[g].transfer();
366 auto tmp_means = sanisizer::create<std::vector<Output_> >(num_groups);
367 auto output_variances = sanisizer::create<std::vector<Output_> >(num_groups);
368 auto valid_group_size = sanisizer::create<std::vector<Index_> >(sopt.
skip_nan ? num_groups : 0);
370 for (Index_ i = 0; i < len; ++i) {
371 auto ptr = ext->fetch(xbuffer.data());
379 output_variances.data(),
381 valid_group_size.data()
384 for (
decltype(num_groups) g = 0; g < num_groups; ++g) {
385 output[g][i + start] = output_variances[g];
392 std::vector<variances::RunningDense<Output_, Value_, Index_> > runners;
393 runners.reserve(num_groups);
394 std::vector<LocalOutputBuffer<Output_> > local_var_output;
395 local_var_output.reserve(num_groups);
396 std::vector<std::vector<Output_> > local_mean_output;
397 local_mean_output.reserve(num_groups);
399 for (
decltype(num_groups) g = 0; g < num_groups; ++g) {
400 local_var_output.emplace_back(thread, start, len, output[g]);
401 local_mean_output.emplace_back(len);
402 runners.emplace_back(len, local_mean_output.back().data(), local_var_output.back().data(), sopt.
skip_nan);
408 for (Index_ i = 0; i < otherdim; ++i) {
409 auto ptr = ext->fetch(xbuffer.data());
410 runners[group[i]].add(ptr);
413 for (
decltype(num_groups) g = 0; g < num_groups; ++g) {
415 local_var_output[g].transfer();
void direct(const Value_ *ptr, Index_ num, const Group_ *group, std::size_t num_groups, const Index_ *group_size, Output_ *output_means, Output_ *output_variances, bool skip_nan, Index_ *valid_group_size)
Definition grouped_variances.hpp:106