コード例 #1
0
ファイル: BallN.hpp プロジェクト: sidch/Thea
    bool rayIntersects(RayN<N, T> const & ray, T max_time = -1) const
    {
      if (max_time >= 0)
        return rayIntersectionTime(ray, max_time) >= 0;

      VectorT co = ray.getOrigin() - center;

      T c = co.squaredNorm() - radius * radius;
      if (c <= 0)  // origin is inside ball
        return true;

      T a = ray.getDirection().squaredNorm();
      T b = 2 * co.dot(ray.getDirection());

      // Solve quadratic a * t^2 + b * t + c = 0
      T b2 = b * b;
      T det = b2 - 4 * a * c;
      if (det < 0) return false;

      if (a > 0)
        return b <= 0 || det >= b2;
      else if (a < 0)
        return b >= 0 || det >= b2;
      else
        return false;
    }
コード例 #2
0
ファイル: Distance.cpp プロジェクト: K4stor/nice-core
Ipp32f BhattacharyyaDistance<Ipp32f>::doCalculate(const VectorT<Ipp32f>& v1, const VectorT<Ipp32f>& v2) const {

    if(v1.size()!=v2.size())
        fthrow(Exception, "Input vectors must have the same size.");

    Ipp32f B;

    #ifdef NICE_USELIB_IPP

        VectorT<Ipp32f> v1f(v1);
        v1f *= v2;

        ippsSqrt(v1f.getDataPointer(), v1f.getDataPointer(), v1f.size());
        ippsSum(v1f.getDataPointer(), v1f.size(), &B);
    
    #else // NICE_USELIB_IPP

        B = 0.0;
        for(uint i=0; i<v1.size(); ++i)
            B += std::sqrt(v1[i]*v2[i]);

    #endif // NICE_USELIB_IPP

    return std::sqrt(1-B);
}
コード例 #3
0
      void operator()(LinPdeSysT const & pde_system,
                      SegmentT   const & segment,
                      StorageType      & storage,
                      MatrixT          & system_matrix,
                      VectorT          & load_vector)
      {
        typedef viennamath::equation                          equ_type;
        typedef viennamath::expr                              expr_type;
        typedef typename expr_type::interface_type            interface_type;
        typedef typename expr_type::numeric_type              numeric_type;

        typedef typename viennagrid::result_of::cell_tag<SegmentT>::type CellTag;

        std::size_t map_index = viennafvm::create_mapping(pde_system, segment, storage);

        system_matrix.clear();
        system_matrix.resize(map_index, map_index, false);
        load_vector.clear();
        load_vector.resize(map_index);


        for (std::size_t pde_index = 0; pde_index < pde_system.size(); ++pde_index)
        {
#ifdef VIENNAFVM_DEBUG
          std::cout << std::endl;
          std::cout << "//" << std::endl;
          std::cout << "//   Equation " << pde_index << std::endl;
          std::cout << "//" << std::endl;
#endif
          assemble(pde_system, pde_index,
                   segment, storage,
                   system_matrix, load_vector);

        } // for pde_index
      } // functor
