Vector.h

Go to the documentation of this file.

//     ____   ______ __
//    / __ \ / ____// /
//   / /_/ // /    / /
//  / ____// /___ / /___   PixInsight Class Library
// /_/     \____//_____/   PCL 2.6.11
// ----------------------------------------------------------------------------
// pcl/Vector.h - Released 2024-05-07T15:27:32Z
// ----------------------------------------------------------------------------
// This file is part of the PixInsight Class Library (PCL).
// PCL is a multiplatform C++ framework for development of PixInsight modules.
//
// Copyright (c) 2003-2024 Pleiades Astrophoto S.L. All Rights Reserved.
//
// Redistribution and use in both source and binary forms, with or without
// modification, is permitted provided that the following conditions are met:
//
// 1. All redistributions of source code must retain the above copyright
//    notice, this list of conditions and the following disclaimer.
//
// 2. All redistributions in binary form must reproduce the above copyright
//    notice, this list of conditions and the following disclaimer in the
//    documentation and/or other materials provided with the distribution.
//
// 3. Neither the names "PixInsight" and "Pleiades Astrophoto", nor the names
//    of their contributors, may be used to endorse or promote products derived
//    from this software without specific prior written permission. For written
//    permission, please contact info@pixinsight.com.
//
// 4. All products derived from this software, in any form whatsoever, must
//    reproduce the following acknowledgment in the end-user documentation
//    and/or other materials provided with the product:
//
//    "This product is based on software from the PixInsight project, developed
//    by Pleiades Astrophoto and its contributors (https://pixinsight.com/)."
//
//    Alternatively, if that is where third-party acknowledgments normally
//    appear, this acknowledgment must be reproduced in the product itself.
//
// THIS SOFTWARE IS PROVIDED BY PLEIADES ASTROPHOTO AND ITS CONTRIBUTORS
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
// TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL PLEIADES ASTROPHOTO OR ITS
// CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
// EXEMPLARY OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, BUSINESS
// INTERRUPTION; PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; AND LOSS OF USE,
// DATA OR PROFITS) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
// CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
// ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
// POSSIBILITY OF SUCH DAMAGE.
// ----------------------------------------------------------------------------
 
#ifndef __PCL_Vector_h
#define __PCL_Vector_h
 
 
#include <pcl/Defs.h>
#include <pcl/Diagnostics.h>
 
#include <pcl/Container.h>
#include <pcl/Exception.h>
#include <pcl/ReferenceCounter.h>
#include <pcl/Search.h>
#include <pcl/Sort.h>
#include <pcl/Utility.h>
 
#ifndef __PCL_NO_VECTOR_STATISTICS
#  include <pcl/Selection.h>
#endif
 
#ifndef __PCL_NO_VECTOR_INSTANTIATE
#  include <pcl/Complex.h>
#endif
 
namespace pcl
{
 
// ----------------------------------------------------------------------------
 
template <typename T>
class PCL_CLASS GenericVector : public DirectContainer<T>
{
public:
 
   using scalar = T;
 
   using component = T;
 
   using iterator = T*;
 
   using const_iterator = const T*;
 
   GenericVector()
   {
      m_data = new Data;
   }
 
   GenericVector( int len )
   {
      PCL_PRECONDITION( len >= 0 )
      m_data = new Data( len );
   }
 
   GenericVector( const component& x, int len )
   {
      PCL_PRECONDITION( len >= 0 )
      m_data = new Data( len );
            iterator __restrict__ i = m_data->Begin();
      const_iterator __restrict__ j = m_data->End();
      PCL_IVDEP
      for ( ; i < j; ++i )
         *i = x;
   }
 
   template <typename T1>
   GenericVector( const T1* a, int len )
   {
      PCL_PRECONDITION( len >= 0 )
      m_data = new Data( len );
      if ( a != nullptr )
      {
               iterator __restrict__ i = m_data->Begin();
         const_iterator __restrict__ j = m_data->End();
         const T1*      __restrict__ k = a;
         PCL_IVDEP
         for ( ; i < j; ++i, ++k )
            *i = component( *k );
      }
   }
 
   template <typename T1>
   GenericVector( std::initializer_list<T1> c )
      : GenericVector( c.begin(), int( c.size() ) )
   {
   }
 
   template <typename T1>
   GenericVector( const T1& x, const T1& y, const T1& z )
   {
      m_data = new Data( 3 );
      iterator v = m_data->Begin();
      *v++ = component( x );
      *v++ = component( y );
      *v   = component( z );
   }
 
   template <typename T1>
   GenericVector( const T1& x, const T1& y, const T1& z, const T1& t )
   {
      m_data = new Data( 4 );
      iterator v = m_data->Begin();
      *v++ = component( x );
      *v++ = component( y );
      *v++ = component( z );
      *v   = component( t );
   }
 
   GenericVector( const GenericVector& x )
      : m_data( x.m_data )
   {
      m_data->Attach();
   }
 
   GenericVector( GenericVector&& x )
      : m_data( x.m_data )
   {
      x.m_data = nullptr;
   }
 
   template <typename T1>
   GenericVector( const GenericVector<T1>& x )
      : GenericVector( x.Begin(), x.Length() )
   {
   }
 
   virtual ~GenericVector()
   {
      if ( m_data != nullptr )
      {
         DetachFromData();
         m_data = nullptr;
      }
   }
 
   void Clear()
   {
      if ( !IsEmpty() )
         if ( m_data->IsUnique() )
            m_data->Deallocate();
         else
         {
            Data* newData = new Data( 0 );
            DetachFromData();
            m_data = newData;
         }
   }
 
   GenericVector& operator =( const GenericVector& x )
   {
      Assign( x );
      return *this;
   }
 
   void Assign( const GenericVector& x )
   {
      x.m_data->Attach();
      DetachFromData();
      m_data = x.m_data;
   }
 
   GenericVector& operator =( GenericVector&& x )
   {
      Transfer( x );
      return *this;
   }
 
   void Transfer( GenericVector& x )
   {
      DetachFromData();
      m_data = x.m_data;
      x.m_data = nullptr;
   }
 
   void Transfer( GenericVector&& x )
   {
      DetachFromData();
      m_data = x.m_data;
      x.m_data = nullptr;
   }
 
   friend void Swap( GenericVector& x1, GenericVector& x2 ) noexcept
   {
      pcl::Swap( x1.m_data, x2.m_data );
   }
 
