Main Page | Namespace List | Class Hierarchy | Compound List | File List | Namespace Members | Compound Members | File Members

parquetfp::SPeval Class Reference

#include <SPeval.h>

Collaboration diagram for parquetfp::SPeval:

Collaboration graph
[legend]
List of all members.

Public Member Functions

 SPeval (const vector< double > &heights, const vector< double > &widths, bool paramUseFastSP)
void evaluate (const vector< unsigned > &X, const vector< unsigned > &Y)
double xEval ()
double yEval ()
void evalSlacks (const vector< unsigned > &X, const vector< unsigned > &Y)
double xEvalRev ()
double yEvalRev ()
void evaluateCompact (const vector< unsigned > &X, const vector< unsigned > &Y, bool whichDir)
double xEvalCompact ()
double yEvalCompact ()
void computeConstraintGraphs ()
void removeRedundantConstraints (bool knownDir)
void computeSPFromCG ()
void evaluateFast (const vector< unsigned > &X, const vector< unsigned > &Y)
double xEvalFast ()
double yEvalFast ()
void evalSlacksFast (const vector< unsigned > &X, const vector< unsigned > &Y)
double xEvalRevFast ()
double yEvalRevFast ()
void changeWidths (const vector< double > &widths)
void changeHeights (const vector< double > &heights)
void changeNodeWidth (const unsigned index, double width)
void changeNodeHeight (const unsigned index, double height)
void changeOrient (unsigned index)

Public Attributes

vector< double > xloc
vector< double > yloc
double xSize
double ySize
vector< double > xSlacks
vector< double > ySlacks
vector< double > xlocRev
vector< double > ylocRev

Private Member Functions

double _lcsCompute (const vector< unsigned > &X, const vector< unsigned > &Y, const vector< double > &weights, vector< unsigned > &match, vector< double > &P, vector< double > &L)
double _lcsReverseCompute (const vector< unsigned > &X, const vector< unsigned > &Y, const vector< double > &weights, vector< unsigned > &match, vector< double > &P, vector< double > &L)
double _lcsComputeCompact (const vector< unsigned > &X, const vector< unsigned > &Y, const vector< double > &weights, vector< unsigned > &match, vector< double > &P, vector< double > &L, vector< double > &oppLocs, vector< double > &oppWeights)
double _findBST (unsigned index)
void _discardNodesBST (unsigned index, double length)
double _lcsComputeFast (const vector< unsigned > &X, const vector< unsigned > &Y, const vector< double > &weights, vector< unsigned > &match, vector< double > &P, vector< double > &L)
void _initializeTCGMatrix (unsigned size)

Private Attributes

vector< unsigned > _match
vector< double > _LL
vector< unsigned > _reverseSeq
vector< unsigned > _XX
vector< unsigned > _YY
vector< double > _heights
vector< double > _widths
map< unsigned, double > _BST
vector< unsigned > _reverseSeq2
vector< vector< bool > > _TCGMatrixHoriz
vector< vector< bool > > _TCGMatrixVert
bool _TCGMatrixInitialized
bool _paramUseFastSP

Constructor & Destructor Documentation

SPeval::SPeval (  const vector< double > &  heights,
const vector< double > &  widths,
bool  paramUseFastSP
) 
 

Definition at line 51 of file SPeval.cxx.

References _heights, _LL, _match, _paramUseFastSP, _reverseSeq, _reverseSeq2, _TCGMatrixInitialized, _widths, _XX, _YY, xloc, xlocRev, xSlacks, yloc, ylocRev, and ySlacks. 

00054 {
00055    _heights=heights;
00056    _widths=widths;
00057   
00058    unsigned size = heights.size();
00059    _match.resize(size);
00060    _LL.resize(size);
00061    _reverseSeq.resize(size);
00062    _XX.resize(size);
00063    _YY.resize(size);
00064    xloc.resize(size);
00065    yloc.resize(size);
00066    xSlacks.resize(size);
00067    ySlacks.resize(size);
00068    xlocRev.resize(size);
00069    ylocRev.resize(size);
00070    _reverseSeq2.resize(size);
00071    _TCGMatrixInitialized = false;
00072    _paramUseFastSP=paramUseFastSP;
00073 }

Member Function Documentation

void SPeval::_discardNodesBST (  unsigned  index,
double  length
)  [private]
 

Definition at line 463 of file SPeval.cxx.

References _BST.

Referenced by _lcsComputeFast(). 

