C++ VectorSpace类代码示例

    std::shared_ptr< VectorSpace > extractSubSpaceImpl( const VectorSpace& space,
                                                        unsigned global_id )
    {
        if ( is< ProductSpace::VectorCreator >( space.creator() ) )
        {
            const auto& product_space_creator =
                cast_ref< ProductSpace::VectorCreator >( space.creator() );
            const auto& subSpaces = product_space_creator.subSpaces();
            std::shared_ptr< VectorSpace > result;
            for ( auto i = 0u; i < subSpaces.size(); ++i )
            {
                if ( product_space_creator.inverseIdMap( i ) == global_id &&
                     !is< ProductSpace::VectorCreator >( subSpaces[ i ]->creator() ) )
                    return subSpaces[ i ];

                if ( is< ProductSpace::VectorCreator >( subSpaces[ i ]->creator() ) )
                {
                    auto result = extractSubSpaceImpl( *subSpaces[ i ], global_id );
                    if ( result )
                        return result;
                }
            }
        }

        return nullptr;
    }

template <class Scalar> inline
DefaultBlockVector<Scalar>
::DefaultBlockVector(const VectorSpace<Scalar>& space)
  : BlockVectorBase<Scalar>(), space_(space), blocks_(space.numBlocks())
{
  for (int i=0; i<space.numBlocks(); i++)
  {
    blocks_[i] = space.getBlock(i).createMember();
  }
}

bool VectorSpaceThyra::is_compatible(const VectorSpace& vec_spc ) const
{
  if( this->dim()==vec_spc.dim() && this->is_in_core() && vec_spc.is_in_core() )
    return true;
  const VectorSpaceThyra
    *thyra_vec_spc = dynamic_cast<const VectorSpaceThyra*>(&vec_spc);
  if( thyra_vec_spc->thyra_vec_spc()->isCompatible(*thyra_vec_spc_) )
    return true;
  return false;
}

 LinearOperatorCreator::LinearOperatorCreator( const VectorSpace& X, const VectorSpace& Y )
     : Generic::LinearOperatorCreator< LinearOperator >(
           [&X, &Y]( const VectorSpace* space ) {
               return LinearOperator(
                   ::Eigen::MatrixXd::Zero( cast_ref< VectorCreator >( X.creator() ).dim(),
                                            cast_ref< VectorCreator >( Y.creator() ).dim() ),
                   *space, X, Y );
           },
           X, Y )
 {
 }

template <class Scalar> inline
void BlockIterator<Scalar>
::goToStart(const VectorSpace<Scalar>& space,
  std::deque<int>& pos) const
{
  pos.push_back(0);
  if (space.isBlockSpace())
  {
    goToStart(space.getBlock(0), pos);
  }
}

SerialVector::SerialVector(const VectorSpace<double>& vs)
  : SingleChunkVector<double>(),
    vecSpace_(vs),
    data_(vs.dim()),
    dim_(vs.dim())
{
  const SerialVectorSpace* rvs 
    = dynamic_cast<const SerialVectorSpace*>(vs.ptr().get());
  TEUCHOS_TEST_FOR_EXCEPTION(rvs==0, std::runtime_error,
    "could not cast vector space to SerialVectorSpace in "
    "SerialVector ctor");
}

/**********************************************************************
 * Function_Name: Intersection
 * Return 		: double
 * Comments 	: returns the dist_from_sphere, if the intersection
 * 				 	else it returns a -1
 **********************************************************************/