   GenericVector& operator =( const scalar& x )
   {
      if ( !IsUnique() )
      {
         Data* newData = new Data( m_data->Length() );
         DetachFromData();
         m_data = newData;
      }
            iterator __restrict__ i = m_data->Begin();
      const_iterator __restrict__ j = m_data->End();
      PCL_IVDEP
      for ( ; i < j; ++i )
         *i = x;
      return *this;
   }
 
   GenericVector& operator +=( const GenericVector& x )
   {
      if ( x.Length() < Length() )
         throw Error( "Invalid vector addition." );
      EnsureUnique();
            iterator __restrict__ i = m_data->Begin();
      const_iterator __restrict__ j = m_data->End();
      const_iterator __restrict__ k = x.Begin();
      PCL_IVDEP
      for ( ; i < j; ++i, ++k )
         *i += *k;
      return *this;
   }
 
   GenericVector& operator -=( const GenericVector& x )
   {
      if ( x.Length() < Length() )
         throw Error( "Invalid vector subtraction." );
      EnsureUnique();
            iterator __restrict__ i = m_data->Begin();
      const_iterator __restrict__ j = m_data->End();
      const_iterator __restrict__ k = x.Begin();
      PCL_IVDEP
      for ( ; i < j; ++i, ++k )
         *i -= *k;
      return *this;
   }
 
   GenericVector& operator *=( const GenericVector& x )
   {
      if ( x.Length() < Length() )
         throw Error( "Invalid vector multiplication." );
      EnsureUnique();
            iterator __restrict__ i = m_data->Begin();
      const_iterator __restrict__ j = m_data->End();
      const_iterator __restrict__ k = x.Begin();
      PCL_IVDEP
      for ( ; i < j; ++i, ++k )
         *i *= *k;
      return *this;
   }
 
   GenericVector& operator /=( const GenericVector& x )
   {
      if ( x.Length() < Length() )
         throw Error( "Invalid vector division." );
      EnsureUnique();
            iterator __restrict__ i = m_data->Begin();
      const_iterator __restrict__ j = m_data->End();
      const_iterator __restrict__ k = x.Begin();
      PCL_IVDEP
      for ( ; i < j; ++i, ++k )
         *i /= *k;
      return *this;
   }
 
#define IMPLEMENT_SCALAR_ASSIGN_OP( op )                                      \
      if ( IsUnique() )                                                       \
      {                                                                       \
               iterator __restrict__ i = m_data->Begin();                     \
         const_iterator __restrict__ j = m_data->End();                       \
         PCL_IVDEP                                                            \
         for ( ; i < j; ++i )                                                 \
            *i op##= x;                                                       \
      }                                                                       \
      else                                                                    \
      {                                                                       \
         Data* newData = new Data( m_data->Length() );                        \
         const_iterator __restrict__ i = m_data->Begin();                     \
         const_iterator __restrict__ j = m_data->End();                       \
               iterator __restrict__ k = newData->Begin();                    \
         PCL_IVDEP                                                            \
         for ( ; i < j; ++i, ++k )                                            \
            *k = *i op x;                                                     \
         DetachFromData();                                                    \
         m_data = newData;                                                    \
      }                                                                       \
      return *this;
 
   GenericVector& operator +=( const scalar& x )
   {
      IMPLEMENT_SCALAR_ASSIGN_OP( + )
   }
 
   GenericVector& operator -=( const scalar& x )
   {
      IMPLEMENT_SCALAR_ASSIGN_OP( - )
   }
 
   GenericVector& operator *=( const scalar& x )
   {
      IMPLEMENT_SCALAR_ASSIGN_OP( * )
   }
 
   GenericVector& operator /=( const scalar& x )
   {
      IMPLEMENT_SCALAR_ASSIGN_OP( / )
   }
 
   GenericVector& operator ^=( const scalar& x )
   {
      if ( IsUnique() )
      {
               iterator __restrict__ i = m_data->Begin();
         const_iterator __restrict__ j = m_data->End();
         PCL_IVDEP
         for ( ; i < j; ++i )
            *i = pcl::Pow( *i, x );
      }
      else
      {
         Data* newData = new Data( m_data->Length() );
         const_iterator __restrict__ i = m_data->Begin();
         const_iterator __restrict__ j = m_data->End();
               iterator __restrict__ k = newData->Begin();
         PCL_IVDEP
         for ( ; i < j; ++i, ++k )
            *k = pcl::Pow( *i, x );
         DetachFromData();
         m_data = newData;
      }
      return *this;
   }
 
#undef IMPLEMENT_SCALAR_ASSIGN_OP
 
   scalar Dot( const GenericVector& v ) const noexcept
   {
      PCL_PRECONDITION( v.Length() >= Length() )
      scalar r = scalar( 0 );
      const_iterator __restrict__ i = m_data->Begin();
      const_iterator __restrict__ j = m_data->End();
      const_iterator __restrict__ k = v.Begin();
      PCL_IVDEP
      for ( ; i < j; ++i, ++k )
         r += scalar( *i ) * scalar( *k );
      return r;
   }
 
   GenericVector Cross( const GenericVector& v2 ) const
   {
      PCL_PRECONDITION( Length() == 3 && v2.Length() == 3 )
      component x1 = *At( 0 );
      component y1 = *At( 1 );
      component z1 = *At( 2 );
      component x2 = v2[0];
      component y2 = v2[1];
      component z2 = v2[2];
      return GenericVector( y1*z2 - z1*y2,
                            z1*x2 - x1*z2,
                            x1*y2 - y1*x2 );
   }
 
   GenericVector operator -() const
   {
      GenericVector R( m_data->Length() );
      const_iterator __restrict__ i = m_data->Begin();
      const_iterator __restrict__ j = m_data->End();
            iterator __restrict__ k = R.Begin();
      PCL_IVDEP
      for ( ; i < j; ++i, ++k )
         *k = -*i;
      return R;
   }
 
   void ReverseSign()
   {
      if ( IsUnique() )
      {
               iterator __restrict__ i = m_data->Begin();
         const_iterator __restrict__ j = m_data->End();
         PCL_IVDEP
         for ( ; i < j; ++i )
            *i = -*i;
      }
      else
      {
         Data* newData = new Data( m_data->Length() );
         const_iterator __restrict__ i = m_data->Begin();
         const_iterator __restrict__ j = m_data->End();
               iterator __restrict__ k = newData->Begin();
         PCL_IVDEP
         for ( ; i < j; ++i, ++k )
            *k = -*i;
         DetachFromData();
         m_data = newData;
      }
   }
 