00464 {
00465    map<unsigned , double>::iterator iter;
00466    map<unsigned , double>::iterator nextIter;
00467    map<unsigned , double>::iterator endIter;
00468    endIter = _BST.end();
00469    iter = _BST.find(index);
00470    nextIter = iter;
00471    ++nextIter;
00472    if(nextIter != _BST.end())
00473    {
00474       ++iter;
00475       while(true)
00476       {
00477          ++nextIter;
00478          if((*iter).second < length)
00479             _BST.erase(iter);
00480          if(nextIter == endIter)
00481             break;
00482          iter = nextIter;
00483       }
00484    }
00485 }

double SPeval::_findBST (  unsigned  index  )  [private]
 

Definition at line 487 of file SPeval.cxx.

References _BST.

Referenced by _lcsComputeFast(). 

00488 {
00489    map<unsigned , double>::iterator iter;  
00490    double loc;
00491    iter = _BST.lower_bound(index);
00492    if(iter != _BST.begin())
00493    {
00494       iter--;
00495       loc = (*iter).second;
00496    }
00497    else
00498       loc = 0;
00499    return loc;
00500 }

void SPeval::_initializeTCGMatrix (  unsigned  size  )  [private]
 

Definition at line 75 of file SPeval.cxx.

References _TCGMatrixHoriz, _TCGMatrixInitialized, and _TCGMatrixVert.

Referenced by computeConstraintGraphs(). 

00076 {
00077    _TCGMatrixVert.resize(size);
00078    _TCGMatrixHoriz.resize(size);
00079    for(unsigned i=0; i<size; ++i)
00080    {
00081       _TCGMatrixVert[i].resize(size);
00082       _TCGMatrixHoriz[i].resize(size);
00083    }
00084    _TCGMatrixInitialized = true;
00085 }

double SPeval::_lcsCompute (  const vector< unsigned > &  X,
const vector< unsigned > &  Y,
const vector< double > &  weights,
vector< unsigned > &  match,
vector< double > &  P,
vector< double > &  L
)  [private]
 

Definition at line 87 of file SPeval.cxx.

Referenced by xEval(), and yEval(). 

00093 {
00094    unsigned size = X.size();
00095    for(unsigned i=0;i<size;++i)
00096    {
00097       match[Y[i]]=i;
00098       L[i]=0;
00099    }
00100   
00101    double t;
00102    unsigned j;
00103    for(unsigned i=0;i<size;++i)
00104    {
00105       unsigned p = match[X[i]];
00106       P[X[i]]=L[p];
00107       t = P[X[i]]+weights[X[i]];
00108       
00109       for(j=p;j<size;++j)
00110       {
00111          if(t>L[j])
00112             L[j]=t;
00113          else
00114             break;
00115       }
00116    }
00117    return L[size-1];
00118 }

double SPeval::_lcsComputeCompact (  const vector< unsigned > &  X,
const vector< unsigned > &  Y,
const vector< double > &  weights,
vector< unsigned > &  match,
vector< double > &  P,
vector< double > &  L,
vector< double > &  oppLocs,
vector< double > &  oppWeights
)  [private]
 

Definition at line 184 of file SPeval.cxx.

Referenced by xEvalCompact(), and yEvalCompact(). 

00193 {
00194    double finalSize = -1e100;
00195    unsigned size = X.size();
00196    for(unsigned i=0;i<size;++i)
00197    {
00198       match[Y[i]]=i;
00199       L[i]=0;
00200    }
00201   
00202    double t;
00203    unsigned j;
00204    for(unsigned i=0;i<size;++i)
00205    {
00206       unsigned p = match[X[i]];
00207       P[X[i]]=L[p];
00208       t = P[X[i]]+weights[X[i]];
00209       
00210       double iStart = oppLocs[X[i]];
00211       double iEnd = oppLocs[X[i]] + oppWeights[X[i]];
00212 
00213       for(j=p;j<size;++j)
00214       {
00215          double jStart = oppLocs[Y[j]];
00216          double jEnd = oppLocs[Y[j]] + oppWeights[Y[j]];
00217           
00218          if(iStart >= jEnd || iEnd <= jStart) //no constraint
00219             continue;
00220           
00221          if(t>L[j])
00222          {
00223             L[j]=t;
00224             if(t > finalSize)
00225                finalSize = t;
00226          }
00227       }
00228    }
00229    return finalSize;
00230 }

double SPeval::_lcsComputeFast (  const vector< unsigned > &  X,
const vector< unsigned > &  Y,
const vector< double > &  weights,
vector< unsigned > &  match,
vector< double > &  P,
vector< double > &  L
)  [private]
 

Definition at line 502 of file SPeval.cxx.

