Logo ROOT  
Reference Guide
TArrayD.cxx
Go to the documentation of this file.
1 // @(#)root/cont:$Id$
2 // Author: Rene Brun 06/03/95
3 
4 /*************************************************************************
5  * Copyright (C) 1995-2000, Rene Brun and Fons Rademakers. *
6  * All rights reserved. *
7  * *
8  * For the licensing terms see $ROOTSYS/LICENSE. *
9  * For the list of contributors see $ROOTSYS/README/CREDITS. *
10  *************************************************************************/
11 
12 /** \class TArrayD
13 \ingroup Containers
14 Array of doubles (64 bits per element).
15 */
16 
17 #include "TArrayD.h"
18 #include "TBuffer.h"
19 
20 
22 
23 ////////////////////////////////////////////////////////////////////////////////
24 /// Default TArrayD ctor.
25 
27 {
28  fArray = nullptr;
29 }
30 
31 ////////////////////////////////////////////////////////////////////////////////
32 /// Create TArrayD object and set array size to n doubles.
33 
35 {
36  fArray = nullptr;
37  if (n > 0) Set(n);
38 }
39 
40 ////////////////////////////////////////////////////////////////////////////////
41 /// Create TArrayD object and initialize it with values of array.
42 
44 {
45  fArray = nullptr;
46  Set(n, array);
47 }
48 
49 ////////////////////////////////////////////////////////////////////////////////
50 /// Copy constructor.
51 
52 TArrayD::TArrayD(const TArrayD &array) : TArray(array)
53 {
54  fArray = nullptr;
55  Set(array.fN, array.fArray);
56 }
57 
58 ////////////////////////////////////////////////////////////////////////////////
59 /// TArrayD assignment operator.
60 
62 {
63  if (this != &rhs)
64  Set(rhs.fN, rhs.fArray);
65  return *this;
66 }
67 
68 ////////////////////////////////////////////////////////////////////////////////
69 /// Delete TArrayD object.
70 
72 {
73  delete [] fArray;
74  fArray = nullptr;
75 }
76 
77 ////////////////////////////////////////////////////////////////////////////////
78 /// Adopt array arr into TArrayD, i.e. don't copy arr but use it directly
79 /// in TArrayD. User may not delete arr, TArrayD dtor will do it.
80 
82 {
83  if (fArray)
84  delete [] fArray;
85 
86  fN = n;
87  fArray = arr;
88 }
89 
90 ////////////////////////////////////////////////////////////////////////////////
91 /// Set the double c value at position i in the array. Check for out of bounds.
92 /// Warning: the name of the method is misleading, it actually overwrites the position i.
93 
95 {
96  if (!BoundsOk("TArrayD::AddAt", i)) return;
97  fArray[i] = c;
98 }
99 
100 ////////////////////////////////////////////////////////////////////////////////
101 /// Set size of this array to n doubles.
102 /// A new array is created, the old contents copied to the new array,
103 /// then the old array is deleted.
104 /// This function should not be called if the array was declared via Adopt.
105 
107 {
108  if (n < 0) return;
109  if (n != fN) {
110  Double_t *temp = fArray;
111  if (n != 0) {
112  fArray = new Double_t[n];
113  if (n < fN) {
114  memcpy(fArray, temp, n*sizeof(Double_t));
115  } else if (temp) {
116  memcpy(fArray, temp, fN*sizeof(Double_t));
117  memset(&fArray[fN], 0, (n-fN)*sizeof(Double_t));
118  } else {
119  memset(fArray, 0, n*sizeof(Double_t));
120  }
121  } else {
122  fArray = nullptr;
123  }
124  if (fN) delete [] temp;
125  fN = n;
126  }
127 }
128 
129 ////////////////////////////////////////////////////////////////////////////////
130 /// Set size of this array to n doubles and set the contents
131 /// This function should not be called if the array was declared via Adopt.
132 
133 void TArrayD::Set(Int_t n, const Double_t *array)
134 {
135  if (fArray && fN != n) {
136  delete [] fArray;
137  fArray = nullptr;
138  }
139  fN = n;
140  if ((fN == 0) || !array)
141  return;
142  if (!fArray) fArray = new Double_t[fN];
143  memmove(fArray, array, n*sizeof(Double_t));
144 }
145 
146 ////////////////////////////////////////////////////////////////////////////////
147 /// Stream a TArrayD object.
148 
149 void TArrayD::Streamer(TBuffer &b)
150 {
151  if (b.IsReading()) {
152  Int_t n;
153  b >> n;
154  Set(n);
155  b.ReadFastArray(fArray,n);
156  } else {
157  b << fN;
158  b.WriteFastArray(fArray, fN);
159  }
160 }
161 
c
#define c(i)
Definition: RSha256.hxx:101
n
const Int_t n
Definition: legend1.C:16
ClassImp
#define ClassImp(name)
Definition: Rtypes.h:364
Int_t
int Int_t
Definition: RtypesCore.h:45
TArrayD::TArrayD
TArrayD()
Default TArrayD ctor.
Definition: TArrayD.cxx:26
TBuffer
Buffer base class used for serializing objects.
Definition: TBuffer.h:43
TArray::fN
Int_t fN
Definition: TArray.h:38
b
#define b(i)
Definition: RSha256.hxx:100
TArrayD::AddAt
void AddAt(Double_t c, Int_t i)
Set the double c value at position i in the array.
Definition: TArrayD.cxx:94
TArrayD.h
TBuffer.h
TArrayD::Set
void Set(Int_t n)
Set size of this array to n doubles.
Definition: TArrayD.cxx:106
TArrayD::~TArrayD
virtual ~TArrayD()
Delete TArrayD object.
Definition: TArrayD.cxx:71
TArrayD::fArray
Double_t * fArray
Definition: TArrayD.h:30
Double_t
double Double_t
Definition: RtypesCore.h:59
TArray
Abstract array base class.
Definition: TArray.h:31
TArray::BoundsOk
Bool_t BoundsOk(const char *where, Int_t at) const
Definition: TArray.h:77
TArrayD::Adopt
void Adopt(Int_t n, Double_t *array)
Adopt array arr into TArrayD, i.e.
Definition: TArrayD.cxx:81
TArrayD
Array of doubles (64 bits per element).
Definition: TArrayD.h:27
TArrayD::operator=
TArrayD & operator=(const TArrayD &rhs)
TArrayD assignment operator.
Definition: TArrayD.cxx:61
int