int find_steals(Node * root, char * word, char * pool, FILE * out_file){
char hist[26];
char limit[26];
create_hist(word, hist);
if (pool){
create_hist(pool, limit);
_find_steals(root, hist, limit, 0, out_file);
}
else
_find_steals(root, hist, 0, 0, out_file);
return 0;
}
Node * create_tree(FILE * in_file){
int z, i, n;
char buf[32];
char hist[26];
Node * root;
Node * cur;
root = new_node();
while(fscanf(in_file, "%s\n", buf) != -1){
create_hist(buf, hist);
cur = root;
for(i = 0; i < 26; i ++){
n = hist[i];
if(n < cur->len && cur->children[n])
cur = cur->children[n];
else
cur = insert_child(cur, n, new_node());
}
insert_child(cur, cur->len, strdup(buf));
z ++;
//if(z > 20000) break;
}
return root;
}
d_hist * _hist_read(const char * filename, REAL minz, REAL maxz, const char * histname, int col1, const char * delimiter, int skip_lines, int grow_by) {
if (histname)
writelog(LOG_MESSAGE,"reading histogram \"%s\" from file %s", histname, filename);
else
writelog(LOG_MESSAGE,"reading histogram from file %s", filename);
vec * vcol1 = NULL;
d_hist * res = NULL;
if (!one_columns_read(filename, col1,
skip_lines, delimiter, grow_by, vcol1))
return NULL;
res = create_hist(minz, maxz, vcol1, histname);
if (histname == NULL) {
char * name = get_name(filename);
res->setName(name);
sstuff_free_char(name);
}
res->normalize();
return res;
};
void mexFunction(int nlhs, mxArray *plhs[], int nrhs, const mxArray *prhs[])
{
int n;
if (nrhs != 2)
mexErrMsgTxt("Incorrect usage.");
n = mxGetM(prhs[0])*mxGetN(prhs[0]);
if (mxGetM(prhs[1])*mxGetN(prhs[1]) != n) mexErrMsgTxt("Incorrect usage.");
if (!mxIsUint8(prhs[0])) mexErrMsgTxt("Incorrect usage.");
if (!mxIsDouble(prhs[1])) mexErrMsgTxt("Incorrect usage.");
plhs[0] = mxCreateDoubleMatrix(256,1,mxREAL);
create_hist(n, (unsigned char *)mxGetPr(prhs[0]), mxGetPr(prhs[1]),mxGetPr(plhs[0]));
}
/*
* Fetch the current history key(s), creating the history principal if
* necessary. Database created since krb5 1.3 will have only one key, but
* databases created before that may have multiple keys (of the same kvno)
* and we need to try them all. History keys will be returned in a list
* terminated by an entry with enctype 0.
*/
krb5_error_code
kdb_get_hist_key(kadm5_server_handle_t handle, krb5_keyblock **keyblocks_out,
krb5_kvno *kvno_out)
{
krb5_error_code ret;
krb5_db_entry *kdb;
krb5_keyblock *mkey, *kblist = NULL;
krb5_int16 i;
/* Fetch the history principal, creating it if necessary. */
ret = kdb_get_entry(handle, hist_princ, &kdb, NULL);
if (ret == KADM5_UNK_PRINC) {
ret = create_hist(handle);
if (ret)
return ret;
ret = kdb_get_entry(handle, hist_princ, &kdb, NULL);
}
if (ret)
return ret;
if (kdb->n_key_data <= 0) {
ret = KRB5_KDB_NO_MATCHING_KEY;
k5_setmsg(handle->context, ret,
_("History entry contains no key data"));
goto done;
}
ret = krb5_dbe_find_mkey(handle->context, kdb, &mkey);
if (ret)
goto done;
kblist = k5calloc(kdb->n_key_data + 1, sizeof(*kblist), &ret);
if (kblist == NULL)
goto done;
for (i = 0; i < kdb->n_key_data; i++) {
ret = krb5_dbe_decrypt_key_data(handle->context, mkey,
&kdb->key_data[i], &kblist[i],
NULL);
if (ret)
goto done;
}
*keyblocks_out = kblist;
kblist = NULL;
*kvno_out = kdb->key_data[0].key_data_kvno;
done:
kdb_free_entry(handle, kdb, NULL);
kdb_free_keyblocks(handle, kblist);
return ret;
}
t_shell *init_struct(char **env)
{
t_shell *sh;
if (!(sh = (t_shell *)malloc(sizeof(t_shell))))
return (NULL);
sh->env = init_env(env);
deal_with_file(sh);
sh->hist = sh->hist->next;
sh->hist = create_hist();
sh->return_val = 0;
push_hist(&sh->head, sh->hist);
return (sh);
}
int is_word(Node * ptr, char * word){
int i, n;
char hist[26];
create_hist(word, hist);
for(i = 0; i < 26; i++){
n = hist[i];
if(n < ptr->len && ptr->children[n])
ptr = ptr->children[n];
else
return 0;
}
for(i = 0; i < ptr->len; i++)
if(!strcmp(word, ptr->children[i]))
return 1;
return 0;
}
/**
* Convert the features of images into histogram
* @param features features of the image
* @param code_book code book of the data sets
* @return histogram of bovw
*/
Hist describe(arma::Mat<T> const &features,
arma::Mat<T> const &code_book) const
{
arma::Mat<T> dist(features.n_cols, code_book.n_cols);
for(arma::uword i = 0; i != features.n_cols; ++i){
dist.row(i) = euclidean_dist(features.col(i),
code_book);
}
//dist.print("dist");
Hist hist = create_hist(dist.n_cols,
armd::is_two_dim<Hist>::type());
for(arma::uword i = 0; i != dist.n_rows; ++i){
arma::uword min_idx;
dist.row(i).min(min_idx);
++hist(min_idx);
}
//hist.print("\nhist");
return hist;
}
d_hist * _hist_from_extvec(const extvec * data, REAL minz, REAL maxz, size_t intervs,
REAL undef_value, const bitvec * mask, const bitvec * mask_undef)
{
vec * Z = create_vec(intervs);
maxz += (maxz-minz)*1e-3;
d_hist * hst = create_hist(minz, maxz, Z);
REAL step = hst->get_step();
size_t cnt = 0;
size_t i;
for (i = 0; i < data->size(); i++) {
if (mask) {
if (mask->get(i) == true)
continue;
}
if (mask_undef) {
if (mask_undef->get(i) == true)
continue;
}
REAL z = (*data)(i);
if (z == undef_value)
continue;
cnt += 1;
size_t pos = (*hst)(z);
(*Z)(pos) += 1;
}
for (i = 0; i < intervs; i++)
(*Z)(i) /= (REAL)(cnt);
return hst;
};
extvec * _extvec_adj_hist(const extvec * X, const d_hist * dest, const bitvec * mask, const bitvec * mask_undef, REAL uval)
{
size_t intervs = dest->size();
size_t i;
d_hist * dhst = create_hist(dest);
dhst->normalize();
size_t X_size = X->size();
//
// modify destination histogram with respect to solved cells
//
for (i = 0; i < X->size(); i++) {
if (mask_undef) {
if (mask_undef->get(i) == false)
continue;
}
REAL val = (*X)(i);
if (val == uval)
continue;
X_size--;
}
REAL elem = REAL(1)/X_size;
REAL dest_minz = dhst->from();
REAL dest_maxz = dhst->to();
for (i = 0; i < X->size(); i++) {
if (mask->get(i) == false)
continue;
REAL val = (*X)(i);
if (val > dest_maxz)
continue;
if (val < dest_minz)
continue;
size_t pos = (*dhst)(val);
(*dhst)[pos] = MAX(0, (*dhst)(pos)-elem);
}
dhst->normalize();
vec * Z = dhst->get_cumulative_hist();
size_t q;
extvec * res = create_extvec(*X);
REAL prev_err = FLT_MAX;
for (q = 0; q < 5; q++)
{
//
// calculating minimum and maximum values if vector X with respect to mask
//
REAL minz = FLT_MAX, maxz = -FLT_MAX;
for (i = 0; i < res->size(); i++) {
if (mask->get(i))
continue;
if (mask_undef) {
if (mask_undef->get(i))
continue;
}
REAL val = (*res)(i);
if (val == FLT_MAX)
continue;
minz = MIN(minz, val);
maxz = MAX(maxz, val);
}
d_hist * hst = _hist_from_extvec(res, minz, maxz, intervs, FLT_MAX, mask, mask_undef);
if (hst->get_step() == 0) {
hst->release();
goto failed_exit;
}
// histogram normalization
hst->normalize();
// calculate cumulative histogram
vec * T = hst->get_cumulative_hist();
extvec * new_res = create_extvec(*res);
size_t j;
for (j = 0; j < X->size(); j++)
{
if (mask->get(j) == true)
continue;
if (mask_undef) {
if (mask_undef->get(j) == true)
continue;
}
REAL val = (*res)(j);
REAL eqval = get_eq_value(T, Z, val,
minz, maxz,
dest_minz, dest_maxz);
if (val == eqval)
continue;
(*new_res)(j) = eqval;
}
REAL max_err = -FLT_MAX;
for (j = 0; j < res->size(); j++)
{
max_err = MAX(max_err, fabs((*res)(j) - (*new_res)(j)));
}
if ((max_err > prev_err) || (max_err < tol*100)) {
new_res->release();
T->release();
hst->release();
break;
}
prev_err = max_err;
res->release();
res = new_res;
T->release();
hst->release();
}
if (dhst)
dhst->release();
if (Z)
Z->release();
return res;
failed_exit:
res->release();
dhst->release();
Z->release();
return NULL;
};