コード例 #4
0
ファイル: RowEchelon.cpp プロジェクト: krishauser/KrisLibrary
void RowEchelon<T>::backSub(VectorT& x) const
{
  Assert(EB.n == 1);
  Assert(EB.m == R.m);
  x.resize(R.n);
  VectorT b;
  EB.getColRef(0,b);

  Assert((int)firstEntry.size() == R.m+1);
  x.setZero();
  int m=R.m,n=R.n;
  for(int i=m-1;i>=0;i--) {
    VectorT ri; R.getRowRef(i,ri);
    //solve to set R*x = b[i]
    //calculate alpha = dot between rest of x[>ji] and R[i]
    int ji=firstEntry[i];
    if(ji == n) continue;
    int ji2=firstEntry[i+1];  //(i+1==m?n:firstEntry[i+1]);
    T alpha;
    if(ji2 == n) alpha = Zero;
    else {
      VectorT rji2; rji2.setRef(ri,ji2,1,R.n-ji2);
      VectorT xji2; xji2.setRef(x,ji2,1,R.n-ji2);
      alpha = xji2.dot(rji2);
    }
    x[ji] = (b[i]-alpha)/ri[ji];
  }
}
コード例 #5
0
void interval_set_element_iter_4_discrete_types()
{
    typedef IntervalSet<T> IntervalSetT;
    typedef typename IntervalSetT::interval_type IntervalT;
    typedef std::vector<T> VectorT;

    IntervalSetT set_a;
    set_a.add(I_I(1,3)).add(I_I(6,7));

    VectorT vec(5), cev(5);
    vec[0]=MK_v(1);vec[1]=MK_v(2);vec[2]=MK_v(3);vec[3]=MK_v(6);vec[4]=MK_v(7);
    cev[0]=MK_v(7);cev[1]=MK_v(6);cev[2]=MK_v(3);cev[3]=MK_v(2);cev[4]=MK_v(1);

    VectorT dest;
    std::copy(elements_begin(set_a), elements_end(set_a), std::back_inserter(dest));
    BOOST_CHECK_EQUAL( vec == dest, true );

    dest.clear();
    std::copy(elements_rbegin(set_a), elements_rend(set_a), std::back_inserter(dest));
    BOOST_CHECK_EQUAL( cev == dest, true );

    dest.clear();
    std::reverse_copy(elements_begin(set_a), elements_end(set_a), std::back_inserter(dest));
    BOOST_CHECK_EQUAL( cev == dest, true );

    dest.clear();
    std::reverse_copy(elements_rbegin(set_a), elements_rend(set_a), std::back_inserter(dest));
    BOOST_CHECK_EQUAL( vec == dest, true );
}
コード例 #6
0
ファイル: EngineEntity.cpp プロジェクト: mark711/Cafu
void EngineEntityT::Draw(bool FirstPersonView, const VectorT& ViewerPos) const
{
    MatSys::Renderer->PushMatrix(MatSys::RendererI::MODEL_TO_WORLD);
    MatSys::Renderer->PushLightingParameters();

    unsigned short Ent_Heading;
    unsigned short Ent_Pitch;
    unsigned short Ent_Bank;

    Entity->GetBodyOrientation(Ent_Heading, Ent_Pitch, Ent_Bank);

    // Get the currently set lighting parameters.
    const float* PosL=MatSys::Renderer->GetCurrentLightSourcePosition();
    VectorT      LightSourcePos   =VectorT(PosL[0], PosL[1], PosL[2]);
    float        LightSourceRadius=MatSys::Renderer->GetCurrentLightSourceRadius();

    const float* PosE=MatSys::Renderer->GetCurrentEyePosition();
    VectorT      EyePos=VectorT(PosE[0], PosE[1], PosE[2]);


    // Starting from world space, compute the position of the light source in model space.
    LightSourcePos=LightSourcePos-Entity->GetOrigin();         // Convert into unrotated model space.
    LightSourcePos=LightSourcePos.GetRotZ(-90.0+float(Ent_Heading)/8192.0*45.0);
    LightSourcePos=scale(LightSourcePos, 1.0/25.4);

    // Don't forget to scale the radius of the light source appropriately down (into model space), too.
    LightSourceRadius/=25.4f;


    // Do the same for the eye: Starting from world space, compute the position of the eye in model space.
    EyePos=EyePos-Entity->GetOrigin();         // Convert into unrotated model space.
    EyePos=EyePos.GetRotZ(-90.0+float(Ent_Heading)/8192.0*45.0);
    EyePos=scale(EyePos, 1.0/25.4);


    // Set the modified (now in model space) lighting parameters.
    MatSys::Renderer->SetCurrentLightSourcePosition(float(LightSourcePos.x), float(LightSourcePos.y), float(LightSourcePos.z));
    MatSys::Renderer->SetCurrentLightSourceRadius(LightSourceRadius);
    MatSys::Renderer->SetCurrentEyePosition(float(EyePos.x), float(EyePos.y), float(EyePos.z));


    // Set the ambient light color for this entity.
    // Paradoxically, this is not a global, but rather a per-entity value that is derived from the lightmaps that are close to that entity.
    const Vector3fT AmbientEntityLight=Entity->GetGameWorld()->GetAmbientLightColorFromBB(Entity->GetDimensions(), Entity->GetOrigin());
    MatSys::Renderer->SetCurrentAmbientLightColor(AmbientEntityLight.x, AmbientEntityLight.y, AmbientEntityLight.z);


    MatSys::Renderer->Translate(MatSys::RendererI::MODEL_TO_WORLD, float(Entity->GetOrigin().x), float(Entity->GetOrigin().y), float(Entity->GetOrigin().z));
    MatSys::Renderer->RotateZ  (MatSys::RendererI::MODEL_TO_WORLD, 90.0f-float(Ent_Heading)/8192.0f*45.0f);
    MatSys::Renderer->Scale    (MatSys::RendererI::MODEL_TO_WORLD, 25.4f);

    Entity->Draw(FirstPersonView, (float)length(ViewerPos-Entity->GetOrigin()));


    MatSys::Renderer->PopLightingParameters();
    MatSys::Renderer->PopMatrix(MatSys::RendererI::MODEL_TO_WORLD);
}
コード例 #7
0
ファイル: ArrayBase.hpp プロジェクト: BijanZarif/coolfluid3
 void set_row(const Uint array_idx, const VectorT& row)
 {
   cf3_assert(row.size() == row_size());
 
   Row row_to_set = m_array[array_idx];
   
   for(Uint j=0; j<row.size(); ++j)
     row_to_set[j] = row[j];
 }
