← Back to branch summary

~cesar-cs/opencog/main

« back to all changes in this revision

Viewing changes to src/reasoning/indefinite/IndefinitePLNFormulas.cc

  • Committer: Cesar Marcondes
  • Date: 2008-06-21 23:24:09 UTC
  • Revision ID: cesar@aaron-20080621232409-pepggg6og8th71vm
Finish version 1 of PLN

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/reasoning/indefinite/IndefinitePLNFormulas.cc
24
24
#include <gsl/gsl_rng.h>
25
25
#include <gsl/gsl_randist.h>
26
26
 
27
 
using namespace reasoning;
28
27
gsl_rng* rng_ = gsl_rng_alloc (gsl_rng_mt19937);
29
28
 
 
29
/* In order to build other distributions 
 
30
 * wrap around the argv and the result
 
31
 */
30
32
void* BetaDistribution(void *arg) {
31
 
        int * argv; argv=(int*)arg;
32
 
        int a = argv[0];
33
 
        int b = argv[1];
 
33
        float * argv; argv=(float*)arg;
 
34
        float a = argv[0];
 
35
        float b = argv[1];
34
36
        static float c = gsl_ran_beta(rng_,a,b);
35
37
        return (void *) &c;
36
38
}
37
39
 
 
40
using namespace reasoning;
 
41
 
 
42
static number_t scaleLU(number_t value, number_t L_, number_t U_) {
 
43
        value = L_ + (U_ - L_)*value;
 
44
        value=(value > 1.0)?1.0:(value < 0.0)?0.0:value;
 
45
        return value;
 
46
}
 
47
 
 
48
static void truncate(number_t &value) {
 
49
        value=(value<=0.0)?0.000001:(value>=1.0)?0.999999:value;
 
50
}
 
51
 
 
52
void Sampler::generateSample   (IndefiniteTruthValue* const& TVa, 
 
53
                                                                IndefiniteTruthValue* const& TVb) {
 
54
 
 
55
        number_t valuesA[n1], valuesB[n1];
 
56
        float alpha = IndefiniteTruthValue::DEFAULT_K*0.5;
 
57
        float beta = alpha; float diff;
 
58
        float default_k = IndefiniteTruthValue::DEFAULT_K;
 
59
        float* args;
 
60
        vector <float*> distributionA, distributionB;
 
61
 
 
62
        // check if first order distribution is ready
 
63
        distributionA = TVa->getFirstOrderDistribution();       
 
64
        distributionB = TVb->getFirstOrderDistribution();       
 
65
        if (!distributionA.empty() && !distributionB.empty()) return;
 
66
 
 
67
        // step 1 - calculate diff on both variables
 
68
        // verify if L_ and U_ were previously calculated
 
69
        
 
70
        diff = TVa->getDiff();
 
71
        diff = TVb->getDiff();
 
72
 
 
73
        // step 2 - generate n1 values for each TV
 
74
        // for two TV - no need to check consistency
 
75
        // The parameters alfa=beta=0.5 is 
 
76
        // the defaulf for beta distribution 
 
77
        
 
78
        args[0] = alpha;
 
79
        args[1] = beta;
 
80
 
 
81
        for (int i=0; i<n1; i++) {
 
82
                valuesA[i] = *(number_t*) distribution(args);
 
83
                valuesB[i] = *(number_t*) distribution(args);
 
84
 
 
85
                valuesA[i] = scaleLU(valuesA[i], TVa->getL_(), TVa->getU_());
 
86
                valuesB[i] = scaleLU(valuesB[i], TVb->getL_(), TVb->getU_());
 
87
        }
 
88
 
 
89
        // step 3 - first Order Distribution 
 
90
        for (int i=0; i<n1; i++) {
 
91
                truncate(valuesA[i]);
 
92
                truncate(valuesB[i]);
 
93
                for (int j=0;i<n2;j++) {
 
94
                        args[0] = default_k * valuesA[i]; 
 
95
                        args[1] = default_k * (1 - valuesA[i]);
 
96
                        distributionA[i][j] = *(number_t*) distribution(args);
 
97
                        truncate(distributionA[i][j]);
 
98
                        
 
99
                        args[0] = default_k * valuesB[i]; 
 
100
                        args[1] = default_k * (1 - valuesB[i]);
 
101
                        distributionB[i][j] = *(number_t*) distribution(args);
 
102
                        truncate(distributionB[i][j]);
 
103
                }
 
104
        }
 
105
 
 
106
        TVa->setFirstOrderDistribution(distributionA);
 
107
        TVb->setFirstOrderDistribution(distributionB);
 
108
};
 
