Scippy

SoPlex

Sequential object-oriented simPlex

dvectorbase.h
Go to the documentation of this file.
1 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
2 /* */
3 /* This file is part of the class library */
4 /* SoPlex --- the Sequential object-oriented simPlex. */
5 /* */
6 /* Copyright (C) 1996-2017 Konrad-Zuse-Zentrum */
7 /* fuer Informationstechnik Berlin */
8 /* */
9 /* SoPlex is distributed under the terms of the ZIB Academic Licence. */
10 /* */
11 /* You should have received a copy of the ZIB Academic License */
12 /* along with SoPlex; see the file COPYING. If not email to soplex@zib.de. */
13 /* */
14 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
15 
16 /**@file dvectorbase.h
17  * @brief Dynamic dense vectors.
18  */
19 #ifndef _DVECTORBASE_H_
20 #define _DVECTORBASE_H_
21 
22 #include <iostream>
23 #include <assert.h>
24 
25 #include "spxdefines.h"
26 #include "spxalloc.h"
27 #include "vectorbase.h"
28 
29 namespace soplex
30 {
31 template < class R > class SVectorBase;
32 
33 /**@brief Dynamic dense vectors.
34  * @ingroup Algebra
35  *
36  * Class DVectorBase is a derived class of VectorBase adding automatic memory management to such objects. This allows
37  * to implement maths operations operator+() and operator-(). Further, it is possible to reset the dimension of a
38  * DVectorBase via method reDim(). However, this may render all references to values of a #reDim()%ed DVectorBase
39  * invalid.
40  *
41  * For vectors that are often subject to reDim() it may be unconvenient to reallocate the required memory every time.
42  * Instead, an array of values of length memSize() is kept, where only the first dim() elements are used. Initially,
43  * memSize() == dim(). However, if the dimension is increased, memSize() will be increased at least by a factor of 1.2
44  * to be prepared for future (small) #reDim()%s. Finally, one can explicitly set memSize() with method reSize(), but
45  * not lower than dim().
46  */
47 template < class R >
48 class DVectorBase : public VectorBase<R>
49 {
50  template < class S > friend class DVectorBase;
51 
52 private:
53 
54  // ------------------------------------------------------------------------------------------------------------------
55  /**@name Data */
56  //@{
57 
58  /// Length of array of values \ref soplex::DVectorBase::mem "mem"
59  int memsize;
60 
61  /// Array of values.
62  R* mem;
63 
64  //@}
65 
66 public:
67 
68  // ------------------------------------------------------------------------------------------------------------------
69  /**@name Construction, destruction, and assignment */
70  //@{
71 
72  /// Default constructor. \p d is the initial dimension.
73  explicit DVectorBase<R>(int d = 0)
74  : VectorBase<R>(0, 0)
75  , mem(0)
76  {
77  memsize = (d > 0) ? d : 4;
78 
79  spx_alloc(mem, memsize);
80  for( int i = 0; i < memsize; i++ )
81  new (&(mem[i])) R();
82 
85 
86  assert(isConsistent());
87  }
88 
89  /// Copy constructor.
90  template < class S >
91  explicit DVectorBase<R>(const VectorBase<S>& old)
92  : VectorBase<R>(0, 0)
93  , mem(0)
94  {
95  VectorBase<R>::dimen = old.dim();
96  memsize = VectorBase<R>::dimen;
97 
98  spx_alloc(mem, memsize);
99 
100  for( int i = 0; i < VectorBase<R>::dimen; i++ )
101  new (&(mem[i])) R(old[i]);
102  for( int i = VectorBase<R>::dimen; i < memsize; i++ )
103  new (&(mem[i])) R();
104 
106 
107  assert(isConsistent());
108  }
109 
110  /// Copy constructor.
111  /** The redundancy with the copy constructor below is necessary since otherwise the compiler doesn't realize that it
112  * could use the more general one with S = R and generates a shallow copy constructor.
113  */
115  : VectorBase<R>(0, 0)
116  , mem(0)
117  {
118  VectorBase<R>::dimen = old.dim();
119  memsize = old.memsize;
120 
121  spx_alloc(mem, memsize);
122 
123  for( int i = 0; i < VectorBase<R>::dimen; i++ )
124  new (&(mem[i])) R(old[i]);
125  for( int i = VectorBase<R>::dimen; i < memsize; i++ )
126  new (&(mem[i])) R();
127 
129 
130  assert(isConsistent());
131  }
132 
133  /// Copy constructor.
134  template < class S >
136  : VectorBase<R>(0, 0)
137  , mem(0)
138  {
139  VectorBase<R>::dimen = old.dim();
140  memsize = old.memsize;
141 
142  spx_alloc(mem, memsize);
143 
144  for( int i = 0; i < VectorBase<R>::dimen; i++ )
145  new (&(mem[i])) R(old[i]);
146  for( int i = VectorBase<R>::dimen; i < memsize; i++ )
147  new (&(mem[i])) R();
148 
150 
151  assert(isConsistent());
152  }
153 
154  /// Assignment operator.
156  {
157  if( (VectorBase<R>*)this != &vec )
158  {
159  if( vec.dim() != VectorBase<R>::dim() )
160  reDim(vec.dim());
161 
163 
164  assert(isConsistent());
165  }
166 
167  return *this;
168  }
169 
170  /// Assignment operator.
171  template < class S >
173  {
174  if( (VectorBase<S>*)this != &vec )
175  {
176  if( vec.dim() != VectorBase<R>::dim() )
177  reDim(vec.dim());
178 
180 
181  assert(isConsistent());
182  }
183 
184  return *this;
185  }
186 
187  /// Assignment operator.
189  {
190  if( this != &vec )
191  {
192  if( vec.dim() != VectorBase<R>::dim() )
193  reDim(vec.dim());
194 
196 
197  assert(isConsistent());
198  }
199 
200  return *this;
201  }
202 
203  /// Assignment operator.
204  template < class S >
206  {
207  if( this != (const DVectorBase<R>*)&vec )
208  {
209  if( vec.dim() != VectorBase<R>::dim() )
210  reDim(vec.dim());
211 
213 
214  assert(isConsistent());
215  }
216 
217  return *this;
218  }
219 
220  /// Assignment operator.
221  template < class S >
223 
224  /// Destructor.
225  virtual ~DVectorBase<R>()
226  {
227  if( mem != 0 )
228  {
229  for( int i = memsize-1; i >= 0; i-- )
230  mem[i].~R();
231 
232  spx_free(mem);
233  }
234  }
235 
236  //@}
237 
238  // ------------------------------------------------------------------------------------------------------------------
239  /**@name Access and modification */
240  //@{
241 
242  /// Returns \ref soplex::DVectorBase "DVectorBase"'s memory size.
243  int memSize() const
244  {
245  return memsize;
246  }
247 
248  /// Resets \ref soplex::DVectorBase "DVectorBase"'s dimension to \p newdim.
249  void reDim(int newdim, const bool setZero = true )
250  {
251  assert(memsize >= 0);
252 
253  if( newdim > memsize )
254  reSize(int(newdim + 0.2 * memsize));
255 
256  if( setZero )
257  {
258  for( int i = VectorBase<R>::dimen; i < newdim; i++ )
259  mem[i] = 0;
260  }
261 
262  VectorBase<R>::dimen = newdim;
263  }
264 
265  /// Resets \ref soplex::DVectorBase "DVectorBase"'s memory size to \p newsize.
266  void reSize(int newsize)
267  {
268  assert(newsize > VectorBase<R>::dim());
269 
270  /* allocate new memory */
271  R* newmem = 0;
272  spx_alloc(newmem, newsize);
273 
274  /* call copy constructor for first elements */
275  int i;
276  for( i = 0; i < VectorBase<R>::dim(); i++ )
277  new (&(newmem[i])) R(mem[i]);
278 
279  /* call default constructor for remaining elements */
280  for( ; i < newsize; i++ )
281  new (&(newmem[i])) R();
282 
283  /* free old memory */
284  for( i = memsize-1; i >= 0; i-- )
285  mem[i].~R();
286 
287  spx_free(mem);
288 
289  /* assign new memory */
290  mem = newmem;
291  memsize = newsize;
293  }
294 
295  //@}
296 
297  // ------------------------------------------------------------------------------------------------------------------
298  /**@name Utilities */
299  //@{
300 
301  /// Consistency check.
302  bool isConsistent() const
303  {
304 #ifdef ENABLE_CONSISTENCY_CHECKS
305  if( VectorBase<R>::val != mem || VectorBase<R>::dimen > memsize || VectorBase<R>::dimen < 0 )
306  return MSGinconsistent("DVectorBase");
307 
309 #else
310  return true;
311 #endif
312  }
313 
314  //@}
315 };
316 
317 
318 
319 /// Resets \ref soplex::DVectorBase "DVectorBase"'s memory size to \p newsize (specialization for Real).
320 template<>
321 inline
322 void DVectorBase<Real>::reSize(int newsize)
323 {
324  assert(newsize >= dim());
325 
326  spx_realloc(mem, newsize);
327 
328  val = mem;
329  memsize = newsize;
330 }
331 
332 
333 
334 /// Default constructor with \p d as the initial dimension (specialization for Real).
335 template<>
336 inline
338  : VectorBase<Real>(0, 0)
339  , mem(0)
340 {
341  memsize = (d > 0) ? d : 4;
342  spx_alloc(mem, memsize);
343  val = mem;
344  dimen = d;
345 
347 }
348 
349 
350 
351 /// Copy constructor (specialization for Real).
352 template<>
353 template<>
354 inline
356  : VectorBase<Real>(0, 0)
357  , mem( 0 )
358 {
359  dimen = old.dim();
360  memsize = dimen;
361  spx_alloc(mem, memsize);
362  val = mem;
363  *this = old;
364 
366 }
367 
368 
369 
370 /// Copy constructor (specialization for Real).
371 template<>
372 inline
374  : VectorBase<Real>(0, 0)
375  , mem(0)
376 {
377  dimen = old.dim();
378  memsize = old.memsize;
379  spx_alloc(mem, memsize);
380  val = mem;
381  *this = old;
382 
384 }
385 } // namespace soplex
386 #endif // _DVECTORBASE_H_
DVectorBase< R > & operator=(const VectorBase< R > &vec)
Assignment operator.
Definition: dvectorbase.h:155
void reDim(int newdim, const bool setZero=true)
Resets DVectorBase&#39;s dimension to newdim.
Definition: dvectorbase.h:249
DVectorBase< R > & operator=(const DVectorBase< R > &vec)
Assignment operator.
Definition: dvectorbase.h:188
bool isConsistent() const
Consistency check.
Definition: dvectorbase.h:302
VectorBase< R > & operator=(const VectorBase< S > &vec)
Assignment operator.
Definition: vectorbase.h:111
Memory allocation routines.
Dynamic dense vectors.Class DVectorBase is a derived class of VectorBase adding automatic memory mana...
Definition: dvectorbase.h:48
Dense vector.Class VectorBase provides dense linear algebra vectors. It does not provide memory manag...
Definition: dsvectorbase.h:28
friend class DVectorBase
Definition: dvectorbase.h:50
int memsize
Length of array of values mem.
Definition: dvectorbase.h:59
void spx_alloc(T &p, int n=1)
Allocate memory.
Definition: spxalloc.h:48
R * mem
Array of values.
Definition: dvectorbase.h:62
void reSize(int newsize)
Resets DVectorBase&#39;s memory size to newsize.
Definition: dvectorbase.h:266
double Real
Definition: spxdefines.h:218
DVectorBase< R > & operator=(const VectorBase< S > &vec)
Assignment operator.
Definition: dvectorbase.h:172
R * val
Values of vector.
Definition: vectorbase.h:87
bool isConsistent() const
Consistency check.
Definition: vectorbase.h:459
Debugging, floating point type and parameter definitions.
DVectorBase< R > & operator=(const DVectorBase< S > &vec)
Assignment operator.
Definition: dvectorbase.h:205
void spx_realloc(T &p, int n)
Change amount of allocated memory.
Definition: spxalloc.h:79
int dim() const
Dimension of vector.
Definition: vectorbase.h:215
Everything should be within this namespace.
Dense vector.
int memSize() const
Returns DVectorBase&#39;s memory size.
Definition: dvectorbase.h:243
Sparse vectors.Class SVectorBase provides packed sparse vectors. Such are a sparse vectors...
Definition: dvectorbase.h:31
#define MSGinconsistent(name)
Definition: spxdefines.h:126
void spx_free(T &p)
Release memory.
Definition: spxalloc.h:109