   GenericVector Sqr() const
   {
      GenericVector R( m_data->Length() );
      const_iterator __restrict__ i = m_data->Begin();
      const_iterator __restrict__ j = m_data->End();
            iterator __restrict__ k = R.Begin();
      PCL_IVDEP
      for ( ; i < j; ++i, ++k )
         *k = *i * *i;
      return R;
   }
 
   void SetSqr()
   {
      if ( IsUnique() )
      {
               iterator __restrict__ i = m_data->Begin();
         const_iterator __restrict__ j = m_data->End();
         PCL_IVDEP
         for ( ; i < j; ++i )
            *i *= *i;
      }
      else
      {
         Data* newData = new Data( m_data->Length() );
         const_iterator __restrict__ i = m_data->Begin();
         const_iterator __restrict__ j = m_data->End();
               iterator __restrict__ k = newData->Begin();
         PCL_IVDEP
         for ( ; i < j; ++i, ++k )
            *k = *i * *i;
         DetachFromData();
         m_data = newData;
      }
   }
 
   GenericVector Sqrt() const
   {
      GenericVector R( m_data->Length() );
      const_iterator __restrict__ i = m_data->Begin();
      const_iterator __restrict__ j = m_data->End();
            iterator __restrict__ k = R.Begin();
      PCL_IVDEP
      for ( ; i < j; ++i, ++k )
         *k = pcl::Sqrt( *i );
      return R;
   }
 
   void SetSqrt()
   {
      if ( IsUnique() )
      {
               iterator __restrict__ i = m_data->Begin();
         const_iterator __restrict__ j = m_data->End();
         for ( ; i < j; ++i )
            *i = pcl::Sqrt( *i );
      }
      else
      {
         Data* newData = new Data( m_data->Length() );
         const_iterator __restrict__ i = m_data->Begin();
         const_iterator __restrict__ j = m_data->End();
               iterator __restrict__ k = newData->Begin();
         PCL_IVDEP
         for ( ; i < j; ++i, ++k )
            *k = pcl::Sqrt( *i );
         DetachFromData();
         m_data = newData;
      }
   }
 
   GenericVector Abs() const
   {
      GenericVector R( m_data->Length() );
      const_iterator __restrict__ i = m_data->Begin();
      const_iterator __restrict__ j = m_data->End();
            iterator __restrict__ k = R.Begin();
      PCL_IVDEP
      for ( ; i < j; ++i, ++k )
         *k = pcl::Abs( *i );
      return R;
   }
 
   void SetAbs()
   {
      if ( IsUnique() )
      {
               iterator __restrict__ i = m_data->Begin();
         const_iterator __restrict__ j = m_data->End();
         PCL_IVDEP
         for ( ; i < j; ++i )
            *i = pcl::Abs( *i );
      }
      else
      {
         Data* newData = new Data( m_data->Length() );
         const_iterator __restrict__ i = m_data->Begin();
         const_iterator __restrict__ j = m_data->End();
               iterator __restrict__ k = newData->Begin();
         PCL_IVDEP
         for ( ; i < j; ++i, ++k )
            *k = pcl::Abs( *i );
         DetachFromData();
         m_data = newData;
      }
   }
 
   scalar Norm( double p ) const noexcept
   {
      return pcl::Norm( m_data->Begin(), m_data->End(), p );
   }
 
   scalar L1Norm() const noexcept
   {
      return pcl::L1Norm( m_data->Begin(), m_data->End() );
   }
 
   scalar L2Norm() const noexcept
   {
      return pcl::L2Norm( m_data->Begin(), m_data->End() );
   }
 
   scalar Norm() const noexcept
   {
      return L2Norm();
   }
 
   GenericVector Unit() const
   {
      GenericVector R( *this );
      scalar N = L2Norm();
      if ( scalar( 1 ) + N > scalar( 1 ) )
         R /= N;
      return R;
   }
 
   void SetUnit()
   {
      scalar N = L2Norm();
      if ( scalar( 1 ) + N > scalar( 1 ) )
         (void)operator /=( N );
   }
 
   void Sort()
   {
      EnsureUnique();
      pcl::Sort( m_data->Begin(), m_data->End() );
   }
 
   GenericVector Sorted() const
   {
      GenericVector R( *this );
      R.Sort();
      return R;
   }
 
   void ReverseSort()
   {
      EnsureUnique();
      pcl::Sort( m_data->Begin(), m_data->End(),
                 []( const scalar& a, const scalar& b ){ return b < a; } );
   }
 
   GenericVector ReverseSorted() const
   {
      GenericVector R( *this );
      R.ReverseSort();
      return R;
   }
 
   template <class BP>
   void Sort( BP p )
   {
      EnsureUnique();
      pcl::Sort( m_data->Begin(), m_data->End(), p );
   }
 
   template <class BP>
   GenericVector Sorted( BP p ) const
   {
      GenericVector R( *this );
      R.Sort( p );
      return R;
   }
 
   int Find( const component& x ) const noexcept
   {
      const_iterator p = pcl::LinearSearch( m_data->Begin(), m_data->End(), x );
      return (p != m_data->End()) ? int( p - m_data->Begin() ) : -1;
   }
 
   int FindFirst( const component& x ) const noexcept
   {
      return Find( x );
   }
 
   int FindLast( const component& x ) const noexcept
   {
      const_iterator p = pcl::LinearSearchLast( m_data->Begin(), m_data->End(), x );
      return (p != m_data->End()) ? int( p - m_data->Begin() ) : -1;
   }
 
   bool Contains( const component& x ) const noexcept
   {
      return pcl::LinearSearch( m_data->Begin(), m_data->End(), x ) != m_data->End();
   }
 
#ifndef __PCL_NO_VECTOR_STATISTICS
 
   int IndexOfSmallestComponent() const noexcept
   {
      return int( pcl::MinItem( m_data->Begin(), m_data->End() ) - m_data->Begin() );
   }
 
   int IndexOfLargestComponent() const noexcept
   {
      return int( pcl::MaxItem( m_data->Begin(), m_data->End() ) - m_data->Begin() );
   }
 
