OptError CGProblem::CreateApplicationOptimizer(OptimizeClass* &objfcn,
NLP0* &func)
{
OptError error;
int numVar = GetNumVar();
VariableList* variables = GetVariables();
AppLauncher* launcher = GetAppLauncher();
USERFCN0APP userFcn = &(launcher->run_app);
INITFCNAPP initFcn = &(launcher->init_app);
if ((variables->upperExists()) || (variables->lowerExists()) ||
(variables->linearExists()) || (variables->nonlinearExists()))
{
cout << "CG does not support constraints." << endl;
cout << "Constraints being ignored" << endl;
}
FDNLF1APP * myFunc = new FDNLF1APP(numVar, userFcn, initFcn,
launcher);
myFunc->setIsExpensive(true);
func = myFunc;
objfcn = new OptCG(myFunc);
error.value = 0;
error.msg = "Success";
return error;
}
virtual void whereClause (const WhereClause* const, const TableOperation* p_GroupGraphPattern, const BindingClause* p_BindingClause) {
ResultSet* joined(NULL);
const ResultSet* working = &rs;
if (p_BindingClause != NULL) {
working = joined = new ResultSet(rs);
p_BindingClause->bindVariables(NULL, joined);
}
vars.clear(); // probably got filled with e.g. select vars.
p_GroupGraphPattern->express(this);
const TableOperation* op = last.tableOperation;
const VariableList* knownVars = working->getKnownVars();
std::vector<const POS*> v(vars.size() + knownVars->size());
std::vector<const POS*>::iterator needed =
std::set_intersection (vars.begin(), vars.end(), knownVars->begin(),
knownVars->end(), v.begin());
const std::set<const POS*> s(v.begin(), v.end());
const Expression* filter = working->getFederationExpression(s, false);
if (filter) {
Filter* f = new Filter(op);
f->addExpression(filter);
op = f;
}
if (joined)
delete joined;
last.whereClause = new WhereClause(op, NULL);
}
std::vector<FormalParameter> juli::Function::transformParameterList(VariableList args, const TypeInfo& typeInfo) {
std::vector<FormalParameter> formalArguments;
for (VariableList::iterator i = args.begin(); i != args.end(); ++i) {
formalArguments.push_back(FormalParameter((*i)->type->resolve(typeInfo), (*i)->name->name));
}
return formalArguments;
}
BaseExpression* Parser::handleFunctionDeclaration(DragonType type, string name)
{
VariableList args;
LexerToken nextToken;
DragonVariable argument = {TYPE_NONE, ""};
while(nextToken.value[0] != ')') {
nextToken = mLexer->getToken();
switch (nextToken.type) {
case TYPE:
argument.type = toDragonType(nextToken.value);
break;
case IDENTIFIER:
if(argument.type != TYPE_NONE) {
argument.name = nextToken.value;
args.push_back(argument);
argument.type = TYPE_NONE;
} else {
printf("No type specified '%s' in argument list for function '%s'", argument.name.c_str(), name.c_str());exit(0);
}
break;
case BRACE:
case SPECIAL_SYMBOL:
break;
default:
printf("Unexpected '%s' in argument list for function '%s',"
" expected ','", nextToken.value.c_str(), name.c_str());exit(0);
break;
}
}
return new FunctionDeclExpr(type, name, args);
}
//执行
void COpScript::Execute(CMoveShape* pShape)
{
#ifdef _RUNSTACKINFO1_
CMessage::AsyWriteFile(GetGame()->GetStatckFileName(), "COpScript::Execute() begin");
#endif
// [5/4/2009 chenxianj]
//CScript *pTempScript = PopFreeScript("COpScript::Execute");
//if (pTempScript)
//{
// pTempScript->SetVariableList(m_pParam->pVariableList);
// pTempScript->SetUsedItemID(m_pParam->GoodsGuid);
// pTempScript->SetSrcShapeEx(m_pParam->pUser);
// // [5/4/2009 chenxianj]
// itExpress it = m_Expressions.begin();
// for(;it != m_Expressions.end();it++)
// {
// if(m_pParam->pUser)
// pTempScript->SetRegion(dynamic_cast<CRegion*>(m_pParam->pUser->GetFather()));
// else
// pTempScript->SetRegion(NULL);
// (*it)->Execute(pTempScript,pShape);
// }
// // [5/4/2009 chenxianj]
// PushFreeScript(pTempScript);
//}
Script::RunEnv env( m_pParam->pUser, pShape, static_cast<CRegion*>( m_pParam->pUser->GetFather() ),
m_pParam->pVariableList );
VariableList *varList = m_pParam->pVariableList;
if( !varList->AddVar( "$ParamA", (double)(DWORD)m_pParam->pUser ) )
{
varList->SetVarValue( "$ParamA", (double)(DWORD) m_pParam->pUser );
}
if( !varList->AddVar( "$ParamB", (double)(DWORD)pShape ) )
{
varList->SetVarValue( "$ParamB", (double)(DWORD) pShape );
}
Script *script = GetInst( ScriptSys ).NewScript( env );
for( itExpress it = m_Expressions.begin(); it != m_Expressions.end(); ++ it )
{
CExpressions *exp = *it;
int ret = exp->Execute( script, pShape );
if( !script->CanDelete( ret ) )
{
// yield script, cannot run.
assert( "Yield script" && 0 );
}
}
GetInst( ScriptSys ).DelScript( script );
#ifdef _RUNSTACKINFO1_
CMessage::AsyWriteFile(GetGame()->GetStatckFileName(), "COpScript::Execute() end");
#endif
}
void NewtonProblem::SetParameters(OptimizeClass* objfcn)
{
Problem::SetParameters(objfcn);
DOMElement* searchXML = GetParameterXML();
VariableList* variables = GetVariables();
string gradMult, searchSize, maxBack;
OptNewtonLike * objfcnNewt = (OptNewtonLike *) objfcn;
if(searchType_ == trustPDS)
{
objfcnNewt->setSearchStrategy(TrustPDS);
gradMult =
XMLString::transcode(searchXML->getAttribute(XMLString::transcode("gradMult")));
if (gradMult != "")
objfcnNewt->setGradMult(atof(gradMult.c_str()));
searchSize =
XMLString::transcode(searchXML->getAttribute(XMLString::transcode("searchSize")));
if (searchSize != "")
objfcnNewt->setSearchSize(atoi(searchSize.c_str()));
}
else if (searchType_ == lineSearch)
{
objfcnNewt->setSearchStrategy(LineSearch);
maxBack =
XMLString::transcode(searchXML->getAttribute(XMLString::transcode("maxBTIter")));
if (maxBack != "")
objfcnNewt->setMaxBacktrackIter(atoi(maxBack.c_str()));
}
else if (searchType_ == trustRegion)
{
if ((variables->upperExists()) || (variables->lowerExists()))
{
cout << "Newton with Trust Region does not support bounds." << endl;
cout << "Using Line Search instead." << endl;
objfcnNewt->setSearchStrategy(LineSearch);
}
else
{
objfcnNewt->setSearchStrategy(TrustRegion);
gradMult =
XMLString::transcode(searchXML->getAttribute(XMLString::transcode("gradMult")));
if (gradMult != "")
objfcnNewt->setGradMult(atof(gradMult.c_str()));
}
}
else
{
cerr << "Unrecognized search strategy type" << endl;
exit(1);
}
}
std::string NFunctionSignature::calculateSignature(const NType& returnType, const VariableList& arguments)
{
std::string name = "fp-(";
name += returnType.name + "-";
for (VariableList::const_iterator i = arguments.begin(); i != arguments.end(); i++)
name += (*i)->type.name + ",";
name += ")";
return name;
}
///
/// 设置指定列表里某个变量的值
///
/// ret = SetVar( operType, "$varName", val, pos )
/// @param operType:VT_SCRIPT, VT_SRCSHAPE, VT_DESTSHAPE, VT_GLOBAL
/// @param varName 变量名
/// @param val 变量值
/// @param pos [可选]数组索引
///
static int SetVar( lua_State *L )
{
Script *script = GetInst( ScriptSys ).GetScript( L );
long operType = (long) tolua_tonumber( L, 1, 0 );
VariableList *varList = ( script != NULL ? script->GetVarList( operType ) : NULL );
bool ret = false;
if( varList != NULL )
{
ret = true;
long index = (long) tolua_tonumber( L, 4, 0 );
const char *varName = TOLUA_TOSTRING( varName, L, 2, "" );
long varType = VarList::VarType( varName );
if( varType == VariableList::VAR_NUM )
{
VariableList::Number val = (VariableList::Number) tolua_tonumber( L, 3, 0 );
varList->SetVarValue( varName, val, index );
if( operType == Script::VT_GLOBAL )
{
ScriptUtils::UpdateValToWS( varName, val, index );
}
}
else if( varType == VariableList::VAR_STRING )
{
const char *val = TOLUA_TOSTRING( val, L, 3, "" );
varList->SetVarValue( varName, tString( val ), index );
if( operType == Script::VT_GLOBAL )
{
ScriptUtils::UpdateValToWS( varName, tString( val ), index );
}
}
else if( varType == VariableList::VAR_GUID )
{
const CGUID *val = TOLUA_TOGUID( val, L, 3, &NULL_GUID );
varList->SetVarValue( varName, *val, index );
if( operType == Script::VT_GLOBAL )
{
ScriptUtils::UpdateValToWS( varName, *val, index );
}
}
else
{
// argument error
ret = false;
}
}
else
{
// pop the arguments.
int top = lua_gettop( L );
lua_settop( L, top - 3 );
}
lua_pushboolean( L, ret ? 1 : 0 );
return 1;
}
uint32_t
ModuleList::FindGlobalVariables (const ConstString &name,
bool append,
uint32_t max_matches,
VariableList& variable_list)
{
size_t initial_size = variable_list.GetSize();
Mutex::Locker locker(m_modules_mutex);
collection::iterator pos, end = m_modules.end();
for (pos = m_modules.begin(); pos != end; ++pos)
{
(*pos)->FindGlobalVariables (name, NULL, append, max_matches, variable_list);
}
return variable_list.GetSize() - initial_size;
}
size_t
ModuleList::FindGlobalVariables (const RegularExpression& regex,
bool append,
size_t max_matches,
VariableList& variable_list) const
{
size_t initial_size = variable_list.GetSize();
Mutex::Locker locker(m_modules_mutex);
collection::const_iterator pos, end = m_modules.end();
for (pos = m_modules.begin(); pos != end; ++pos)
{
(*pos)->FindGlobalVariables (regex, append, max_matches, variable_list);
}
return variable_list.GetSize() - initial_size;
}
size_t
ModuleList::FindGlobalVariables (const ConstString &name,
bool append,
size_t max_matches,
VariableList& variable_list) const
{
size_t initial_size = variable_list.GetSize();
std::lock_guard<std::recursive_mutex> guard(m_modules_mutex);
collection::const_iterator pos, end = m_modules.end();
for (pos = m_modules.begin(); pos != end; ++pos)
{
(*pos)->FindGlobalVariables(name, nullptr, append, max_matches, variable_list);
}
return variable_list.GetSize() - initial_size;
}
uint32_t SymbolFile::FindGlobalVariables(
const ConstString &name, const CompilerDeclContext *parent_decl_ctx,
bool append, uint32_t max_matches, VariableList &variables) {
if (!append)
variables.Clear();
return 0;
}
uint32_t SymbolFile::FindGlobalVariables(const RegularExpression ®ex,
bool append, uint32_t max_matches,
VariableList &variables) {
if (!append)
variables.Clear();
return 0;
}
int addSymtable(Symtable& t){
bool err=false;
TType* ret = t.lookupType(type.name);
if(ret==NULL){
cerr << "Error in function declaration " << id.name << " type "<< type.name << " does not exist" << endl;
err=true;
}
std::vector<TType*>* arguments = new vector<TType*>();
int i;
TType* c;
for(i=0; i<args.size(); i++){
c = t.lookupType(args[i]->type.name);
if(c==NULL){
err=true;
cerr << "Error in function declaration " << id.name << " type " << args[i]->type.name << " does not exist" << endl;
}
arguments->push_back(c);
}
if(err){
return 1;
}
TFunc* f = new TFunc(id.name,ret,arguments);
if(!t.insertfun(f))
return 2;
else
return 0;
}
void printTree(std::ostream& os, int depth =0){
os<<string(depth,' ')<<"NUnionDecl: id= "<< type.name<<endl;
os<<string(depth+1,' ')<<"fields= {"<< type.name<<endl;
for(int i=0;i<fields.size();i++){
fields[i]->printTree(os,depth+2);
}
os<<string(depth+1,' ')<<"}"<< type.name<<endl;
}
///
/// 移除指定列表里的某个脚本变量
///
/// RemoveVar( operType, "$varName" )
/// @param operType:VT_SCRIPT, VT_SRCSHAPE, VT_DESTSHAPE
/// @param varName 变量名
///
static int RemoveVar( lua_State *L )
{
Script *script = GetInst( ScriptSys ).GetScript( L );
long operType = (long) tolua_tonumber( L, 1, 0 );
VariableList *varList = ( script != NULL ? script->GetVarList( operType ) : NULL );
if( operType == Script::VT_GLOBAL )
{
// not support global variable list
varList = NULL;
}
const char *varName = TOLUA_TOSTRING( varName, L, 2, "" );
if( varList != NULL )
{
varList->RemoveVar( varName );
}
return 0;
}
void Location::abstract_rates(const VariableList &cvl,
const Valuations &dvl,
vector<int> &v_rates) const
{
int pos = 0;
for ( auto it = cvl.begin(); it != cvl.end(); it++, pos++) {
auto x = *it;
for ( auto iit = rates.begin(); iit != rates.end(); iit++) {
if (x == iit->get_var()) {
int r = iit->eval(dvl);
v_rates[pos] = r;
break;
}
}
}
}
OptError NewtonProblem::CreateApplicationOptimizer(OptimizeClass * &objfcn,
NLP0 * &func)
{
OptError error;
int numVar = GetNumVar();
VariableList* variables = GetVariables();
CompoundConstraint* constraints = 0;
AppLauncher * launcher = GetAppLauncher();
USERFCN0APP userFcn = &(launcher->run_app);
INITFCNAPP initFcn = &(launcher->init_app);
if(userFcn == NULL)
{
error.value = -4;
error.msg = "Error loading user function";
return error;
}
else if(initFcn == NULL)
{
error.value = -4;
error.msg = "Error loading init function";
return error;
}
if ((variables->linearExists()) || (variables->nonlinearExists()))
{
cout << "Newton does not support linear or nonlinear constraints." << endl;
cout << "Linear and nonlinear constraints being ignored." << endl;
}
if ((variables->upperExists()) || (variables->lowerExists()))
{
constraints = new CompoundConstraint(Constraint(variables->GetBoundConstraints()));
}
FDNLF1APP * myFunc = new FDNLF1APP(numVar, userFcn, initFcn,
launcher, constraints);
myFunc->setIsExpensive(true);
if(searchType_ == trustPDS)
myFunc->setSpecOption(NoSpec);
func = myFunc;
if ((variables->upperExists()) || (variables->lowerExists()))
{
objfcn = new OptBCQNewton(myFunc);
}
else
{
objfcn = new OptQNewton(myFunc);
}
error.value = 0;
error.msg = "Success";
return error;
}
size_t
VariableList::AppendVariablesIfUnique (const RegularExpression& regex, VariableList &var_list, size_t& total_matches)
{
const size_t initial_size = var_list.GetSize();
iterator pos, end = m_variables.end();
for (pos = m_variables.begin(); pos != end; ++pos)
{
if ((*pos)->NameMatches (regex))
{
// Note the total matches found
total_matches++;
// Only add this variable if it isn't already in the "var_list"
var_list.AddVariableIfUnique (*pos);
}
}
// Return the number of new unique variables added to "var_list"
return var_list.GetSize() - initial_size;
}
void testVarParser(char *buf)
{
printf("===== Testing Variable parser ======\n");
// time_t start = GetTickCount();
VariableList li;
// fflush(stdout);
std::map<std::string, std::string> ignoreTokens;
get_variables(buf, li, ignoreTokens, true);
// time_t end = GetTickCount();
for (VariableList::iterator iter = li.begin(); iter != li.end(); iter++) {
Variable var = *iter;
var.Print();
}
// printf("total time: %d\n", end-start);
printf("matches found: %d\n", li.size());
}
void GeneralConstraint::stackVariables( VariableList& varList,
const VariableSet& varSet )
{
for(VariableSet::const_iterator it= varSet.begin();
it!=varSet.end();
++it)
{
varList.push_back(*it);
}
} // End of method 'GeneralConstraint::stackVariables()'
void printTree(std::ostream& os, int depth =0){
os<<string(depth,' ')<<"NFunctionDecl: id= "<< id.name<<"type="<<type.name<<endl;
os<<string(depth,' ')<<"args= ("<<endl;
for(int i=0;i<args.size();i++){
args[i]->printTree(os,depth+1);
}
os<<string(depth,' ')<<")"<<endl;
if(block!=NULL) {
block->printTree(os,depth+1);
}
}
/**
* Creates and caches a simplified version of the linear programming problem,
* where redundant rows, columns and constraints are removed,
* if it has not been created before.
* Then, the simplified problem is solved.
*
* @return the result of the solving attempt
*/
ResultType
LPSolveInterface::_Presolve(const VariableList& variables)
{
if (fLpPresolved == NULL) {
fLpPresolved = copy_lp(fLP);
set_presolve(fLpPresolved, PRESOLVE_ROWS | PRESOLVE_COLS
| PRESOLVE_LINDEP, get_presolveloops(fLpPresolved));
}
ResultType result = (ResultType)solve(fLpPresolved);
if (result == OPTIMAL) {
int32 size = variables.CountItems();
for (int32 i = 0; i < size; i++) {
Variable* current = variables.ItemAt(i);
current->SetValue(get_var_primalresult(fLpPresolved,
get_Norig_rows(fLpPresolved) + current->GlobalIndex() + 1));
}
}
return result;
}
Linear_Constraint Location::rates_to_Linear_Constraint(const VariableList &cvl,
const Valuations &dvl,
VariableList &lvars) const
{
Linear_Constraint lc;
for ( auto const &x : cvl) {
//string x = it->name;
for ( auto iit = rates.begin(); iit != rates.end(); iit++) {
if (x == iit->get_var()) {
PPL::Variable v = get_ppl_variable(cvl, x);
Linear_Expr le = iit->to_Linear_Expr(cvl, dvl);
AT_Constraint atc = (v==le);
lc.insert(atc);
for (auto lt = lvars.begin(); lt != lvars.end(); lt++)
if ( x == *lt) {
lvars.erase(lt);
break;
}
break;
}
}
}
return lc;
}
// do not need to revise all variables because we assume soft AC already done
void VACExtension::reset()
{
VACVariable *x;
TreeDecomposition *td = wcsp->getTreeDec();
clear();
while (!queueP->empty())
queueP->pop();
while (!queueR->empty())
queueR->pop();
// int bucket = cost2log2glb(ToulBar2::costThreshold);
int bucket = cost2log2glb(itThreshold);
if (bucket < 0)
bucket = 0;
for (; bucket < wcsp->getNCBucketSize(); bucket++) {
VariableList *varlist = wcsp->getNCBucket(bucket);
for (VariableList::iterator iter = varlist->begin();
iter != varlist->end();) {
x = (VACVariable *) * iter;
if (x->unassigned() && (x->getMaxCost() >= itThreshold)) {
if (td) {
if (td->
isActiveAndInCurrentClusterSubTree
(x->getCluster()))
x->queueVAC();
} else
x->queueVAC();
}
++iter;
}
}
// for (BTQueue::iterator it = VAC2.begin(); it != VAC2.end(); ++it) {
// x = (VACVariable*) (*it);
// if (td) { if(td->isActiveAndInCurrentClusterSubTree(x->getCluster())) x->queueVAC(); }
// else x->queueVAC();
// }
}
int addToSymtable(Symtable& t){
bool err=false;
TVar* vars;
TRegister* reg=new TRegister(type.name);
for(int i=0;i<fields.size();i++){
vars = (TVar*)t.lookup(fields[i]->id.name);
if(vars==NULL) cerr<<fields[i]->id.name<<" variable not declared"<<endl;
else {
reg->addField(&vars->type,vars->name);
}
}
#ifdef DEBUG
cout<<"inserting "<<type.name<<endl;
#endif
t.insertType(type.name,reg);
return 0;
}
TType* typeChk(Symtable& t,TType* expected = NULL){
t.begScope();
bool err=false;
TType* temp;
for (int i=0;i<fields.size();i++){
temp = fields[i]->typeChk(t);
if(temp == NULL){
cerr<<"error in the declaration"<<i+1<<" of union "<<type.name<<endl;
err = true;
}
}
t.endScope();
if (err) {
cerr << "Error in union "<<type.name<<" declaration"<<endl;
return NULL;
}
return t.lookupType("void");
}
bool NSParser::readPointVar(Symbol* symbol, VariableList& variables, Tools::RPoint &point)
{
bool result = false;
QString varName = readVar(symbol);
if (variables.contains(varName))
{
DeclaredVariable& var = variables[varName];
if (var.isPoint())
{
point = var.toPoint();
result = true;
}
else
addError(NSParsingError::invalidVariableTypeError(varName, "point", symbol));
}
else
addError(NSParsingError::undeclaredVariableError(varName, symbol));
return result;
}
bool NSParser::readRectVar(Symbol* symbol, VariableList &variables, QRectF &r)
{
bool result = false;
QString varName = readVar(symbol);
if (variables.contains(varName))
{
DeclaredVariable& var = variables[varName];
if (var.isRect())
{
r = var.toRect();
result = true;
}
else
addError(NSParsingError::invalidVariableTypeError(varName, "rect", symbol));
}
else
addError(NSParsingError::undeclaredVariableError(varName, symbol));
return result;
}
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
void VariableAnalysis::InsertAggregateCandidates(OperandVariableDict& dict,
const VariableList& varList) {
auto unit = funct_->ParentUnit();
for(int i = 0; i < varList.Count(); i++) {
auto variable = varList[i];
if((variable->IsArray() ||
variable->IsRecord() ||
variable->IsPointer()) == false) {
continue;
}
variable->SetIsAddresTaken(false); // Presume it's not.
auto variableRefType = unit->Types().GetPointer(variable->GetType());
auto variableRef = unit->References().GetVariableRef(variable, variableRefType);
dict.Add(variableRef, OVPair(variableRef, variable));
}
}