double Ellipse::Intersection(const Vertex& RayOrigin, const VectorSpace& Ray) const
{
	Vertex V_Point = GetInversection_v_Point(RayOrigin, Ray);

	VectorSpace RayOrig2EllipCenter(  RayOrigin.arr, Center.arr );
	VectorSpace RayOrig2Ellip_Norm;
	RayOrig2Ellip_Norm = RayOrig2EllipCenter;
	RayOrig2Ellip_Norm.DoNormalization();

	VectorSpace RayNorm;
	RayNorm = Ray;
	RayNorm.DoNormalization();

	double c_dot_v  = RayOrig2Ellip_Norm.Dot( RayNorm );

	if( c_dot_v > 0 || Ray.RayNVal != 1 ) // Sphere is not behind the ray origin
	{
		double r = mean_radius;
		double c = RayOrigin.Distance( Center );

		double v = V_Point.Distance( RayOrigin );

		double v2 = pow(v,2);
		double c2 = pow(c,2);
		double r2 = pow(r,2);
		double dSquare = r2 - c2 + v2;

		if( dSquare < 0 )
		{
			return -1;
		}
		else
		{
			double d = sqrt( dSquare );
			double t;

			if( Ray.RayNVal == 1)
			{
				t = v - d;
				return t;
			}
			else
			{
				t = v + d;
				return t;
			}
		}

	}

	return -1;
}

bool VectorSpaceSubSpace::is_compatible(const VectorSpace& another_space) const
{
  if( this->dim() == another_space.dim() && this->is_in_core() && another_space.is_in_core() )
    return true;
  const VectorSpaceSubSpace
    *a_space = dynamic_cast<const VectorSpaceSubSpace*>(&another_space);
  if(!a_space)
    return false;
  return
    ( this->full_space_.get() == NULL && a_space->full_space_.get() == NULL )
    ||
    ( this->rng_ == a_space->rng_ && this->full_space_->is_compatible(*a_space->full_space_) );
}

  IteratesVectorSpace::IteratesVectorSpace(const VectorSpace& x_space, const VectorSpace& s_space,
      const VectorSpace& y_c_space, const VectorSpace& y_d_space,
      const VectorSpace& z_L_space, const VectorSpace& z_U_space,
      const VectorSpace& v_L_space, const VectorSpace& v_U_space
                                          )
      :
      CompoundVectorSpace(8, x_space.Dim() + s_space.Dim()
                          + y_c_space.Dim() + y_d_space.Dim()
                          + z_L_space.Dim() + z_U_space.Dim()
                          + v_L_space.Dim() + v_U_space.Dim()
                         )
  {
    x_space_ = &x_space;
    s_space_ = &s_space;
    y_c_space_ = &y_c_space;
    y_d_space_ = &y_d_space;
    z_L_space_ = &z_L_space;
    z_U_space_ = &z_U_space;
    v_L_space_ = &v_L_space;
    v_U_space_ = &v_U_space;

    this->CompoundVectorSpace::SetCompSpace(0, *x_space_);
    this->CompoundVectorSpace::SetCompSpace(1, *s_space_);
    this->CompoundVectorSpace::SetCompSpace(2, *y_c_space_);
    this->CompoundVectorSpace::SetCompSpace(3, *y_d_space_);
    this->CompoundVectorSpace::SetCompSpace(4, *z_L_space_);
    this->CompoundVectorSpace::SetCompSpace(5, *z_U_space_);
    this->CompoundVectorSpace::SetCompSpace(6, *v_L_space_);
    this->CompoundVectorSpace::SetCompSpace(7, *v_U_space_);
  }

/**********************************************************************
 * Function_Name: RotAxis
 * Return 		:
 * Comments 	:
 **********************************************************************/
int Transformation::RotAxis( double(&Rw)[4][4],  VectorSpace w )
{

	w.DoNormalization();

	VectorSpace m;

	for( int i = 0; i < 3; i++ )
	{
		m.vs[i] = (double)(rand() % 1000)/1000;
	}

	m.DoNormalization();


	VectorSpace u;

	u = w;
	u.CrossProduct(m);
	u.DoNormalization();

	VectorSpace v;
	v = w;
	v.CrossProduct(u);


	// Filling Up Rw
	FillUpRw( Rw, u.vs, v.vs, w.vs);

	CheckRotationMat(Rw);

	return EXIT_SUCCESS;
}

VectorSpace<Type, N> VectorSpace<Type, N>::operator -(const VectorSpace<Type, N>& v2) const
{

	// Vectors should have same size
	VectorSpace<Type, N> result;

	for (int i= v2.MinIndex(); i <= v2.MaxIndex(); ++i)
	{
		result[i] = (*this)[i] - v2[i];
	}

	return result;

}