コード例 #8
0
ファイル: DynTable.hpp プロジェクト: xyuan/coolfluid3
  void set_row(const Uint array_idx, const VectorT& row)
  {
    if (row.size() != row_size(array_idx))
      m_array[array_idx].resize(row.size());

    Uint j=0;
    boost_foreach( const typename VectorT::value_type& v, row)
      m_array[array_idx][j++] = v;
  }
コード例 #9
0
ファイル: Difference.hpp プロジェクト: krishnangv/coolfluid3
void vector_test(const VectorT& A, const VectorT& B, Accumulator& Result)
{
    const Uint sizeA = A.size();
    const Uint sizeB = B.size();
    for(Uint i = 0, j = 0; i != sizeA && j != sizeB; ++i, ++j)
        test(A[i], B[j], Result);

    Result.exact(sizeA == sizeB);
};
コード例 #10
0
ファイル: main.cpp プロジェクト: CCJY/coliru
int main()
{
    VectorT<int> vint;
    VectorT<double> vdouble;
    
    vint.Normalize();
    vdouble.Normalize();
    
    return 0;
}
コード例 #11
0
ファイル: Distance.cpp プロジェクト: K4stor/nice-core
Ipp32f EuclidianDistance<Ipp32f>::doCalculate(const VectorT<Ipp32f>& v1, const VectorT<Ipp32f>& v2) const {

    if(v1.size()!=v2.size())
        fthrow(Exception, "Input vectors must have the same size.");

    Ipp32f dist = 0;

    #ifdef NICE_USELIB_IPP

        VectorT<Ipp32f> res(v1.size());

        ippsSub_32f(v1.getDataPointer(), v2.getDataPointer(), res.getDataPointer(), v1.size());
        ippsSqr_32f(res.getDataPointer(), res.getDataPointer(), res.size());

        dist = res.Sum();

    #else // NICE_USELIB_IPP

        const Ipp32f* pSrc1 = v1.getDataPointer();
        const Ipp32f* pSrc2 = v2.getDataPointer();
                
        for(Ipp32u i=0; i<v1.size(); ++i,++pSrc1,++pSrc2)
            dist += (*pSrc1-*pSrc2)*(*pSrc1-*pSrc2);

    #endif // NICE_USELIB_IPP

    dist = std::sqrt(dist);

    return dist;
}
コード例 #12
0
ファイル: DiagonalMatrix.cpp プロジェクト: panjia1983/mintos
void DiagonalMatrixTemplate<T>::mulPseudoInverse(const VectorT& a, VectorT& b) const
{
  if(BaseT::n != a.n) FatalError(MatrixError_ArgIncompatibleDimensions);
  if(b.n == 0)
    b.resize(this->n);
  else if(b.n != this->n) FatalError(MatrixError_DestIncompatibleDimensions);
  
  ItT v=this->begin();
  VectorIterator<T> va=a.begin(),vb=b.begin();
  for(int i=0; i<this->n; i++, v++,va++,vb++)
    *vb = *va * PseudoInv(*v);
}
コード例 #13
0
ファイル: BallN.hpp プロジェクト: sidch/Thea
    T rayIntersectionTime(RayN<N, T> const & ray, T max_time = -1) const
    {
      VectorT co = ray.getOrigin() - center;

      T c = co.squaredNorm() - radius * radius;
      if (c <= 0)  // origin is inside ball
        return 0;

      // We could do an early test to see if the distance from the ray origin to the ball is less than
      // max_time * ray.getDirection().norm(), but it would involve a square root so might as well solve the quadratic.

      T a = ray.getDirection().squaredNorm();
      T b = 2 * co.dot(ray.getDirection());

      // Solve quadratic a * t^2 + b * t + c = 0
      T det = b * b - 4 * a * c;
      if (det < 0) return -1;

      T d = std::sqrt(det);
      T t = -1;
      if (a > 0)
      {
        T s0 = -b - d;
        if (s0 >= 0)
          t = s0 / (2 * a);
        else
        {
          T s1 = -b + d;
          if (s1 >= 0)
            t = s1 / (2 * a);
        }
      }
      else if (a < 0)
      {
        T s0 = -b + d;
        if (s0 <= 0)
          t = s0 / (2 * a);
        else
        {
          T s1 = -b - d;
          if (s1 <= 0)
            t = s1 / (2 * a);
        }
      }

      if (max_time >= 0 && t > max_time)
        return -1;
      else
        return t;
    }
