typename std::set<Connection*> WeightedPoll::get_objects(){
typename std::set<Connection*> items;
for(typename std::map<Connection*,double>::iterator it = counter.begin(); it != counter.end(); ++it) {
items.insert(it->first);
}
return items;
}
template<typename T> std::set<T> UnionSets(const std::set<T>& s1, const std::set<T>& s2) {
typename std::set<T> r;
typename std::set<T>::const_iterator sit;
for (sit = s1.begin(); sit != s1.end(); sit++) { r.insert(*sit); }
for (sit = s2.begin(); sit != s2.end(); sit++) { r.insert(*sit); }
return r;
}
void setup_stiffness_matrix(PROBLEM& P,
const std::set<typename PROBLEM::Index>& Lambda1,
const std::set<typename PROBLEM::Index>& Lambda2,
SparseMatrix<double>& A_Lambda,
bool preconditioned)
{
cout << "setup_stiffness_matrix()" << endl;
A_Lambda.resize(Lambda1.size(), Lambda2.size());
typedef typename SparseMatrix<double>::size_type size_type;
size_type row = 0;
typedef typename PROBLEM::Index Index;
typedef std::list<Index> IntersectingList;
for (typename std::set<Index>::const_iterator it1(Lambda1.begin()), itend(Lambda1.end());
it1 != itend; ++it1, ++row)
{
// determine list of thise indices which intersect with *it1
IntersectingList Nu;
intersecting_wavelets(P.basis(), *it1.p(), *it1.p(), Lambda2, Nu);
const double d1 = preconditioned ? P.D(*it1) : 1.0;
std::list<size_type> indices;
std::list<double> entries;
size_type column = 0;
// for (typename std::set<Index>::const_iterator it2(Lambda2.begin()), itend2(Lambda2.end());
// it2 != itend2; ++it2, ++column)
for (typename std::list<Index>::const_iterator it2(Nu.begin()), itend2(Nu.end());
it2 != itend2; ++it2, ++column)
{
//if (intersect_singular_support(P.basis(), *it1, *it2))
//double entry = P.a(*it2, *it1);
double entry = P.a(*it1, *it2);
//const double entry = 0;
#if _WAVELETTL_GALERKINUTILS_VERBOSITY >= 2
if (fabs(entry) > 1e-15) {
cout << " column: " << *it2 << ", value " << entry << endl;
}
#endif
if (fabs(entry) > 1e-15) {
indices.push_back(column);
entries.push_back(entry / (preconditioned ? d1 * P.D(*it2) : 1.0));
}
// }
}
A_Lambda.set_row(row, indices, entries);
}
cout << "done" << endl;
}
template<typename T> std::set<T> IntersectSets(const std::set<T>& s1, const std::set<T>& s2) {
typename std::set<T> r;
typename std::set<T>::const_iterator sit;
for (sit = s1.begin(); sit != s1.end(); sit++) {
if (s2.find(*sit) != s2.end()) {
r.insert(*sit);
}
}
return r;
}
template <typename Key, typename Compare, typename Alloc> std::set<Key, Compare, Alloc> set_difference(const std::set<Key, Compare, Alloc>& set1, const std::set<Key, Compare, Alloc>& set2)
{
typename std::set<Key, Compare, Alloc> result;
Compare comp;
std::set_difference(set1.begin(), set1.end(), set2.begin(), set2.end(), std::inserter(result, result.end()), comp);
return result;
}
const Matrix* BooleanInvolutiveBasis<MonomType>::ToMatrix() const
{
MatrixConstructor matrixConstructor(PRing->make_FreeModule(1), 0);
const Monoid* monoid = PRing->getMonoid();
const ring_elem coefficientUnit = PRing->getCoefficients()->one();
monomial tmpRingMonomial = monoid->make_one();
for (typename std::list<Polynom<MonomType>*>::const_iterator currentPolynom = GBasis.begin();
currentPolynom != GBasis.end();
++currentPolynom)
{
if (!*currentPolynom)
{
continue;
}
ring_elem currentRingPolynomial;
for (const MonomType* currentMonom = &(**currentPolynom).Lm();
currentMonom;
currentMonom = currentMonom->Next)
{
exponents currentExponent = newarray_atomic_clear(int, MonomType::GetDimIndepend());
typename std::set<typename MonomType::Integer> variablesSet = currentMonom->GetVariablesSet();
for (typename std::set<typename MonomType::Integer>::const_iterator currentVariable = variablesSet.begin();
currentVariable != variablesSet.end();
++currentVariable)
{
currentExponent[*currentVariable] = 1;
}
monoid->from_expvector(currentExponent, tmpRingMonomial);
deletearray(currentExponent);
ring_elem tmpRingPolynomial = PRing->make_flat_term(coefficientUnit, tmpRingMonomial);
PRing->add_to(currentRingPolynomial, tmpRingPolynomial);
}
matrixConstructor.append(PRing->make_vec(0, currentRingPolynomial));
}
return matrixConstructor.to_matrix();
}
void Generator<Annotation, Runtime, Driver>::generate(
const LoopTrees<Annotation> & loop_trees,
std::set<std::list<Kernel<Annotation, Runtime> *> > & kernel_lists,
LoopMapper<Annotation, Runtime> & loop_mapper,
LoopTiler<Annotation, Runtime> & loop_tiler,
DataFlow<Annotation, Runtime> & data_flow
) {
typedef typename LoopTrees<Annotation>::loop_t loop_t;
typedef typename LoopTiler<Annotation, Runtime>::loop_tiling_t loop_tiling_t;
typedef Kernel<Annotation, Runtime> Kernel;
typename std::set<std::list<Kernel *> >::const_iterator it_kernel_list;
typename std::list<Kernel *>::const_iterator it_kernel;
typename DataFlow<Annotation, Runtime>::context_t df_ctx;
// 0 - init data flow
data_flow.createContextFromLoopTree(loop_trees, df_ctx);
data_flow.markSplittedData(df_ctx);
// 1 - Loop Selection : Generate multiple list of kernel that implement the given LoopTree
loop_mapper.createKernels(loop_trees, kernel_lists);
// 2 - Data Flow : performs data-flow analysis for each list of kernel
for (it_kernel_list = kernel_lists.begin(); it_kernel_list != kernel_lists.end(); it_kernel_list++)
data_flow.generateFlowSets(*it_kernel_list, df_ctx);
// 3 - Arguments : determines the list of arguments needed by each kernel
for (it_kernel_list = kernel_lists.begin(); it_kernel_list != kernel_lists.end(); it_kernel_list++)
for (it_kernel = it_kernel_list->begin(); it_kernel != it_kernel_list->end(); it_kernel++)
buildArgumentLists(loop_trees, *it_kernel);
for (it_kernel_list = kernel_lists.begin(); it_kernel_list != kernel_lists.end(); it_kernel_list++)
for (it_kernel = it_kernel_list->begin(); it_kernel != it_kernel_list->end(); it_kernel++) {
// 4 - Iterations Mapping : determines the "shape" of every loop of each kernel.
// The "shape" of a loop is how this loop is adapted to the execution model.
std::map<loop_t *, std::vector<loop_tiling_t *> > tiling_map;
loop_tiler.determineTiles(*it_kernel, tiling_map);
std::set<std::map<loop_t *, loop_tiling_t *> > loop_tiling_set;
buildAllTileConfigs<Annotation, Runtime>(
std::map<loop_t *, loop_tiling_t *>(),
tiling_map.begin(),
tiling_map.end(),
loop_tiling_set
);
// 5 - Code Generation
size_t cnt = 0;
typename std::set<std::map<loop_t *, loop_tiling_t *> >::iterator it_loop_tiling_map;
for (it_loop_tiling_map = loop_tiling_set.begin(); it_loop_tiling_map != loop_tiling_set.end(); it_loop_tiling_map++) {
typename ::MFB::KLT<Kernel>::object_desc_t kernel_desc(cnt++, *it_kernel, p_file_id);
kernel_desc.tiling.insert(it_loop_tiling_map->begin(), it_loop_tiling_map->end());
typename Kernel::kernel_desc_t * kernel = p_driver.template build<Kernel>(kernel_desc);
(*it_kernel)->addKernel(kernel);
}
typename std::map<loop_t *, std::vector<loop_tiling_t *> >::const_iterator it_tiling_vect;
typename std::vector<loop_tiling_t *>::const_iterator it_tiling;
for (it_tiling_vect = tiling_map.begin(); it_tiling_vect != tiling_map.end(); it_tiling_vect++)
for (it_tiling = it_tiling_vect->second.begin(); it_tiling != it_tiling_vect->second.end(); it_tiling++)
delete *it_tiling;
}
}
std::list<STATE> AStar(const STATE& start, const STATE& target,
boost::function<void (const STATE&, const STATE&,
const STATE&,
std::vector<STATE>&,
std::vector<STATE>&)>
generate_next_states)
{
//std::cout<<"start A* ------------------"<<std::endl;
std::set<STATE> open;
std::set<STATE> closed;
STATE current = start;
while ( current.moreCost() > 0.0000001f ){
//std::cout<<"state: "<<current.p()<<std::endl;
typename std::set<STATE>::iterator iter = closed.begin();
for(; closed.end() != iter; ++iter){
if ( iter->sameAs(current) ) break;
}
if ( closed.end() == iter ){
// insert to closed
closed.insert(current);
}
iter = open.begin();
for(; open.end() != iter; ++iter){
if (iter->sameAs(current)){
open.erase(iter);
break;
}
}
std::vector<STATE> nextStates, unReach;
generate_next_states(current, target, target, nextStates, unReach);
//std::cout<<"next size: "<<nextStates.size()<<std::endl;
for( typename std::vector<STATE>::iterator iter=nextStates.begin();
nextStates.end()!=iter; ++iter){
typename std::set<STATE>::iterator citer = closed.begin();
for(; citer != closed.end(); ++citer){
if ( citer->sameAs(*iter) ) break;
}
if ( closed.end() != citer ){
//std::cout<<"the state "<<iter->p()
//<<"have been closed"<<std::endl;
continue; // the state have be closed
}
iter->setPrevious(current);
typename std::set<STATE>::iterator oiter = open.begin();
for(; oiter != open.end(); ++oiter){
if ( oiter->sameAs(*iter) ) break;
}
if ( open.end() == oiter ){
//std::cout<<"insert "<<iter->p()
//<<" ("<<iter->cost()<<")"<<std::endl;
open.insert(*iter); // first reach this state
}
else{
if ( oiter->cost() > iter->cost() ){
//std::cout<<"refresh "<<iter->p()
//<<" "<<oiter->cost()<<" -> "
//<<iter->cost()<<std::endl;
// find a better path to reach this state
open.erase(oiter);
open.insert(*iter);
}
}
}
if ( open.empty() ){
//std::cout<<"no path! open empty"<<std::endl;
break; // no path!
}
// start from the best state at currently
current = *open.begin();
}
std::list<STATE> path;
while ( !start.sameAs(current) )
{
path.push_front(current);
STATE previous = current.previous();
typename std::set<STATE>::const_iterator p = closed.begin();
for(; p!=closed.end(); ++p ){
if ( previous.sameAs(*p) ) break;
}
if ( closed.end() == p ){
//std::cout<<"no path! closed empty"<<std::endl;
// no path: closed empty!
break;
}
current = *p;
}
//std::cout<<"end A* ----------------"<<std::endl;
return path;
}
PathType getPath(const GraphAdapterType& graphAdapter, const NodeAdapterType& start, const std::function<bool(const NodeAdapterType&)>& endCondition) const {
PathType resultPath;
struct NodePositionComparator {
bool operator() (const NodeAdapterType& lhs, const NodeAdapterType& rhs) {
return lhs.position < rhs.position;
}
};
std::set<NodeAdapterType> open = { start };
std::set<NodeAdapterType, NodePositionComparator> closed;
std::map<NodeAdapterType, NodeAdapterType, NodePositionComparator> came_from;
typename std::set<NodeAdapterType>::iterator current;
while(open.empty() == false) {
current = open.begin();
if(endCondition(*current) == true) {
// Goal found, recreating path from 'goal' node to 'start' node
resultPath.push_front(current->position);
auto pathCurrent = came_from.find(*current);
if(pathCurrent != came_from.end()) {
while(pathCurrent->second.position != start.position) {
resultPath.push_front(pathCurrent->second.position);
pathCurrent = came_from.find(pathCurrent->second);
}
}
return resultPath;
}
closed.insert(*current);
std::vector<NodeAdapterType> neighbours = graphAdapter.getNeighboursOf(*current);
for(NodeAdapterType& neighbour : neighbours) {
if(graphAdapter.isAvailable(neighbour.position)) {
typename std::set<NodeAdapterType>::iterator cIter, oIter;
cIter = closed.find(neighbour);
if(cIter != closed.end()) {
continue;
}
neighbour.g(current->g() + 1);
neighbour.h(graphAdapter.getHeuristicCostLeft(neighbour, neighbour));
oIter = open.find(neighbour);
if(oIter == open.end() || neighbour.g() < oIter->g()) {
if(oIter != open.end()) {
open.erase(oIter);
}
auto cameFromIter = came_from.find(neighbour);
if(cameFromIter != came_from.end()) {
if(cameFromIter->second.g() > neighbour.g()) {
came_from.erase(cameFromIter);
}
}
came_from.emplace(std::pair<NodeAdapterType, NodeAdapterType>(neighbour, *current));
open.insert(neighbour);
}
}
}
open.erase(current);
}
// If algorithm comes here, no path was found, and return value of this method will be empty vector
return resultPath;
}
int test_lrs(){
typedef NT_ NT;
typedef std::vector<NT> Point;
typedef std::vector<Point> Points;
typedef std::vector<NT> Normal;
typedef std::set<std::vector<NT> > Polytope;
// construct the input, the points and the vector containing them
Point p(2),q(2),r(2),s(2);
p[0]=NT(0);p[1]=NT(0);
q[0]=NT(3);q[1]=NT(3);
r[0]=NT(0);r[1]=NT(3);
s[0]=NT(1);s[1]=NT(2);
Points input(4);
input[0]=p;input[1]=q;input[2]=r;input[3]=s;
// create a LRS_CH object
LRS_CH<NT> ch_object(input);
// output the H-representation
Polytope output=ch_object.get_h_rep();
// check that the output is three hyperplanes
if(output.size()!=3)
return -1;
typename Polytope::const_iterator hi=output.begin();
// check that the first element is [-1,1,0]
if(hi->size()!=3)
return -2;
if((*hi)[0]!=-1||(*hi)[1]!=1||(*hi)[2]!=0)
return -3;
// check that the second element is [0,-1,3]
++hi;
if(hi->size()!=3)
return -4;
if((*hi)[0]!=0||(*hi)[1]!=-1||(*hi)[2]!=3)
return -5;
// check that the third element is [1,0,0]
++hi;
if(hi->size()!=3)
return -6;
if((*hi)[0]!=1||(*hi)[1]!=0||(*hi)[2]!=0)
return -7;
// now, check the normals
std::set<Normal> normals=ch_object.get_normals();
// check that there are three normals
if(normals.size()!=3)
return -8;
typename std::set<Normal>::const_iterator ni=normals.begin();
// check that the first element is [-1,0]
if(ni->size()!=2)
return -9;
if((*ni)[0]!=-1||(*ni)[1]!=0)
return -10;
// check that the second element is [0,1]
++ni;
if(ni->size()!=2)
return -11;
if((*ni)[0]!=0||(*ni)[1]!=1)
return -12;
// check that the third element is [1,-1]
++ni;
if(ni->size()!=2)
return -13;
if((*ni)[0]!=1||(*ni)[1]!=-1)
return -14;
return 0;
}