void crypto::columnar_decryption(std::string cipher)
{
static int count = 0; //static count for printing, not really useful in general
std::ofstream file("perms.txt", std::ofstream::app); //open the file to append to
scores ord, writer; // 2 vectors of scores writer is the master list, ord is the temp list
// attack all key lengths up to 10 (should probably avoid a magic number and make max_key_len a parameter)
for (int columns = 1; columns <= 10; columns++)
{
//create a vector of the indexes based on the key length
std::vector<size_t> indexes;
for (int i = 0; i < columns; ++i)
indexes.push_back(i);
//number of columns for all rows(integer division is ok here)
int rows = cipher.size() / columns;
//number of columns that will be in the final row (if it exists)
int extra = cipher.size() % columns;
// the columns of the message
std::vector<std::string> pqr(indexes.size());
//decrypt the columnar transposition for each permutation of column orderings
while (std::next_permutation(indexes.begin(), indexes.end()))
{
int start = 0;
int end;
for (int i = 0; i < columns; ++i)
{
end = rows + (extra > indexes[i]);
pqr[indexes[i]] = cipher.substr(start, end);
start += end;
}
std::string word;
for (int i = 0; i < rows + (extra > 0); ++i)
{
auto offset = i*columns;
for (int j = 0; j < columns; ++j)
{
auto index = j + offset;
if (index < cipher.size())
word += pqr[j][i];
}
}
auto score = get_scores(word);// get the score for the decrypted message
if (ord.find(word) != ord.end())
ord[word] = std::max(ord[word], score);//only keep the max scores
else
ord[word] = score;//add a new score if we don't have it yet
} // end while
writer = top(ord, writer, 1000);//only keep the top 1000 scores for the future
}
// order the list by score instead of string so we need to use a multimap
auto ret = flip_map(writer);
//write the scores to a file
for (auto it = ret.begin(); it != ret.end(); ++it)
file << it->first << " " << it->second << std::endl;
file.close();
++count;
printf("Finished %d \n", count);
}
int main(int argc, char *argv[]) {
//Immediately start the timer which will be called on exit
boost::timer::auto_cpu_timer t;
//Parse any command line flags we want, default 2 threads
std::string dirName = "";
int nThreads = 2;
int mostUsedWords = 10;
bool printIndexing = true;
if(argc > 2) {
//Have thread flag and directory
if(std::string(argv[1]) == "-t") {
dirName = argv[3];
nThreads = atoi(argv[2]);
}
else {
usage();
return 0;
}
}
else if(argc == 2) {
dirName = argv[1];
nThreads = 2;
}
else {
usage();
return 0;
}
//First step, setup our thread controls and variables
//wvmap is typedef std::vector<std::map<std::string, int>* >
//start profiling
auto beginThreads = std::chrono::high_resolution_clock::now();
sQueue<cppfiData> squeue;
controlStructure MCP; //TRON
wvmap tidWordCount;
tidWordCount.reserve(nThreads);
MCP.nThreads = nThreads;
MCP.printIndexing = printIndexing;
//Create the maps on the heap for each individual thread
for(int j = 0; j < nThreads; j++) {
tidWordCount[j] = new std::map<std::string, int>;
}
//Get the file finder up and running with the squeue
fileFinder fFileFinder(dirName, squeue, MCP);
std::thread t1(&fileFinder::runFileFinder, fFileFinder);
t1.detach();
//Boot up N threads of indexers, they need to know about their place in the master map
//Hand them the entire vector of map pointers, although they are only allowed to access their
//own. Enforced by hand via their index variable, in this case, i.
std::vector<std::thread> workerThreads;
std::vector<fileIndexer*> indexerObjects;
for(int i = 0; i < nThreads; ++i) {
indexerObjects.push_back(new fileIndexer(i, squeue, MCP));
workerThreads.push_back(std::thread(&fileIndexer::runFileIndexer, indexerObjects[i], std::ref(tidWordCount)));
}
/*
Here is all the work happens. We should have one finder up and running that
is populating the squeue, and nThreads indexers which are each keeping track
of their own word counts. Main should just block on the next statement.
*/
//Wait for all the worker threads to finish
for(auto& t : workerThreads) {
t.join();
}
//t1.join();
auto endThreads = std::chrono::high_resolution_clock::now();
std::cout << "Thread work: " <<
std::chrono::duration_cast<std::chrono::milliseconds>(endThreads-beginThreads).count() << "ms" << std::endl;
//Merge the maps together into a final map from harvesting!
//Basically the same as a reduce operation
auto beginReduce = std::chrono::high_resolution_clock::now();
std::map<std::string, int> finalMap;
for(int i = 0; i < nThreads; i++) {
std::map<std::string, int>& wMap = *(tidWordCount[i]);
for(auto& kv : wMap) {
finalMap[kv.first] += kv.second;
}
}
//Now, swap the order!
std::multimap<int, std::string> invertedFinalMap = flip_map(finalMap);
int counter = 0;
//Explicitly search backwards, the highest values with be at the end. Basically
//exploit how the map is sorted already. We could throw in a vector to sort,
//but this is already available. remember we typedefed mmri
for(mmri it = invertedFinalMap.rbegin(); it != invertedFinalMap.rend(); it++) {
std::cout << "[" << it->second << "]" << "\t" << it->first << std::endl;
counter++;
if(counter >= mostUsedWords) //However many words you want
break;
}
auto endReduce = std::chrono::high_resolution_clock::now();
std::cout << "Reduce work: " <<
std::chrono::duration_cast<std::chrono::milliseconds>(endReduce-beginReduce).count() << "ms" << std::endl;
//Destroy the indexers
for(auto& indexer : indexerObjects) {
delete indexer;
}
//Destroy the maps
for(int j = 0; j < nThreads; j++) {
delete tidWordCount[j];
}
return EXIT_SUCCESS;
}
int
set0(Evas *e){
Evas_Object *img, *proxy;
bool rv;
int w,h;
struct imageupdate *iu;
//int minw,minh,maxw,maxh;
label_add(e,10,0,"The Source",false);
img = evas_object_image_filled_add(e);
evas_object_image_file_set(img, images[0], NULL);
evas_object_image_size_get(img, &w, &h);
w = w/2; h = h/2;
evas_object_resize(img, w, h);
evas_object_move(img, 10,10);
evas_object_show(img);
iu = calloc(1,sizeof(struct imageupdate));
iu->cur = 0;
iu->max = N_IMAGES;
iu->obj = img;
iu->imagelist = images;
ecore_timer_add(1.4, image_next, iu);
label_add(e,20+w,0,"Normal Proxy",false);
proxy = evas_object_image_filled_add(e);
if (!proxy){
printf("Unable to create proxy object\n");
return 1;
}
rv = evas_object_image_source_set(proxy, img);
if (rv != true){
printf("Error setting proxy source\n");
return 1;
}
evas_object_resize(proxy, w, h);
evas_object_move(proxy, 20 + w, 10);
/* If this is uncommented: Moves proxy evyer second (swap x/y) */
//iu->proxy = proxy;
evas_object_show(proxy);
label_add(e,10,h + 20, "Reflected Proxy",false);
proxy = evas_object_image_filled_add(e);
evas_object_image_source_set(proxy, img);
evas_object_resize(proxy, w, h);
evas_object_move(proxy, 10, 30+h);
evas_object_show(proxy);
flip_map(proxy);
label_add(e,20+w,h+20,"Squish Proxy",false);
proxy = evas_object_image_add(e);
evas_object_image_source_set(proxy, img);
evas_object_resize(proxy, w, h / 2);
evas_object_image_fill_set(proxy, 0,0, w, h/2);
evas_object_move(proxy, 20+w, 30+h);
evas_object_show(proxy);
/* Proxy a label */
img = label_add(e, 300, 10, "Label Source ",true);
evas_object_geometry_get(img, NULL, NULL, &w, &h);
proxy = evas_object_image_filled_add(e);
evas_object_image_source_set(proxy, img);
evas_object_resize(proxy, w, h);
evas_object_move(proxy, 300, 10 + h + 3);
evas_object_show(proxy);
flip_map(proxy);
label_add(e, 440, 10, "Squish Label",false);
proxy = evas_object_image_add(e);
evas_object_image_source_set(proxy, img);
evas_object_resize(proxy, w, h / 2);
evas_object_image_fill_set(proxy, 0,0,w,h/2);
evas_object_move(proxy, 440, 10 + h + 3);
evas_object_show(proxy);
label_add(e, 440, 60, "Stretch Label",false);
proxy = evas_object_image_add(e);
evas_object_image_source_set(proxy, img);
evas_object_resize(proxy, w, h);
evas_object_image_fill_set(proxy, 0,0,w, h);
evas_object_move(proxy, 440, 60 + h + 3);
evas_object_show(proxy);
label_add(e, 240, 60, "Highlight", false);
proxy = evas_object_image_add(e);
evas_object_image_source_set(proxy, img);
evas_object_resize(proxy, 50,50);
evas_object_image_fill_set(proxy, -w/2,-h/2,w*3,h*3);
evas_object_move(proxy, 250, 60 + h + 3);
evas_object_show(proxy);
img = label_add(e, 400, 120, "Zoomy Text!", false);
proxy = evas_object_image_filled_add(e);
evas_object_image_source_set(proxy, img);
evas_object_resize(proxy, w, h);
evas_object_move(proxy, 350, 150);
zoom_map(proxy);
evas_object_show(proxy);
/* Proxy a text block */
img = textblock_add(e, 10, 200);
evas_object_geometry_get(img, NULL, NULL, &w, &h);
proxy = evas_object_image_filled_add(e);
evas_object_image_source_set(proxy, img);
evas_object_resize(proxy, w, h);
evas_object_move(proxy, 10, 320);
evas_object_show(proxy);
flip_map(proxy);
proxy = evas_object_image_filled_add(e);
evas_object_image_source_set(proxy, img);
evas_object_resize(proxy, w/2, h/2);
evas_object_move(proxy, 10 + w, 320);
evas_object_show(proxy);
/* The 'smart' object */
img = sp_add(e);
evas_object_move(img, 300,200);
evas_object_resize(img, 100, 20);
ecore_timer_add(0.05, smart_animate, img);
w = 100;
h = 20;
proxy = evas_object_image_filled_add(e);
evas_object_image_source_set(proxy, img);
evas_object_resize(proxy, w, h);
evas_object_move(proxy, 300, 240);
evas_object_show(proxy);
flip_map(proxy);
proxy = evas_object_image_filled_add(e);
evas_object_image_source_set(proxy, img);
evas_object_resize(proxy, w * 2, h / 3);
evas_object_image_fill_set(proxy, 0, 0, w * 2, h /3 );
evas_object_move(proxy, 420, 240);
evas_object_show(proxy);
img = evas_object_image_filled_add(e);
proxy = evas_object_image_filled_add(e);
evas_object_move(img, 500, 300);
evas_object_move(proxy, 600, 300);
evas_object_resize(img, 100, 100);
evas_object_resize(proxy, 100, 100);
evas_object_show(img);
evas_object_show(proxy);
evas_object_image_source_set(img, proxy);
evas_object_image_source_set(proxy, img);
#if 0
label_add(e, 300,90, "Edje File", false);
img = edje_object_add(e);
if (!_edje_load_or_show_error(img, "basic.edj", "proxytest")){
evas_object_del(img);
}
evas_object_resize(img,220,200);
evas_object_move(img,300,100);
evas_object_show(img);
edje_object_size_max_get(img, &maxw, &maxh);
edje_object_size_min_get(img, &minw, &minh);
if ((minw <= 0) && (minh <= 0))
edje_object_size_min_calc(img, &minw, &minh);
evas_object_size_hint_max_set(img, maxw, maxh);
evas_object_size_hint_min_set(img, minw, minh);
evas_object_size_hint_weight_set(img,
EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
evas_object_size_hint_align_set(img, EVAS_HINT_FILL, EVAS_HINT_FILL);
#endif /* The edje file */
return 0;
}
static int
set1(Evas *e){
Evas_Object *img, *proxy, *lbl;
int w,h;
/* create an image,, but don't show */
label_add(e,10,0,"Hidden Source",false);
img = evas_object_image_add(e);
evas_object_image_file_set(img, images[0], NULL);
/* don't do anything that may cause it to load */
w = 96; h = 98;
evas_object_resize(img, w, h);
evas_object_image_fill_set(img, 0, 0, w, h);
evas_object_move(img, 10,10);
label_add(e,w + 90,0,"Proxy",false);
proxy = evas_object_image_filled_add(e);
evas_object_image_source_set(proxy, img);
evas_object_resize(proxy, w, h);
evas_object_image_fill_set(proxy, 0, 0, w, h);
evas_object_move(proxy, w + 90, 10);
evas_object_show(proxy);
/*
* Test a hidden label
*/
label_add(e, 10, 120, "Hidden Text", false);
lbl = label_add(e, 10, 120, "Can't See ME!", false);
evas_object_hide(lbl);
label_add(e, 200, 120, "Proxy Text", false);
w = 200; h = 200;
proxy = evas_object_image_filled_add(e);
evas_object_image_source_set(proxy, lbl);
evas_object_resize(proxy, w, h);
evas_object_image_fill_set(proxy, 0, 0, w, h);
evas_object_move(proxy, 200, 120);
evas_object_show(proxy);
/*
* Invisible text block
*/
img = textblock_add(e, 600, 200);
evas_object_hide(img);
evas_object_geometry_get(img, NULL, NULL, &w, &h);
proxy = evas_object_image_filled_add(e);
evas_object_image_source_set(proxy, img);
evas_object_resize(proxy, w, h);
evas_object_move(proxy, 10, 320);
evas_object_show(proxy);
flip_map(proxy);
/*
* Test an offscreen 'widget'
*/
img = sp_add(e);
evas_object_move(img, -300,200);
evas_object_resize(img, 100, 20);
ecore_timer_add(0.05, smart_animate, img);
w = 100;
h = 20;
proxy = evas_object_image_filled_add(e);
evas_object_image_source_set(proxy, img);
evas_object_resize(proxy, w, h);
evas_object_move(proxy, 300, 300);
evas_object_show(proxy);
flip_map(proxy);
return 0;
}
void MedeaSpAgentObserver::selectRankProp()
{
if(_wm->_genomesList.size() != 0)
{
int idBest = 0;
if(_wm->_genomesList.size() == 1)
{
idBest = (*_wm->_genomesList.begin()).first;
}
else
{
double minimumExpected = MedeaSpSharedData::gMinimumExpectedValue;
double maximumExpected = MedeaSpSharedData::gMaximumExpectedValue;
//reverse the map to sort by fitness. Will put lowest first
std::multimap<double,int> sortedFitness = flip_map(_wm->_fitnessList);
std::map<int, double> f;
int rank = 0;
for (std::multimap<double, int >::iterator it = sortedFitness.begin(); it != sortedFitness.end() ; it++)
{
f[(*it).second] = ( maximumExpected - (maximumExpected - minimumExpected) * (rank / ( (double)_wm->_fitnessList.size() - 1.0) )) / (double)_wm->_fitnessList.size() ;
rank ++;
}
double sum1 = 0.0;
for( std::map<int, double>::iterator it = f.begin() ; it != f.end() ; it ++)
{
sum1 += f[(*it).first];
}
double sum2 = 0.0;
std::map<int, double> p;
for( std::map<int, double>::iterator it = f.begin() ; it != f.end() ; it ++)
{
if (f[(*it).first] > 0.0)
{
sum2 += f[(*it).first];
p[(*it).first] = sum2/sum1;
}
}
double r = ranf();
//Proportional selection
std::map<int, double >::iterator it = p.begin() ;
while( (r > p[(*it).first]) && (it != p.end()))
{
it ++;
}
idBest = (*it).first ;
_wm->_currentGenome =_wm->_genomesList[idBest];
if ( MedeaSpSharedData::gDynamicSigma == true )
{
mutateWithBouncingBounds(_wm->_sigmaList[idBest]);
}
else
{
mutateWithBouncingBounds(-1.00);
}
_wm->setNewGenomeStatus(true);
_wm->setFatherId(idBest);
//gLogFile << gWorld->getIterations() << " : " << _wm->_agentId + 1000 * _wm->getDateOfBirth() << " take " << _wm->getFatherId()<<std::endl;
if (_wm->_agentId == 1 && gVerbose) // debug
std::cout << " Sigma is " << _wm->_sigmaList[idBest] << "." << std::endl;
_wm->_genomesList.clear();
_wm->_fitnessList.clear();
}
}
}
