SVector.h File Reference

#include <utl/AugerException.h>
#include <utl/ErrorLogger.h>
#include <utl/ListAssignmentProxy.h>
#include <utl/IteratorRange.h>
#include <boost/lambda/lambda.hpp>
#include <cstddef>
#include <cmath>
#include <iostream>
#include <sstream>
#include <utl/SMatrixSVectorOp.h>

Go to the source code of this file.

Classes
class	boost::lambda::plain_return_type_2< arithmetic_action< minus_action >, utl::SVector< n, T >, utl::SVector< n, U > >
class	boost::lambda::plain_return_type_2< arithmetic_action< multiply_action >, utl::SVector< n, T >, utl::SVector< n, U > >
	specialization for custom class SVector<> More...
class	boost::lambda::plain_return_type_2< arithmetic_action< plus_action >, utl::SVector< n, T >, utl::SVector< n, U > >
class	utl::SVector< n, T >
	Static (small and dense) vector class. More...

Namespaces
	boost
	boost::lambda
	utl

Macros
#define	UTL_SVECTOR_ARITHMETIC_ACTION(ACTION, OPERATOR)
#define	UTL_SVECTOR_BINARY_RETURN_TYPE_SPECIALIZATION(ACTION)

Functions
template<typename T , typename U >
double	utl::Angle (SVector< 3, T > left, SVector< 3, U > right)
template<typename T , typename U >
double	utl::CosAngle (const SVector< 3, T > &l, const SVector< 3, U > &r)
template<typename T , typename U >
SVector< 3, typename boost::lambda::return_type_2 < boost::lambda::arithmetic_action < boost::lambda::multiply_action > , T, U >::type >	utl::Cross (const SVector< 3, T > &a, const SVector< 3, U > &b)
template<std::size_t n, typename T , typename U >
boost::lambda::return_type_2 < boost::lambda::arithmetic_action < boost::lambda::multiply_action > , SVector< n, T >, SVector< n, U > >::type	utl::operator* (const SVector< n, T > &a, const SVector< n, U > &b)
	dot product More...
template<std::size_t n, typename T , typename U >
boost::lambda::return_type_2 < boost::lambda::arithmetic_action < boost::lambda::plus_action > , SVector< n, T >, SVector< n, U > >::type	utl::operator+ (const SVector< n, T > &a, const SVector< n, U > &b)
template<std::size_t n, typename T , typename U >
boost::lambda::return_type_2 < boost::lambda::arithmetic_action < boost::lambda::minus_action > , SVector< n, T >, SVector< n, U > >::type	utl::operator- (const SVector< n, T > &a, const SVector< n, U > &b)
template<std::size_t n, typename T >
std::ostream &	utl::operator<< (std::ostream &os, const SVector< n, T > &v)
template<std::size_t n, typename T >
std::istream &	utl::operator>> (std::istream &is, SVector< n, T > &v)

Macro Definition Documentation

#define UTL_SVECTOR_ARITHMETIC_ACTION	(		ACTION,
			OPERATOR
	)

Value:

template<std::size_t n, typename T, typename U>                    \
  inline                                                             \
  typename boost::lambda::return_type_2<                             \
    boost::lambda::arithmetic_action<boost::lambda::ACTION>,         \
    SVector<n, T>,                                                   \
    SVector<n, U>                                                    \
  >::type                                                            \
  operator OPERATOR(const SVector<n, T>& a, const SVector<n, U>& b)  \
  {                                                                  \
    typedef typename boost::lambda::return_type_2<                   \
      boost::lambda::arithmetic_action<boost::lambda::ACTION>, T, U  \
    >::type ActionType;                                              \
                                                                     \
    SVector<n, ActionType> r;                                        \
                                                                     \
    for (std::size_t i = 0; i < n; ++i)                              \
      r[i] = a[i] OPERATOR b[i];                                     \
                                                                     \
    return r;                                                        \
  }

Definition at line 304 of file SVector.h.

#define UTL_SVECTOR_BINARY_RETURN_TYPE_SPECIALIZATION

(

ACTION

)

Value:

template<std::size_t n, typename T, typename U>           \
    class plain_return_type_2<                                \
      arithmetic_action<ACTION>,                              \
      utl::SVector<n, T>,                                     \
      utl::SVector<n, U>                                      \
    > {                                                       \
    private:                                                  \
      typedef typename                                        \
        return_type_2<                                        \
          arithmetic_action<ACTION>, T, U                     \
        >::type res_type;                                     \
                                                              \
    public:                                                   \
      typedef utl::SVector<n, res_type> type;                 \
    }

Definition at line 380 of file SVector.h.