const Vector<T> TriDiagonalMatrix<T>::getColumn(const int column) const
{
if(column < 0 || column >= numColumns())
{
throw std::invalid_argument("Column number is invalid");
}
Vector<T> columnVector(numColumns());
for(int i = 0; i < columnVector.numTerms(); i++)
{
columnVector[i] = 0;
}
if(column == 0)
{
columnVector[0] = data[1][column];
columnVector[1] = data[0][column];
}
else if(column == numColumns() - 1)
{
columnVector[column - 1] = data[2][column - 1];
columnVector[column] = data[1][column];
}
else
{
columnVector[column - 1] = data[2][column - 1];
columnVector[column] = data[1][column];
columnVector[column + 1] = data[0][column];
}
return columnVector;
}
void PlotMatrix::alignScaleBorder( int rowOrColumn, int axis )
{
int startDist = 0;
int endDist = 0;
if ( axis == QwtPlot::yLeft )
{
QwtPlot *p = plotAt( rowOrColumn, 0 );
if ( p )
p->axisWidget( axis )->getBorderDistHint( startDist, endDist );
for ( int col = 1; col < numColumns(); col++ )
{
QwtPlot *p = plotAt( rowOrColumn, col );
if ( p )
p->axisWidget( axis )->setMinBorderDist( startDist, endDist );
}
}
else if ( axis == QwtPlot::yRight )
{
QwtPlot *p = plotAt( rowOrColumn, numColumns() - 1 );
if ( p )
p->axisWidget( axis )->getBorderDistHint( startDist, endDist );
for ( int col = 0; col < numColumns() - 1; col++ )
{
QwtPlot *p = plotAt( rowOrColumn, col );
if ( p )
p->axisWidget( axis )->setMinBorderDist( startDist, endDist );
}
}
if ( axis == QwtPlot::xTop )
{
QwtPlot *p = plotAt( rowOrColumn, 0 );
if ( p )
p->axisWidget( axis )->getBorderDistHint( startDist, endDist );
for ( int row = 1; row < numRows(); row++ )
{
QwtPlot *p = plotAt( row, rowOrColumn );
if ( p )
p->axisWidget( axis )->setMinBorderDist( startDist, endDist );
}
}
else if ( axis == QwtPlot::xBottom )
{
QwtPlot *p = plotAt( numRows() - 1, rowOrColumn );
if ( p )
p->axisWidget( axis )->getBorderDistHint( startDist, endDist );
for ( int row = 0; row < numRows() - 1; row++ )
{
QwtPlot *p = plotAt( row, rowOrColumn );
if ( p )
p->axisWidget( axis )->setMinBorderDist( startDist, endDist );
}
}
}
void SimpleTable::addRow( const std::vector<double>& row) {
if (row.size() == numColumns()) {
for (size_t colIndex = 0; colIndex < numColumns(); colIndex++) {
auto& col = getColumn( colIndex );
col.addValue( row[colIndex] );
}
} else
throw std::invalid_argument("Size mismatch");
}
void PlotMatrix::updateLayout()
{
for ( int row = 0; row < numRows(); row++ )
{
for ( int col = 0; col < numColumns(); col++ )
{
QwtPlot *p = plot( row, col );
if ( p )
{
bool showAxis[QwtPlot::axisCnt];
showAxis[QwtPlot::xBottom] =
axisEnabled( QwtPlot::xBottom ) && row == numRows() - 1;
showAxis[QwtPlot::xTop] =
axisEnabled( QwtPlot::xTop ) && row == 0;
showAxis[QwtPlot::yLeft] =
axisEnabled( QwtPlot::yLeft ) && col == 0;
showAxis[QwtPlot::yRight] =
axisEnabled( QwtPlot::yRight ) && col == numColumns() - 1;
for ( int axis = 0; axis < QwtPlot::axisCnt; axis++ )
{
if ( axis == QwtPlot::xBottom || axis == QwtPlot::xTop )
p->enableAxis( axis, showAxis[axis] );
else
{
p->enableAxis( axis, true );
QwtScaleDraw *sd = p->axisScaleDraw( axis );
sd->enableComponent(
QwtScaleDraw::Backbone, showAxis[axis] );
sd->enableComponent(
QwtScaleDraw::Ticks, showAxis[axis] );
sd->enableComponent(
QwtScaleDraw::Labels, showAxis[axis] );
}
}
}
}
}
for ( int col = 0; col < numColumns(); col++ )
{
alignVAxes( col, QwtPlot::yLeft );
alignVAxes( col, QwtPlot::yRight );
}
for ( int row = 0; row < numRows(); row++ )
{
for ( int col = 0; col < numColumns(); col++ )
{
QwtPlot *p = plot( row, col );
if ( p )
p->replot();
}
}
}
void PlotMatrix::updateLayout()
{
for ( int row = 0; row < numRows(); row++ )
{
for ( int col = 0; col < numColumns(); col++ )
{
QwtPlot *p = plotAt( row, col );
if ( p )
{
bool showAxis[QwtPlot::axisCnt];
showAxis[QwtPlot::xBottom] =
axisEnabled( QwtPlot::xBottom ) && row == numRows() - 1;
showAxis[QwtPlot::xTop] =
axisEnabled( QwtPlot::xTop ) && row == 0;
showAxis[QwtPlot::yLeft] =
axisEnabled( QwtPlot::yLeft ) && col == 0;
showAxis[QwtPlot::yRight] =
axisEnabled( QwtPlot::yRight ) && col == numColumns() - 1;
for ( int axis = 0; axis < QwtPlot::axisCnt; axis++ )
{
enablePlotAxis( p, axis, showAxis[axis] );
}
}
}
}
for ( int row = 0; row < numRows(); row++ )
{
alignAxes( row, QwtPlot::xTop );
alignAxes( row, QwtPlot::xBottom );
alignScaleBorder( row, QwtPlot::yLeft );
alignScaleBorder( row, QwtPlot::yRight );
}
for ( int col = 0; col < numColumns(); col++ )
{
alignAxes( col, QwtPlot::yLeft );
alignAxes( col, QwtPlot::yRight );
alignScaleBorder( col, QwtPlot::xBottom );
alignScaleBorder( col, QwtPlot::xTop );
}
for ( int row = 0; row < numRows(); row++ )
{
for ( int col = 0; col < numColumns(); col++ )
{
QwtPlot *p = plotAt( row, col );
if ( p )
p->replot();
}
}
}
void SMat<CoeffRing>::addInPlace(const SMat<CoeffRing> &B)
// return this + B. return NULL of sizes or types do not match.
{
assert(&B.ring() == &ring());
assert(B.numRows() == numRows());
assert(B.numColumns() == numColumns());
for (size_t c = 0; c < numColumns(); c++)
{
sparsevec *v = vec_copy(B.columns_[c]);
vec_add_to(columns_[c], v);
}
}
bool SMat<CoeffRing>::is_equal(const SMat &B) const
{
assert(&ring() == &B.ring());
if (B.numRows() != numRows()) return false;
if (B.numColumns() != numColumns()) return false;
for (size_t c = 0; c < numColumns(); c++)
{
sparsevec *v = columns_[c];
sparsevec *w = B.columns_[c];
if (!vec_equals(v, w)) return false;
}
return true;
}
void WTable::printDebug()
{
std::cerr << "Table: "
<< formName() << " " << numRows() << "x" << numColumns()
<< std::endl;
for (int i = 0; i < numRows(); ++i) {
for (int j = 0; j < numColumns(); ++j) {
std::cerr << "(" << i << "," << j << "): "
<< itemAt(i, j).cell << std::endl;
}
}
}
void SMat<CoeffRing>::subtractInPlace(const SMat<CoeffRing> &B)
// this -= B.
// assumption:the assert statements below:
{
assert(&B.ring() == &ring());
assert(B.numRows() == numRows());
assert(B.numColumns() == numColumns());
for (size_t c = 0; c < numColumns(); c++)
{
sparsevec *v = vec_copy(B.columns_[c]);
vec_negate(v);
vec_add_to(columns_[c], v);
}
}
unsigned SparseMatrix::copyCCS(long*& colptr, long*& index, double*& value) const {
unsigned N = numNonZeros();
colptr = (long int*) malloc((numColumns() + 1) * sizeof(long int));
index = (long int*) malloc(N * sizeof(long int));
value = (double*) malloc(N * sizeof(double));
colptr[0] = 0;
for (unsigned i = 0; i < numColumns(); ++i) {
SparseArray col = getColumn(i);
int offset = col.numNonZeros();
col.copy( &(index[colptr[i]]), &(value[colptr[i]]) );
colptr[i+1] = colptr[i] + offset;
}
return N;
}
// ==========================================================================
// MODIFIERS
void Board::setTile(int i, int j, Tile* t) {
assert (i >= 0 && i < numRows());
assert (j >= 0 && j < numColumns());
//assert (t != NULL);
//assert (board[i][j] == NULL);
board[i][j] = t;
}
SparseMatrix SparseMatrix::multiply(const double b) const
{
SparseMatrix c(numRows(), numColumns());
for (unsigned i=0; i<numRows(); ++i)
c.setRow(i, getRow(i) * b);
return c;
}
void WTable::expand(int row, int column, int rowSpan, int columnSpan)
{
int newNumRows = row + rowSpan;
int curNumColumns = numColumns();
int newNumColumns = std::max(curNumColumns, column + columnSpan);
if ((newNumRows > numRows())
|| (newNumColumns > curNumColumns)) {
gridChanged_ = true;
repaint();
for (int row = numRows(); row < newNumRows; ++row) {
rows_.push_back(new WTableRow(this, newNumColumns));
}
if (newNumColumns > curNumColumns) {
for (int row = 0; row < numRows(); ++row) {
WTableRow *tr = rows_[row];
tr->expand(newNumColumns);
}
}
}
//printDebug();
}
void SMat<CoeffRing>::negateInPlace()
// this = -this
{
for (size_t c = 0; c < numColumns(); c++)
for (sparsevec *p = columns_[c]; p != NULL; p = p->next)
ring().negate(p->coeff, p->coeff);
}
int ServerConfig::adjacentScreenIndex(int idx, int deltaColumn, int deltaRow) const
{
if (screens()[idx].isNull())
return -1;
// if we're at the left or right end of the table, don't find results going further left or right
if ((deltaColumn > 0 && (idx+1) % numColumns() == 0)
|| (deltaColumn < 0 && idx % numColumns() == 0))
return -1;
int arrayPos = idx + deltaColumn + deltaRow * numColumns();
if (arrayPos >= screens().size() || arrayPos < 0)
return -1;
return arrayPos;
}
const QwtPlot* PlotMatrix::plot( int row, int column ) const
{
const int index = row * numColumns() + column;
if ( index < d_data->plotWidgets.size() )
return d_data->plotWidgets[index];
return NULL;
}
void fill(T const & value)
{
long nr = numRows(), nc = numColumns();
for (long r = 0; r < nr; ++r)
{
T * scanline = static_cast<T *>(image->getScanLine(r));
std::fill(scanline, scanline + nc, value);
}
}
// create table from single record
void SimpleTable::init(Opm::DeckItemConstPtr deckItem,
const std::vector<std::string> &columnNames)
{
createColumns(columnNames);
if ( (deckItem->size() % numColumns()) != 0)
throw std::runtime_error("Number of columns in the data file is"
"inconsistent with the ones specified");
{
size_t rows = deckItem->size() / numColumns();
for (size_t rowIdx = 0; rowIdx < rows; rowIdx++) {
for (size_t colIdx = 0; colIdx < numColumns(); ++colIdx) {
size_t deckItemIdx = rowIdx*numColumns() + colIdx;
m_columns[colIdx].push_back( deckItem->getSIDouble(deckItemIdx) );
m_valueDefaulted[colIdx].push_back( deckItem->defaultApplied(deckItemIdx) );
}
}
}
}
Vector<T> TriDiagonalMatrix<T>::getRow(int x) const
{
Vector<T> vect(numColumns());
if(x < 0 || x >= rows)
{
throw std::invalid_argument("TriDiagonal [] error: Out of bounds");
}
for(int i = 0; i < numColumns(); i++)
{
vect[i] = 0;
}
int numData = 3, startingDiag = 0, vectStartSpot = x - 1;
if(x == 0)
{
numData = 2;
startingDiag = 1;
vectStartSpot = 0;
}
else if(x == 1)
{
vectStartSpot = 0;
}
else if(x == rows - 1)
{
numData = 2;
startingDiag = 0;
vectStartSpot = columns - 2;
}
vectStartSpot = vectStartSpot < 0 ? 0 : vectStartSpot;
for(int i = 0; i < numData; i++)
{
vect[vectStartSpot] = data[startingDiag][startingDiag == 0 ? x - 1 : x];
startingDiag++;
vectStartSpot++;
}
return vect;
}
void WTable::deleteRow(int row)
{
for (int i = 0; i < numColumns(); ++i)
delete rows_[row]->cells_[i].cell;
delete rows_[row];
rows_.erase(rows_.begin() + row);
gridChanged_ = true;
repaint();
}
DomElement *WTable::createDomElement()
{
//printDebug();
DomElement *table = DomElement::createNew(DomElement::TABLE);
table->setId(this);
DomElement *tbody = DomElement::createNew(DomElement::TBODY);
for (unsigned row = 0; row < (unsigned)numRows(); ++row)
for (unsigned col = 0; col < (unsigned)numColumns(); ++col)
itemAt(row, col).overSpanned = false;
for (unsigned row = 0; row < (unsigned)numRows(); ++row) {
DomElement *tr = DomElement::createNew(DomElement::TR);
tr->setId(rows_[row]);
for (unsigned col = 0; col < (unsigned)numColumns(); ++col) {
WTableRow::TableData& d = itemAt(row, col);
if (!d.overSpanned) {
DomElement *td = d.cell->createSDomElement();
tr->addChild(td);
for (int i = 0; i < d.cell->rowSpan(); ++i)
for (int j = 0; j < d.cell->columnSpan(); ++j)
if (i + j > 0)
itemAt(row + i, col + j).overSpanned = true;
}
}
tbody->addChild(tr);
}
table->addChild(tbody);
updateDom(*table, true);
gridChanged_ = false;
return table;
}
SparseMatrix SparseMatrix::getTranspose() const {
SparseMatrix transpose(numColumns(), numRows());
for (unsigned i=0; i<numRows(); ++i) {
unsigned nnz = _row[i].numNonZeros();
for (unsigned j=0; j<nnz; ++j) {
int index = _row[i].readIndex(j);
double value = _row[i].readValue(j);
transpose._row[index].insert(i, value);
}
}
return transpose;
}
void SimpleTable::init( const DeckItem& deckItem ) {
this->addColumns();
if ( (deckItem.size() % numColumns()) != 0)
throw std::runtime_error("Number of columns in the data file is"
"inconsistent with the ones specified");
size_t rows = deckItem.size() / numColumns();
for (size_t colIdx = 0; colIdx < numColumns(); ++colIdx) {
auto& column = getColumn( colIdx );
for (size_t rowIdx = 0; rowIdx < rows; rowIdx++) {
size_t deckItemIdx = rowIdx*numColumns() + colIdx;
if (deckItem.defaultApplied(deckItemIdx))
column.addDefault( );
else
column.addValue( deckItem.getSIDouble(deckItemIdx) );
}
if (colIdx > 0)
column.applyDefaults(getColumn( 0 ));
}
}
void ServerConfig::init()
{
switchCorners().clear();
screens().clear();
// m_NumSwitchCorners is used as a fixed size array. See Screen::init()
for (int i = 0; i < NumSwitchCorners; i++)
switchCorners() << false;
// There must always be screen objects for each cell in the screens QList. Unused screens
// are identified by having an empty name.
for (int i = 0; i < numColumns() * numRows(); i++)
addScreen(Screen());
}
MainWindow::MainWindow():
PlotMatrix(3, 4)
{
enableAxis(QwtPlot::yLeft);
enableAxis(QwtPlot::yRight);
enableAxis(QwtPlot::xBottom);
for ( int row = 0; row < numRows(); row++ )
{
const double v = qPow(10.0, row);
setAxisScale(QwtPlot::yLeft, row, -v, v);
setAxisScale(QwtPlot::yRight, row, -v, v);
}
for ( int col = 0; col < numColumns(); col++ )
{
const double v = qPow(10.0, col);
setAxisScale(QwtPlot::xBottom, col, -v, v);
setAxisScale(QwtPlot::xTop, col, -v, v);
}
for ( int row = 0; row < numRows(); row++ )
{
for ( int col = 0; col < numColumns(); col++ )
{
QwtPlot *plt = plot(row, col);
plt->setCanvasBackground(QColor(Qt::darkBlue));
QwtPlotGrid *grid = new QwtPlotGrid();
grid->enableXMin(true);
grid->setMajPen(QPen(Qt::white, 0, Qt::DotLine));
grid->setMinPen(QPen(Qt::gray, 0 , Qt::DotLine));
grid->attach(plt);
}
}
}
// ==========================================================================
// PRINTING
void Board::Print() const {
for (int b = 0; b < numRows(); b++) {
for (int i = 0; i < GLOBAL_TILE_SIZE; i++) {
for (int j = 0; j < numColumns(); j++) {
if (board[b][j] != NULL) {
board[b][j]->rotate(board[b][j]->getRotation()).printRow(std::cout,i);
} else {
std::cout << std::string(GLOBAL_TILE_SIZE,' ');
}
}
std::cout << "\n";
}
}
fflush(stdout);
}
void ServerConfig::saveSettings()
{
settings().beginGroup("internalConfig");
settings().remove("");
settings().setValue("numColumns", numColumns());
settings().setValue("numRows", numRows());
settings().setValue("hasHeartbeat", hasHeartbeat());
settings().setValue("heartbeat", heartbeat());
settings().setValue("relativeMouseMoves", relativeMouseMoves());
settings().setValue("screenSaverSync", screenSaverSync());
settings().setValue("win32KeepForeground", win32KeepForeground());
settings().setValue("hasSwitchDelay", hasSwitchDelay());
settings().setValue("switchDelay", switchDelay());
settings().setValue("hasSwitchDoubleTap", hasSwitchDoubleTap());
settings().setValue("switchDoubleTap", switchDoubleTap());
settings().setValue("switchCornerSize", switchCornerSize());
settings().setValue("ignoreAutoConnectClient", ignoreAutoConnectClient());
writeSettings(settings(), switchCorners(), "switchCorner");
settings().beginWriteArray("screens");
for (int i = 0; i < screens().size(); i++)
{
settings().setArrayIndex(i);
screens()[i].saveSettings(settings());
}
settings().endArray();
settings().beginWriteArray("hotkeys");
for (int i = 0; i < hotkeys().size(); i++)
{
settings().setArrayIndex(i);
hotkeys()[i].saveSettings(settings());
}
settings().endArray();
settings().endGroup();
}
sparsevec *column(size_t c)
{
assert(c < numColumns());
return columns_[c];
}
void SMat<CoeffRing>::scalarMultInPlace(const elem &f)
// this = f * this
{
for (size_t c = 0; c < numColumns(); c++) vec_scale(columns_[c], f);
}
void PlotMatrix::scaleDivChanged()
{
if ( d_data->inScaleSync )
return;
d_data->inScaleSync = true;
QwtPlot *plt = NULL;
int axisId = -1;
int rowOrColumn = -1;
// find the changed axis
for ( int row = 0; row < numRows(); row++ )
{
for ( int col = 0; col < numColumns(); col++ )
{
QwtPlot *p = plot( row, col );
if ( p )
{
for ( int axis = 0; axis < QwtPlot::axisCnt; axis++ )
{
if ( p->axisWidget( axis ) == sender() )
{
plt = p;
axisId = axis;
if ( axisId == QwtPlot::xBottom || axisId == QwtPlot::xTop )
rowOrColumn = col;
else
rowOrColumn = row;
}
}
}
}
}
if ( plt )
{
// synchronize the axes
if ( axisId == QwtPlot::xBottom || axisId == QwtPlot::xTop )
{
for ( int row = 0; row < numRows(); row++ )
{
QwtPlot *p = plot( row, rowOrColumn );
if ( p != plt )
p->setAxisScaleDiv( axisId, plt->axisScaleDiv( axisId ) );
}
}
else
{
for ( int col = 0; col < numColumns(); col++ )
{
QwtPlot *p = plot( rowOrColumn, col );
if ( p != plt )
p->setAxisScaleDiv( axisId, plt->axisScaleDiv( axisId ) );
}
}
updateLayout();
}
d_data->inScaleSync = false;
}
