C++ VectorType::data方法代码示例

template<typename MatrixType> void generalized_eigensolver_real(const MatrixType& m)
{
  typedef typename MatrixType::Index Index;
  /* this test covers the following files:
     GeneralizedEigenSolver.h
  */
  Index rows = m.rows();
  Index cols = m.cols();

  typedef typename MatrixType::Scalar Scalar;
  typedef typename NumTraits<Scalar>::Real RealScalar;
  typedef Matrix<Scalar, MatrixType::RowsAtCompileTime, 1> VectorType;
  typedef Matrix<RealScalar, MatrixType::RowsAtCompileTime, 1> RealVectorType;
  typedef typename std::complex<typename NumTraits<typename MatrixType::Scalar>::Real> Complex;

  MatrixType a = MatrixType::Random(rows,cols);
  MatrixType b = MatrixType::Random(rows,cols);
  MatrixType a1 = MatrixType::Random(rows,cols);
  MatrixType b1 = MatrixType::Random(rows,cols);
  MatrixType spdA =  a.adjoint() * a + a1.adjoint() * a1;
  MatrixType spdB =  b.adjoint() * b + b1.adjoint() * b1;

  // lets compare to GeneralizedSelfAdjointEigenSolver
  GeneralizedSelfAdjointEigenSolver<MatrixType> symmEig(spdA, spdB);
  GeneralizedEigenSolver<MatrixType> eig(spdA, spdB);

  VERIFY_IS_EQUAL(eig.eigenvalues().imag().cwiseAbs().maxCoeff(), 0);

  VectorType realEigenvalues = eig.eigenvalues().real();
  std::sort(realEigenvalues.data(), realEigenvalues.data()+realEigenvalues.size());
  VERIFY_IS_APPROX(realEigenvalues, symmEig.eigenvalues());
}

void DiscretePolicyManager::UpdateCallback( const ros::TimerEvent& event )
{
	StampedFeatures inputs;
	if( !_inputStreams.ReadStream( event.current_real, inputs ) )
	{
		ROS_WARN_STREAM( "Could not read input stream." );
		return;
	}

	// Generate probability mass function values
	_networkInput.SetOutput( inputs.features );
	_networkInput.Invalidate();
	_networkInput.Foreprop();
	VectorType pmf = _network->GetProbabilitySource().GetOutput();

	// Sample from PMF
	std::vector<double> weights( pmf.data(), pmf.data() + pmf.size() );
	std::vector<unsigned int> draws;
	NaiveWeightedSample( weights, 1, draws, _engine );
	unsigned int actionIndex = draws[0];

	// Convert single index into multiple indices
	std::vector<unsigned int> indices;
	indices = multibase_long_div( actionIndex, _interface->GetOutputSizes() );
	_interface->SetOutput( indices );

	// TODO name policy
	DiscreteParamAction action( event.current_real,
	                            inputs.features,
	                            actionIndex );
	_actionPub.publish( action.ToMsg() );
}

void deep_network::set_parameter(const VectorType &parameter_)
{
    int start_idx = 0;
    for (auto & layer : this->layers)
    {
        layer.W = Map<const MatrixType>(parameter_.data()+ start_idx,layer.get_input_dim(),layer.get_output_dim()) ;
        start_idx += layer.get_input_dim()  * layer.get_output_dim();
        layer.b = Map<const VectorType>(parameter_.data()+ start_idx, layer.get_output_dim());
        start_idx += layer.get_output_dim();
    }

}

VectorType deep_network::get_parameter() {

    int total_param_num = 0;
    for (auto & layer : this->layers)
    {
        total_param_num += (layer.get_input_dim() + 1) * layer.get_output_dim();
    }

    VectorType Wb = VectorType::Zero(total_param_num);

    int start_idx = 0;
    for (auto & layer : this->layers)
    {
        Map<MatrixType>(Wb.data()+ start_idx,layer.get_input_dim(),layer.get_output_dim()) = layer.W;
        start_idx += layer.get_input_dim()  * layer.get_output_dim();
        Map<VectorType>(Wb.data()+ start_idx, layer.get_output_dim()) = layer.b;
        start_idx += layer.get_output_dim();
    }
    return Wb;
}

