SoPlex Doxygen Documentation
svector.cpp
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-2012 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 #include <assert.h>
17 #include <iostream>
18 
19 #include "spxdefines.h"
20 #include "svector.h"
21 #include "ssvector.h"
22 
23 namespace soplex
24 {
25 void SVector::add(int n, const int i[], const Real v[])
26 {
27  assert(n + size() <= max());
28  Element* e = m_elem + size();
29  set_size( size() + n );
30  while (n--)
31  {
32  e->idx = *i++;
33  e->val = *v++;
34  e++;
35  }
36 }
37 
38 void SVector::add(int n, const Element e[])
39 {
40  assert(n + size() <= max());
41  Element* ee = m_elem + size();
42  set_size( size() + n );
43  while (n--)
44  *ee++ = *e++;
45 }
46 
47 void SVector::remove(int n, int m)
48 {
49  assert(n <= m && m < size() && n >= 0);
50  ++m;
51 
52  int cpy = m - n;
53  cpy = (size() - m >= cpy) ? cpy : size() - m;
54 
55  Element* e = &m_elem[size() - 1];
56  Element* r = &m_elem[n];
57  set_size( size() - cpy );
58  do
59  {
60  *r++ = *e--;
61  }
62  while (--cpy);
63 }
64 
65 int SVector::dim() const
66 {
67  const Element* e = m_elem;
68  int d = -1;
69  int n = size();
70  while (n--)
71  {
72  d = (d > e->idx) ? d : e->idx;
73  e++;
74  }
75  return d+1;
76 }
77 
79 {
80  if( m_elem != 0 )
81  {
82  Element dummy;
83  Element* w;
84  Element* l;
85  Element* s = &(m_elem[0]);
86  Element* e = s + size();
87  for (l = s, w = s + 1; w < e; l = w, ++w)
88  {
89  if (l->idx > w->idx)
90  {
91  dummy = *w;
92  do
93  {
94  l[1] = *l;
95  if (l-- == s)
96  break;
97  }
98  while (l->idx > dummy.idx);
99  l[1] = dummy;
100  }
101  }
102  }
103 }
104 
106 {
107  Real x = 0;
108  int n = size();
109  const Element* e = m_elem;
110  while (n--)
111  {
112  x += e->val * e->val;
113  e++;
114  }
115  return x;
116 }
117 
119 {
120 #if 0 // old
121  Real x = 0;
122  int n = size();
123  const Element* e = m_elem;
124  while (n--)
125  {
126  x = (e->val > x) ? e->val : ((-e->val > x) ? -e->val : x);
127  e++;
128  }
129  return x;
130 #else // new
131  Real maxi = 0.0;
132 
133  for(int i = 0; i < size(); ++i)
134  if (fabs(m_elem[i].val) > maxi)
135  maxi = fabs(m_elem[i].val);
136 
137  assert(maxi >= 0.0);
138 
139  return maxi;
140 #endif
141 }
142 
144 {
145 #if 0 // old
146  Real x = infinity;
147  int n = size();
148  const Element* e = m_elem;
149 
150  while (n--)
151  { // vvvvvvvvvv bug
152  x = (e->val < x) ? e->val : ((-e->val < x) ? -e->val : x);
153  e++;
154  }
155  return x;
156 #else // new
157  Real mini = infinity;
158 
159  for(int i = 0; i < size(); ++i)
160  if (fabs(m_elem[i].val) < mini)
161  mini = fabs(m_elem[i].val);
162 
163  assert(mini >= 0.0);
164 
165  return mini;
166 #endif
167 }
168 
170 {
171  int n = size();
172  Element* e = m_elem;
173  while (n--)
174  {
175  e->val *= x;
176  e++;
177  }
178  return *this;
179 }
180 
182 {
183  assert(max() >= sv.size());
184  set_size( sv.size() );
185  int i = size();
186  Element *e = m_elem;
187 
188  while (i--)
189  {
190  e->idx = sv.index(i);
191  e->val = sv[e->idx];
192  ++e;
193  }
194  return *this;
195 }
196 
198 {
199  int n = 0;
200  int i = vec.dim();
201  Element *e = m_elem;
202  clear();
203  while (i--)
204  {
205  if (vec[i])
206  {
207  assert(n < max());
208  e->idx = i;
209  e->val = vec[i];
210  ++e;
211  ++n;
212  }
213  }
214  set_size( n );
215  return *this;
216 }
217 
219 {
220  if (this != &sv)
221  {
222  assert(max() >= sv.size());
223  int i = sv.size();
224  Element *e = m_elem;
225  const Element *s = sv.m_elem;
226  while (i--)
227  {
228  assert(e != 0);
229  *e++ = *s++;
230  }
231  set_size( sv.size() );
232  }
233  return *this;
234 }
235 
236 std::ostream& operator<<(std::ostream& os, const SVector& v)
237 {
238  int i, j;
239  for (i = j = 0; i < v.size(); ++i)
240  {
241  if (j)
242  {
243  if (v.value(i) < 0)
244  os << " - " << -v.value(i);
245  else
246  os << " + " << v.value(i);
247  }
248  else
249  os << v.value(i);
250  os << " x" << v.index(i);
251  j = 1;
252  if ((i + 1) % 4 == 0)
253  os << "\n\t";
254  }
255  return os;
256 }
257 
259 {
260 #ifdef ENABLE_CONSISTENCY_CHECKS
261  if (m_elem != 0)
262  {
263  const int my_size = size();
264  const int my_max = max();
265  if (my_size < 0 || my_max < 0 || my_size > my_max)
266  return MSGinconsistent("SVector");
267 
268  for (int i = 1; i < my_size; ++i)
269  {
270  for (int j = 0; j < i; ++j)
271  {
272  // allow trailing zeros
273  if (m_elem[i].idx == m_elem[j].idx && m_elem[i].val != 0.0 )
274  return MSGinconsistent("SVector");
275  }
276  }
277  }
278 #endif
279 
280  return true;
281 }
282 } // namespace soplex
283 
284 //-----------------------------------------------------------------------------
285 //Emacs Local Variables:
286 //Emacs mode:c++
287 //Emacs c-basic-offset:3
288 //Emacs tab-width:8
289 //Emacs indent-tabs-mode:nil
290 //Emacs End:
291 //-----------------------------------------------------------------------------