References _BST, _discardNodesBST(), and _findBST().

Referenced by xEvalFast(), xEvalRevFast(), yEvalFast(), and yEvalRevFast(). 

00509 {
00510    _BST.clear();
00511    _BST[0] = 0;
00512    unsigned size = X.size();
00513    for(unsigned i=0;i<size;++i)
00514    {
00515       match[Y[i]]=i;
00516    }
00517   
00518    double t;
00519 //unsigned j;
00520    for(unsigned i=0;i<size;++i)
00521    {
00522       unsigned p = match[X[i]];
00523       P[X[i]]=_findBST(p);
00524       t = P[X[i]]+weights[X[i]];
00525       _BST[p] = t;
00526       _discardNodesBST(p,t);
00527    }
00528    double length = _findBST(size);
00529    return length;
00530 }

Here is the call graph for this function:

double SPeval::_lcsReverseCompute (  const vector< unsigned > &  X,
const vector< unsigned > &  Y,
const vector< double > &  weights,
vector< unsigned > &  match,
vector< double > &  P,
vector< double > &  L
)  [private]
 

Definition at line 390 of file SPeval.cxx.

Referenced by xEvalRev(), and yEvalRev(). 

00397 {
00398    unsigned size = X.size();
00399    for(unsigned i=0;i<size;++i)
00400    {
00401       match[Y[i]]=i;
00402       L[i]=0;
00403    }
00404   
00405    double t;
00406    int j;
00407    for(int i=size-1;i>=0;--i)
00408    {
00409       unsigned p = match[X[i]];
00410       P[X[i]]=L[p];
00411       t = P[X[i]]+weights[X[i]];
00412       
00413       for(j=p;j>=0;--j)
00414       {
00415          if(t>L[j])
00416             L[j]=t;
00417          else
00418             break;
00419       }
00420    }
00421    return L[0];
00422 }

void SPeval::changeHeights (  const vector< double > &  heights  ) 
 

Definition at line 367 of file SPeval.cxx.

References _heights.

Referenced by parquetfp::Annealer::takeSPfromDB(). 

00368 {
00369    _heights = heights;
00370 }

void SPeval::changeNodeHeight (  const unsigned  index,
double  height
) 
 

Definition at line 377 of file SPeval.cxx.

References _heights.

Referenced by parquetfp::Annealer::anneal(), and parquetfp::Annealer::packSoftBlocks(). 

00378 {
00379    _heights[index] = height;
00380 }

void SPeval::changeNodeWidth (  const unsigned  index,
double  width
) 
 

Definition at line 372 of file SPeval.cxx.

References _widths.

Referenced by parquetfp::Annealer::anneal(), and parquetfp::Annealer::packSoftBlocks(). 

00373 {
00374    _widths[index] = width;
00375 }

void SPeval::changeOrient (  unsigned  index  ) 
 

Definition at line 382 of file SPeval.cxx.

References _heights, and _widths.

Referenced by parquetfp::Annealer::anneal(). 

00383 {
00384    double tempWidth = _heights[index];
00385    _heights[index] = _widths[index];
00386    _widths[index] = tempWidth;
00387 }

void SPeval::changeWidths (  const vector< double > &  widths  ) 
 

Definition at line 362 of file SPeval.cxx.

References _widths.

Referenced by parquetfp::Annealer::takeSPfromDB(). 

00363 {
00364    _widths = widths;
00365 }

void SPeval::computeConstraintGraphs (   ) 
 

Definition at line 232 of file SPeval.cxx.

References _initializeTCGMatrix(), _TCGMatrixHoriz, _TCGMatrixInitialized, _TCGMatrixVert, _XX, and _YY. 

00233 {
00234    unsigned size = _XX.size();
00235    if(!_TCGMatrixInitialized)
00236       _initializeTCGMatrix(size);
00237 
00238    vector<unsigned> matchX;
00239    vector<unsigned> matchY;
00240    matchX.resize(size);
00241    matchY.resize(size);
00242 
00243    for(unsigned i=0;i<size;++i)
00244    {
00245       matchX[_XX[i]]=i;
00246       matchY[_YY[i]]=i;
00247    }
00248 
00249    for(unsigned i=0;i<size;++i)
00250    {
00251       for(unsigned j=0; j<size; ++j)
00252       {
00253          if(i==j)
00254          {
00255             _TCGMatrixHoriz[i][j] = 1;
00256             _TCGMatrixVert[i][j] = 1;
00257             continue;
00258          }
00259 
00260          _TCGMatrixHoriz[i][j] = 0;
00261          _TCGMatrixVert[i][j] = 0;
00262          _TCGMatrixHoriz[j][i] = 0;
00263          _TCGMatrixVert[j][i] = 0;
00264 
00265           
00266          if(matchX[i] < matchX[j] && matchY[i] < matchY[j])
00267             _TCGMatrixHoriz[i][j] = 1;
00268          else if(matchX[i] > matchX[j] && matchY[i] > matchY[j])
00269             _TCGMatrixHoriz[j][i] = 1;
00270          else if(matchX[i] < matchX[j] && matchY[i] > matchY[j])
00271             _TCGMatrixVert[j][i] = 1;
00272          else if(matchX[i] > matchX[j] && matchY[i] < matchY[j])
00273             _TCGMatrixVert[i][j] = 1;
00274          else
00275             cout<<"ERROR: in computeConstraintGraph \n";
00276       }
00277    }
00278 }

