Logo ROOT   6.30.04
Reference Guide
 All Namespaces Files Pages
TQpDataBase.cxx
Go to the documentation of this file.
1 // @(#)root/quadp:$Id$
2 // Author: Eddy Offermann May 2004
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 /*************************************************************************
13  * Parts of this file are copied from the OOQP distribution and *
14  * are subject to the following license: *
15  * *
16  * COPYRIGHT 2001 UNIVERSITY OF CHICAGO *
17  * *
18  * The copyright holder hereby grants you royalty-free rights to use, *
19  * reproduce, prepare derivative works, and to redistribute this software*
20  * to others, provided that any changes are clearly documented. This *
21  * software was authored by: *
22  * *
23  * E. MICHAEL GERTZ gertz@mcs.anl.gov *
24  * Mathematics and Computer Science Division *
25  * Argonne National Laboratory *
26  * 9700 S. Cass Avenue *
27  * Argonne, IL 60439-4844 *
28  * *
29  * STEPHEN J. WRIGHT swright@cs.wisc.edu *
30  * Computer Sciences Department *
31  * University of Wisconsin *
32  * 1210 West Dayton Street *
33  * Madison, WI 53706 FAX: (608)262-9777 *
34  * *
35  * Any questions or comments may be directed to one of the authors. *
36  * *
37  * ARGONNE NATIONAL LABORATORY (ANL), WITH FACILITIES IN THE STATES OF *
38  * ILLINOIS AND IDAHO, IS OWNED BY THE UNITED STATES GOVERNMENT, AND *
39  * OPERATED BY THE UNIVERSITY OF CHICAGO UNDER PROVISION OF A CONTRACT *
40  * WITH THE DEPARTMENT OF ENERGY. *
41  *************************************************************************/
42 
43 #include "TQpDataBase.h"
44 
45 ////////////////////////////////////////////////////////////////////////////////
46 ///
47 /// \class TQpDataBase
48 ///
49 /// Data for the general QP formulation
50 ///
51 /// The Data class stores the data defining the problem and provides
52 /// methods for performing the operations with this data required by
53 /// the interior-point algorithms. These operations include assembling
54 /// the linear systems (5) or (7), performing matrix-vector operations
55 /// with the data, calculating norms of the data, reading input into the
56 /// data structure from various sources, generating random problem
57 /// instances, and printing the data.
58 ///
59 ////////////////////////////////////////////////////////////////////////////////
60 
61 ClassImp(TQpDataBase);
62 
63 ////////////////////////////////////////////////////////////////////////////////
64 /// Default constructor
65 
66 TQpDataBase::TQpDataBase()
67 {
68  fNx = 0;
69  fMy = 0;
70  fMz = 0;
71 }
72 
73 
74 ////////////////////////////////////////////////////////////////////////////////
75 /// Constructor
76 
77 TQpDataBase::TQpDataBase(Int_t nx,Int_t my,Int_t mz)
78 {
79  fNx = nx;
80  fMy = my;
81  fMz = mz;
82 
83  fG .ResizeTo(fNx);
84 
85  fBa .ResizeTo(fMy);
86 
87  fXupBound.ResizeTo(fNx);
88  fXupIndex.ResizeTo(fNx);
89  fXloBound.ResizeTo(fNx);
90  fXloIndex.ResizeTo(fNx);
91 
92  fCupBound.ResizeTo(fMz);
93  fCupIndex.ResizeTo(fMz);
94  fCloBound.ResizeTo(fMz);
95  fCloIndex.ResizeTo(fMz);
96 }
97 
98 
99 ////////////////////////////////////////////////////////////////////////////////
100 /// Copy constructor
101 
102 TQpDataBase::TQpDataBase(const TQpDataBase &another) : TObject(another)
103 {
104  *this = another;
105 }
106 
107 
108 ////////////////////////////////////////////////////////////////////////////////
109 /// Randomly choose x and its boundaries
110 
111 void TQpDataBase::RandomlyChooseBoundedVariables(
112  TVectorD &x,TVectorD &dualx,TVectorD &xlow,TVectorD &ixlow,
113  TVectorD &xupp,TVectorD &ixupp,Double_t &ix,Double_t percentLowerOnly,
114  Double_t percentUpperOnly,Double_t percentBound)
115 {
116  const Int_t n = x.GetNrows();
117 
118  // Initialize the upper and lower bounds on x
119 
120  Int_t i;
121  for (i = 0; i < n; i++) {
122  const Double_t r = Drand(ix);
123 
124  if (r < percentLowerOnly) {
125  ixlow[i] = 1.0;
126  xlow [i] = (Drand(ix)-0.5)*3.0;
127  ixupp[i] = 0.0;
128  xupp [i] = 0.0;
129  }
130  else if (r < percentLowerOnly+percentUpperOnly) {
131  ixlow[i] = 0.0;
132  xlow [i] = 0.0;
133  ixupp[i] = 1.0;
134  xupp [i] = (Drand(ix)-0.5)*3.0;
135  }
136  else if (r < percentLowerOnly+percentUpperOnly+percentBound) {
137  ixlow[i] = 1.0;
138  xlow [i] = (Drand(ix)-0.5)*3.0;
139  ixupp[i] = 1.0;
140  xupp [i] = xlow[i]+Drand(ix)*10.0;
141  }
142  else {
143  // it is free
144  ixlow[i] = 0.0;
145  xlow [i] = 0.0;
146  ixupp[i] = 0.0;
147  xupp [i] = 0.0;
148  }
149  }
150 
151  for (i = 0; i < n; i++) {
152  if (ixlow[i] == 0.0 && ixupp[i] == 0.0 ) {
153  // x[i] not bounded
154  x [i] = 20.0*Drand(ix)-10.0;
155  dualx[i] = 0.0;
156  }
157  else if (ixlow[i] != 0.0 && ixupp[i] != 0.0) {
158  // x[i] is bounded above and below
159  const Double_t r = Drand(ix);
160  if (r < 0.33 ) {
161  // x[i] is on its lower bound
162  x [i] = xlow[i];
163  dualx[i] = 10.0*Drand(ix);
164  }
165  else if ( r > .66 ) {
166  // x[i] is on its upper bound
167  x [i] = xupp[i];
168  dualx[i] = -10.0*Drand(ix);
169  }
170  else {
171  // x[i] is somewhere in between
172  const Double_t theta = .99*Drand(ix)+.005;
173  x [i] = (1-theta)*xlow[i]+theta*xupp[i];
174  dualx[i] = 0.0;
175  }
176  }
177  else if (ixlow[i] != 0.0) {
178  // x[i] is only bounded below
179  if (Drand(ix) < .33 ) {
180  // x[i] is on its lower bound
181  x [i] = xlow[i];
182  dualx[i] = 10.0*Drand(ix);
183  }
184  else {
185  // x[i] is somewhere above its lower bound
186  x [i] = xlow[i]+0.005+10.0*Drand(ix);
187  dualx[i] = 0.0;
188  }
189  } // x[i] only has an upper bound
190  else {
191  if (Drand(ix) > .66 ) {
192  // x[i] is on its upper bound
193  x [i] = xupp[i];
194  dualx[i] = -10.0*Drand(ix);
195  }
196  else {
197  // x[i] is somewhere below its upper bound
198  x [i] = xupp[i]-0.005-10.0*Drand(ix);
199  dualx[i] = 0.0;
200  }
201  }
202  }
203 }
204 
205 
206 ////////////////////////////////////////////////////////////////////////////////
207 /// Assignment operator
208 
209 TQpDataBase &TQpDataBase::operator=(const TQpDataBase &source)
210 {
211  if (this != &source) {
212  TObject::operator=(source);
213  fNx = source.fNx;
214  fMy = source.fMy;
215  fMz = source.fMz;
216 
217  fG .ResizeTo(source.fG) ; fG = source.fG ;
218  fBa .ResizeTo(source.fBa) ; fBa = source.fBa ;
219  fXupBound.ResizeTo(source.fXupBound); fXupBound = source.fXupBound;
220  fXupIndex.ResizeTo(source.fXupIndex); fXupIndex = source.fXupIndex;
221  fXloBound.ResizeTo(source.fXloBound); fXloBound = source.fXloBound;
222  fXloIndex.ResizeTo(source.fXloIndex); fXloIndex = source.fXloIndex;
223  fCupBound.ResizeTo(source.fCupBound); fCupBound = source.fCupBound;
224  fCupIndex.ResizeTo(source.fCupIndex); fCupIndex = source.fCupIndex;
225  fCloBound.ResizeTo(source.fCloBound); fCloBound = source.fCloBound;
226  fCloIndex.ResizeTo(source.fCloIndex); fCloIndex = source.fCloIndex;
227  }
228  return *this;
229 }