C++ (Cpp) CGraphPtrの例

コード例 #1

ファイル: PolynomialFunction.cpp プロジェクト: ashutoshmahajan/minotaur

PolynomialFunction::PolynomialFunction(CGraphPtr cg)
 : cb_(0),
   cg_(cg), // NULL
   eTol_(1e-10),
   terms_(0)
{
  if (cg->getOut()) {
    recCG_(cg->getOut(), &cb_, &terms_);
  }
}

コード例 #2

ファイル: YEqCGs.cpp プロジェクト: ashutoshmahajan/minotaur

VariablePtr YEqCGs::findY(CGraphPtr cg)
{
  double hash = evalHash_(cg->getOut(), 1);
  for (UInt i=0; i<y_.size(); ++i) {
    if (fabs(hash-hash_[i])<1e-10 &&
        cg->isIdenticalTo(cg_[i])) {
      return y_[i];
    }
  }
  return VariablePtr();
}

コード例 #3

ファイル: YEqUCGs.cpp プロジェクト: ashutoshmahajan/minotaur

void YEqUCGs::insert(VariablePtr auxvar, CGraphPtr cg)
{
  VariablePtr x;

  assert(auxvar && cg);

  x = *(cg->varsBegin());
  op_.push_back(cg->getOut()->getOp());
  hash_.push_back(evalHash_(cg->getOut(), 1));
  y_.push_back(auxvar);
  x_.push_back(x);
  cg_.push_back(cg);
}

コード例 #4

ファイル: YEqUCGs.cpp プロジェクト: ashutoshmahajan/minotaur

VariablePtr YEqUCGs::findY(CGraphPtr cg)
{
  double hash = evalHash_(cg->getOut(), 1);
  OpCode op = cg->getOut()->getOp();
  VariablePtr x = *(cg->varsBegin());
  for (UInt i=0; i<y_.size(); ++i) {
    if (fabs(hash-hash_[i])<1e-10
        && op == op_[i]
        && x == x_[i]
        && cg->isIdenticalTo(cg_[i])) {
      return y_[i];
    }
  }
  return VariablePtr();
}

コード例 #5

ファイル: YEqCGs.cpp プロジェクト: ashutoshmahajan/minotaur

void YEqCGs::insert(VariablePtr auxvar, CGraphPtr cg)
{
  assert(auxvar && cg);
  hash_.push_back(evalHash_(cg->getOut(), 1));
  y_.push_back(auxvar);
  cg_.push_back(cg);
}

コード例 #6

ファイル: Transformer.cpp プロジェクト: devanandR/minotaur

VariablePtr Transformer::newVar_(CGraphPtr cg, ProblemPtr newp)
{
  VariablePtr iv;
  VariablePtr ov = VariablePtr(); // NULL
  FunctionPtr f;
  LinearFunctionPtr lf;
  ConstraintPtr cnew;
  assert(cg);

  if (OpSumList!=cg->getOut()->getOp()) {
    ov = yUniExprs_->findY(cg);
  } 

  if (!ov) {
    ov = newp->newVariable(VarTran);
    lf = (LinearFunctionPtr) new LinearFunction();
    lf->addTerm(ov, -1.0);
    f = (FunctionPtr) new Function(lf, cg);
    cnew = newp->newConstraint(f, 0.0, 0.0);
#if SPEW
      logger_->msgStream(LogDebug) << me_ << "added new constraint "
                                   << std::endl;
      cnew->write(logger_->msgStream(LogDebug));
#endif 
    assignHandler_(cg, cnew);

    yUniExprs_->insert(ov, cg);
  }
  return ov;
}

コード例 #7

ファイル: Transformer.cpp プロジェクト: devanandR/minotaur

void Transformer::assignHandler_(CGraphPtr cg, ConstraintPtr c)
{
  switch (cg->getOut()->getOp()) {
  case OpMult:
  case OpSqr:
    qHandler_->addConstraint(c);
    break;
  default:
    {
    VariablePtr iv;
    VariablePtr ov = VariablePtr();
    LinearFunctionPtr lf = c->getFunction()->getLinearFunction();
    if (lf) {
      assert(lf->getNumTerms()==1);
      ov = lf->termsBegin()->first;
    }
    iv = *(c->getFunction()->getNonlinearFunction()->varsBegin());
    uHandler_->addConstraint(c, iv, ov, 'E');
    }
  }
}

コード例 #8

ファイル: CoverCutTest.cpp プロジェクト: devanandR/minotaur

Bool logobj(LinearFunctionPtr lf, CGraphPtr nlf)
{
  UInt numvars = lf->getNumTerms();
  // VariableSet vars;
  // lf->getVars(&vars);
  VariableGroup::const_iterator it;
  VariableGroup::const_iterator begin = lf->termsBegin();
  VariableGroup::const_iterator end   = lf->termsEnd();
  // Variable nodes.
  std::map<UInt,CNode*> varnodes;
  std::map<CNode*, CNode*> lognodes;
  std::map<UInt, CNode*> logidnodes;
  std::map<CNode*, CNode*> numnodes;
  std::map<UInt, CNode*> numidnodes;
  std::map<CNode*, CNode*> mulnodes;
  std::map<UInt, CNode*> mulidnodes;
  std::set<CNode*> multnodes;
  std::map<UInt, CNode*> multidnodes;
  CNode** multnodesvec = new CNode*[numvars];
  // Iterate through variables.
  CNode* tempnode;
  CNode* lognode;
  CNode* numnode;
  CNode* mulnode;
  CNode* onenode;
  CNode* sumnode;
  // Create numnode for one.
  UInt index = 0;
  for(it=begin; it!=end; ++it) {
    VariablePtr var = it->first;
    Double varlb = var->getLb();
    if (varlb >= 0) {
      UInt varid = var->getId();
      Double coeff = it->second;
      // Create variable node and add it to a set.
      tempnode = nlf->newNode(var);
      varnodes.insert(std::pair<UInt,CNode*>(varid,tempnode));
      onenode = nlf->newNode(1.0);
      // Create sumnode.      
      sumnode = nlf->newNode(OpPlus, onenode, tempnode);
      // Create log nodes.
      lognode = nlf->newNode(OpLog, &sumnode, 1);
      lognodes.insert(std::pair<CNode* , CNode*>(tempnode, lognode));
      logidnodes.insert(std::pair<UInt, CNode*>(varid, lognode));
      // Create num nodes.
      numnode = nlf->newNode(coeff);
      numnodes.insert(std::pair<CNode*, CNode*>(tempnode, numnode));
      numidnodes.insert(std::pair<UInt, CNode*>(varid, numnode));
      // Create mul nodes.
      mulnode = nlf->newNode(OpMult, numnode, lognode);
      multnodes.insert(mulnode);
      multidnodes.insert(std::pair<UInt, CNode*>(varid,mulnode));
      multnodesvec[index] = mulnode;
      index++;
    }
  }
  
  // This is the root node.
  CNode* sumlistnode = nlf->newNode(OpSumList, multnodesvec, index);  
  nlf->setOut(sumlistnode);
  nlf->finalize();
  
  return true;
}