TArrayD.h Source File

00001 // @(#)root/cont:$Name:  $:$Id: TArrayD.h,v 1.14 2002/10/30 20:39:50 brun Exp $
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 
00017 //                                                                      //
00018 // TArrayD                                                              //
00019 //                                                                      //
00020 // Array of doubles (64 bits per element).                              //
00021 //                                                                      //
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); for (Int_t i=0;i<fN;i++) array.fArray[i] = fArray[i];}
00045    const Double_t *GetArray() const { return fArray; }
00046    Double_t       *GetArray() { return fArray; }
00047    Stat_t          GetSum() const {Stat_t sum=0; for (Int_t i=0;i<fN;i++) sum+=fArray[i]; return sum;}
00048    void            Reset()             {memset(fArray, 0, fN*sizeof(Double_t));}
00049    void            Reset(Double_t val) {for (Int_t i=0;i<fN;i++) fArray[i] = val;}
00050    void            Set(Int_t n);
00051    void            Set(Int_t n, const Double_t *array);
00052    Double_t       &operator[](Int_t i);
00053    Double_t        operator[](Int_t i) const;
00054 
00055    ClassDef(TArrayD,1)  //Array of doubles
00056 };
00057 
00058 
00059 #if defined R__TEMPLATE_OVERLOAD_BUG
00060 template <>
00061 #endif
00062 inline TBuffer &operator>>(TBuffer &buf, TArrayD *&obj)
00063 {
00064    // Read TArrayD object from buffer.
00065 
00066    obj = (TArrayD *) TArray::ReadArray(buf, TArrayD::Class());
00067    return buf;
00068 }
00069 
00070 #if defined R__TEMPLATE_OVERLOAD_BUG
00071 template <>
00072 #endif
00073 inline TBuffer &operator<<(TBuffer &buf, const TArrayD *obj)
00074 {
00075    // Write a TArrayD object into buffer
00076    return buf << (TArray*)obj;
00077 }
00078 
00079 inline Double_t TArrayD::At(Int_t i) const
00080 {
00081    if (!BoundsOk("TArrayD::At", i)) return 0;
00082    return fArray[i];
00083 }
00084 
00085 inline Double_t &TArrayD::operator[](Int_t i)
00086 {
00087    if (!BoundsOk("TArrayD::operator[]", i))
00088       i = 0;
00089    return fArray[i];
00090 }
00091 
00092 inline Double_t TArrayD::operator[](Int_t i) const
00093 {
00094    if (!BoundsOk("TArrayD::operator[]", i)) return 0;
00095    return fArray[i];
00096 }
00097 
00098 #endif