void LaplacianOperator::computeLaplacianOperator( Eigen::SparseMatrix<double>& laplacianOperator )
{
laplacianOperator.resize(mMeshVertexCount,mMeshVertexCount);
laplacianOperator.reserve(Eigen::VectorXi::Constant(mMeshVertexCount,10));
for (int i = 0; i < mMeshVertexCount; i++)
{
/* 如果第i个点没有邻接点，即它是一个孤立的点，那么它的laplacian坐标为0 */
if( adjacentMatrix.innerVector(i).nonZeros() == 0)
{
laplacianOperator.insert(i,i) = 0;
continue;
}
laplacianOperator.insert(i,i) = 1;
#ifdef MY_DEBUG
int adjCount = 0;
#endif
for (Eigen::SparseMatrix<double>::InnerIterator it(adjacentMatrix,i); it; it++)
{
if(i != it.row())
{
laplacianOperator.insert(i,it.row()) = -1/degreeMatrix(i);
#ifdef MY_DEBUG
adjCount++;
if(adjCount >= 10)
printf("InnerVector size should expand! CurrentMax:%d.\n",adjCount);
#endif
}
}
}
}
IGL_INLINE void igl::sparse(
const IndexVector & I,
const IndexVector & J,
const ValueVector & V,
const size_t m,
const size_t n,
Eigen::SparseMatrix<T>& X)
{
using namespace std;
using namespace Eigen;
assert((int)I.maxCoeff() < (int)m);
assert((int)I.minCoeff() >= 0);
assert((int)J.maxCoeff() < (int)n);
assert((int)J.minCoeff() >= 0);
assert(I.size() == J.size());
assert(J.size() == V.size());
// Really we just need .size() to be the same, but this is safer
assert(I.rows() == J.rows());
assert(J.rows() == V.rows());
assert(I.cols() == J.cols());
assert(J.cols() == V.cols());
vector<Triplet<T> > IJV;
IJV.reserve(I.size());
for(int x = 0;x<I.size();x++)
{
IJV.push_back(Triplet<T >(I(x),J(x),V(x)));
}
X.resize(m,n);
X.setFromTriplets(IJV.begin(),IJV.end());
}
ZSparseMatrix Assembler2D::getDisplacementStrainMatrix() {
typedef Eigen::Triplet<double> T;
std::vector<T> triplets;
for (size_t i=0; i<m_mesh->getNbrElements(); i++) {
Eigen::MatrixXd dN = m_DN[i];
VectorI idx = m_mesh->getElement(i);
assert(idx.size() == 3);
double V = m_mesh->getElementVolume(i);
// e_xx
size_t row = i * 3;
for (size_t k=0; k<3; k++) {
triplets.push_back(T(row, idx[k]*2, dN(k,0)));
}
// e_yy
row++;
for (size_t k=0; k<3; k++) {
triplets.push_back(T(row, idx[k]*2+1, dN(k,1)));
}
// e_xy
row++;
for (size_t k=0; k<3; k++) {
triplets.push_back(T(row, idx[k]*2 , dN(k,1) / 2.0));
triplets.push_back(T(row, idx[k]*2+1, dN(k,0) / 2.0));
}
}
Eigen::SparseMatrix<double> B = Eigen::SparseMatrix<double>(3*m_mesh->getNbrElements(), 2*m_mesh->getNbrNodes());
B.setFromTriplets(triplets.begin(), triplets.end());
return ZSparseMatrix(B);
}
void SetConstraints(Eigen::SparseMatrix<float>::InnerIterator& it, int index)
{
if (it.row() == index || it.col() == index)
{
it.valueRef() = it.row() == it.col() ? 1.0f : 0.0f;
}
}
void ProbitNoise::evalModel(Eigen::SparseMatrix<double> & Ytest, const int n, Eigen::VectorXd & predictions, Eigen::VectorXd & predictions_var, const Eigen::MatrixXd &cols, const Eigen::MatrixXd &rows, double mean_rating) {
const unsigned N = Ytest.nonZeros();
Eigen::VectorXd pred(N);
Eigen::VectorXd test(N);
// #pragma omp parallel for schedule(dynamic,8) reduction(+:se, se_avg) <- dark magic :)
for (int k = 0; k < Ytest.outerSize(); ++k) {
int idx = Ytest.outerIndexPtr()[k];
for (Eigen::SparseMatrix<double>::InnerIterator it(Ytest,k); it; ++it) {
pred[idx] = nCDF(cols.col(it.col()).dot(rows.col(it.row())));
test[idx] = it.value();
// https://en.wikipedia.org/wiki/Algorithms_for_calculating_variance#Online_algorithm
double pred_avg;
if (n == 0) {
pred_avg = pred[idx];
} else {
double delta = pred[idx] - predictions[idx];
pred_avg = (predictions[idx] + delta / (n + 1));
predictions_var[idx] += delta * (pred[idx] - pred_avg);
}
predictions[idx++] = pred_avg;
}
}
auc_test_onesample = auc(pred,test);
auc_test = auc(predictions, test);
}
ZSparseMatrix Assembler2D::getLaplacianMatrix() {
typedef Eigen::Triplet<double> T;
std::vector<T> triplets;
for (size_t i=0; i<m_mesh->getNbrElements(); ++i)
{
VectorI idx = m_mesh->getElement(i);
assert(idx.size() == 3);
Eigen::MatrixXd& dN = m_DN[i];
// Small strain-displacement matrix
//
Eigen::MatrixXd B(2,3);
B << dN(0,0), dN(1,0), dN(2,0),
dN(0,1), dN(1,1), dN(2,1);
Eigen::MatrixXd k_el = B.transpose() * B * m_mesh->getElementVolume(i);
for (size_t j=0; j<3; ++j)
for (size_t k=0; k<3; ++k)
triplets.push_back(T(idx[j], idx[k], k_el(j,k)));
}
Eigen::SparseMatrix<double> L = Eigen::SparseMatrix<double>(m_mesh->getNbrNodes(), m_mesh->getNbrNodes());
L.setFromTriplets(triplets.begin(), triplets.end());
return ZSparseMatrix(L);
}
void igl::crouzeix_raviart_massmatrix(
const Eigen::PlainObjectBase<DerivedV> & V,
const Eigen::PlainObjectBase<DerivedF> & F,
const Eigen::PlainObjectBase<DerivedE> & E,
const Eigen::PlainObjectBase<DerivedEMAP> & EMAP,
Eigen::SparseMatrix<MT> & M)
{
using namespace Eigen;
using namespace std;
assert(F.cols() == 3);
// Mesh should be edge-manifold
assert(is_edge_manifold(F));
// number of elements (triangles)
int m = F.rows();
// Get triangle areas
VectorXd TA;
doublearea(V,F,TA);
vector<Triplet<MT> > MIJV(3*m);
for(int f = 0;f<m;f++)
{
for(int c = 0;c<3;c++)
{
MIJV[f+m*c] = Triplet<MT>(EMAP(f+m*c),EMAP(f+m*c),TA(f)*0.5);
}
}
M.resize(E.rows(),E.rows());
M.setFromTriplets(MIJV.begin(),MIJV.end());
}
IGL_INLINE void igl::find(
const Eigen::SparseMatrix<T>& X,
Eigen::DenseBase<DerivedI> & I,
Eigen::DenseBase<DerivedJ> & J,
Eigen::DenseBase<DerivedV> & V)
{
// Resize outputs to fit nonzeros
I.derived().resize(X.nonZeros(),1);
J.derived().resize(X.nonZeros(),1);
V.derived().resize(X.nonZeros(),1);
int i = 0;
// Iterate over outside
for(int k=0; k<X.outerSize(); ++k)
{
// Iterate over inside
for(typename Eigen::SparseMatrix<T>::InnerIterator it (X,k); it; ++it)
{
V(i) = it.value();
I(i) = it.row();
J(i) = it.col();
i++;
}
}
}
void LTransform::Create_spMat_U(Eigen::SparseMatrix<double> &spMat_U){
//*****************************
//2015-06-29 TYPE=Notes
//*****************************
//求解笛卡尔坐标;2.构建控制点矩阵spMat_U;
//*****************************
//spMat_U=spMat_V;
//*****************************
qDebug() <<"START:spMat_U.insert"<< endl;
for(int i=0;i<LMT_point.size();i++){
spMat_U.insert(LMT_point[i].index,0)=LMT_point[i].X;
spMat_U.insert(LMT_point[i].index,1)=LMT_point[i].Y;
spMat_U.insert(LMT_point[i].index,2)=LMT_point[i].Z;
}
for (int k=0; k<spMat_V.outerSize(); ++k)
for (Eigen::SparseMatrix<double>::InnerIterator it(spMat_V,k); it; ++it){
if(!objMesh.is_limitP(LMT_point,it.row())){
spMat_U.insert(it.row(),it.col())=it.value();
}
}
qDebug() <<"END:spMat_U.insert"<< endl;
}//控制点坐标矩阵;
IGL_INLINE void igl::min(
const Eigen::SparseMatrix<AType> & A,
const int dim,
Eigen::PlainObjectBase<DerivedB> & B,
Eigen::PlainObjectBase<DerivedI> & I)
{
const int n = A.cols();
const int m = A.rows();
B.resize(dim==1?n:m);
B.setConstant(std::numeric_limits<typename DerivedB::Scalar>::max());
I.resize(dim==1?n:m);
for_each(A,[&B,&I,&dim](int i, int j,const typename DerivedB::Scalar v)
{
if(dim == 2)
{
std::swap(i,j);
}
// Coded as if dim == 1, assuming swap for dim == 2
if(v < B(j))
{
B(j) = v;
I(j) = i;
}
});
Eigen::VectorXi Z;
find_zero(A,dim,Z);
for(int j = 0;j<I.size();j++)
{
if(Z(j) != (dim==1?m:n) && 0 < B(j))
{
B(j) = 0;
I(j) = Z(j);
}
}
}
IGL_INLINE void igl::PolyVectorFieldFinder<DerivedV, DerivedF>::computeCoefficientLaplacian(int n, Eigen::SparseMatrix<std::complex<typename DerivedV::Scalar> > &D)
{
std::vector<Eigen::Triplet<std::complex<typename DerivedV::Scalar> >> tripletList;
// For every non-border edge
for (unsigned eid=0; eid<numE; ++eid)
{
if (!isBorderEdge[eid])
{
int fid0 = E2F(eid,0);
int fid1 = E2F(eid,1);
tripletList.push_back(Eigen::Triplet<std::complex<typename DerivedV::Scalar> >(fid0,
fid0,
std::complex<typename DerivedV::Scalar>(1.)));
tripletList.push_back(Eigen::Triplet<std::complex<typename DerivedV::Scalar> >(fid1,
fid1,
std::complex<typename DerivedV::Scalar>(1.)));
tripletList.push_back(Eigen::Triplet<std::complex<typename DerivedV::Scalar> >(fid0,
fid1,
-1.*std::polar(1.,-1.*n*K[eid])));
tripletList.push_back(Eigen::Triplet<std::complex<typename DerivedV::Scalar> >(fid1,
fid0,
-1.*std::polar(1.,1.*n*K[eid])));
}
}
D.resize(numF,numF);
D.setFromTriplets(tripletList.begin(), tripletList.end());
}
IGL_INLINE void igl::in_element(
const Eigen::PlainObjectBase<DerivedV> & V,
const Eigen::MatrixXi & Ele,
const Eigen::PlainObjectBase<DerivedQ> & Q,
const AABB<DerivedV,DIM> & aabb,
Eigen::SparseMatrix<Scalar> & I)
{
using namespace std;
using namespace Eigen;
using namespace igl;
const int Qr = Q.rows();
std::vector<Triplet<Scalar> > IJV;
IJV.reserve(Qr);
#pragma omp parallel for if (Qr>10000)
for(int e = 0;e<Qr;e++)
{
// find all
const auto R = aabb.find(V,Ele,Q.row(e),false);
for(const auto r : R)
{
#pragma omp critical
IJV.push_back(Triplet<Scalar>(e,r,1));
}
}
I.resize(Qr,Ele.rows());
I.setFromTriplets(IJV.begin(),IJV.end());
}
IGL_INLINE void igl::in_element(
const Eigen::MatrixXd & V,
const Eigen::MatrixXi & Ele,
const Eigen::MatrixXd & Q,
const InElementAABB & aabb,
Eigen::SparseMatrix<double> & I)
{
using namespace std;
using namespace Eigen;
using namespace igl;
const int Qr = Q.rows();
std::vector<Triplet<double> > IJV;
IJV.reserve(Qr);
#pragma omp parallel for
for(int e = 0;e<Qr;e++)
{
// find all
const auto R = aabb.find(V,Ele,Q.row(e),false);
for(const auto r : R)
{
#pragma omp critical
IJV.push_back(Triplet<double>(e,r,1));
}
}
I.resize(Qr,Ele.rows());
I.setFromTriplets(IJV.begin(),IJV.end());
}
IGL_INLINE void igl::slice_into(
const Eigen::SparseMatrix<T>& X,
const Eigen::Matrix<int,Eigen::Dynamic,1> & R,
const Eigen::Matrix<int,Eigen::Dynamic,1> & C,
Eigen::SparseMatrix<T>& Y)
{
int xm = X.rows();
int xn = X.cols();
assert(R.size() == xm);
assert(C.size() == xn);
#ifndef NDEBUG
int ym = Y.size();
int yn = Y.size();
assert(R.minCoeff() >= 0);
assert(R.maxCoeff() < ym);
assert(C.minCoeff() >= 0);
assert(C.maxCoeff() < yn);
#endif
// create temporary dynamic sparse matrix
Eigen::DynamicSparseMatrix<T, Eigen::RowMajor> dyn_Y(Y);
// Iterate over outside
for(int k=0; k<X.outerSize(); ++k)
{
// Iterate over inside
for(typename Eigen::SparseMatrix<T>::InnerIterator it (X,k); it; ++it)
{
dyn_Y.coeffRef(R(it.row()),C(it.col())) = it.value();
}
}
Y = Eigen::SparseMatrix<T>(dyn_Y);
}
void place::erodeSparse(const Eigen::SparseMatrix<double> &src,
Eigen::SparseMatrix<double> &dst) {
dst = Eigen::SparseMatrix<double>(src.rows(), src.cols());
std::vector<Eigen::Triplet<double>> tripletList;
Eigen::MatrixXd srcNS = Eigen::MatrixXd(src);
for (int i = 0; i < srcNS.cols(); ++i) {
for (int j = 0; j < srcNS.rows(); ++j) {
double value = 0.0;
for (int k = -1; k < 1; ++k) {
for (int l = -1; l < 1; ++l) {
if (i + k < 0 || i + k >= srcNS.cols() || j + l < 0 ||
j + l >= srcNS.rows())
continue;
else
value = std::max(value, srcNS(j + l, i + k));
}
}
if (value != 0)
tripletList.push_back(Eigen::Triplet<double>(j, i, value));
}
}
dst.setFromTriplets(tripletList.begin(), tripletList.end());
}
// fmap case
void create_matrix(const paracel::list_type<paracel::str_type> & linelst,
Eigen::SparseMatrix<double, Eigen::RowMajor> & blk_mtx,
paracel::dict_type<size_t, paracel::str_type> & rm,
paracel::dict_type<size_t, paracel::str_type> & cm,
paracel::dict_type<size_t, int> & dm,
paracel::dict_type<size_t, int> & col_dm) {
paracel::scheduler scheduler(m_comm, pattern, mix); // TODO
// hash lines into slotslst
auto result = scheduler.lines_organize(linelst, parserfunc);
std::cout << "procs " << m_comm.get_rank() << " slotslst generated" << std::endl;
m_comm.sync();
// alltoall exchange
auto stf = scheduler.exchange(result);
std::cout << "procs " << m_comm.get_rank() << " get desirable lines" << std::endl;
m_comm.sync();
// mapping inds to ids, get rmap, cmap, std_new...
paracel::list_type<std::tuple<size_t, size_t, double> > stf_new;
scheduler.index_mapping(stf, stf_new, rm, cm, dm, col_dm);
std::cout << "procs " << m_comm.get_rank() << " index mapping" << std::endl;
// create block sparse matrix
paracel::list_type<eigen_triple> nonzero_tpls;
for(auto & tpl : stf_new) {
nonzero_tpls.push_back(eigen_triple(std::get<0>(tpl), std::get<1>(tpl), std::get<2>(tpl)));
}
blk_mtx.resize(rm.size(), cm.size());
blk_mtx.setFromTriplets(nonzero_tpls.begin(), nonzero_tpls.end());
}
matrix<Type> invertSparseMatrix(Eigen::SparseMatrix<Type> A){
matrix<Type> I(A.rows(),A.cols());
I.setIdentity();
Eigen::SimplicialLDLT< Eigen::SparseMatrix<Type> > ldlt(A);
matrix<Type> ans = ldlt.solve(I);
return ans;
}
// inserts the sparse matrix 'ins' into the sparse matrix 'original' in the place given by 'row' and 'col' integers
void insertSparseBlock(const Eigen::SparseMatrix<Scalar>& ins, Eigen::SparseMatrix<Scalar>& original, const unsigned int& row, const unsigned int& col)
{
for (int k=0; k<ins.outerSize(); ++k)
for (Eigen::SparseMatrix<Scalar>::InnerIterator iti(ins,k); iti; ++iti)
original.coeffRef(iti.row() + row, iti.col() + col) = iti.value();
original.makeCompressed();
}
void CodeAtlas::FuzzyDependBuilder::buildChildDepend( QMultiHash<QString, ChildPack>& childList ,
Eigen::SparseMatrix<double>& vtxEdgeMat,
Eigen::VectorXd& edgeWeightVec,
QList<FuzzyDependAttr::DependPair>& dependPair)
{
QStringList codeList;
QVector<ChildPack*> childPackPtr;
for (QMultiHash<QString, ChildPack>::Iterator pChild = childList.begin();
pChild != childList.end(); ++pChild)
{
codeList.push_back(pChild.value().m_code);
childPackPtr.push_back(&pChild.value());
}
std::vector<Triplet> tripletArray;
QVector<double> edgeWeightArray;
// add dependency edges between child nodes
int ithSrc = 0;
for (QMultiHash<QString, ChildPack>::Iterator pChild = childList.begin();
pChild != childList.end(); ++pChild, ++ithSrc)
{
// for each child, find number of occurrences of this child's name
ChildPack& srcChild = pChild.value();
const QString& srcName = pChild.key();
QVector<int> occurence;
WordExtractor::findOccurrence(srcName, codeList, occurence);
for (int ithTar = 0; ithTar < childPackPtr.size(); ++ithTar)
{
int nOccur = occurence[ithTar];
if (nOccur == 0 || ithTar == ithSrc)
continue;
ChildPack& tarChild = *childPackPtr[ithTar];
SymbolEdge::Ptr pEdge = SymbolTree::getOrAddEdge(srcChild.m_pNode, tarChild.m_pNode, SymbolEdge::EDGE_FUZZY_DEPEND);
pEdge->clear();
pEdge->strength() = nOccur;
int nEdge = tripletArray.size()/2;
tripletArray.push_back(Triplet(srcChild.m_index, nEdge ,1.0));
tripletArray.push_back(Triplet(tarChild.m_index, nEdge ,-1.0));
edgeWeightArray.push_back(nOccur);
dependPair.push_back(FuzzyDependAttr::DependPair(srcChild.m_pNode, tarChild.m_pNode, nOccur));
}
}
if (int nEdges = tripletArray.size()/2)
{
vtxEdgeMat.resize(childList.size(),nEdges);
vtxEdgeMat.setFromTriplets(tripletArray.begin(), tripletArray.end());
edgeWeightVec.resize(nEdges);
memcpy(edgeWeightVec.data(), edgeWeightArray.data(), sizeof(double)* nEdges);
}
}
Mat::Mat(vector<string> _row_names, vector<string> _col_names,
Eigen::SparseMatrix<double> _matrix,MatType _mattype)
{
row_names = _row_names;
col_names = _col_names;
assert(row_names.size() == _matrix.rows());
assert(col_names.size() == _matrix.cols());
matrix = _matrix;
mattype = _mattype;
}
void UnknownVars::Solve(const AAndBVars& aAndBVars)
{
// solve Ax = b using UmfPack:
Eigen::SparseMatrix<double> A = aAndBVars.GetA();
A.transpose();
Eigen::SparseLU<Eigen::SparseMatrix<double>,Eigen::UmfPack> lu_of_A(A);
wxASSERT(lu_of_A.succeeded());
bool success = lu_of_A.solve(aAndBVars.GetBVarsConst(),&m_u);
wxASSERT(success);
}
void testEigen(int m, int n, int nnz, std::vector<int>& rows, std::vector<int>& cols,
std::vector<double>& values, double* matB){
double start, stop, time_to_solve, time_to_build;
double tol=1e-9;
Eigen::SparseMatrix<double> A;
std::vector< Eigen::Triplet<double> > trips;
trips.reserve(m * n);
for (int k = 0; k < nnz; k++){
double _val = values[k];
int i = rows[k];
int j = cols[k];
if (fabs(_val) > tol){
trips.push_back(Eigen::Triplet<double>(i-1,j-1,_val));
}
}
//NOTE: setFromTriples() accumulates contributions to the same (i,j)!
A.resize(m, n);
start = second();
A.setFromTriplets(trips.begin(), trips.end());
stop = second();
time_to_build = stop - start;
Eigen::SparseLU< Eigen::SparseMatrix<double>, Eigen::COLAMDOrdering<int> > solverLU;
Eigen::VectorXd b; b.resize(m);
for (int i = 0; i < m; i++ ) b(i) = matB[i];
printf("\nProcessing in Eigen using LU...\n");
start = second();
solverLU.compute(A);
Eigen::VectorXd X = solverLU.solve(b);
stop = second();
time_to_solve = stop - start;
Eigen::VectorXd ax = A * X;
Eigen::VectorXd bMinusAx = b - ax;
double h_r[m];
for (int i=0; i<m; i++) h_r[i]=bMinusAx(i);
double r_inf = vec_norminf(m, h_r);
printf("(Eigen) |b - A*x| = %E \n", r_inf);
printf("(Eigen) Time to build(sec): %f\n", time_to_build);
printf("(Eigen) Time (sec): %f\n", time_to_solve);
}
IGL_INLINE void igl::components(
const Eigen::SparseMatrix<AScalar> & A,
Eigen::PlainObjectBase<DerivedC> & C,
Eigen::PlainObjectBase<Derivedcounts> & counts)
{
using namespace Eigen;
using namespace std;
assert(A.rows() == A.cols() && "A should be square.");
const size_t n = A.rows();
Array<bool,Dynamic,1> seen = Array<bool,Dynamic,1>::Zero(n,1);
C.resize(n,1);
typename DerivedC::Scalar id = 0;
vector<typename Derivedcounts::Scalar> vcounts;
// breadth first search
for(int k=0; k<A.outerSize(); ++k)
{
if(seen(k))
{
continue;
}
queue<int> Q;
Q.push(k);
vcounts.push_back(0);
while(!Q.empty())
{
const int f = Q.front();
Q.pop();
if(seen(f))
{
continue;
}
seen(f) = true;
C(f,0) = id;
vcounts[id]++;
// Iterate over inside
for(typename SparseMatrix<AScalar>::InnerIterator it (A,f); it; ++it)
{
const int g = it.index();
if(!seen(g) && it.value())
{
Q.push(g);
}
}
}
id++;
}
assert((size_t) id == vcounts.size());
const size_t ncc = vcounts.size();
assert((size_t)C.maxCoeff()+1 == ncc);
counts.resize(ncc,1);
for(size_t i = 0;i<ncc;i++)
{
counts(i) = vcounts[i];
}
}
inline
void
space_operator(
Eigen::SparseMatrix<double>& result,
Eigen::SparseMatrix<double>& laplace,
const double multiplier,
Eigen::SparseMatrix<double>& unit_matrix)
{
result.resize(unit_matrix.rows(), unit_matrix.cols());
result = laplace*multiplier+unit_matrix;
}
void MacauOnePrior<FType>::sample_latents(
Eigen::MatrixXd &U,
const Eigen::SparseMatrix<double> &Ymat,
double mean_value,
const Eigen::MatrixXd &V,
double alpha,
const int num_latent)
{
const int N = U.cols();
const int D = U.rows();
#pragma omp parallel for schedule(dynamic, 4)
for (int i = 0; i < N; i++) {
const int nnz = Ymat.outerIndexPtr()[i + 1] - Ymat.outerIndexPtr()[i];
VectorXd Yhat(nnz);
// precalculating Yhat and Qi
int idx = 0;
VectorXd Qi = lambda;
for (SparseMatrix<double>::InnerIterator it(Ymat, i); it; ++it, idx++) {
Qi.noalias() += alpha * V.col(it.row()).cwiseAbs2();
Yhat(idx) = mean_value + U.col(i).dot( V.col(it.row()) );
}
VectorXd rnorms(num_latent);
bmrandn_single(rnorms);
for (int d = 0; d < D; d++) {
// computing Lid
const double uid = U(d, i);
double Lid = lambda(d) * (mu(d) + Uhat(d, i));
idx = 0;
for ( SparseMatrix<double>::InnerIterator it(Ymat, i); it; ++it, idx++) {
const double vjd = V(d, it.row());
// L_id += alpha * (Y_ij - k_ijd) * v_jd
Lid += alpha * (it.value() - (Yhat(idx) - uid*vjd)) * vjd;
}
// Now use Lid and Qid to update uid
double uid_old = U(d, i);
double uid_var = 1.0 / Qi(d);
// sampling new u_id ~ Norm(Lid / Qid, 1/Qid)
U(d, i) = Lid * uid_var + sqrt(uid_var) * rnorms(d);
// updating Yhat
double uid_delta = U(d, i) - uid_old;
idx = 0;
for (SparseMatrix<double>::InnerIterator it(Ymat, i); it; ++it, idx++) {
Yhat(idx) += uid_delta * V(d, it.row());
}
}
}
}
IGL_INLINE void igl::speye(const int m, const int n, Eigen::SparseMatrix<T> & I)
{
// size of diagonal
int d = (m<n?m:n);
I = Eigen::SparseMatrix<T>(m,n);
I.reserve(d);
for(int i = 0;i<d;i++)
{
I.insert(i,i) = 1.0;
}
I.finalize();
}
// Test that column indexes of values from sparse matrix in sparse
// format are extracted after makeCompressed().
TEST(SparseStuff, csr_extract_v_sparse_compressed) {
stan::math::matrix_d m(2, 3);
Eigen::SparseMatrix<double, Eigen::RowMajor> a;
m << 2.0, 4.0, 6.0, 0.0, 0.0, 0.0;
a = m.sparseView();
a.makeCompressed();
std::vector<int> result = stan::math::csr_extract_v(a);
EXPECT_EQ(1, result[0]);
EXPECT_EQ(2, result[1]);
EXPECT_EQ(3, result[2]);
EXPECT_EQ(3, result.size());
}
void createSearchKey(unsigned int numberRows, unsigned int NBFS, std::vector<int> &search_key, const Eigen::SparseMatrix<int> &EdgeMatrix)
{
//columndegree contains number of nonzeros per column
//for removing searchkey values that are not connected to main graph
std::vector<int> columndegree;
columndegree.reserve(numberRows);
for (unsigned int i = 0; i < numberRows; i++)
{
columndegree.push_back(EdgeMatrix.outerIndexPtr()[i+1]-EdgeMatrix.outerIndexPtr()[i]);
}
//generate search key values based on time seed
std::mt19937 generator(std::chrono::system_clock::now().time_since_epoch()/std::chrono::seconds(1));
std::cout << "creating search key vector" << std::endl;
for (unsigned int i = 0; i < numberRows; i++)
{
search_key.push_back(i);
}
//shuffle search key values
std::shuffle(search_key.begin(),search_key.end(),generator);
//take first 64 or entire search key, whichever is smaller
if (search_key.size() > NBFS)
{
for (unsigned int i = 0; i < NBFS+20; i++)
{
//remove search key values that aren't connected to main graph
if (columndegree.at(search_key.at(i)) == 0)
{
search_key.erase(search_key.begin()+i);
i--;
}
}
search_key.erase(search_key.begin()+NBFS, search_key.end());
}
std::cout << "Removing search keys with no edges" << std::endl;
for (unsigned int i = 0; i < search_key.size(); i++)
{
//remove search key values that aren't connected to main graph
if (columndegree.at(search_key.at(i)) == 0)
{
search_key.erase(search_key.begin()+i);
i--;
}
}
search_key.shrink_to_fit();
}
std::vector<double> getRowSum(const Eigen::SparseMatrix<int,Eigen::RowMajor>& adjacencyMatrix)
{
int rowSize = adjacencyMatrix.rows();
std::vector<double> rowSum;
rowSum.reserve(rowSize);
for(int i=0; i<rowSize;++i){
double value = adjacencyMatrix.innerVector(i).sum();
rowSum.push_back(value);
}
return rowSum;
}
IGL_INLINE bool igl::GeneralPolyVectorFieldFinder<DerivedV, DerivedF>::
solve(const Eigen::VectorXi &isConstrained,
const Eigen::Matrix<typename DerivedV::Scalar, Eigen::Dynamic, Eigen::Dynamic> &cfW,
const Eigen::VectorXi &rootsIndex,
Eigen::Matrix<typename DerivedV::Scalar, Eigen::Dynamic, Eigen::Dynamic> &output)
{
// polynomial is of the form:
// z^(2n) +
// -c[0]z^(2n-1) +
// c[1]z^(2n-2) +
// -c[2]z^(2n-3) +
// ... +
// (-1)^n c[n-1]
std::vector<Eigen::Matrix<std::complex<typename DerivedV::Scalar>, Eigen::Dynamic,1>> coeffs(n,Eigen::Matrix<std::complex<typename DerivedV::Scalar>, Eigen::Dynamic,1>::Zero(numF, 1));
for (int i =0; i<n; ++i)
{
int degree = i+1;
Eigen::Matrix<std::complex<typename DerivedV::Scalar>, Eigen::Dynamic,1> Ck;
getGeneralCoeffConstraints(isConstrained,
cfW,
i,
rootsIndex,
Ck);
Eigen::SparseMatrix<std::complex<typename DerivedV::Scalar> > DD;
computeCoefficientLaplacian(degree, DD);
Eigen::SparseMatrix<std::complex<typename DerivedV::Scalar> > f; f.resize(numF,1);
if (isConstrained.sum() == numF)
coeffs[i] = Ck;
else
minQuadWithKnownMini(DD, f, isConstrained, Ck, coeffs[i]);
}
std::vector<Eigen::Matrix<typename DerivedV::Scalar, Eigen::Dynamic, 2> > pv;
setFieldFromGeneralCoefficients(coeffs, pv);
output.setZero(numF,3*n);
for (int fi=0; fi<numF; ++fi)
{
const Eigen::Matrix<typename DerivedV::Scalar, 1, 3> &b1 = B1.row(fi);
const Eigen::Matrix<typename DerivedV::Scalar, 1, 3> &b2 = B2.row(fi);
for (int i=0; i<n; ++i)
output.block(fi,3*i, 1, 3) = pv[i](fi,0)*b1 + pv[i](fi,1)*b2;
}
return true;
}