   int IndexOfLastSmallestComponent() const noexcept
   {
      iterator i = m_data->Begin();
      if ( m_data->Length() > 0 )
         for ( iterator j = m_data->Begin(); ++j < m_data->End(); )
            if ( *j <= *i )
               i = j;
      return i - m_data->Begin();
   }
 
   int IndexOfLastLargestComponent() const noexcept
   {
      iterator i = m_data->Begin();
      if ( m_data->Length() > 0 )
         for ( iterator j = m_data->Begin(); ++j < m_data->End(); )
            if ( *i <= *j )
               i = j;
      return i - m_data->Begin();
   }
 
   int IndexOfSmallestNonzeroComponent() const noexcept
   {
      iterator i = m_data->Begin();
      if ( m_data->Length() > 0 )
      {
         while ( *i == component( 0 ) )
            if ( ++i == m_data->End() )
               return m_data->Length();
         for ( iterator j = i; ++j < m_data->End(); )
            if ( *j != component( 0 ) )
               if ( *j < *i )
                  i = j;
      }
      return i - m_data->Begin();
   }
 
   int IndexOfLastSmallestNonzeroComponent() const noexcept
   {
      iterator i = m_data->Begin();
      if ( m_data->Length() > 0 )
      {
         while ( *i == component( 0 ) )
            if ( ++i == m_data->End() )
               return m_data->Length();
         for ( iterator j = i; ++j < m_data->End(); )
            if ( *j != component( 0 ) )
               if ( *j <= *i )
                  i = j;
      }
      return i - m_data->Begin();
   }
 
   component MinComponent() const noexcept
   {
      if ( m_data->Length() > 0 )
         return *pcl::MinItem( m_data->Begin(), m_data->End() );
      return component( 0 );
   }
 
   component MaxComponent() const noexcept
   {
      if ( m_data->Length() > 0 )
         return *pcl::MaxItem( m_data->Begin(), m_data->End() );
      return component( 0 );
   }
 
   component OrderStatistic( int k )
   {
      PCL_PRECONDITION( !IsEmpty() )
      PCL_PRECONDITION( k >= 0 && k < m_data->Length() )
      EnsureUnique();
      return *pcl::Select( m_data->Begin(), m_data->End(), k );
   }
 
   component OrderStatistic( int k ) const
   {
      return GenericVector( *this ).OrderStatistic( k );
   }
 
   double Sum() const noexcept
   {
      return pcl::Sum( m_data->Begin(), m_data->End() );
   }
 
   double StableSum() const noexcept
   {
      return pcl::StableSum( m_data->Begin(), m_data->End() );
   }
 
   double Modulus() const noexcept
   {
      return pcl::Modulus( m_data->Begin(), m_data->End() );
   }
 
   double StableModulus() const noexcept
   {
      return pcl::StableModulus( m_data->Begin(), m_data->End() );
   }
 
   double SumOfSquares() const noexcept
   {
      return pcl::SumOfSquares( m_data->Begin(), m_data->End() );
   }
 
   double StableSumOfSquares() const noexcept
   {
      return pcl::StableSumOfSquares( m_data->Begin(), m_data->End() );
   }
 
   double Mean() const
   {
      return pcl::Mean( m_data->Begin(), m_data->End() );
   }
 
   double StableMean() const noexcept
   {
      return pcl::StableMean( m_data->Begin(), m_data->End() );
   }
 
   double TrimmedMean( distance_type l = 1, distance_type h = 1 ) const noexcept
   {
      return pcl::TrimmedMean( m_data->Begin(), m_data->End(), l, h );
   }
 
   double TrimmedMeanOfSquares( distance_type l = 1, distance_type h = 1 ) const noexcept
   {
      return pcl::TrimmedMeanOfSquares( m_data->Begin(), m_data->End(), l, h );
   }
 
   double Variance() const noexcept
   {
      return pcl::Variance( m_data->Begin(), m_data->End() );
   }
 
   double StdDev() const noexcept
   {
      return pcl::StdDev( m_data->Begin(), m_data->End() );
   }
 
   double Median() const
   {
      return pcl::Median( m_data->Begin(), m_data->End() );
   }
 
   double AvgDev( double center ) const noexcept
   {
      return pcl::AvgDev( m_data->Begin(), m_data->End(), center );
   }
 
   double StableAvgDev( double center ) const noexcept
   {
      return pcl::StableAvgDev( m_data->Begin(), m_data->End(), center );
   }
 
   double AvgDev() const
   {
      return pcl::AvgDev( m_data->Begin(), m_data->End() );
   }
 
   double StableAvgDev() const
   {
      return pcl::StableAvgDev( m_data->Begin(), m_data->End() );
   }
 
   TwoSidedEstimate TwoSidedAvgDev( double center ) const noexcept
   {
      return pcl::TwoSidedAvgDev( m_data->Begin(), m_data->End(), center );
   }
 
   TwoSidedEstimate TwoSidedAvgDev() const
   {
      return pcl::TwoSidedAvgDev( m_data->Begin(), m_data->End() );
   }
 
   double MAD( double center ) const
   {
      return pcl::MAD( m_data->Begin(), m_data->End(), center );
   }
 
   double MAD() const
   {
      return pcl::MAD( m_data->Begin(), m_data->End() );
   }
 
   TwoSidedEstimate TwoSidedMAD( double center ) const
   {
      return pcl::TwoSidedMAD( m_data->Begin(), m_data->End(), center );
   }
 
   TwoSidedEstimate TwoSidedMAD() const
   {
      return pcl::TwoSidedMAD( m_data->Begin(), m_data->End() );
   }
 
   double BiweightMidvariance( double center, double sigma, int k = 9, bool reducedLength = false ) const noexcept
   {
      return pcl::BiweightMidvariance( m_data->Begin(), m_data->End(), center, sigma, k, reducedLength );
   }
 
   double BiweightMidvariance( int k = 9, bool reducedLength = false ) const
   {
      double center = Median();
      return BiweightMidvariance( center, MAD( center ), k, reducedLength );
   }
 
   TwoSidedEstimate TwoSidedBiweightMidvariance( double center, const TwoSidedEstimate& sigma,
                                                 int k = 9, bool reducedLength = false ) const noexcept
   {
      return pcl::TwoSidedBiweightMidvariance( m_data->Begin(), m_data->End(), center, sigma, k, reducedLength );
   }
 