Here is the call graph for this function:

void SPeval::computeSPFromCG (   ) 
 

Definition at line 346 of file SPeval.cxx.

References _TCGMatrixHoriz, _TCGMatrixVert, _XX, and _YY. 

00347 {
00348    unsigned size = _XX.size();
00349    for(unsigned i=0; i<size; ++i)
00350    {
00351       _XX[i] = i;
00352       _YY[i] = i;
00353    }
00354   
00355    SPXRelation SPX(_TCGMatrixHoriz, _TCGMatrixVert);
00356    SPYRelation SPY(_TCGMatrixHoriz, _TCGMatrixVert);
00357 
00358    std::sort(_XX.begin(), _XX.end(), SPX);
00359    std::sort(_YY.begin(), _YY.end(), SPY);
00360 }

void SPeval::evalSlacks (  const vector< unsigned > &  X,
const vector< unsigned > &  Y
) 
 

Definition at line 439 of file SPeval.cxx.

References _heights, _paramUseFastSP, _widths, _XX, _YY, evalSlacksFast(), xEval(), xEvalRev(), xloc, xlocRev, xSize, xSlacks, yEval(), yEvalRev(), yloc, ylocRev, ySize, and ySlacks.

Referenced by parquetfp::Annealer::evalSlacks(), parquetfp::Annealer::go(), parquetfp::Annealer::makeARMove(), parquetfp::Annealer::makeARWLMove(), parquetfp::Annealer::makeIndexSoftBlMove(), parquetfp::Annealer::makeMoveSlacks(), parquetfp::Annealer::makeMoveSlacksOrient(), parquetfp::Annealer::makeSoftBlMove(), and parquetfp::Annealer::packSoftBlocks(). 

00441 {
00442    if(_paramUseFastSP)
00443    {
00444       evalSlacksFast(X, Y);
00445       return;
00446    }
00447    _XX = X;
00448    _YY = Y;
00449    xSize = xEval();
00450    ySize = yEval();
00451    xEvalRev();
00452    yEvalRev();
00453 
00454    for(unsigned i=0; i<_XX.size(); ++i)
00455    {
00456       xlocRev[i] = xSize - xlocRev[i] - _widths[i];
00457       ylocRev[i] = ySize - ylocRev[i] - _heights[i];
00458       xSlacks[i] = (xlocRev[i] - xloc[i])*100/xSize;
00459       ySlacks[i] = (ylocRev[i] - yloc[i])*100/ySize;
00460    }
00461 }

Here is the call graph for this function:

void SPeval::evalSlacksFast (  const vector< unsigned > &  X,
const vector< unsigned > &  Y
) 
 

Definition at line 575 of file SPeval.cxx.

References _heights, _widths, _XX, _YY, xEvalFast(), xEvalRevFast(), xloc, xlocRev, xSize, xSlacks, yEvalFast(), yEvalRevFast(), yloc, ylocRev, ySize, and ySlacks.

Referenced by evalSlacks(). 

00577 {
00578    _XX = X;
00579    _YY = Y;
00580    xSize = xEvalFast();
00581    ySize = yEvalFast();
00582    xEvalRevFast();
00583    yEvalRevFast();
00584 
00585    for(unsigned i=0; i<_XX.size(); ++i)
00586    {
00587       xlocRev[i] = xSize - xlocRev[i] - _widths[i];
00588       ylocRev[i] = ySize - ylocRev[i] - _heights[i];
00589       xSlacks[i] = (xlocRev[i] - xloc[i])*100/xSize;
00590       ySlacks[i] = (ylocRev[i] - yloc[i])*100/ySize;
00591    }
00592 }

Here is the call graph for this function:

