library: libSmatrix
#include "SVector.h"

ROOT::Math::SVector<float,4>

class description - header file - source file - inheritance tree (.pdf)

class ROOT::Math::SVector<float,4>

Inheritance Chart:
ROOT::Math::SVector<float,4>
 

    public:

                                                   SVector<float,4>()
                                                   SVector<float,4>(const ROOT::Math::SVector<float,4>& rhs)
                                                   SVector<float,4>(const float* a, unsigned int len)
                                                   SVector<float,4>(ROOT::Math::SVector<float,4>::const_iterator begin, ROOT::Math::SVector<float,4>::const_iterator end)
                                                   SVector<float,4>(const float& a1)
                                                   SVector<float,4>(const float& a1, const float& a2)
                                                   SVector<float,4>(const float& a1, const float& a2, const float& a3)
                                                   SVector<float,4>(const float& a1, const float& a2, const float& a3, const float& a4)
                                                   SVector<float,4>(const float& a1, const float& a2, const float& a3, const float& a4, const float& a5)
                                                   SVector<float,4>(const float& a1, const float& a2, const float& a3, const float& a4, const float& a5, const float& a6)
                                                   SVector<float,4>(const float& a1, const float& a2, const float& a3, const float& a4, const float& a5, const float& a6, const float& a7)
                                                   SVector<float,4>(const float& a1, const float& a2, const float& a3, const float& a4, const float& a5, const float& a6, const float& a7, const float& a8)
                                                   SVector<float,4>(const float& a1, const float& a2, const float& a3, const float& a4, const float& a5, const float& a6, const float& a7, const float& a8, const float& a9)
                                                   SVector<float,4>(const float& a1, const float& a2, const float& a3, const float& a4, const float& a5, const float& a6, const float& a7, const float& a8, const float& a9, const float& a10)
                                                   ~SVector<float,4>()
                                             float apply(unsigned int i) const
                                      const float* Array() const
                                            float* Array()
            ROOT::Math::SVector<float,4>::iterator begin()
      ROOT::Math::SVector<float,4>::const_iterator begin() const
                               static unsigned int Dim()
            ROOT::Math::SVector<float,4>::iterator end()
      ROOT::Math::SVector<float,4>::const_iterator end() const
                                              bool operator!=(const float& rhs) const
                                              bool operator!=(const ROOT::Math::SVector<float,4>& rhs) const
                                      const float& operator()(unsigned int i) const
                                            float& operator()(unsigned int i)
                     ROOT::Math::SVector<float,4>& operator*=(const float& rhs)
                     ROOT::Math::SVector<float,4>& operator+=(const float& rhs)
                     ROOT::Math::SVector<float,4>& operator+=(const ROOT::Math::SVector<float,4>& rhs)
                     ROOT::Math::SVector<float,4>& operator-=(const float& rhs)
                     ROOT::Math::SVector<float,4>& operator-=(const ROOT::Math::SVector<float,4>& rhs)
                     ROOT::Math::SVector<float,4>& operator/=(const float& rhs)
                                              bool operator<(const float& rhs) const
                                              bool operator<(const ROOT::Math::SVector<float,4>& rhs) const
                     ROOT::Math::SVector<float,4>& operator=(const float& a1)
                     ROOT::Math::SVector<float,4>& operator=(const ROOT::Math::SVector<float,4>&)
                                              bool operator==(const float& rhs) const
                                              bool operator==(const ROOT::Math::SVector<float,4>& rhs) const
                                              bool operator>(const float& rhs) const
                                              bool operator>(const ROOT::Math::SVector<float,4>& rhs) const
                                      const float& operator[](unsigned int i) const
                                            float& operator[](unsigned int i)
                                          ostream& Print(ostream& os) const
                     ROOT::Math::SVector<float,4>& Unit()

Data Members

    private:

      float fArray[4]  

    public:

      static const enum ROOT::Math::SVector<float,4>:: kSize

Class Description

SVector<T,D>& operator=(const T& a1)
/ assignment from a scalar (for size 1 vector)
SVector<T,D>& operator=(const VecExpr<A,T,D>& rhs)


unsigned int Dim()


/ return dimension $D$



T apply(unsigned int i)


/ access the parse tree. Index starts from zero



const T* Array()


/ return read-only pointer to internal array



T* Array()


/ return non-const pointer to internal array



iterator begin()




iterator end()




const_iterator begin()




const_iterator end()




bool operator==(const T& rhs)


/ element wise comparison



bool operator!=(const T& rhs)


/ element wise comparison



bool operator==(const SVector<T,D>& rhs)


/ element wise comparison



bool operator!=(const SVector<T,D>& rhs)


/ element wise comparison



bool operator>(const T& rhs)


/ element wise comparison



bool operator<(const T& rhs)


/ element wise comparison



bool operator>(const SVector<T,D>& rhs)


/ element wise comparison



bool operator<(const SVector<T,D>& rhs)


/ element wise comparison



const T& operator[](unsigned int i)


/ read-only access of vector elements. Index starts from 0.



const T& operator()(unsigned int i)


/ read-only access of vector elements. Index starts from 0.



T& operator[](unsigned int i)


/ read/write access of vector elements. Index starts from 0.



T& operator()(unsigned int i)


/ read/write access of vector elements. Index starts from 0.



SVector<T,D>& operator+=(const T& rhs)


/ self addition with a scalar



SVector<T,D>& operator-=(const T& rhs)


/ self subtraction with a scalar



SVector<T,D>& operator*=(const T& rhs)


/ self multiplication with a scalar



SVector<T,D>& operator/=(const T& rhs)


/ self division with a scalar



SVector<T,D>& operator+=(const SVector<T,D>& rhs)


/ self addition with another vector



SVector<T,D>& operator-=(const SVector<T,D>& rhs)


/ self subtraction with another vector



SVector<T,D>& Unit()


/ transform vector into a vector of lenght 1



std::ostream& Print(std::ostream& os)


/ used by operator<<()






Last update: Tue Jul 11 11:47:23 2006









ROOT page - Class index - Class Hierarchy - Top of the page









This page has been automatically generated. If you have any comments or suggestions about the page layout send a mail to ROOT support, or contact the developers with any questions or problems regarding ROOT.