コード例 #14
0
ファイル: MatrixTemplate.cpp プロジェクト: panjia1983/mintos
void MatrixTemplate<T>::copyCols(const VectorT* cols)
{
  CHECKEMPTY();
  for(int j=0; j<n; j++)
  {
    if(cols[j].n != m)
    {
      RaiseErrorFmt(WHERE_AM_I,MatrixError_IncompatibleDimensions,m,n,cols[j].n,-1);
    }
    VectorT tempcol;
    getColRef(j,tempcol);
    tempcol.copy(cols[j]);
  }
}
コード例 #15
0
ファイル: MatrixTemplate.cpp プロジェクト: panjia1983/mintos
void MatrixTemplate<T>::copyRows(const VectorT* rows)
{
  CHECKEMPTY();
  for(int i=0; i<m; i++)
  {
    if(rows[i].n != n)
    {
      RaiseErrorFmt(WHERE_AM_I,MatrixError_IncompatibleDimensions,m,n,-1,rows[i].n);
    }
    VectorT temprow;
    getRowRef(i,temprow);
    temprow.copy(rows[i]);
  }
}
コード例 #16
0
void SparseMatrixTemplate_RM<T>::mulTranspose(const VectorT& a,VectorT& x) const
{
  if(x.n == 0) x.resize(n);
  if(x.n != n) {
    FatalError("Destination vector has incorrect dimensions");
  }
  if(a.n != m) {
    FatalError("Source vector has incorrect dimensions");
  }
  x.setZero();
  for(int i=0;i<m;i++) {
    for(ConstRowIterator it=rows[i].begin();it!=rows[i].end();it++)
      x(it->first) += it->second*a(i);
  }
}
コード例 #17
0
ファイル: matrix_utils.hpp プロジェクト: cmu-sei/gbtl
    MatrixT diag(VectorT const                 &v,
                 typename MatrixT::ScalarType  zero =
                     static_cast<typename MatrixT::ScalarType>(0))
    {
        MatrixT diag(v.size(), v.size(), zero);
        diag.set_zero(zero);
        //populate diagnals:
        std::vector<IndexType> indices;
        for (graphblas::IndexType ix = 0; ix < v.size(); ++ix) {
            indices.push_back(ix);
        }

        graphblas::buildmatrix(diag, indices.begin(), indices.begin(), v.begin(), v.size());
        return diag;
    }
