C++ VectorXd::cols方法代码示例

void Reservoir::linear_activation(VectorXd &inputs, VectorXd &results) {
    unsigned int num_elems = (inputs.rows() > inputs.cols()) ? inputs.rows() : inputs.cols();
    results.resize(num_elems, 1);
    for (unsigned int i=0; i<num_elems; i++) {
        results(i) = inputs(i);
    }
}

 void MultivariateFNormalSufficientSparse::set_FM(const VectorXd& FM)
 {
   if (FM.rows() != FM_.rows() || FM.cols() != FM_.cols() || FM != FM_){
       if (FM.rows() != M_) {
           IMP_THROW("size mismatch for FM: got "
                   <<FM.rows() << " instead of " << M_, ModelException);
           }
       FM_=FM;
       IMP_LOG(TERSE, "MVNsparse:   set FM to new vector" << std::endl);
       compute_epsilon();
   }
 }

 void MultivariateFNormalSufficientSparse::set_Fbar(const VectorXd& Fbar)
 {
   if (Fbar.rows() != Fbar_.rows() || Fbar.cols() != Fbar_.cols()
           || Fbar != Fbar_){
       if (Fbar.rows() != M_) {
           IMP_THROW("size mismatch for Fbar: got "
                   << Fbar.rows() << " instead of " << M_, ModelException);
           }
       Fbar_=Fbar;
       IMP_LOG(TERSE, "MVNsparse:   set Fbar to new vector" << std::endl);
       compute_epsilon();
   }
 }

 void MultivariateFNormalSufficient::set_FM(const VectorXd& FM)
 {
   if (FM.rows() != FM_.rows() || FM.cols() != FM_.cols() || FM != FM_){
       CHECK(FM.rows() == M_,
           "size mismatch for FM: got "
           <<FM.rows() << " instead of " << M_);
       FM_=FM;
       LOG( "MVN:   set FM to new vector" << std::endl);
       flag_epsilon_ = false;
       flag_Peps_ = false;
   }
   flag_FM_ = true;
 }

bool LocallyWeightedRegression::updateThetas(const VectorXd &deltaThetas)
{
    if (!initialized_)
    {
        printf("ERROR: LWR model not initialized.\n");
        return initialized_;
    }
    assert(deltaThetas.cols() == thetas_.cols());
    assert(deltaThetas.rows() == thetas_.rows());
    thetas_ += deltaThetas;

    return true;
}

 void MultivariateFNormalSufficient::set_FM(const VectorXd& FM)
 {
   if (FM.rows() != FM_.rows() || FM.cols() != FM_.cols() || FM != FM_){
       if (FM.rows() != M_) {
           IMP_THROW("size mismatch for FM: got "
                   <<FM.rows() << " instead of " << M_, ModelException);
           }
       FM_=FM;
       IMP_LOG(TERSE, "MVN:   set FM to new vector" << std::endl);
       flag_epsilon_ = false;
       flag_Peps_ = false;
   }
   flag_FM_ = true;
 }

bool LocallyWeightedRegression::getThetas(VectorXd &thetas)
{
    if (!initialized_)
    {
        printf("ERROR: LWR model not initialized.\n");
        return initialized_;
    }

    assert(thetas.cols() == thetas_.cols());
    assert(thetas.rows() == thetas_.rows());

    thetas = thetas_;

    return true;
}

 void MultivariateFNormalSufficient::set_Fbar(const VectorXd& Fbar)
 {
   if (Fbar.rows() != Fbar_.rows() || Fbar.cols() != Fbar_.cols()
           || Fbar != Fbar_){
       CHECK(Fbar.rows() == M_,
           "size mismatch for Fbar: got "
                   << Fbar.rows() << " instead of " << M_);
       Fbar_=Fbar;
       LOG( "MVN:   set Fbar to new vector" << std::endl);
       flag_epsilon_ = false;
       flag_W_ = false;
       flag_PW_ = false;
       flag_Peps_ = false;
   }
   flag_Fbar_ = true;
 }

