C++ MatrixXd::maxCoeff方法代码示例

void ActivationFunctionsTestCase::normaltanh()
{
  const int N = 1000;
  Eigen::MatrixXd a = Eigen::VectorXd::Random(N) * 10.0;
  Eigen::MatrixXd z = Eigen::VectorXd::Zero(N);
  OpenANN::normaltanh(a, z);
  ASSERT_WITHIN(z.minCoeff(), -1.0, -0.5);
  ASSERT_WITHIN(z.maxCoeff(), 0.5, 1.0);

  Eigen::MatrixXd gd = Eigen::VectorXd::Zero(N);
  OpenANN::normaltanhDerivative(z, gd);
  ASSERT_WITHIN(gd.minCoeff(), 0.0, 1.0);
  ASSERT_WITHIN(gd.maxCoeff(), 0.0, 1.0);
}

void ActivationFunctionsTestCase::linear()
{
  const int N = 1000;
  Eigen::MatrixXd a = Eigen::VectorXd::Random(N) * 10.0;
  Eigen::MatrixXd z = Eigen::VectorXd::Zero(N);
  OpenANN::linear(a, z);
  ASSERT_EQUALS(a.minCoeff(), z.minCoeff());
  ASSERT_EQUALS(a.maxCoeff(), z.maxCoeff());

  Eigen::MatrixXd gd = Eigen::VectorXd::Zero(N);
  Eigen::MatrixXd expected = Eigen::VectorXd::Ones(N);
  OpenANN::linearDerivative(gd);
  ASSERT_EQUALS(gd.sum(), expected.sum());
}

void ActivationFunctionsTestCase::logistic()
{
  const int N = 1000;
  Eigen::MatrixXd a = Eigen::VectorXd::Random(N) * 10.0;
  Eigen::MatrixXd z = Eigen::VectorXd::Zero(N);
  OpenANN::logistic(a, z);
  ASSERT_WITHIN(z.minCoeff(), 0.0, 0.2);
  ASSERT_WITHIN(z.maxCoeff(), 0.8, 1.0);

  Eigen::MatrixXd gd = Eigen::VectorXd::Zero(N);
  OpenANN::logisticDerivative(z, gd);
  ASSERT_WITHIN(gd.minCoeff(), 0.0, 1.0);
  ASSERT_WITHIN(gd.maxCoeff(), 0.0, 1.0);
}

void ActivationFunctionsTestCase::rectifier()
{
  const int N = 1000;
  Eigen::MatrixXd a = Eigen::MatrixXd::Random(1, N) * 10.0;
  Eigen::MatrixXd z = Eigen::MatrixXd::Zero(1, N);
  OpenANN::rectifier(a, z);
  ASSERT_EQUALS(0.0, z.minCoeff());
  ASSERT_EQUALS(a.maxCoeff(), z.maxCoeff());

  Eigen::MatrixXd gd = Eigen::MatrixXd::Zero(1, N);
  Eigen::MatrixXd expected = Eigen::MatrixXd::Ones(1, N);
  for(int i = 0; i < N; i++)
    expected(i) *= (double)(z(i) > 0.0);
  OpenANN::rectifierDerivative(z, gd);
  ASSERT_EQUALS(gd.sum(), expected.sum());
}

void ActivationFunctionsTestCase::softmax()
{
  const int N = 1000;
  Eigen::MatrixXd a = Eigen::VectorXd::Random(N).transpose();
  OpenANN::softmax(a);
  ASSERT_EQUALS_DELTA(1.0, a.sum(), 1e-3);
  ASSERT_WITHIN(a.minCoeff(), 0.0, 1.0);
  ASSERT_WITHIN(a.maxCoeff(), 0.0, 1.0);
}

BowResult BoWClassifier::ComputeClass(const std::string& data) {
    auto toks = Tokenizer::FR(data);
    ngram_.Annotate(toks);

    Eigen::MatrixXd probas = bow_.ComputeClass(toks);
    Eigen::MatrixXd::Index label_res, dummy_zero;
    probas.maxCoeff(&label_res, &dummy_zero);
    return {probas, label_res, toks};
}