コード例 #18
0
      /**
       * Compute the search direction based on the current (inverse) Hessian
       * approximation and given gradient.
       *
       * @param[out] pk The negative product of the inverse Hessian and gradient
       * direction gk.
       * @param[in] gk Gradient direction.
       **/
      inline void search_direction(VectorT &pk, const VectorT &gk) const {
        std::vector<Scalar> alphas(_buf.size());
        typename
          boost::circular_buffer<UpdateT>::const_reverse_iterator buf_rit;
        typename boost::circular_buffer<UpdateT>::const_iterator buf_it;
        typename std::vector<Scalar>::const_iterator alpha_it;
        typename std::vector<Scalar>::reverse_iterator alpha_rit;

        pk.noalias() = -gk;
        for (buf_rit = _buf.rbegin(), alpha_rit = alphas.rbegin();
             buf_rit != _buf.rend();
             buf_rit++, alpha_rit++) {
          Scalar alpha;
          const Scalar &rhoi(boost::get<0>(*buf_rit));
          const VectorT &yi(boost::get<1>(*buf_rit));
          const VectorT &si(boost::get<2>(*buf_rit));

          alpha = rhoi * si.dot(pk);
          pk -= alpha * yi;
          *alpha_rit = alpha;
        }
        pk *= _gammak;
        for (buf_it = _buf.begin(), alpha_it = alphas.begin();
             buf_it != _buf.end();
             buf_it++, alpha_it++) {
          Scalar beta;
          const Scalar &rhoi(boost::get<0>(*buf_it));
          const VectorT &yi(boost::get<1>(*buf_it));
          const VectorT &si(boost::get<2>(*buf_it));

          beta = rhoi*yi.dot(pk);
          pk += (*alpha_it - beta)*si;
        }
      }
コード例 #19
0
void QRDecomposition<T>::backSub(const VectorT& b, VectorT& x) const
{
  if(x.n == 0) x.resize(QR.n);
  Assert(QR.m == b.n);
  Assert(QR.n == x.n);

  /* compute rhs = Q^T b */
  VectorT rhs;
  QtMul(b,rhs);
  if(QR.m == QR.n) {
    /* Solve R x = rhs, storing x in-place */
    UBackSubstitute(QR,rhs,x);
    //UBackSubstitute(QR,x,x);
  }
  else if(QR.m > QR.n) {
    //solve the top part of R x = rhs
    MatrixT R1; R1.setRef(QR,0,0,1,1,QR.n,QR.n);
    VectorT rhs1; rhs1.setRef(rhs,0,1,QR.n);
    UBackSubstitute(R1,rhs1,x);
  }
  else {
    cerr<<"What do we do with m < n?"<<endl;
    MatrixPrinter mprint(QR); mprint.mode = MatrixPrinter::AsciiShade;
    cerr<<mprint<<endl;
    //solve the left part of R x = rhs
    MatrixT R1; R1.setRef(QR,0,0,1,1,QR.m,QR.m);
    VectorT x1; x1.setRef(x,0,1,QR.m);
    UBackSubstitute(R1,rhs,x1);
    getchar();
  }
}
コード例 #20
0
      Requires_t<mtl::traits::is_distributed<VectorT>>
    initVector(VectorT& x) const
    {
#ifdef HAVE_PARALLEL_MTL4
      x.init_distribution(col_distribution(*fullMatrix), num_cols(*fullMatrix));
#endif
      set_to_zero(x);
    }
コード例 #21
0
			bool equivalent (const Line<D, NumericT> & other) {
				// Are we pointing in the same direction
				if (!_direction.equivalent(other._direction))
					return false;

				// Is the distance between the parallel lines equivalent to zero?
				return Numerics::equivalent(shortest_distance_to_point(other._point), 0);
			}