std::tuple<double, VectorXd, SparseMatrix>
kantorovich_2(const Density_2 &pl,
	      const MatrixXd &X,
	      const VectorXd &w)
{
  size_t N = X.rows();
  assert(X.cols() == 2);
  assert(w.cols() == 1);
  assert(w.rows() == N);

  VectorXd g(N);

  SparseMatrix h;
  double res = MA::kantorovich(pl._t, pl._functions, X, w, g, h);
  return std::make_tuple(res, g, h);
}

 void MultivariateFNormalSufficient::set_Fbar(const VectorXd& Fbar)
 {
   if (Fbar.rows() != Fbar_.rows() || Fbar.cols() != Fbar_.cols()
           || Fbar != Fbar_){
       if (Fbar.rows() != M_) {
           IMP_THROW("size mismatch for Fbar: got "
                   << Fbar.rows() << " instead of " << M_, ModelException);
           }
       Fbar_=Fbar;
       IMP_LOG(TERSE, "MVN:   set Fbar to new vector" << std::endl);
       flag_epsilon_ = false;
       flag_W_ = false;
       flag_PW_ = false;
       flag_Peps_ = false;
   }
   flag_Fbar_ = true;
 }

std::tuple<VectorXd, MatrixXd, MatrixXd>
moments_2(const Density_2 &pl,
	  const MatrixXd &X,
	  const VectorXd &w)
{
  size_t N = X.rows();
  assert(X.cols() == 2);
  assert(w.cols() == 1);
  assert(w.rows() == N);

  // create some room for return values: masses, centroids and inertia
  VectorXd m(N);
  MatrixXd c(N, 2);
  MatrixXd I(N, 3);

  MA::second_moment(pl._t, pl._functions, X, w, m, c, I);
  return std::make_tuple(m, c, I);
}

  Density_2(const MatrixXd& X,
            const VectorXd& f,
            const MatrixXi& tri) : gen(clock())
  {
    size_t N = X.rows();
    assert(X.cols() == 2);
    assert(f.cols() == 1);
    assert(f.rows() == N);
    assert(tri.cols() == 3);


    CGAL::Triangulation_incremental_builder_2<T> builder(_t);
    builder.begin_triangulation();

    // add vertices
    std::vector<T::Vertex_handle> vertices(N);
    for (size_t i = 0; i < N; ++i)
      {
	Point p(X(i,0),X(i,1));
	vertices[i] = builder.add_vertex(Point(X(i,0), X(i,1)));
	vertices[i]->info() = i;
      }

    // add faces
    size_t Nt = tri.rows();
    for (size_t i = 0; i < Nt; ++i)
      {
	int a = tri(i,0), b = tri(i,1), c = tri(i,2);
	builder.add_face(vertices[a], vertices[b], vertices[c]);
      }
    builder.end_triangulation();

    // compute functions
    for (T::Finite_faces_iterator it = _t.finite_faces_begin ();
	 it != _t.finite_faces_end(); ++it)
      {
	size_t a = it->vertex(0)->info();
	size_t b = it->vertex(1)->info();
	size_t c = it->vertex(2)->info();
	_functions[it] = Function(vertices[a]->point(), f[a],
				  vertices[b]->point(), f[b],
				  vertices[c]->point(), f[c]);
      }
  }

void
python_to_delaunay_2(const MatrixXd& X,
                     const VectorXd& w,
		     RT &dt)
{
  size_t N = X.rows();
  assert(X.cols() == 2);
  assert(w.cols() == 1);
  assert(w.rows() == N);

  // insert points with indices in the regular triangulation
  std::vector<std::pair<Weighted_point,size_t> > Xw(N);
  for (size_t i = 0; i < N; ++i)
    {
      Xw[i] = std::make_pair(Weighted_point(Point(X(i,0), X(i,1)),
					    w(i)), i);
    }
  dt.clear();
  dt.insert(Xw.begin(), Xw.end());
  dt.infinite_vertex()->info() = -1;
}

void mexFunction(int nlhs, mxArray *plhs[],
    int nrhs, const mxArray *prhs[])
{
  // This is useful for debugging whether Matlab is caching the mex binary
  //mexPrintf("%s %s\n",__TIME__,__DATE__);
  igl::MexStream mout;
  std::streambuf *outbuf = std::cout.rdbuf(&mout);

  using namespace std;
  using namespace Eigen;
  using namespace igl;

  MatrixXd V,P,N;
  VectorXd S;
  MatrixXi F;
  int num_samples;
  parse_rhs(nrhs,prhs,V,F,P,N,num_samples);
  // Prepare left-hand side
  nlhs = 1;

  //read_triangle_mesh("../shared/cheburashka.off",V,F);
  //P = V;
  //per_vertex_normals(V,F,N);
  ambient_occlusion(V,F,P,N,num_samples,S);
  //MatlabWorkspace mw;
  //mw.save(V,"V");
  //mw.save(P,"P");
  //mw.save(N,"N");
  //mw.save_index(F,"F");
  //mw.save(S,"S");
  //mw.write("out.mat");

  plhs[0] = mxCreateDoubleMatrix(S.rows(),S.cols(), mxREAL);
  copy(S.data(),S.data()+S.size(),mxGetPr(plhs[0]));

  // Restore the std stream buffer Important!
  std::cout.rdbuf(outbuf);
}