109
 
 
110
void Sampler::generateSample   (IndefiniteTruthValue* const& TVa, 
 
111
                                                                IndefiniteTruthValue* const& TVb,
 
112
                                                                IndefiniteTruthValue* const& TVc) {
 
113
 
 
114
        number_t valuesA[n1], valuesC[n1], valuesAC[n1];
 
115
        float alpha = IndefiniteTruthValue::DEFAULT_K*0.5;
 
116
        float beta = alpha; float diff;
 
117
        float default_k = IndefiniteTruthValue::DEFAULT_K;
 
118
        float* args;
 
119
        vector <float*> distributionA, distributionC, distributionAC;
 
120
 
 
121
        // check if first order distribution is ready
 
122
        distributionA = TVa->getFirstOrderDistribution();       
 
123
        distributionC = TVb->getFirstOrderDistribution();       
 
124
        distributionAC = TVc->getFirstOrderDistribution();      
 
125
        if (!distributionA.empty() && 
 
126
                !distributionC.empty() && !distributionAC.empty()) return;
 
127
 
 
128
        // step 1 - same as generateSample(TVa, TVb);
 
129
        diff = TVa->getDiff();
 
130
        diff = TVb->getDiff();
 
131
        diff = TVc->getDiff();
 
132
 
 
133
        // step 2 - generate n1 consistent values for each TV
 
134
        args[0] = alpha;
 
135
        args[1] = beta;
 
136
 
 
137
        for (int i=0; i<n1; i++) {
 
138
                do {
 
139
                valuesA[i] = *(number_t*) distribution(args);
 
140
                valuesC[i] = *(number_t*) distribution(args);
 
141
                valuesAC[i] = *(number_t*) distribution(args);
 
142
 
 
143
                valuesA[i] = scaleLU(valuesA[i], TVa->getL_(), TVa->getU_());
 
144
                valuesC[i] = scaleLU(valuesC[i], TVb->getL_(), TVb->getU_());
 
145
                valuesAC[i] = scaleLU(valuesAC[i], TVc->getL_(), TVc->getU_());
 
146
                } while (valuesAC[i] < 
 
147
                                GSL_MAX((valuesA[i] + valuesC[i] - 1)/valuesA[i],0) ||
 
148
                                valuesAC[i] > GSL_MIN(valuesC[i]/valuesA[i],1));
 
149
        }
 
150
 
 
151
        // step 3 - first Order Distribution
 
152
        for (int i=0; i<n1; i++) {
 
153
                truncate(valuesA[i]);
 
154
                truncate(valuesC[i]);
 
155
                truncate(valuesAC[i]);
 
156
 
 
157
                for (int j=0;i<n2;j++) {
 
158
                        do {
 
159
                        args[0] = default_k * valuesA[i]; 
 
160
                        args[1] = default_k * (1 - valuesA[i]);
 
161
                        distributionA[i][j] = *(number_t*) distribution(args);
 
162
                        truncate(distributionA[i][j]);
 
163
                        
 
164
                        args[0] = default_k * valuesC[i]; 
 
165
                        args[1] = default_k * (1 - valuesC[i]);
 
166
                        distributionC[i][j] = *(number_t*) distribution(args);
 
167
                        truncate(distributionC[i][j]);
 
168
 
 
169
                        args[0] = default_k * valuesAC[i]; 
 
170
                        args[1] = default_k * (1 - valuesAC[i]);
 
171
                        distributionAC[i][j] = *(number_t*) distribution(args);
 
172
                        truncate(distributionAC[i][j]);
 
173
 
 
174
                        } while (distributionAC[i][j] < 
 
175
                                GSL_MAX((distributionA[i][j] + distributionC[i][j] - 1)/
 
176
                                        distributionA[i][j],0) ||
 
177
                                distributionAC[i][j] > GSL_MIN(distributionC[i][j]/
 
178
                                        distributionA[i][j],1)
 
179
                                );
 
180
                }
 
181
        }
 
182
 
 
183
        TVa->setFirstOrderDistribution(distributionA);
 
184
        TVb->setFirstOrderDistribution(distributionC);
 
185
        TVc->setFirstOrderDistribution(distributionAC);
 
186
};
 
