inline
cons_index_list<I1,
cons_index_list<I2,
cons_index_list<I3,
nil_index_list> > >
index_list(const I1& idx1, const I2& idx2, const I3& idx3) {
return cons_list(idx1, index_list(idx2, idx3));
}
void service_abort(void) {
int n = service_total();
uint32_t list[n];
n = index_list(g.index, n, list);
int i;
for (i=0; i<n; i++)
service_release(list[i]);
}
list<MatrixXd> Covariances::access(const node_pair_list_t& node_pair_list) const {
const SparseSystem& R = (_slam==NULL) ? _R : _slam->_R;
if (_slam) {
_slam->update_starts();
}
if (R.num_rows()>1) { // skip if _R not calculated yet (eg. before batch step)
// count how many entries in requested blocks
int num = 0;
for (node_pair_list_t::const_iterator it = node_pair_list.begin();
it != node_pair_list.end(); it++) {
num += get_dim(it->first) * get_dim(it->second);
}
// request individual covariance entries
vector < pair<int, int> > index_list(num);
const int* trans = R.a_to_r();
int n = 0;
for (node_pair_list_t::const_iterator it = node_pair_list.begin();
it != node_pair_list.end(); it++) {
int start_r = get_start(it->first);
int start_c = get_start(it->second);
int dim_r = get_dim(it->first);
int dim_c = get_dim(it->second);
for (int r=0; r<dim_r; r++) {
for (int c=0; c<dim_c; c++) {
index_list[n] = make_pair(trans[start_r + r], trans[start_c + c]);
n++;
}
}
}
list<double> covs = cov_marginal(R, _cache, index_list);
// assemble into block matrices
list<MatrixXd> result;
list<double>::iterator it_cov = covs.begin();
for (node_pair_list_t::const_iterator it = node_pair_list.begin();
it != node_pair_list.end(); it++) {
int dim_r = get_dim(it->first);
int dim_c = get_dim(it->second);
MatrixXd matrix(dim_r, dim_c);
for (int r=0; r<dim_r; r++) {
for (int c=0; c<dim_c; c++) {
matrix(r,c) = *it_cov;
it_cov++;
}
}
result.push_back(matrix);
}
return result;
}
list<MatrixXd> empty_list;
return empty_list;
}
main(void)
{
char line[256];
char stemkeys[256];
int rval;
printf("dictionary? ");
gets(line);
printf("munch %s\n", line );
rval = index_list(line,":le:");
printf("done indexing\n");
}
inline cons_index_list<I1, cons_index_list<I2, nil_index_list> >
index_list(const I1& idx1, const I2& idx2) {
return cons_list(idx1, index_list(idx2));
}
inline cons_index_list<I, nil_index_list>
index_list(const I& idx) {
return cons_list(idx, index_list());
}
static
do_index(char *file, int indfreq)
{
FILE * foutput;
/*
char curkey[BIGSTRING];
char prevkey[BIGSTRING];
char curtag[BIGSTRING];
char prevtag[BIGSTRING];
*/
char *curkey;
char *prevkey;
char *curtag;
char *prevtag;
long i;
char ** table;
curkey = malloc(BIGSTRING);
prevkey = malloc(BIGSTRING);
curtag = malloc(BIGSTRING);
prevtag = malloc(BIGSTRING);
table = stems;
qsort(table,(size_t)stemcount,sizeof * table, zstrcmp );
/*
lqsort((char **)table,stemcount,(int) sizeof * table, xstrcmp );
*/
fprintf(stderr,"out of qsort\n");
if(! (foutput=MorphFopen(file,"w"))) {
char tmp[256];
sprintf(tmp,"Could not open %s!", file );
ErrorMess(tmp);
return(-1);
}
prevtag[0] = 0;
for(i=0;i<stemcount;i++) {
if( ! (i % 5000 ) ) printf("processing %ld: %s\n", i , *(table+i) );
nextkey(*(table+i),curtag);
/*
* if a new keys
*/
if( morphstrcmp(curtag,prevtag) ) {
if( prevtag[0] ) fprintf(foutput,"\n");
fprintf(foutput,"%s%s%s", curtag, DELIMITER, *(table+i) );
} else if ( strcmp(prevkey,*(table+i) ) )
/*
* don't include lines such as "uiais perf_act perf_act"
* where the same key is repeated
*/
fprintf(foutput,"%s%s", DELIMITER, *(table+i) );
strcpy(prevtag,curtag);
strcpy(prevkey,*(table+i));
}
fprintf(stderr,"done with i=%ld, %ld\n", i , stemcount-i);
fclose(foutput);
fprintf(stderr,"about to index [%s]\n", file);
/*
free(bufptr);
*/
index_list(file,"",indfreq);
fprintf(stderr,"have just indexed [%s]\n", file);
/*
for(i=0;i<stemcount;i++) free(*(table+i));
*/
free(table);
}
std::unique_ptr<IResourceDataSet> PackResourceManager::LoadResourceBatch(const std::uint32_t* p_sorted_rid_list, size_t count) const
{
struct ResourceDataSet : public IResourceDataSet
{
std::vector<std::uint8_t> data;
std::vector<Index> index_list;
std::size_t Count() const override
{
return index_list.size();
}
int GetDataByRid(std::uint32_t rid, const std::uint8_t*& out_p_data, std::size_t& out_size) const override
{
auto result_iter = std::lower_bound(this->index_list.begin(), this->index_list.end(), rid, IndexSearchCmp());
if (result_iter->rid != rid)
{
out_p_data = nullptr;
out_size = 0;
return -1;
}
else
{
out_p_data = &this->data[result_iter->pos];
out_size = result_iter->size;
return 0;
}
}
int GetDataByIdx(std::size_t idx, const std::uint8_t*& out_p_data, std::size_t& out_size) const override
{
if (idx < this->index_list.size())
{
const Index& index = this->index_list[idx];
out_p_data = &this->data[index.pos];
out_size = index.size;
return 0;
}
else
{
out_p_data = nullptr;
out_size = 0;
return -1;
}
}
};
std::unique_ptr<ResourceDataSet> up_resourece_data_set(new ResourceDataSet());
up_resourece_data_set->index_list.reserve(count);
auto search_iter = this->index_list.begin();
auto end_iter = this->index_list.end();
std::vector<const Index*> index_list(count);
std::uint32_t size = 0;
for (size_t i = 0; i < count; ++i) {
std::uint32_t rid = p_sorted_rid_list[i];
auto result_iter = std::lower_bound(search_iter, end_iter, rid, IndexSearchCmp());
if (result_iter->rid != rid)
return nullptr;
index_list[i] = &*result_iter;
up_resourece_data_set->index_list.push_back({rid, size, result_iter->size});
size += result_iter->size;
}
up_resourece_data_set->data.resize(size);
std::uint8_t* p = &up_resourece_data_set->data[0];
std::ifstream file(this->pack_path);
for (const Index* p_index : index_list)
{
file.seekg(p_index->pos);
file.read(reinterpret_cast<char*>(p), p_index->size);
p += p_index->size;
}
return std::move(up_resourece_data_set);
}
