void DataPartitions::doFrequency(DoubleVector dimData){
m_partitions.clear();
PairVector dimOrData;
initPairs(dimOrData, dimData);
pairSort(dimOrData);
int dimsize = dimData.size();
int nBins = this->m_rddtClust->m_rddtOp->m_nBins;
if(nBins == 0 ){
nBins = 1;
}
if(nBins>dimsize){
nBins = dimsize;
}
for(int i = 0; i< nBins; i++){
DataPartition* partition = new DataPartition();
partition->setPartitions(this);
partition->m_partitionIdx = i;
this->m_partitions.push_back(partition);
}
int partitionsize = (int)ceil((double)dimsize/(double)nBins);
for(unsigned i = 0; i< dimOrData.size(); i++){
int p = (int)((double)i/(double)partitionsize);
if(p>(int)m_partitions.size())
p=m_partitions.size();
int first = (dimOrData[i]).first;
(m_partitions[p])->m_parIndices.push_back(first);
}
}
void DataPartitions::initPairs(PairVector &dimOrData, DoubleVector dimData){
dimOrData.clear();
for(unsigned i = 0; i< dimData.size(); i++){
int first = (int)i;
double second = dimData[i];
std::pair<int, double> temp(first,second);
dimOrData.push_back(temp);
}
}
void Transformed::divideTools(const std::vector<TopoDS_Shape> &toolsIn, std::vector<TopoDS_Shape> &individualsOut,
TopoDS_Compound &compoundOut) const
{
typedef std::pair<TopoDS_Shape, Bnd_Box> ShapeBoundPair;
typedef std::list<ShapeBoundPair> PairList;
typedef std::vector<ShapeBoundPair> PairVector;
PairList pairList;
std::vector<TopoDS_Shape>::const_iterator it;
for (it = toolsIn.begin(); it != toolsIn.end(); ++it)
{
Bnd_Box bound;
BRepBndLib::Add(*it, bound);
bound.SetGap(0.0);
ShapeBoundPair temp = std::make_pair(*it, bound);
pairList.push_back(temp);
}
BRep_Builder builder;
builder.MakeCompound(compoundOut);
while(!pairList.empty())
{
PairVector currentGroup;
currentGroup.push_back(pairList.front());
pairList.pop_front();
PairList::iterator it = pairList.begin();
while(it != pairList.end())
{
PairVector::const_iterator groupIt;
bool found(false);
for (groupIt = currentGroup.begin(); groupIt != currentGroup.end(); ++groupIt)
{
if (!(*it).second.IsOut((*groupIt).second))//touching means is out.
{
found = true;
break;
}
}
if (found)
{
currentGroup.push_back(*it);
pairList.erase(it);
it=pairList.begin();
continue;
}
it++;
}
if (currentGroup.size() == 1)
builder.Add(compoundOut, currentGroup.front().first);
else
{
PairVector::const_iterator groupIt;
for (groupIt = currentGroup.begin(); groupIt != currentGroup.end(); ++groupIt)
individualsOut.push_back((*groupIt).first);
}
}
}
void UCK::getGraph(vector<String>& v, PairVector& e, const Molecule& mol)
{
weight_ = 0.0;
Size count = 0;
vector<pair<String, Size> >* mol_name;
mol_name = new vector<pair<String, Size> >;
bool found_atom = false;
for(AtomConstIterator atit1 = mol.beginAtom(); atit1 != mol.endAtom(); ++atit1)
{
if(ignore_hydrogens_ && atit1->getElement()==PTE[1]) continue;
// find chemical formula
for(Size i = 0; i != mol_name->size(); ++i)
{
if((*mol_name)[i].first == atit1->getElement().getSymbol()) // increase number of already existing molecules
{
(*mol_name)[i].second++;
found_atom = true;
break;
}
}
if(!found_atom) // add current atom to formula, if it doesn't exist
{
mol_name->push_back(make_pair(atit1->getElement().getSymbol(),1));
found_atom = false;
}
found_atom = false;
weight_ += atit1->getElement().getAtomicWeight();
v.push_back(atit1->getElement().getSymbol()); // add atom-name to label-list
Size dest = 0;
// find bonds from current atom to all other atoms and store them in e
for(AtomConstIterator atit2 = mol.beginAtom(); atit2 != mol.endAtom(); ++atit2)
{
if(ignore_hydrogens_ && atit2->getElement()==PTE[1]) continue;
if(atit1->getBond(*atit2) != 0)
{
e.push_back(make_pair(count, dest));
}
++dest;
}
++count;
}
sort(mol_name->begin(), mol_name->end()); // sort vector mol_name in order to get the lexicographically ordered
for(Size i = 0; i != mol_name->size(); ++i) // chemical formula
{
formula_ += ((*mol_name)[i].first)+(String)(*mol_name)[i].second;
}
delete mol_name;
return;
}
String UCK::lambda(String lambda_d, const PairVector& e, const vector<String>& v, Size i, Size d)
{
lambda_d = v[i]; // fix label
vector<String>* lam;
lam = new vector<String>;
if(d==0) // depth 0 is reached, return the label written in new_label
{
delete lam;
return lambda_d;
}
else // d!=0
{
// compute lambda_d-1_labels for all children
for(PairVector::const_iterator it = e.begin(); it != e.end(); ++it)
{
if(it->first!=i) // if source node in e is not equal to the current position i, then skip this edge
{
continue;
}
else // an edge to another node is found, so compute lambda_d-1 of the child and store the resulting string
// in vector lam
{
lam->push_back(eraseDoubleLabels(d, v[i], lambda("", e, v, it->second, d-1)));
}
}
sort(lam->begin(), lam->end()); // lexicographically order the lambda_d-1 -labels
}
// concatenate lambda_d-1 -labels and produce lambda_d -label
for(vector<String>::iterator it = lam->begin(); it != lam->end(); ++it)
{
lambda_d += *it;
}
delete lam;
return lambda_d;
}
void UCK::makePathMatrix(const PairVector& e, SizeVector& sp, const Size e_size)
{
std::vector<Size>* line;
// create bond-matrix, because Floyd's Algorithm requires a reachability matrix
SizeVector* bond_matrix;
line = new vector<Size>;
bond_matrix = new SizeVector;
// initialize bond-matrix with 0 at every position
for (Size i = 0; i != e_size; ++i)
{
line->clear();
for(Size j = 0; j != e_size; ++j)
{
line->push_back(0);
}
bond_matrix->push_back(*line);
}
// proceed all edges and set corresponding position in bond_matrix to 1
for (Size i = 0; i != e.size(); ++i)
{
(*bond_matrix)[e[i].first][e[i].second] = 1;
}
// initialize sp-matrix
for(Size i = 0; i != bond_matrix->size(); ++i)
{
line->clear();
for(Size j = 0; j != bond_matrix->size(); ++j)
{
if (i == j) // distance from a node to itself = 0
{
line->push_back(0);
}
else if((*bond_matrix)[i][j] == 1) // if an edge exists between node i and j,
{
line->push_back(1); // the distance between them is 1
}
else
{
line->push_back(std::numeric_limits<Index>::max()); // otherwise the distance is set to infinity
}
}
sp.push_back(*line);
}
// Floyd's Algorithm
for(Size i = 0; i != sp.size(); ++i)
{
for(Size j = 0; j != sp.size(); ++j)
{
for(Size k = 0; k != sp.size(); k++)
{
if(sp[j][k] > (sp[j][i] + sp[i][k]))
{
sp[j][k] = (sp[j][i] + sp[i][k]);
}
}
}
}
delete bond_matrix;
delete line;
return;
}
bool Monster::pushItem(Item* item, int32_t radius)
{
const Position& centerPos = item->getPosition();
PairVector pairVector;
pairVector.push_back(PositionPair(-1, -1));
pairVector.push_back(PositionPair(-1, 0));
pairVector.push_back(PositionPair(-1, 1));
pairVector.push_back(PositionPair(0, -1));
pairVector.push_back(PositionPair(0, 1));
pairVector.push_back(PositionPair(1, -1));
pairVector.push_back(PositionPair(1, 0));
pairVector.push_back(PositionPair(1, 1));
std::random_shuffle(pairVector.begin(), pairVector.end());
Position tryPos;
for(int32_t n = 1; n <= radius; ++n)
{
for(PairVector::iterator it = pairVector.begin(); it != pairVector.end(); ++it)
{
int32_t dx = it->first * n, dy = it->second * n;
tryPos = centerPos;
tryPos.x = tryPos.x + dx;
tryPos.y = tryPos.y + dy;
Tile* tile = g_game.getTile(tryPos);
if(tile && g_game.canThrowObjectTo(centerPos, tryPos) && g_game.internalMoveItem(this, item->getParent(),
tile, INDEX_WHEREEVER, item, item->getItemCount(), NULL) == RET_NOERROR)
return true;
}
}
return false;
}
void DataPartitions::pairSort(PairVector &dimOrData){
std::sort(dimOrData.begin(),dimOrData.end(),pairSortComp);
}