   TwoSidedEstimate TwoSidedBiweightMidvariance( int k = 9, bool reducedLength = false ) const
   {
      double center = Median();
      return TwoSidedBiweightMidvariance( center, TwoSidedMAD( center ), k, reducedLength );
   }
 
   double BendMidvariance( double center, double beta = 0.2 ) const
   {
      return pcl::BendMidvariance( m_data->Begin(), m_data->End(), center, beta );
   }
 
   double BendMidvariance( double beta = 0.2 ) const
   {
      return pcl::BendMidvariance( m_data->Begin(), m_data->End(), Median(), beta );
   }
 
   double Sn() const
   {
      GenericVector v( *this );
      return pcl::Sn( v.Begin(), v.End() );
   }
 
   double Qn() const
   {
      GenericVector v( *this );
      return pcl::Qn( v.Begin(), v.End() );
   }
 
#endif   // !__PCL_NO_VECTOR_STATISTICS
 
   uint64 Hash64( uint64 seed = 0 ) const noexcept
   {
      return pcl::Hash64( m_data->Begin(), m_data->Size(), seed );
   }
 
   uint32 Hash32( uint32 seed = 0 ) const noexcept
   {
      return pcl::Hash32( m_data->Begin(), m_data->Size(), seed );
   }
 
   uint64 Hash( uint64 seed = 0 ) const noexcept
   {
      return Hash64( seed );
   }
 
   bool IsUnique() const noexcept
   {
      return m_data->IsUnique();
   }
 
   bool IsAliasOf( const GenericVector& x ) const noexcept
   {
      return m_data == x.m_data;
   }
 
   void EnsureUnique()
   {
      if ( !IsUnique() )
      {
         Data* newData = new Data( m_data->Length() );
         const_iterator __restrict__ i = m_data->Begin();
         const_iterator __restrict__ j = m_data->End();
               iterator __restrict__ k = newData->Begin();
         PCL_IVDEP
         for ( ; i < j; ++i, ++k )
            *k = *i;
         DetachFromData();
         m_data = newData;
      }
   }
 
   int Length() const noexcept
   {
      return m_data->Length();
   }
 
   size_type Size() const noexcept
   {
      return m_data->Size();
   }
 
   bool IsValid() const noexcept
   {
      return m_data != nullptr;
   }
 
   bool IsEmpty() const noexcept
   {
      return Length() == 0;
   }
 
   operator bool() const noexcept
   {
      return !IsEmpty();
   }
 
   bool operator ==( const GenericVector& x ) const noexcept
   {
      return IsAliasOf( x ) || SameLength( x ) && pcl::Equal( Begin(), x.Begin(), x.End() );
   }
 
   bool operator <( const GenericVector& x ) const noexcept
   {
      return !IsAliasOf( x ) && pcl::Compare( Begin(), End(), x.Begin(), x.End() ) < 0;
   }
 
   bool SameLength( const GenericVector& x ) const noexcept
   {
      return Length() == x.Length();
   }
 
   iterator At( int i )
   {
      EnsureUnique();
      return m_data->At( i );
   }
 
   const_iterator At( int i ) const noexcept
   {
      return m_data->At( i );
   }
 
   iterator Begin()
   {
      EnsureUnique();
      return m_data->Begin();
   }
 
   const_iterator Begin() const noexcept
   {
      return m_data->Begin();
   }
 
   const_iterator ConstBegin() const noexcept
   {
      return Begin();
   }
 
   iterator operator *()
   {
      return Begin();
   }
 
   const_iterator operator *() const noexcept
   {
      return Begin();
   }
 
   iterator End()
   {
      EnsureUnique();
      return m_data->End();
   }
 
   const_iterator End() const noexcept
   {
      return m_data->End();
   }
 
   const_iterator ConstEnd() const noexcept
   {
      return End();
   }
 
   component& operator []( int i )
   {
      return *At( i );
   }
 
   const component& operator []( int i ) const noexcept
   {
      return *At( i );
   }
 
   iterator DataPtr() noexcept
   {
      return m_data->v;
   }
 
   iterator ComponentPtr( int i ) noexcept
   {
      return m_data->At( i );
   }
 
#ifndef __PCL_NO_STL_COMPATIBLE_ITERATORS
   iterator begin()
   {
      return Begin();
   }
 
   const_iterator begin() const noexcept
   {
      return Begin();
   }
 
   iterator end()
   {
      return End();
   }
 
   const_iterator end() const noexcept
   {
      return End();
   }
#endif   // !__PCL_NO_STL_COMPATIBLE_ITERATORS
 
   template <typename T1, typename T2>
   void ToSpherical( T1& lon, T2& lat ) const noexcept
   {
      PCL_PRECONDITION( Length() >= 3 )
      double x = *At( 0 );
      double y = *At( 1 );
      double z = *At( 2 );
      double m2 = x*x + y*y;
      lon = T1( (m2 == 0) ? 0.0 : ArcTan( y, x ) );
      lat = T2( (z == 0)  ? 0.0 : ArcTan( z, pcl::Sqrt( m2 ) ) );
   }
 
   template <typename T1, typename T2>
   void ToSpherical2Pi( T1& lon, T2& lat ) const noexcept
   {
      ToSpherical( lon, lat );
      if ( lon < 0 )
         lon += TwoPi();
   }
 
   static GenericVector FromSpherical( double slon, double clon, double slat, double clat )
   {
      return GenericVector( clon*clat, slon*clat, slat );
   }
 
   template <typename T1, typename T2>
   static GenericVector FromSpherical( const T1& lon, const T2& lat )
   {
      double slon, clon, slat, clat;
      SinCos( double( lon ), slon, clon );
      SinCos( double( lat ), slat, clat );
      return FromSpherical( slon, clon, slat, clat );
   }
 
   template <typename T1>
   static GenericVector FromArray( const T1* a, int len )
   {
      return GenericVector( a, len );
   }
 
   double Angle2D( const GenericVector& v ) const noexcept
   {
      /*
       * https://stackoverflow.com/questions/14066933/direct-way-of-computing-clockwise-angle-between-2-vectors
       * https://stackoverflow.com/questions/243945/calculating-a-2d-vectors-cross-product
       */
      component x1 = *At( 0 );
      component y1 = *At( 1 );
      component x2 = v[0];
      component y2 = v[1];
      return ArcTan( x1*y2 - y1*x2, Dot( v ) );
   }
 