void SPeval::evaluate (  const vector< unsigned > &  X,
const vector< unsigned > &  Y
) 
 

Definition at line 135 of file SPeval.cxx.

References _paramUseFastSP, _XX, _YY, evaluateFast(), xEval(), xSize, yEval(), and ySize.

Referenced by parquetfp::Annealer::anneal(), parquetfp::Annealer::eval(), parquetfp::Annealer::go(), parquetfp::Annealer::makeARWLMove(), parquetfp::Annealer::makeHPWLMove(), and parquetfp::Annealer::packSoftBlocks(). 

00137 {
00138    if(_paramUseFastSP)
00139    {
00140       evaluateFast(X, Y);
00141       return;
00142    }
00143   
00144    _XX = X;
00145    _YY = Y;
00146    xSize = xEval();
00147    ySize = yEval();
00148 }

Here is the call graph for this function:

void SPeval::evaluateCompact (  const vector< unsigned > &  X,
const vector< unsigned > &  Y,
bool  whichDir
) 
 

Definition at line 150 of file SPeval.cxx.

References _XX, _YY, xEval(), xEvalCompact(), xSize, yEval(), yEvalCompact(), and ySize.

Referenced by parquetfp::Annealer::evalCompact(). 

00153 {
00154    _XX = X;
00155    _YY = Y;
00156    if(whichDir == 0)  //evaluate yloc first and then compact
00157    {
00158       ySize = yEval();
00159       xSize = xEvalCompact();
00160    }
00161    else               //evaluate xloc first and then compact
00162    {
00163       xSize = xEval();
00164       ySize = yEvalCompact();
00165    }
00166 }

Here is the call graph for this function:

void SPeval::evaluateFast (  const vector< unsigned > &  X,
const vector< unsigned > &  Y
) 
 

Definition at line 547 of file SPeval.cxx.

References _XX, _YY, xEvalFast(), xSize, yEvalFast(), and ySize.

Referenced by evaluate(). 

00549 {
00550    _XX = X;
00551    _YY = Y;
00552    xSize = xEvalFast();
00553    ySize = yEvalFast();
00554 }

Here is the call graph for this function:

void SPeval::removeRedundantConstraints (  bool  knownDir  ) 
 

Definition at line 280 of file SPeval.cxx.

References _heights, _TCGMatrixHoriz, _TCGMatrixVert, _widths, _XX, xloc, and yloc. 

00281 {
00282    unsigned size = _XX.size();
00283    double iStart, iEnd, jStart, jEnd;
00284    for(unsigned i=0; i<size; ++i)
00285    {
00286       if(knownDir == 0) //horizontal
00287       {
00288          iStart = xloc[i];
00289          iEnd = iStart+_widths[i];
00290       }
00291       else  //vertical
00292       {
00293          iStart = yloc[i];
00294          iEnd = iStart+_heights[i];
00295       }
00296       for(unsigned j=0; j<size; ++j)
00297       {
00298          if(i == j)
00299             continue;
00300 
00301          if(knownDir == 0)
00302          {
00303             jStart = xloc[j];
00304             jEnd = jStart+_widths[j];
00305          }
00306          else
00307          {
00308             jStart = yloc[j];
00309             jEnd = jStart+_heights[j];
00310          }
00311           
00312          if(knownDir == 0)
00313          {
00314             if(_TCGMatrixVert[i][j] == 1)
00315             {
00316                if(iStart >= jEnd || iEnd <= jStart) //no constraint
00317                {
00318                   _TCGMatrixVert[i][j] = 0;
00319                   if(iStart < jStart)
00320                      _TCGMatrixHoriz[i][j] = 1;
00321                   else
00322                      _TCGMatrixHoriz[j][i] = 1;
00323                }
00324             }
00325          }
00326          else
00327          {
00328             if(_TCGMatrixHoriz[i][j] == 1)
00329             {
00330                if(iStart >= jEnd || iEnd <= jStart) //no constraint
00331                {
00332                   cout<<i<<"\t"<<j<<"\t"<<iStart<<"\t"<<iEnd<<"\t"<<
00333                      jStart<<"\t"<<jEnd<<endl;
00334                   _TCGMatrixHoriz[i][j] = 0;
00335                   if(iStart < jStart)
00336                      _TCGMatrixVert[i][j] = 1;
00337                   else
00338                      _TCGMatrixVert[j][i] = 1;
00339                }
00340             }
00341          }
00342       }
00343    }
00344 }

double SPeval::xEval (   ) 
 

Definition at line 121 of file SPeval.cxx.

References _lcsCompute(), _LL, _match, _widths, _XX, _YY, and xloc.

