src/infer.c

   1 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
   2  * RICE 4.0x              Copyright (C) 1993             Rene' Jager *
   3  *                                                                   *
   4  *                                                                   *
   5  * This toolbox is free software; you can redistribute it and/or     *
   6  * modify it under the terms of the GNU General Public License as    *
   7  * published by the Free Software Foundation; either version 2 of    *
   8  * the License, or (at your option) any later version.               *
   9  *                                                                   *
  10  * This toolbox is distributed in the hope that it will be useful,   *
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of    *
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the      *
  13  * GNU General Public License for more details.                      *
  14  *                                                                   *
  15  * You should have received a copy of the GNU General Public License *
  16  * along with this toolbox; if not, write to the:                    *
  17  *                                                                   *
  18  *    Free Software Foundation, Inc.                                 *
  19  *    675 Mass Ave, Cambridge                                        *
  20  *    MA 02139, USA.                                                 *
  21  *                                                                   *
  22  * See the RICE documentation for more information on the toolbox.   *
  23  * The file COPYING for the complete GNU General Public License.     *
  24  *                                                                   *
  25  * You can reach me by (preferably e-mail):                          *
  26  *                                                                   *
  27  *    Rene' Jager                                                    *
  28  *                                                                   *
  29  *    Delft University of Technology                                 *
  30  *    Department of Electrical Engineering                           *
  31  *    Control Laboratory                                             *
  32  *                                                                   *
  33  *    Room ET 12.06                                                  *
  34  *                                                                   *
  35  *    Mekelweg 4                                                     *
  36  *    P.O.Box 5031                                                   *
  37  *    2600 GA  Delft                                                 *
  38  *    The Netherlands                                                *
  39  *                                                                   *
  40  *    e-mail: R.Jager@ET.TUDelft.NL                                  *
  41  *    phone:  +31-15-78 51 14                                        *
  42  *    fax:    +31-15-62 67 38                                        *
  43  *    telex:  38151 butud nl                                         *
  44  *                                                                   *
  45  * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
  46
  47 /*
  48    File:   infer.c
  49    Author: Rene' Jager
  50    Update: January 4, 1993
  51    Info:   source file for RICE
  52 */
  53
  54
  55 /* hidden include files */
  56
  57 #include "include.h"
  58 #include "define.h"
  59 #include "type.h"
  60 #include "function.h"
  61 #include "variable.h"
  62
  63
  64 /* macro for swapping */
  65
  66 #define SwapIndices(ind1,ind2) \
  67 { \
  68    int __ind; \
  69    Protect(1); \
  70    __ind = ind1; \
  71    ind1 = ind2; \
  72    ind2 = __ind; \
  73    Protect(0); \
  74 }
  75
  76
  77 /* prototypes of static functions */
  78
  79 PROTOTYPE(static int KnownCondition, (OBJ_CONDITION *));
  80 PROTOTYPE(static int KnownRule, (OBJ_RULE *));
  81 PROTOTYPE(static int KnownDimension, (OBJ_DIMENSION *));
  82 PROTOTYPE(static int RelationTarget, (OBJ_RELATION *));
  83
  84 PROTOTYPE(static void EvaluateCondition, (OBJ_CONDITION *, float *, int));
  85 PROTOTYPE(static void EvaluateDimension, (OBJ_DIMENSION *, float *, int));
  86 PROTOTYPE(static void ExecuteAction, (OBJ_ACTION *, float *));
  87 PROTOTYPE(static void ExecuteDimension, (OBJ_DIMENSION *, float *));
  88 PROTOTYPE(static void InferBase, (OBJ_BASE *));
  89 PROTOTYPE(static void InferLayer, (OBJ_LAYER *));
  90 PROTOTYPE(static void InferFact, (OBJ_FACT *));
  91 PROTOTYPE(static void ApplyRule, (OBJ_RULE *));
  92 PROTOTYPE(static void ApplyRelation, (OBJ_RELATION *, int));
  93 PROTOTYPE(static void AskFact, (OBJ_FACT *, int, char *[]));
  94 PROTOTYPE(static void InformFact, (OBJ_FACT *, int, char *[]));
  95 PROTOTYPE(static void RunFact, (OBJ_FACT *, int, char *[]));
  96
  97
  98 /* main infer-funtion */
  99
 100 FUNCTION(int InferKB,
 101    (int index),
 102    (index),
 103    int index;
 104 )
 105 {
 106    if(SwitchES(index))
 107       return -1;
 108
 109    if(!objectList)
 110       return -1;
 111
 112    InferBase(IDX2BAS(0));
 113
 114    return 0;
 115 }
 116
 117
 118 /* static infer-functions */
 119
 120 FUNCTION(static void InferBase,
 121    (OBJ_BASE *base),
 122    (base),
 123    OBJ_BASE *base;
 124 )
 125 {
 126    register int i, j;
 127    OBJ_LAYER *layer;
 128
 129    for(i = 1; i <= base->layer[0]; i++)
 130    {
 131       layer = IDX2LAY(base->layer[i]);
 132
 133       for(j = 1; j <= layer->rule[0]; j++)
 134          IDX2RUL(layer->rule[j])->slot.FIREABLE = 0;
 135
 136       for(j = 1; j <= layer->relation[0]; j++)
 137          IDX2REL(layer->relation[j])->slot.FIREABLE = 0;
 138    }
 139
 140    for(i = 1; i <= base->layer[0]; i++)
 141       if(IDX2OBJ(base->layer[i])->status.ACTIVE)
 142          InferLayer(IDX2LAY(base->layer[i]));
 143 }
 144
 145
 146 FUNCTION(static void InferLayer,
 147    (OBJ_LAYER *layer),
 148    (layer),
 149    OBJ_LAYER *layer;
 150 )
 151 {
 152    register int i;
 153    OBJ_FACT *fact;
 154    OBJ_RULE *rule;
 155    OBJ_RELATION *relation;
 156    int target, fired;
 157    float grade = GRD_TRUE;
 158
 159    /* do all initial actions */
 160    for(i = 1; i <= layer->init[0]; i++)
 161       ExecuteAction(IDX2ACT(layer->init[i]), &grade);
 162
 163    /* in case of forward reasoning, get all data from previous layers */
 164    if(layer->slot.FORWARD)
 165    {
 166       for(i = 1; i <= layer->data[0]; i++)
 167       {
 168          fact = IDX2FAC(layer->data[i]);
 169
 170          InferFact(fact);
 171
 172          /* fact must be known before inferring layer */
 173          if(fact->grade == GRD_UNKNOWN)
 174          {
 175             if(fact->slot.CODE)
 176                RunFact(fact, 1, &fact->symbolic);
 177             else
 178                AskFact(fact, 1, &fact->symbolic);
 179          }
 180       }
 181    }
 182
 183    /* release all rules and relations in this layer */
 184    for(i = 1; i <= layer->rule[0]; i++)
 185       IDX2RUL(layer->rule[i])->slot.FIREABLE = 1;
 186
 187    for(i = 1; i <= layer->relation[0]; i++)
 188       IDX2REL(layer->relation[i])->slot.FIREABLE = 1;
 189
 190    /* breadth-first forward reasoning */
 191    if(layer->slot.FORWARD)
 192    {
 193       do
 194       {
 195          fired = 0;
 196
 197          for(i = 1; i <= layer->rule[0]; i++)
 198          {
 199             rule = IDX2RUL(layer->rule[i]);
 200
 201             if(rule->status.ACTIVE && rule->slot.FIREABLE && !rule->slot.FIRED)
 202                if(KnownRule(rule))
 203                {
 204                   ApplyRule(rule);
 205                   fired = 1;
 206                }
 207          }
 208
 209          for(i = 1; i <= layer->relation[0]; i++)
 210          {
 211             relation = IDX2REL(layer->relation[i]);
 212
 213             if(relation->status.ACTIVE && relation->slot.FIREABLE && !relation->slot.FIRED)
 214                if((target = RelationTarget(relation)))
 215                {
 216                   ApplyRelation(relation, target);
 217                   fired = 1;
 218                }
 219          }
 220       }
 221       while(fired);
 222    }
 223
 224    /* depth-first backward reasoning */
 225    if(layer->slot.BACKWARD)
 226    {
 227       for(i = 1; i <= layer->goal[0]; i++)
 228       {
 229          fact = IDX2FAC(layer->goal[i]);
 230
 231          InferFact(fact);
 232
 233          if(fact->grade == GRD_UNKNOWN)
 234          {
 235             if(fact->slot.CODE)
 236                RunFact(fact, 1, &fact->symbolic);
 237             elif(interactiveMode)
 238                AskFact(fact, 1, &fact->symbolic);
 239          }
 240       }
 241    }
 242 }
 243
 244
 245 FUNCTION(static void InferFact,
 246    (OBJ_FACT *fact),
 247    (fact),
 248    OBJ_FACT *fact;
 249 )
 250 {
 251    register int i;
 252
 253    /* if fact is already being inferred */
 254    if(fact->slot.INFERRING)
 255       return;
 256
 257    fact->slot.INFERRING = 1;
 258
 259    if(fact->grade == GRD_UNKNOWN)
 260    {
 261       for(i = 1; i <= fact->backward[0]; i++)
 262       {
 263          switch(IDX2OBJ(fact->backward[i])->type)
 264          {
 265             case TYP_RULE:
 266                if(IDX2RUL(fact->backward[i])->slot.FIREABLE)
 267                   if(IDX2RUL(fact->backward[i])->status.ACTIVE)
 268                      ApplyRule(IDX2RUL(fact->backward[i]));
 269                break;
 270
 271             case TYP_RELATION:
 272                if(IDX2REL(fact->backward[i])->slot.FIREABLE)
 273                   if(IDX2REL(fact->backward[i])->status.ACTIVE)
 274                      ApplyRelation(IDX2REL(fact->backward[i]), fact->number);
 275                break;
 276
 277             default:
 278                Report(MSG_ERROR, MSG_BUG_INTERNAL);
 279                Abandon();
 280                break;
 281          }
 282       }
 283    }
 284
 285    fact->slot.INFERRING = 0;
 286 }
 287
 288
 289 /* help-functions */
 290
 291 FUNCTION(static void ApplyRule,
 292    (OBJ_RULE *rule),
 293    (rule),
 294    OBJ_RULE *rule;
 295 )
 296 {
 297    register int i;
 298    OBJ_CONDITION *condition;
 299    float grade = GRD_UNKNOWN, degree;
 300
 301    if((rule->slot.FIRED || rule->slot.FIRING) && !recursiveMode)
 302       return;
 303
 304    rule->slot.FIRING = 1;
 305
 306    if(rule->slot.INTERSECTION)
 307    {
 308       grade = GRD_TRUE;
 309
 310       for(i = 1; i <= rule->condition[0]; i++)
 311       {
 312          condition = IDX2CON(rule->condition[i]);
 313
 314          if(condition->status.ACTIVE)
 315             EvaluateCondition(condition, &degree, MOD_DEPTH);
 316          else
 317             degree = GRD_TRUE;
 318
 319          grade = (*condition->norm)(grade, degree);
 320
 321          if(grade == GRD_FALSE)
 322          {
 323             if(selectiveMode && i > 1 && !condition->slot.IF)
 324                if(!IDX2CON(rule->condition[i-1])->slot.IF)
 325                   SwapIndices(rule->condition[i], rule->condition[i-1]);
 326
 327             break;
 328          }
 329       }
 330    }
 331    elif(rule->slot.UNION)
 332    {
 333       grade = GRD_FALSE;
 334
 335       for(i = 1; i <= rule->condition[0]; i++)
 336       {
 337          condition = IDX2CON(rule->condition[i]);
 338
 339          if(condition->status.ACTIVE)
 340             EvaluateCondition(condition, &degree, MOD_DEPTH);
 341          else
 342             degree = GRD_FALSE;
 343
 344          grade = (*condition->norm)(grade, degree);
 345
 346          if(grade == GRD_TRUE)
 347          {
 348             if(selectiveMode && i > 1 && !condition->slot.IF)
 349                if(!IDX2CON(rule->condition[i-1])->slot.IF)
 350                   SwapIndices(rule->condition[i], rule->condition[i-1]);
 351
 352             break;
 353          }
 354       }
 355    }
 356
 357    /* grade should have usable value */
 358    if(grade != GRD_UNKNOWN)
 359    {
 360       for(i = 1; i <= rule->action[0]; i++)
 361       {
 362          /* action should be active */
 363          if(IDX2ACT(rule->action[i])->status.ACTIVE && grade != GRD_UNKNOWN)
 364             ExecuteAction(IDX2ACT(rule->action[i]), &grade);
 365       }
 366    }
 367
 368    rule->slot.FIRED = 1;
 369    rule->slot.FIRING = 0;
 370 }
 371
 372
 373 FUNCTION(static int KnownCondition,
 374    (OBJ_CONDITION *condition),
 375    (condition),
 376    OBJ_CONDITION *condition;
 377 )
 378 {
 379    /* condition object should be a fact */
 380    if(condition->slot.FAC)
 381    {
 382       /* nothing to be inferred */
 383       if(condition->slot.ON || condition->slot.OFF)
 384          return 1;
 385
 386       /* in case of arguments always unknown */
 387       if(condition->argc > 1)
 388          return 0;
 389
 390       /* run or ask perform in repetitive mode */
 391       if((condition->slot.RUN || condition->slot.USR) && repetitiveMode)
 392          return 0;
 393
 394       /* just an unknown fact */
 395       if(IDX2FAC(condition->object)->grade == GRD_UNKNOWN)
 396          return 0;
 397    }
 398
 399    return 1;
 400 }
 401
 402
 403 FUNCTION(static int KnownRule,
 404    (OBJ_RULE *rule),
 405    (rule),
 406    OBJ_RULE *rule;
 407 )
 408 {
 409    register int i;
 410    int known;
 411
 412    if(rule->slot.INTERSECTION)
 413    {
 414       /* false condition is sufficient */
 415       for(i = 1, known = 1; i <= rule->condition[0]; i++)
 416          if(!KnownCondition(IDX2CON(rule->condition[i])))
 417             known = 0;
 418          else
 419             if(IDX2FAC(IDX2CON(rule->condition[i])->object)->grade == GRD_FALSE)
 420                return 1;
 421
 422       if(known)
 423          return 1;
 424    }
 425    elif(rule->slot.UNION)
 426    {
 427       /* true condition is sufficient */
 428       for(i = 1, known = 1; i <= rule->condition[0]; i++)
 429          if(!KnownCondition(IDX2CON(rule->condition[i])))
 430             known = 0;
 431          else
 432             if(IDX2FAC(IDX2CON(rule->condition[i])->object)->grade == GRD_TRUE)
 433                return 1;
 434
 435       if(known)
 436          return 1;
 437    }
 438
 439    return 0;
 440 }
 441
 442
 443 FUNCTION(static void EvaluateCondition,
 444    (OBJ_CONDITION *condition, float *grade, int mode),
 445    (condition, grade, mode),
 446    OBJ_CONDITION *condition;
 447    float *grade;
 448    int mode;
 449 )
 450 {
 451    float degree = GRD_UNKNOWN;
 452
 453    if(condition->slot.ON)
 454       degree = IDX2OBJ(condition->object)->status.ACTIVE ? GRD_TRUE : GRD_FALSE;
 455    elif(condition->slot.OFF)
 456       degree = IDX2OBJ(condition->object)->status.ACTIVE ? GRD_FALSE : GRD_TRUE;
 457    elif(condition->slot.FAC)
 458    {
 459       OBJ_FACT *fact;
 460
 461       fact = IDX2FAC(condition->object);
 462
 463       if(mode == MOD_DEPTH)
 464       {
 465          if(condition->slot.RUN)
 466          {
 467             if(repetitiveMode || fact->grade == GRD_UNKNOWN || condition->argc > 1)
 468             {
 469                RunFact(fact, condition->argc, condition->argv);
 470                degree = fact->grade;
 471
 472                /* arguments make it temporal */
 473                if(condition->argc > 1)
 474                   fact->grade = GRD_UNKNOWN;
 475             }
 476          }
 477          elif(condition->slot.USR)
 478          {
 479             if(repetitiveMode || fact->grade == GRD_UNKNOWN || condition->argc > 1)
 480             {
 481                AskFact(fact, condition->argc, condition->argv);
 482                degree = fact->grade;
 483
 484                /* arguments make it temporal */
 485                if(condition->argc > 1)
 486                   fact->grade = GRD_UNKNOWN;
 487             }
 488          }
 489          else
 490          {
 491             /* explaination */
 492             if(condition->slot.SHW)
 493                WhyFact(fact, -1);
 494
 495             if(fact->grade == GRD_UNKNOWN)
 496                InferFact(fact);
 497
 498             if(fact->grade == GRD_UNKNOWN)
 499             {
 500                if(fact->slot.CODE)
 501                   RunFact(fact, condition->argc, condition->argv);
 502                elif(interactiveMode)
 503                   AskFact(fact, condition->argc, condition->argv);
 504
 505                degree = fact->grade;
 506
 507                /* arguments make it temporal */
 508                if(condition->argc > 1)
 509                   fact->grade = GRD_UNKNOWN;
 510             }
 511             else
 512                degree = fact->grade;
 513          }
 514       }
 515       else
 516          degree = fact->grade;
 517    }
 518    elif(condition->slot.LAY)
 519    {
 520       OBJ_LAYER *layer;
 521
 522       layer = IDX2LAY(condition->object);
 523
 524       if(condition->slot.BKW)
 525          degree = layer->slot.BACKWARD ? GRD_TRUE : GRD_FALSE;
 526       elif(condition->slot.FRW)
 527          degree = layer->slot.FORWARD ? GRD_TRUE : GRD_FALSE;
 528    }
 529    elif(condition->slot.CON)
 530    {
 531       OBJ_CONDITION *condition2;
 532
 533       condition2 = IDX2CON(condition->object);
 534
 535       if(condition->slot.CUT)
 536          degree = condition2->level;
 537    }
 538    elif(condition->slot.ACT)
 539    {
 540       OBJ_ACTION *action;
 541
 542       action = IDX2ACT(condition->object);
 543
 544       if(condition->slot.GRD)
 545          degree = action->grade;
 546       elif(condition->slot.CUT)
 547          degree = action->level;
 548    }
 549    elif(condition->slot.DIM)
 550    {
 551       OBJ_DIMENSION *dimension;
 552
 553       dimension = IDX2DIM(condition->object);
 554
 555       if(condition->slot.GRD)
 556          degree = dimension->grade;
 557       elif(condition->slot.CUT)
 558          degree = dimension->level;
 559    }
 560
 561    if(condition->slot.NOT)
 562       degree = FNOT(degree);
 563
 564    condition->truth = *grade = FCUT(degree, condition->level);
 565 }
 566
 567
 568 FUNCTION(static void ExecuteAction,
 569    (OBJ_ACTION *action, float *grade),
 570    (action, grade),
 571    OBJ_ACTION *action;
 572    float *grade;
 573 )
 574 {
 575    float degree = *grade;
 576
 577    if(action->slot.THEN && degree < action->level)
 578       return;
 579
 580    if(action->slot.ELSE && degree > action->level)
 581       return;
 582
 583    if(action->slot.ELSE)
 584       degree = FNOT(degree);
 585
 586    if(action->slot.NOT)
 587       degree = FNOT(degree);
 588
 589    action->truth = degree = (*action->norm)(action->grade, degree);
 590
 591    if(action->slot.ON || action->slot.OFF)
 592    {
 593       /* activate in case of ON flag */
 594       IDX2OBJ(action->object)->status.ACTIVE =
 595          (!action->slot.NOT && action->slot.ON) ||
 596          (action->slot.NOT && action->slot.OFF);
 597
 598       /* also (in)activate rules and relations of layers */
 599       if(action->slot.LAY)
 600       {
 601          register int i;
 602          OBJ_LAYER *layer = IDX2LAY(action->object);
 603
 604          for(i = 1; i <= layer->rule[0]; i++)
 605             IDX2RUL(layer->rule[i])->status.ACTIVE = layer->status.ACTIVE;
 606
 607          for(i = 1; i <= layer->relation[0]; i++)
 608             IDX2RUL(layer->relation[i])->status.ACTIVE = layer->status.ACTIVE;
 609       }
 610    }
 611    elif(action->slot.FAC)
 612    {
 613       OBJ_FACT *fact;
 614
 615       fact = IDX2FAC(action->object);
 616
 617       /* run or inform if trivial, assign degree as temporal */
 618       if(action->slot.RUN || (action->argc > 1 && IDX2FAC(action->object)->slot.CODE))
 619       {
 620          fact->grade = degree;
 621          RunFact(fact, action->argc, action->argv);
 622
 623          /* grade is temporal in case of arguments */
 624          if(action->argc > 1)
 625             fact->grade = GRD_UNKNOWN;
 626       }
 627       elif(action->slot.USR || (action->argc > 1 && !IDX2FAC(action->object)->slot.CODE))
 628       {
 629          fact->grade = degree;
 630          InformFact(fact, action->argc, action->argv);
 631
 632          /* grade is temporal in case of arguments */
 633          if(action->argc > 1)
 634             fact->grade = GRD_UNKNOWN;
 635       }
 636       elif(action->slot.SHW)
 637       {
 638          fact->grade = degree;
 639          HowFact(fact, -1);
 640
 641          /* grade is temporal in case of arguments */
 642          if(action->argc > 1)
 643             fact->grade = GRD_UNKNOWN;
 644       }
 645       else
 646       {
 647          /* when not an init take average when multiple concluded */
 648          if(action->slot.INIT)
 649             fact->grade = degree;
 650          else
 651             fact->grade = (fact->sumgrade += degree)/(fact->numgrade += 1);
 652       }
 653    }
 654    elif(action->slot.LAY)
 655    {
 656       OBJ_LAYER *layer;
 657
 658       layer = IDX2LAY(action->object);
 659
 660       if(action->slot.BKW)
 661          layer->slot.BACKWARD = (action->slot.NOT ? 0 : 1);
 662       elif(action->slot.FRW)
 663          layer->slot.FORWARD = (action->slot.NOT ? 0 : 1);
 664       elif(action->slot.INV)
 665          InferLayer(OBJ2LAY(objectList[action->object]));
 666    }
 667    elif(action->slot.CON)
 668    {
 669       OBJ_CONDITION *condition;
 670
 671       condition = IDX2CON(action->object);
 672
 673       if(action->slot.CUT)
 674          condition->level = degree;
 675    }
 676    elif(action->slot.ACT)
 677    {
 678       OBJ_ACTION *action2;
 679
 680       action2 = IDX2ACT(action->object);
 681
 682       if(action->slot.GRD)
 683          action2->grade = degree;
 684       elif(action->slot.CUT)
 685          action2->level = degree;
 686    }
 687    elif(action->slot.DIM)
 688    {
 689       OBJ_DIMENSION *dimension;
 690
 691       dimension = IDX2DIM(action->object);
 692
 693       if(action->slot.GRD)
 694          dimension->grade = degree;
 695       elif(action->slot.CUT)
 696          dimension->level = degree;
 697    }
 698 }
 699
 700
 701 FUNCTION(static int KnownDimension,
 702    (OBJ_DIMENSION *dimension),
 703    (dimension),
 704    OBJ_DIMENSION *dimension;
 705 )
 706 {
 707    /* unknown object can only be a fact */
 708    if(dimension->slot.FAC)
 709    {
 710       /* always unknown in case of arguments */
 711       if(dimension->argc > 1)
 712          return 0;
 713
 714       /* perforn run or ask in repetitive mode */
 715       if((dimension->slot.RUN || dimension->slot.USR) && repetitiveMode)
 716          return 0;
 717
 718       /* just an unknown fact */
 719       if(IDX2FAC(dimension->object)->grade == GRD_UNKNOWN)
 720          return 0;
 721    }
 722
 723    return 1;
 724 }
 725
 726
 727 FUNCTION(static int RelationTarget,
 728    (OBJ_RELATION *relation),
 729    (relation),
 730    OBJ_RELATION *relation;
 731 )
 732 {
 733    register int i;
 734    int target = 0;
 735
 736    for(i = 1; i <= relation->dimension[0]; i++)
 737    {
 738       if(!KnownDimension(IDX2DIM(relation->dimension[i])))
 739       {
 740          if(target)
 741             return 0;
 742          else
 743             target = IDX2DIM(relation->dimension[i])->object;
 744       }
 745    }
 746
 747    return target;
 748 }
 749
 750
 751 FUNCTION(static void ApplyRelation,
 752    (OBJ_RELATION *relation, int target),
 753    (relation, target),
 754    OBJ_RELATION *relation;
 755    int target;
 756 )
 757 {
 758    register int i;
 759    OBJ_DIMENSION *dimension, *output = 0;
 760    float grade, degree;
 761
 762    if(!relation->status.ACTIVE)
 763       return;
 764
 765    if((relation->slot.FIRED || relation->slot.FIRING) && !recursiveMode)
 766       return;
 767
 768    relation->slot.FIRING = 1;
 769
 770    if(relation->dimension[0] > 1)
 771       grade = GRD_TRUE;
 772    else
 773       grade = GRD_UNKNOWN;
 774
 775    for(i = 1; i <= relation->dimension[0]; i++)
 776    {
 777       dimension = IDX2DIM(relation->dimension[i]);
 778
 779       if(dimension->object != target)
 780       {
 781          if(dimension->status.ACTIVE)
 782             EvaluateDimension(dimension, &degree, MOD_DEPTH);
 783          else
 784             degree = GRD_TRUE;
 785
 786          grade = (*dimension->norm)(grade, degree);
 787
 788          if(grade == GRD_FALSE)
 789          {
 790             if(selectiveMode && i > 1)
 791                SwapIndices(relation->dimension[i], relation->dimension[i-1]);
 792
 793             break;
 794          }
 795       }
 796       else
 797          output = dimension;
 798
 799       if(grade == GRD_FALSE)
 800          break;
 801    }
 802
 803    if(!output)   /* quickly find target dimension */
 804    {
 805       for(; i <= relation->dimension[0]; i++)
 806       {
 807          dimension = IDX2DIM(relation->dimension[i]);
 808
 809          if(dimension->object == target)
 810          {
 811             output = dimension;
 812             break;
 813          }
 814       }
 815    }
 816
 817    if(output->status.ACTIVE)
 818       ExecuteDimension(output, &grade);
 819
 820    relation->slot.FIRED = 1;
 821    relation->slot.FIRING = 0;
 822 }
 823
 824
 825 FUNCTION(static void EvaluateDimension,
 826    (OBJ_DIMENSION *dimension, float *grade, int mode),
 827    (dimension, grade, mode),
 828    OBJ_DIMENSION *dimension;
 829    float *grade;
 830    int mode;
 831 )
 832 {
 833    float degree = GRD_UNKNOWN;
 834
 835    if(dimension->slot.ON)
 836       degree = IDX2OBJ(dimension->object)->status.ACTIVE ? GRD_TRUE : GRD_FALSE;
 837    elif(dimension->slot.OFF)
 838       degree = IDX2OBJ(dimension->object)->status.ACTIVE ? GRD_FALSE : GRD_TRUE;
 839    elif(dimension->slot.FAC)
 840    {
 841       OBJ_FACT *fact;
 842
 843       fact = IDX2FAC(dimension->object);
 844
 845       if(mode == MOD_DEPTH)
 846       {
 847          if(dimension->slot.RUN)
 848          {
 849             if(repetitiveMode || fact->grade == GRD_UNKNOWN || dimension->argc > 1)
 850             {
 851                RunFact(fact, dimension->argc, dimension->argv);
 852                degree = fact->grade;
 853                if(dimension->argc > 1)   /* reset because of arguments */
 854                   fact->grade = GRD_UNKNOWN;
 855             }
 856          }
 857          elif(dimension->slot.USR)
 858          {
 859             if(repetitiveMode || fact->grade == GRD_UNKNOWN || dimension->argc > 1)
 860             {
 861                AskFact(fact, dimension->argc, dimension->argv);
 862                degree = fact->grade;
 863                if(dimension->argc > 1)   /* reset because of arguments */
 864                   fact->grade = GRD_UNKNOWN;
 865             }
 866          }
 867          else
 868          {
 869             /* explaination */
 870             if(dimension->slot.SHW)
 871                WhyFact(fact, -1);
 872
 873             if(fact->grade == GRD_UNKNOWN)
 874                InferFact(fact);
 875
 876             if(fact->grade == GRD_UNKNOWN)
 877             {
 878                if(fact->slot.CODE)
 879                   RunFact(fact, dimension->argc, dimension->argv);
 880                elif(interactiveMode)
 881                   AskFact(fact, dimension->argc, dimension->argv);
 882
 883                degree = fact->grade;
 884
 885                if(dimension->argc > 1)
 886                   fact->grade = GRD_UNKNOWN;  /* reset due to arguments */
 887             }
 888             else
 889                degree = fact->grade;
 890          }
 891       }
 892       else
 893          degree = fact->grade;
 894    }
 895    elif(dimension->slot.LAY)
 896    {
 897       OBJ_LAYER *layer;
 898
 899       layer = IDX2LAY(dimension->object);
 900
 901       if(dimension->slot.BKW)
 902          degree = layer->slot.BACKWARD ? GRD_TRUE : GRD_FALSE;
 903       elif(dimension->slot.FRW)
 904          degree = layer->slot.FORWARD ? GRD_TRUE : GRD_FALSE;
 905    }
 906    elif(dimension->slot.CON)
 907    {
 908       OBJ_CONDITION *condition;
 909
 910       condition = IDX2CON(dimension->object);
 911
 912       if(dimension->slot.CUT)
 913          degree = condition->level;
 914    }
 915    elif(dimension->slot.ACT)
 916    {
 917       OBJ_ACTION *action;
 918
 919       action = IDX2ACT(dimension->object);
 920
 921       if(dimension->slot.GRD)
 922          degree = action->grade;
 923       elif(dimension->slot.CUT)
 924          degree = action->level;
 925    }
 926    elif(dimension->slot.DIM)
 927    {
 928       OBJ_DIMENSION *dimension2;
 929
 930       dimension2 = IDX2DIM(dimension->object);
 931
 932       if(dimension->slot.GRD)
 933          degree = dimension2->grade;
 934       elif(dimension->slot.CUT)
 935          degree = dimension2->level;
 936    }
 937
 938    if(dimension->slot.NOT)
 939       degree = FNOT(degree);
 940
 941    dimension->truth[0] = *grade = FCUT(degree, dimension->level);
 942 }
 943
 944
 945 FUNCTION(static void ExecuteDimension,
 946    (OBJ_DIMENSION *dimension, float *grade),
 947    (dimension, grade),
 948    OBJ_DIMENSION *dimension;
 949    float *grade;
 950 )
 951 {
 952    float degree = *grade;
 953
 954    if(degree < dimension->level)
 955       return;
 956
 957    if(dimension->slot.NOT)
 958       degree = FNOT(degree);
 959
 960    dimension->truth[1] = degree = (*dimension->norm)(dimension->grade, degree);
 961
 962    if(dimension->slot.ON || dimension->slot.OFF)
 963    {
 964       /* activate in case of ON flag */
 965       IDX2OBJ(dimension->object)->status.ACTIVE =
 966          (!dimension->slot.NOT && dimension->slot.ON) ||
 967          (dimension->slot.NOT && dimension->slot.OFF);
 968
 969       /* also (in)activate rules and relations of layers */
 970       if(dimension->slot.LAY)
 971       {
 972          register int i;
 973          OBJ_LAYER *layer = IDX2LAY(dimension->object);
 974
 975          for(i = 1; i <= layer->rule[0]; i++)
 976             IDX2RUL(layer->rule[i])->status.ACTIVE = layer->status.ACTIVE;
 977
 978          for(i = 1; i <= layer->relation[0]; i++)
 979             IDX2RUL(layer->relation[i])->status.ACTIVE = layer->status.ACTIVE;
 980       }
 981    }
 982    elif(dimension->slot.FAC)
 983    {
 984       OBJ_FACT *fact;
 985
 986       fact = IDX2FAC(dimension->object);
 987
 988       /* run or inform when trivial */
 989       if(dimension->slot.RUN || (dimension->argc > 1 && fact->slot.CODE))
 990       {
 991          fact->grade = degree;
 992          RunFact(fact, dimension->argc, dimension->argv);
 993
 994          /* grade is temporal in case of arguments */
 995          if(dimension->argc > 1)
 996             fact->grade = GRD_UNKNOWN;
 997       }
 998       elif(dimension->slot.USR || (dimension->argc > 1 && !fact->slot.CODE))
 999       {
1000          fact->grade = degree;
1001          InformFact(fact, dimension->argc, dimension->argv);
1002
1003             /* grade is temporal in case of arguments */
1004          if(dimension->argc > 1)
1005             fact->grade = GRD_UNKNOWN;
1006       }
1007       elif(dimension->slot.SHW)
1008       {
1009          fact->grade = degree;
1010          HowFact(fact, -1);
1011
1012          /* grade is temporal in case of arguments */
1013          if(dimension->argc > 1)
1014             fact->grade = GRD_UNKNOWN;
1015       }
1016       else
1017       {
1018          /* take average when multiple concluded */
1019          fact->grade = (fact->sumgrade += degree)/(fact->numgrade += 1);
1020       }
1021    }
1022    elif(dimension->slot.LAY)
1023    {
1024       OBJ_LAYER *layer;
1025
1026       layer = IDX2LAY(dimension->object);
1027
1028       if(dimension->slot.BKW)
1029          layer->slot.BACKWARD = (dimension->slot.NOT ? 0 : 1);
1030       elif(dimension->slot.FRW)
1031          layer->slot.FORWARD = (dimension->slot.NOT ? 0 : 1);
1032    }
1033    elif(dimension->slot.CON)
1034    {
1035       OBJ_CONDITION *condition;
1036
1037       condition = IDX2CON(dimension->object);
1038
1039       if(dimension->slot.CUT)
1040          condition->level = degree;
1041    }
1042    elif(dimension->slot.ACT)
1043    {
1044       OBJ_ACTION *action;
1045
1046       action = IDX2ACT(dimension->object);
1047
1048       if(dimension->slot.GRD)
1049          action->grade = degree;
1050       elif(dimension->slot.CUT)
1051          action->level = degree;
1052    }
1053    elif(dimension->slot.DIM)
1054    {
1055       OBJ_DIMENSION *dimension2;
1056
1057       dimension2 = IDX2DIM(dimension->object);
1058
1059       if(dimension->slot.GRD)
1060          dimension2->grade = degree;
1061       elif(dimension->slot.CUT)
1062          dimension2->level = degree;
1063    }
1064 }
1065
1066
1067 FUNCTION(static void AskFact,
1068    (OBJ_FACT *fact, int argc, char *argv[]),
1069    (fact, argc, argv),
1070    OBJ_FACT *fact;
1071    int argc;
1072    char *argv[];
1073 )
1074 {
1075    argv[0] = fact->symbolic;
1076
1077    Ask(argc, argv, &fact->grade);
1078 }
1079
1080
1081 FUNCTION(static void InformFact,
1082    (OBJ_FACT *fact, int argc, char *argv[]),
1083    (fact, argc, argv),
1084    OBJ_FACT *fact;
1085    int argc;
1086    char *argv[];
1087 )
1088 {
1089    float grade;
1090
1091    grade = fact->grade;
1092    argv[0] = fact->symbolic;
1093
1094    Inform(argc, argv, &grade);
1095 }
1096
1097
1098 FUNCTION(static void RunFact,
1099    (OBJ_FACT *fact, int argc, char *argv[]),
1100    (fact, argc, argv),
1101    OBJ_FACT *fact;
1102    int argc;
1103    char *argv[];
1104 )
1105 {
1106    argv[0] = fact->symbolic;
1107
1108    Run(fact->link, argc, argv, &fact->grade);
1109
1110    if(fact->grade < GRD_FALSE || GRD_TRUE < fact->grade)
1111       fact->grade = GRD_UNKNOWN;
1112 }
1113
1114
1115
1116