void training_text_map::refreshTrainingMap(QString inputString) {
QString punctuation = ",.?<>:;\"'!@#$%^&()-_\t\r";
for(int i = 0; i < punctuation.size(); i++)
inputString.replace(punctuation.at(i)," ");
inputString.replace("\n"," ");
inputString.simplified();
QStringList tokens = inputString.split(' ',QString::SkipEmptyParts);
for(int i = 0; i < tokens.size(); i++){
QString token = tokens.at(i);
if( !trainingMap.contains(token) ){
trainingMap[token].first = 1;
trainingMap[token].second = calculateFrequency(trainingMap[token].first, tokens.size());
}
else{
trainingMap[token].first = trainingMap[token].first + 1;
trainingMap[token].second = calculateFrequency(trainingMap[token].first, tokens.size());
}
}
size = trainingMap.size();
}
/**
* if the new read left-most position @param pos is in the second vector (this->vector2),
* that means the first vector (this->vector1) is no longer in use.
* so we can swap them
*/
void DepthCounter::beginNewRead(const uint64_t& pos){
#ifdef _DEBUG_DEPTHCOUNTER_
fprintf(stderr, "beginNewRead at %lu\n", pos);
#endif
if (pos >= this->vector2->getStart() + this->vector2->getLen()){
calculateFrequency(this->vector1);
calculateFrequency(this->vector2);
this->vector1->setStart(pos);
this->vector2->setStart(pos + this->vector1->getLen());
this->vector1->clear();
this->vector2->clear();
} else if (pos >= this->vector2->getStart()){
swapVector();
} else {
//assert(pos >= this->vector1->getStart());
if (pos >= this->vector1->getStart()) {
} else {
fprintf(stderr, "WARNING: Rewind distVec - this means your input files may not be sorted.\n");
calculateFrequency(this->vector1);
calculateFrequency(this->vector2);
this->vector1->setStart(pos);
this->vector2->setStart(pos + this->vector1->getLen());
this->vector1->clear();
this->vector2->clear();
}
};
};
void SceneGame::loadGame() {
savedGameDB->exe("SELECT * FROM savedGame");
if(savedGameDB->vdata.size() == 0) {
// start a new game
newGame();
} else {
// load the game
strcpy(plaintext, savedGameDB->vdata[0].c_str());
strcpy(ciphertext, savedGameDB->vdata[1].c_str());
strcpy(key, savedGameDB->vdata[2].c_str());
strcpy(inverseKey, savedGameDB->vdata[3].c_str());
strcpy(answerKey, savedGameDB->vdata[4].c_str());
strcpy(inverseAnswerKey, savedGameDB->vdata[5].c_str());
time = atoi(savedGameDB->vdata[6].c_str());
// if the key so far is blank, reset the time to 0
if(strcmp(inverseAnswerKey, "__________________________") == 0) {
time = 0;
GameTimeLabel* timeLabel = (GameTimeLabel*)this->getChildByTag(SceneGameTagTimeLabel);
if(timeLabel != NULL) {
timeLabel->min = 0;
timeLabel->sec = 0;
}
}
IGLog("game loaded");
}
// do frequency analysis
calculateFrequency();
}
void decifrar(char * mensagem, char * resultado) {
int i, minDev, minI, dev;
char order[26]; //vetor para a sequencia de frequencia
int freq[26]; //vetor para a quantidade de cada letra
char *temp = malloc((strlen(mensagem) + 1) * sizeof(char));
//testar todas as possibilidades
for (i = 0; i < 26; i++) {
//decifrar usando a chave atual
transform(mensagem, temp, i);
//calcular a frequencia de letras
calculateFrequency(temp, order, freq);
//calcular o desvio com relação à distribuição esperada
dev = abs(getDeviation(order, freq));
if (!i || (dev < minDev && isValid(temp))) {
//armazenar o menor desvio
minDev = dev;
minI = i;
}
if (!minDev) {
//se a distancia for zero não é necessário
//continuar a verificação
break;
}
}
free(temp);
//usando o menor desvio, traduza a mensagem
transform(mensagem, resultado, minI);
}
void Widget::on_chkP1V_clicked()
{
if(ui->chkP1V->isChecked()){
GenerateSINEPattern(0.2);
ISPIMemory->accessSPIRAM(DRIVERAM);
ISPIMemory->setAutoIncrement();
ISPIMemory->writeAppCardSRAM(0,100,&mValues[0]);
usleep(1000);
IAppCard->setDDSWaveSelect(RAM_DATA);
RAMACCESS pRAMSelect;
pRAMSelect.m_bDRAMMODE=true;
pRAMSelect.m_bRRAM1MODE=true;
IAppCard->setRAMModeAccess(pRAMSelect);
IAppCard->setDriveRAMStarAddress(0);
IAppCard->setDriveRAMEndAddress(0x63);
calculateFrequency();
IAppCard->setDrivePatternCount(false,0);
IAppCard->startDrive(1);
usleep(1000);
IAppCard->setDrivePatternCount(true,0);
IAppCard->startDrive(1);
// IAppCard->writeRegister(0,0x82);
// IAppCard->writeRegister(0x63,0x84);
//IAppCard->writeRegister(0x3,0x86);
}
}
void Widget::receiveValue(double pValue){
if(m_nLineEditIndex==3){
objForceVoltage->setText(QString::number(pValue,'f',5));
m_nForceVoltage = pValue;
}
else if(m_nLineEditIndex==4){
objFrequency->setText(QString::number(pValue,'f',5));
m_nFrequency= pValue;
if(ui->chkDDSFreq->isChecked())
{
//m_nFrequency= validateFrequency(pValue);
calculateDDSFrequency();
}
else
{
calculateFrequency();
}
}
else if(m_nLineEditIndex==5){
objAverageSamples->setText(QString::number(pValue,'f',5));
m_nAVGSamples=pValue;
}
}
void
calculate_click_cb(GtkWidget* widget, gpointer data)
{
for(int i=0; i<file_info->frames; i++) {
p_pos[i] = snd_data[i];
}
int start = (int) gtk_adjustment_get_value(scroll_adj);
calculateFrequency(snd_data+start, start, 2048);
gtk_widget_queue_draw(drawing_area);
}
/**
* @return frequency table
* by default: freq from 0 - 254 is counted
* this should be called at last
*/
void DepthCounter::swapVector() {
// store the data in vector1
calculateFrequency(this->vector1);
// swap both vectors
this->vector1->setStart(this->vector2->getStart() + this->vector2->getLen());
this->vector1->clear();
DepthVector* tmp = this->vector2;
this->vector2 = this->vector1;
this->vector1 = tmp;
};
void ActivationFrequencyCalculator::eventOccured(Event *event) {
if(event == 0) {
return;
}
else if(event == mNetworksUpdatedEvent) {
calculateFrequency();
}
else if(event == mNetworksModifiedEvent || event == mNetworksReplacedEvent) {
updateNetworkConnection();
}
}
int main(int argc,char **argv) {
int selection; // Komut satırı argümanlarını kontrol etmek için kullanılır.
char *filename = NULL; // Kaynak dosya olarak verilen dosya isimlerini tutar.
char *target = NULL; // Hedef olarak verilen dosya isimlerini tutar.
int posibiltyFlag = 0; // Frekans hesaplaması yapılacağında bu bayrak 1 değerini alır.
int encodingFlag = 0; // Encode işlemi yapılacağında bu bayrak 1 değerini alır.
int decodingFlag = 0; // Decode işlemi yapılacağında bu bayrak 1 değerini laır.
int counterList[MAXINDEX]; // ASCII tablosu indis olarak kabul edilirse kaynak dosyadaki tüm karakterlerin kaç defa tekrarlandığını tutar.
int totalCharacterCount = 0; // Kaynak dosyadaki toplam karakter sayısını tutar.
HASH **hashTable; // Kod tablosunun tutar.
int hashTableLength = 0; // Kod tablosunun uzunluğunu tutar.
char *huffmanTree= NULL; // huffman.txt 'den okunan huffman ikili ağacının tutar.
int huffmanTreeLength = 0; // huffman.txt 'den okunan huffman ikili ağacının uzunluğunu tutar.
int encodedBitCount = 0; // Encode işlemi sırasında kaç bitin encode edildiğini tutar.
for(register int i=0; i<MAXINDEX; i++)
{
counterList[i] = 0;
}
opterr = 0;
while( (selection = getopt(argc, argv, "pef:t:d:")) != -1 )
{
switch (selection) {
case 'f':
filename = optarg;
break;
case 'p':
posibiltyFlag = 1;
break;
case 'e':
encodingFlag = 1;
break;
case 't':
target = optarg;
break;
case 'd':
encodedBitCount = atoi(optarg);
printf("\n%d\n",encodedBitCount);
decodingFlag = 1;
break;
default:
printf("Eksik veya hatalı bir argüman girildi!");
exit(EXIT_FAILURE);
}
}
// Yapılacak her işlem için kaynak dosyaya ihtiyaç vardır.
if(!filename)
{
printf("You have to enter a filename. Ex -f filename.txt");
exit(EXIT_FAILURE);
}
// Yapılacak her işlem için hedef dosyaya ihtiyaç vardır.
if(!target)
{
printf("You have to enter a target filename. Ex -t target.txt");
exit(EXIT_FAILURE);
}
if(posibiltyFlag)
{
totalCharacterCount = calculateFrequency(counterList,filename);
FILE *frequencyFp = fopen(target,"w");
for(register int i=0; i<MAXINDEX; i++)
{
if(counterList[i]){
#if DEBUG == 1
printf("\n %c -> %.2lf\n",i, (double)counterList[i]/ totalCharacterCount );
fprintf(frequencyFp, "\n %c -> %.2lf",i, (double)counterList[i]/ totalCharacterCount);
#endif
}
}
fclose(frequencyFp);
}
if(encodingFlag)
{
huffmanTree = readHuffmanTree(&huffmanTreeLength);
hashTable = createHashTable(&hashTableLength, huffmanTree, huffmanTreeLength);
#if DEBUG == 1
printf("\n---------------Hash Tablosu-------------------\n");
for(register int i=0; i<hashTableLength;i++)
{
printf("\nKarakter: %c\t\tKod: %s\n", hashTable[i]->letter, hashTable[i]->code);
}
printf("\n---------------Hash Tablosu-------------------\n");
#endif
encodedBitCount = encodeFile(filename, target, hashTable, hashTableLength);
#if DEBUG == 1
printf("\n\n");
printf("\t\t Şifrelenen bit sayısı : %d", encodedBitCount);
printf("\n\n");
#endif
}
if(decodingFlag)
{
huffmanTree = readHuffmanTree(&huffmanTreeLength);
hashTable = createHashTable(&hashTableLength, huffmanTree, huffmanTreeLength);
#if DEBUG == 1
printf("\n---------------Hash Tablosu-------------------\n");
for(register int i=0; i<hashTableLength;i++)
{
printf("\nKarakter: %c\t\tKod: %s\n", hashTable[i]->letter, hashTable[i]->code);
}
printf("\n---------------Hash Tablosu-------------------\n");
#endif
decodeFile(filename, target, hashTable, hashTableLength,encodedBitCount);
}
return EXIT_SUCCESS;
}
