void CheckCondition::checkIncorrectLogicOperator() { const bool printStyle = _settings->isEnabled("style"); const bool printWarning = _settings->isEnabled("warning"); if (!printWarning && !printStyle) return; const SymbolDatabase *symbolDatabase = _tokenizer->getSymbolDatabase(); const std::size_t functions = symbolDatabase->functionScopes.size(); for (std::size_t ii = 0; ii < functions; ++ii) { const Scope * scope = symbolDatabase->functionScopes[ii]; for (const Token* tok = scope->classStart->next(); tok != scope->classEnd; tok = tok->next()) { if (!Token::Match(tok, "%oror%|&&") || !tok->astOperand1() || !tok->astOperand2()) continue; // Opposite comparisons around || or && => always true or always false if ((tok->astOperand1()->isName() || tok->astOperand2()->isName()) && isOppositeCond(true, _tokenizer->isCPP(), tok->astOperand1(), tok->astOperand2(), _settings->library.functionpure)) { const bool alwaysTrue(tok->str() == "||"); incorrectLogicOperatorError(tok, tok->expressionString(), alwaysTrue); continue; } // 'A && (!A || B)' is equivalent with 'A && B' // 'A || (!A && B)' is equivalent with 'A || B' if (printStyle && ((tok->str() == "||" && tok->astOperand2()->str() == "&&") || (tok->str() == "&&" && tok->astOperand2()->str() == "||"))) { const Token* tok2 = tok->astOperand2()->astOperand1(); if (isOppositeCond(true, _tokenizer->isCPP(), tok->astOperand1(), tok2, _settings->library.functionpure)) { std::string expr1(tok->astOperand1()->expressionString()); std::string expr2(tok->astOperand2()->astOperand1()->expressionString()); std::string expr3(tok->astOperand2()->astOperand2()->expressionString()); if (expr1.length() + expr2.length() + expr3.length() > 50U) { if (expr1[0] == '!' && expr2[0] != '!') { expr1 = "!A"; expr2 = "A"; } else { expr1 = "A"; expr2 = "!A"; } expr3 = "B"; } const std::string cond1 = expr1 + " " + tok->str() + " (" + expr2 + " " + tok->astOperand2()->str() + " " + expr3 + ")"; const std::string cond2 = expr1 + " " + tok->str() + " " + expr3; redundantConditionError(tok, tok2->expressionString() + ". '" + cond1 + "' is equivalent to '" + cond2 + "'"); continue; } } // Comparison #1 (LHS) const Token *comp1 = tok->astOperand1(); if (comp1 && comp1->str() == tok->str()) comp1 = comp1->astOperand2(); // Comparison #2 (RHS) const Token *comp2 = tok->astOperand2(); // Parse LHS bool not1; std::string op1, value1; const Token *expr1; if (!parseComparison(comp1, ¬1, &op1, &value1, &expr1)) continue; // Parse RHS bool not2; std::string op2, value2; const Token *expr2; if (!parseComparison(comp2, ¬2, &op2, &value2, &expr2)) continue; if (isSameExpression(_tokenizer->isCPP(), comp1, comp2, _settings->library.functionpure)) continue; // same expressions => only report that there are same expressions if (!isSameExpression(_tokenizer->isCPP(), expr1, expr2, _settings->library.functionpure)) continue; const bool isfloat = astIsFloat(expr1, true) || MathLib::isFloat(value1) || astIsFloat(expr2, true) || MathLib::isFloat(value2); // don't check floating point equality comparisons. that is bad // and deserves different warnings. if (isfloat && (op1 == "==" || op1 == "!=" || op2 == "==" || op2 == "!=")) continue; const double d1 = (isfloat) ? MathLib::toDoubleNumber(value1) : 0; const double d2 = (isfloat) ? MathLib::toDoubleNumber(value2) : 0; const MathLib::bigint i1 = (isfloat) ? 0 : MathLib::toLongNumber(value1); const MathLib::bigint i2 = (isfloat) ? 0 : MathLib::toLongNumber(value2); const bool useUnsignedInt = (std::numeric_limits<MathLib::bigint>::max()==i1)||(std::numeric_limits<MathLib::bigint>::max()==i2); const MathLib::biguint u1 = (useUnsignedInt) ? MathLib::toLongNumber(value1) : 0; const MathLib::biguint u2 = (useUnsignedInt) ? MathLib::toLongNumber(value2) : 0; // evaluate if expression is always true/false bool alwaysTrue = true, alwaysFalse = true; bool firstTrue = true, secondTrue = true; for (int test = 1; test <= 5; ++test) { // test: // 1 => testvalue is less than both value1 and value2 // 2 => testvalue is value1 // 3 => testvalue is between value1 and value2 // 4 => testvalue value2 // 5 => testvalue is larger than both value1 and value2 bool result1, result2; if (isfloat) { const double testvalue = getvalue<double>(test, d1, d2); result1 = checkFloatRelation(op1, testvalue, d1); result2 = checkFloatRelation(op2, testvalue, d2); } else if (useUnsignedInt) { const MathLib::biguint testvalue = getvalue<MathLib::biguint>(test, u1, u2); result1 = checkIntRelation(op1, testvalue, u1); result2 = checkIntRelation(op2, testvalue, u2); } else { const MathLib::bigint testvalue = getvalue<MathLib::bigint>(test, i1, i2); result1 = checkIntRelation(op1, testvalue, i1); result2 = checkIntRelation(op2, testvalue, i2); } if (not1) result1 = !result1; if (not2) result2 = !result2; if (tok->str() == "&&") { alwaysTrue &= (result1 && result2); alwaysFalse &= !(result1 && result2); } else { alwaysTrue &= (result1 || result2); alwaysFalse &= !(result1 || result2); } firstTrue &= !(!result1 && result2); secondTrue &= !(result1 && !result2); } const std::string cond1str = conditionString(not1, expr1, op1, value1); const std::string cond2str = conditionString(not2, expr2, op2, value2); if (printWarning && (alwaysTrue || alwaysFalse)) { const std::string text = cond1str + " " + tok->str() + " " + cond2str; incorrectLogicOperatorError(tok, text, alwaysTrue); } else if (printStyle && secondTrue) { const std::string text = "If '" + cond1str + "', the comparison '" + cond2str + "' is always " + (secondTrue ? "true" : "false") + "."; redundantConditionError(tok, text); } else if (printStyle && firstTrue) { //const std::string text = "The comparison " + cond1str + " is always " + // (firstTrue ? "true" : "false") + " when " + // cond2str + "."; const std::string text = "If '" + cond2str + "', the comparison '" + cond1str + "' is always " + (firstTrue ? "true" : "false") + "."; redundantConditionError(tok, text); } } } }
PHPEntityBase::Ptr_t PHPCodeCompletion::DoGetPHPEntryUnderTheAtPos(IEditor* editor, int pos, bool forFunctionCalltip) { if(!PHPWorkspace::Get()->IsOpen()) return PHPEntityBase::Ptr_t(NULL); pos = editor->GetSTC()->WordEndPosition(pos, true); // Get the expression under the caret wxString unsavedBuffer = editor->GetTextRange(0, pos); wxString filter; PHPEntityBase::Ptr_t resolved; // Parse the source file PHPSourceFile source(unsavedBuffer); source.SetFilename(editor->GetFileName()); source.SetParseFunctionBody(false); source.Parse(); PHPEntityBase::Ptr_t currentScope = source.CurrentScope(); if(currentScope && currentScope->Is(kEntityTypeClass)) { // we are trying to resolve a 'word' under the caret within the class // body but _not_ within a function body (i.e. it can only be // a definition of some kind) // try to construct an expression that will work int wordStart = editor->GetSTC()->WordStartPosition(pos, true); wxString theWord = editor->GetTextRange(wordStart, pos); wxString theWordNoDollar = theWord; if(theWord.StartsWith("$")) { theWordNoDollar = theWord.Mid(1); } PHPExpression expr2(unsavedBuffer, "<?php $this->" + theWordNoDollar, forFunctionCalltip); resolved = expr2.Resolve(m_lookupTable, editor->GetFileName().GetFullPath()); filter = expr2.GetFilter(); if(!resolved) { // Maybe its a static member/function/const, try using static keyword PHPExpression expr3(unsavedBuffer, "<?php static::" + theWord, forFunctionCalltip); resolved = expr2.Resolve(m_lookupTable, editor->GetFileName().GetFullPath()); filter = expr2.GetFilter(); } } if(!resolved) { PHPExpression expr(unsavedBuffer, "", forFunctionCalltip); resolved = expr.Resolve(m_lookupTable, editor->GetFileName().GetFullPath()); filter = expr.GetFilter(); } if(resolved && !filter.IsEmpty()) { resolved = m_lookupTable.FindMemberOf(resolved->GetDbId(), filter); if(!resolved) { // Fallback to functions and constants PHPEntityBase::List_t children = m_lookupTable.FindGlobalFunctionAndConsts(PHPLookupTable::kLookupFlags_ExactMatch, filter); if(children.size() == 1) { resolved = *children.begin(); } } if(resolved && resolved->Is(kEntityTypeFunction)) { // for a function, we need to load its children (function arguments) resolved->SetChildren(m_lookupTable.LoadFunctionArguments(resolved->GetDbId())); } } return resolved; }
/**************************************************程序入口****************************************************/ int main() { clock_t start,finish; double totaltime; start=clock(); time_t nowTime=time(0); struct tm* nowTimeStruct=localtime(&nowTime);//打印系统时间 // output<<"系统当前时间:"<<1900+nowTimeStruct->tm_year<<"."<<nowTimeStruct->tm_mon+1<<"."<< // nowTimeStruct->tm_mday<<" "<<nowTimeStruct->tm_hour<<":"<<nowTimeStruct->tm_min<<":"<<nowTimeStruct->tm_sec<<endl; try { // output<<">>>>>>>>>>>>>>>>>>>>>>>>>数据区<<<<<<<<<<<<<<<<<<<<"<<endl; define_data(env);//首先初始化全局变量 // output<<">>>>>>>>>>>>>>>>>>>>>>>>>/数据区<<<<<<<<<<<<<<<<<<<"<<endl<<endl; IloInvert(env,B0,B0l,Node-1);//求逆矩阵 //在此创建两种形式的目标函数 IloNumExpr Cost(env);//目标函数 for(IloInt w=0;w<NW;++w) { Cost+=detaPw[w]; } IloObjective min(env,Cost,IloObjective::Sense::Minimize,"min"); IloObjective max(env,Cost,IloObjective::Sense::Maximize,"max"); Master_Model.add(min); // Master_Model.add(IloMaximize(env,Cost));//目标函数二选一 Cost.end(); IloNumExpr expr1(env),expr2(env);//功率平衡约束 for(IloInt i=0;i<NG;++i) { expr1+=detaP[i]; } for(IloInt w=0;w<NW;++w) { expr2+=detaPw[w]; } Master_Model.add(expr1+expr2==0); expr1.end(); expr2.end(); for(IloInt i=0;i<NG;++i)//机组可调节范围 { Master_Model.add(detaP[i]>=Unit[i][1]*u[i]-P1[i]); Master_Model.add(detaP[i]<=Unit[i][2]*u[i]-P1[i]); Master_Model.add(detaP[i]>=-detaa[i]); Master_Model.add(detaP[i]<=detaa[i]); } IloNumExprArray detaP_node(env,Node-1),detaPw_node(env,Node-1);//安全约束,实际上安全约束影响不大 IloNumExprArray Theta(env,Node); for(IloInt b=0;b<Node-1;++b) { detaP_node[b]=IloNumExpr(env); detaPw_node[b]=IloNumExpr(env); IloInt i=0; for(;i<NG;++i) { if(Unit[i][0]==b-1)break; } if(i<NG) { detaP_node[b]+=detaP[i]; } if(Sw[b]>=0) { detaPw_node[b]+=detaPw[ Sw[b] ]; } } for(IloInt b=0;b<Node-1;++b) { Theta[b]=IloNumExpr(env); for(IloInt k=0;k<Node-1;++k) { Theta[b]+=B0l[b][k]*(detaP_node[k]+detaPw_node[k]); } } Theta[Node-1]=IloNumExpr(env); for(IloInt h=0;h<Branch;++h) { IloNumExpr exprTheta(env);//莫明其妙的错误 exprTheta+=(Theta[(IloInt)Info_Branch[h][0]-1]-Theta[(IloInt)Info_Branch[h][1]-1]); Master_Model.add(exprTheta<=Info_Branch[h][3]*(Info_Branch[h][4]-PL[h])); Master_Model.add(exprTheta>=Info_Branch[h][3]*(-Info_Branch[h][4]-PL[h])); exprTheta.end(); //两个相减的节点顺序没有影响么? } Theta.end(); detaP_node.end(); detaPw_node.end(); Master_Cplex.extract(Master_Model); Master_Cplex.solve(); if (Master_Cplex.getStatus() == IloAlgorithm::Infeasible)//输出结果 { output<<"Master Problem Have No Solution"<<endl; goto lable2; } /************************************************************输出显示过程**************************************************/ // output/*<<endl<<"Min:"*/<<Master_Cplex.getObjValue()<<endl; Master_Model.remove(min); Master_Model.add(max); Master_Cplex.extract(Master_Model); Master_Cplex.solve(); if (Master_Cplex.getStatus() == IloAlgorithm::Infeasible)//输出结果 { output<<"Master Problem Have No Solution"<<endl; goto lable2; } output/*<<endl<<"Max:"*/<<Master_Cplex.getObjValue()<<endl<<endl;; // output<<endl<<"常规机组出力调整量:"<<endl; // for(IloInt i=0;i<NG;++i) // { // output<<Master_Cplex.getValue(detaP[i])<<" "; // } // output<<endl<<"风电机组出力调整量:"<<endl; // for(IloInt i=0;i<NW;++i) // { // output<<Master_Cplex.getValue(detaPw[i])<<" "; // } // output<<endl; lable2: Master_Model.end(); Master_Cplex.end(); env.end(); } catch(IloException& ex)//异常捕获 { output<<"Error: "<<ex<<endl; } catch(...) { output<<"Error: Unknown exception caught!" << endl; } finish=clock(); totaltime=(double)(finish-start)/CLOCKS_PER_SEC; output<<"totaltime: "<<totaltime<<"s"<<endl<<endl; output.close(); return 0; }