RCP<GhostImporter<double> > 
EpetraVectorType::createGhostImporter(const VectorSpace<double>& space,
                                      int nGhost,
                                      const int* ghostIndices) const
{
  const EpetraVectorSpace* p 
    = dynamic_cast<const EpetraVectorSpace*>(space.ptr().get());

  TEUCHOS_TEST_FOR_EXCEPTION(p==0, std::runtime_error,
                     "non-epetra vector space [" << space.description() << "] given as "
                     "argument to EpetraVectorType::createGhostImporter()");

  return rcp(new EpetraGhostImporter(p->epetraMap(), nGhost, ghostIndices));
  
}

template <class Scalar> inline
SimpleBlockOp<Scalar>::SimpleBlockOp(
  const VectorSpace<Scalar>& domain,
  const VectorSpace<Scalar>& range)
  : LinearOpWithSpaces<Scalar>(domain, range), blocks_(range.numBlocks())
{
  for (int i=0; i<blocks_.size(); i++) 
  {
    blocks_[i] = Array<LinearOperator<Scalar> >(domain.numBlocks());
    for (int j=0; j<blocks_[i].size(); j++)
    {
      blocks_[i][j] = zeroOperator(domain.getBlock(j), range.getBlock(i));
    }
  }
}

void MatrixSymPosDefLBFGS::init_identity( const VectorSpace& space_diag, value_type alpha )
{
  // Validate input
  TEUCHOS_TEST_FOR_EXCEPTION(
    alpha <= 0.0, std::invalid_argument
    ,"MatrixSymPosDefLBFGS::init_identity(n,alpha) : Error, "
    "alpha = " << alpha << " <= 0 is not allowed!" );
  
  // Set the vector space
  vec_spc_ = space_diag.clone();
  vec_spc_.get();

  // Set storage
  S_ = vec_spc_->create_members(m_);
  Y_ = vec_spc_->create_members(m_);
  TEUCHOS_TEST_FOR_EXCEPT( !( S_.get() ) );
  TEUCHOS_TEST_FOR_EXCEPT( !( Y_.get() ) );
  STY_.resize( m_, m_ );
  STSYTY_.resize( m_+1, m_+1 );
  STSYTY_.diag(0) = 0.0;

  gamma_k_ = 1.0/alpha;

  // Initialize counters
  m_bar_	= 0;

  n_ = vec_spc_->dim();        // initialized;
  original_is_updated_ = true; // This will never change for now
  inverse_is_updated_  = true; // This will never change for now
  num_secant_updates_  = 0;    // reset this to zero
}

ExperimentStorage<S_V,S_M,D_V,D_M>::ExperimentStorage(
  const VectorSpace<S_V,S_M>& scenarioSpace,
  unsigned int                numExperiments)
  :
  m_env                    (scenarioSpace.env()),
  m_scenarioSpace          (scenarioSpace),
  m_paper_n                (numExperiments),
  m_paper_n_ys_transformed (m_paper_n,0),
  m_paper_n_y              (0),
  m_addId                  (0),
  m_scenarioVecs_standard  (m_paper_n, (S_V*) NULL),
  m_dataVecs_transformed   (m_paper_n, (D_V*) NULL),
  m_covMats_transformed_inv(m_paper_n, (D_M*) NULL),
  m_y_space                (NULL),
  m_yVec_transformed       (NULL),
  m_Wy                     (NULL)
{
  if ((m_env.subDisplayFile()) && (m_env.displayVerbosity() >= 2)) {
    *m_env.subDisplayFile() << "Entering ExperimentStorage<S_V,S_M,D_V,D_M>::constructor()"
                            << "\n  m_paper_n = " << m_paper_n
                            << std::endl;
  }

  if ((m_env.subDisplayFile()) && (m_env.displayVerbosity() >= 2)) {
    *m_env.subDisplayFile() << "Leaving ExperimentStorage<S_V,S_M,D_V,D_M>::constructor()"
                            << std::endl;
  }
}