187
 
 
188
void Sampler::generateSample   (IndefiniteTruthValue* const& TVa, 
 
189
                                                                IndefiniteTruthValue* const& TVb,
 
190
                                                                IndefiniteTruthValue* const& TVc,
 
191
                                                                IndefiniteTruthValue* const& TVab,
 
192
                                                                IndefiniteTruthValue* const& TVcb_bc) {
 
193
 
 
194
        number_t valuesA[n1], valuesB[n1], 
 
195
                         valuesC[n1], valuesAB[n1], valuesCB_BC[n1];
 
196
        float alpha = IndefiniteTruthValue::DEFAULT_K*0.5;
 
197
        float beta = alpha; float diff;
 
198
        float default_k = IndefiniteTruthValue::DEFAULT_K;
 
199
        float* args;
 
200
        bool check = false;
 
201
        vector <float*> distributionA, distributionB, 
 
202
                   distributionC, distributionAB, distributionCB_BC;
 
203
 
 
204
        // check if first order distribution is ready
 
205
        distributionA = TVa->getFirstOrderDistribution();       
 
206
        distributionB = TVb->getFirstOrderDistribution();       
 
207
        distributionC = TVc->getFirstOrderDistribution();       
 
208
        distributionAB = TVab->getFirstOrderDistribution();     
 
209
        distributionCB_BC = TVcb_bc->getFirstOrderDistribution();       
 
210
 
 
211
        if (!distributionA.empty() && !distributionB.empty() && 
 
212
                !distributionC.empty() && !distributionAB.empty() &&
 
213
                !distributionCB_BC.empty()) return;
 
214
 
 
215
        // step 1 - same as generateSample(TVa, TVb);
 
216
        diff = TVa->getDiff();
 
217
        diff = TVb->getDiff();
 
218
        diff = TVc->getDiff();
 
219
        diff = TVab->getDiff();
 
220
        diff = TVcb_bc->getDiff();
 
221
 
 
222
        // step 2 - generate n1 consistent values for each TV
 
223
        args[0] = alpha;
 
224
        args[1] = beta;
 
225
 
 
226
        for (int i=0; i<n1; i++) {
 
227
                do {
 
228
                valuesA[i] = *(number_t*) distribution(args);
 
229
                valuesB[i] = *(number_t*) distribution(args);
 
230
                valuesC[i] = *(number_t*) distribution(args);
 
231
                valuesAB[i] = *(number_t*) distribution(args);
 
232
                valuesCB_BC[i] = *(number_t*) distribution(args);
 
233
        
 
234
                valuesA[i] = scaleLU(valuesA[i], TVa->getL_(), TVa->getU_());
 
235
                valuesB[i] = scaleLU(valuesB[i], TVb->getL_(), TVb->getU_());
 
236
                valuesC[i] = scaleLU(valuesC[i], TVc->getL_(), TVc->getU_());
 
237
                valuesAB[i] = scaleLU(valuesAB[i], TVab->getL_(), TVab->getU_());
 
238
                valuesCB_BC[i] = scaleLU(valuesCB_BC[i], 
 
239
                                TVcb_bc->getL_(), TVcb_bc->getU_());
 
240
 
 
241
                if (!deduction) 
 
242
                        check = (valuesCB_BC[i] < 
 
243
                                        GSL_MAX((valuesC[i] + valuesB[i] - 1)/ valuesC[i],0) 
 
244
                                        || valuesCB_BC[i] > 
 
245
                                        GSL_MIN(valuesB[i]/valuesC[i],1));
 
246
                else 
 
247
                        check = (valuesCB_BC[i] < 
 
248
                                        GSL_MAX((valuesB[i] + valuesC[i] - 1)/valuesB[i],0) 
 
249
                                        || valuesCB_BC[i] > 
 
250
                                        GSL_MIN(valuesC[i]/valuesB[i],1));
 
251
 
 
252
                } while (valuesAB[i] < 
 
253
                                GSL_MAX((valuesA[i] + valuesB[i] - 1)/valuesA[i],0) ||
 
254
                                valuesAB[i] > GSL_MIN(valuesB[i]/valuesA[i],1) || 
 
255
                                check);
 
256
        }
 
257
 
 
258
        // step 3 - first Order Distribution
 
259
 
 
260
        for (int i=0; i<n1; i++) {
 
261
                truncate(valuesA[i]);
 
262
                truncate(valuesB[i]);
 
263
                truncate(valuesC[i]);
 
264
                truncate(valuesAB[i]);
 
265
                truncate(valuesCB_BC[i]);
 
266
 
 
267
                for (int j=0;i<n2;j++) {
 
268
                        do {
 
269
                        args[0] = default_k * valuesA[i]; 
 
270
                        args[1] = default_k * (1 - valuesA[i]);
 
271
                        distributionA[i][j] = *(number_t*) distribution(args);
 
272
                        truncate(distributionA[i][j]);
 
273
                        
 
274
                        args[0] = default_k * valuesB[i]; 
 
275
                        args[1] = default_k * (1 - valuesB[i]);
 
276
                        distributionB[i][j] = *(number_t*) distribution(args);
 
277
                        truncate(distributionB[i][j]);
 
278
 
 
279
                        args[0] = default_k * valuesC[i]; 
 
280
                        args[1] = default_k * (1 - valuesC[i]);
 
281
                        distributionC[i][j] = *(number_t*) distribution(args);
 
282
                        truncate(distributionC[i][j]);
 
283
                        
 
284
                        args[0] = default_k * valuesAB[i]; 
 
285
                        args[1] = default_k * (1 - valuesAB[i]);
 
286
                        distributionAB[i][j] = *(number_t*) distribution(args);
 
287
                        truncate(distributionAB[i][j]);
 
288
 
 
289
                        args[0] = default_k * valuesCB_BC[i]; 
 
290
                        args[1] = default_k * (1 - valuesCB_BC[i]);
 
291
                        distributionCB_BC[i][j] = *(number_t*) distribution(args);
 
292
                        truncate(distributionCB_BC[i][j]);
 
293
        
 
294
                        if (!deduction) 
 
295
                                check = (distributionCB_BC[i][j] < 
 
296
                                        GSL_MAX((distributionC[i][j]+ distributionB[i][j]-1)/ 
 
297
                                                distributionC[i][j] ,0) 
 
298
                                        || distributionCB_BC[i][j] > 
 
299
                                        GSL_MIN(distributionB[i][j]/distributionC[i][j],1));
 
300
                        else 
 
301
                                check = (distributionCB_BC[i][j] < 
 
302
                                        GSL_MAX((distributionB[i][j] + distributionC[i][j]-1)/
 
303
                                                distributionB[i][j],0)
 
304
                                        || distributionCB_BC[i][j] > 
 
305
                                        GSL_MIN(distributionC[i][j]/distributionB[i][j],1));
 
306
 
 
307
                        } while (distributionAB[i][j] < 
 
308
                                GSL_MAX((distributionA[i][j] + distributionB[i][j] - 1)/
 
309
                                        distributionA[i][j],0) ||
 
310
                                distributionAB[i][j] > GSL_MIN(distributionB[i][j]/
 
311
                                        distributionA[i][j],1) || check); 
 
312
                }
 
313
        }
 
314
 
 
315
        TVa->setFirstOrderDistribution(distributionA);
 
316
        TVb->setFirstOrderDistribution(distributionB);
 
317
        TVc->setFirstOrderDistribution(distributionC);
 
318
        TVab->setFirstOrderDistribution(distributionAB);
 
319
        TVcb_bc->setFirstOrderDistribution(distributionCB_BC);
 
320
};
 
