void predict2(struct loess_struct* lo, double* eval,
double* fit, double* se_fit, long m, long se)
{
long size_info[3];
size_info[0] = lo->in.p;
size_info[1] = lo->in.n;
size_info[2] = m;
pred_(lo->in.y, lo->in.x, eval, size_info, &lo->out.s,
lo->in.weights,
lo->out.robust,
&lo->model.span,
&lo->model.degree,
&lo->model.normalize,
lo->model.parametric,
lo->model.drop_square,
&lo->control.surface,
&lo->control.cell,
&lo->model.family,
lo->kd_tree.parameter,
lo->kd_tree.a,
lo->kd_tree.xi,
lo->kd_tree.vert,
lo->kd_tree.vval,
lo->out.divisor,
&se,
fit,
se_fit);
}
void advance()
{
do
{
++current_;
}
while((current_ != end_) && (!pred_(*current_)));
} // advance
void check_for_unused_instances() {
auto iter =
std::remove_if(using_instances_.begin(), using_instances_.end(),
[this](const_pointer instance) {
if (pred_(instance)) {
push(instance);
return true;
}
return false;
});
using_instances_.erase(iter, using_instances_.cend());
}
void
predict(double *eval, int m, loess *lo, prediction *pre, int se)
{
int size_info[3];
void pred_();
pre->fit = (double *) malloc(m * sizeof(double));
pre->se_fit = (double *) malloc(m * sizeof(double));
pre->residual_scale = lo->outputs.s;
pre->df = (lo->outputs.one_delta * lo->outputs.one_delta) /
lo->outputs.two_delta;
size_info[0] = lo->inputs.p;
size_info[1] = lo->inputs.n;
size_info[2] = m;
error_status = 0;
lo->status.err_status = 0;
lo->status.err_msg = NULL;
pred_(lo->inputs.y,
lo->inputs.x, eval,
size_info,
&lo->outputs.s,
lo->inputs.weights,
lo->outputs.robust,
&lo->model.span,
&lo->model.degree,
&lo->model.normalize,
lo->model.parametric,
lo->model.drop_square,
&lo->control.surface,
&lo->control.cell,
&lo->model.family,
lo->kd_tree.parameter,
lo->kd_tree.a,
lo->kd_tree.xi,
lo->kd_tree.vert,
lo->kd_tree.vval,
lo->outputs.divisor,
&se,
pre->fit,
pre->se_fit);
if(error_status){
lo->status.err_status = error_status;
lo->status.err_msg = error_message;
}
}
bool operator()(T&& t) const
{
return !pred_(val_, std::forward<T>(t));
}
void operator() (const src_container_type & src_container, dst_container_type & dst_container)
{
for (typename src_container_type::const_iterator it = src_container.begin(); it != src_container.end(); ++it)
if (pred_(*it))
dst_container.insert( *it );
}
void operator() (container_type & src_container, viennagrid::view<base_container_type, handle_container_tag> & dst_view)
{
for (typename container_type::iterator it = src_container.begin(); it != src_container.end(); ++it)
if (pred_( *it ))
dst_view.insert_handle( it.handle() );
}
bool operator()(T&& t) const
{
return pred_(std::forward<T>(t), val_);
}
filter_iterator(const iterator_type& begin, const iterator_type& end, const predicate_type& pred):
current_(begin), end_(end), pred_(pred)
{
while((current_ != end_) && (!pred_(*current_))) // why do we need here? DRY, see method advance() below.
++current_;
} // filter_iterator