Referenced by evalSlacks(), evaluate(), and evaluateCompact(). 

00122 {
00123    fill(_match.begin(),_match.end(),0);
00124    return _lcsCompute( _XX, _YY, _widths, _match, xloc, _LL);
00125 }

Here is the call graph for this function:

double SPeval::xEvalCompact (   ) 
 

Definition at line 168 of file SPeval.cxx.

References _heights, _lcsComputeCompact(), _LL, _match, _widths, _XX, _YY, xloc, and yloc.

Referenced by evaluateCompact(). 

00169 {
00170    fill(_match.begin(),_match.end(),0);
00171    return _lcsComputeCompact( _XX, _YY, _widths, _match, xloc, _LL, yloc, 
00172                               _heights);
00173 }

Here is the call graph for this function:

double SPeval::xEvalFast (   ) 
 

Definition at line 533 of file SPeval.cxx.

References _lcsComputeFast(), _LL, _match, _widths, _XX, _YY, and xloc.

Referenced by evalSlacksFast(), and evaluateFast(). 

00534 {
00535    fill(_match.begin(),_match.end(),0);
00536    return _lcsComputeFast( _XX, _YY, _widths, _match, xloc, _LL);
00537 }

Here is the call graph for this function:

double SPeval::xEvalRev (   ) 
 

Definition at line 425 of file SPeval.cxx.

References _lcsReverseCompute(), _LL, _match, _widths, _XX, _YY, and xlocRev.

Referenced by evalSlacks(). 

00426 {
00427    fill(_match.begin(),_match.end(),0);
00428    return _lcsReverseCompute( _XX, _YY, _widths, _match, xlocRev, _LL);
00429 }

Here is the call graph for this function:

double SPeval::xEvalRevFast (   ) 
 

Definition at line 556 of file SPeval.cxx.

References _lcsComputeFast(), _LL, _match, _reverseSeq, _reverseSeq2, _widths, _XX, _YY, and xlocRev.

Referenced by evalSlacksFast(). 

00557 {
00558    fill(_match.begin(),_match.end(),0);
00559    _reverseSeq = _XX;
00560    reverse(_reverseSeq.begin(),_reverseSeq.end());
00561    _reverseSeq2 = _YY;
00562    reverse(_reverseSeq2.begin(),_reverseSeq2.end());
00563    return _lcsComputeFast( _reverseSeq, _reverseSeq2, _widths, _match, xlocRev,
00564                            _LL);
00565 }

Here is the call graph for this function:

double SPeval::yEval (   ) 
 

Definition at line 127 of file SPeval.cxx.

References _heights, _lcsCompute(), _LL, _match, _reverseSeq, _XX, _YY, and yloc.

Referenced by evalSlacks(), evaluate(), and evaluateCompact(). 

00128 {
00129    _reverseSeq = _XX;
00130    reverse(_reverseSeq.begin(),_reverseSeq.end());
00131    fill(_match.begin(),_match.end(),0);
00132    return _lcsCompute( _reverseSeq, _YY, _heights, _match, yloc, _LL);
00133 }

Here is the call graph for this function:

double SPeval::yEvalCompact (   ) 
 

Definition at line 175 of file SPeval.cxx.

References _heights, _lcsComputeCompact(), _LL, _match, _reverseSeq, _widths, _XX, _YY, xloc, and yloc.

Referenced by evaluateCompact(). 

00176 {
00177    _reverseSeq = _XX;
00178    reverse(_reverseSeq.begin(),_reverseSeq.end());
00179    fill(_match.begin(),_match.end(),0);
00180    return _lcsComputeCompact( _reverseSeq, _YY, _heights, _match, yloc, _LL, 
00181                               xloc, _widths);
00182 }

Here is the call graph for this function:

double SPeval::yEvalFast (   ) 
 

Definition at line 539 of file SPeval.cxx.

References _heights, _lcsComputeFast(), _LL, _match, _reverseSeq, _XX, _YY, and yloc.

Referenced by evalSlacksFast(), and evaluateFast(). 

00540 {
00541    _reverseSeq = _XX;
00542    reverse(_reverseSeq.begin(),_reverseSeq.end());
00543    fill(_match.begin(),_match.end(),0);
00544    return _lcsComputeFast( _reverseSeq, _YY, _heights, _match, yloc, _LL);
00545 }

Here is the call graph for this function:

double SPeval::yEvalRev (   ) 
 

Definition at line 431 of file SPeval.cxx.

References _heights, _lcsReverseCompute(), _LL, _match, _reverseSeq, _XX, _YY, and ylocRev.

