int main(){
srand(123);
headWay = allocWay(0);
ACO();
freeWay(headWay);
return 0;
}
//TSP -> NN -> Generations( g, ForkJoin ( n, ACO -> 2-OPT ) ) -> TSP'
void Pipeline3(tsp_class& tsp_instance, unsigned int number_of_tasks,
unsigned int number_of_generations)
{
#pragma region "PipelineConfiguration"
auto a = Args<General_args_type>(make_General_args(number_of_generations, number_of_tasks));
auto sa = Args<SA_args_type>();
auto ga = Args<GA_args_type>();
const int aco_iterations = static_cast<int>(tsp_instance.cities.size() * 100);
const ants_type::size_type number_of_ants = tsp_instance.cities.size();
const double BASE_PHEROMONE = 1.0f / static_cast<double>(tsp_instance.cities.size());
const double ALPHA = 1.0;
const double BETA = 1.0;
const double RHO = 0.9;
const double QVAL = 70;
auto aco = Args<ACO_args_type>(make_ACO_args(aco_iterations, number_of_ants,
BASE_PHEROMONE, ALPHA, BETA, RHO, QVAL));
const char* pipeline_description = "TSP -> NN -> Generations( g, ForkJoin ( n, ACO -> 2-OPT ) ) -> TSP'";
display_args(pipeline_description, a, sa, aco, ga);
auto g = a[0].number_of_iterations_or_generations;
auto n = a[0].number_of_tasks_in_parallel;
auto _TSP = TSP(just(tsp_instance));
auto _DisplayInput = Display("TSP INPUT", DisplayFlags::All);
auto _NN = Measure(NN(), Display("NEAREST NEIGHBOUR", DisplayFlags::EmitMathematicaGraphPlot));
auto _ACO_2OPT = Chain(ACO(aco[0].aco_iterations, aco[0].number_of_ants, aco[0].base_pheromone,
aco[0].favor_pheromone_level_over_distance,
aco[0].favor_distance_over_pheromone_level,
aco[0].value_for_intensification_and_evaporation,
aco[0].pheronome_distribution), _2OPT());
auto _ForkJoin = [](unsigned int n, TSP::transformer_type map_fun){ return Measure(ForkJoin(n, map_fun)); };
auto _DisplayOutput = Display("TSP OUTPUT", DisplayFlags::EmitMathematicaGraphPlot);
#pragma endregion
//TSP -> NN -> Generations( g, ForkJoin ( n, ACO -> 2-OPT ) ) -> TSP'
auto result = _TSP
.map(_DisplayInput)
.map(_NN)
.map(Generations(g, _ForkJoin(n, _ACO_2OPT)))
.map(_DisplayOutput);
}
float optTSP(Element x[SIZE][SIZE],int n,int k[2*SIZE],int t,int m)
{
int i=0,p;
float j;
int l[2*SIZE];
float best=MAX;
while(i<t)
{
j= ACO(x,n,k,m);
if(j!=0 && j<best)
{
best=j;
for(p=0;p<2*n;p++)
l[p]=k[p];
if(i>3)
update(x,n,k,best,0);
}
i++;
}
for(p=0;p<2*n;p++)
k[p]=l[p];
return best;
}
::libmaus2::autoarray::AutoArray<uint64_t> toWaveletTreeBitsParallel(
::libmaus2::bitio::CompactArray * C, bool const verbose, uint64_t const
#if defined(_OPENMP)
numthreads
#endif
)
{
uint64_t const pn = ((C->n + 63) / 64)*64;
::libmaus2::autoarray::AutoArray<uint64_t> B( pn/64 , false );
::libmaus2::parallel::OMPLock block;
typedef std::pair<uint64_t, uint64_t> qtype;
std::deque < qtype > Q;
Q.push_back( qtype(0,C->n) );
if ( verbose )
std::cerr << "(Sorting bits...";
for ( int ib = (C->getB())-1; ib>=0; --ib )
{
std::deque < qtype > Q2;
uint64_t const sb = (C->getB()-ib-1);
uint64_t const mask = (1ull << ib);
if ( verbose )
std::cerr << "(l=" << ib << ")";
::libmaus2::bitio::CompactSparseArray S(C->D,C->n, C->getB() - sb , sb , C->getB());
while ( Q.size() )
{
uint64_t l = Q.front().first, r = Q.front().second;
Q.pop_front();
// std::cerr << "[" << l << "," << r << "]" << std::endl;
uint64_t const numpackets = getMaxThreads() * 2;
::libmaus2::autoarray::AutoArray < uint64_t > aones(numpackets+1);
::libmaus2::autoarray::AutoArray < uint64_t > azeroes(numpackets+1);
uint64_t const intervalsize = r-l;
uint64_t const packetsize = ( intervalsize + numpackets - 1 ) / numpackets;
if ( verbose )
std::cerr << "(c01/b";
#if defined(_OPENMP)
#pragma omp parallel for schedule(dynamic,1) num_threads(numthreads)
#endif
for ( int64_t h = 0; h < static_cast<int64_t>(numpackets); ++h )
{
uint64_t ones = 0;
uint64_t low = std::min ( l + h * packetsize, r );
uint64_t const rlow = low;
uint64_t const high = std::min ( low + packetsize, r );
uint64_t const low64 = std::min ( ((low+63)/64)*64, high );
uint64_t const high64 = high & (~(63ull));
// std::cerr << "low=" << low << " low64=" << low64 << std::endl;
/**
* align low to 64
**/
block.lock();
for ( ; low != low64 ; ++low )
{
uint64_t const v = (C->get(low)&mask)>>ib;
ones += v;
::libmaus2::bitio::putBit(B.get(), low, v);
}
block.unlock();
/**
* handle full blocks of 64 values
**/
if ( low != high )
{
assert ( low % 64 == 0 );
assert ( high64 >= low );
uint64_t * Bptr = B.get() + (low/64);
while ( low != high64 )
{
uint64_t vb = 0;
uint64_t const lh = low+64;
for ( ; low != lh ; ++low )
{
uint64_t const v = (C->get(low)&mask)>>ib;
ones += v;
vb <<= 1;
vb |= v;
}
(*Bptr++) = vb;
}
}
/**
* handle rest
**/
block.lock();
for ( ; (low != high) ; ++low )
{
uint64_t const v = (C->get(low)&mask)>>ib;
ones += v;
::libmaus2::bitio::putBit(B.get(), low, v);
}
block.unlock();
uint64_t const zeroes = (high-rlow)-ones;
aones [ h ] = ones;
azeroes [ h ] = zeroes;
}
if ( verbose )
std::cerr << ")";
/**
* compute prefix sums for zeroes and ones
**/
{
uint64_t c = 0;
for ( uint64_t i = 0; i < numpackets + 1; ++i )
{
uint64_t const t = aones[i];
aones[i] = c;
c += t;
}
}
{
uint64_t c = 0;
for ( uint64_t i = 0; i < numpackets + 1; ++i )
{
uint64_t const t = azeroes[i];
azeroes[i] = c;
c += t;
}
}
uint64_t const ones = aones[numpackets];
uint64_t const zeros = (r-l)-ones;
::libmaus2::autoarray::AutoArray < ::libmaus2::bitio::CompactArray::unique_ptr_type > ACZ(numpackets);
::libmaus2::autoarray::AutoArray < ::libmaus2::bitio::CompactArray::unique_ptr_type > ACO(numpackets);
if ( verbose )
std::cerr << "(a";
for ( uint64_t h = 0; h < numpackets; ++h )
{
::libmaus2::bitio::CompactArray::unique_ptr_type tACZ(
new ::libmaus2::bitio::CompactArray( azeroes [ h+1 ] - azeroes[ h ], C->getB() - sb )
);
ACZ[h] = UNIQUE_PTR_MOVE(tACZ);
::libmaus2::bitio::CompactArray::unique_ptr_type tACO(
new ::libmaus2::bitio::CompactArray( aones [ h+1 ] - aones[ h ], C->getB() - sb )
);
ACO[h] = UNIQUE_PTR_MOVE(tACO);
}
if ( verbose )
std::cerr << ")";
if ( verbose )
std::cerr << "(d";
#if defined(_OPENMP)
#pragma omp parallel for schedule(dynamic,1) num_threads(numthreads)
#endif
for ( int64_t h = 0; h < static_cast<int64_t>(numpackets); ++h )
{
uint64_t const low = std::min ( l + h * packetsize, r );
uint64_t const high = std::min ( low + packetsize, r );
uint64_t zp = 0;
uint64_t op = 0;
::libmaus2::bitio::CompactArray & CO = *ACO[h];
::libmaus2::bitio::CompactArray & CZ = *ACZ[h];
for ( uint64_t i = low; i != high; ++i )
{
uint64_t const v = S.get(i);
if ( v & mask )
CO.set ( op++, v);
else
CZ.set ( zp++, v);
}
assert ( zp == azeroes[h+1]-azeroes[h] );
assert ( op == aones[h+1]-aones[h] );
}
if ( verbose )
std::cerr << ")";
std::vector < CopyBackPacket > zpacketstodo;
for ( int64_t h = 0; h < static_cast<int64_t>(numpackets); ++h )
{
uint64_t const low = l + azeroes[h];
uint64_t const high = low + (azeroes[h+1]-azeroes[h]);
if ( high-low )
zpacketstodo.push_back ( CopyBackPacket(h,low,high) );
}
std::vector < CopyBackPacket > opacketstodo;
for ( int64_t h = 0; h < static_cast<int64_t>(numpackets); ++h )
{
uint64_t const low = l + azeroes[numpackets ] + aones[h];
uint64_t const high = low + (aones[h+1]-aones[h]);
if ( high-low )
opacketstodo.push_back ( CopyBackPacket(h,low,high) );
}
std::vector < std::vector < CopyBackPacket > > zpackets;
while ( zpacketstodo.size() )
{
std::vector < CopyBackPacket > zpacketsnewtodo;
std::vector < CopyBackPacket > nlist;
nlist.push_back(zpacketstodo.front());
for ( uint64_t i = 1; i < zpacketstodo.size(); ++i )
if ( CopyBackPacket::overlap(nlist.back(), zpacketstodo[i], C->getB()) )
zpacketsnewtodo.push_back(zpacketstodo[i]);
else
nlist.push_back(zpacketstodo[i]);
zpackets.push_back(nlist);
zpacketstodo = zpacketsnewtodo;
}
std::vector < std::vector < CopyBackPacket > > opackets;
while ( opacketstodo.size() )
{
std::vector < CopyBackPacket > opacketsnewtodo;
std::vector < CopyBackPacket > nlist;
nlist.push_back(opacketstodo.front());
for ( uint64_t i = 1; i < opacketstodo.size(); ++i )
if ( CopyBackPacket::overlap(nlist.back(), opacketstodo[i], C->getB()) )
opacketsnewtodo.push_back(opacketstodo[i]);
else
nlist.push_back(opacketstodo[i]);
opackets.push_back(nlist);
opacketstodo = opacketsnewtodo;
}
// std::cerr << "zpackets: " << zpackets.size() << " opackets: " << opackets.size() << std::endl;
if ( verbose )
std::cerr << "(cb";
for ( uint64_t q = 0; q < zpackets.size(); ++q )
#if defined(_OPENMP)
#pragma omp parallel for schedule(dynamic,1) num_threads(numthreads)
#endif
for ( int64_t j = 0; j < static_cast<int64_t>(zpackets[q].size()); ++j )
{
CopyBackPacket const CBP = zpackets[q][j];
uint64_t ac = CBP.low;
::libmaus2::bitio::CompactArray & CZ = *ACZ[CBP.h];
for ( uint64_t zc = 0 ; zc != CBP.high-CBP.low; ++zc )
S.set ( ac++ , CZ.get(zc) );
}
for ( uint64_t q = 0; q < opackets.size(); ++q )
#if defined(_OPENMP)
#pragma omp parallel for schedule(dynamic,1) num_threads(numthreads)
#endif
for ( int64_t j = 0; j < static_cast<int64_t>(opackets[q].size()); ++j )
{
CopyBackPacket const CBP = opackets[q][j];
uint64_t ac = CBP.low;
::libmaus2::bitio::CompactArray & CO = *ACO[CBP.h];
for ( uint64_t oc = 0 ; oc != CBP.high-CBP.low; ++oc )
S.set ( ac++ , CO.get(oc) );
}
if ( verbose )
std::cerr << ")";
if ( zeros )
Q2.push_back ( qtype(l,l+zeros) );
if ( ones )
Q2.push_back ( qtype(r-ones,r) );
}
// std::cerr << std::endl;
uint64_t const numpackets = getMaxThreads() * 2;
uint64_t const intervalsize = C->n;
uint64_t const packetsize = ( intervalsize + numpackets - 1 ) / numpackets;
std::vector < CopyBackPacket > packetstodo;
for ( int64_t h = 0; h < static_cast<int64_t>(numpackets); ++h )
{
uint64_t const low = std::min(h*packetsize,C->n);
uint64_t const high = std::min(low+packetsize,C->n);
if ( high-low )
packetstodo.push_back ( CopyBackPacket(h,low,high) );
}
std::vector < std::vector < CopyBackPacket > > packets;
while ( packetstodo.size() )
{
std::vector < CopyBackPacket > packetsnewtodo;
std::vector < CopyBackPacket > nlist;
nlist.push_back(packetstodo.front());
for ( uint64_t i = 1; i < packetstodo.size(); ++i )
if ( CopyBackPacket::overlap(nlist.back(), packetstodo[i], C->getB()) )
packetsnewtodo.push_back(packetstodo[i]);
else
nlist.push_back(packetstodo[i]);
packets.push_back(nlist);
packetstodo = packetsnewtodo;
}
for ( uint64_t q = 0; q < packets.size(); ++q )
#if defined(_OPENMP)
#pragma omp parallel for schedule(dynamic,1) num_threads(numthreads)
#endif
for ( int64_t h = 0; h < static_cast<int64_t>(packets[q].size()); ++h )
{
CopyBackPacket const CBP = packets[q][h];
for ( uint64_t i = CBP.low; i < CBP.high; ++i )
::libmaus2::bitio::putBit ( C->D , i*C->getB() + sb , ::libmaus2::bitio::getBit(B.get(), i) );
}
Q = Q2;
}