// template <typename tA, typename tB, typename tC, typename tD, typename tE,
// typename tF, typename tG>
// int fastQPThatTakesQinv(vector< MatrixBase<tA>* > QinvblkDiag, const
// MatrixBase<tB>& f, const MatrixBase<tC>& Aeq, const MatrixBase<tD>& beq,
// const MatrixBase<tE>& Ain, const MatrixBase<tF>& bin, set<int>& active,
// MatrixBase<tG>& x)
int fastQPThatTakesQinv(vector<MatrixXd*> QinvblkDiag, const VectorXd& f,
                        const MatrixXd& Aeq, const VectorXd& beq,
                        const MatrixXd& Ain, const VectorXd& bin,
                        set<int>& active, VectorXd& x) {
  int i, d;
  int iterCnt = 0;

  int M_in = bin.size();
  int M = Aeq.rows();
  int N = Aeq.cols();

  if (f.rows() != N) {
    cerr << "size of f (" << f.rows() << " by " << f.cols()
         << ") doesn't match cols of Aeq (" << Aeq.rows() << " by "
         << Aeq.cols() << ")" << endl;
    return 2;
  }
  if (beq.rows() != M) {
    cerr << "size of beq doesn't match rows of Aeq" << endl;
    return 2;
  }
  if (Ain.cols() != N) {
    cerr << "cols of Ain doesn't match cols of Aeq" << endl;
    return 2;
  };
  if (bin.rows() != Ain.rows()) {
    cerr << "bin rows doesn't match Ain rows" << endl;
    return 2;
  };
  if (x.rows() != N) {
    cerr << "x doesn't match Aeq" << endl;
    return 2;
  }
  int n_active = active.size();

  MatrixXd Aact = MatrixXd(n_active, N);
  VectorXd bact = VectorXd(n_active);

  MatrixXd QinvAteq(N, M);
  VectorXd minusQinvf(N);

  // calculate a bunch of stuff that is constant during each iteration
  int startrow = 0;
  //  for (typename vector< MatrixBase<tA>* >::iterator
  //  iterQinv=QinvblkDiag.begin(); iterQinv!=QinvblkDiag.end(); iterQinv++) {
  //  	MatrixBase<tA> *thisQinv = *iterQinv;
  for (vector<MatrixXd*>::iterator iterQinv = QinvblkDiag.begin();
       iterQinv != QinvblkDiag.end(); iterQinv++) {
    MatrixXd* thisQinv = *iterQinv;
    int numRow = thisQinv->rows();
    int numCol = thisQinv->cols();

    if (numRow == 1 || numCol == 1) {  // it's a vector
      d = numRow * numCol;
      if (M > 0)
        QinvAteq.block(startrow, 0, d, M) =
            thisQinv->asDiagonal() *
            Aeq.block(0, startrow, M, d)
                .transpose();  // Aeq.transpoODse().block(startrow, 0, d, N)
      minusQinvf.segment(startrow, d) =
          -thisQinv->cwiseProduct(f.segment(startrow, d));
      startrow = startrow + d;
    } else {  // potentially dense matrix
      d = numRow;
      if (numRow != numCol) {
        cerr << "Q is not square! " << numRow << "x" << numCol << "\n";
        return -2;
      }
      if (M > 0)
        QinvAteq.block(startrow, 0, d, M) = thisQinv->operator*(
            Aeq.block(0, startrow, M, d)
                .transpose());  // Aeq.transpose().block(startrow, 0, d, N)
      minusQinvf.segment(startrow, d) =
          -thisQinv->operator*(f.segment(startrow, d));
      startrow = startrow + d;
    }
    if (startrow > N) {
      cerr << "Q is too big!" << endl;
      return -2;
    }
  }
  if (startrow != N) {
    cerr << "Q is the wrong size.  Got " << startrow << "by" << startrow
         << " but needed " << N << "by" << N << endl;
    return -2;
  }

  MatrixXd A;
  VectorXd b;
  MatrixXd QinvAt;
  VectorXd lam, lamIneq;
  VectorXd violated(M_in);
  VectorXd violation;

//.........这里部分代码省略.........