321
 
38
322
// IndefiniteRule Common Rule Conclusion
39
323
IndefiniteRule::IndefiniteRule (IndefiniteTruthValue* const& TVa, 
40
324
                                                                IndefiniteTruthValue* const& TVb) {
41
 
        int a,b;
42
 
        s = new Sampler(BetaDistribution);
 
325
        tvset[0] = TVa; 
 
326
        tvset[1] = TVb;
 
327
        s = new Sampler(BetaDistribution, 100, 100);
43
328
        s->generateSample(TVa, TVb);
44
329
};
45
330
 
46
331
IndefiniteRule::IndefiniteRule (IndefiniteTruthValue* const& TVa, 
47
332
                                                                IndefiniteTruthValue* const& TVb,
48
333
                                                                IndefiniteTruthValue* const& TVc) {
49
 
        s = new Sampler();
 
334
        tvset[0] = TVa; 
 
335
        tvset[1] = TVb;
 
336
        tvset[2] = TVb;
 
337
        s = new Sampler(BetaDistribution, 100, 100);
50
338
        s->generateSample(TVa, TVb, TVc);
51
339
};
52
340
 
54
342
                                                                IndefiniteTruthValue* const& TVb,
55
343
                                                                IndefiniteTruthValue* const& TVc,
56
344
                                                                IndefiniteTruthValue* const& TVab,
