ROOT_528-00b_version: include/TArrayD.h Source File

00001 // @(#)root/cont:$Id: TArrayD.h 20882 2007-11-19 11:31:26Z rdm $
00002 // Author: Rene Brun   06/03/95
00003 
00004 /*************************************************************************
00005  * Copyright (C) 1995-2000, Rene Brun and Fons Rademakers.               *
00006  * All rights reserved.                                                  *
00007  *                                                                       *
00008  * For the licensing terms see $ROOTSYS/LICENSE.                         *
00009  * For the list of contributors see $ROOTSYS/README/CREDITS.             *
00010  *************************************************************************/
00011 
00012 #ifndef ROOT_TArrayD
00013 #define ROOT_TArrayD
00014 
00015 
00016 //////////////////////////////////////////////////////////////////////////
00017 //                                                                      //
00018 // TArrayD                                                              //
00019 //                                                                      //
00020 // Array of doubles (64 bits per element).                              //
00021 //                                                                      //
00022 //////////////////////////////////////////////////////////////////////////
00023 
00024 #ifndef ROOT_TArray
00025 #include "TArray.h"
00026 #endif
00027 
00028 
00029 class TArrayD : public TArray {
00030 
00031 public:
00032    Double_t    *fArray;       //[fN] Array of fN doubles
00033 
00034    TArrayD();
00035    TArrayD(Int_t n);
00036    TArrayD(Int_t n, const Double_t *array);
00037    TArrayD(const TArrayD &array);
00038    TArrayD    &operator=(const TArrayD &rhs);
00039    virtual    ~TArrayD();
00040 
00041    void            Adopt(Int_t n, Double_t *array);
00042    void            AddAt(Double_t c, Int_t i);
00043    Double_t        At(Int_t i) const ;
00044    void            Copy(TArrayD &array) const {array.Set(fN,fArray);}
00045    const Double_t *GetArray() const { return fArray; }
00046    Double_t       *GetArray() { return fArray; }
00047    Double_t        GetAt(Int_t i) const { return At(i); }
00048    Stat_t          GetSum() const {Stat_t sum=0; for (Int_t i=0;i<fN;i++) sum+=fArray[i]; return sum;}
00049    void            Reset()             {memset(fArray, 0, fN*sizeof(Double_t));}
00050    void            Reset(Double_t val) {for (Int_t i=0;i<fN;i++) fArray[i] = val;}
00051    void            Set(Int_t n);
00052    void            Set(Int_t n, const Double_t *array);
00053    void            SetAt(Double_t v, Int_t i) { AddAt(v, i); }
00054    Double_t       &operator[](Int_t i);
00055    Double_t        operator[](Int_t i) const;
00056 
00057    ClassDef(TArrayD,1)  //Array of doubles
00058 };
00059 
00060 
00061 #if defined R__TEMPLATE_OVERLOAD_BUG
00062 template <>
00063 #endif
00064 inline TBuffer &operator>>(TBuffer &buf, TArrayD *&obj)
00065 {
00066    // Read TArrayD object from buffer.
00067 
00068    obj = (TArrayD *) TArray::ReadArray(buf, TArrayD::Class());
00069    return buf;
00070 }
00071 
00072 #if defined R__TEMPLATE_OVERLOAD_BUG
00073 template <>
00074 #endif
00075 inline TBuffer &operator<<(TBuffer &buf, const TArrayD *obj)
00076 {
00077    // Write a TArrayD object into buffer
00078    return buf << (TArray*)obj;
00079 }
00080 
00081 inline Double_t TArrayD::At(Int_t i) const
00082 {
00083    if (!BoundsOk("TArrayD::At", i)) return 0;
00084    return fArray[i];
00085 }
00086 
00087 inline Double_t &TArrayD::operator[](Int_t i)
00088 {
00089    if (!BoundsOk("TArrayD::operator[]", i))
00090       i = 0;
00091    return fArray[i];
00092 }
00093 
00094 inline Double_t TArrayD::operator[](Int_t i) const
00095 {
00096    if (!BoundsOk("TArrayD::operator[]", i)) return 0;
00097    return fArray[i];
00098 }
00099 
00100 #endif