void CLexiconReadWindow::initActions() { qDebug() << "CLexiconReadWindow::initActions"; BtActionCollection* ac = actionCollection(); CReadWindow::initActions(); CLexiconReadWindow::insertKeyboardActions(ac); m_actions.backInHistory = dynamic_cast<BtToolBarPopupAction*>( ac->action(CResMgr::displaywindows::general::backInHistory::actionName) ); Q_ASSERT(m_actions.backInHistory); addAction(m_actions.backInHistory); m_actions.forwardInHistory = dynamic_cast<BtToolBarPopupAction*>( ac->action(CResMgr::displaywindows::general::forwardInHistory::actionName) ); Q_ASSERT(m_actions.forwardInHistory); addAction(m_actions.forwardInHistory); QAction* qaction; qaction = ac->action("nextEntry"); QObject::connect(qaction, SIGNAL(triggered()), this, SLOT( nextEntry() ) ); addAction(qaction); qaction = ac->action("previousEntry"); QObject::connect(qaction, SIGNAL(triggered()), this, SLOT( previousEntry() ) ); addAction(qaction); m_actions.selectAll = ac->action("selectAll"); Q_ASSERT(m_actions.selectAll); m_actions.findText = ac->action("findText"); Q_ASSERT(m_actions.findText); m_actions.findStrongs = ac->action(CResMgr::displaywindows::general::findStrongs::actionName); QObject::connect(m_actions.findStrongs, SIGNAL(triggered()), this, SLOT(openSearchStrongsDialog()) ); addAction(m_actions.findStrongs); m_actions.copy.reference = ac->action("copyReferenceOnly"); QObject::connect(m_actions.copy.reference, SIGNAL(triggered()), displayWidget()->connectionsProxy(), SLOT(copyAnchorOnly()) ); addAction(m_actions.copy.reference); m_actions.copy.entry = ac->action("copyEntryWithText"); QObject::connect(m_actions.copy.entry, SIGNAL(triggered()), displayWidget()->connectionsProxy(), SLOT(copyAll()) ); addAction(m_actions.copy.entry); Q_ASSERT(ac->action("copySelectedText")); m_actions.copy.selectedText = ac->action("copySelectedText"); m_actions.save.entryAsPlain = new QAction(tr("Entry as plain text"), ac ); QObject::connect(m_actions.save.entryAsPlain, SIGNAL(triggered()), this, SLOT(saveAsPlain()) ); addAction(m_actions.save.entryAsPlain); m_actions.save.entryAsHTML = ac->action("saveHtml"); QObject::connect(m_actions.save.entryAsHTML, SIGNAL(triggered()), this, SLOT(saveAsHTML())); addAction(m_actions.save.entryAsHTML); m_actions.print.reference = ac->action("printReferenceOnly"); QObject::connect(m_actions.print.reference, SIGNAL(triggered()), this, SLOT(printAnchorWithText())); addAction(m_actions.print.reference); m_actions.print.entry = ac->action("printEntryWithText"); QObject::connect(m_actions.print.entry, SIGNAL(triggered()), this, SLOT(printAll())); addAction(m_actions.print.entry); // init with the user defined settings qDebug() << "call CBTConfig::setupAccelSettings(CBTConfig::lexiconWindow, ac); and end CLexiconReadWindow::initActions"; CBTConfig::setupAccelSettings(CBTConfig::lexiconWindow, ac); }
void withoutReplacementImpl(withoutReplacementArgs& args) { boost::numeric::ublas::matrix<double>& matrix = args.matrix; int n = args.n; int seed = args.seed; double alpha = args.alpha; if(matrix.size1() != matrix.size2()) { throw std::runtime_error("Matrix must be square"); } if(n < 1) { throw std::runtime_error("Input n must be at least 1"); } int dimension = matrix.size1(); boost::mt19937 randomSource; randomSource.seed(seed); std::vector<double> columnSums(dimension,0); for(int row = 0; row < dimension; row++) { for(int column = 0; column < dimension; column++) { columnSums[column] += std::fabs(matrix(row, column)); } } std::vector<double> currentColumnSums(dimension), newCurrentColumnSums; std::vector<int> availableColumns(dimension), newAvailableColumns; std::vector<int> availableRows(dimension), newAvailableRows; std::vector<int> previousEntry(1), newPreviousEntry; std::vector<bool> usedRows(dimension), newUsedRows; std::vector<mpfr_class> weights(1, 1), newWeights; //Get out the choices at the start. std::vector<possibility> possibilities; for(int i = 0; i < dimension; i++) { for(int j = 0; j < dimension; j++) { possibility nextPos; nextPos.parent = 0; nextPos.previousEntry = i; nextPos.newEntry = j; possibilities.push_back(nextPos); } } //These choices are all derived from a single particle at the start std::copy(columnSums.begin(), columnSums.end(), currentColumnSums.begin()); for(int i = 0; i < dimension; i++) { availableColumns[i] = i; availableRows[i] = i; } std::fill(usedRows.begin(), usedRows.end(), false); sampling::sampfordFromParetoNaiveArgs samplingArgs; samplingArgs.n = n; samplingArgs.weights.resize(dimension*dimension); for(int i = 0; i < (int)possibilities.size(); i++) { possibility& pos = possibilities[i]; if(pos.previousEntry == pos.newEntry) { samplingArgs.weights[i] = alpha * std::fabs(matrix(pos.previousEntry, pos.newEntry)) / (dimension*(dimension - 1)); } else { samplingArgs.weights[i] = std::fabs(matrix(pos.previousEntry, pos.newEntry)) / dimension; } } int currentSamples = 1; for(int permutationCounter = 0; permutationCounter < dimension; permutationCounter++) { //Draw sample if((int)possibilities.size() <= n) { newCurrentColumnSums.resize(possibilities.size()*dimension); newAvailableColumns.resize(possibilities.size()*(dimension - permutationCounter-1)); newAvailableRows.resize(possibilities.size()*(dimension - permutationCounter-1)); newUsedRows.resize(possibilities.size()*dimension); newPreviousEntry.resize(possibilities.size()); int newAvailableColumnsIndex = 0; int newAvailableRowsIndex = 0; for(int i = 0; i < (int)possibilities.size(); i++) { possibility& pos = possibilities[i]; std::copy(currentColumnSums.begin() + pos.parent * dimension, currentColumnSums.begin() + (pos.parent + 1) * dimension, newCurrentColumnSums.begin() + dimension * i); newCurrentColumnSums[dimension*i + pos.newEntry] -= std::fabs(matrix(pos.previousEntry, pos.newEntry)); std::copy(usedRows.begin() + pos.parent*dimension, usedRows.begin() + (pos.parent + 1) * dimension, newUsedRows.begin() + dimension*i); newUsedRows[dimension*i + pos.previousEntry] = true; for(int j = 0; j < dimension - permutationCounter; j++) { if(availableColumns[j + pos.parent*(dimension - permutationCounter)] != pos.newEntry) { newAvailableColumns.at(newAvailableColumnsIndex) = availableColumns.at(j + pos.parent*(dimension - permutationCounter)); newAvailableColumnsIndex++; } if(availableRows[j + pos.parent*(dimension - permutationCounter)] != pos.previousEntry) { newAvailableRows.at(newAvailableRowsIndex) = availableRows.at(j + pos.parent*(dimension - permutationCounter)); newAvailableRowsIndex++; } } if(newUsedRows[i*dimension + pos.newEntry]) { newPreviousEntry[i] = -1; } else { newPreviousEntry[i] = pos.newEntry; } } newWeights.swap(samplingArgs.weights); currentSamples = possibilities.size(); } else { sampfordFromParetoNaive(samplingArgs, randomSource); newCurrentColumnSums.resize(n*dimension); newAvailableColumns.resize(n*(dimension - permutationCounter-1)); newAvailableRows.resize(n*(dimension - permutationCounter-1)); newUsedRows.resize(n*dimension); newWeights.resize(n); newPreviousEntry.resize(n); int newAvailableColumnsIndex = 0; int newAvailableRowsIndex = 0; for(int i = 0; i < n; i++) { possibility& pos = possibilities[samplingArgs.indices[i]]; std::copy(currentColumnSums.begin() + pos.parent * dimension, currentColumnSums.begin() + (pos.parent + 1) * dimension, newCurrentColumnSums.begin() + dimension * i); newCurrentColumnSums[dimension*i + pos.newEntry] -= std::fabs(matrix(pos.previousEntry, pos.newEntry)); std::copy(usedRows.begin() + pos.parent*dimension, usedRows.begin() + (pos.parent + 1) * dimension, newUsedRows.begin() + dimension*i); newUsedRows[dimension*i + pos.previousEntry] = true; for(int j = 0; j < dimension - permutationCounter; j++) { if(availableColumns[j + pos.parent*(dimension - permutationCounter)] != pos.newEntry) { newAvailableColumns.at(newAvailableColumnsIndex) = availableColumns.at(j + pos.parent*(dimension - permutationCounter)); newAvailableColumnsIndex++; } if(availableRows[j + pos.parent*(dimension - permutationCounter)] != pos.previousEntry) { newAvailableRows.at(newAvailableRowsIndex) = availableRows.at(j + pos.parent*(dimension - permutationCounter)); newAvailableRowsIndex++; } } if(newUsedRows[i*dimension + pos.newEntry]) { newPreviousEntry[i] = -1; } else { newPreviousEntry[i] = pos.newEntry; } newWeights[i] = samplingArgs.weights[samplingArgs.indices[i]] / samplingArgs.rescaledWeights[samplingArgs.indices[i]]; } currentSamples = n; } previousEntry.swap(newPreviousEntry); currentColumnSums.swap(newCurrentColumnSums); availableColumns.swap(newAvailableColumns); availableRows.swap(newAvailableRows); usedRows.swap(newUsedRows); weights.swap(newWeights); //If we're not at the end, get out the list of possibilities and also weights if(permutationCounter != dimension - 1) { possibilities.clear(); samplingArgs.weights.clear(); for(int i = 0; i < currentSamples; i++) { if(previousEntry[i] == -1) { for(int j = 0; j < dimension - permutationCounter - 1; j++) { for(int k = 0; k < dimension - permutationCounter - 1; k++) { possibility pos; pos.parent = i; pos.previousEntry = availableRows[(dimension - permutationCounter - 1) * i + j]; pos.newEntry = availableColumns[(dimension - permutationCounter - 1) * i + k]; possibilities.push_back(pos); if(j == k || usedRows[pos.newEntry + dimension * i]) { if(dimension - 2 != permutationCounter) { samplingArgs.weights.push_back(weights[i] * alpha * std::fabs(matrix(pos.previousEntry, pos.newEntry))/ (dimension - permutationCounter - 2)); } else { samplingArgs.weights.push_back(weights[i] * alpha * std::fabs(matrix(pos.previousEntry, pos.newEntry))); } } else { samplingArgs.weights.push_back(weights[i] * std::fabs(matrix(pos.previousEntry, pos.newEntry))); } } } } else { for(int j = 0; j < dimension - permutationCounter - 1; j++) { possibility pos; pos.parent = i; pos.previousEntry = previousEntry[i]; pos.newEntry = availableColumns[(dimension - permutationCounter - 1) * i + j]; possibilities.push_back(pos); if(j == previousEntry[i] || usedRows[pos.newEntry + dimension * i]) { if(dimension - 2 != permutationCounter) { samplingArgs.weights.push_back(weights[i] * alpha * std::fabs(matrix(pos.previousEntry, pos.newEntry)) / (dimension - permutationCounter - 2)); } else { samplingArgs.weights.push_back(weights[i] * alpha * std::fabs(matrix(pos.previousEntry, pos.newEntry))); } } else { samplingArgs.weights.push_back(weights[i] * std::fabs(matrix(pos.previousEntry, pos.newEntry))); } } } } } } args.estimate = 0; for(int i = 0; i < (int)weights.size(); i++) { args.estimate += weights[i]; } }
void CLexiconReadWindow::initActions() { qDebug("CLexiconReadWindow::initActions"); KActionCollection* ac = actionCollection(); CLexiconReadWindow::insertKeyboardActions(ac); CReadWindow::initActions(); m_actions.backInHistory = dynamic_cast<KToolBarPopupAction*>( ac->action(CResMgr::displaywindows::general::backInHistory::actionName) ); Q_ASSERT(m_actions.backInHistory); m_actions.forwardInHistory = dynamic_cast<KToolBarPopupAction*>( ac->action(CResMgr::displaywindows::general::forwardInHistory::actionName) ); Q_ASSERT(m_actions.forwardInHistory); KAction* kaction; kaction = new KAction(tr("Next entry"), ac ); kaction->setShortcut( CResMgr::displaywindows::lexiconWindow::nextEntry::accel); QObject::connect(kaction, SIGNAL(triggered()), this, SLOT( nextEntry() ) ); ac->addAction("nextEntry", kaction); kaction = new KAction(tr("Previous entry"), ac ); kaction->setShortcut( CResMgr::displaywindows::lexiconWindow::previousEntry::accel); QObject::connect(kaction, SIGNAL(triggered()), this, SLOT( previousEntry() ) ); ac->addAction("previousEntry", kaction); m_actions.selectAll = qobject_cast<KAction*>(ac->action("selectAll")); //TODO: Q_ASSERT(m_actions.selectAll); m_actions.findText = qobject_cast<KAction*>(ac->action("findText")); //TODO: Q_ASSERT(m_actions.findText); m_actions.findStrongs = new KAction( KIcon(CResMgr::displaywindows::general::findStrongs::icon), tr("Strong's Search"), ac ); m_actions.findStrongs->setShortcut(CResMgr::displaywindows::general::findStrongs::accel); QObject::connect(m_actions.findStrongs, SIGNAL(triggered()), this, SLOT(openSearchStrongsDialog()) ); ac->addAction(CResMgr::displaywindows::general::findStrongs::actionName, m_actions.findStrongs); m_actions.copy.reference = new KAction(tr("Reference only"), ac ); QObject::connect(m_actions.copy.reference, SIGNAL(triggered()), displayWidget()->connectionsProxy(), SLOT(copyAnchorOnly()) ); ac->addAction("copyReferenceOnly", m_actions.copy.reference); m_actions.copy.entry = new KAction(tr("Entry with text"), ac ); QObject::connect(m_actions.copy.entry, SIGNAL(triggered()), displayWidget()->connectionsProxy(), SLOT(copyAll()) ); ac->addAction("copyEntryWithText", m_actions.copy.entry); Q_ASSERT(ac->action("copySelectedText")); m_actions.copy.selectedText = qobject_cast<KAction*>(ac->action("copySelectedText")); m_actions.save.entryAsPlain = new KAction(tr("Entry as plain text"), ac ); QObject::connect(m_actions.save.entryAsPlain, SIGNAL(triggered()), this, SLOT(saveAsPlain()) ); ac->addAction("saveEntryAsPlain", m_actions.save.entryAsPlain); m_actions.save.entryAsHTML = new KAction(tr("Entry as HTML"), ac ); QObject::connect(m_actions.save.entryAsHTML, SIGNAL(triggered()), this, SLOT(saveAsHTML())); ac->addAction("saveEntryAsHTML", m_actions.save.entryAsHTML); m_actions.print.reference = new KAction(tr("Reference only"), ac); QObject::connect(m_actions.print.reference, SIGNAL(triggered()), this, SLOT(printAnchorWithText())); ac->addAction("printReferenceOnly", m_actions.print.reference); m_actions.print.entry = new KAction(tr("Entry with text"), ac); QObject::connect(m_actions.print.entry, SIGNAL(triggered()), this, SLOT(printAll())); ac->addAction("printEntryWithText", m_actions.print.entry); // init with the user defined settings qDebug("call CBTConfig::setupAccelSettings(CBTConfig::lexiconWindow, ac); and end CLexiconReadWindow::initActions"); CBTConfig::setupAccelSettings(CBTConfig::lexiconWindow, ac); };