コード例 #22
0
ファイル: tensor_subview.cpp プロジェクト: fsheikh/openvsip
void
set_v(
  VectorT         vec,
  IndexObj const& obj)
{
  for (index_type p=0; p<vec.size(); ++p)
    vec(p) = obj(p);
}
コード例 #23
0
ファイル: tensor_subview.cpp プロジェクト: fsheikh/openvsip
void
check_v(
  VectorT         vec,
  IndexObj const& obj)
{
  for (index_type p=0; p<vec.size(); ++p)
    test_assert(vec(p) == obj(p));
}
コード例 #24
0
ファイル: StreamHelpers.hpp プロジェクト: Peita/coolfluid3
void print_vector(StreamT& stream, const VectorT& vector, const std::string& sep=" ", const std::string& prefix = "", const std::string& suffix = "")
{
  stream << prefix;
  const Uint vector_size = vector.size();
  for(Uint i = 0; i != vector_size; ++i)
  {
    stream << (i != 0 ? sep : "") << vector[i];
  }
  stream << suffix;
}
コード例 #25
0
      /**
       * Add a new set of update vectors to the history.
       *
       * @param yk Difference between the current and previous gradient vector.
       * @param sk Difference between the current and previous state vector.
       * @param reset Whether to reset the approximation, forgetting about
       * previous values.
       * @return In the case of a reset, returns the optimal scaling of the
       * initial Hessian
       * approximation which is useful for predicting step-sizes.
       **/
      inline Scalar update(const VectorT &yk, const VectorT &sk,
                           bool reset = false) {
        Scalar skyk = yk.dot(sk);

        Scalar B0fact;
        if (reset) {
          B0fact = yk.squaredNorm()/skyk;
          _buf.clear();
        } else {
          B0fact = 1.0;
        }

        // New updates are pushed to the "back" of the circular buffer
        Scalar invskyk = 1.0/skyk;
        _gammak = skyk/yk.squaredNorm();
        _buf.push_back();
        _buf.back() = boost::tie(invskyk, yk, sk);

        return B0fact;
      }
コード例 #26
0
void SparseVectorTemplate<T>::get(VectorT& v) const
{
  v.resize(this->n);
  int k=0;
  for(const_iterator i=this->begin();i!=this->end();i++) {
    while(k < i->first) { v(k)=0; k++; }
    v(k) = i->second;
    k=i->first+1;
  }
  while(k < (int)this->n) { v(k)=0; k++; }
}
コード例 #27
0
ファイル: MatrixTemplate.cpp プロジェクト: panjia1983/mintos
void MatrixTemplate<T>::maddTranspose(const VectorT& a, VectorT& b) const
{
  if(m != a.n)
  {
    RaiseErrorFmt(WHERE_AM_I,MatrixError_ArgIncompatibleDimensions);
  }
  if(b.n == 0)
  {
    b.resize(n);
  }
  else if(b.n != n)
  {
    RaiseErrorFmt(WHERE_AM_I,MatrixError_DestIncompatibleDimensions);
  }

  gen_array2d_vector_madd_transpose(b.getStart(),b.stride,
    getStart(),istride,jstride, 
    a.getStart(),a.stride, 
    m, n);
}
コード例 #28
0
			/// Returns the time on the line where a point is closest to the given point.
			NumericT time_for_closest_point (const VectorT & p3) const {
				auto p1 = _point;
				auto p2 = _point + _direction;

				auto d = _direction.length_squared();
				NumericT t = 0;

				for (dimension i = 0; i < D; ++i)
					t += (p3[i] - p1[i]) * (p2[i] - p1[i]);

				return t / d;
			}
コード例 #29
0
void SparseVectorCompressed<T>::get(VectorT& v) const
{
  v.resize(n);
  int i=0;
  for(int k=0;k<num_entries;k++) {
    for(;i<indices[k];i++)
      v[i]=Zero;
    v[i]=vals[k];
  }
  for(;i<this->n;i++)
    v[i]=Zero;
}
コード例 #30
0
ファイル: norm_2.hpp プロジェクト: BijanZarif/coolfluid3
 typename VectorT::value_type
 norm_2(VectorT const& v1,
      typename viennacl::tools::enable_if< viennacl::is_stl< typename viennacl::traits::tag_of< VectorT >::type >::value
                                         >::type* dummy = 0)
 {
   //std::cout << "stl .. " << std::endl;
   typename VectorT::value_type result = 0;
   for (typename VectorT::size_type i=0; i<v1.size(); ++i)
     result += v1[i] * v1[i];
   
   return sqrt(result);
 }