   double Angle3D( const GenericVector& v ) const noexcept
   {
      /*
       * https://stackoverflow.com/questions/14066933/direct-way-of-computing-clockwise-angle-between-2-vectors
       */
      return ArcTan( Cross( v ).L2Norm(), Dot( v ) );
   }
 
   double Angle3D( const GenericVector& v, const GenericVector& n ) const
   {
      /*
       * https://stackoverflow.com/questions/14066933/direct-way-of-computing-clockwise-angle-between-2-vectors
       */
      GenericVector c = Cross( v );
      return ArcTan( (((n * c) >= 0) ? 1 : -1) * c.L2Norm(), Dot( v ) );
   }
 
   template <class S, typename SP>
   S& ToSeparated( S& s, SP separator ) const
   {
      const_iterator i = m_data->Begin(), j = m_data->End();
      if ( i < j )
      {
         s.Append( S( *i ) );
         if ( ++i < j )
            do
            {
               s.Append( separator );
               s.Append( S( *i ) );
            }
            while ( ++i < j );
      }
      return s;
   }
 
   template <class S, typename SP, class AF>
   S& ToSeparated( S& s, SP separator, AF append ) const
   {
      const_iterator i = m_data->Begin(), j = m_data->End();
      if ( i < j )
      {
         append( s, S( *i ) );
         if ( ++i < j )
         {
            S p( separator );
            do
            {
               append( s, p );
               append( s, S( *i ) );
            }
            while ( ++i < j );
         }
      }
      return s;
   }
 
   template <class S>
   S& ToCommaSeparated( S& s ) const
   {
      return ToSeparated( s, ',' );
   }
 
   template <class S>
   S& ToSpaceSeparated( S& s ) const
   {
      return ToSeparated( s, ' ' );
   }
 
   template <class S>
   S& ToTabSeparated( S& s ) const
   {
      return ToSeparated( s, '\t' );
   }
 
private:
 
   struct Data : public ReferenceCounter
   {
      int        n = 0;       
      component* v = nullptr; 
 
      Data() = default;
 
      Data( int len )
      {
         if ( len > 0 )
            Allocate( len );
      }
 
      ~Data()
      {
         Deallocate();
      }
 
      int Length() const noexcept
      {
         return n;
      }
 
      size_type Size() const noexcept
      {
         return size_type( n )*sizeof( component );
      }
 
      iterator At( int i ) const noexcept
      {
         return v + i;
      }
 
      iterator Begin() const noexcept
      {
//          if ( likely( std::is_scalar<component>::value ) )
//             return reinterpret_cast<iterator>( PCL_ASSUME_ALIGNED_32( v ) );
         return v;
      }
 
      iterator End() const noexcept
      {
         return At( n );
      }
 
      void Allocate( int len )
      {
         n = len;
         if ( likely( std::is_scalar<component>::value ) )
         {
            v = reinterpret_cast<component*>( PCL_ALIGNED_MALLOC( Size(), 32 ) );
            if ( unlikely( v == nullptr ) )
            {
               n = 0;
               throw std::bad_alloc();
            }
         }
         else
            v = new component[ len ];
      }
 
      void Deallocate()
      {
         PCL_PRECONDITION( refCount == 0 )
         if ( likely( std::is_scalar<component>::value ) )
            PCL_ALIGNED_FREE( v );
         else
            delete [] v;
         v = nullptr;
         n = 0;
      }
   };
 
   Data* m_data = nullptr;
 