Referenced by evalSlacks(). 

00432 {
00433    _reverseSeq = _XX;
00434    reverse(_reverseSeq.begin(),_reverseSeq.end());
00435    fill(_match.begin(),_match.end(),0);
00436    return _lcsReverseCompute( _reverseSeq, _YY, _heights, _match, ylocRev, _LL);
00437 }

Here is the call graph for this function:

double SPeval::yEvalRevFast (   ) 
 

Definition at line 567 of file SPeval.cxx.

References _heights, _lcsComputeFast(), _LL, _match, _reverseSeq2, _XX, _YY, and ylocRev.

Referenced by evalSlacksFast(). 

00568 {
00569    _reverseSeq2 = _YY;
00570    reverse(_reverseSeq2.begin(),_reverseSeq2.end());
00571    fill(_match.begin(),_match.end(),0);
00572    return _lcsComputeFast( _XX, _reverseSeq2, _heights, _match, ylocRev, _LL);
00573 }

Here is the call graph for this function:

Member Data Documentation

map<unsigned , double> parquetfp::SPeval::_BST [private]
 

Definition at line 62 of file SPeval.h.

Referenced by _discardNodesBST(), _findBST(), and _lcsComputeFast().

vector<double> parquetfp::SPeval::_heights [private]
 

Definition at line 60 of file SPeval.h.

Referenced by changeHeights(), changeNodeHeight(), changeOrient(), evalSlacks(), evalSlacksFast(), removeRedundantConstraints(), SPeval(), xEvalCompact(), yEval(), yEvalCompact(), yEvalFast(), yEvalRev(), and yEvalRevFast().

vector<double> parquetfp::SPeval::_LL [private]
 

Definition at line 56 of file SPeval.h.

Referenced by SPeval(), xEval(), xEvalCompact(), xEvalFast(), xEvalRev(), xEvalRevFast(), yEval(), yEvalCompact(), yEvalFast(), yEvalRev(), and yEvalRevFast().

vector<unsigned> parquetfp::SPeval::_match [private]
 

Definition at line 55 of file SPeval.h.

Referenced by SPeval(), xEval(), xEvalCompact(), xEvalFast(), xEvalRev(), xEvalRevFast(), yEval(), yEvalCompact(), yEvalFast(), yEvalRev(), and yEvalRevFast().

bool parquetfp::SPeval::_paramUseFastSP [private]
 

Definition at line 109 of file SPeval.h.

Referenced by evalSlacks(), evaluate(), and SPeval().

vector<unsigned> parquetfp::SPeval::_reverseSeq [private]
 

Definition at line 57 of file SPeval.h.

Referenced by SPeval(), xEvalRevFast(), yEval(), yEvalCompact(), yEvalFast(), and yEvalRev().

vector<unsigned> parquetfp::SPeval::_reverseSeq2 [private]
 

Definition at line 63 of file SPeval.h.

Referenced by SPeval(), xEvalRevFast(), and yEvalRevFast().

vector< vector<bool> > parquetfp::SPeval::_TCGMatrixHoriz [private]
 

Definition at line 65 of file SPeval.h.

Referenced by _initializeTCGMatrix(), computeConstraintGraphs(), computeSPFromCG(), and removeRedundantConstraints().

bool parquetfp::SPeval::_TCGMatrixInitialized [private]
 

Definition at line 107 of file SPeval.h.

Referenced by _initializeTCGMatrix(), computeConstraintGraphs(), and SPeval().

vector< vector<bool> > parquetfp::SPeval::_TCGMatrixVert [private]
 

Definition at line 66 of file SPeval.h.

Referenced by _initializeTCGMatrix(), computeConstraintGraphs(), computeSPFromCG(), and removeRedundantConstraints().

vector<double> parquetfp::SPeval::_widths [private]
 

Definition at line 61 of file SPeval.h.

Referenced by changeNodeWidth(), changeOrient(), changeWidths(), evalSlacks(), evalSlacksFast(), removeRedundantConstraints(), SPeval(), xEval(), xEvalCompact(), xEvalFast(), xEvalRev(), xEvalRevFast(), and yEvalCompact().

vector<unsigned> parquetfp::SPeval::_XX [private]
 

Definition at line 58 of file SPeval.h.

Referenced by computeConstraintGraphs(), computeSPFromCG(), evalSlacks(), evalSlacksFast(), evaluate(), evaluateCompact(), evaluateFast(), removeRedundantConstraints(), SPeval(), xEval(), xEvalCompact(), xEvalFast(), xEvalRev(), xEvalRevFast(), yEval(), yEvalCompact(), yEvalFast(), yEvalRev(), and yEvalRevFast().

