void extractInternalFaces(const Dune::CpGrid& grid, Eigen::Array<int, Eigen::Dynamic, 1>& internal_faces, Eigen::Array<int, Eigen::Dynamic, 2, Eigen::RowMajor>& nbi) { // Extracts the internal faces of the grid. // These are stored in internal_faces. int nf=numFaces(grid); int num_internal=0; for(int f=0; f<nf; ++f) { if(grid.faceCell(f, 0)<0 || grid.faceCell(f, 1)<0) continue; ++num_internal; } // std::cout << num_internal << " internal faces." << std::endl; nbi.resize(num_internal, 2); internal_faces.resize(num_internal); int fi = 0; for (int f = 0; f < nf; ++f) { if(grid.faceCell(f, 0)>=0 && grid.faceCell(f, 1)>=0) { internal_faces[fi] = f; nbi(fi,0) = grid.faceCell(f, 0); nbi(fi,1) = grid.faceCell(f, 1); ++fi; } } }
void factor_U(const Eigen::Matrix<T, Eigen::Dynamic, Eigen::Dynamic>& U, Eigen::Array<T, Eigen::Dynamic, 1>& CPCs) { size_t K = U.rows(); size_t position = 0; size_t pull = K - 1; if (K == 2) { CPCs(0) = atanh(U(0, 1)); return; } Eigen::Array<T, 1, Eigen::Dynamic> temp = U.row(0).tail(pull); CPCs.head(pull) = temp; Eigen::Array<T, Eigen::Dynamic, 1> acc(K); acc(0) = -0.0; acc.tail(pull) = 1.0 - temp.square(); for (size_t i = 1; i < (K - 1); i++) { position += pull; pull--; temp = U.row(i).tail(pull); temp /= sqrt(acc.tail(pull) / acc(i)); CPCs.segment(position, pull) = temp; acc.tail(pull) *= 1.0 - temp.square(); } CPCs = 0.5 * ( (1.0 + CPCs) / (1.0 - CPCs) ).log(); // now unbounded }
Eigen::Matrix<T, Eigen::Dynamic, Eigen::Dynamic> read_corr_L(const Eigen::Array<T, Eigen::Dynamic, 1>& CPCs, // on (-1, 1) size_t K) { Eigen::Array<T, Eigen::Dynamic, 1> temp; Eigen::Array<T, Eigen::Dynamic, 1> acc(K-1); acc.setOnes(); // Cholesky factor of correlation matrix Eigen::Array<T, Eigen::Dynamic, Eigen::Dynamic> L(K, K); L.setZero(); size_t position = 0; size_t pull = K - 1; L(0, 0) = 1.0; L.col(0).tail(pull) = temp = CPCs.head(pull); acc.tail(pull) = T(1.0) - temp.square(); for (size_t i = 1; i < (K - 1); i++) { position += pull; pull--; temp = CPCs.segment(position, pull); L(i, i) = sqrt(acc(i-1)); L.col(i).tail(pull) = temp * acc.tail(pull).sqrt(); acc.tail(pull) *= T(1.0) - temp.square(); } L(K-1, K-1) = sqrt(acc(K-2)); return L.matrix(); }
void operator() (Image<value_type>& dec_img) { w = 1.0; if (w_img.valid()) { assign_pos_of(dec_img, 0, 3).to(w_img); w = w_img.value(); if (w <= 0.0) { for (auto l = Loop (3) (dec_img); l; ++l) dec_img.value() = 0.0; return; } } for (auto l = Loop (3) (dec_img); l; ++l) dec[dec_img.index(3)] = dec_img.value(); dec = dec.cwiseMax(0.0); br = std::pow((dec.pow(gamma) * coefs).sum() , 1.0 / gamma); if (br == 0.0) dec.fill(grey * w); else dec = dec * (w / br); for (auto l = Loop (3) (dec_img); l; ++l) dec_img.value() = dec[dec_img.index(3)]; }
void extractInternalFaces(const UnstructuredGrid& grid, Eigen::Array<int, Eigen::Dynamic, 1>& internal_faces, Eigen::Array<int, Eigen::Dynamic, 2, Eigen::RowMajor>& nbi) { typedef Eigen::Array<bool, Eigen::Dynamic, 1> OneColBool; typedef Eigen::Array<int, Eigen::Dynamic, 2, Eigen::RowMajor> TwoColInt; typedef Eigen::Array<bool, Eigen::Dynamic, 2, Eigen::RowMajor> TwoColBool; TwoColInt nb = faceCells(grid); // std::cout << "nb = \n" << nb << std::endl; // Extracts the internal faces of the grid. // These are stored in internal_faces. TwoColBool nbib = nb >= 0; OneColBool ifaces = nbib.rowwise().all(); const int num_internal = ifaces.cast<int>().sum(); // std::cout << num_internal << " internal faces." << std::endl; nbi.resize(num_internal, 2); internal_faces.resize(num_internal); int fi = 0; int nf = numFaces(grid); for (int f = 0; f < nf; ++f) { if (ifaces[f]) { internal_faces[fi] = f; nbi.row(fi) = nb.row(f); ++fi; } } }
void saveAsBitmap(const Eigen::VectorXd& x, int n, const char* filename) { Eigen::Array<unsigned char,Eigen::Dynamic,Eigen::Dynamic> bits = (x*255).cast<unsigned char>(); QImage img(bits.data(), n,n,QImage::Format_Indexed8); img.setColorCount(256); for(int i=0;i<256;i++) img.setColor(i,qRgb(i,i,i)); img.save(filename); }
typename boost::math::tools::promote_args<T_y,T_loc,T_scale,T_shape>::type lkj_cov_log(const Eigen::Matrix<T_y,Eigen::Dynamic,Eigen::Dynamic>& y, const Eigen::Matrix<T_loc,Eigen::Dynamic,1>& mu, const Eigen::Matrix<T_scale,Eigen::Dynamic,1>& sigma, const T_shape& eta, const Policy&) { static const char* function = "stan::prob::lkj_cov_log(%1%)"; using stan::math::check_size_match; using stan::math::check_finite; using stan::math::check_positive; using boost::math::tools::promote_args; typename promote_args<T_y,T_loc,T_scale,T_shape>::type lp(0.0); if (!check_size_match(function, mu.rows(), "Rows of location parameter", sigma.rows(), "columns of scale parameter", &lp, Policy())) return lp; if (!check_size_match(function, y.rows(), "Rows of random variable", y.cols(), "columns of random variable", &lp, Policy())) return lp; if (!check_size_match(function, y.rows(), "Rows of random variable", mu.rows(), "rows of location parameter", &lp, Policy())) return lp; if (!check_positive(function, eta, "Shape parameter", &lp, Policy())) return lp; if (!check_finite(function, mu, "Location parameter", &lp, Policy())) return lp; if (!check_finite(function, sigma, "Scale parameter", &lp, Policy())) return lp; // FIXME: build vectorized versions for (int m = 0; m < y.rows(); ++m) for (int n = 0; n < y.cols(); ++n) if (!check_finite(function, y(m,n), "Covariance matrix", &lp, Policy())) return lp; const unsigned int K = y.rows(); const Eigen::Array<T_y,Eigen::Dynamic,1> sds = y.diagonal().array().sqrt(); for (unsigned int k = 0; k < K; k++) { lp += lognormal_log<propto>(sds(k), mu(k), sigma(k), Policy()); } if (stan::is_constant<typename stan::scalar_type<T_shape> >::value && eta == 1.0) { // no need to rescale y into a correlation matrix lp += lkj_corr_log<propto,T_y,T_shape,Policy>(y, eta, Policy()); return lp; } Eigen::DiagonalMatrix<T_y,Eigen::Dynamic> D(K); D.diagonal() = sds.inverse(); lp += lkj_corr_log<propto,T_y,T_shape,Policy>(D * y * D, eta, Policy()); return lp; }
Eigen::Matrix<T, Eigen::Dynamic, Eigen::Dynamic> read_cov_L(const Eigen::Array<T, Eigen::Dynamic, 1>& CPCs, const Eigen::Array<T, Eigen::Dynamic, 1>& sds, T& log_prob) { size_t K = sds.rows(); // adjust due to transformation from correlations to covariances log_prob += (sds.log().sum() + LOG_2) * K; return sds.matrix().asDiagonal() * read_corr_L(CPCs, K, log_prob); }
void SLHA_io::convert_symmetric_fermion_mixings_to_slha(Eigen::Array<double, N, 1>& m, Eigen::Matrix<std::complex<double>, N, N>& z) { for (int i = 0; i < N; i++) { // check if i'th row contains non-zero imaginary parts if (!is_zero(z.row(i).imag().cwiseAbs().maxCoeff())) { z.row(i) *= std::complex<double>(0.0,1.0); m(i) *= -1; } } }
Eigen::MatrixXd eddy2scheme (const Eigen::MatrixXd& config, const Eigen::Array<int, Eigen::Dynamic, 1>& indices) { if (config.cols() != 4) throw Exception ("Expected 4 columns in EDDY-format phase-encoding config file"); Eigen::MatrixXd result (indices.size(), 4); for (ssize_t row = 0; row != indices.size(); ++row) { if (indices[row] > config.rows()) throw Exception ("Malformed EDDY-style phase-encoding information: Index exceeds number of config entries"); result.row(row) = config.row(indices[row]-1); } return result; }
IGL_INLINE void igl::ears( const Eigen::MatrixBase<DerivedF> & F, Eigen::PlainObjectBase<Derivedear> & ear, Eigen::PlainObjectBase<Derivedear_opp> & ear_opp) { assert(F.cols() == 3 && "F should contain triangles"); Eigen::Array<bool,Eigen::Dynamic,3> B; { Eigen::Array<bool,Eigen::Dynamic,1> I; on_boundary(F,I,B); } find(B.rowwise().count() == 2,ear); Eigen::Array<bool,Eigen::Dynamic,3> Bear; slice(B,ear,1,Bear); Eigen::Array<bool,Eigen::Dynamic,1> M; mat_min(Bear,2,M,ear_opp); }
void SLHA_io::convert_symmetric_fermion_mixings_to_hk(Eigen::Array<double, N, 1>& m, Eigen::Matrix<std::complex<double>, N, N>& z) { for (int i = 0; i < N; i++) { if (m(i) < 0.) { z.row(i) *= std::complex<double>(0.0,1.0); m(i) *= -1; } } }
void Streamer::calculateAverageUpdateTime() { static boost::chrono::steady_clock::time_point currentTime, lastRecordedTime; static Eigen::Array<float, 5, 1> recordedTimes = Eigen::Array<float, 5, 1>::Zero(); currentTime = boost::chrono::steady_clock::now(); if (lastRecordedTime.time_since_epoch().count()) { if (!(recordedTimes > 0).all()) { boost::chrono::duration<float> elapsedTime = currentTime - lastRecordedTime; recordedTimes[(recordedTimes > 0).count()] = elapsedTime.count(); } else { averageUpdateTime = recordedTimes.mean() * 50.0f; recordedTimes.setZero(); } } lastRecordedTime = currentTime; }
int FeatureTransformationEstimator::consensus3D(Eigen::MatrixXd P, Eigen::MatrixXd Q, Eigen::Isometry3d T, double thresh, Eigen::Array<bool, 1, Eigen::Dynamic> &consensusSet) { int consensus = 0; P = T * P.colwise().homogeneous(); Eigen::MatrixXd norms = (P - Q).colwise().norm(); consensusSet = norms.array() < thresh; consensus = consensusSet.count(); return consensus; }
void BinaryInputStream::readVector (Eigen::Array<FinalType,Rows,1> &values, size_t n) { values.resize(n); SourceType value; for (size_t i=0; i<n; i++) { stream->read((char *) &value, sizeof(SourceType)); if (swapEndian) swap(&value); values[i] = static_cast<FinalType>(value); } }
void LQCDA::readVector(AsciiReader& reader, Eigen::Array<double, Eigen::Dynamic, 1>& output) { try { int i; reader.read(i); output.resize(i); for(int _i=0; _i<i; ++_i) reader.read(output(_i)); } catch (const IOException& e) { } }
typename boost::math::tools::promote_args<T_y,T_loc,T_scale,T_shape>::type lkj_cov_log(const Eigen::Matrix<T_y,Eigen::Dynamic,Eigen::Dynamic>& y, const T_loc& mu, const T_scale& sigma, const T_shape& eta, const Policy&) { static const char* function = "stan::prob::lkj_cov_log(%1%)"; using stan::math::check_finite; using stan::math::check_positive; using boost::math::tools::promote_args; typename promote_args<T_y,T_loc,T_scale,T_shape>::type lp(0.0); if (!check_positive(function, eta, "Shape parameter", &lp, Policy())) return lp; if (!check_finite(function, mu, "Location parameter", &lp, Policy())) return lp; if (!check_finite(function, sigma, "Scale parameter", &lp, Policy())) return lp; const unsigned int K = y.rows(); const Eigen::Array<T_y,Eigen::Dynamic,1> sds = y.diagonal().array().sqrt(); for (unsigned int k = 0; k < K; k++) { lp += lognormal_log<propto>(sds(k), mu, sigma, Policy()); } if (stan::is_constant<typename stan::scalar_type<T_shape> >::value && eta == 1.0) { // no need to rescale y into a correlation matrix lp += lkj_corr_log<propto>(y,eta,Policy()); return lp; } Eigen::DiagonalMatrix<T_y,Eigen::Dynamic> D(K); D.diagonal() = sds.inverse(); lp += lkj_corr_log<propto,T_y,T_shape,Policy>(D * y * D, eta, Policy()); return lp; }
// project points outside of domain back to boundary void distmesh::utils::projectPointsToBoundary( Functional const& distanceFunction, double const initialPointDistance, Eigen::Ref<Eigen::ArrayXXd> points) { Eigen::ArrayXd distance = distanceFunction(points); // check for points outside of boundary Eigen::Array<bool, Eigen::Dynamic, 1> outside = distance > 0.0; if (outside.any()) { // calculate gradient Eigen::ArrayXXd gradient(points.rows(), points.cols()); Eigen::ArrayXXd deltaX = Eigen::ArrayXXd::Zero(points.rows(), points.cols()); for (int dim = 0; dim < points.cols(); ++dim) { deltaX.col(dim).fill(constants::deltaX * initialPointDistance); gradient.col(dim) = (distanceFunction(points + deltaX) - distance) / (constants::deltaX * initialPointDistance); deltaX.col(dim).fill(0.0); } // project points back to boundary points -= outside.replicate(1, points.cols()).select( gradient.colwise() * distance / gradient.square().rowwise().sum(), 0.0); } }
Eigen::Matrix<T, Eigen::Dynamic, Eigen::Dynamic> read_corr_L(const Eigen::Array<T, Eigen::Dynamic, 1>& CPCs, size_t K, T& log_prob) { Eigen::Matrix<T, Eigen::Dynamic, 1> values(CPCs.rows() - 1); size_t pos = 0; // no need to abs() because this Jacobian determinant // is strictly positive (and triangular) // see inverse of Jacobian in equation 11 of LKJ paper for (size_t k = 1; k <= (K - 2); k++) for (size_t i = k + 1; i <= K; i++) { values(pos) = (K - k - 1) * log1m(square(CPCs(pos))); pos++; } log_prob += 0.5 * sum(values); return read_corr_L(CPCs, K); }
//----------------------------------------------------------- // Utility functions //----------------------------------------------------------- void LQCDA::readArray(AsciiReader& reader, Eigen::Array<double, Eigen::Dynamic, Eigen::Dynamic>& output) { try { std::string line; reader.readLine(line); std::istringstream isstr (line); int i, j; isstr >> i >> j; output.resize(i, j); for(int _i=0; _i<i; ++_i) for(int _j=0; _j<j; ++_j) { reader.read(output(_i,_j)); } } catch (const IOException& e) { } }
int FeatureTransformationEstimator::consensusReprojection(Eigen::MatrixXd P, Eigen::MatrixXd Q, Eigen::Isometry3d T, double thresh, Eigen::Array<bool, 1, Eigen::Dynamic> &consensusSet) { Eigen::MatrixXd Pproj(2, P.cols()); Eigen::MatrixXd Qproj(2, P.cols()); for (int i = 0; i < P.cols(); i++) { Eigen::Vector3d PT = T * P.col(i).homogeneous(); Pproj(0,i) = pnp.uc + pnp.fu * PT(0) / PT(2); Pproj(1,i) = pnp.vc + pnp.fv * PT(1) / PT(2); Qproj(0,i) = pnp.uc + pnp.fu * Q(0,i) / Q(2,i); Qproj(1,i) = pnp.vc + pnp.fv * Q(1,i) / Q(2,i); } int consensus = 0; Eigen::MatrixXd norms = (Pproj - Qproj).colwise().norm(); consensusSet = norms.array() < thresh; consensus = consensusSet.count(); return consensus; }
Eigen::Matrix<Scalar, Eigen::Dynamic, Eigen::Dynamic> operator() ( const Eigen::Array<Scalar, Rows, Cols>& a, const Eigen::Array<Scalar, Rows, Cols>& b) { return a.matrix() * b.matrix().transpose(); }
bool SavePng(std::string filename, const DepthImage& img) { // Open up a file for writing FILE* output = fopen(filename.c_str(), "wb"); if (output == NULL) { printf("Failed to open PNG file for writing (errno = %i)\n", errno); return false; } // Create a png pointer with the callbacks above png_structp png_ptr = png_create_write_struct( PNG_LIBPNG_VER_STRING, NULL, on_png_error, on_png_warn); if (png_ptr == NULL) { fprintf(stderr, "Failed to allocate png write_struct\n"); fclose(output); return false; } // Create an info pointer png_infop info_ptr = png_create_info_struct(png_ptr); if (info_ptr == NULL) { fprintf(stderr, "Failed to create png info_struct"); png_destroy_write_struct(&png_ptr, &info_ptr); fclose(output); return false; } // Set physical vars png_set_IHDR(png_ptr, info_ptr, img.cols(), img.rows(), 16, PNG_COLOR_TYPE_GRAY, PNG_INTERLACE_NONE, PNG_COMPRESSION_TYPE_BASE, PNG_FILTER_TYPE_BASE); png_init_io(png_ptr, output); const float zmax = img.maxCoeff(); const float zmin = (img == -std::numeric_limits<float>::infinity()) .select(DepthImage::Constant(img.rows(), img.cols(), zmax), img) .minCoeff(); auto scaled = (zmax == zmin) ? DepthImage((img - zmin) + 65535) : DepthImage((img - zmin) * 65534 / (zmax - zmin) + 1); Eigen::Array<uint16_t, Eigen::Dynamic, Eigen::Dynamic> pixels = scaled.cast<uint16_t>().transpose(); std::vector<uint16_t*> rows; for (int i=pixels.cols() - 1; i >= 0; --i) { rows.push_back(pixels.data() + i * pixels.rows()); } png_set_rows(png_ptr, info_ptr, reinterpret_cast<png_bytepp>(&rows[0])); png_write_png(png_ptr, info_ptr, PNG_TRANSFORM_SWAP_ENDIAN, NULL); fclose(output); png_destroy_write_struct(&png_ptr, &info_ptr); return true; }
mglData mgl(const Eigen::Array<Scalar, Eigen::Dynamic, 1>& d) { return mglData(d.size(), d.data()); }
DecWeighter (Eigen::Matrix<value_type, 3, 1> coefs, value_type gamma, Image<value_type>& w_img) : coefs (coefs), gamma (gamma), w_img (w_img), grey (1.0 / std::pow(coefs.sum(), 1.0 / gamma)) {}