// >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
unsigned int
ListControl::columnIndexAt(const Core::Vector2& p) const
{
unsigned int ret = 0;
for(unsigned i = 0; i < numberOfColumns()-1; ++i)
{
if( (p.x() >= long(columnWidths_[i])) && (p.x() < long(columnWidths_[i+1])) ) break;
ret++;
}
if(ret >= numberOfColumns()) ret = numberOfColumns()-1;
return ret;
}
Vector Matrix::operator*(const Vector &vector) const {
if (vector.isTransposed() && numberOfColumns() != 1) {
throw std::runtime_error("operator*(const Vector &vector): Vector is not transposed correctly");
} else if (numberOfColumns() != vector.getDimension()) {
throw std::runtime_error("operator*(const Vector &vector): Dimensions of matrix and vector do not match");
}
Vector result(numberOfRows(), 0.0);
parallelForNonZeroElementsInRowOrder([&](node i, node j, double value) {
result[i] += value * vector[j];
});
return result;
}
RMatrix& RMatrix::attachRows (const RMatrix& A)
{
//! \todo zcopy_ verwenden
const LongInt n = numberOfColumns();
const LongInt m1 = numberOfRows();
const LongInt m2 = A.numberOfRows();
const LongInt m = m1+m2;
RMatrix temp((*this));
setDimension(m,n);
for(LongInt j=0; j<n; j++)
{
LongInt i;
for(i=0; i<m1; i++)
{
(*this)(i,j) = temp(i,j);
}
for(i=0; i<m2; i++)
{
(*this)(i+m1,j) = A(i,j);
}
}
return (*this);
}
RMatrix& RMatrix::isInverseOf(const AMatrix& s, AMatrix& w)
{
const AMatrixType theMatrixS = s.type();
const AMatrixType theMatrixW = w.type();
if(theMatrixS==isRMatrix && theMatrixW==isRMatrix)
{
const RMatrix& S = (const RMatrix&)s;
const RMatrix& W = (const RMatrix&)w;
(*this) = S;
integer m = numberOfRows();
integer n = numberOfColumns();
integer lda = MAX(1,m);
integer dim = MIN(m,n);
integer info = 0;
integer lwork = m*n;
integer* ipiv = new integer[dim];
// dgetrf (&m, &n, (LongReal*) &_pelm[0], &lda, ipiv, &info);
// dgetri (&m, (LongReal*) &_pelm[0], &lda, ipiv, (LongReal*) &W(0,0), &lwork, &info);
info = TensorCalculus::Lapack<double>::getrf (m, n, &_pelm[0], lda, ipiv);
info = TensorCalculus::Lapack<double>::getri (m, &_pelm[0], lda, ipiv, &W(0,0), lwork);
delete [] ipiv;
}
else
{
throw SimpleException(IString("Warning In RMatrix::isInverseOf(const AMatrix& s, const AMatrix& w), Bad Type!!!"));
}
return (*this);
}
BufferedFTPrinter& BufferedFTPrinter::append(const endl input) {
if (_lines.back() != (int)numberOfColumns() || _lines.back()==0) {
_lines.push_back(0);
_columnFormats.push_back(format::basic);
}
return *this;
}
int CalculationController::indexFromCumulatedWidth(KDCoordinate offsetX) {
int result = 0;
int i = 0;
while (result < offsetX && i < numberOfColumns()) {
result += columnWidth(i++);
}
return (result < offsetX || offsetX == 0) ? i : i - 1;
}
int TableViewDataSource::indexFromCumulatedWidth(KDCoordinate offsetX) {
int result = 0;
int i = 0;
while (result < offsetX && i < numberOfColumns()) {
result += columnWidth(i++);
}
return (result < offsetX || offsetX == 0) ? i : i - 1;
}
double Matrix::operator()(const index &i, const index &j) const {
if (i < 0 || i >= numberOfRows()) {
throw std::out_of_range("Matrix(i,j): Row index out of range");
} else if (j< 0 || j >= numberOfColumns()) {
throw std::out_of_range("Matrix(i,j): Column index out of range");
}
return graph.weight(i,j);
}
RMatrix& RMatrix::addMatrix (const AMatrix& A, const LongInt& rowIndex, const LongInt& colIndex)
{
const AMatrixType theMatrixA = A.type();
LongInt m = numberOfRows();
LongInt n = numberOfColumns();
LongInt m1 = A.numberOfRows();
LongInt n1 = A.numberOfColumns();
if(theMatrixA==isRkRMatrix)
{
const RkRMatrix& R = (const RkRMatrix&)A;
LongInt k = R.rank();
LongInt mR = R.numberOfRows();
LongInt nR = R.numberOfColumns();
LongReal mike = 1.0;
// dgemm ( ¬ConjTrans, &conjTrans, &MIN(m,mR), &MIN(n,nR), &k, (LongReal*) &(Complex::complexUnit),
// (LongReal*) &(R.attr_A(rowIndex, 0)), &mR,
// (LongReal*) &(R.attr_B(colIndex, 0)), &nR, (LongReal*) &(Complex::complexUnit),
// (LongReal*) &(*this)(0, 0), &m);
TensorCalculus::Blas<double>::gemm (notConjTrans, conjTrans, MIN(m,mR), MIN(n,nR), k, 1.0,
&(R.attr_A(rowIndex, 0)), mR,
&(R.attr_B(colIndex, 0)), nR, 1.0,
&(*this)(0, 0), m);
}
else if(theMatrixA==isRMatrix)
{
const RMatrix& C = (const RMatrix&)A;
int ic = 1;
for(LongInt i=0; i<n; i++)
{
// daxpy (&m, (LongReal*) &(Complex::complexUnit), (LongReal*) &C(rowIndex, colIndex+i),
// &ic, (LongReal*) &(*this)(0, i), &ic);
TensorCalculus::Blas<double>::axpy (m, 1.0, &C(rowIndex, colIndex+i), ic, &(*this)(0, i), ic);
}
}
else if(theMatrixA==isHMatrixInterface)
{
RMatrix C(m1, n1);
C.isConversionOf(A);
addMatrix(C, rowIndex, colIndex);
}
else
{
throw SimpleException(IString("Warning In RMatrix::addMatrix (const AMatrix& A, const LongInt& rowIndex, const LongInt& colIndex), Type Not Implemented !!!"));
}
return (*this);
}
void Matrix::setValue(const index &i, const index &j, const double &value) {
if (i < 0 || i >= numberOfRows()) {
throw std::out_of_range("Matrix::setValue(const index &i, const index &j, const double &value): "
"Row index out of range");
} else if (j< 0 || j >= numberOfColumns()) {
throw std::out_of_range("Matrix::setValue(const index &i, const index &j, const double &value): "
"Column index out of range");
}
graph.setWeight(i, j, value);
}
Matrix& Matrix::operator-=(const Matrix &other) {
if (numberOfRows() != other.numberOfRows() || numberOfColumns() != other.numberOfColumns()) {
throw std::runtime_error("Matrix::operator-=(const Matrix &other): Dimensions of matrices do not match");
}
other.parallelForNonZeroElementsInRowOrder([&](node i, node j, double value) {
graph.increaseWeight(i, j, -value);
});
return *this;
}
RMatrix& RMatrix::addIdentityScaledBy (const LongReal& z)
{
const LongInt dim = MIN(numberOfRows(),numberOfColumns());
for(LongInt i=0; i<dim; i++)
{
(*this)(i,i) += z;
}
return(*this);
}
Vector Matrix::row(const index &i) const {
if (i < 0 || i >= numberOfRows()) {
throw std::out_of_range("Matrix::row(const index &i): Row index out of range");
}
Vector row(numberOfColumns(), 0.0, true);
graph.forEdgesOf(i, [&](node i, node j, double value) {
row[j] = value;
});
return row;
}
Vector Matrix::column(const index &j) const {
if (j < 0 || j >= numberOfColumns()) {
throw std::out_of_range("Matrix::column(const index &j): Column index out of range");
}
Vector column(numberOfRows());
#pragma omp parallel for
for (node i = 0; i < numberOfRows(); ++i) {
column[i] = graph.weight(i,j);
}
return column;
}
BufferedFTPrinter& BufferedFTPrinter::append(const double input) {
_columns.push_back(FTPrinter::decimalNumberToStr(input, maxColumnWidth(_lines.back())));
if (_lines.back() == (int)numberOfColumns()) {
_lines.push_back(1);
if (_columnFormats.size() == _columns.size() - 1)
append(format::basic);
}
else {
append(_columnFormats.back());
++(_lines.back());
}
return *this;
}
// >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
Window&
ListControl::resizeColumns()
{
const float clientWidth = (size().x() - 2.0f);
if(usingDefaultWidths_)
{
// set the default column widths
const float defaultWidth = floorf(clientWidth / numberOfColumns());
for(unsigned int i = 0; i < numberOfColumns()-1; ++i)
{
columnWidths_[i] = defaultWidth;
}
columnWidths_[numberOfColumns()-1] = 0.0f;
columnWidths_[numberOfColumns()-1] = std::accumulate(columnWidths_.begin(), columnWidths_.end(), 0.0f);
}
else
{
const float totalWidth = std::accumulate(columnWidths_.begin(), columnWidths_.end(), 0.0f);
columnWidths_[numberOfColumns()-1] = clientWidth - totalWidth;
}
return *this;
}
// >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
ListControl&
ListControl::setColumnWidths(const std::vector<float>& widths)
{
ASSERT ( widths.size() == numberOfColumns() );
std::vector<float>::const_iterator it;
int index = 0;
for(it = widths.begin(); it != widths.end(); ++it)
{
columnWidths_[index++] = *it;
}
usingDefaultWidths_ = false;
return *this;
}
// >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
ListControl&
ListControl::addRow(const std::vector<std::string>& strings)
{
ASSERT ( strings.size() <= numberOfColumns() );
Row newRow(*this);
for(unsigned i = 0; i < strings.size(); ++i)
{
newRow.setEntry(i, strings[i]);
}
rows_.push_back(newRow);
onContentsChanged();
return *this;
}
bool RMatrix::partialEvaluateTransposeAt (const LongInt& i, RVector& w, const LongInt& j, const RVector& v) const
{
bool value = true;
integer incx = 1;
integer n = numberOfRows();
integer m = numberOfColumns();
integer lda = n;
// dgemv ( &trans, &n, &m, (LongReal*) &(Complex::complexUnit), (LongReal*) (&_pelm[0]),
// &lda, (LongReal*) &v(j), &incx, (LongReal*) &(Complex::complexUnit),
// (LongReal*)&w(i), &incx
// );
TensorCalculus::Blas<double>::gemv(trans, n, m, 1.0, (&_pelm[0]), lda, &v(j), incx, 1.0, &w(i), incx);
return value;
}
bool RMatrix::operator () (const LongInt& i, RVector& w, const LongInt& j, const RVector& v)
{
bool value = true;
integer incx = 1;
integer m = numberOfRows();
integer n = numberOfColumns();
integer lda = m;
// dgemv ( correctChar(), &m, &n, (LongReal*) &(Complex::complexUnit), (LongReal*) (&_pelm[0]),
// &lda, (LongReal*) &v(j), &incx, (LongReal*) &(Complex::complexUnit),
// (LongReal*) &w(i), &incx
// );
TensorCalculus::Blas<double>::gemv(*correctChar(), m, n, 1.0, &_pelm[0],
lda, &v(j), incx, 1.0, &w(i), incx);
clearTranspose();
return value;
}
RMatrix& RMatrix::invert()
{
integer m = numberOfRows();
integer n = numberOfColumns();
integer lda = MAX(1,m);
integer dim = MIN(m,n);
integer info = 0;
integer* ipiv = new integer[dim];
// dgetrf (&m, &n, (LongReal*) &_pelm[0], &lda, ipiv, &info);
info = TensorCalculus::Lapack<double>::getrf(m, n, &_pelm[0], lda, ipiv);
integer lwork = m*n;
RVector work(lwork);
// dgetri (&m, (LongReal*) &_pelm[0], &lda, ipiv, (LongReal*) &work(0), &lwork, &info);
info = TensorCalculus::Lapack<double>::getri(m, &_pelm[0], lda, ipiv, &work(0), lwork);
delete [] ipiv;
return (*this);
}
RMatrix& RMatrix::attachColumns (const RMatrix& A)
{
const LongInt m = numberOfRows();
const LongInt n1 = numberOfColumns();
const LongInt n2 = A.numberOfColumns();
const LongInt n = n1+n2;
RMatrix temp((*this));
setDimension(m, n);
integer dim1 = m*n1;
integer nx = 1;
// dcopy (&dim1, (LongReal*)(&temp._pelm[0]), &nx, (LongReal*)(&_pelm[0]), &nx);
TensorCalculus::Blas<double>::copy (dim1, (&temp._pelm[0]), nx, (&_pelm[0]), nx);
integer dim2 = m*n2;
// dcopy (&dim2, (LongReal*)(&A._pelm[0]), &nx, (LongReal*)(&_pelm[dim1]), &nx);
TensorCalculus::Blas<double>::copy (dim2, (&A._pelm[0]), nx, (&_pelm[dim1]), nx);
return (*this);
}
Matrix Matrix::operator*(const Matrix &other) const {
if (numberOfColumns() != other.numberOfRows()) {
throw std::runtime_error("Matrix::operator*(const Matrix &other): Dimensions of matrices do not match");
}
Matrix result(numberOfRows(), other.numberOfColumns());
SparseAccumulator spa(numberOfRows());
for (index r = 0; r < numberOfRows(); ++r) {
graph.forNeighborsOf(r, [&](node v, double w1){
other.graph.forNeighborsOf(v, [&](node u, double w2){
double value = w1 * w2;
spa.scatter(value, u);
});
});
spa.gather([&](node row, node column, double value){
result.graph.addEdge(row, column, value);
});
spa.increaseRow();
}
return result;
}
size_t BufferedFTPrinter::maxTableWidth() const {
size_t maxTableWidth = separator().size();
for (size_t i = 0; i < numberOfColumns(); ++i)
maxTableWidth += maxColumnWidth(i) + separator().size();
return maxTableWidth;
}
void
FWTestTableManager::implSort(int col, bool sortOrder)
{
if(col >-1 && col < m_columns.size()) {
std::vector<std::pair<std::string,unsigned int> > toSort;
int nRows = numberOfRows();
toSort.reserve(nRows);
for(int row=0; row< nRows; ++row) {
toSort.push_back( std::make_pair<std::string, unsigned int>(m_content[col+row*numberOfColumns()],row));
}
if(sortOrder) {
std::sort(toSort.begin(),toSort.end(),std::greater<std::pair<std::string,unsigned int> >());
} else {
std::sort(toSort.begin(),toSort.end(),std::less<std::pair<std::string,unsigned int> >());
}
std::vector<unsigned int>::iterator itSort = m_sortOrder.begin();
for(std::vector<std::pair<std::string,unsigned int> >::iterator it = toSort.begin(), itEnd=toSort.end();
it != itEnd;
++it,++itSort) {
*itSort = it->second;
}
}
}