vector<unsigned> parquetfp::SPeval::_YY [private]
 

Definition at line 59 of file SPeval.h.

Referenced by computeConstraintGraphs(), computeSPFromCG(), evalSlacks(), evalSlacksFast(), evaluate(), evaluateCompact(), evaluateFast(), SPeval(), xEval(), xEvalCompact(), xEvalFast(), xEvalRev(), xEvalRevFast(), yEval(), yEvalCompact(), yEvalFast(), yEvalRev(), and yEvalRevFast().

vector<double> parquetfp::SPeval::xloc
 

Definition at line 112 of file SPeval.h.

Referenced by parquetfp::Annealer::anneal(), parquetfp::Annealer::eval(), parquetfp::Annealer::evalCompact(), evalSlacks(), evalSlacksFast(), parquetfp::Annealer::go(), parquetfp::Annealer::makeARWLMove(), parquetfp::Annealer::makeHPWLMove(), removeRedundantConstraints(), SPeval(), parquetfp::Annealer::updatePlacement(), xEval(), xEvalCompact(), xEvalFast(), and yEvalCompact().

vector<double> parquetfp::SPeval::xlocRev
 

Definition at line 118 of file SPeval.h.

Referenced by evalSlacks(), evalSlacksFast(), SPeval(), xEvalRev(), and xEvalRevFast().

double parquetfp::SPeval::xSize
 

Definition at line 114 of file SPeval.h.

Referenced by parquetfp::Annealer::anneal(), evalSlacks(), evalSlacksFast(), evaluate(), evaluateCompact(), evaluateFast(), parquetfp::Annealer::getXSize(), parquetfp::Annealer::go(), parquetfp::Annealer::makeARWLMove(), parquetfp::Annealer::makeHPWLMove(), parquetfp::Annealer::makeIndexSoftBlMove(), parquetfp::Annealer::makeSoftBlMove(), and parquetfp::Annealer::packSoftBlocks().

vector<double> parquetfp::SPeval::xSlacks
 

Definition at line 116 of file SPeval.h.

Referenced by evalSlacks(), parquetfp::Annealer::evalSlacks(), evalSlacksFast(), parquetfp::Annealer::go(), parquetfp::Annealer::makeARWLMove(), parquetfp::Annealer::makeIndexSoftBlMove(), parquetfp::Annealer::makeSoftBlMove(), parquetfp::Annealer::sortSlacks(), and SPeval().

vector<double> parquetfp::SPeval::yloc
 

Definition at line 113 of file SPeval.h.

Referenced by parquetfp::Annealer::anneal(), parquetfp::Annealer::eval(), parquetfp::Annealer::evalCompact(), evalSlacks(), evalSlacksFast(), parquetfp::Annealer::go(), parquetfp::Annealer::makeARWLMove(), parquetfp::Annealer::makeHPWLMove(), removeRedundantConstraints(), SPeval(), parquetfp::Annealer::updatePlacement(), xEvalCompact(), yEval(), yEvalCompact(), and yEvalFast().

vector<double> parquetfp::SPeval::ylocRev
 

Definition at line 119 of file SPeval.h.

Referenced by evalSlacks(), evalSlacksFast(), SPeval(), yEvalRev(), and yEvalRevFast().

double parquetfp::SPeval::ySize
 

Definition at line 115 of file SPeval.h.

Referenced by parquetfp::Annealer::anneal(), evalSlacks(), evalSlacksFast(), evaluate(), evaluateCompact(), evaluateFast(), parquetfp::Annealer::getYSize(), parquetfp::Annealer::go(), parquetfp::Annealer::makeARWLMove(), parquetfp::Annealer::makeHPWLMove(), parquetfp::Annealer::makeIndexSoftBlMove(), parquetfp::Annealer::makeSoftBlMove(), and parquetfp::Annealer::packSoftBlocks().

vector<double> parquetfp::SPeval::ySlacks
 

Definition at line 117 of file SPeval.h.

Referenced by evalSlacks(), parquetfp::Annealer::evalSlacks(), evalSlacksFast(), parquetfp::Annealer::go(), parquetfp::Annealer::makeARWLMove(), parquetfp::Annealer::makeIndexSoftBlMove(), parquetfp::Annealer::makeSoftBlMove(), parquetfp::Annealer::sortSlacks(), and SPeval().

The documentation for this class was generated from the following files:
Generated on Mon Apr 25 01:18:49 2005 for Parquete by doxygen 1.3.2