void MuteVisitor::visit (const MatrixExp &e) { exps_t lines = e.getLines(); for (exps_t::const_iterator it = lines.begin(), itEnd = lines.end(); it != itEnd ; ++it) { (*it)->mute(); (*it)->accept(*this); } }
/** \name Visit Matrix Expressions nodes. ** \{ */ void PrintVisitor::visit (const MatrixExp &e) { ast::exps_t::const_iterator i, j; *ostr << SCI_OPEN_MATRIX; ++indent; this->is_last_matrix_line = false; ast::exps_t lines = e.getLines(); for (i = lines.begin() ; i != lines.end() ; ) { bool addIndent = false; j = i; if (++j == lines.end()) { this->is_last_matrix_line = true; } else { if ((*i)->getLocation().last_line != (*j)->getLocation().first_line) { addIndent = true; } } if (displayOriginal) { (*i)->getOriginal()->accept(*this); } else { (*i)->accept(*this); } //if (lines.size() > 1 || this->is_last_column_comment) if (addIndent) { *ostr << std::endl; this->apply_indent(); } ++i; } *ostr << SCI_CLOSE_MATRIX; --indent; }
void RunVisitorT<T>::visitprivate(const MatrixExp &e) { CoverageInstance::invokeAndStartChrono((void*)&e); try { exps_t::const_iterator row; exps_t::const_iterator col; types::InternalType *poResult = NULL; std::list<types::InternalType*> rowList; exps_t lines = e.getLines(); if (lines.size() == 0) { setResult(types::Double::Empty()); CoverageInstance::invokeAndStartChrono((void*)&e); return; } //special case for 1x1 matrix if (lines.size() == 1) { exps_t cols = lines[0]->getAs<MatrixLineExp>()->getColumns(); if (cols.size() == 1) { setResult(NULL); // Reset value on loop re-start cols[0]->accept(*this); //manage evstr('//xxx') for example if (getResult() == NULL) { setResult(types::Double::Empty()); } CoverageInstance::invokeAndStartChrono((void*)&e); return; } } //do all [x,x] for (row = lines.begin(); row != lines.end(); row++) { types::InternalType* poRow = NULL; exps_t cols = (*row)->getAs<MatrixLineExp>()->getColumns(); for (col = cols.begin(); col != cols.end(); col++) { setResult(NULL); // Reset value on loop re-start try { (*col)->accept(*this); } catch (const InternalError& error) { if (poRow) { poRow->killMe(); } if (poResult) { poResult->killMe(); } throw error; } types::InternalType *pIT = getResult(); if (pIT == NULL) { continue; } //reset result but without delete the value clearResultButFirst(); if (pIT->isImplicitList()) { types::ImplicitList *pIL = pIT->getAs<types::ImplicitList>(); if (pIL->isComputable()) { types::InternalType* pIT2 = pIL->extractFullMatrix(); pIT->killMe(); pIT = pIT2; } else { if (poRow == NULL) { //first loop poRow = pIT; } else { try { poRow = callOverloadMatrixExp(L"c", poRow, pIT); } catch (const InternalError& error) { if (poResult) { poResult->killMe(); } throw error; } } continue; } } if (pIT->isGenericType() == false) { pIT->killMe(); std::wostringstream os; os << _W("unable to concatenate\n"); throw ast::InternalError(os.str(), 999, (*col)->getLocation()); } types::GenericType* pGT = pIT->getAs<types::GenericType>(); if (poRow == NULL) { //first loop if (poResult == NULL && pGT->isDouble() && pGT->getAs<types::Double>()->isEmpty()) { pGT->killMe(); continue; } if (pGT->isDouble() && pGT->getAs<types::Double>()->isEmpty()) { if (poResult && (poResult->isList() || poResult->isStruct())) { //in case of [list(); [], ...] //we don't know what to do with [], keep it as "normal" value and continue process poRow = pGT; continue; } pGT->killMe(); continue; } poRow = pGT; continue; } //manage overload on list/struct/implicitlist and hypermatrix before management of [] if (pGT->isList() || poRow->isList() || pGT->isStruct() || poRow->isStruct() || poRow->isImplicitList() || pGT->getDims() > 2) { try { poRow = callOverloadMatrixExp(L"c", poRow, pGT); } catch (const InternalError& error) { if (poResult) { poResult->killMe(); } throw error; } continue; } if (pGT->isDouble() && pGT->getAs<types::Double>()->isEmpty()) { pGT->killMe(); continue; } types::GenericType* pGTResult = poRow->getAs<types::GenericType>(); //check dimension if (pGT->getDims() != 2 || pGT->getRows() != pGTResult->getRows()) { poRow->killMe(); if (poRow != pGT) { pGT->killMe(); } std::wostringstream os; os << _W("inconsistent row/column dimensions\n"); throw ast::InternalError(os.str(), 999, (*row)->getLocation()); } // if we concatenate [Double Sparse], transform the Double to Sparse and perform [Sparse Sparse] // this avoids to allocate a Double result of size of Double+Sparse and initialize all elements. if (pGT->isSparse() && pGTResult->isDouble()) { poRow = new types::Sparse(*pGTResult->getAs<types::Double>()); pGTResult->killMe(); pGTResult = poRow->getAs<types::GenericType>(); } else if (pGT->isSparseBool() && pGTResult->isBool()) // [Bool SparseBool] => [SparseBool SparseBool] { poRow = new types::SparseBool(*pGTResult->getAs<types::Bool>()); pGTResult->killMe(); pGTResult = poRow->getAs<types::GenericType>(); } else if (pGT->isDollar() && pGTResult->isDouble()) { int _iRows = pGTResult->getRows(); int _iCols = pGTResult->getCols(); int* piRank = new int[_iRows * _iCols]; memset(piRank, 0x00, _iRows * _iCols * sizeof(int)); poRow = new types::Polynom(pGT->getAs<types::Polynom>()->getVariableName(), _iRows, _iCols, piRank); types::Polynom* pP = poRow->getAs<types::Polynom>(); types::SinglePoly** pSS = pP->get(); types::Double* pDb = pGTResult->getAs<types::Double>(); double* pdblR = pDb->get(); if (pDb->isComplex()) { double* pdblI = pDb->getImg(); pP->setComplex(true); for (int i = 0; i < pDb->getSize(); i++) { pSS[i]->setRank(0); pSS[i]->setCoef(pdblR + i, pdblI + i); } } else { for (int i = 0; i < pDb->getSize(); i++) { pSS[i]->setRank(0); pSS[i]->setCoef(pdblR + i, NULL); } } delete[] piRank; } types::InternalType *pNewSize = AddElementToVariable(NULL, poRow, pGTResult->getRows(), pGTResult->getCols() + pGT->getCols()); types::InternalType* p = AddElementToVariable(pNewSize, pGT, 0, pGTResult->getCols()); if (p != pNewSize) { pNewSize->killMe(); } // call overload if (p == NULL) { try { poRow = callOverloadMatrixExp(L"c", pGTResult, pGT); } catch (const InternalError& error) { if (poResult) { poResult->killMe(); } throw error; } continue; } if (poRow != pGT) { pGT->killMe(); } if (p != poRow) { poRow->killMe(); poRow = p; } } if (poRow == NULL) { continue; } if (poResult == NULL) { poResult = poRow; continue; } // management of concatenation with 1:$ if (poRow->isImplicitList() || poResult->isImplicitList()) { try { poResult = callOverloadMatrixExp(L"f", poResult, poRow); } catch (const InternalError& error) { throw error; } continue; } types::GenericType* pGT = poRow->getAs<types::GenericType>(); //check dimension types::GenericType* pGTResult = poResult->getAs<types::GenericType>(); if (pGT->isList() || pGTResult->isList() || pGT->isStruct() || pGTResult->isStruct() || pGT->getDims() > 2) { try { poResult = callOverloadMatrixExp(L"f", pGTResult, pGT); } catch (const InternalError& error) { throw error; } continue; } else {//[] if (pGT->isDouble() && pGT->getAs<types::Double>()->isEmpty()) { pGT->killMe(); continue; } } //check dimension if (pGT->getCols() != pGTResult->getCols()) { poRow->killMe(); if (poResult) { poResult->killMe(); } std::wostringstream os; os << _W("inconsistent row/column dimensions\n"); throw ast::InternalError(os.str(), 999, (*e.getLines().begin())->getLocation()); } // if we concatenate [Double Sparse], transform the Double to Sparse and perform [Sparse Sparse] // this avoids to allocate a Double result of size of Double+Sparse and initialize all elements. if (pGT->isSparse() && pGTResult->isDouble()) { poResult = new types::Sparse(*pGTResult->getAs<types::Double>()); pGTResult->killMe(); pGTResult = poResult->getAs<types::GenericType>(); } else if (pGT->isSparseBool() && pGTResult->isBool()) // [Bool SparseBool] => [SparseBool SparseBool] { poResult = new types::SparseBool(*pGTResult->getAs<types::Bool>()); pGTResult->killMe(); pGTResult = poResult->getAs<types::GenericType>(); } types::InternalType* pNewSize = AddElementToVariable(NULL, poResult, pGTResult->getRows() + pGT->getRows(), pGT->getCols()); types::InternalType* p = AddElementToVariable(pNewSize, pGT, pGTResult->getRows(), 0); if (p != pNewSize) { pNewSize->killMe(); } // call overload if (p == NULL) { try { poResult = callOverloadMatrixExp(L"f", pGTResult, pGT); } catch (const InternalError& error) { throw error; } continue; } if (poResult != poRow) { poRow->killMe(); } if (p != poResult) { poResult->killMe(); poResult = p; } } if (poResult) { setResult(poResult); } else { setResult(types::Double::Empty()); } } catch (const InternalError& error) { setResult(NULL); CoverageInstance::invokeAndStartChrono((void*)&e); throw error; } CoverageInstance::invokeAndStartChrono((void*)&e); }