   void DetachFromData()
   {
      if ( !m_data->Detach() )
         delete m_data;
   }
};
 
// ----------------------------------------------------------------------------
 
template <typename T> inline
GenericVector<T> operator +( const GenericVector<T>& A, const GenericVector<T>& B )
{
   int n = A.Length();
   if ( B.Length() < n )
      throw Error( "Invalid vector addition." );
   GenericVector<T> R( n );
   typename GenericVector<T>::iterator       __restrict__ r = R.Begin();
   typename GenericVector<T>::const_iterator __restrict__ a = A.Begin();
   typename GenericVector<T>::const_iterator __restrict__ c = A.End();
   if ( likely( !A.IsAliasOf( B ) ) )
   {
      typename GenericVector<T>::const_iterator __restrict__ b = B.Begin();
      PCL_IVDEP
      for ( ; a < c; ++a, ++b, ++r )
         *r = *a + *b;
   }
   else
   {
      PCL_IVDEP
      for ( ; a < c; ++a, ++r )
         *r = *a + *a;
   }
   return R;
}
 
template <typename T> inline
GenericVector<T> operator +( GenericVector<T>&& A, const GenericVector<T>& B )
{
   A += B;
   return std::move( A );
}
 
template <typename T> inline
GenericVector<T> operator +( const GenericVector<T>& A, GenericVector<T>&& B )
{
   B += A;
   return std::move( B );
}
 
template <typename T> inline
GenericVector<T> operator +( GenericVector<T>&& A, GenericVector<T>&& B )
{
   A += B;
   return std::move( A );
}
 
template <typename T, typename S> inline
GenericVector<T> operator +( const GenericVector<T>& A, const S& x )
{
   GenericVector<T> R( A.Length() );
   typename GenericVector<T>::iterator       __restrict__ r = R.Begin();
   typename GenericVector<T>::const_iterator __restrict__ a = A.Begin();
   typename GenericVector<T>::const_iterator __restrict__ c = A.End();
   PCL_IVDEP
   for ( ; a < c; ++a, ++r )
      *r = *a + x;
   return R;
}
 
template <typename T, typename S> inline
GenericVector<T> operator +( GenericVector<T>&& A, const S& x )
{
   A += typename GenericVector<T>::scalar( x );
   return std::move( A );
}
 
template <typename T, typename S> inline
GenericVector<T> operator +( const S& x, const GenericVector<T>& A )
{
   return A + x;
}
 
template <typename T, typename S> inline
GenericVector<T> operator +( const S& x, GenericVector<T>&& A )
{
   A += typename GenericVector<T>::scalar( x );
   return std::move( A );
}
 
// ----------------------------------------------------------------------------
 
template <typename T> inline
GenericVector<T> operator -( const GenericVector<T>& A, const GenericVector<T>& B )
{
   int n = A.Length();
   if ( B.Length() < n )
      throw Error( "Invalid vector subtraction." );
 
   GenericVector<T> R( n );
   typename GenericVector<T>::iterator       __restrict__ r = R.Begin();
   typename GenericVector<T>::const_iterator __restrict__ a = A.Begin();
   typename GenericVector<T>::const_iterator __restrict__ c = A.End();
   if ( likely( !A.IsAliasOf( B ) ) )
   {
      typename GenericVector<T>::const_iterator __restrict__ b = B.Begin();
      PCL_IVDEP
      for ( ; a < c; ++a, ++b, ++r )
         *r = *a - *b;
   }
   else
   {
      PCL_IVDEP
      for ( ; a < c; ++a, ++r )
         *r = *a - *a;
   }
   return R;
}
 
template <typename T> inline
GenericVector<T> operator -( GenericVector<T>&& A, const GenericVector<T>& B )
{
   A -= B;
   return std::move( A );
}
 
template <typename T> inline
GenericVector<T> operator -( const GenericVector<T>& A, GenericVector<T>&& B )
{
   if ( A.Length() < B.Length() )
      throw Error( "Invalid vector subtraction." );
 
   typename GenericVector<T>::const_iterator __restrict__ a = A.Begin();
   typename GenericVector<T>::iterator       __restrict__ b = B.Begin();
   typename GenericVector<T>::const_iterator __restrict__ c = B.End();
   PCL_IVDEP
   for ( ; b < c; ++a, ++b )
      *b = *a - *b;
   return std::move( B );
}
 
template <typename T> inline
GenericVector<T> operator -( GenericVector<T>&& A, GenericVector<T>&& B )
{
   A -= B;
   return std::move( A );
}
 
template <typename T, typename S> inline
GenericVector<T> operator -( const GenericVector<T>& A, const S& x )
{
   GenericVector<T> R( A.Length() );
   typename GenericVector<T>::iterator       __restrict__ r = R.Begin();
   typename GenericVector<T>::const_iterator __restrict__ a = A.Begin();
   typename GenericVector<T>::const_iterator __restrict__ c = A.End();
   PCL_IVDEP
   for ( ; a < c; ++a, ++r )
      *r = *a - x;
   return R;
}
 
template <typename T, typename S> inline
GenericVector<T> operator -( GenericVector<T>&& A, const S& x )
{
   A -= typename GenericVector<T>::scalar( x );
   return std::move( A );
}
 
template <typename T, typename S> inline
GenericVector<T> operator -( const S& x, const GenericVector<T>& A )
{
   GenericVector<T> R( A.Length() );
   typename GenericVector<T>::iterator       __restrict__ r = R.Begin();
   typename GenericVector<T>::const_iterator __restrict__ a = A.Begin();
   typename GenericVector<T>::const_iterator __restrict__ c = A.End();
   PCL_IVDEP
   for ( ; a < c; ++a, ++r )
      *r = x - *a;
   return R;
}
 
template <typename T, typename S> inline
GenericVector<T> operator -( const S& x, GenericVector<T>&& A )
{
   typename GenericVector<T>::iterator       __restrict__ a = A.Begin();
   typename GenericVector<T>::const_iterator __restrict__ c = A.End();
   PCL_IVDEP
   for ( ; a < c; ++a )
      *a = x - *a;
   return std::move( A );
}
 
// ----------------------------------------------------------------------------
 
template <typename T> inline
GenericVector<T> operator ^( const GenericVector<T>& A, const GenericVector<T>& B )
{
   PCL_PRECONDITION( A.Length() == 3 && B.Length() == 3 )
   return GenericVector<T>( A[1]*B[2] - A[2]*B[1],
                            A[2]*B[0] - A[0]*B[2],
                            A[0]*B[1] - A[1]*B[0] );
}
 
template <typename T> inline
GenericVector<T> operator ^( GenericVector<T>&& A, const GenericVector<T>& B )
{
   T x = A[1]*B[2] - A[2]*B[1],
     y = A[2]*B[0] - A[0]*B[2],
     z = A[0]*B[1] - A[1]*B[0];
   typename GenericVector<T>::iterator a = A.Begin();
   a[0] = x; a[1] = y; a[2] = z;
   return std::move( A );
}
 
template <typename T> inline
GenericVector<T> operator ^( const GenericVector<T>& A, GenericVector<T>&& B )
{
   T x = A[1]*B[2] - A[2]*B[1],
     y = A[2]*B[0] - A[0]*B[2],
     z = A[0]*B[1] - A[1]*B[0];
   typename GenericVector<T>::iterator b = B.Begin();
   b[0] = x; b[1] = y; b[2] = z;
   return std::move( B );
}
 
template <typename T> inline
GenericVector<T> operator ^( GenericVector<T>&& A, GenericVector<T>&& B )
{
   T x = A[1]*B[2] - A[2]*B[1],
     y = A[2]*B[0] - A[0]*B[2],
     z = A[0]*B[1] - A[1]*B[0];
   typename GenericVector<T>::iterator a = A.Begin();
   a[0] = x; a[1] = y; a[2] = z;
   return std::move( A );
}
 
// ----------------------------------------------------------------------------
 
template <typename T> inline
T operator *( const GenericVector<T>& A, const GenericVector<T>& B ) noexcept
{
   PCL_PRECONDITION( B.Length() >= A.Length() )
   typename GenericVector<T>::const_iterator __restrict__ a = A.Begin();
   typename GenericVector<T>::const_iterator __restrict__ c = A.End();
   T r = T( 0 );
   if ( likely( !A.IsAliasOf( B ) ) )
   {
      typename GenericVector<T>::const_iterator __restrict__ b = B.Begin();
      PCL_IVDEP
      for ( ; a < c; ++a, ++b )
         r += *a * *b;
   }
   else
   {
      PCL_IVDEP
      for ( ; a < c; ++a )
         r += *a * *a;
   }
   return r;
}
 
// ----------------------------------------------------------------------------
 
template <typename T, typename S> inline
GenericVector<T> operator *( const GenericVector<T>& A, const S& x )
{
   GenericVector<T> R( A.Length() );
   typename GenericVector<T>::iterator       __restrict__ r = R.Begin();
   typename GenericVector<T>::const_iterator __restrict__ a = A.Begin();
   typename GenericVector<T>::const_iterator __restrict__ c = A.End();
   PCL_IVDEP
   for ( ; a < c; ++a, ++r )
      *r = *a * x;
   return R;
}
 
template <typename T, typename S> inline
GenericVector<T> operator *( GenericVector<T>&& A, const S& x )
{
   A *= typename GenericVector<T>::scalar( x );
   return std::move( A );
}
 
template <typename T, typename S> inline
GenericVector<T> operator *( const S& x, const GenericVector<T>& A )
{
   return A * x;
}
 
template <typename T, typename S> inline
GenericVector<T> operator *( const S& x, GenericVector<T>&& A )
{
   A *= typename GenericVector<T>::scalar( x );
   return std::move( A );
}
 
// ----------------------------------------------------------------------------
 
template <typename T, typename S> inline
GenericVector<T> operator /( const GenericVector<T>& A, const S& x )
{
   GenericVector<T> R( A.Length() );
   typename GenericVector<T>::iterator       __restrict__ r = R.Begin();
   typename GenericVector<T>::const_iterator __restrict__ a = A.Begin();
   typename GenericVector<T>::const_iterator __restrict__ c = A.End();
   PCL_IVDEP
   for ( ; a < c; ++a, ++r )
      *r = *a / x;
   return R;
}
 
template <typename T, typename S> inline
GenericVector<T> operator /( GenericVector<T>&& A, const S& x )
{
   A /= typename GenericVector<T>::scalar( x );
   return std::move( A );
}
 
template <typename T, typename S> inline
GenericVector<T> operator /( const S& x, const GenericVector<T>& A )
{
   GenericVector<T> R( A.Length() );
   typename GenericVector<T>::iterator       __restrict__ r = R.Begin();
   typename GenericVector<T>::const_iterator __restrict__ a = A.Begin();
   typename GenericVector<T>::const_iterator __restrict__ c = A.End();
   PCL_IVDEP
   for ( ; a < c; ++a, ++r )
      *r = x / *a;
   return R;
}
 
template <typename T, typename S> inline
GenericVector<T> operator /( const S& x, GenericVector<T>&& A )
{
   typename GenericVector<T>::iterator       __restrict__ a = A.Begin();
   typename GenericVector<T>::const_iterator __restrict__ c = A.End();
   PCL_IVDEP
   for ( ; a < c; ++a )
      *a = x / *a;
   return std::move( A );
}
 
template <typename T> inline
GenericVector<T> operator /( const GenericVector<T>& A, const GenericVector<T>& B )
{
   int n = A.Length();
   if ( B.Length() < n )
      throw Error( "Invalid vector division." );
 
   GenericVector<T> R( n );
   typename GenericVector<T>::iterator       __restrict__ r = R.Begin();
   typename GenericVector<T>::const_iterator __restrict__ a = A.Begin();
   typename GenericVector<T>::const_iterator __restrict__ c = A.End();
   if ( likely( !A.IsAliasOf( B ) ) )
   {
      typename GenericVector<T>::const_iterator __restrict__ b = B.Begin();
      PCL_IVDEP
      for ( ; a < c; ++a, ++b, ++r )
         *r = *a / *b;
   }
   else
   {
      PCL_IVDEP
      for ( ; a < c; ++a, ++r )
         *r = *a / *a;
   }
   return R;
}
 
template <typename T> inline
GenericVector<T> operator /( GenericVector<T>&& A, const GenericVector<T>& B )
{
   return A /= B;
}
 
// ----------------------------------------------------------------------------
 
template <typename T, typename S> inline
GenericVector<T> operator ^( const GenericVector<T>& A, const S& x )
{
   GenericVector<T> R( A.Length() );
   typename GenericVector<T>::iterator       __restrict__ r = R.Begin();
   typename GenericVector<T>::const_iterator __restrict__ a = A.Begin();
   typename GenericVector<T>::const_iterator __restrict__ c = A.End();
   PCL_IVDEP
   for ( ; a < c; ++a, ++r )
      *r = pcl::Pow( *a, x );
   return R;
}
 
template <typename T, typename S> inline
GenericVector<T> operator ^( GenericVector<T>&& A, const S& x )
{
   A ^= typename GenericVector<T>::scalar( x );
   return std::move( A );
}
 
template <typename T, typename S> inline
GenericVector<T> operator ^( const S& x, const GenericVector<T>& A )
{
   GenericVector<T> R( A.Length() );
   typename GenericVector<T>::iterator       __restrict__ r = R.Begin();
   typename GenericVector<T>::const_iterator __restrict__ a = A.Begin();
   typename GenericVector<T>::const_iterator __restrict__ c = A.End();
   PCL_IVDEP
   for ( ; a < c; ++a, ++r )
      *r = pcl::Pow( x, *a );
   return R;
}
 
template <typename T, typename S> inline
GenericVector<T> operator ^( const S& x, GenericVector<T>&& A )
{
   typename GenericVector<T>::iterator       __restrict__ a = A.Begin();
   typename GenericVector<T>::const_iterator __restrict__ c = A.End();
   PCL_IVDEP
   for ( ; a < c; ++a )
      *a = pcl::Pow( x, *a );
   return std::move( A );
}
 
// ----------------------------------------------------------------------------
 
#ifndef __PCL_NO_VECTOR_INSTANTIATE
 
using I8Vector = GenericVector<int8>;
 
using CharVector = I8Vector;
 
using UI8Vector = GenericVector<uint8>;
 
using ByteVector = UI8Vector;
 
using I16Vector = GenericVector<int16>;
 
using UI16Vector = GenericVector<uint16>;
 
using I32Vector = GenericVector<int32>;
 
using IVector = I32Vector;
 
using UI32Vector = GenericVector<uint32>;
 
using UIVector = UI32Vector;
 
using I64Vector = GenericVector<int64>;
 
using UI64Vector = GenericVector<uint64>;
 
using SzVector = GenericVector<size_type>;
 
using F32Vector = GenericVector<float>;
 
using FVector = F32Vector;
 
using F64Vector = GenericVector<double>;
 
using DVector = F64Vector;
 
using Vector = DVector;
 
using C32Vector = GenericVector<Complex32>;
 
using C64Vector = GenericVector<Complex64>;
 
#ifndef _MSC_VER
 
using F80Vector = GenericVector<long double>;
 
using LDVector = F80Vector;
 
#endif   // !_MSC_VER
 
#endif   // !__PCL_NO_VECTOR_INSTANTIATE
 
// ----------------------------------------------------------------------------
 
} // pcl
 
#endif   // __PCL_Vector_h
 
// ----------------------------------------------------------------------------
// EOF pcl/Vector.h - Released 2024-05-07T15:27:32Z