MultiAgentDecisionProcess  Release 0.2.1
BeliefValue.cpp
Go to the documentation of this file.
1 
28 #include "BeliefValue.h"
29 #include <float.h>
30 #include <limits.h>
31 
32 using namespace std;
33 
34 #include "AlphaVector.h"
35 #include "JointBeliefInterface.h"
36 
37 vector<double> BeliefValue::GetValues(const BeliefSet &Beliefs,
38  const AlphaVector &alpha)
39 {
41  V.push_back(alpha);
42  return(GetValues(Beliefs,V));
43 }
44 
48 vector<double> BeliefValue::GetValues(const BeliefSet &Beliefs,
50 {
51  int nrInV=V.size();
52  int nrB=Beliefs.size();
53 
54  vector<double> values(nrB,-DBL_MAX);
55  double x;
56 
57  for(int b=0;b!=nrB;b++)
58  for(int i=0;i!=nrInV;i++)
59  {
60  // compute inner product of belief with vector
61  x=Beliefs[b]->InnerProduct(V[i].GetValues());
62 
63  // keep the maximizing value
64  if(x>values[b])
65  values[b]=x;
66  }
67 
68  return(values);
69 }
70 
71 vector<double> BeliefValue::GetValues(const BeliefSet &Beliefs,
72  const QFunctionsDiscrete &Q)
73 {
74  vector<double> values(Beliefs.size()),
75  maxValues(Beliefs.size(),-DBL_MAX);
76  for(QFDcit i=Q.begin();i!=Q.end();++i)
77  {
78  values=GetValues(Beliefs,*i);
79  for(unsigned int j=0;j!=values.size();++j)
80  if(values[j]>maxValues[j])
81  maxValues[j]=values[j];
82  }
83 
84  return(maxValues);
85 }
86 
88  const AlphaVector &alpha)
89 {
90  return(Belief.InnerProduct(alpha.GetValues()));
91 }
92 
94  const QFunctionsDiscrete &Q)
95 {
96  double x,maxVal=-DBL_MAX;
97 
98  for(QFDcit i=Q.begin();i!=Q.end();++i)
99  {
100  x=GetValue(Belief,*i);
101  if(x>maxVal)
102  maxVal=x;
103  }
104 
105  return(maxVal);
106 }
107 
110  Index t)
111 {
112 #if 0
113  double x,maxVal=-DBL_MAX;
114 
115  for(QFDNScit i=Q.begin();i!=Q.end();++i)
116  {
117  x=GetValue(Belief,*i);
118  if(x>maxVal)
119  maxVal=x;
120  }
121 
122  return(maxVal);
123 #endif
124  return(GetValue(Belief,Q.at(t)));
125 }
126 
129 {
130  double x,maxVal=-DBL_MAX;
131 
132  for(unsigned int i=0;i!=V.size();i++)
133  {
134  // compute inner product of belief with vector
135  x=Belief.InnerProduct(V[i].GetValues());
136 
137  // keep the maximizing value
138  if(x>maxVal)
139  maxVal=x;
140  }
141 
142  return(maxVal);
143 }
144 
147  const vector<bool> mask)
148 {
149  double x,maxVal=-DBL_MAX;
150  bool maskValid=false;
151 
152  if(mask.size()!=V.size())
153  {
154  throw(E("BeliefValue::GetValue: mask has incorrect size"));
155  }
156 
157  for(unsigned int i=0;i!=V.size();i++)
158  {
159  if(mask[i])
160  {
161  maskValid=true;
162  // compute inner product of belief with vector
163  x=Belief.InnerProduct(V[i].GetValues());
164 
165  // keep the maximizing value
166  if(x>maxVal)
167  maxVal=x;
168  }
169  }
170 
171  return(maxVal);
172 }
173 
175  const VectorSet &v,
176  const vector<bool> mask)
177 {
178  double x,maxVal=-DBL_MAX;
179  bool maskValid=false;
180  vector<double> values(v.size2());
181 
182  if(mask.size()!=v.size1())
183  {
184  throw(E("BeliefValue::GetValue: mask has incorrect size"));
185  }
186 
187  for(unsigned int i=0;i!=v.size1();i++)
188  {
189  if(mask[i])
190  {
191  maskValid=true;
192  for(unsigned int k=0;k!=v.size2();++k)
193  values[k]=v(i,k);
194 
195  // compute inner product of belief with vector
196  x=Belief.InnerProduct(values);
197 
198  // keep the maximizing value
199  if(x>maxVal)
200  maxVal=x;
201  }
202  }
203 
204  return(maxVal);
205 }
206 
207 int
209  const VectorSet &v)
210 {
211  int nrInV=v.size1();
212  int maximizingVectorI=0;
213  double maxVal;
214 
215  // compute value of b for every vector in VS
216  vector<double> Vb=b.InnerProduct(v);
217 
218  // find maximizing vector, ignores effects of duplicate values
219  maxVal=-DBL_MAX;
220  for(int k=0;k!=nrInV;k++)
221  {
222  if(Vb[k]>maxVal)
223  {
224  maxVal=Vb[k];
225  maximizingVectorI=k;
226  }
227  }
228 
229  return(maximizingVectorI);
230 }
231 
232 int
236 {
237  int nrInV=V.size();
238  int maximizingVectorI=0;
239  double maxVal;
240 
241  // compute value of b for every vector in V
242  vector<double> Vb(nrInV,0);
243  for(int k=0;k!=nrInV;k++)
244  Vb[k]=b.InnerProduct(V[k].GetValues());
245 
246  // find maximizing vector, ignores effects of duplicate values
247  maxVal=-DBL_MAX;
248  for(int k=0;k!=nrInV;k++)
249  {
250  if(Vb[k]>maxVal)
251  {
252  maxVal=Vb[k];
253  maximizingVectorI=k;
254  }
255  }
256 
257  return(maximizingVectorI);
258 }
259 
262 int
264  const VectorSet &v,
265  const vector<bool> &mask)
266 {
267  int nrInV=v.size1();
268  int maximizingVectorI=INT_MAX;
269  double maxVal;
270  bool maskValid=false;
271 
272  if(static_cast<int>(mask.size())!=nrInV)
273  {
274  throw(E("BeliefValue::GetMaximizingVectorIndex: mask has incorrect size"));
275  }
276 
277  for(int k=0;k!=nrInV;k++)
278  if(mask[k])
279  {
280  maskValid=true;
281  break;
282  }
283 
284  // no vector was enabled in the mask, so there is no maximizing vector
285  if(!maskValid)
286  return(-1);
287 
288  // compute value of b for every vector in VS which has its mask
289  // set to true
290  vector<double> Vb=b.InnerProduct(v,mask);
291 
292  // find maximizing vector, ignores effects of duplicate values
293  maxVal=-DBL_MAX;
294  for(int k=0;k!=nrInV;k++)
295  {
296  if(mask[k] && Vb[k]>maxVal)
297  {
298  maxVal=Vb[k];
299  maximizingVectorI=k;
300  }
301  }
302 
303  if(maxVal==-DBL_MAX)
304  {
305  throw(E("BeliefValue::GetMaximizingVectorIndex: no maximizing vector found"));
306  }
307  return(maximizingVectorI);
308 }
309 
310 int
312  const VectorSet &v,
313  const vector<bool> &mask,
314  double &value)
315 {
316  //ugly, copy of JointBelief version..
317 
318  int nrInV=v.size1();
319  int maximizingVectorI=INT_MAX;
320  bool maskValid=false;
321 
322  if(static_cast<int>(mask.size())!=nrInV)
323  {
324  throw(E("BeliefValue::GetMaximizingVectorIndex: mask has incorrect size"));
325  }
326 
327  for(int k=0;k!=nrInV;k++)
328  if(mask[k])
329  {
330  maskValid=true;
331  break;
332  }
333 
334  // no vector was enabled in the mask, so there is no maximizing vector
335  if(!maskValid)
336  return(-1);
337 
338  // compute value of b for every vector in VS which has its mask
339  // set to true
340  vector<double> Vb=b.InnerProduct(v,mask);
341 
342  // find maximizing vector, ignores effects of duplicate values
343  value=-DBL_MAX;
344  for(int k=0;k!=nrInV;k++)
345  {
346  if(mask[k] && Vb[k]>value)
347  {
348  value=Vb[k];
349  maximizingVectorI=k;
350  }
351  }
352 
353  if(value==-DBL_MAX)
354  {
355  throw(E("BeliefValue::GetMaximizingVectorIndex: no maximizing vector found"));
356  }
357  return(maximizingVectorI);
358 }
359 
362  int k,
364 {
365  int nrInV=V.size();
366 
367  double x,y=-DBL_MAX;
368  int maxI=-1;
369 
370  for(int i=0;i!=nrInV;i++)
371  {
372  x=S[k]->InnerProduct(V[i].GetValues());
373 
374  if(x>y)
375  {
376  y=x;
377  maxI=i;
378  }
379  }
380 
381  if(maxI!=-1)
382  return(V[maxI]);
383  else
384  {
385  AlphaVector alpha(S[k]->Size(),-DBL_MAX);
386  alpha.SetAction(INT_MAX);
387  return(alpha);
388  }
389 }
390