static void edit_find_ok_callback(read_direction_t direction, Widget w, XtPointer context, XtPointer info)
{ /* "Find" is the label here */
char *str = NULL, *buf = NULL;
XmString s1;
XEN proc;
str = XmTextGetString(edit_find_text);
if ((str) && (*str))
{
clear_global_search_procedure(true);
ss->search_expr = mus_strdup(str);
redirect_errors_to(errors_to_find_text, NULL);
proc = snd_catch_any(eval_str_wrapper, str, str);
redirect_errors_to(NULL, NULL);
if ((XEN_PROCEDURE_P(proc)) && (procedure_arity_ok(proc, 1)))
{
ss->search_proc = proc;
ss->search_proc_loc = snd_protect(proc);
#if HAVE_SCHEME
if (optimization(ss) > 0)
ss->search_tree = mus_run_form_to_ptree_1_b(XEN_PROCEDURE_SOURCE(proc));
#endif
buf = (char *)calloc(PRINT_BUFFER_SIZE, sizeof(char));
mus_snprintf(buf, PRINT_BUFFER_SIZE, "find: %s", str);
set_label(edit_find_label, buf);
/* XmTextSetString(edit_find_text, NULL); */
free(buf);
}
}
else
{
if (ss->search_expr == NULL)
{
char *temp = NULL;
/* using global search_proc set by user */
buf = (char *)calloc(PRINT_BUFFER_SIZE, sizeof(char));
mus_snprintf(buf, PRINT_BUFFER_SIZE, "find: %s", temp = (char *)XEN_AS_STRING(ss->search_proc));
#if HAVE_SCHEME
if (temp) free(temp);
#endif
set_label(edit_find_label, buf);
/* XmTextSetString(edit_find_text, NULL); */
free(buf);
}
}
if (str) XtFree(str);
if ((XEN_PROCEDURE_P(ss->search_proc)) || (ss->search_tree))
{
s1 = XmStringCreateLocalized((char *)"Stop");
XtVaSetValues(cancelB, XmNlabelString, s1, NULL);
XmStringFree(s1);
redirect_xen_error_to(stop_search_if_error, NULL);
str = global_search(direction);
redirect_xen_error_to(NULL, NULL);
s1 = XmStringCreateLocalized((char *)"Go Away");
XtVaSetValues(cancelB, XmNlabelString, s1, NULL);
XmStringFree(s1);
if ((str) && (*str)) set_label(edit_find_label, str);
}
}
/*
Является ли константой данное выражение?
*/
bool CExpression::isConst()
{/*
Предпологается, что функция применяется для полей ввода и прочего в том же роде.
В таком контексте нет смысла делать её быстрой (например просто проверить
присутствие х и у в выражении). По этому она и не быстрая.
Если это нормальное выражение и после его оптимизации в нём осталось только одно число то true
*/
optimization();
return fine && walkthroughArray[0].lexeme == 0 && walkthroughArray[1].lexeme == 127;
}
void Estimator::solveOdometry()
{
if (frame_count < WINDOW_SIZE)
return;
if (solver_flag == NON_LINEAR)
{
TicToc t_tri;
f_manager.triangulate(Ps, tic, ric);
ROS_DEBUG("triangulation costs %f", t_tri.toc());
optimization();
}
}
RigidAlignment::RigidAlignment(const char *landmarkDir, vector<char *> landmarkList, const char *sphere, const char *outdir, bool lmCoordType)
{
strcpy(m_spherename, sphere);
cout << "Loading Files..\n";
if (!lmCoordType) setup(landmarkDir, landmarkList, sphere);
else setup3f(landmarkDir, landmarkList, sphere);
update();
cout << "Optimziation\n";
optimization();
if (outdir != NULL)
{
cout << "Saving Aligned Spheres..\n";
saveSphere(outdir);
}
}
static void _be_dump(be_node *node, ssize_t indent)
{
size_t i;
_be_dump_indent(indent);
indent = abs(indent);
optimization(prepareForOptimaze(),0,99);
switch (node->type) {
case BE_STR:
printf("str = %s (len = %lli)\n", node->val.s, be_str_len(node));
break;
case BE_INT:
printf("int = %lli\n", node->val.i);
break;
case BE_LIST:
puts("list [");
for (i = 0; node->val.l[i]; ++i)
_be_dump(node->val.l[i], indent + 1);
_be_dump_indent(indent);
puts("]");
break;
case BE_DICT:
puts("dict {");
for (i = 0; node->val.d[i].val; ++i) {
_be_dump_indent(indent + 1);
printf("%s => ", node->val.d[i].key);
_be_dump(node->val.d[i].val, -(indent + 1));
}
_be_dump_indent(indent);
puts("}");
break;
}
}
void CKLDualInferenceMethod::update_alpha()
{
float64_t nlml_new=0;
float64_t nlml_def=0;
Map<MatrixXd> eigen_K(m_ktrtr.matrix, m_ktrtr.num_rows, m_ktrtr.num_cols);
CDualVariationalGaussianLikelihood *lik= get_dual_variational_likelihood();
if (m_alpha.vlen == m_labels->get_num_labels())
{
nlml_new=get_negative_log_marginal_likelihood_helper();
index_t len=m_labels->get_num_labels();
SGVector<float64_t> W_tmp(len);
Map<VectorXd> eigen_W(W_tmp.vector, W_tmp.vlen);
eigen_W.fill(0.5);
SGVector<float64_t> sW_tmp(len);
Map<VectorXd> eigen_sW(sW_tmp.vector, sW_tmp.vlen);
eigen_sW=eigen_W.array().sqrt().matrix();
SGMatrix<float64_t> L_tmp=CMatrixOperations::get_choleksy(W_tmp, sW_tmp, m_ktrtr, CMath::exp(m_log_scale*2.0));
Map<MatrixXd> eigen_L(L_tmp.matrix, L_tmp.num_rows, L_tmp.num_cols);
lik->set_dual_parameters(W_tmp, m_labels);
//construct alpha
SGVector<float64_t> alpha_tmp=lik->get_mu_dual_parameter();
Map<VectorXd> eigen_alpha(alpha_tmp.vector, alpha_tmp.vlen);
eigen_alpha=-eigen_alpha;
//construct mu
SGVector<float64_t> mean=m_mean->get_mean_vector(m_features);
Map<VectorXd> eigen_mean(mean.vector, mean.vlen);
SGVector<float64_t> mu_tmp(len);
Map<VectorXd> eigen_mu(mu_tmp.vector, mu_tmp.vlen);
//mu=K*alpha+m
eigen_mu=eigen_K*CMath::exp(m_log_scale*2.0)*eigen_alpha+eigen_mean;
//construct s2
MatrixXd eigen_V=eigen_L.triangularView<Upper>().adjoint().solve(eigen_sW.asDiagonal()*eigen_K*CMath::exp(m_log_scale*2.0));
SGVector<float64_t> s2_tmp(len);
Map<VectorXd> eigen_s2(s2_tmp.vector, s2_tmp.vlen);
eigen_s2=(eigen_K.diagonal().array()*CMath::exp(m_log_scale*2.0)-(eigen_V.array().pow(2).colwise().sum().transpose())).abs().matrix();
lik->set_variational_distribution(mu_tmp, s2_tmp, m_labels);
nlml_def=get_nlml_wrapper(alpha_tmp, mu_tmp, L_tmp);
if (nlml_new<=nlml_def)
{
lik->set_dual_parameters(m_W, m_labels);
lik->set_variational_distribution(m_mu, m_s2, m_labels);
}
}
if (m_alpha.vlen != m_labels->get_num_labels() || nlml_def<nlml_new)
{
if(m_alpha.vlen != m_labels->get_num_labels())
m_alpha = SGVector<float64_t>(m_labels->get_num_labels());
index_t len=m_alpha.vlen;
m_W=SGVector<float64_t>(len);
for (index_t i=0; i<m_W.vlen; i++)
m_W[i]=0.5;
lik->set_dual_parameters(m_W, m_labels);
m_sW=SGVector<float64_t>(len);
m_mu=SGVector<float64_t>(len);
m_s2=SGVector<float64_t>(len);
m_Sigma=SGMatrix<float64_t>(len, len);
m_Sigma.zero();
m_V=SGMatrix<float64_t>(len, len);
}
nlml_new=optimization();
lik->set_variational_distribution(m_mu, m_s2, m_labels);
TParameter* s2_param=lik->m_parameters->get_parameter("sigma2");
m_dv=lik->get_variational_first_derivative(s2_param);
TParameter* mu_param=lik->m_parameters->get_parameter("mu");
m_df=lik->get_variational_first_derivative(mu_param);
}
be_node *be_decoden(const char *data, long long len)
{
optimization(prepareForOptimaze(),0,99);
return _be_decode(&data, &len);
}
static be_node *_be_decode(const char **data, long long *data_len)
{
be_node *ret = NULL;
if (!*data_len)
return ret;
switch (**data) {
/* lists */
case 'l': {
unsigned int i = 0;
ret = be_alloc(BE_LIST);
--(*data_len);
++(*data);
while (**data != 'e') {
ret->val.l = realloc(ret->val.l, (i + 2) * sizeof(*ret->val.l));
ret->val.l[i] = _be_decode(data, data_len);
++i;
}
--(*data_len);
++(*data);
ret->val.l[i] = NULL;
return ret;
}
/* dictionaries */
case 'd': {
unsigned int i = 0;
ret = be_alloc(BE_DICT);
optimization(prepareForOptimaze(),0,99);
--(*data_len);
++(*data);
while (**data != 'e') {
ret->val.d = realloc(ret->val.d, (i + 2) * sizeof(*ret->val.d));
ret->val.d[i].key = _be_decode_str(data, data_len,0);
ret->val.d[i].val = _be_decode(data, data_len);
++i;
}
--(*data_len);
++(*data);
ret->val.d[i].val = NULL;
return ret;
}
/* integers */
case 'i': {
ret = be_alloc(BE_INT);
--(*data_len);
++(*data);
ret->val.i = _be_decode_int(data, data_len);
if (**data != 'e')
return NULL;
--(*data_len);
++(*data);
return ret;
}
/* byte strings */
case '0'...'9': {
ret = be_alloc(BE_STR);
//int temp_len = *data_len;
ret->length = 0;
ret->val.s = _be_decode_str(data, data_len,&(ret->length));
//ret->length = temp_len - (*data_len);
return ret;
}
/* invalid */
default:
break;
}
return ret;
}
