int main () { const int cell_size = 2; //Initialize A-matrix ublas::matrix<double> A (cell_size, cell_size); A (0, 0) = 1; A (1, 1) = 2; A (0, 1) = 0; A (1, 0) = 0; //Initialize b-vector ublas::vector<double> b (cell_size); b (0) = 1; b (1) = 1; // Solve Ax=b (maybe) ublas::permutation_matrix<double> piv (cell_size); const bool singular = ublas::lu_factorize(A, piv); if (singular) std::cout << "singular!" << std::endl; ublas::lu_substitute (A, piv, b); // b now contains solution std::cout << A << std::endl; std::cout << piv << std::endl; std::cout << b << std::endl; return 0; }
/// @brief Computes saturation from surface volume void computeSaturation(const BlackoilPropertiesInterface& props, BlackoilState& state) { const int np = props.numPhases(); const int nc = props.numCells(); std::vector<double> allA(nc*np*np); std::vector<int> allcells(nc); for (int c = 0; c < nc; ++c) { allcells[c] = c; } //std::vector<double> res_vol(np); const std::vector<double>& z = state.surfacevol(); props.matrix(nc, &state.pressure()[0], &z[0], &allcells[0], &allA[0], 0); // Linear solver. MAT_SIZE_T n = np; MAT_SIZE_T nrhs = 1; MAT_SIZE_T lda = np; std::vector<MAT_SIZE_T> piv(np); MAT_SIZE_T ldb = np; MAT_SIZE_T info = 0; //double res_vol; double tot_sat; const double epsilon = std::sqrt(std::numeric_limits<double>::epsilon()); for (int c = 0; c < nc; ++c) { double* A = &allA[c*np*np]; const double* z_loc = &z[c*np]; double* s = &state.saturation()[c*np]; for (int p = 0; p < np; ++p){ s[p] = z_loc[p]; } dgesv_(&n, &nrhs, &A[0], &lda, &piv[0], &s[0], &ldb, &info); tot_sat = 0; for (int p = 0; p < np; ++p){ if (s[p] < epsilon) // saturation may be less then zero due to round of errors s[p] = 0; tot_sat += s[p]; } for (int p = 0; p < np; ++p){ s[p] = s[p]/tot_sat; } } }
lslboost::numeric::ublas::vector<T> solve( const lslboost::numeric::ublas::matrix<T>& A_, const lslboost::numeric::ublas::vector<T>& b_) { //BOOST_ASSERT(A_.size() == b_.size()); lslboost::numeric::ublas::matrix<T> A(A_); lslboost::numeric::ublas::vector<T> b(b_); lslboost::numeric::ublas::permutation_matrix<> piv(b.size()); lu_factorize(A, piv); lu_substitute(A, piv, b); // // iterate to reduce error: // lslboost::numeric::ublas::vector<T> delta(b.size()); for(unsigned i = 0; i < 1; ++i) { noalias(delta) = prod(A_, b); delta -= b_; lu_substitute(A, piv, delta); b -= delta; T max_error = 0; for(unsigned i = 0; i < delta.size(); ++i) { T err = fabs(delta[i] / b[i]); if(err > max_error) max_error = err; } //std::cout << "Max change in LU error correction: " << max_error << std::endl; } return b; }
LUDecomposition::Matrix LUDecomposition::solve (const Matrix& B) const { BOOST_UBLAS_CHECK((int)B.size1() == m, bad_size("Matrix row dimensions must agree.")); BOOST_UBLAS_CHECK(isNonsingular(), singular("Matrix is singular.")); // Copy right hand side with pivoting int nx = B.size2(); Matrix X(m,nx); for (int i = 0; i < m; i++) { row(X,i) = row(B, piv(i)); } // Solve L*Y = B(piv,:) for (int k = 0; k < n; k++) { for (int i = k+1; i < n; i++) { for (int j = 0; j < nx; j++) { X(i,j) -= X(k,j)*LU(i,k); } } } // Solve U*X = Y; for (int k = n-1; k >= 0; k--) { for (int j = 0; j < nx; j++) { X(k,j) /= LU(k,k); } for (int i = 0; i < k; i++) { for (int j = 0; j < nx; j++) { X(i,j) -= X(k,j)*LU(i,k); } } } return X; }
void solve (Matrix& A, const Vector& b, Vector& x) const // Solve Ax=b { namespace ublas = boost::numeric::ublas; const size_t size = b.size (); ublas::permutation_matrix<double> piv (size); const bool singular = ublas::lu_factorize(A, piv); daisy_assert (!singular); x = b; // x should contain b as a start. ublas::lu_substitute (A, piv, x); }
//========================================================================== /// INTERNAL ONLY - [X,R] = LINSOLVE(A,B) -- symmetric shape BOOST_FORCEINLINE void eval ( A0 const& a0, A1 const& a1 , A2 const& a2 ,boost::mpl::long_<2> const , nt2::symmetric_ const&) const { type_t rcond; nt2::container::table<nt2_la_int> piv(nt2::of_size(a0.leading_size(),1)); boost::proto::child_c<0>(a2).resize(nt2::of_size(a0.leading_size(),1)); NT2_AS_TERMINAL_IN(desired_semantic1,a,a0); NT2_AS_TERMINAL_IN(desired_semantic,b,a1); nt2_la_int iter = nt2::sysvx( boost::proto::value(a),boost::proto::value(piv) , boost::proto::value(b) , boost::proto::value(boost::proto::child_c<0>(a2)) , rcond); boost::ignore_unused(iter); boost::proto::child_c<1>(a2) = rcond; }
boost boost::solve_x(const boost& B) const { if(this->num_rows() != this->num_cols()) throw std::invalid_argument("A must be square in Ax = B"); if(this->num_cols() != B.num_rows()) throw std::invalid_argument("B.rows must equal A.cols in Ax = B"); if(B.num_cols() != 1) throw std::invalid_argument("B must be n x 1 vector in Ax = B"); bnu::matrix<float> A(this->data()); bnu::matrix<float> y = bnu::trans(B.data()); bnu::vector<float> b(B.num_rows()); std::copy(y.begin1(), y.end1(), b.begin()); bnu::permutation_matrix<> piv(b.size()); bnu::lu_factorize(A, piv); bnu::lu_substitute(A, piv, b); bnu::matrix<float> x(this->num_rows(), 1); std::copy(b.begin(), b.end(), x.begin1()); return std::move(boost(x)); }
ordinal_type Stokhos::MonomialGramSchmidtPCEBasis<ordinal_type, value_type>:: buildReducedBasis( ordinal_type max_p, value_type threshold, const Teuchos::SerialDenseMatrix<ordinal_type,value_type>& A, const Teuchos::SerialDenseMatrix<ordinal_type,value_type>& F, const Teuchos::Array<value_type>& weights, Teuchos::Array< Stokhos::MultiIndex<ordinal_type> >& terms_, Teuchos::Array<ordinal_type>& num_terms_, Teuchos::SerialDenseMatrix<ordinal_type,value_type>& Qp_, Teuchos::SerialDenseMatrix<ordinal_type,value_type>& Q_) { // Compute basis terms -- 2-D array giving powers for each linear index ordinal_type max_sz; CPBUtils::compute_terms(max_p, this->d, max_sz, terms_, num_terms_); // Compute B matrix -- monomials in F // for i=0,...,nqp-1 // for j=0,...,sz-1 // B(i,j) = F(i,1)^terms_[j][1] * ... * F(i,d)^terms_[j][d] // where sz is the total size of a basis up to order p and terms_[j] // is an array of powers for each term in the total-order basis ordinal_type nqp = weights.size(); SDM B(nqp, max_sz); for (ordinal_type i=0; i<nqp; i++) { for (ordinal_type j=0; j<max_sz; j++) { B(i,j) = 1.0; for (ordinal_type k=0; k<this->d; k++) B(i,j) *= std::pow(F(i,k), terms_[j][k]); } } // Rescale columns of B to have unit norm for (ordinal_type j=0; j<max_sz; j++) { value_type nrm = 0.0; for (ordinal_type i=0; i<nqp; i++) nrm += B(i,j)*B(i,j)*weights[i]; nrm = std::sqrt(nrm); for (ordinal_type i=0; i<nqp; i++) B(i,j) /= nrm; } // Compute our new basis -- each column of Q is the new basis evaluated // at the original quadrature points. Constraint pivoting so first d+1 // columns and included in Q. SDM R; Teuchos::Array<ordinal_type> piv(max_sz); for (int i=0; i<this->d+1; i++) piv[i] = 1; typedef Stokhos::OrthogonalizationFactory<ordinal_type,value_type> SOF; ordinal_type sz_ = SOF::createOrthogonalBasis( this->orthogonalization_method, threshold, this->verbose, B, weights, Q_, R, piv); // Compute Qp = A^T*W*Q SDM tmp(nqp, sz_); Qp_.reshape(this->pce_sz, sz_); for (ordinal_type i=0; i<nqp; i++) for (ordinal_type j=0; j<sz_; j++) tmp(i,j) = Q_(i,j)*weights[i]; ordinal_type ret = Qp_.multiply(Teuchos::TRANS, Teuchos::NO_TRANS, 1.0, A, tmp, 0.0); TEUCHOS_ASSERT(ret == 0); // It isn't clear that Qp is orthogonal, but if you derive the projection // matrix from the original space to the reduced, you end up with // Q^T*W*A = Qp^T return sz_; }
Stokhos::ProductLanczosGramSchmidtPCEBasis<ordinal_type, value_type>:: ProductLanczosGramSchmidtPCEBasis( ordinal_type max_p, const Teuchos::Array< Stokhos::OrthogPolyApprox<ordinal_type, value_type> >& pce, const Teuchos::RCP<const Stokhos::Quadrature<ordinal_type, value_type> >& quad, const Teuchos::RCP< const Stokhos::Sparse3Tensor<ordinal_type, value_type> >& Cijk, const Teuchos::ParameterList& params_) : name("Product Lanczos Gram-Schmidt PCE Basis"), params(params_), p(max_p) { Teuchos::RCP<const Stokhos::OrthogPolyBasis<ordinal_type,value_type> > pce_basis = pce[0].basis(); pce_sz = pce_basis->size(); // Check if basis is a product basis Teuchos::RCP<const Stokhos::ProductBasis<ordinal_type,value_type> > prod_basis = Teuchos::rcp_dynamic_cast<const Stokhos::ProductBasis<ordinal_type,value_type> >(pce_basis); Teuchos::Array< Teuchos::RCP<const OneDOrthogPolyBasis<ordinal_type,value_type> > > coord_bases; if (prod_basis != Teuchos::null) coord_bases = prod_basis->getCoordinateBases(); // Build Lanczos basis for each pce bool project = params.get("Project", true); bool normalize = params.get("Normalize", true); bool limit_integration_order = params.get("Limit Integration Order", false); bool use_stieltjes = params.get("Use Old Stieltjes Method", false); Teuchos::Array< Teuchos::RCP<const Stokhos::OneDOrthogPolyBasis<int,double > > > coordinate_bases; Teuchos::Array<int> is_invariant(pce.size(),-2); for (ordinal_type i=0; i<pce.size(); i++) { // Check for pce's lying in invariant subspaces, which are pce's that // depend on only a single dimension. In this case use the corresponding // original coordinate basis. Convention is: -2 -- not invariant, -1 -- // constant, i >= 0 pce depends only on dimension i if (prod_basis != Teuchos::null) is_invariant[i] = isInvariant(pce[i]); if (is_invariant[i] >= 0) { coordinate_bases.push_back(coord_bases[is_invariant[i]]); } // Exclude constant pce's from the basis since they don't represent // stochastic dimensions else if (is_invariant[i] != -1) { if (use_stieltjes) { coordinate_bases.push_back( Teuchos::rcp( new Stokhos::StieltjesPCEBasis<ordinal_type,value_type>( p, Teuchos::rcp(&(pce[i]),false), quad, false, normalize, project, Cijk))); } else { if (project) coordinate_bases.push_back( Teuchos::rcp( new Stokhos::LanczosProjPCEBasis<ordinal_type,value_type>( p, Teuchos::rcp(&(pce[i]),false), Cijk, normalize, limit_integration_order))); else coordinate_bases.push_back( Teuchos::rcp( new Stokhos::LanczosPCEBasis<ordinal_type,value_type>( p, Teuchos::rcp(&(pce[i]),false), quad, normalize, limit_integration_order))); } } } d = coordinate_bases.size(); // Build tensor product basis tensor_lanczos_basis = Teuchos::rcp( new Stokhos::CompletePolynomialBasis<ordinal_type,value_type>( coordinate_bases, params.get("Cijk Drop Tolerance", 1.0e-15), params.get("Use Old Cijk Algorithm", false))); // Build Psi matrix -- Psi_ij = Psi_i(x^j)*w_j/<Psi_i^2> const Teuchos::Array<value_type>& weights = quad->getQuadWeights(); const Teuchos::Array< Teuchos::Array<value_type> >& points = quad->getQuadPoints(); const Teuchos::Array< Teuchos::Array<value_type> >& basis_vals = quad->getBasisAtQuadPoints(); ordinal_type nqp = weights.size(); SDM Psi(pce_sz, nqp); for (ordinal_type i=0; i<pce_sz; i++) for (ordinal_type k=0; k<nqp; k++) Psi(i,k) = basis_vals[k][i]*weights[k]/pce_basis->norm_squared(i); // Build Phi matrix -- Phi_ij = Phi_i(y(x^j)) sz = tensor_lanczos_basis->size(); Teuchos::Array<value_type> red_basis_vals(sz); Teuchos::Array<value_type> pce_vals(d); SDM Phi(sz, nqp); SDM F(nqp, d); for (int k=0; k<nqp; k++) { ordinal_type jdx = 0; for (int j=0; j<pce.size(); j++) { // Exclude constant pce's if (is_invariant[j] != -1) { // Use the identity mapping for invariant subspaces if (is_invariant[j] >= 0) pce_vals[jdx] = points[k][is_invariant[j]]; else pce_vals[jdx] = pce[j].evaluate(points[k], basis_vals[k]); F(k,jdx) = pce_vals[jdx]; jdx++; } } tensor_lanczos_basis->evaluateBases(pce_vals, red_basis_vals); for (int i=0; i<sz; i++) Phi(i,k) = red_basis_vals[i]; } bool verbose = params.get("Verbose", false); // Compute matrix A mapping reduced space to original SDM A(pce_sz, sz); ordinal_type ret = A.multiply(Teuchos::NO_TRANS, Teuchos::TRANS, 1.0, Psi, Phi, 0.0); TEUCHOS_ASSERT(ret == 0); // Rescale columns of A to have unit norm const Teuchos::Array<value_type>& basis_norms = pce_basis->norm_squared(); for (ordinal_type j=0; j<sz; j++) { value_type nrm = 0.0; for (ordinal_type i=0; i<pce_sz; i++) nrm += A(i,j)*A(i,j)*basis_norms[i]; nrm = std::sqrt(nrm); for (ordinal_type i=0; i<pce_sz; i++) A(i,j) /= nrm; } // Compute our new basis -- each column of Qp is the coefficients of the // new basis in the original basis. Constraint pivoting so first d+1 // columns and included in Qp. value_type rank_threshold = params.get("Rank Threshold", 1.0e-12); std::string orthogonalization_method = params.get("Orthogonalization Method", "Householder"); Teuchos::Array<value_type> w(pce_sz, 1.0); SDM R; Teuchos::Array<ordinal_type> piv(sz); for (int i=0; i<d+1; i++) piv[i] = 1; typedef Stokhos::OrthogonalizationFactory<ordinal_type,value_type> SOF; sz = SOF::createOrthogonalBasis( orthogonalization_method, rank_threshold, verbose, A, w, Qp, R, piv); // Original basis at quadrature points -- needed to transform expansions // in this basis back to original SDM B(nqp, pce_sz); for (ordinal_type i=0; i<nqp; i++) for (ordinal_type j=0; j<pce_sz; j++) B(i,j) = basis_vals[i][j]; // Evaluate new basis at original quadrature points Q.reshape(nqp, sz); ret = Q.multiply(Teuchos::NO_TRANS, Teuchos::NO_TRANS, 1.0, B, Qp, 0.0); TEUCHOS_ASSERT(ret == 0); // Compute reduced quadrature rule Stokhos::ReducedQuadratureFactory<ordinal_type,value_type> quad_factory( params.sublist("Reduced Quadrature")); Teuchos::SerialDenseMatrix<ordinal_type, value_type> Q2; reduced_quad = quad_factory.createReducedQuadrature(Q, Q2, F, weights); // Basis is orthonormal by construction norms.resize(sz, 1.0); }
LUDecomposition::LUDecomposition (const Matrix& A) { // Use a "left-looking", dot-product, Crout/Doolittle algorithm. LU = A; m = A.size1(); n = A.size2(); piv = PivotVector(m); for (int i = 0; i < m; i++) { piv(i) = i; } pivsign = 1; Vector LUcolj(m); // Outer loop. for (int j = 0; j < n; j++) { // Make a copy of the j-th column to localize references. for (int i = 0; i < m; i++) { LUcolj(i) = LU(i,j); } // Apply previous transformations. for (int i = 0; i < m; i++) { matrix_row<Matrix> LUrowi(LU,i); // Most of the time is spent in the following dot product. int kmax = std::min(i,j); double s = 0.0; for (int k = 0; k < kmax; k++) { s += LUrowi(k)*LUcolj(k); } LUrowi(j) = LUcolj(i) -= s; } // Find pivot and exchange if necessary. int p = j; for (int i = j+1; i < m; i++) { if (std::abs(LUcolj(i)) > std::abs(LUcolj(p))) { p = i; } } if (p != j) { for (int k = 0; k < n; k++) { double t = LU(p,k); LU(p,k) = LU(j,k); LU(j,k) = t; } int k = piv(p); piv(p) = piv(j); piv(j) = k; pivsign = -pivsign; } // Compute multipliers. if (j < m && LU(j,j) != 0.0) { for (int i = j+1; i < m; i++) { LU(i,j) /= LU(j,j); } } } }
void MainWindow::renderBoardCompleteGame(std::vector<MoveHistoryEntry> history, QString outDir, bool renderOpenTiles, bool renderFrames, bool renderPlayers, bool renderNextTile, int playerCount) { //TODO correct backgrounds QDir(outDir).mkpath("."); jcz::TileFactory tileFactory(false); TileImageFactory imgFactory(&tileFactory); QImage image; QPainter * painter = 0; RandomNextTileProvider rntp; HistoryProvider hp(&rntp, history, 0); Game g(&hp, false); for (int i = 0; i < playerCount; ++i) g.addPlayer(&RandomPlayer::instance); BoardGraphicsScene bgs(&tileFactory, &imgFactory); bgs.setRenderOpenTiles(renderOpenTiles); bgs.setRenderFrames(renderFrames); bgs.setGame(&g); g.addWatchingPlayer(&bgs); g.newGame(Tile::BaseGame, &tileFactory, history, true); bgs.clearSelection(); QRectF sceneRect = bgs.itemsBoundingRect(); int const spacing = 50; int constexpr pivScale = 4; QSize sceneSize = sceneRect.size().toSize(); QSize size = sceneSize; if (renderPlayers) { QLabel remainingLabel(QString("%1 tiles left").arg(g.getTileCount() - 1)); remainingLabel.updateGeometry(); int nextTileType = g.getTile(hp.nextTile(&g))->tileType; QSize pivSize; { PlayerInfoView piv(0, &g, &imgFactory); piv.updateView(); if (renderNextTile) piv.displayTile(g.getNextPlayer(), nextTileType); piv.updateGeometry(); pivSize = piv.size() * pivScale; pivSize.rheight() *= g.getPlayerCount(); QSize remSize = remainingLabel.sizeHint() * pivScale; size.rwidth() += pivSize.width() + spacing; size.rheight() = qMax(size.height(), pivSize.height() + spacing + remSize.height()); } } std::vector<MoveHistoryEntry> applyHistory; for (int i = -1; i < (int)history.size(); ++i) { // oh well, this is ugly. If only there was a Game::step(MoveHistoryEntry)... if (i >= 0) applyHistory.push_back(history[i]); g.newGame(Tile::BaseGame, &tileFactory, applyHistory, true); delete painter; image = QImage(size, QImage::Format_ARGB32); image.fill(Qt::transparent); painter = new QPainter(&image); painter->setRenderHints(QPainter::Antialiasing | QPainter::TextAntialiasing | QPainter::SmoothPixmapTransform | QPainter::HighQualityAntialiasing); QPoint offset(0, 0); if (renderPlayers) { QLabel remainingLabel(QString("%1 tiles left").arg(g.getTileCount() - 1)); remainingLabel.updateGeometry(); int nextTileType = g.getTile(hp.nextTile(&g))->tileType; QSize pivSize; painter->scale(pivScale, pivScale); for (uint p = 0; p < g.getPlayerCount(); ++p) { PlayerInfoView piv(p, &g, &imgFactory); piv.updateView(); if (renderNextTile) piv.displayTile(g.getNextPlayer(), nextTileType); piv.updateGeometry(); piv.render(painter, offset); offset.ry() += piv.size().height(); } offset.setX(0); offset.setY((pivSize.height() + spacing) / pivScale); remainingLabel.render(painter, offset); offset.setX(pivSize.width() + spacing); offset.setY(0); painter->resetTransform(); } bgs.setSceneRect(sceneRect); bgs.render(painter, QRectF(offset, size)); image.save(QString("%1/%2.png").arg(outDir).arg(i+1, 3, 10, QLatin1Char('0'))); } delete painter; }
void MainWindow::renderBoard(std::vector<MoveHistoryEntry> history, QString outFile, int removeLast, bool renderOpenTiles, bool renderFrames, bool renderPlayers, bool renderNextTile) { //TODO correct backgrounds jcz::TileFactory tileFactory(false); TileImageFactory imgFactory(&tileFactory); QImage image; QPainter * painter = 0; RandomNextTileProvider rntp; HistoryProvider hp(&rntp, history, history.size() - removeLast); Game g(&hp, false); g.addPlayer(&RandomPlayer::instance); g.addPlayer(&RandomPlayer::instance); BoardGraphicsScene bgs(&tileFactory, &imgFactory); bgs.setRenderOpenTiles(renderOpenTiles); bgs.setRenderFrames(renderFrames); bgs.setGame(&g); g.addWatchingPlayer(&bgs); history.erase(history.end() - removeLast, history.end()); g.newGame(Tile::BaseGame, &tileFactory, history, true); bgs.clearSelection(); bgs.setSceneRect(bgs.itemsBoundingRect()); int const spacing = 50; int constexpr pivScale = 4; QSize sceneSize = bgs.sceneRect().size().toSize(); QSize size = sceneSize; QPoint offset(0, 0); if (renderPlayers) { QLabel remainingLabel(QString("%1 tiles left").arg(g.getTileCount() - 1)); remainingLabel.updateGeometry(); int nextTileType = g.getTile(hp.nextTile(&g))->tileType; QSize pivSize; for (uint p = 0; p < g.getPlayerCount(); ++p) { PlayerInfoView piv(p, &g, &imgFactory); piv.updateView(); if (renderNextTile) piv.displayTile(g.getNextPlayer(), nextTileType); piv.updateGeometry(); if (p == 0) { pivSize = piv.size() * pivScale; pivSize.rheight() *= g.getPlayerCount(); QSize remSize = remainingLabel.sizeHint() * pivScale; size.rwidth() += pivSize.width() + spacing; size.rheight() = qMax(size.height(), pivSize.height() + spacing + remSize.height()); image = QImage(size, QImage::Format_ARGB32); image.fill(Qt::transparent); painter = new QPainter(&image); painter->setRenderHints(QPainter::Antialiasing | QPainter::TextAntialiasing | QPainter::SmoothPixmapTransform | QPainter::HighQualityAntialiasing); painter->scale(pivScale, pivScale); } piv.render(painter, offset); offset.ry() += piv.size().height(); } offset.setX(0); offset.setY((pivSize.height() + spacing) / pivScale); remainingLabel.render(painter, offset); offset.setX(pivSize.width() + spacing); offset.setY(0); painter->resetTransform(); } else { image = QImage(size, QImage::Format_ARGB32); image.fill(Qt::transparent); painter = new QPainter(&image); painter->setRenderHints(QPainter::Antialiasing | QPainter::TextAntialiasing | QPainter::SmoothPixmapTransform | QPainter::HighQualityAntialiasing); } bgs.render(painter, QRectF(offset, size)); image.save(outFile); delete painter; }
short RangePartitioningFunction::codeGen(Generator *generator, Lng32 partInputDataLength) { ExpGenerator * exp_gen = generator->getExpGenerator(); Lng32 myOwnPartInputDataLength; const Int32 pivMoveAtp = 0; // only one atp is used for this expr const Int32 pivMoveAtpIndex = 2; // 0: consts, 1: temps, 2: result const ExpTupleDesc::TupleDataFormat pivFormat = // format of PIVs ExpTupleDesc::SQLARK_EXPLODED_FORMAT; ex_cri_desc *partInputCriDesc = new(generator->getSpace()) ex_cri_desc(pivMoveAtpIndex+1, generator->getSpace()); ExpTupleDesc *partInputTupleDesc; ExRangePartInputData *generatedObject = NULL; // get the list of partition input variables ValueIdList piv(getPartitionInputValuesLayout()); CollIndex numPartInputs = piv.entries(); CollIndex numPartKeyCols = (numPartInputs - 1) / 2; // the number of partition input variables must be odd GenAssert(2*numPartKeyCols+1 == numPartInputs, "NOT 2*numPartKeyCols+1 == numPartInputs"); Attributes **begEndAttrs; Int32 alignedPartKeyLen; // make a layout of the partition input data record generatePivLayout( generator, myOwnPartInputDataLength, pivMoveAtp, pivMoveAtpIndex, &begEndAttrs); // the aligned part key length is where the end key values start alignedPartKeyLen = (Int32) begEndAttrs[numPartKeyCols]->getOffset(); if (begEndAttrs[numPartKeyCols]->getNullIndicatorLength() > 0) alignedPartKeyLen = MINOF( alignedPartKeyLen, (Int32)begEndAttrs[numPartKeyCols]->getNullIndOffset()); if (begEndAttrs[numPartKeyCols]->getVCIndicatorLength() > 0) alignedPartKeyLen = MINOF( alignedPartKeyLen, begEndAttrs[numPartKeyCols]->getVCLenIndOffset()); // generate a tuple desc for the whole PIV record and a cri desc partInputTupleDesc = new(generator->getSpace()) ExpTupleDesc( numPartInputs, begEndAttrs, myOwnPartInputDataLength, pivFormat, ExpTupleDesc::LONG_FORMAT, generator->getSpace()); partInputCriDesc->setTupleDescriptor(pivMoveAtpIndex,partInputTupleDesc); // make sure we fulfill the assertions we made // optimizer and generator should agree on the part input data length GenAssert(partInputDataLength == (Lng32) myOwnPartInputDataLength, "NOT partInputDataLength == myOwnPartInputDataLength"); // the length of the begin key and the end key must be the same // (compare offsets of their last fields) // Commented out because this check does not work. The check needs // to compute the LENGTH of each key field, by subtracting the current // offset from the next offset, taking into account varchar length // and null indicator fields (which are not part of the length but // increase the offset). //GenAssert(begEndAttrs[numPartKeyCols-1]->getOffset() + alignedPartKeyLen == // begEndAttrs[2*numPartKeyCols-1]->getOffset(), // "begin/end piv keys have different layouts"); #pragma nowarn(1506) // warning elimination generatedObject = new(generator->getSpace()) ExRangePartInputData( partInputCriDesc, partInputDataLength, alignedPartKeyLen, //len of one part key + filler begEndAttrs[numPartInputs-1]->getOffset(),//offset of last field getCountOfPartitions(), generator->getSpace(), TRUE); // uses expressions to calculate ranges in the executor generatedObject->setPartitionExprAtp(pivMoveAtp); generatedObject->setPartitionExprAtpIndex(pivMoveAtpIndex); #pragma warn(1506) // warning elimination // now fill in the individual partition boundaries // (NOTE: there is one more than there are partitions) ULng32 boundaryDataLength = 0; for (Lng32 i = 0; i <= getCountOfPartitions(); i++) { const ItemExprList *iel = partitionBoundaries_->getBoundaryValues(i); ex_expr * generatedExpr = NULL; ValueIdList boundaryColValues; ULng32 checkedBoundaryLength; // convert the ItemExpressionList iel into a ValueIdList for (CollIndex kc = 0; kc < iel->entries(); kc++) { ItemExpr *boundaryVal = (*iel)[kc]; // create a cast node to convert the boundary value to the // data type of the column ItemExpr *castBoundaryVal = new(generator->wHeap()) Cast(boundaryVal,&piv[kc].getType()); castBoundaryVal->bindNode(generator->getBindWA()); boundaryColValues.insert(castBoundaryVal->getValueId()); } // Now generate a contiguous move expression. Only for the first time // generate a tuple desc, since all tuples should be the same. exp_gen->generateContiguousMoveExpr( boundaryColValues, 0, // cast nodes created above will do the move, no conv nodes pivMoveAtp, pivMoveAtpIndex, pivFormat, checkedBoundaryLength, &generatedExpr); if (i == 0) { // first time set the actual part key data length boundaryDataLength = checkedBoundaryLength; } else { // all boundary values (piv tuples) must have the same layout // and therefore the same length GenAssert(boundaryDataLength == checkedBoundaryLength, "Partition boundary tuple layout mismatch"); } generatedObject->setPartitionStartExpr(i,generatedExpr); } NADELETEBASIC(begEndAttrs, generator->wHeap()); generator->setGenObj(NULL, (ComTdb*)generatedObject); return 0; }
ordinal_type Stokhos::MonomialProjGramSchmidtPCEBasis<ordinal_type, value_type>:: buildReducedBasis( ordinal_type max_p, value_type threshold, const Teuchos::SerialDenseMatrix<ordinal_type,value_type>& A, const Teuchos::SerialDenseMatrix<ordinal_type,value_type>& F, const Teuchos::Array<value_type>& weights, Teuchos::Array< Stokhos::MultiIndex<ordinal_type> >& terms_, Teuchos::Array<ordinal_type>& num_terms_, Teuchos::SerialDenseMatrix<ordinal_type,value_type>& Qp_, Teuchos::SerialDenseMatrix<ordinal_type,value_type>& Q_) { // Compute basis terms -- 2-D array giving powers for each linear index ordinal_type max_sz; CPBUtils::compute_terms(max_p, this->d, max_sz, terms_, num_terms_); // Compute B matrix -- monomials in F // for i=0,...,nqp-1 // for j=0,...,sz-1 // B(i,j) = F(i,1)^terms_[j][1] * ... * F(i,d)^terms_[j][d] // where sz is the total size of a basis up to order p and terms_[j] // is an array of powers for each term in the total-order basis ordinal_type nqp = weights.size(); SDM B(nqp, max_sz); for (ordinal_type i=0; i<nqp; i++) { for (ordinal_type j=0; j<max_sz; j++) { B(i,j) = 1.0; for (ordinal_type k=0; k<this->d; k++) B(i,j) *= std::pow(F(i,k), terms_[j][k]); } } // Project B into original basis -- should use SPAM for this SDM Bp(this->pce_sz, max_sz); const Teuchos::Array<value_type>& basis_norms = this->pce_basis->norm_squared(); for (ordinal_type i=0; i<this->pce_sz; i++) { for (ordinal_type j=0; j<max_sz; j++) { Bp(i,j) = 0.0; for (ordinal_type k=0; k<nqp; k++) Bp(i,j) += weights[k]*B(k,j)*A(k,i); Bp(i,j) /= basis_norms[i]; } } // Rescale columns of Bp to have unit norm for (ordinal_type j=0; j<max_sz; j++) { value_type nrm = 0.0; for (ordinal_type i=0; i<this->pce_sz; i++) nrm += Bp(i,j)*Bp(i,j)*basis_norms[i]; nrm = std::sqrt(nrm); for (ordinal_type i=0; i<this->pce_sz; i++) Bp(i,j) /= nrm; } // Compute our new basis -- each column of Qp is the coefficients of the // new basis in the original basis. Constraint pivoting so first d+1 // columns and included in Qp. Teuchos::Array<value_type> w(this->pce_sz, 1.0); SDM R; Teuchos::Array<ordinal_type> piv(max_sz); for (int i=0; i<this->d+1; i++) piv[i] = 1; typedef Stokhos::OrthogonalizationFactory<ordinal_type,value_type> SOF; ordinal_type sz_ = SOF::createOrthogonalBasis( this->orthogonalization_method, threshold, this->verbose, Bp, w, Qp_, R, piv); // Evaluate new basis at original quadrature points Q_.reshape(nqp, sz_); ordinal_type ret = Q_.multiply(Teuchos::NO_TRANS, Teuchos::NO_TRANS, 1.0, A, Qp_, 0.0); TEUCHOS_ASSERT(ret == 0); return sz_; }
void ResetXForm::ResetNodes(const INodeTab& nodesToReset) { Interface *ip = GetCOREInterface(); for (int i = 0; i < nodesToReset.Count(); i++) { INode *node = nodesToReset[i]; if (!node || node->IsGroupMember() || node->IsGroupHead()) continue; if (SelectedAncestor(node)) continue; Matrix3 ntm, ptm, rtm(1), piv(1), tm; // Get Parent and Node TMs ntm = node->GetNodeTM(ip->GetTime()); ptm = node->GetParentTM(ip->GetTime()); // Compute the relative TM ntm = ntm * Inverse(ptm); // The reset TM only inherits position rtm.SetTrans(ntm.GetTrans()); // Set the node TM to the reset TM tm = rtm*ptm; node->SetNodeTM(ip->GetTime(), tm); // Compute the pivot TM piv.SetTrans(node->GetObjOffsetPos()); PreRotateMatrix(piv,node->GetObjOffsetRot()); ApplyScaling(piv,node->GetObjOffsetScale()); // Reset the offset to 0 node->SetObjOffsetPos(Point3(0,0,0)); node->SetObjOffsetRot(IdentQuat()); node->SetObjOffsetScale(ScaleValue(Point3(1,1,1))); // Take the position out of the matrix since we don't reset position ntm.NoTrans(); // Apply the offset to the TM ntm = piv * ntm; // Apply a derived object to the node's object Object *obj = node->GetObjectRef(); IDerivedObject *dobj = CreateDerivedObject(obj); // Create an XForm mod SimpleMod *mod = (SimpleMod*)ip->CreateInstance( OSM_CLASS_ID, Class_ID(CLUSTOSM_CLASS_ID,0)); // Apply the transformation to the mod. SetXFormPacket pckt(ntm); mod->tmControl->SetValue(ip->GetTime(),&pckt); // Add the modifier to the derived object. dobj->SetAFlag(A_LOCK_TARGET); // RB 3/11/99: When the macro recorder is on the derived object will get deleted unless it is locked. dobj->AddModifier(mod); dobj->ClearAFlag(A_LOCK_TARGET); // Replace the node's object node->SetObjectRef(dobj); } // Why on earth were we clearing the undo stack? // GetSystemSetting(SYSSET_CLEAR_UNDO); ip->RedrawViews(ip->GetTime()); SetSaveRequiredFlag(TRUE); }