void test_lcp_random_sequential_access(Lcp& lcp, typename Lcp::size_type times=1000000, typename Lcp::size_type seq_len=64)
{
typedef typename Lcp::size_type size_type;
size_type n = lcp.size();
if (times > n)
times = n;
if (seq_len >= n)
seq_len = n-1;
const int s = 20;
const uint64_t mask = (1<<s)-1;
int_vector<64> rands(1<<s ,0);
util::set_random_bits(rands, 17);
for (int_vector<64>::size_type i=0; i < rands.size(); ++i) {
rands[i] = rands[i] % n;
if (rands[i] + seq_len >= n)
rands[i] = n - 1 - seq_len;
}
size_type cnt=0;
write_R_output("lcp","random sequential access","begin",times*(seq_len+1),cnt);
for (size_type i=0; i<times; ++i) {
for (size_type j=rands[i&mask], k=0; k<=seq_len; ++k, ++j) {
cnt += lcp[ j ];
}
}
write_R_output("lcp","random sequential access","end",times*(seq_len+1),cnt);
}
void test_select_random_access(const Select& select, bit_vector::size_type args, bit_vector::size_type times)
{
typedef bit_vector::size_type size_type;
const int s = 20;
const uint64_t mask = (1<<s)-1;
int_vector<64> rands(1<<s ,0);
util::set_random_bits(rands, 17);
util::all_elements_mod(rands, args);
for (size_type i=0; i<rands.size(); ++i)
rands[i] = rands[i]+1;
size_type cnt=0;
write_R_output("select","random access","begin",times,cnt);
for (size_type i=0; i<times; ++i) {
cnt += select.select(rands[ i&mask ]);
}
write_R_output("select","random access","end",times,cnt);
}
static cv::Rect2d propagEstimate(std::vector<cv::Rect2d> &particles, const std::vector<double> &weights, cv::RNG* rng){
cv::Rect2d estim;
for (size_t i=0; i<particles.size(); i++){
estim.x+=particles[i].x;
estim.y+=particles[i].y;
estim.width+=particles[i].width;
estim.height+=particles[i].height;
}
estim.x/=particles.size();
estim.y/=particles.size();
estim.width/=particles.size();
estim.height/=particles.size();
//std::cout<<"estima="<<estim.x<<","<<estim.y<<","<<estim.width<<","<<estim.height<<std::endl;
// PURPOSE : Performs the resampling stage of the SIR
// in order(number of samples) steps. It uses Liu's
// residual resampling algorithm and Niclas' magic line.
int S = (int)particles.size();
std::vector<int> N_babies(S);
std::vector<double> q_res = weights;
std::transform( q_res.begin(), q_res.end(), q_res.begin(),
std::bind1st(std::multiplies<double>(), double(S)) );
int sum_N_babies=0;
for (size_t i=0; i<N_babies.size(); i++){
if (q_res[i]>0) N_babies[i] = (int)std::floor(q_res[i]);
else N_babies[i] = (int)std::ceil(q_res[i]);
sum_N_babies+=N_babies[i];
}
int N_res = S - sum_N_babies;
//std::cout<<"N_res: "<<N_res<<std::endl;
//std::cout<<"S: "<<S<<std::endl;
//std::cout<<"sum_N_babies: "<<sum_N_babies<<std::endl;
std::vector<double> cumDist(S);
std::vector<double> cumProd(N_res);
std::vector<double> expos;
linspace(expos, N_res, 1, -1);
if (N_res>0){
for (size_t i=0; i<q_res.size(); i++){
q_res[i]=(q_res[i]-N_babies[i])/N_res;
if (i==0) cumDist[i]=q_res[i];
else cumDist[i]=cumDist[i-1]+q_res[i];
}
//std::cout<<"cumDist=";
//for (int i=0; i<cumDist.size(); i++) std::cout<<" "<<cumDist[i]<<" ";
//std::cout<<std::endl;
std::vector<double> rands(N_res);
//std::cout<<"idx=";
for (int i=0; i<N_res; i++){
rands[i] = std::pow( rng->uniform(0.0f,1.0f), 1/expos[i] );
if (i==0){
cumProd[(N_res-1)-i]=rands[i];
//std::cout<<(N_res-1)-i<<" ";
}else{
cumProd[(N_res-1)-i]=cumProd[(N_res-1)-i+1]*rands[i];
//std::cout<<(N_res-1-i+1)<<" ";
}
}
//std::cout<<std::endl;
//std::cout<<"1/expos=";
//for (int i=0; i<expos.size(); i++) std::cout<<" "<<1/expos[i]<<" ";
//std::cout<<std::endl;
//std::cout<<"rands=";
//for (int i=0; i<cumProd.size(); i++) std::cout<<" "<<cumProd[i]<<" ";
//std::cout<<std::endl;
//std::cout<<"cumProd=";
//for (int i=0; i<cumProd.size(); i++) std::cout<<" "<<cumProd[i]<<" ";
//std::cout<<std::endl;
int j=0;
for (int i=0; i<N_res; i++){
while (cumProd[i]>cumDist[j]){
j=j+1;
}
if (j<N_babies.size())
N_babies[j]+=1;
}
//std::cout<<"N_babies=";
//for (int i=0; i<N_babies.size(); i++) std::cout<<" "<<N_babies[i]<<" ";
//std::cout<<std::endl;
// propagate
std::vector<cv::Rect2d> particles_=particles;
int index=0;
for (int i=0; i<S; i++){
for (int j=index; j<index+N_babies[i]-1; j++){
if (j<particles.size())
particles[j] = particles_[i];
}
index = index+N_babies[i];
}
// estimate
estim.x=0; estim.y=0;
for (size_t i=0;i<particles.size();i++){
estim.x += weights[i]*particles[i].x;
estim.y += weights[i]*particles[i].y;
}
}
//std::cout<<"estimb="<<estim.x<<","<<estim.y<<","<<estim.width<<","<<estim.height<<std::endl;
return estim;
}