//.........这里部分代码省略.........
                + " -D" + ElementWiseOperatorTrait<OP>::operation;

        if (sizeof(clsparseIdx_t) == 8)
        {
            std::string options = std::string()
                + " -DSIZE_TYPE=" + OclTypeTraits<cl_ulong>::type;
            params.append(options);
        }
        else
        {
            std::string options = std::string()
                + " -DSIZE_TYPE=" + OclTypeTraits<cl_uint>::type;
            params.append(options);
        }

        if(typeid(T) == typeid(cl_double))
        {
            params.append(" -DDOUBLE");
            if (!control->dpfp_support)
            {
#ifndef NDEBUG
                std::cerr << "Failure attempting to run double precision kernel on device without DPFP support." << std::endl;
#endif
                return clsparseInvalidDevice;
            }
        }

        cl::Kernel kernel = KernelCache::get(control->queue, "scan",
                                             "per_block_inclusive_scan", params);

        KernelWrap kWrapper(kernel);


        kWrapper << input.data()
                 << operator_identity
                 << (SizeType)input.size()
                 << cl::Local(lds)
                 << preSumArray.data()
                 << preSumArray1.data()
                 << (int) exclusive;

        cl::NDRange global(numElementsRUP/2);
        cl::NDRange local (kernel0_WgSize);

        cl_int status = kWrapper.run(control, global, local);

        CLSPARSE_V(status, "Error: per_block_inclusive_scan");

        if (status != CL_SUCCESS)
        {
            return clsparseInvalidKernelExecution;
        }

    }


    {
        //local mem size
        std::size_t lds = kernel0_WgSize * sizeof(T);

        SizeType workPerThread = sizeScanBuff / kernel1_WgSize;

        std::string params = std::string()
                + " -DVALUE_TYPE=" + OclTypeTraits<T>::type
                + " -DWG_SIZE="    + std::to_string(kernel1_WgSize)
                + " -D" + ElementWiseOperatorTrait<OP>::operation;

//.........这里部分代码省略.........
    while ( true ) 
    {
        bool TriangleSplitted = false; //algorithm stops when no more splits are required
        
        HoleCoverType new_cover;
        
//        std::cout<<"Cover size: "<<m_coverFaces->size()<<std::endl;

        //SaveIsolatedCover("1.vtk");
        
        //for(HoleCoverType::iterator coverIt = m_coverFaces->begin(); coverIt!=m_coverFaces->end(); coverIt++)    
        for(HoleCoverType::iterator coverIt = m_coverFaces->begin(); coverIt!=m_coverFaces->end(); coverIt++)    
        {
            
            //calculate centroid
            const vtkIdType idVi = (*coverIt).id[0];
            const vtkIdType idVj = (*coverIt).id[1];
            const vtkIdType idVk = (*coverIt).id[2];
            
            VectorType Vc;
            double Svc;
            
//            std::cout<<"Cover size: "<<m_coverFaces->size()<<std::endl;
//            std::cout<<"Splitting verifying: "<<idVi<<" "<<idVj<<" "<<idVk<<std::endl;
            if( IsTriangleSplitRequired(idVi, idVj, idVk, Vc, Svc) )
            {  //create new triangles
                //erase old triangle
                
                //                std::cout<<"Splitting confirmed: "<<idVi<<" "<<idVj<<" "<<idVk<<std::endl;
                
                //m_coverFaces->erase(coverIt);
                
                //add new vertex
                const vtkIdType idVc = m_coverVertices->InsertNextPoint(Vc.data());
                
                
                //replace (vi,vj,vk) with (vc,vj,vk), (vi,vc,vk), (vi,vj,vc)
                TriangleCellType tri1; tri1.id[0]=idVc; tri1.id[1]=idVj; tri1.id[2]=idVk;
                TriangleCellType tri2; tri2.id[0]=idVi; tri2.id[1]=idVc; tri2.id[2]=idVk;
                TriangleCellType tri3; tri3.id[0]=idVi; tri3.id[1]=idVj; tri3.id[2]=idVc;
                //relax edges (vi,vj), (vi,vk), (vj,vk)
                //              TriangleSplitted = true;
                new_cover.push_back(tri1);
                new_cover.push_back(tri2);
                new_cover.push_back(tri3);

//                std::cout<<"Inserting: "<<tri1.id[0]<<" "<<tri1.id[1]<<" "<<tri1.id[2]<<std::endl;                
//                std::cout<<"Inserting: "<<tri2.id[0]<<" "<<tri2.id[1]<<" "<<tri2.id[2]<<std::endl;                
//                std::cout<<"Inserting: "<<tri3.id[0]<<" "<<tri3.id[1]<<" "<<tri3.id[2]<<std::endl;                

//                CheckForDuplicateTriangles();
                
                
                //Update matrices
                m_sigmas.push_back(Svc);
                
                //new point added - need resize
                //conn.conservativeResize(coverVertices->GetNumberOfPoints(), coverVertices->GetNumberOfPoints());
                //std::cout<<"conn matrix size: "<<conn.rows()<<", "<<conn.cols()<<std::endl;
//                vtkIdType max_id1 =  std::max( tri1.id[0], std::max( tri1.id[1], tri1.id[2]) );
//                vtkIdType max_id2 =  std::max( tri2.id[0], std::max( tri2.id[1], tri2.id[2]) );
//                vtkIdType max_id3 =  std::max( tri3.id[0], std::max( tri3.id[1], tri3.id[2]) );
//                vtkIdType max_id4 =  std::max( max_id1, std::max( max_id2, max_id3) );
//
//                std::cout<<"max id to store: "<<max_id4<<std::endl;