Changeset 278 for branches


Ignore:
Timestamp:
Oct 31, 2011 10:42:31 AM (7 years ago)
Author:
awalther
Message:

first working version of nlf

Location:
branches/NLF/ADOL-C/src
Files:
2 edited

Legend:

Unmodified
Added
Removed
  • branches/NLF/ADOL-C/src/adouble.cpp

    r262 r278  
    573573      {
    574574        upd = upd_resloc_inc_prod(a_loc,location,eq_plus_prod);
    575         ++ADOLC_CURRENT_TAPE_INFOS.num_eq_prod;
    576575      }
    577576    if (upd) {
     
    580579            ADOLC_DELETE_SCAYLOR(&ADOLC_GLOBAL_TAPE_VARS.store[a_loc]);
    581580        --ADOLC_CURRENT_TAPE_INFOS.numTays_Tape;
     581        ++ADOLC_CURRENT_TAPE_INFOS.num_eq_prod;
    582582    } else {
    583583        if (ADOLC_CURRENT_TAPE_INFOS.traceFlag) { // old: write_assign_a(location,a_loc);
     
    626626      {
    627627        upd = upd_resloc_inc_prod(a_loc,location,eq_min_prod);
    628         ++ADOLC_CURRENT_TAPE_INFOS.num_eq_prod;
    629628      }
    630629    if (upd) {
     
    633632            ADOLC_DELETE_SCAYLOR(&ADOLC_GLOBAL_TAPE_VARS.store[a_loc]);
    634633        --ADOLC_CURRENT_TAPE_INFOS.numTays_Tape;
     634        ++ADOLC_CURRENT_TAPE_INFOS.num_eq_prod;
    635635    } else {
    636636        if (ADOLC_CURRENT_TAPE_INFOS.traceFlag) { // old: write_assign_a(location,a_loc);
  • branches/NLF/ADOL-C/src/uni5_for.c

    r264 r278  
    1717
    1818           Uses the preprocessor to compile the 7 different object files
    19            with/without "keep" parameter:                     define _KEEP_
     19           with/without "keep" parameter:                   define _KEEP_
    2020
    2121 Copyright (c) Andrea Walther, Andreas Griewank, Andreas Kowarz,
     
    143143#if defined(_NLF_)
    144144
    145 void combine_2_domains(int res, int arg1, int arg2, locint **ind_dom);
     145typedef struct IndexElement {
     146    locint  entry;
     147    struct IndexElement* left;
     148    struct IndexElement* right;
     149}
     150IndexElement;
    146151
    147152#if defined(_TIGHT_)
     153
     154void traverse_nlf(IndexElement* nlf, char* inddomain);
     155void traverse_crs(IndexElement* fod2, IndexElement* csod);
     156void traverse_fod(IndexElement* tree, IndexElement* fod, int i, IndexElement* fod2);
     157void extend_nonlinearity_domain_unary2(char* inddomain, locint **nonl_dom, int num, int indcheck);
     158
     159
    148160#define GENERATED_FILENAME "nlf_forward_t"
    149161#endif
     
    151163#define GENERATED_FILENAME "nlf_forward_s"
    152164#endif
    153 typedef struct IndexElement {
    154     locint  entry;
    155     struct IndexElement* next;
    156 }
    157 IndexElement;
    158165#endif
    159166
     
    782789    int l=0;
    783790    int max_ind_dom;
    784 #if defined (_NLF_)
    785     IndexElement** csod;
    786     IndexElement*  temp;
    787     IndexElement*  temp1;
     791#if !defined(_NLF_)
     792    /* index domains */
     793    locint** ind_dom;
     794#else
     795    char *nlfdomain;
     796    char *nlfdomain1;
     797    locint* arg_index;
     798    IndexElement* csod;
     799    IndexElement* fod2;
     800    IndexElement* fod;
     801    IndexElement* nlf;
     802    IndexElement* temp;
     803    IndexElement* temp1;
    788804    locint entry;
    789805    int opind;
     
    838854#define T0res  T0temp
    839855#define T0arg  T0temp
    840 
    841     /* index domains */
    842     locint** ind_dom;
    843 #if defined(_NLF_)
    844     locint** nlf;
    845     locint* arg_index;
    846 #endif
    847856#else
    848857    double *dp_T0;
     
    10401049          }
    10411050#else
    1042         ind_dom = (locint **)  malloc(sizeof(locint*) * (ADOLC_CURRENT_TAPE_INFOS.stats[NUM_OPERATIONS]+ADOLC_CURRENT_TAPE_INFOS.stats[NUM_EQ_PROD]));
    1043 /*      nlf = (locint **)  malloc(sizeof(locint*) * (ADOLC_CURRENT_TAPE_INFOS.stats[NUM_OPERATIONS]+ADOLC_CURRENT_TAPE_INFOS.stats[NUM_EQ_PROD]));     */
     1051        fod = (struct IndexElement*) malloc(sizeof(struct IndexElement) * (ADOLC_CURRENT_TAPE_INFOS.stats[NUM_OPERATIONS]+ADOLC_CURRENT_TAPE_INFOS.stats[NUM_EQ_PROD]));
     1052        nlf = (struct IndexElement*) malloc(sizeof(struct IndexElement) * (ADOLC_CURRENT_TAPE_INFOS.stats[NUM_OPERATIONS]+ADOLC_CURRENT_TAPE_INFOS.stats[NUM_EQ_PROD]));
    10441053        arg_index = (locint *)  malloc(sizeof(locint) * (ADOLC_CURRENT_TAPE_INFOS.stats[NUM_MAX_LIVES]));
    10451054        opind = 0;
    10461055        max_ind_dom = ADOLC_CURRENT_TAPE_INFOS.stats[NUM_OPERATIONS]+ADOLC_CURRENT_TAPE_INFOS.stats[NUM_EQ_PROD];
    1047         csod = (struct IndexElement**) malloc(sizeof(struct IndexElement*) * indcheck);
     1056
     1057        csod = (struct IndexElement*) malloc(sizeof(struct IndexElement) * indcheck);
     1058        fod2 = (struct IndexElement*) malloc(sizeof(struct IndexElement) * indcheck);
     1059
    10481060        for(i=0;i<indcheck;i++)
    10491061          {
    1050             csod[i] = (struct IndexElement*) malloc(sizeof(struct IndexElement));
    1051             csod[i]->entry = 0;
    1052             csod[i]->next = NULL;
     1062            csod[i].entry = 0;
     1063            csod[i].left = NULL;
     1064            csod[i].right = NULL;
     1065            fod2[i].entry = -1;
     1066            fod2[i].left = NULL;
     1067            fod2[i].right = NULL;
    10531068          }
    10541069#endif
     
    11251140    while (operation !=end_of_tape) {
    11261141 
    1127 /*       printf(" op %d \n",operation); */
    11281142      switch (operation) {
    11291143
     
    12911305                copy_index_domain(res, arg, ind_dom);
    12921306#else
    1293 /*                 copy_index_domain(opind,arg_index[arg], ind_dom); */
    1294 /*                 copy_index_domain(opind,arg_index[arg], nlf); */
    12951307                arg_index[res] = arg_index[arg];               
    12961308#endif
     
    13221334                ind_dom[res][0]=0;
    13231335#else
    1324                 ind_dom[opind] = (locint *)  malloc(sizeof(locint) * 1);
    1325                 ind_dom[opind][0] = 0;
    1326 /*              nlf[opind] = (locint *)  malloc(sizeof(locint) * 1); */
    1327 /*              nlf[opind][0] = 0; */
     1336                fod[opind].entry = -1;
     1337                fod[opind].left = NULL;
     1338                fod[opind].right = NULL;
     1339                nlf[opind].entry = -1;
     1340                nlf[opind].left = NULL;
     1341                nlf[opind].right = NULL;
    13281342                arg_index[res] = opind++;               
    13291343#endif
     
    13531367                ind_dom[res][0]=0;
    13541368#else
    1355                 ind_dom[opind] = (locint *)  malloc(sizeof(locint) * 1);
    1356                 ind_dom[opind][0] = 0;
    1357 /*              nlf[opind] = (locint *)  malloc(sizeof(locint) * 1); */
    1358 /*              nlf[opind][0] = 0; */
     1369                fod[opind].entry = -1;
     1370                fod[opind].left = NULL;
     1371                fod[opind].right = NULL;
     1372                nlf[opind].entry = -1;
     1373                nlf[opind].left = NULL;
     1374                nlf[opind].right = NULL;
    13591375                arg_index[res] = opind++;               
    13601376#endif
     
    13841400                ind_dom[res][0]=0;
    13851401#else
    1386                 ind_dom[opind] = (locint *)  malloc(sizeof(locint) * 1);
    1387                 ind_dom[opind][0] = 0;
    1388 /*              nlf[opind] = (locint *)  malloc(sizeof(locint) * 1); */
    1389 /*              nlf[opind][0] = 0; */
     1402                fod[opind].entry = -1;
     1403                fod[opind].left = NULL;
     1404                fod[opind].right = NULL;
     1405                nlf[opind].entry = -1;
     1406                nlf[opind].left = NULL;
     1407                nlf[opind].right = NULL;
    13901408                arg_index[res] = opind++;               
    13911409#endif
     
    14171435                ind_dom[res][2] = indexi;
    14181436#else
    1419                 ind_dom[opind] = (locint *)  malloc(sizeof(locint) * 2);
    1420                 ind_dom[opind][0] = 1;
    1421                 ind_dom[opind][1] = opind;
    1422 /*              nlf[opind] = (locint *)  malloc(sizeof(locint) * 1); */
    1423 /*              nlf[opind][0] = 0; */
     1437                fod[opind].entry = indexi;
     1438                fod[opind].left = NULL;
     1439                fod[opind].right = NULL;
     1440                nlf[opind].entry = -1;
     1441                nlf[opind].left = NULL;
     1442                nlf[opind].right = NULL;
    14241443                arg_index[res] = opind++;               
    14251444#endif         
     
    14691488#if defined(_NLF_)
    14701489               
    1471 /*              for(l=1;l<nlf[arg_index[res]][0]+1;l++) */
    1472 /*                { */
    1473 /*                  int index = nlf[arg_index[res]][l]; */
    1474 /*                  for(ii=1;ii<ind_dom[index][0]+1;ii++) */
    1475 /*                    { */
    1476 /*                      index1 = ind_dom[index][ii]; */
    1477 /*                      for(jj=1;jj<ind_dom[index][0]+1;jj++) */
    1478 /*                        { */
    1479 /*                          temp1 = csod[index1]; */
    1480 /*                          temp = csod[index1]->next; */
    1481 /*                          num = csod[index1]->entry; */
    1482 /*                          i=0; */
    1483 /*                          do */
    1484 /*                            { */
    1485 /*                              if (temp==NULL) */
    1486 /*                                { */
    1487 /*                                  temp = (struct IndexElement*) malloc(sizeof(struct IndexElement)); */
    1488 /*                                  temp1->next = temp; */
    1489 /*                                  temp->entry = ind_dom[index][jj]; */
    1490 /*                                  temp->next = NULL; */
    1491 /*                                  csod[index1]->entry++; */
    1492 /*                                  i = 1; */
    1493 /*                                } */
    1494 /*                              else */
    1495 /*                                { */
    1496 /*                                  if (temp->entry < ind_dom[index][jj]) */
    1497 /*                                    { */
    1498 /*                                      temp1 = temp; */
    1499 /*                                      temp = temp->next; */
    1500 /*                                    } */
    1501 /*                                  else */
    1502 /*                                    { */
    1503 /*                                      if (temp->entry == ind_dom[index][jj]) */
    1504 /*                                        i = 1; */
    1505 /*                                      else */
    1506 /*                                        { */
    1507 /*                                          temp = (struct IndexElement*) malloc(sizeof(struct IndexElement)); */
    1508 /*                                          temp->entry = ind_dom[index][jj]; */
    1509 /*                                          csod[index1]->entry++; */
    1510 /*                                          temp->next = temp1->next; */
    1511 /*                                          temp1->next = temp; */
    1512 /*                                          i=1; */
    1513 /*                                        } */
    1514 /*                                    } */
    1515 /*                                } */
    1516 /*                            } */
    1517 /*                          while (i == 0); */
    1518 /*                        } */
    1519 /*                    } */
    1520 /*                } */
     1490                nlfdomain = (char*) calloc(opind+1,sizeof(char));
     1491                traverse_nlf(&nlf[arg_index[res]],nlfdomain);
     1492                for(i=1;i<opind;i++)
     1493                  {
     1494                    if (nlfdomain[i])
     1495                      {
     1496                        traverse_fod(&fod[i-1],fod, i-1,fod2);
     1497                      }
     1498                  }
     1499                free(nlfdomain);
    15211500#endif
    15221501#else
     
    15721551                merge_2_index_domains(res, arg, ind_dom);
    15731552#else
    1574                 combine_2_domains(opind, arg_index[res], arg_index[arg], ind_dom);
    1575 /*                 combine_2_domains(opind, arg_index[res], arg_index[arg], nlf); */
     1553                fod[opind].entry = -1;
     1554                fod[opind].left = &fod[arg_index[res]];
     1555                fod[opind].right = &fod[arg_index[arg]];
     1556                nlf[opind].entry = -1;
     1557                nlf[opind].left = &nlf[arg_index[res]];
     1558                nlf[opind].right = &nlf[arg_index[arg]];
    15761559                arg_index[res] = opind++;               
    15771560#endif
     
    16211604                merge_2_index_domains(res, arg, ind_dom);
    16221605#else
    1623                 combine_2_domains(opind, arg_index[res], arg_index[arg], ind_dom);
    1624 /*                 combine_2_domains(opind, arg_index[res], arg_index[arg], nlf); */
    1625                 arg_index[res] = opind++;               
     1606                fod[opind].entry = -1;
     1607                fod[opind].left = &fod[arg_index[res]];
     1608                fod[opind].right = &fod[arg_index[arg]];
     1609                nlf[opind].entry = -1;
     1610                nlf[opind].left = &nlf[arg_index[res]];
     1611                nlf[opind].right = &nlf[arg_index[arg]];       
    16261612#endif
    16271613#else
     
    16791665                merge_2_index_domains(res, arg, ind_dom);
    16801666#else
    1681                 combine_2_domains(opind, arg_index[res], arg_index[arg], ind_dom);
    1682 /*              nlf[opind] = (locint *)  malloc(sizeof(locint) * 2); */
    1683 /*              nlf[opind][0] = 1; */
    1684 /*              nlf[opind][1] = opind; */
     1667                fod[opind].entry = -1;
     1668                fod[opind].left = &fod[arg_index[res]];
     1669                fod[opind].right = &fod[arg_index[arg]];
     1670                nlf[opind].entry = opind;
     1671                nlf[opind].left = NULL;
     1672                nlf[opind].right = NULL;
    16851673                arg_index[res] = opind++;               
    16861674#endif
     
    17641752                combine_2_index_domains(res, arg1, arg2, ind_dom);
    17651753#else     
    1766                 combine_2_domains(opind, arg_index[arg1], arg_index[arg2], ind_dom);
    1767 /*                 combine_2_domains(opind, arg_index[arg1], arg_index[arg2], nlf); */
     1754                fod[opind].entry = -1;
     1755                fod[opind].left = &fod[arg_index[arg1]];
     1756                fod[opind].right = &fod[arg_index[arg2]];
     1757                nlf[opind].entry = -1;
     1758                nlf[opind].left = &nlf[arg_index[arg1]];
     1759                nlf[opind].right = &nlf[arg_index[arg2]];
    17681760                arg_index[res] = opind++;               
    17691761#endif
     
    18021794                copy_index_domain(res, arg, ind_dom);
    18031795#else
    1804 /*                 copy_index_domain(opind,arg_index[arg], ind_dom); */
    1805 /*                 copy_index_domain(opind,arg_index[arg], nlf); */
    18061796                arg_index[res] = arg_index[arg];
    18071797#endif
     
    18361826                combine_2_index_domains(res, arg1, arg2, ind_dom);
    18371827#else
    1838                 combine_2_domains(opind, arg_index[arg1], arg_index[arg2], ind_dom);
    1839 /*                 combine_2_domains(opind, arg_index[arg1], arg_index[arg2], nlf); */
     1828
     1829                fod[opind].entry = -1;
     1830                fod[opind].left = &fod[arg_index[arg1]];
     1831                fod[opind].right = &fod[arg_index[arg2]];
     1832                nlf[opind].entry = -1;
     1833                nlf[opind].left = &nlf[arg_index[arg1]];
     1834                nlf[opind].right = &nlf[arg_index[arg2]];
    18401835                arg_index[res] = opind++;               
    18411836#endif
     
    18741869                copy_index_domain(res, arg, ind_dom);
    18751870#else
    1876 /*                 copy_index_domain(opind,arg_index[arg], ind_dom); */
    1877 /*                 copy_index_domain(opind,arg_index[arg], nlf); */
    18781871                arg_index[res] = arg_index[arg];               
    18791872#endif
     
    19061899                combine_2_index_domains(res, arg1, arg2, ind_dom);
    19071900#else
    1908                 combine_2_domains(opind, arg_index[arg1], arg_index[arg2], ind_dom);
    1909 /*              nlf[opind] =  (locint *)  malloc(sizeof(locint) * 2);  */
    1910 /*              nlf[opind][0] = 1; */
    1911 /*              nlf[opind][1] = opind; */
     1901                fod[opind].entry = -1;
     1902                fod[opind].left = &fod[arg_index[arg1]];
     1903                fod[opind].right = &fod[arg_index[arg2]];
     1904                nlf[opind].entry = opind;
     1905                nlf[opind].left = NULL;
     1906                nlf[opind].right = NULL;
    19121907                arg_index[res] = opind++;               
    19131908#endif
     
    19681963                // operation: v = v+u*w
    19691964                // first step: z = u*w, index domains
    1970                 combine_2_domains(opind, arg_index[arg1], arg_index[arg2], ind_dom);
     1965                fod[opind].entry = -1;
     1966                fod[opind].left = &fod[arg_index[arg1]];
     1967                fod[opind].right = &fod[arg_index[arg2]];
    19711968                // first step: z = u*w, nlf
    1972 /*              nlf[opind] = (locint *)  malloc(sizeof(locint) * 2); */
    1973 /*              nlf[opind][0] = 1; */
    1974 /*              nlf[opind][1] = opind++; */
     1969                nlf[opind].entry = opind;
     1970                nlf[opind].left = NULL;
     1971                nlf[opind].right = NULL;
     1972                opind++;
    19751973                // second step: v = v+z, index domains
    1976                 combine_2_domains(opind, arg_index[res], opind-1,ind_dom);
     1974                fod[opind].entry = -1;
     1975                fod[opind].left = &fod[arg_index[res]];
     1976                fod[opind].right = &fod[opind-1];
    19771977                // second step: v = v+z, nlf
    1978 /*              nlf[opind] = (locint *)  malloc(sizeof(locint) * (nlf[arg_index[res]][0]+2)); */
    1979 /*              for(l=0;l<nlf[arg_index[res]][0]+1;l++) */
    1980 /*                nlf[opind][l] = nlf[arg_index[res]][l]; */
    1981 /*              nlf[opind][nlf[arg_index[res]][0]+1] = opind-1; */
    1982 /*              nlf[opind][0]++; */
     1978                nlf[opind].entry = -1;
     1979                nlf[opind].left = &nlf[arg_index[res]];
     1980                nlf[opind].right =  &nlf[opind-1];
    19831981                arg_index[res] = opind++;               
    19841982#endif
     
    20362034                merge_3_index_domains(res, arg1, arg2, ind_dom);
    20372035#else
    2038                 // operation: v = v+u*w
     2036                // operation: v = v-u*w
    20392037                // first step: z = u*w, index domains
    2040                 combine_2_domains(opind, arg_index[arg1], arg_index[arg2], ind_dom);
     2038                fod[opind].entry = -1;
     2039                fod[opind].left = &fod[arg_index[arg1]];
     2040                fod[opind].right = &fod[arg_index[arg2]];
    20412041                // first step: z = u*w, nlf
    2042 /*              nlf[opind] = (locint *)  malloc(sizeof(locint) * 2); */
    2043 /*              nlf[opind][0] = 1; */
    2044 /*              nlf[opind][1] = opind++; */
    2045                 // second step: v = v+z, index domains
    2046                 combine_2_domains(opind, arg_index[res], opind-1,ind_dom);
    2047                 // second step: v = v+z, nlf
    2048 /*              nlf[opind] = (locint *)  malloc(sizeof(locint) * (nlf[arg_index[res]][0]+2)); */
    2049 /*              for(l=0;l<nlf[arg_index[res]][0]+1;l++) */
    2050 /*                nlf[opind][l] = nlf[arg_index[res]][l]; */
    2051 /*              nlf[opind][nlf[arg_index[res]][0]+1] = opind-1; */
    2052 /*              nlf[opind][0]++; */
    2053                 arg_index[res] = opind++;               
     2042                nlf[opind].entry = opind;
     2043                nlf[opind].left = NULL;
     2044                nlf[opind].right = NULL;
     2045                opind++;
     2046                // second step: v = v-z, index domains
     2047                fod[opind].entry = -1;
     2048                fod[opind].left = &fod[arg_index[res]];
     2049                fod[opind].right = &fod[opind-1];
     2050                // second step: v = v-z, nlf
     2051                nlf[opind].entry = -1;
     2052                nlf[opind].left = &nlf[arg_index[res]];
     2053                nlf[opind].right =  &nlf[arg_index[opind-1]];
     2054                arg_index[res] = opind++;       
    20542055#endif
    20552056#if defined(_NONLIND_)
     
    21122113                copy_index_domain(res, arg, ind_dom);
    21132114#else
    2114 /*                 copy_index_domain(opind,arg_index[arg], ind_dom); */
    2115 /*                 copy_index_domain(opind,arg_index[arg], nlf); */
    21162115                arg_index[res] = arg_index[arg];               
    21172116#endif
     
    21542153                combine_2_index_domains(res, arg1, arg2, ind_dom);
    21552154#else
    2156                 combine_2_domains(opind, arg_index[arg1], arg_index[arg2], ind_dom);
    2157 /*              nlf[opind] = (locint *)  malloc(sizeof(locint) * 2); */
    2158 /*              nlf[opind][0] = 1; */
    2159 /*              nlf[opind][1] = opind; */
     2155                fod[opind].entry = -1;
     2156                fod[opind].left = &fod[arg_index[arg1]];
     2157                fod[opind].right = &fod[arg_index[arg2]];
     2158                nlf[opind].entry = opind;
     2159                nlf[opind].left = NULL;
     2160                nlf[opind].right = NULL;
    21602161                arg_index[res] = opind++;               
    21612162#endif
     
    22232224                copy_index_domain(res, arg, ind_dom);
    22242225#else
    2225 /*                 copy_index_domain(opind,arg_index[arg], ind_dom); */
    2226 /*                 copy_index_domain(opind,arg_index[arg], nlf); */
    22272226                arg_index[res] = arg_index[arg];               
    22282227#endif
     
    22812280                copy_index_domain(res, arg, ind_dom);
    22822281#else
    2283 /*                 copy_index_domain(opind,arg_index[arg], ind_dom); */
    2284 /*                 copy_index_domain(opind,arg_index[arg], nlf); */
    22852282                arg_index[res] = arg_index[arg];                           
    22862283#endif
     
    23112308                copy_index_domain(res, arg, ind_dom);
    23122309#else
    2313 /*                 copy_index_domain(opind,arg_index[arg], ind_dom); */
    2314 /*                 copy_index_domain(opind,arg_index[arg], nlf); */
    23152310                arg_index[res] = arg_index[arg];               
    23162311#endif
     
    23522347                copy_index_domain(res, arg, ind_dom);
    23532348#else
    2354 /*                 copy_index_domain(opind,arg_index[arg], ind_dom); */
    2355 /*                 copy_index_domain(opind,arg_index[arg], nlf); */
    2356                 arg_index[res] = arg_index[arg];               
     2349                fod[opind].entry = -1;
     2350                fod[opind].left = &fod[arg_index[arg]];
     2351                fod[opind].right = NULL;
     2352                nlf[opind].entry = opind;
     2353                nlf[opind].left = NULL;
     2354                nlf[opind].right = NULL;
     2355                arg_index[res] = opind++;               
    23572356#endif
    23582357#if defined(_NONLIND_)
     
    24142413                copy_index_domain(res, arg1, ind_dom);
    24152414#else
    2416 /*                 copy_index_domain(opind,arg_index[arg1], ind_dom); */
    2417 /*                 copy_index_domain(opind,arg_index[arg1], nlf); */
    2418                 arg_index[res] = arg_index[arg1];               
     2415                fod[opind].entry = -1;
     2416                fod[opind].left = &fod[arg_index[arg1]];
     2417                fod[opind].right = NULL;
     2418                nlf[opind].entry = opind;
     2419                nlf[opind].left = NULL;
     2420                nlf[opind].right = NULL;
     2421                arg_index[res] = opind++;               
    24192422#endif
    24202423#if defined(_NONLIND_)
     
    24862489                copy_index_domain(res, arg1, ind_dom);
    24872490#else
    2488 /*                 copy_index_domain(opind,arg_index[arg1], ind_dom); */
    2489 /*                 copy_index_domain(opind,arg_index[arg1], nlf); */
    2490                 arg_index[res] = arg_index[arg1];               
     2491                fod[opind].entry = -1;
     2492                fod[opind].left = &fod[arg_index[arg1]];
     2493                fod[opind].right = NULL;
     2494                nlf[opind].entry = opind;
     2495                nlf[opind].left = NULL;
     2496                nlf[opind].right = NULL;
     2497                arg_index[res] = opind++;               
    24912498#endif
    24922499#if defined(_NONLIND_)
     
    25552562                copy_index_domain(res, arg1, ind_dom);
    25562563#else
    2557 /*                 copy_index_domain(opind,arg_index[arg1], ind_dom); */
    2558 /*                 copy_index_domain(opind,arg_index[arg1], nlf); */
    2559                 arg_index[res] = arg_index[arg1];               
     2564                fod[opind].entry = -1;
     2565                fod[opind].left = &fod[arg_index[arg1]];
     2566                fod[opind].right = NULL;
     2567                nlf[opind].entry = opind;
     2568                nlf[opind].left = NULL;
     2569                nlf[opind].right = NULL;
     2570                arg_index[res] = opind++;               
    25602571#endif
    25612572#if defined(_NONLIND_)
     
    26162627                copy_index_domain(res, arg1, ind_dom);
    26172628#else
    2618 /*                 copy_index_domain(opind,arg_index[arg1], ind_dom); */
    2619 /*                 copy_index_domain(opind,arg_index[arg1], nlf); */
    2620                 arg_index[res] = arg_index[arg1];               
     2629                fod[opind].entry = -1;
     2630                fod[opind].left = &fod[arg_index[arg1]];
     2631                fod[opind].right = NULL;
     2632                nlf[opind].entry = opind;
     2633                nlf[opind].left = NULL;
     2634                nlf[opind].right = NULL;
     2635                arg_index[res] = opind++;               
    26212636#endif
    26222637#if defined(_NONLIND_)
     
    27152730                copy_index_domain(res, arg1, ind_dom);
    27162731#else
    2717 /*                 copy_index_domain(opind,arg_index[arg1], ind_dom); */
    2718 /*                 copy_index_domain(opind,arg_index[arg1], nlf); */
    2719                 arg_index[res] = arg_index[arg1];               
     2732                fod[opind].entry = -1;
     2733                fod[opind].left = &fod[arg_index[arg1]];
     2734                fod[opind].right = NULL;
     2735                nlf[opind].entry = opind;
     2736                nlf[opind].left = NULL;
     2737                nlf[opind].right = NULL;
     2738                arg_index[res] = opind++;               
    27202739#endif
    27212740#if defined(_NONLIND_)
     
    28162835                copy_index_domain(res, arg1, ind_dom);
    28172836#else
    2818 /*                 copy_index_domain(opind,arg_index[arg1], ind_dom); */
    2819 /*                 copy_index_domain(opind,arg_index[arg1], nlf); */
    2820                 arg_index[res] = arg_index[arg1];               
     2837                fod[opind].entry = -1;
     2838                fod[opind].left = &fod[arg_index[arg1]];
     2839                fod[opind].right = NULL;
     2840                nlf[opind].entry = opind;
     2841                nlf[opind].left = NULL;
     2842                nlf[opind].right = NULL;
     2843                arg_index[res] = opind++;               
    28212844#endif
    28222845#if defined(_NONLIND_)
     
    28772900                copy_index_domain(res, arg1, ind_dom);
    28782901#else
    2879 /*                 copy_index_domain(opind,arg_index[arg1], ind_dom); */
    2880 /*                 copy_index_domain(opind,arg_index[arg1], nlf); */
    2881                 arg_index[res] = arg_index[arg1];               
     2902                fod[opind].entry = -1;
     2903                fod[opind].left = &fod[arg_index[arg1]];
     2904                fod[opind].right = NULL;
     2905                nlf[opind].entry = opind;
     2906                nlf[opind].left = NULL;
     2907                nlf[opind].right = NULL;
     2908                arg_index[res] = opind++;               
    28822909#endif
    28832910#if defined(_NONLIND_)
     
    29602987                copy_index_domain(res, arg1, ind_dom);
    29612988#else
    2962 /*                 copy_index_domain(opind,arg_index[arg1], ind_dom); */
    2963 /*                 copy_index_domain(opind,arg_index[arg1], nlf); */
    2964                 arg_index[res] = arg_index[arg1];               
     2989                fod[opind].entry = -1;
     2990                fod[opind].left = &fod[arg_index[arg1]];
     2991                fod[opind].right = NULL;
     2992                nlf[opind].entry = opind;
     2993                nlf[opind].left = NULL;
     2994                nlf[opind].right = NULL;
     2995                arg_index[res] = opind++;               
    29652996#endif
    29662997#if defined(_NONLIND_)
     
    30643095                copy_index_domain(res, arg1, ind_dom);
    30653096#else
    3066 /*                 copy_index_domain(opind,arg_index[arg1], ind_dom); */
    3067 /*                 copy_index_domain(opind,arg_index[arg1], nlf); */
    3068                 arg_index[res] = arg_index[arg1];               
     3097                fod[opind].entry = -1;
     3098                fod[opind].left = &fod[arg_index[arg1]];
     3099                fod[opind].right = NULL;
     3100                nlf[opind].entry = opind;
     3101                nlf[opind].left = NULL;
     3102                nlf[opind].right = NULL;
     3103                arg_index[res] = opind++;               
    30693104#endif
    30703105#else
     
    31173152                copy_index_domain(res, arg, ind_dom);
    31183153#else
    3119 /*                 copy_index_domain(opind,arg_index[arg], ind_dom); */
    3120 /*                 copy_index_domain(opind,arg_index[arg], nlf); */
    3121                 arg_index[res] = arg_index[arg];               
     3154                fod[opind].entry = -1;
     3155                fod[opind].left = &fod[arg_index[arg]];
     3156                fod[opind].right = NULL;
     3157                nlf[opind].entry = opind;
     3158                nlf[opind].left = NULL;
     3159                nlf[opind].right = NULL;
     3160                arg_index[res] = opind++;               
    31223161#endif
    31233162#if defined(_NONLIND_)
     
    32013240                copy_index_domain(res, arg, ind_dom);
    32023241#else
    3203 /*                 copy_index_domain(opind,arg_index[arg], ind_dom); */
    3204 /*                 copy_index_domain(opind,arg_index[arg], nlf); */
    3205                 arg_index[res] = arg_index[arg];               
     3242                fod[opind].entry = -1;
     3243                fod[opind].left = &fod[arg_index[arg]];
     3244                fod[opind].right = NULL;
     3245                nlf[opind].entry = opind;
     3246                nlf[opind].left = NULL;
     3247                nlf[opind].right = NULL;
     3248                arg_index[res] = opind++;               
    32063249#endif
    32073250#if defined(_NONLIND_)
     
    33423385                copy_index_domain(res, arg, ind_dom);
    33433386#else
    3344 /*                 copy_index_domain(opind,arg_index[arg], ind_dom); */
    3345 /*                 copy_index_domain(opind,arg_index[arg], nlf); */
    3346                 arg_index[res] = arg_index[arg];               
     3387                fod[opind].entry = -1;
     3388                fod[opind].left = &fod[arg_index[arg]];
     3389                fod[opind].right = NULL;
     3390                nlf[opind].entry = opind;
     3391                nlf[opind].left = NULL;
     3392                nlf[opind].right = NULL;
     3393                arg_index[res] = opind++;               
    33473394#endif
    33483395#if defined(_NONLIND_)
     
    35133560                    if (dp_T0[arg1] < dp_T0[arg2])
    35143561                      {
    3515 /*                      copy_index_domain(opind,arg_index[arg1], ind_dom); */
    3516 /*                      copy_index_domain(opind,arg_index[arg1], nlf); */
    3517                         arg_index[res] = arg_index[arg1];
     3562                        fod[opind].entry = -1;
     3563                        fod[opind].left = &fod[arg_index[arg1]];
     3564                        fod[opind].right = NULL;
     3565                        nlf[opind].entry = -1;
     3566                        nlf[opind].left = &nlf[arg_index[arg1]];
     3567                        nlf[opind].right = NULL;
     3568                        arg_index[res] = opind++;               
    35183569                      }           
    35193570                    else {
    35203571                        if (dp_T0[arg1] > dp_T0[arg2])
    35213572                          {
    3522 /*                          copy_index_domain(opind,arg_index[arg2], ind_dom); */
    3523 /*                          copy_index_domain(opind,arg_index[arg2], nlf); */
    3524                             arg_index[res] = arg_index[arg2];
     3573                            fod[opind].entry = -1;
     3574                            fod[opind].left = &fod[arg_index[arg2]];
     3575                            fod[opind].right = NULL;
     3576                            nlf[opind].entry = -1;
     3577                            nlf[opind].left = &nlf[arg_index[arg2]];
     3578                            nlf[opind].right = NULL;
     3579                            arg_index[res] = opind++;           
     3580
    35253581                          }               
    35263582                        else
    35273583                          {
    3528                             combine_2_domains(opind, arg_index[arg1], arg_index[arg2], ind_dom);
    3529 /*                          combine_2_domains(opind, arg_index[arg1], arg_index[arg2], nlf); */
     3584                            fod[opind].entry = -1;
     3585                            fod[opind].left = &fod[arg_index[arg1]];
     3586                            fod[opind].right = &fod[arg_index[arg2]];
     3587                            nlf[opind].entry = -1;
     3588                            nlf[opind].left = &nlf[arg_index[arg1]];
     3589                            nlf[opind].right = &nlf[arg_index[arg2]];
     3590                            arg_index[res] = opind++;           
    35303591                          }
    35313592                    }
    35323593#else
    3533                             combine_2_domains(opind, arg_index[arg1], arg_index[arg2], ind_dom);
    3534 /*                          combine_2_domains(opind, arg_index[arg1], arg_index[arg2], nlf); */
    3535 #endif
    3536                 arg_index[res] = opind++;               
     3594                    fod[opind].entry = -1;
     3595                    fod[opind].left = &fod[arg_index[arg1]];
     3596                    fod[opind].right = &fod[arg_index[arg2]];
     3597                    nlf[opind].entry = -1;
     3598                    nlf[opind].left = &nlf[arg_index[arg1]];
     3599                    nlf[opind].right = &nlf[arg_index[arg2]];
     3600                    arg_index[res] = opind++;           
     3601                    arg_index[res] = opind++;           
     3602#endif
    35373603#endif
    35383604
     
    36563722                copy_index_domain(res, arg, ind_dom);
    36573723#else
    3658 /*                 copy_index_domain(opind,arg_index[arg], ind_dom); */
    3659 /*                 copy_index_domain(opind,arg_index[arg], nlf); */
    36603724                arg_index[res] = arg_index[arg];               
    36613725#endif
     
    37363800                copy_index_domain(res, arg, ind_dom);
    37373801#else
    3738 /*                 copy_index_domain(opind,arg_index[arg], ind_dom); */
    3739 /*                 copy_index_domain(opind,arg_index[arg], nlf); */
    37403802                arg_index[res] = arg_index[arg];               
    37413803#endif
     
    37693831                copy_index_domain(res, arg, ind_dom);
    37703832#else
    3771 /*                 copy_index_domain(opind,arg_index[arg], ind_dom); */
    3772 /*                 copy_index_domain(opind,arg_index[arg], nlf); */
    37733833                arg_index[res] = arg_index[arg];               
    37743834#endif
     
    38283888                    dp_T0[res] = dp_T0[arg1];
    38293889
    3830 /*                  copy_index_domain(opind,arg_index[arg1], ind_dom); */
    3831 /*                  copy_index_domain(opind,arg_index[arg1], nlf); */
    38323890                    arg_index[res] = arg_index[arg1];           
    38333891
     
    38383896                        MINDEC(ret_c,0);
    38393897                    dp_T0[res] = dp_T0[arg2];
    3840 /*                  copy_index_domain(opind,arg_index[arg2], ind_dom); */
    3841 /*                  copy_index_domain(opind,arg_index[arg2], nlf); */
    38423898                    arg_index[res] = arg_index[arg2];           
    38433899                }
    38443900
    38453901#else
    3846                 combine_2_domains(opind, arg_index[arg1], arg_index[arg2], ind_dom);
    3847 /*                 combine_2_domains(opind, arg_index[arg1], arg_index[arg2], nlf); */
    3848                 arg_index[res] = opind++;               
     3902               arg_index[res] = opind++;               
    38493903#endif
    38503904#endif
     
    39223976                copy_index_domain(res, arg1, ind_dom);
    39233977#else
    3924 /*                 copy_index_domain(opind,arg_index[arg1], ind_dom); */
    3925 /*                 copy_index_domain(opind,arg_index[arg1], nlf); */
    39263978                arg_index[res] = arg_index[arg1];               
    39273979#endif
     
    40994151        } /* endswitch */
    41004152
    4101 /* #if defined(_NLF_) */
    4102 /*       printf("ind\n"); */
    4103 /*       for(l=0;l<opind;l++) */
    4104 /*      { */
    4105 /*        printf(" %d : ",l); */
    4106 /*        for(i=1;i<ind_dom[l][0]+1;i++) */
    4107 /*          printf(" %d ",ind_dom[l][i]); */
    4108 /*        printf("\n"); */
    4109 /*      } */
    4110 /*       printf("nlf\n"); */
    4111 /*       for(l=0;l<opind;l++) */
    4112 /*      { */
    4113 /*        printf(" %d : ",l); */
    4114 /*        for(i=1;i<nlf[l][0]+1;i++) */
    4115 /*          printf(" %d ",nlf[l][i]); */
    4116 /*        printf("\n"); */
    4117 /*      } */
    4118 /* #endif */
     4153
    41194154        /* Read the next operation */
    41204155        operation=get_op_f();
     
    41674202    free(ind_dom);
    41684203#else
     4204
    41694205    for( i=0; i < indcheck; i++) {
    4170        crs[i] = (unsigned int*) malloc(sizeof(unsigned int) * (csod[i]->entry+1));
    4171        crs[i][0] = csod[i]->entry;
    4172        temp1 = csod[i];
    4173        temp  = csod[i]->next;
    4174        for(l=1; l < crs[i][0]+1; l++)
    4175          {
    4176            crs[i][l] = temp->entry;
    4177            free(temp1);
    4178            temp1 = temp;
    4179            temp = temp->next;
    4180          }
     4206      traverse_crs(&fod2[i],&csod[i]);
     4207      crs[i] = (unsigned int*) malloc(sizeof(unsigned int) * (csod[i].entry+1));
     4208      crs[i][0] = csod[i].entry;
     4209      temp = csod[i].left;
     4210      for( ii=1; ii <=csod[i].entry; ii++)
     4211        {
     4212          crs[i][ii] = temp->entry;
     4213          temp1 = temp->left;
     4214          free(temp);
     4215          temp = temp1;
     4216        }
    41814217    }
     4218
     4219    free(fod);
     4220    free(fod2);
     4221    free(nlf);
    41824222    free(csod);
    4183 
    4184     for(i=0;i<opind;i++)
    4185       {
    4186         free(ind_dom[i]);
    4187 /*      free(nlf[i]); */
    4188       }
    4189     free(ind_dom);
    4190 /*     free(nlf); */
    41914223    free(arg_index);
    41924224#endif
     
    44144446#endif
    44154447
    4416 /****************************************************************************/
    4417 
    4418 
    4419 /****************************************************************************/
    4420 
    44214448#if defined(_NLF_)
    44224449
     
    44294456#if defined(_TIGHT_)
    44304457
    4431 void combine_2_domains(int res, int arg1, int arg2, locint **dom) {
    4432 
    4433   int num1,num2, i,j,k,l;
    4434 
    4435 /*   printf("c2d %d %d %d \n",res,arg1,arg2); */
    4436   num1 = dom[arg1][0];
    4437   num2 = dom[arg2][0];
    4438 
    4439   dom[res] = (locint *)  malloc(sizeof(locint) * (num1+num2+1));
    4440 
    4441   i = 1;
    4442   j = 1;
    4443   k = 1;
    4444   num1 += 1;
    4445   num2 += 1;
    4446 
    4447   while ((i< num1) && (j < num2))
     4458void traverse_nlf(IndexElement* tree, char * nlfdomain)
     4459{
     4460
     4461  if (tree->left != NULL)
    44484462    {
    4449       if (dom[arg1][i] < dom[arg2][j])
     4463      traverse_nlf(tree->left, nlfdomain);
     4464      if (tree->right != NULL)
     4465        traverse_nlf(tree->right, nlfdomain);
     4466     }
     4467  else
     4468    {
     4469      nlfdomain[tree->entry+1] = 1;
     4470    }
     4471}
     4472
     4473void traverse_crs(IndexElement* tree,  IndexElement* csod)
     4474{
     4475
     4476  IndexElement *temp, *temp1;
     4477  int ii;
     4478
     4479  if (tree->left != NULL)
     4480      traverse_crs(tree->left, csod);
     4481  if (tree->right != NULL)
     4482          traverse_crs(tree->right, csod);
     4483  if (tree->entry+1)
     4484    {
     4485      temp = csod->left;
     4486      if (temp == NULL)
    44504487        {
    4451           dom[res][k] = dom[arg1][i];
    4452           i++; k++;
     4488          temp = (struct IndexElement*) malloc(sizeof(struct IndexElement));
     4489          temp->left = NULL;
     4490          temp->entry = tree->entry;
     4491          csod->entry++;
     4492          csod->left=temp;
    44534493        }
    44544494      else
    44554495        {
    4456           dom[res][k] = dom[arg2][j];
    4457           j++;k++;
    4458           if (dom[arg1][i] == dom[arg2][j-1])
    4459               i++;
     4496          while ((temp->entry < tree->entry) && (temp->left != NULL))
     4497            {
     4498              temp1 = temp;
     4499              temp = temp->left;
     4500            }
     4501          if (temp->left == NULL)
     4502            {
     4503              if(temp->entry < tree->entry)
     4504                {
     4505                  temp->left = (struct IndexElement*) malloc(sizeof(struct IndexElement));
     4506                  temp = temp->left;
     4507                  temp->left = NULL;
     4508                  temp->entry = tree->entry;
     4509                  csod->entry++;
     4510                }
     4511              if(temp->entry > tree->entry)
     4512                {
     4513                  temp->left = (struct IndexElement*) malloc(sizeof(struct IndexElement));
     4514                  temp->left->entry = temp->entry;
     4515                  temp->left->left = NULL;
     4516                  temp->entry = tree->entry;
     4517                  csod->entry++;
     4518                }
     4519            }
     4520          else
     4521            {
     4522              if (temp->entry > tree->entry)
     4523                {
     4524                  temp1 = (struct IndexElement*) malloc(sizeof(struct IndexElement));
     4525                  temp1->left = temp->left;
     4526                  temp1->entry = temp->entry;
     4527                  temp->entry = tree->entry;
     4528                  temp->left=temp1;
     4529                  csod->entry++;
     4530                }
     4531             
     4532            }
    44604533        }
    44614534    }
    4462 
    4463 
    4464   for(l=i;l<num1;l++)
     4535}
     4536
     4537void traverse_fod(IndexElement* tree,  IndexElement* fod,  int i, IndexElement* fod2)
     4538{
     4539  IndexElement *temp;
     4540
     4541  if (tree->left != NULL)
    44654542    {
    4466       dom[res][k] = dom[arg1][l];
    4467       k++;
     4543      traverse_fod(tree->left, fod, i, fod2);
     4544      if (tree->right != NULL)
     4545        {
     4546          traverse_fod(tree->right, fod, i, fod2);
     4547        }
     4548     }
     4549  else
     4550    {
     4551      temp = (struct IndexElement*) malloc(sizeof(struct IndexElement));
     4552      temp->right = &fod[i];
     4553      temp->left = fod2[tree->entry].left;
     4554      temp->entry= -1;
     4555      fod2[tree->entry].left = temp;
    44684556    }
    4469   for(l=j;l<num2;l++)
    4470     {
    4471       dom[res][k] = dom[arg2][l];
    4472       k++;
    4473     }
    4474   dom[res][0] = k-1;
    44754557}
    44764558
    44774559#endif
    44784560#endif
     4561
    44794562END_C_DECLS
Note: See TracChangeset for help on using the changeset viewer.