57
 
                                                                IndefiniteTruthValue* const& TVbc) {
58
 
        s = new Sampler();
 
345
                                                                IndefiniteTruthValue* const& TVbc,
 
346
                                                                bool deduction) {
 
347
        tvset[0] = TVa; 
 
348
        tvset[1] = TVb;
 
349
        tvset[2] = TVc;
 
350
        tvset[1] = TVab;
 
351
        tvset[2] = TVbc;
 
352
        s = new Sampler(BetaDistribution, 100, 100);
 
353
        s->setDeduction(deduction);
59
354
        s->generateSample(TVa, TVb, TVc, TVab, TVbc);
60
355
};
61
356
 
62
 
void Sampler::generateSample   (IndefiniteTruthValue* const& TVa, 
63
 
                                                                IndefiniteTruthValue* const& TVb) {
64
 
        // test
65
 
};
66
 
 
 
357
// Common conclusion among IndefiniteRules
67
358
IndefiniteTruthValue* IndefiniteRule::conclusion(dmatrix d) { 
68
359
 
69
360
        int qBelow, qAbove, n1, n2;
234
525
                                                                IndefiniteTruthValue* const& TVcb) {
235
526
        // create a sampler for two TV
236
527
        // create a constraint always true
237
 
        IndefiniteRule::IndefiniteRule(TVa, TVb, TVc, TVab, TVcb);
 
528
        IndefiniteRule::IndefiniteRule(TVa, TVb, TVc, TVab, TVcb, false);
238
529
}
239
530
 
240
531
IndefiniteTruthValue* AbductionRule::solve() {
298
589
                                                                IndefiniteTruthValue* const& TVbc) {
299
590
        // create a sampler for two TV
300
591
        // create a constraint always true
301
 
        IndefiniteRule::IndefiniteRule(TVa, TVb, TVc, TVab, TVbc);
 
592
        IndefiniteRule::IndefiniteRule(TVa, TVb, TVc, TVab, TVbc, true);
302
593
}
303
594
 
304
595
IndefiniteTruthValue* DeductionRule::solve() {