int main(int argc, char * argv[])
{
  using namespace Eigen;
  using namespace std;
  using namespace igl;
  VectorXd D;
  if(!read_triangle_mesh("../shared/beetle.off",V,F))
  {
    cout<<"failed to load mesh"<<endl;
  }
  twod = V.col(2).minCoeff()==V.col(2).maxCoeff();
  bbd = (V.colwise().maxCoeff()-V.colwise().minCoeff()).norm();
  SparseMatrix<double> L,M;
  cotmatrix(V,F,L);
  L = (-L).eval();
  massmatrix(V,F,MASSMATRIX_TYPE_DEFAULT,M);
  const size_t k = 5;
  if(!eigs(L,M,k+1,EIGS_TYPE_SM,U,D))
  {
    cout<<"failed."<<endl;
  }
  U = ((U.array()-U.minCoeff())/(U.maxCoeff()-U.minCoeff())).eval();

  igl::viewer::Viewer viewer;
  viewer.callback_key_down = [&](igl::viewer::Viewer & viewer,unsigned char key,int)->bool
  {
    switch(key)
    {
      default: 
        return false;
      case ' ':
      {
        U = U.rightCols(k).eval();
        // Rescale eigen vectors for visualization
        VectorXd Z = 
          bbd*0.5*U.col(c);
        Eigen::MatrixXd C;
        igl::parula(U.col(c).eval(),false,C);
        c = (c+1)%U.cols();
        if(twod)
        {
          V.col(2) = Z;
        }
        viewer.data.set_mesh(V,F);
        viewer.data.compute_normals();
        viewer.data.set_colors(C);
        return true;
      }
    }
  };
  viewer.callback_key_down(viewer,' ',0);
  viewer.core.show_lines = false;
  viewer.launch();
}

void scaleData(Eigen::MatrixXd& data, double min, double max)
{
  if(min >= max)
    throw OpenANNException("Scaling failed: max has to be greater than min!");
  const double minData = data.minCoeff();
  const double maxData = data.maxCoeff();
  const double dataRange = maxData - minData;
  const double desiredRange = max - min;
  const double scaling = desiredRange / dataRange;
  data = data.array() * scaling + (min - minData * scaling);
}

void Locator::buildPathDistMat( const QHash<SymbolPath, SymbolData>& symbolWordList, 
							    Eigen::MatrixXd& distMat, 
								Eigen::VectorXd& radiusVec,
								Eigen::VectorXd& alignVec)
{
	// add to path index map
	QHash<SymbolPath, int> pathIdxMap;
	QList<QString> pathStrVec;
	int ithPath = 0;
	for (QHash<SymbolPath, SymbolData>::ConstIterator pPath = symbolWordList.constBegin();
		pPath != symbolWordList.constEnd(); ++pPath, ++ithPath)
	{
		pathIdxMap[pPath.key()] = ithPath;
		pathStrVec.push_back(pPath.key().getLastSymbol()->toString());
	}

	// build adjencency matrix
	int n = ithPath;
	ithPath = 0;
	radiusVec.resize(n);
	alignVec = Eigen::VectorXd::Ones(n);
	Eigen::MatrixXf adjMat = Eigen::MatrixXf::Constant(n,n,-1);
	for (QHash<SymbolPath, SymbolData>::ConstIterator pPath = symbolWordList.constBegin();
		pPath != symbolWordList.constEnd(); ++pPath, ++ithPath)
	{
		const SymbolData& symData = pPath.value();
		const SymbolPath& symPath = pPath.key();
		int   srcIdx = pathIdxMap[pPath.key()];

		for (QSet<SymbolPath>::ConstIterator pChild = symData.m_lowLevelSym.constBegin();
			pChild != symData.m_lowLevelSym.constEnd(); ++pChild)
		{
			QHash<SymbolPath, int>::ConstIterator pTar = pathIdxMap.find(*pChild);
			if (pTar == pathIdxMap.constEnd())
				continue;
			int tarIdx = pTar.value();
			adjMat(srcIdx, tarIdx) = adjMat(tarIdx, srcIdx) = 1;
		}

		radiusVec(ithPath) = symData.getRadius();
		if(const SymbolInfo* info = symPath.getLastSymbol())
		{
			alignVec(ithPath) = MDSSolver::getAlignVal(info->name());
		}
	}

	// build distance matrix
	MatrixXf dMat;
	GraphUtility::computePairDist(adjMat, dMat);
	distMat = dMat.cast<double>();

	// save mats for debug
	QString matStr = GlobalUtility::toMatlabString(adjMat, "adjMat");
	matStr +=        GlobalUtility::toMatlabString(dMat, "distMat");
	matStr +=        GlobalUtility::toMatlabString(pathStrVec, "entityName");
	matStr +=        "adjMat(find(adjMat<0)) = 0;\n";
	GlobalUtility::saveString("H:\\Programs\\QtCreator\\qt-creator_master\\src\\plugins\\MyPlugin\\CodeAtlas\\tests\\2-20\\matStr.m", matStr);

	// fill distances of different connect components 
	float maxDist= distMat.maxCoeff() * 2.f;
	for (int i = 0; i < distMat.rows(); i++)
		for (int j = 0; j < distMat.cols(); j++)
			if (distMat(i,j) == -1)
				distMat(i,j) = maxDist;
}