static VALUE rb_gsl_multimin_function_new(int argc, VALUE *argv, VALUE klass)
{
gsl_multimin_function *F = NULL;
VALUE ary;
size_t i;
F = ALLOC(gsl_multimin_function);
F->f = &rb_gsl_multimin_function_f;
ary = rb_ary_new2(2);
/* (VALUE) F->params = ary;*/
F->params = (void *) ary;
if (rb_block_given_p()) rb_ary_store(ary, 0, RB_GSL_MAKE_PROC);
else rb_ary_store(ary, 0, Qnil);
rb_ary_store(ary, 1, Qnil);
switch (argc) {
case 0:
break;
case 1:
set_function(0, argv, F);
break;
case 2:
case 3:
for (i = 0; i < argc; i++) set_function(i, argv, F);
break;
default:
rb_raise(rb_eArgError, "wrong number of arguments");
}
return Data_Wrap_Struct(klass, gsl_multimin_function_mark, gsl_multimin_function_free, F);
}
void init_eval() {
sym_amp = intern("&");
sym_args = intern("args");
sym_do = intern("do");
sym_fn = intern("fn");
sym_if = intern("if");
sym_quote = intern("quote");
set_function(intern("apply"), builtin(cons(sym_fn, cons(sym_args, NIL)), fn_apply, 2, NO));
set_function(intern("macroexpand"), builtin(cons(sym_args, NIL), fn_macroexpand, 1, NO));
set_function(intern("macroexpand1"), builtin(cons(sym_args, NIL), fn_macroexpand1, 1, NO));
}
void set_parent_info(JITMethodInfo& info) {
parent_info_ = &info;
vm_ = info.vm();
out_args_ = info.out_args();
counter_ = info.counter();
set_function(info.function());
}
static VALUE rb_gsl_multimin_function_set_f(int argc, VALUE *argv, VALUE obj)
{
gsl_multimin_function *F = NULL;
VALUE ary;
size_t i;
Data_Get_Struct(obj, gsl_multimin_function, F);
ary = (VALUE) F->params;
if (rb_block_given_p()) rb_ary_store(ary, 0, RB_GSL_MAKE_PROC);
switch (argc) {
case 1:
set_function(0, argv, F);
break;
case 2:
case 3:
for (i = 0; i < argc; i++) set_function(i, argv, F);
break;
default:
rb_raise(rb_eArgError, "wrong number of arguments");
}
return obj;
}
int main () {
//sol::state lua;
//lua.open_libraries(sol::lib::base);
// BOTH need to work!
// Should match function 2
set_function<int>("overloaded", overloaded);
//lua.script("overloaded(1)");
// Should match function 1
set_function("non_overloaded", non_overloaded);
//lua.script("overloaded(1)");
}
//规则子函数字符串
int opfunc(struct function *fc,struct rule *r,char *fl){ //根据函数动作如：alert（"test");转化成函数结构
//处理表达式字符串
char *v1=NULL;
char *v2=NULL;
char *p=NULL;
if((p=strstr(fl,"++"))){
p[0]='\0'; //切割出表达式参数
v1=fl;
set_addself(r,fc,v1);
return 1;
}
if((p=strstr(fl,"--"))){
p[0]='\0';
v1=fl;
set_delself(r,fc,v1);
return 2;
}
if((p=strstr(fl,">"))){
p[0]='\0';
v1=fl;
v2=p+1;
set_greater(r,fc,v1,v2);
return 3;
}
if((p=strstr(fl,"<"))){
p[0]='\0';
v1=fl;
v2=p+1;
set_less(r,fc,v1,v2);
return 4;
}
if((p=strstr(fl,"=="))){
p[0]='\0';
v1=fl;
v2=p+2;
set_equal(r,fc,v1,v2);
return 5;
}
if((p=strstr(fl,"!="))){
p[0]='\0';
v1=fl;
v2=p+2;
set_unequal(r,fc,v1,v2);
return 6;
}
set_function(r,fc,fl);
return 0;
}
/*@@
@routine ParseFile
@author Paul Walker
@desc
This routine actually parses the parameter file. The
syntax we allow is
<ul>
<li>a = b
<li>a,b,c = d,e,f
<li># rest of the line is ignored
<li>x = "string value"
</ul>
So it is easy to parse
<p>
We go through the file looking for stuff and then set
it in the global database using calls to the passed in set_function.
@enddesc
@history
@hdate Tue Jan 12 16:41:36 1999 @hauthor Tom Goodale
@hdesc Moved to CCTK.
Changed to pass data to arbitrary function.
Changed to take a file descriptor rather than a filename.
@endhistory
@var ifp
@vdesc The filestream to parse
@vtype FILE *
@vio in
@vcomment
@endvar
@var set_function
@vdesc The function to call to set the value of a parameter
@vtype int (*)(const char *, const char *)
@vio in
@vcomment
@endvar
@var ConfigData
@vdesc Flesh configuration data
@vtype tFleshConfig *
@vio in
@vcomment
@endvar
@returntype int
@returndesc
0 - success
@endreturndesc
@@*/
int ParseFile(FILE *ifp,
int (*set_function)(const char *, const char *, int),
tFleshConfig *ConfigData)
{
/* Buffers for parsing from the file */
char *tokens, *value;
char *subtoken, *subvalue;
/* Positions in the buffers */
int ntokens;
/* Status flags */
int intoken, inval;
/* Current char. Have to make it an int so we can compare with
EOF. See man 3 fgetc
*/
int c;
int num_errors; /* number of errors in file parsing */
num_errors = 0;
/* avoid compiler warning about unused parameter */
ConfigData = ConfigData;
/* allocate parse buffers */
tokens = (char *) malloc (4 * BUF_SZ);
value = tokens + 1*BUF_SZ;
subtoken = tokens + 2*BUF_SZ;
subvalue = tokens + 3*BUF_SZ;
intoken = 0; inval = 0;
while ((c=fgetc(ifp)) != EOF)
{
#ifdef DEBUG
printf("%c",c);
#endif
/* Main Loop */
while (c == '#' || c == '!' )
{
/* Comment line. So forget rest of line */
while ((c=fgetc(ifp)) != '\n' && c != EOF)
{
#ifdef DEBUG
printf("%c",c);
#endif
}
if (c == '\n')
{
lineno++;
}
c = fgetc(ifp);
#ifdef DEBUG
printf("%c",c);
#endif
}
/* End of line */
if (c == '\n')
{
if(intoken)
{
fprintf(stderr, "Parse error at line %d. No value supplied.\n", lineno);
num_errors++;
intoken = 0;
}
#ifdef DEBUG
printf ("LINE %d\n",lineno);
#endif
lineno ++;
}
/* Token character */
if (intoken && c != '=')
{
tokens[intoken++] = c;
CheckBuf(intoken,lineno);
}
/* Start of a new token */
if (c != ' ' && c != '\t' && c != '\n' && !inval && !intoken)
{
intoken = 0;
tokens[intoken++] = c;
}
/* End of a token signified by an = */
if (c == '=')
{
if (intoken)
{
unsigned int ll;
tokens[intoken] = '\0'; /* Very important! */
intoken = 0;
inval = 0;
removeSpaces(tokens);
ntokens = 1;
for (ll=0;ll < strlen(tokens); ll++)
if (tokens[ll] == ',') ntokens++;
#ifdef DEBUG
printf ("\nNew token! >>%s<<\n",tokens);
printf ("%d token elements\n",ntokens);
#endif
/* Scan ahead to the beginning of the value
* and check if the value is a string or not.
* This parser DOES strip quotes off of the strings.
*/
while ((c = fgetc(ifp)) == ' ' || c == '\n' || c == '\t')
{
#ifdef DEBUG
printf("%c",c);
#endif
if (c == '\n')
{
#ifdef DEBUG
printf ("LINE %d\n",lineno);
#endif
lineno++;
}
}
if (c == '"')
{
/* Just handle the thing. */
int p = 0;
if (ntokens > 1)
{
fprintf (stderr, "%s%s%s\n",
"WARNING: Multiple string ",
"tokens not supported for ",
tokens);
fprintf(stderr, "This is a fatal error");
/* deallocate parse buffers */
free (tokens);
return 1;
}
while ((c = fgetc(ifp)) != '"')
{
#ifdef DEBUG
printf("%c",c);
#endif
/* Make an important decision NOT to include
* line feeds in the string parameters
*/
if (c != '\n') value[p++] = c;
if (c == '\n')
{
printf ("%sWarning:%s Quoted string contains newline for token %s\n",
BOLDON, BOLDOFF, tokens);
printf ("This could indicated a parameter file error or missing quote\n");
#ifdef DEBUG
printf ("LINE %d\n",lineno);
#endif
lineno++;
}
CheckBuf(p,lineno);
}
value[p] = '\0';
#ifdef DEBUG
printf ("\nString %s -> %s\n",
tokens,value);
#endif
set_function(tokens,value, lineno);
}
else if (c == '$')
{
/* We got a define */
/* FIXME: Assume it is a parameter file for now */
char filename[500];
char *dir;
char *file;
int lpar;
CCTK_ParameterFilename(500,filename);
Util_SplitFilename(&dir,&file,filename);
lpar=((strlen(file)-3)*sizeof(char));
/* ignore everything else on the line */
while (!(c==' ' || c=='\t' || c == '\n' || c == EOF))
{
c = fgetc(ifp);
#ifdef DEBUG
printf("%c",c);
#endif
}
strncpy(value,file,lpar);
free(dir);
free(file);
value[strlen(value)-1] = '\0';
set_function(tokens,value,lineno);
}
else
{
int p = 0;
value[p++] = c;
if (ntokens == 1)
{
/* Simple case. We have an int
or a double which contain no
spaces! */
c = fgetc(ifp);
#ifdef DEBUG
printf("%c",c);
#endif
while (!(c==' ' || c=='\t' || c == '\n' || c == EOF))
{
value[p++] = c;
CheckBuf(p,lineno);
c = fgetc(ifp);
#ifdef DEBUG
printf("%c",c);
#endif
}
value[p] = '\0';
#ifdef DEBUG
printf ("Parsed %d characters\n", p);
printf("\nFloat/Int: %s -> %s\n", tokens,value);
#endif
set_function(tokens,value,lineno);
if (c=='\n')
{
#ifdef DEBUG
printf ("LINE %d\n",lineno);
#endif
lineno++;
}
}
else
{
/* Harder case of multiple tokens */
int ncommas = 0;
int pp=0, i;
int pt, pv;
value[pp++] = c;
/* OK, since we only have numbers in the
old input stream, we can go along getting
ntokens-1 commas, stripping spaces, and
make a nice little string.
*/
c = fgetc(ifp);
#ifdef DEBUG
printf("%c",c);
#endif
while (ncommas < ntokens-1 && c != EOF)
{
if (!(c == ' ' || c == '\t' || c == '\n'))
{
value[pp++] = c;
CheckBuf(pp,lineno);
}
if (c == ',') ncommas ++;
c = fgetc(ifp);
#ifdef DEBUG
printf("%c",c);
#endif
}
if (c == ' ' || c == '\t')
{
/* Great now strip out the spaces */
while((c = fgetc(ifp)) == ' ' || c=='\t' || c == '\n')
{
#ifdef DEBUG
printf("%c",c);
#endif
if (c=='\n')
{
#ifdef DEBUG
printf ("LINE %d\n",lineno);
#endif
lineno++;
}
}
}
/* And tack the rest on */
value[pp++] = c;
CheckBuf(p,lineno);
c = fgetc(ifp);
#ifdef DEBUG
printf("%c",c);
#endif
while (c != ' ' && c != '\t' && c != '\n' && c != EOF)
{
value[pp++] = c;
CheckBuf(pp,lineno);
c = fgetc(ifp);
#ifdef DEBUG
printf("%c",c);
#endif
}
value[pp] = '\0';
#ifdef DEBUG
printf("Comma list: %s -> %s\n",
tokens,value);
#endif
/* So parse out the tokens */
pt = 0;
pv = 0;
for (i=0;i<ncommas;i++)
{
pp = 0;
while (tokens[pt] != ',')
{
subtoken[pp++] = tokens[pt++];
CheckBuf(p,lineno);
}
subtoken[pp] = '\0';
pp = 0;
while (value[pv] != ',')
{
subvalue[pp++] = value[pv++];
CheckBuf(pp,lineno);
}
subvalue[pp] = '\0';
set_function(subtoken,subvalue,lineno);
#ifdef DEBUG
printf("Setting sub-token %s -> %s\n",
subtoken, subvalue);
#endif
/* Now remember we are sitting on a comma
* in both our input strings, so bump by one
*/
pv ++; pt ++;
}
/* And OK, so now we have one parameter left
* so lets handle that
*/
pp = 0;
while (tokens[pt] != '\0')
{
subtoken[pp++] = tokens[pt++];
CheckBuf(pp,lineno);
}
subtoken[pp] = '\0';
pp = 0;
while (value[pv] != '\0')
{
subvalue[pp++] = value[pv++];
CheckBuf(pp,lineno);
}
subvalue[pp] = '\0';
set_function(subtoken,subvalue,lineno);
}
}
}
else
{
fprintf (stderr, "Parser failed at = on line %d\n",
lineno);
}
}
}
/* deallocate parse buffers */
free (tokens);
return num_errors;
}
void BonminInterface::init(const Dict& opts) {
// Call the init method of the base class
Nlpsol::init(opts);
// Default options
pass_nonlinear_variables_ = true;
pass_nonlinear_constraints_ = true;
Dict hess_lag_options, jac_g_options, grad_f_options;
std::vector< std::vector<int> > sos1_groups;
std::vector< std::vector<double> > sos1_weights;
// Read user options
for (auto&& op : opts) {
if (op.first=="bonmin") {
opts_ = op.second;
} else if (op.first=="pass_nonlinear_variables") {
pass_nonlinear_variables_ = op.second;
} else if (op.first=="pass_nonlinear_constraints") {
pass_nonlinear_constraints_ = op.second;
} else if (op.first=="var_string_md") {
var_string_md_ = op.second;
} else if (op.first=="var_integer_md") {
var_integer_md_ = op.second;
} else if (op.first=="var_numeric_md") {
var_numeric_md_ = op.second;
} else if (op.first=="con_string_md") {
con_string_md_ = op.second;
} else if (op.first=="con_integer_md") {
con_integer_md_ = op.second;
} else if (op.first=="con_numeric_md") {
con_numeric_md_ = op.second;
} else if (op.first=="hess_lag_options") {
hess_lag_options = op.second;
} else if (op.first=="jac_g_options") {
jac_g_options = op.second;
} else if (op.first=="grad_f_options") {
grad_f_options = op.second;
} else if (op.first=="hess_lag") {
Function f = op.second;
casadi_assert_dev(f.n_in()==4);
casadi_assert_dev(f.n_out()==1);
set_function(f, "nlp_hess_l");
} else if (op.first=="jac_g") {
Function f = op.second;
casadi_assert_dev(f.n_in()==2);
casadi_assert_dev(f.n_out()==2);
set_function(f, "nlp_jac_g");
} else if (op.first=="grad_f") {
Function f = op.second;
casadi_assert_dev(f.n_in()==2);
casadi_assert_dev(f.n_out()==2);
set_function(f, "nlp_grad_f");
} else if (op.first=="sos1_groups") {
sos1_groups = to_int(op.second.to_int_vector_vector());
for (auto & g : sos1_groups) {
for (auto & e : g) e-= GlobalOptions::start_index;
}
} else if (op.first=="sos1_weights") {
sos1_weights = op.second.to_double_vector_vector();
} else if (op.first=="sos1_priorities") {
sos1_priorities_ = to_int(op.second.to_int_vector());
}
}
// Do we need second order derivatives?
exact_hessian_ = true;
auto hessian_approximation = opts_.find("hessian_approximation");
if (hessian_approximation!=opts_.end()) {
exact_hessian_ = hessian_approximation->second == "exact";
}
// Setup NLP functions
create_function("nlp_f", {"x", "p"}, {"f"});
create_function("nlp_g", {"x", "p"}, {"g"});
if (!has_function("nlp_grad_f")) {
create_function("nlp_grad_f", {"x", "p"}, {"f", "grad:f:x"});
}
if (!has_function("nlp_jac_g")) {
create_function("nlp_jac_g", {"x", "p"}, {"g", "jac:g:x"});
}
jacg_sp_ = get_function("nlp_jac_g").sparsity_out(1);
// By default, assume all nonlinear
nl_ex_.resize(nx_, true);
nl_g_.resize(ng_, true);
// Allocate temporary work vectors
if (exact_hessian_) {
if (!has_function("nlp_hess_l")) {
create_function("nlp_hess_l", {"x", "p", "lam:f", "lam:g"},
{"hess:gamma:x:x"}, {{"gamma", {"f", "g"}}});
}
hesslag_sp_ = get_function("nlp_hess_l").sparsity_out(0);
if (pass_nonlinear_variables_) {
const casadi_int* col = hesslag_sp_.colind();
for (casadi_int i=0;i<nx_;++i) nl_ex_[i] = col[i+1]-col[i];
}
} else {
if (pass_nonlinear_variables_)
nl_ex_ = oracle_.which_depends("x", {"f", "g"}, 2, false);
}
if (pass_nonlinear_constraints_)
nl_g_ = oracle_.which_depends("x", {"g"}, 2, true);
// Create sos info
// Declare size
sos_num_ = sos1_groups.size();
// sos1 type
sos1_types_.resize(sos_num_, 1);
casadi_assert(sos1_weights.empty() || sos1_weights.size()==sos_num_,
"sos1_weights has incorrect size");
casadi_assert(sos1_priorities_.empty() || sos1_priorities_.size()==sos_num_,
"sos1_priorities has incorrect size");
if (sos1_priorities_.empty()) sos1_priorities_.resize(sos_num_, 1);
sos_num_nz_ = 0;
for (casadi_int i=0;i<sos_num_;++i) {
// get local group
const std::vector<int>& sos1_group = sos1_groups[i];
// Get local weights
std::vector<double> default_weights(sos1_group.size(), 1.0);
const std::vector<double>& sos1_weight =
sos1_weights.empty() ? default_weights : sos1_weights[i];
casadi_assert(sos1_weight.size()==sos1_group.size(),
"sos1_weights has incorrect size");
// Populate lookup vector
sos1_starts_.push_back(sos_num_nz_);
sos_num_nz_+=sos1_group.size();
sos1_weights_.insert(sos1_weights_.end(), sos1_weight.begin(), sos1_weight.end());
sos1_indices_.insert(sos1_indices_.end(), sos1_group.begin(), sos1_group.end());
}
sos1_starts_.push_back(sos_num_nz_);
// Allocate work vectors
alloc_w(nx_, true); // xk_
alloc_w(nx_, true); // lam_xk_
alloc_w(ng_, true); // gk_
alloc_w(nx_, true); // grad_fk_
alloc_w(jacg_sp_.nnz(), true); // jac_gk_
if (exact_hessian_) {
alloc_w(hesslag_sp_.nnz(), true); // hess_lk_
}
}
neuron_hopf_input::neuron_hopf_input() : neuron_input(), neuron_with_input()
{
set_function(linear_func);
}
neuron_hopf_output::neuron_hopf_output() : neuron_hide()
{
set_function(sigmoid_func);
}
static void set_local(void)
{
__function= set_function("poll", "HOSTILE_POLL");
}
void set_function(T&& key, Args&&... args) {
// fails if given overloaded set: will not work with overloaded things
set_function( std::forward<T>(key), std::forward<Args>(args)...);
}
static void set_local(void)
{
__function= set_function("getaddrinfo", "HOSTILE_GETADDRINFO");
}
static void set_local(void)
{
__function= set_function("accept", "HOSTILE_SEND");
}
proxy& operator=(U&& other) {
return set_function(std::forward<U>(other));
}
static void
obj_coff_endef (int ignore ATTRIBUTE_UNUSED)
{
symbolS *symbolP = NULL;
dim_index = 0;
if (def_symbol_in_progress == NULL)
{
as_warn (_(".endef pseudo-op used outside of .def/.endef: ignored."));
demand_empty_rest_of_line ();
return;
}
/* Set the section number according to storage class. */
switch (S_GET_STORAGE_CLASS (def_symbol_in_progress))
{
case C_STRTAG:
case C_ENTAG:
case C_UNTAG:
SF_SET_TAG (def_symbol_in_progress);
/* Fall through. */
case C_FILE:
case C_TPDEF:
SF_SET_DEBUG (def_symbol_in_progress);
S_SET_SEGMENT (def_symbol_in_progress, fetch_coff_debug_section ());
break;
case C_EFCN:
SF_SET_LOCAL (def_symbol_in_progress); /* Do not emit this symbol. */
/* Fall through. */
case C_BLOCK:
SF_SET_PROCESS (def_symbol_in_progress); /* Will need processing before writing. */
/* Fall through. */
case C_FCN:
{
const char *name;
S_SET_SEGMENT (def_symbol_in_progress, text_section);
name = S_GET_NAME (def_symbol_in_progress);
if (name[0] == '.' && name[2] == 'f' && name[3] == '\0')
{
switch (name[1])
{
case 'b':
/* .bf */
if (! in_function ())
as_warn (_("`%s' symbol without preceding function"), name);
/* Will need relocating. */
SF_SET_PROCESS (def_symbol_in_progress);
clear_function ();
break;
#ifdef TE_PE
case 'e':
/* .ef */
/* The MS compilers output the actual endline, not the
function-relative one... we want to match without
changing the assembler input. */
SA_SET_SYM_LNNO (def_symbol_in_progress,
(SA_GET_SYM_LNNO (def_symbol_in_progress)
+ coff_line_base));
break;
#endif
}
}
}
break;
#ifdef C_AUTOARG
case C_AUTOARG:
#endif /* C_AUTOARG */
case C_AUTO:
case C_REG:
case C_ARG:
case C_REGPARM:
case C_FIELD:
/* According to the COFF documentation:
http://osr5doc.sco.com:1996/topics/COFF_SectNumFld.html
A special section number (-2) marks symbolic debugging symbols,
including structure/union/enumeration tag names, typedefs, and
the name of the file. A section number of -1 indicates that the
symbol has a value but is not relocatable. Examples of
absolute-valued symbols include automatic and register variables,
function arguments, and .eos symbols.
But from Ian Lance Taylor:
http://sources.redhat.com/ml/binutils/2000-08/msg00202.html
the actual tools all marked them as section -1. So the GNU COFF
assembler follows historical COFF assemblers.
However, it causes problems for djgpp
http://sources.redhat.com/ml/binutils/2000-08/msg00210.html
By defining STRICTCOFF, a COFF port can make the assembler to
follow the documented behavior. */
#ifdef STRICTCOFF
case C_MOS:
case C_MOE:
case C_MOU:
case C_EOS:
#endif
SF_SET_DEBUG (def_symbol_in_progress);
S_SET_SEGMENT (def_symbol_in_progress, absolute_section);
break;
#ifndef STRICTCOFF
case C_MOS:
case C_MOE:
case C_MOU:
case C_EOS:
S_SET_SEGMENT (def_symbol_in_progress, absolute_section);
break;
#endif
case C_EXT:
case C_WEAKEXT:
#ifdef TE_PE
case C_NT_WEAK:
#endif
case C_STAT:
case C_LABEL:
/* Valid but set somewhere else (s_comm, s_lcomm, colon). */
break;
default:
case C_USTATIC:
case C_EXTDEF:
case C_ULABEL:
as_warn (_("unexpected storage class %d"),
S_GET_STORAGE_CLASS (def_symbol_in_progress));
break;
}
/* Now that we have built a debug symbol, try to find if we should
merge with an existing symbol or not. If a symbol is C_EFCN or
absolute_section or untagged SEG_DEBUG it never merges. We also
don't merge labels, which are in a different namespace, nor
symbols which have not yet been defined since they are typically
unique, nor do we merge tags with non-tags. */
/* Two cases for functions. Either debug followed by definition or
definition followed by debug. For definition first, we will
merge the debug symbol into the definition. For debug first, the
lineno entry MUST point to the definition function or else it
will point off into space when obj_crawl_symbol_chain() merges
the debug symbol into the real symbol. Therefor, let's presume
the debug symbol is a real function reference. */
/* FIXME-SOON If for some reason the definition label/symbol is
never seen, this will probably leave an undefined symbol at link
time. */
if (S_GET_STORAGE_CLASS (def_symbol_in_progress) == C_EFCN
|| S_GET_STORAGE_CLASS (def_symbol_in_progress) == C_LABEL
|| (streq (bfd_get_section_name (stdoutput,
S_GET_SEGMENT (def_symbol_in_progress)),
"*DEBUG*")
&& !SF_GET_TAG (def_symbol_in_progress))
|| S_GET_SEGMENT (def_symbol_in_progress) == absolute_section
|| ! symbol_constant_p (def_symbol_in_progress)
|| (symbolP = symbol_find (S_GET_NAME (def_symbol_in_progress))) == NULL
|| SF_GET_TAG (def_symbol_in_progress) != SF_GET_TAG (symbolP))
{
/* If it already is at the end of the symbol list, do nothing */
if (def_symbol_in_progress != symbol_lastP)
{
symbol_remove (def_symbol_in_progress, &symbol_rootP, &symbol_lastP);
symbol_append (def_symbol_in_progress, symbol_lastP, &symbol_rootP,
&symbol_lastP);
}
}
else
{
/* This symbol already exists, merge the newly created symbol
into the old one. This is not mandatory. The linker can
handle duplicate symbols correctly. But I guess that it save
a *lot* of space if the assembly file defines a lot of
symbols. [loic] */
/* The debug entry (def_symbol_in_progress) is merged into the
previous definition. */
c_symbol_merge (def_symbol_in_progress, symbolP);
symbol_remove (def_symbol_in_progress, &symbol_rootP, &symbol_lastP);
def_symbol_in_progress = symbolP;
if (SF_GET_FUNCTION (def_symbol_in_progress)
|| SF_GET_TAG (def_symbol_in_progress)
|| S_GET_STORAGE_CLASS (def_symbol_in_progress) == C_STAT)
{
/* For functions, and tags, and static symbols, the symbol
*must* be where the debug symbol appears. Move the
existing symbol to the current place. */
/* If it already is at the end of the symbol list, do nothing. */
if (def_symbol_in_progress != symbol_lastP)
{
symbol_remove (def_symbol_in_progress, &symbol_rootP, &symbol_lastP);
symbol_append (def_symbol_in_progress, symbol_lastP, &symbol_rootP, &symbol_lastP);
}
}
}
if (SF_GET_TAG (def_symbol_in_progress))
{
symbolS *oldtag;
oldtag = symbol_find (S_GET_NAME (def_symbol_in_progress));
if (oldtag == NULL || ! SF_GET_TAG (oldtag))
tag_insert (S_GET_NAME (def_symbol_in_progress),
def_symbol_in_progress);
}
if (SF_GET_FUNCTION (def_symbol_in_progress))
{
know (sizeof (def_symbol_in_progress) <= sizeof (long));
set_function (def_symbol_in_progress);
SF_SET_PROCESS (def_symbol_in_progress);
if (symbolP == NULL)
/* That is, if this is the first time we've seen the
function. */
symbol_table_insert (def_symbol_in_progress);
}
def_symbol_in_progress = NULL;
demand_empty_rest_of_line ();
}
static int setup_issue(void **state)
{
csh *handle;
char **list_params;
int size_params;
int arch, mode;
int i, index, result;
char *(*function)(csh *, cs_mode, cs_insn*);
getDetail = 0;
failed_setup = 0;
if (e_flag == 0)
while (counter < size_lines && strncmp(list_lines[counter], "!# ", 3))
counter++; // get issue line
else
while (counter < size_lines && strncmp(list_lines[counter], "// !# ", 6))
counter++;
counter++;
if (e_flag == 0)
while (counter < size_lines && strncmp(list_lines[counter], "!#", 2))
counter++; // get arch line
else
while (counter < size_lines && strncmp(list_lines[counter], "// !# ", 6))
counter++;
if (e_flag == 0)
list_params = split(list_lines[counter] + 3, ", ", &size_params);
else
list_params = split(list_lines[counter] + 6, ", ", &size_params);
arch = get_value(arches, NUMARCH, list_params[0]);
if (!strcmp(list_params[0], "CS_ARCH_ARM64"))
mc_mode = 2;
else
mc_mode = 1;
mode = 0;
for (i = 0; i < NUMMODE; ++i) {
if (strstr(list_params[1], modes[i].str)) {
mode += modes[i].value;
switch (modes[i].value) {
case CS_MODE_16:
mc_mode = 0;
break;
case CS_MODE_64:
mc_mode = 2;
break;
case CS_MODE_THUMB:
mc_mode = 1;
break;
default:
break;
}
}
}
if (arch == -1) {
fprintf(stderr, "[ ERROR ] --- Arch is not supported!\n");
failed_setup = 1;
return -1;
}
handle = (csh *)calloc(1, sizeof(csh));
if(cs_open(arch, mode, handle) != CS_ERR_OK) {
fprintf(stderr, "[ ERROR ] --- Cannot initialize capstone\n");
failed_setup = 1;
return -1;
}
for (i = 0; i < NUMOPTION; ++i) {
if (strstr(list_params[2], options[i].str)) {
if (cs_option(*handle, options[i].first_value, options[i].second_value) != CS_ERR_OK) {
fprintf(stderr, "[ ERROR ] --- Option is not supported for this arch/mode\n");
failed_setup = 1;
return -1;
}
if (i == 0) {
result = set_function(arch);
if (result == -1) {
fprintf(stderr, "[ ERROR ] --- Cannot get details\n");
failed_setup = 1;
return -1;
}
getDetail = 1;
}
}
}
*state = (void *)handle;
issue_mode = mode;
if (e_flag == 0)
while (counter < size_lines && strncmp(list_lines[counter], "0x", 2))
counter++;
else
while (counter < size_lines && strncmp(list_lines[counter], "// 0x", 5))
counter++;
free_strs(list_params, size_params);
return 0;
}
static void set_local(void)
{
__function= set_function("send", "HOSTILE_SEND");
}
void BonminInterface::init(const Dict& opts) {
// Call the init method of the base class
Nlpsol::init(opts);
// Default options
pass_nonlinear_variables_ = false;
Dict hess_lag_options, jac_g_options, grad_f_options;
// Read user options
for (auto&& op : opts) {
if (op.first=="bonmin") {
opts_ = op.second;
} else if (op.first=="pass_nonlinear_variables") {
pass_nonlinear_variables_ = op.second;
} else if (op.first=="var_string_md") {
var_string_md_ = op.second;
} else if (op.first=="var_integer_md") {
var_integer_md_ = op.second;
} else if (op.first=="var_numeric_md") {
var_numeric_md_ = op.second;
} else if (op.first=="con_string_md") {
con_string_md_ = op.second;
} else if (op.first=="con_integer_md") {
con_integer_md_ = op.second;
} else if (op.first=="con_numeric_md") {
con_numeric_md_ = op.second;
} else if (op.first=="hess_lag_options") {
hess_lag_options = op.second;
} else if (op.first=="jac_g_options") {
jac_g_options = op.second;
} else if (op.first=="grad_f_options") {
grad_f_options = op.second;
} else if (op.first=="hess_lag") {
Function f = op.second;
casadi_assert(f.n_in()==4);
casadi_assert(f.n_out()==1);
set_function(f, "nlp_hess_l");
} else if (op.first=="jac_g") {
Function f = op.second;
casadi_assert(f.n_in()==2);
casadi_assert(f.n_out()==2);
set_function(f, "nlp_jac_g");
} else if (op.first=="grad_f") {
Function f = op.second;
casadi_assert(f.n_in()==2);
casadi_assert(f.n_out()==2);
set_function(f, "nlp_grad_f");
}
}
// Do we need second order derivatives?
exact_hessian_ = true;
auto hessian_approximation = opts_.find("hessian_approximation");
if (hessian_approximation!=opts_.end()) {
exact_hessian_ = hessian_approximation->second == "exact";
}
// Setup NLP functions
create_function("nlp_f", {"x", "p"}, {"f"});
create_function("nlp_g", {"x", "p"}, {"g"});
if (!has_function("nlp_grad_f")) {
create_function("nlp_grad_f", {"x", "p"}, {"f", "grad:f:x"});
}
if (!has_function("nlp_jac_g")) {
create_function("nlp_jac_g", {"x", "p"}, {"g", "jac:g:x"});
}
jacg_sp_ = get_function("nlp_jac_g").sparsity_out(1);
// Allocate temporary work vectors
if (exact_hessian_) {
if (!has_function("nlp_hess_l")) {
create_function("nlp_hess_l", {"x", "p", "lam:f", "lam:g"},
{"hess:gamma:x:x"}, {{"gamma", {"f", "g"}}});
}
hesslag_sp_ = get_function("nlp_hess_l").sparsity_out(0);
} else if (pass_nonlinear_variables_) {
nl_ex_ = oracle_.which_depends("x", {"f", "g"}, 2, false);
}
// Allocate work vectors
alloc_w(nx_, true); // xk_
alloc_w(ng_, true); // lam_gk_
alloc_w(nx_, true); // lam_xk_
alloc_w(ng_, true); // gk_
alloc_w(nx_, true); // grad_fk_
alloc_w(jacg_sp_.nnz(), true); // jac_gk_
if (exact_hessian_) {
alloc_w(hesslag_sp_.nnz(), true); // hess_lk_
}
}
void SundialsInterface::init(const Dict& opts) {
// Call the base class method
Integrator::init(opts);
// If sensitivity equations, make sure derivative_of_ is available
casadi_assert_message(ns_==0 || !derivative_of_.is_null(),
"Not implemented.");
// Default options
abstol_ = 1e-8;
reltol_ = 1e-6;
max_num_steps_ = 10000;
stop_at_end_ = true;
use_precon_ = true;
max_krylov_ = 10;
linear_solver_ = "csparse";
string newton_scheme = "direct";
quad_err_con_ = false;
string interpolation_type = "hermite";
steps_per_checkpoint_ = 20;
disable_internal_warnings_ = false;
max_multistep_order_ = 5;
second_order_correction_ = true;
step0_ = 0;
max_order_ = 0;
nonlin_conv_coeff_ = 0;
// Read options
for (auto&& op : opts) {
if (op.first=="abstol") {
abstol_ = op.second;
} else if (op.first=="reltol") {
reltol_ = op.second;
} else if (op.first=="max_num_steps") {
max_num_steps_ = op.second;
} else if (op.first=="stop_at_end") {
stop_at_end_ = op.second;
} else if (op.first=="use_preconditioner") {
use_precon_ = op.second;
} else if (op.first=="max_krylov") {
max_krylov_ = op.second;
} else if (op.first=="newton_scheme") {
newton_scheme = op.second.to_string();
} else if (op.first=="linear_solver") {
linear_solver_ = op.second.to_string();
} else if (op.first=="linear_solver_options") {
linear_solver_options_ = op.second;
} else if (op.first=="quad_err_con") {
quad_err_con_ = op.second;
} else if (op.first=="interpolation_type") {
interpolation_type = op.second.to_string();
} else if (op.first=="steps_per_checkpoint") {
steps_per_checkpoint_ = op.second;
} else if (op.first=="disable_internal_warnings") {
disable_internal_warnings_ = op.second;
} else if (op.first=="max_multistep_order") {
max_multistep_order_ = op.second;
} else if (op.first=="second_order_correction") {
second_order_correction_ = op.second;
} else if (op.first=="step0") {
step0_ = op.second;
} else if (op.first=="max_order") {
max_order_ = op.second;
} else if (op.first=="nonlin_conv_coeff") {
nonlin_conv_coeff_ = op.second;
}
}
// Type of Newton scheme
if (newton_scheme=="direct") {
newton_scheme_ = SD_DIRECT;
} else if (newton_scheme=="gmres") {
newton_scheme_ = SD_GMRES;
} else if (newton_scheme=="bcgstab") {
newton_scheme_ = SD_BCGSTAB;
} else if (newton_scheme=="tfqmr") {
newton_scheme_ = SD_TFQMR;
} else {
casadi_error("Unknown Newton scheme: " + newton_scheme);
}
// Interpolation_type
if (interpolation_type=="hermite") {
interp_ = SD_HERMITE;
} else if (interpolation_type=="polynomial") {
interp_ = SD_POLYNOMIAL;
} else {
casadi_error("Unknown interpolation type: " + interpolation_type);
}
// Get or create Jacobians and linear system solvers
for (bool backward : {false, true}) {
// Skip backward?
if (backward && nrx_==0) continue;
// Get Jacobian function
Function J;
if (ns_==0) {
J = getJ(backward);
} else {
SundialsInterface* d = derivative_of_.get<SundialsInterface>();
casadi_assert(d!=0);
if (d->ns_==0) {
J = d->get_function(backward ? "jacB" : "jacF");
} else {
J = d->getJ(backward);
}
}
set_function(J, J.name(), true);
alloc_w(J.nnz_out(0), true);
}
// Allocate work vectors
alloc_w(np_, true); // p
alloc_w(nrp_, true); // rp
alloc_w(2*max(nx_+nz_, nrx_+nrz_), true); // v1, v2
// Allocate linear solvers
linsolF_ = Linsol("linsolF", linear_solver_, linear_solver_options_);
if (nrx_>0) {
linsolB_ = Linsol("linsolB", linear_solver_, linear_solver_options_);
}
}
/** Register the function for evaluation and statistics gathering */
void set_function(const Function& fcn) { set_function(fcn, fcn.name()); }
static void set_local(void)
{
__function= set_function("pipe", "HOSTILE_PIPE");
__function= set_function("pipe2", "HOSTILE_PIPE2");
}
static void set_malloc(void)
{
__function= set_function("malloc", "HOSTILE_MALLOC");
}
