Changeset 279 for branches


Ignore:
Timestamp:
Nov 8, 2011 6:45:00 AM (7 years ago)
Author:
awalther
Message:

bug fixes here and there

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

Legend:

Unmodified
Added
Removed
  • branches/NLF/ADOL-C/src/uni5_for.c

    r278 r279  
    150150IndexElement;
    151151
     152typedef struct IndexElement_csod {
     153    locint  entry;
     154    struct IndexElement_csod* left;
     155}
     156IndexElement_csod;
     157
     158
    152159#if defined(_TIGHT_)
    153160
     161void free_tree(IndexElement* nlf, int num);
    154162void traverse_nlf(IndexElement* nlf, char* inddomain);
    155 void traverse_crs(IndexElement* fod2, IndexElement* csod);
    156 void traverse_fod(IndexElement* tree, IndexElement* fod, int i, IndexElement* fod2);
    157 void extend_nonlinearity_domain_unary2(char* inddomain, locint **nonl_dom, int num, int indcheck);
     163void traverse_crs(IndexElement* fod2, IndexElement_csod* csod, int num);
     164void traverse_fod(IndexElement* tree, IndexElement* fod, int i, IndexElement* fod2, int num);
     165void free_fod2(IndexElement* fod2);
    158166
    159167
     
    172180 */
    173181
    174 void extend_nonlinearity_domain_binary_step
    175 (int arg1, int arg2, locint **ind_dom, locint **nonl_dom);
    176 void extend_nonlinearity_domain_unary
    177 (int arg, locint **ind_dom, locint **nonl_dom);
    178 void extend_nonlinearity_domain_binary
    179 (int arg1, int arg2, locint **ind_dom, locint **nonl_dom);
    180 
     182typedef struct IndexElement {
     183    locint  entry;
     184    struct IndexElement* left;
     185    struct IndexElement* right;
     186}
     187IndexElement;
     188
     189typedef struct IndexElement_csod {
     190    locint  entry;
     191    struct IndexElement_csod* left;
     192}
     193IndexElement_csod;
    181194
    182195#if defined(_TIGHT_)
     196
     197void traverse_unary(IndexElement* fod, IndexElement* nonl_dom,  IndexElement* fodi, int num);
     198
    183199#define GENERATED_FILENAME "nonl_ind_forward_t"
    184200#endif
     
    789805    int l=0;
    790806    int max_ind_dom;
    791 #if !defined(_NLF_)
     807#if defined(_INDOPRO_)
    792808    /* index domains */
    793809    locint** ind_dom;
    794 #else
     810#endif
     811#if defined(_NONLIND_)
     812    /* nonlinear interaction domains */
     813    locint* arg_index;
     814    IndexElement* fod;
     815    IndexElement* nonl_dom;
     816    IndexElement_csod* sod;
     817    IndexElement_csod* temp;
     818    IndexElement_csod* temp1;
     819    int maxopind;
     820    int opind;
     821    int ii;
     822#endif
     823#if defined(_NLF_)
    795824    char *nlfdomain;
    796825    char *nlfdomain1;
    797826    locint* arg_index;
    798     IndexElement* csod;
     827    IndexElement_csod* csod;
     828    IndexElement_csod* temp;
     829    IndexElement_csod* temp1;
    799830    IndexElement* fod2;
    800831    IndexElement* fod;
    801832    IndexElement* nlf;
    802     IndexElement* temp;
    803     IndexElement* temp1;
    804833    locint entry;
    805834    int opind;
     835    int maxopind;
    806836    int index;
    807837    int index1;
     
    810840    int ii;
    811841    int jj;
    812 #endif
    813 #if defined(_NONLIND_)
    814     /* nonlinear interaction domains */
    815     locint** nonl_dom;
    816     locint*  temp;
    817     locint*  temp1;
    818842#endif
    819843#endif
     
    10361060#else                                                                /* INDOPRO */
    10371061#if defined(_INDO_)
    1038 #if !defined(_NLF_)
     1062#if defined(_INDOPRO_)
    10391063        ind_dom = (locint **)  malloc(sizeof(locint*) * ADOLC_CURRENT_TAPE_INFOS.stats[NUM_MAX_LIVES]);
    10401064        max_ind_dom = ADOLC_CURRENT_TAPE_INFOS.stats[NUM_MAX_LIVES];
     
    10481072            ind_dom[i][1] = NUMNNZ;
    10491073          }
    1050 #else
    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]));
     1074#endif
     1075#if defined(_NONLIND_)
     1076        maxopind=ADOLC_CURRENT_TAPE_INFOS.stats[NUM_OPERATIONS]+ADOLC_CURRENT_TAPE_INFOS.stats[NUM_EQ_PROD];
     1077        fod = (struct IndexElement*) malloc(sizeof(struct IndexElement) * maxopind);
     1078        nonl_dom = (struct IndexElement*) malloc(sizeof(struct IndexElement) * indcheck);
    10531079        arg_index = (locint *)  malloc(sizeof(locint) * (ADOLC_CURRENT_TAPE_INFOS.stats[NUM_MAX_LIVES]));
    10541080        opind = 0;
    1055         max_ind_dom = ADOLC_CURRENT_TAPE_INFOS.stats[NUM_OPERATIONS]+ADOLC_CURRENT_TAPE_INFOS.stats[NUM_EQ_PROD];
    1056 
    1057         csod = (struct IndexElement*) malloc(sizeof(struct IndexElement) * indcheck);
     1081        sod = (struct IndexElement_csod*) malloc(sizeof(struct IndexElement_csod) * indcheck);
     1082
     1083        for(i=0;i<indcheck;i++)
     1084          {
     1085            sod[i].entry = 0;
     1086            sod[i].left = NULL;
     1087            nonl_dom[i].entry = indcheck+2;
     1088            nonl_dom[i].left = NULL;
     1089            nonl_dom[i].right = NULL;
     1090          }
     1091#endif
     1092#if defined(_NLF_)
     1093        maxopind=ADOLC_CURRENT_TAPE_INFOS.stats[NUM_OPERATIONS]+ADOLC_CURRENT_TAPE_INFOS.stats[NUM_EQ_PROD];
     1094        fod = (struct IndexElement*) malloc(sizeof(struct IndexElement) * maxopind);
     1095        nlf = (struct IndexElement*) malloc(sizeof(struct IndexElement) * maxopind);
     1096        arg_index = (locint *)  malloc(sizeof(locint) * (ADOLC_CURRENT_TAPE_INFOS.stats[NUM_MAX_LIVES]));
     1097        opind = 0;
     1098
     1099        csod = (struct IndexElement_csod*) malloc(sizeof(struct IndexElement_csod) * indcheck);
    10581100        fod2 = (struct IndexElement*) malloc(sizeof(struct IndexElement) * indcheck);
    10591101
     
    10621104            csod[i].entry = 0;
    10631105            csod[i].left = NULL;
    1064             csod[i].right = NULL;
    1065             fod2[i].entry = -1;
     1106            fod2[i].entry = maxopind+2;
    10661107            fod2[i].left = NULL;
    10671108            fod2[i].right = NULL;
    10681109          }
    1069 #endif
    1070 
    1071 #if defined(_NONLIND_)
    1072     nonl_dom = (locint**) malloc(sizeof(locint*) * indcheck);
    1073     for(i=0;i<indcheck;i++){
    1074           nonl_dom[i] = (locint*) malloc(sizeof(locint)*(NUMNNZ+2));
    1075           nonl_dom[i][0]=0;
    1076           nonl_dom[i][1]=NUMNNZ;
    1077        }
    10781110#endif
    10791111
     
    13021334
    13031335#if defined(_INDO_)
    1304 #if !defined(_NLF_)
     1336#if defined(_INDOPRO_)
    13051337                copy_index_domain(res, arg, ind_dom);
    1306 #else
     1338#endif
     1339#if defined(_NONLIND_)
     1340                arg_index[res] = arg_index[arg];               
     1341#endif
     1342#if defined(_NLF_)
    13071343                arg_index[res] = arg_index[arg];               
    13081344#endif
     
    13311367
    13321368#if defined(_INDO_)
    1333 #if !defined(_NLF_)
     1369#if defined(_INDOPRO_)
    13341370                ind_dom[res][0]=0;
    1335 #else
    1336                 fod[opind].entry = -1;
     1371#endif
     1372#if defined(_NONLIND_)
     1373                fod[opind].entry = maxopind+2;
    13371374                fod[opind].left = NULL;
    13381375                fod[opind].right = NULL;
    1339                 nlf[opind].entry = -1;
     1376                arg_index[res] = opind++;               
     1377#endif
     1378#if defined(_NLF_)
     1379                fod[opind].entry = maxopind+2;
     1380                fod[opind].left = NULL;
     1381                fod[opind].right = NULL;
     1382                nlf[opind].entry = maxopind+2;
    13401383                nlf[opind].left = NULL;
    13411384                nlf[opind].right = NULL;
     
    13641407
    13651408#if defined(_INDO_)
    1366 #if !defined(_NLF_)
     1409#if defined(_INDOPRO_)
    13671410                ind_dom[res][0]=0;
    1368 #else
    1369                 fod[opind].entry = -1;
     1411#endif
     1412#if defined(_NONLIND_)
     1413                fod[opind].entry = maxopind+2;
    13701414                fod[opind].left = NULL;
    13711415                fod[opind].right = NULL;
    1372                 nlf[opind].entry = -1;
     1416                arg_index[res] = opind++;               
     1417#endif
     1418#if defined(_NLF_)
     1419                fod[opind].entry = maxopind+2;
     1420                fod[opind].left = NULL;
     1421                fod[opind].right = NULL;
     1422                nlf[opind].entry = maxopind+2;
    13731423                nlf[opind].left = NULL;
    13741424                nlf[opind].right = NULL;
     
    13971447
    13981448#if defined(_INDO_)
    1399 #if !defined(_NLF_)
     1449#if defined(_INDOPRO_)
    14001450                ind_dom[res][0]=0;
    1401 #else
    1402                 fod[opind].entry = -1;
     1451#endif
     1452#if defined(_NONLIND_)
     1453                fod[opind].entry = maxopind+2;
    14031454                fod[opind].left = NULL;
    14041455                fod[opind].right = NULL;
    1405                 nlf[opind].entry = -1;
     1456                arg_index[res] = opind++;               
     1457#endif
     1458#if defined(_NLF_)
     1459                fod[opind].entry = maxopind+2;
     1460                fod[opind].left = NULL;
     1461                fod[opind].right = NULL;
     1462                nlf[opind].entry = maxopind+2;
    14061463                nlf[opind].left = NULL;
    14071464                nlf[opind].right = NULL;
     
    14311488
    14321489#if defined(_INDO_)
    1433 #if !defined(_NLF_)
     1490#if defined(_INDOPRO_)
    14341491                ind_dom[res][0] = 1;
    14351492                ind_dom[res][2] = indexi;
    1436 #else
     1493#endif         
     1494#if defined(_NONLIND_)
    14371495                fod[opind].entry = indexi;
    14381496                fod[opind].left = NULL;
    14391497                fod[opind].right = NULL;
    1440                 nlf[opind].entry = -1;
     1498                arg_index[res] = opind++;               
     1499#endif         
     1500#if defined(_NLF_)
     1501                fod[opind].entry = indexi;
     1502                fod[opind].left = NULL;
     1503                fod[opind].right = NULL;
     1504                nlf[opind].entry = maxopind+2;
    14411505                nlf[opind].left = NULL;
    14421506                nlf[opind].right = NULL;
     
    14861550                }
    14871551#endif
     1552#if defined(_NONLIND_)
     1553#endif
    14881554#if defined(_NLF_)
    14891555               
    1490                 nlfdomain = (char*) calloc(opind+1,sizeof(char));
     1556                nlfdomain = (char*) calloc(maxopind+4,sizeof(char));
    14911557                traverse_nlf(&nlf[arg_index[res]],nlfdomain);
    1492                 for(i=1;i<opind;i++)
     1558                for(i=0;i<opind;i++)
    14931559                  {
    14941560                    if (nlfdomain[i])
    14951561                      {
    1496                         traverse_fod(&fod[i-1],fod, i-1,fod2);
     1562                        traverse_fod(&fod[i], fod, i, fod2, maxopind+1);
    14971563                      }
    14981564                  }
     
    15481614
    15491615#if defined(_INDO_)
    1550 #if !defined(_NLF_)
     1616#if defined(_INDOPRO_)
    15511617                merge_2_index_domains(res, arg, ind_dom);
    1552 #else
    1553                 fod[opind].entry = -1;
     1618#endif
     1619#if defined(_NONLIND_)
     1620                fod[opind].entry = maxopind+2;
    15541621                fod[opind].left = &fod[arg_index[res]];
    15551622                fod[opind].right = &fod[arg_index[arg]];
    1556                 nlf[opind].entry = -1;
     1623                arg_index[res] = opind++;               
     1624#endif
     1625#if defined(_NLF_)
     1626                fod[opind].entry = maxopind+2;
     1627                fod[opind].left = &fod[arg_index[res]];
     1628                fod[opind].right = &fod[arg_index[arg]];
     1629                nlf[opind].entry = maxopind+2;
    15571630                nlf[opind].left = &nlf[arg_index[res]];
    15581631                nlf[opind].right = &nlf[arg_index[arg]];
     
    16011674
    16021675#if defined(_INDO_)
    1603 #if !defined(_NLF_)
     1676#if defined(_INDOPRO_)
    16041677                merge_2_index_domains(res, arg, ind_dom);
    1605 #else
    1606                 fod[opind].entry = -1;
     1678#endif
     1679#if defined(_NONLIND_)
     1680                fod[opind].entry = maxopind+2;
    16071681                fod[opind].left = &fod[arg_index[res]];
    16081682                fod[opind].right = &fod[arg_index[arg]];
    1609                 nlf[opind].entry = -1;
     1683                arg_index[res] = opind++;               
     1684#endif
     1685#if defined(_NLF_)
     1686                fod[opind].entry = maxopind+2;
     1687                fod[opind].left = &fod[arg_index[res]];
     1688                fod[opind].right = &fod[arg_index[arg]];
     1689                nlf[opind].entry = maxopind+2;
    16101690                nlf[opind].left = &nlf[arg_index[res]];
    16111691                nlf[opind].right = &nlf[arg_index[arg]];       
     1692                arg_index[res] = opind++;               
    16121693#endif
    16131694#else
     
    16621743
    16631744#if defined(_INDO_)
    1664 #if !defined(_NLF_)
     1745#if defined(_INDOPRO_)
    16651746                merge_2_index_domains(res, arg, ind_dom);
    1666 #else
    1667                 fod[opind].entry = -1;
     1747#endif
     1748#if defined(_NONLIND_)
     1749                fod[opind].entry = maxopind+2;
     1750                fod[opind].left = &fod[arg_index[res]];
     1751                fod[opind].right = &fod[arg_index[arg]];
     1752                traverse_unary(&fod[arg_index[res]], nonl_dom, &fod[opind], indcheck+1);
     1753                traverse_unary(&fod[arg_index[arg]], nonl_dom, &fod[opind], indcheck+1);
     1754                arg_index[res] = opind++;               
     1755#endif
     1756#if defined(_NLF_)
     1757                fod[opind].entry = maxopind+2;
    16681758                fod[opind].left = &fod[arg_index[res]];
    16691759                fod[opind].right = &fod[arg_index[arg]];
     
    16721762                nlf[opind].right = NULL;
    16731763                arg_index[res] = opind++;               
    1674 #endif
    1675 #if defined(_NONLIND_)
    1676                 extend_nonlinearity_domain_binary(res, arg, ind_dom, nonl_dom);
    16771764#endif
    16781765#else
     
    17491836
    17501837#if defined(_INDO_)
    1751 #if !defined(_NLF_)
     1838#if defined(_INDOPRO_)
    17521839                combine_2_index_domains(res, arg1, arg2, ind_dom);
    1753 #else     
    1754                 fod[opind].entry = -1;
     1840#endif     
     1841#if defined(_NONLIND_)
     1842                fod[opind].entry = maxopind+2;
    17551843                fod[opind].left = &fod[arg_index[arg1]];
    17561844                fod[opind].right = &fod[arg_index[arg2]];
    1757                 nlf[opind].entry = -1;
     1845                arg_index[res] = opind++;               
     1846#endif
     1847#if defined(_NLF_)
     1848                fod[opind].entry = maxopind+2;
     1849                fod[opind].left = &fod[arg_index[arg1]];
     1850                fod[opind].right = &fod[arg_index[arg2]];
     1851                nlf[opind].entry = maxopind+2;
    17581852                nlf[opind].left = &nlf[arg_index[arg1]];
    17591853                nlf[opind].right = &nlf[arg_index[arg2]];
     
    17911885
    17921886#if defined(_INDO_)
    1793 #if !defined(_NLF_)
     1887#if defined(_INDOPRO_)
    17941888                copy_index_domain(res, arg, ind_dom);
    1795 #else
     1889#endif
     1890#if defined(_NONLIND_)
     1891                arg_index[res] = arg_index[arg];
     1892#endif
     1893#if defined(_NLF_)
    17961894                arg_index[res] = arg_index[arg];
    17971895#endif
     
    18231921
    18241922#if defined(_INDO_)
    1825 #if !defined(_NLF_)
     1923#if defined(_INDOPRO_)
    18261924                combine_2_index_domains(res, arg1, arg2, ind_dom);
    1827 #else
    1828 
    1829                 fod[opind].entry = -1;
     1925#endif
     1926#if defined(_NONLIND_)
     1927                fod[opind].entry = maxopind+2;
    18301928                fod[opind].left = &fod[arg_index[arg1]];
    18311929                fod[opind].right = &fod[arg_index[arg2]];
    1832                 nlf[opind].entry = -1;
     1930                arg_index[res] = opind++;               
     1931#endif
     1932#if defined(_NLF_)
     1933                fod[opind].entry = maxopind+2;
     1934                fod[opind].left = &fod[arg_index[arg1]];
     1935                fod[opind].right = &fod[arg_index[arg2]];
     1936                nlf[opind].entry = maxopind+2;
    18331937                nlf[opind].left = &nlf[arg_index[arg1]];
    18341938                nlf[opind].right = &nlf[arg_index[arg2]];
     
    18661970
    18671971#if defined(_INDO_)
    1868 #if !defined(_NLF_)
     1972#if defined(_INDOPRO_)
    18691973                copy_index_domain(res, arg, ind_dom);
    1870 #else
     1974#endif
     1975#if defined(_NONLIND_)
     1976                arg_index[res] = arg_index[arg];               
     1977#endif
     1978#if defined(_NLF_)
    18711979                arg_index[res] = arg_index[arg];               
    18721980#endif
     
    18962004
    18972005#if defined(_INDO_)
    1898 #if !defined(_NLF_)
     2006#if defined(_INDOPRO_)
    18992007                combine_2_index_domains(res, arg1, arg2, ind_dom);
    1900 #else
    1901                 fod[opind].entry = -1;
     2008#endif
     2009#if defined(_NONLIND_)
     2010                fod[opind].entry = maxopind+2;
     2011                fod[opind].left = &fod[arg_index[arg1]];
     2012                fod[opind].right = &fod[arg_index[arg2]];
     2013                traverse_unary(&fod[arg_index[arg1]], nonl_dom, &fod[opind], indcheck+1);
     2014                traverse_unary(&fod[arg_index[arg2]], nonl_dom, &fod[opind], indcheck+1);
     2015
     2016                arg_index[res] = opind++;               
     2017#endif
     2018#if defined(_NLF_)
     2019                fod[opind].entry = maxopind+2;
    19022020                fod[opind].left = &fod[arg_index[arg1]];
    19032021                fod[opind].right = &fod[arg_index[arg2]];
     
    19062024                nlf[opind].right = NULL;
    19072025                arg_index[res] = opind++;               
    1908 #endif
    1909 #if defined(_NONLIND_)
    1910                 extend_nonlinearity_domain_binary(arg1, arg2, ind_dom, nonl_dom);
    19112026#endif
    19122027#else
     
    19582073
    19592074#if defined(_INDO_)
    1960 #if !defined(_NLF_)
     2075#if defined(_INDOPRO_)
    19612076                merge_3_index_domains(res, arg1, arg2, ind_dom);
    1962 #else
     2077#endif
     2078#if defined(_NONLIND_)
    19632079                // operation: v = v+u*w
    19642080                // first step: z = u*w, index domains
    1965                 fod[opind].entry = -1;
     2081                fod[opind].entry = maxopind+2;
     2082                fod[opind].left = &fod[arg_index[arg1]];
     2083                fod[opind].right = &fod[arg_index[arg2]];
     2084                // first step: z = u*w,
     2085                traverse_unary(&fod[arg_index[arg1]], nonl_dom, &fod[opind], indcheck+1);
     2086                traverse_unary(&fod[arg_index[arg2]], nonl_dom, &fod[opind], indcheck+1);
     2087                opind++;
     2088                // second step: v = v+z, index domains
     2089                fod[opind].entry = maxopind+2;
     2090                fod[opind].left = &fod[arg_index[res]];
     2091                fod[opind].right = &fod[opind-1];
     2092                // second step: v = v+z,
     2093                arg_index[res] = opind++;               
     2094#endif
     2095#if defined(_NLF_)
     2096                // operation: v = v+u*w
     2097                // first step: z = u*w, index domains
     2098                fod[opind].entry = maxopind+2;
    19662099                fod[opind].left = &fod[arg_index[arg1]];
    19672100                fod[opind].right = &fod[arg_index[arg2]];
     
    19722105                opind++;
    19732106                // second step: v = v+z, index domains
    1974                 fod[opind].entry = -1;
     2107                fod[opind].entry = maxopind+2;
    19752108                fod[opind].left = &fod[arg_index[res]];
    19762109                fod[opind].right = &fod[opind-1];
    19772110                // second step: v = v+z, nlf
    1978                 nlf[opind].entry = -1;
     2111                nlf[opind].entry = maxopind+2;
    19792112                nlf[opind].left = &nlf[arg_index[res]];
    19802113                nlf[opind].right =  &nlf[opind-1];
    19812114                arg_index[res] = opind++;               
    1982 #endif
    1983 #if defined(_NONLIND_)
    1984                 extend_nonlinearity_domain_binary(arg1, arg2, ind_dom, nonl_dom);
    19852115#endif
    19862116#else
     
    20312161
    20322162#if defined(_INDO_)
    2033 #if !defined(_NLF_)
     2163#if defined(_INDOPRO_)
    20342164                merge_3_index_domains(res, arg1, arg2, ind_dom);
    2035 #else
     2165#endif
     2166#if defined(_NONLIND_)
    20362167                // operation: v = v-u*w
    20372168                // first step: z = u*w, index domains
    2038                 fod[opind].entry = -1;
     2169                fod[opind].entry = maxopind+2;
     2170                fod[opind].left = &fod[arg_index[arg1]];
     2171                fod[opind].right = &fod[arg_index[arg2]];
     2172                // first step: z = u*w,
     2173                traverse_unary(&fod[arg_index[arg1]], nonl_dom, &fod[opind], indcheck+1);
     2174                traverse_unary(&fod[arg_index[arg2]], nonl_dom, &fod[opind], indcheck+1);
     2175                opind++;
     2176                // second step: v = v-z, index domains
     2177                fod[opind].entry = maxopind+2;
     2178                fod[opind].left = &fod[arg_index[res]];
     2179                fod[opind].right = &fod[opind-1];
     2180                // second step: v = v-z,
     2181                arg_index[res] = opind++;       
     2182#endif
     2183#if defined(_NLF_)
     2184                // operation: v = v-u*w
     2185                // first step: z = u*w, index domains
     2186                fod[opind].entry = maxopind+2;
    20392187                fod[opind].left = &fod[arg_index[arg1]];
    20402188                fod[opind].right = &fod[arg_index[arg2]];
     
    20452193                opind++;
    20462194                // second step: v = v-z, index domains
    2047                 fod[opind].entry = -1;
     2195                fod[opind].entry = maxopind+2;
    20482196                fod[opind].left = &fod[arg_index[res]];
    20492197                fod[opind].right = &fod[opind-1];
    20502198                // second step: v = v-z, nlf
    2051                 nlf[opind].entry = -1;
     2199                nlf[opind].entry = maxopind+2;
    20522200                nlf[opind].left = &nlf[arg_index[res]];
    20532201                nlf[opind].right =  &nlf[arg_index[opind-1]];
    20542202                arg_index[res] = opind++;       
    2055 #endif
    2056 #if defined(_NONLIND_)
    2057                 extend_nonlinearity_domain_binary(arg1, arg2, ind_dom, nonl_dom);
    20582203#endif
    20592204#else
     
    21102255
    21112256#if defined(_INDO_)
    2112 #if !defined(_NLF_)
     2257#if defined(_INDOPRO_)
    21132258                copy_index_domain(res, arg, ind_dom);
    2114 #else
     2259#endif
     2260#if defined(_NONLIND_)
     2261                arg_index[res] = arg_index[arg];               
     2262#endif
     2263#if defined(_NLF_)
    21152264                arg_index[res] = arg_index[arg];               
    21162265#endif
     
    21502299
    21512300#if defined(_INDO_)
    2152 #if !defined(_NLF_)
     2301#if defined(_INDOPRO_)
    21532302                combine_2_index_domains(res, arg1, arg2, ind_dom);
    2154 #else
    2155                 fod[opind].entry = -1;
     2303#endif
     2304#if defined(_NONLIND_)
     2305                fod[opind].entry = maxopind+2;
     2306                fod[opind].left = &fod[arg_index[arg1]];
     2307                fod[opind].right = &fod[arg_index[arg2]];
     2308                traverse_unary(&fod[arg_index[arg1]], nonl_dom, &fod[arg_index[arg2]], indcheck+1);
     2309                traverse_unary(&fod[arg_index[arg2]], nonl_dom, &fod[opind], indcheck+1);
     2310                arg_index[res] = opind++;               
     2311#endif
     2312#if defined(_NLF_)
     2313                fod[opind].entry = maxopind+2;
    21562314                fod[opind].left = &fod[arg_index[arg1]];
    21572315                fod[opind].right = &fod[arg_index[arg2]];
     
    21602318                nlf[opind].right = NULL;
    21612319                arg_index[res] = opind++;               
    2162 #endif
    2163 #if defined(_NONLIND_)
    2164                 extend_nonlinearity_domain_binary(arg1, arg2, ind_dom, nonl_dom);
    2165                 extend_nonlinearity_domain_unary(arg2, ind_dom, nonl_dom);
    21662320#endif
    21672321#else
     
    22212375
    22222376#if defined(_INDO_)
    2223 #if !defined(_NLF_)
     2377#if defined(_INDOPRO_)
    22242378                copy_index_domain(res, arg, ind_dom);
    2225 #else
    2226                 arg_index[res] = arg_index[arg];               
    22272379#endif
    22282380#if defined(_NONLIND_)
    2229                 extend_nonlinearity_domain_unary(arg, ind_dom, nonl_dom);
     2381                fod[opind].entry = maxopind+2;
     2382                fod[opind].left = &fod[arg_index[arg]];
     2383                fod[opind].right = NULL;
     2384                traverse_unary(&fod[opind], nonl_dom, &fod[opind], indcheck+1);
     2385                arg_index[res] = opind++;               
     2386#endif
     2387#if defined(_NLF_)
     2388                fod[opind].entry = maxopind+2;
     2389                fod[opind].left = &fod[arg_index[arg]];
     2390                fod[opind].right = NULL;
     2391                nlf[opind].entry = opind;
     2392                nlf[opind].left = NULL;
     2393                nlf[opind].right = NULL;
     2394                arg_index[res] = opind++;               
    22302395#endif
    22312396#else
     
    22772442
    22782443#if defined(_INDO_)
    2279 #if !defined(_NLF_)
     2444#if defined(_INDOPRO_)
    22802445                copy_index_domain(res, arg, ind_dom);
    2281 #else
     2446#endif
     2447#if defined(_NONLIND_)
     2448                arg_index[res] = arg_index[arg];                           
     2449#endif
     2450#if defined(_NLF_)
    22822451                arg_index[res] = arg_index[arg];                           
    22832452#endif
     
    23052474
    23062475#if defined(_INDO_)
    2307 #if !defined(_NLF_)
     2476#if defined(_INDOPRO_)
    23082477                copy_index_domain(res, arg, ind_dom);
    2309 #else
    2310                 arg_index[res] = arg_index[arg];               
     2478#endif
     2479#if defined(_NONLIND_)
     2480                arg_index[res] = arg_index[arg];                           
     2481#endif
     2482#if defined(_NLF_)
     2483                arg_index[res] = arg_index[arg];                           
    23112484#endif
    23122485#else
     
    23442517
    23452518#if defined(_INDO_)
    2346 #if !defined(_NLF_)
     2519#if defined(_INDOPRO_)
    23472520                copy_index_domain(res, arg, ind_dom);
    2348 #else
    2349                 fod[opind].entry = -1;
     2521#endif
     2522#if defined(_NONLIND_)
     2523                fod[opind].entry = maxopind+2;
     2524                fod[opind].left = &fod[arg_index[arg]];
     2525                fod[opind].right = NULL;
     2526                traverse_unary(&fod[opind], nonl_dom, &fod[opind], indcheck+1);
     2527                arg_index[res] = opind++;               
     2528#endif
     2529#if defined(_NLF_)
     2530                fod[opind].entry = maxopind+2;
    23502531                fod[opind].left = &fod[arg_index[arg]];
    23512532                fod[opind].right = NULL;
     
    23542535                nlf[opind].right = NULL;
    23552536                arg_index[res] = opind++;               
    2356 #endif
    2357 #if defined(_NONLIND_)
    2358                 extend_nonlinearity_domain_unary(arg, ind_dom, nonl_dom);
    23592537#endif
    23602538#else
     
    24102588
    24112589#if defined(_INDO_)
    2412 #if !defined(_NLF_)
     2590#if defined(_INDOPRO_)
    24132591                copy_index_domain(res, arg1, ind_dom);
    2414 #else
    2415                 fod[opind].entry = -1;
     2592#endif
     2593#if defined(_NONLIND_)
     2594                fod[opind].entry = maxopind+2;
     2595                fod[opind].left = &fod[arg_index[arg1]];
     2596                fod[opind].right = NULL;
     2597                traverse_unary(&fod[opind], nonl_dom, &fod[opind], indcheck+1);
     2598                arg_index[res] = opind++;               
     2599#endif
     2600#if defined(_NLF_)
     2601                fod[opind].entry = maxopind+2;
    24162602                fod[opind].left = &fod[arg_index[arg1]];
    24172603                fod[opind].right = NULL;
     
    24202606                nlf[opind].right = NULL;
    24212607                arg_index[res] = opind++;               
    2422 #endif
    2423 #if defined(_NONLIND_)
    2424                 extend_nonlinearity_domain_unary(arg1, ind_dom, nonl_dom);
    24252608#endif
    24262609#else
     
    24862669
    24872670#if defined(_INDO_)
    2488 #if !defined(_NLF_)
     2671#if defined(_INDOPRO_)
    24892672                copy_index_domain(res, arg1, ind_dom);
    2490 #else
    2491                 fod[opind].entry = -1;
     2673#endif
     2674#if defined(_NONLIND_)
     2675                fod[opind].entry = maxopind+2;
     2676                fod[opind].left = &fod[arg_index[arg1]];
     2677                fod[opind].right = NULL;
     2678                traverse_unary(&fod[opind], nonl_dom, &fod[opind], indcheck+1);
     2679                arg_index[res] = opind++;               
     2680#endif
     2681#if defined(_NLF_)
     2682                fod[opind].entry = maxopind+2;
    24922683                fod[opind].left = &fod[arg_index[arg1]];
    24932684                fod[opind].right = NULL;
     
    24962687                nlf[opind].right = NULL;
    24972688                arg_index[res] = opind++;               
    2498 #endif
    2499 #if defined(_NONLIND_)
    2500                 extend_nonlinearity_domain_unary(arg1, ind_dom, nonl_dom);
    25012689#endif
    25022690#else
     
    25592747
    25602748#if defined(_INDO_)
    2561 #if !defined(_NLF_)
     2749#if defined(_INDOPRO_)
    25622750                copy_index_domain(res, arg1, ind_dom);
    2563 #else
    2564                 fod[opind].entry = -1;
     2751#endif
     2752#if defined(_NONLIND_)
     2753                fod[opind].entry = maxopind+2;
     2754                fod[opind].left = &fod[arg_index[arg1]];
     2755                fod[opind].right = NULL;
     2756                traverse_unary(&fod[opind], nonl_dom, &fod[opind], indcheck+1);
     2757                arg_index[res] = opind++;               
     2758#endif
     2759#if defined(_NLF_)
     2760                fod[opind].entry = maxopind+2;
    25652761                fod[opind].left = &fod[arg_index[arg1]];
    25662762                fod[opind].right = NULL;
     
    25692765                nlf[opind].right = NULL;
    25702766                arg_index[res] = opind++;               
    2571 #endif
    2572 #if defined(_NONLIND_)
    2573                 extend_nonlinearity_domain_unary(arg1, ind_dom, nonl_dom);
    25742767#endif
    25752768#else
     
    26242817
    26252818#if defined(_INDO_)
    2626 #if !defined(_NLF_)
     2819#if defined(_INDOPRO_)
    26272820                copy_index_domain(res, arg1, ind_dom);
    2628 #else
    2629                 fod[opind].entry = -1;
     2821#endif
     2822#if defined(_NONLIND_)
     2823                fod[opind].entry = maxopind+2;
     2824                fod[opind].left = &fod[arg_index[arg1]];
     2825                fod[opind].right = NULL;
     2826                traverse_unary(&fod[opind], nonl_dom, &fod[opind], indcheck+1);
     2827                arg_index[res] = opind++;               
     2828#endif
     2829#if defined(_NLF_)
     2830                fod[opind].entry = maxopind+2;
    26302831                fod[opind].left = &fod[arg_index[arg1]];
    26312832                fod[opind].right = NULL;
     
    26342835                nlf[opind].right = NULL;
    26352836                arg_index[res] = opind++;               
    2636 #endif
    2637 #if defined(_NONLIND_)
    2638                 extend_nonlinearity_domain_unary(arg1, ind_dom, nonl_dom);
    26392837#endif
    26402838#else
     
    27272925
    27282926#if defined(_INDO_)
    2729 #if !defined(_NLF_)
     2927#if defined(_INDOPRO_)
    27302928                copy_index_domain(res, arg1, ind_dom);
    2731 #else
    2732                 fod[opind].entry = -1;
     2929#endif
     2930#if defined(_NONLIND_)
     2931                fod[opind].entry = maxopind+2;
     2932                fod[opind].left = &fod[arg_index[arg1]];
     2933                fod[opind].right = NULL;
     2934                traverse_unary(&fod[opind], nonl_dom, &fod[opind], indcheck+1);
     2935                arg_index[res] = opind++;               
     2936#endif
     2937#if defined(_NLF_)
     2938                fod[opind].entry = maxopind+2;
    27332939                fod[opind].left = &fod[arg_index[arg1]];
    27342940                fod[opind].right = NULL;
     
    27372943                nlf[opind].right = NULL;
    27382944                arg_index[res] = opind++;               
    2739 #endif
    2740 #if defined(_NONLIND_)
    2741                 extend_nonlinearity_domain_unary(arg1, ind_dom, nonl_dom);
    27422945#endif
    27432946#else
     
    28323035
    28333036#if defined(_INDO_)
    2834 #if !defined(_NLF_)
     3037#if defined(_INDOPRO_)
    28353038                copy_index_domain(res, arg1, ind_dom);
    2836 #else
    2837                 fod[opind].entry = -1;
     3039#endif
     3040#if defined(_NONLIND_)
     3041                fod[opind].entry = maxopind+2;
     3042                fod[opind].left = &fod[arg_index[arg1]];
     3043                fod[opind].right = NULL;
     3044                traverse_unary(&fod[opind], nonl_dom, &fod[opind], indcheck+1);
     3045                arg_index[res] = opind++;               
     3046#endif
     3047#if defined(_NLF_)
     3048                fod[opind].entry = maxopind+2;
    28383049                fod[opind].left = &fod[arg_index[arg1]];
    28393050                fod[opind].right = NULL;
     
    28423053                nlf[opind].right = NULL;
    28433054                arg_index[res] = opind++;               
    2844 #endif
    2845 #if defined(_NONLIND_)
    2846                 extend_nonlinearity_domain_unary(arg1, ind_dom, nonl_dom);
    28473055#endif
    28483056#else
     
    28973105
    28983106#if defined(_INDO_)
    2899 #if !defined(_NLF_)
     3107#if defined(_INDOPRO_)
    29003108                copy_index_domain(res, arg1, ind_dom);
    2901 #else
    2902                 fod[opind].entry = -1;
     3109#endif
     3110#if defined(_NONLIND_)
     3111                fod[opind].entry = maxopind+2;
     3112                fod[opind].left = &fod[arg_index[arg1]];
     3113                fod[opind].right = NULL;
     3114                traverse_unary(&fod[opind], nonl_dom, &fod[opind], indcheck+1);
     3115                arg_index[res] = opind++;               
     3116#endif
     3117#if defined(_NLF_)
     3118                fod[opind].entry = maxopind+2;
    29033119                fod[opind].left = &fod[arg_index[arg1]];
    29043120                fod[opind].right = NULL;
     
    29073123                nlf[opind].right = NULL;
    29083124                arg_index[res] = opind++;               
    2909 #endif
    2910 #if defined(_NONLIND_)
    2911                 extend_nonlinearity_domain_unary(arg1, ind_dom, nonl_dom);
    29123125#endif
    29133126#else
     
    29843197
    29853198#if defined(_INDO_)
    2986 #if !defined(_NLF_)
     3199#if defined(_INDOPRO_)
    29873200                copy_index_domain(res, arg1, ind_dom);
    2988 #else
    2989                 fod[opind].entry = -1;
     3201#endif
     3202#if defined(_NONLIND_)
     3203                fod[opind].entry = maxopind+2;
     3204                fod[opind].left = &fod[arg_index[arg1]];
     3205                fod[opind].right = NULL;
     3206                traverse_unary(&fod[opind], nonl_dom, &fod[opind], indcheck+1);
     3207                arg_index[res] = opind++;               
     3208#endif
     3209#if defined(_NLF_)
     3210                fod[opind].entry = maxopind+2;
    29903211                fod[opind].left = &fod[arg_index[arg1]];
    29913212                fod[opind].right = NULL;
     
    29943215                nlf[opind].right = NULL;
    29953216                arg_index[res] = opind++;               
    2996 #endif
    2997 #if defined(_NONLIND_)
    2998                 extend_nonlinearity_domain_unary(arg1, ind_dom, nonl_dom);
    29993217#endif
    30003218#else
     
    30923310                ADOLC_OPENMP_RESTORE_THREAD_NUMBER;
    30933311#if defined(_INDO_)
    3094 #if !defined(_NLF_)
     3312#if defined(_INDOPRO_)
    30953313                copy_index_domain(res, arg1, ind_dom);
    3096 #else
    3097                 fod[opind].entry = -1;
     3314#endif
     3315#if defined(_NONLIND_)
     3316                fod[opind].entry = maxopind+2;
     3317                fod[opind].left = &fod[arg_index[arg1]];
     3318                fod[opind].right = NULL;
     3319                traverse_unary(&fod[opind], nonl_dom, &fod[opind], indcheck+1);
     3320                arg_index[res] = opind++;               
     3321#endif
     3322#if defined(_NLF_)
     3323                fod[opind].entry = maxopind+2;
    30983324                fod[opind].left = &fod[arg_index[arg1]];
    30993325                fod[opind].right = NULL;
     
    31493375
    31503376#if defined(_INDO_)
    3151 #if !defined(_NLF_)
     3377#if defined(_INDOPRO_)
    31523378                copy_index_domain(res, arg, ind_dom);
    3153 #else
    3154                 fod[opind].entry = -1;
     3379#endif
     3380#if defined(_NONLIND_)
     3381                fod[opind].entry = maxopind+2;
     3382                fod[opind].left = &fod[arg_index[arg]];
     3383                fod[opind].right = NULL;
     3384                traverse_unary(&fod[opind], nonl_dom, &fod[opind], indcheck+1);
     3385                arg_index[res] = opind++;               
     3386#endif
     3387#if defined(_NLF_)
     3388                fod[opind].entry = maxopind+2;
    31553389                fod[opind].left = &fod[arg_index[arg]];
    31563390                fod[opind].right = NULL;
     
    31593393                nlf[opind].right = NULL;
    31603394                arg_index[res] = opind++;               
    3161 #endif
    3162 #if defined(_NONLIND_)
    3163                 extend_nonlinearity_domain_unary(arg, ind_dom, nonl_dom);
    31643395#endif
    31653396#else
     
    32373468                ADOLC_OPENMP_RESTORE_THREAD_NUMBER;
    32383469#if defined(_INDO_)
    3239 #if !defined(_NLF_)
     3470#if defined(_INDOPRO_)
    32403471                copy_index_domain(res, arg, ind_dom);
    3241 #else
    3242                 fod[opind].entry = -1;
     3472#endif
     3473#if defined(_NONLIND_)
     3474                fod[opind].entry = maxopind+2;
     3475                fod[opind].left = &fod[arg_index[arg]];
     3476                fod[opind].right = NULL;
     3477                traverse_unary(&fod[opind], nonl_dom, &fod[opind], indcheck+1);
     3478                arg_index[res] = opind++;               
     3479#endif
     3480#if defined(_NLF_)
     3481                fod[opind].entry = maxopind+2;
    32433482                fod[opind].left = &fod[arg_index[arg]];
    32443483                fod[opind].right = NULL;
     
    32473486                nlf[opind].right = NULL;
    32483487                arg_index[res] = opind++;               
    3249 #endif
    3250 #if defined(_NONLIND_)
    3251                 extend_nonlinearity_domain_unary(arg, ind_dom, nonl_dom);
    32523488#endif
    32533489#else
     
    33823618
    33833619#if defined(_INDO_)
    3384 #if !defined(_NLF_)
     3620#if defined(_INDOPRO_)
    33853621                copy_index_domain(res, arg, ind_dom);
    3386 #else
    3387                 fod[opind].entry = -1;
     3622#endif
     3623#if defined(_NONLIND_)
     3624                fod[opind].entry = maxopind+2;
     3625                fod[opind].left = &fod[arg_index[arg]];
     3626                fod[opind].right = NULL;
     3627                traverse_unary(&fod[opind], nonl_dom, &fod[opind], indcheck+1);
     3628                arg_index[res] = opind++;               
     3629#endif
     3630#if defined(_NLF_)
     3631                fod[opind].entry = maxopind+2;
    33883632                fod[opind].left = &fod[arg_index[arg]];
    33893633                fod[opind].right = NULL;
     
    33923636                nlf[opind].right = NULL;
    33933637                arg_index[res] = opind++;               
    3394 #endif
    3395 #if defined(_NONLIND_)
    3396                 extend_nonlinearity_domain_unary(arg, ind_dom, nonl_dom);
    33973638#endif
    33983639#else
     
    35423783#endif /* !_NTIGHT_ */
    35433784
    3544 #if defined(_INDO_)
    3545 #if !defined(_NLF_)
    3546 #ifdef _TIGHT_
     3785#if defined (_INDO_)
     3786#if defined (_INDOPRO_)
     3787#if defined (_TIGHT_)
    35473788                    if (dp_T0[arg1] < dp_T0[arg2])
    35483789                        copy_index_domain(res, arg1, ind_dom);
     
    35563797                    combine_2_index_domains(res, arg1, arg2, ind_dom);
    35573798#endif
    3558 #else
     3799#endif
     3800#if defined(_NONLIND_)
    35593801#ifdef _TIGHT_
    35603802                    if (dp_T0[arg1] < dp_T0[arg2])
    35613803                      {
    3562                         fod[opind].entry = -1;
     3804                        fod[opind].entry = maxopind+2;
    35633805                        fod[opind].left = &fod[arg_index[arg1]];
    35643806                        fod[opind].right = NULL;
    3565                         nlf[opind].entry = -1;
     3807                        arg_index[res] = opind++;               
     3808                      }           
     3809                    else {
     3810                        if (dp_T0[arg1] > dp_T0[arg2])
     3811                          {
     3812                            fod[opind].entry = maxopind+2;
     3813                            fod[opind].left = &fod[arg_index[arg2]];
     3814                            fod[opind].right = NULL;
     3815                            arg_index[res] = opind++;           
     3816
     3817                          }               
     3818                        else
     3819                          {
     3820                            fod[opind].entry = maxopind+2;
     3821                            fod[opind].left = &fod[arg_index[arg1]];
     3822                            fod[opind].right = &fod[arg_index[arg2]];
     3823                            arg_index[res] = opind++;           
     3824                          }
     3825                    }
     3826#else
     3827                    fod[opind].entry = maxopind+2;
     3828                    fod[opind].left = &fod[arg_index[arg1]];
     3829                    fod[opind].right = &fod[arg_index[arg2]];
     3830                    arg_index[res] = opind++;           
     3831                    arg_index[res] = opind++;           
     3832#endif
     3833#endif
     3834#if defined(_NLF_)
     3835#ifdef _TIGHT_
     3836                    if (dp_T0[arg1] < dp_T0[arg2])
     3837                      {
     3838                        fod[opind].entry = maxopind+2;
     3839                        fod[opind].left = &fod[arg_index[arg1]];
     3840                        fod[opind].right = NULL;
     3841                        nlf[opind].entry = maxopind+2;
    35663842                        nlf[opind].left = &nlf[arg_index[arg1]];
    35673843                        nlf[opind].right = NULL;
     
    35713847                        if (dp_T0[arg1] > dp_T0[arg2])
    35723848                          {
    3573                             fod[opind].entry = -1;
     3849                            fod[opind].entry = maxopind+2;
    35743850                            fod[opind].left = &fod[arg_index[arg2]];
    35753851                            fod[opind].right = NULL;
    3576                             nlf[opind].entry = -1;
     3852                            nlf[opind].entry = maxopind+2;
    35773853                            nlf[opind].left = &nlf[arg_index[arg2]];
    35783854                            nlf[opind].right = NULL;
     
    35823858                        else
    35833859                          {
    3584                             fod[opind].entry = -1;
     3860                            fod[opind].entry = maxopind+2;
    35853861                            fod[opind].left = &fod[arg_index[arg1]];
    35863862                            fod[opind].right = &fod[arg_index[arg2]];
    3587                             nlf[opind].entry = -1;
     3863                            nlf[opind].entry = maxopind+2;
    35883864                            nlf[opind].left = &nlf[arg_index[arg1]];
    35893865                            nlf[opind].right = &nlf[arg_index[arg2]];
     
    35923868                    }
    35933869#else
    3594                     fod[opind].entry = -1;
     3870                    fod[opind].entry = maxopind+2;
    35953871                    fod[opind].left = &fod[arg_index[arg1]];
    35963872                    fod[opind].right = &fod[arg_index[arg2]];
    3597                     nlf[opind].entry = -1;
     3873                    nlf[opind].entry = maxopind+2;
    35983874                    nlf[opind].left = &nlf[arg_index[arg1]];
    35993875                    nlf[opind].right = &nlf[arg_index[arg2]];
     
    37193995
    37203996#if defined(_INDO_)
    3721 #if !defined(_NLF_)
     3997#if defined(_INDOPRO_)
    37223998                copy_index_domain(res, arg, ind_dom);
    3723 #else
     3999#endif
     4000#if defined(_NONLIND_)
     4001                arg_index[res] = arg_index[arg];               
     4002#endif
     4003#if defined(_NLF_)
    37244004                arg_index[res] = arg_index[arg];               
    37254005#endif
     
    37974077
    37984078#if defined(_INDO_)
    3799 #if !defined(_NLF_)
     4079#if defined(_INDOPRO_)
    38004080                copy_index_domain(res, arg, ind_dom);
    3801 #else
     4081#endif
     4082#if defined(_NONLIND_)
     4083                arg_index[res] = arg_index[arg];               
     4084#endif
     4085#if defined(_NLF_)
    38024086                arg_index[res] = arg_index[arg];               
    38034087#endif
     
    38284112
    38294113#if defined(_INDO_)
    3830 #if !defined(_NLF_)
     4114#if defined(_INDOPRO_)
    38314115                copy_index_domain(res, arg, ind_dom);
    3832 #else
     4116#endif
     4117#if defined(_NONLIND_)
     4118                arg_index[res] = arg_index[arg];               
     4119#endif
     4120#if defined(_NLF_)
    38334121                arg_index[res] = arg_index[arg];               
    38344122#endif
     
    38584146
    38594147                /* olvo 980924 changed order to allow reflexive ops */
    3860 #if defined(_INDO_)
    3861 #if !defined(_NLF_)
    3862 #ifdef _TIGHT_
     4148#if defined (_INDO_)
     4149#if defined (_INDOPRO_)
     4150#if defined (_TIGHT_)
    38634151                if (dp_T0[arg] > 0) {
    38644152                    if (coval <= 0.0)
     
    38814169                    combine_2_index_domains(res, arg1, arg2, ind_dom);
    38824170#endif
    3883 #else
    3884 #ifdef _TIGHT_
     4171#endif
     4172#if defined (_NONLIND_)
     4173#if defined (_TIGHT_)
     4174                if (dp_T0[arg] > 0) {
     4175                    if (coval <= 0.0)
     4176                        MINDEC(ret_c,2);
     4177                    dp_T0[res] = dp_T0[arg1];
     4178
     4179                    arg_index[res] = arg_index[arg1];           
     4180
     4181                } else {
     4182                    if (coval > 0.0)
     4183                        MINDEC(ret_c,2);
     4184                    if (dp_T0[arg] == 0)
     4185                        MINDEC(ret_c,0);
     4186                    dp_T0[res] = dp_T0[arg2];
     4187                    arg_index[res] = arg_index[arg2];           
     4188                }
     4189
     4190#else
     4191               arg_index[res] = opind++;               
     4192#endif
     4193#endif
     4194#if defined (_NLF_)
     4195#if defined (_TIGHT_)
    38854196                if (dp_T0[arg] > 0) {
    38864197                    if (coval <= 0.0)
     
    39734284                /* olvo 980924 changed order to allow reflexive ops */
    39744285#if defined(_INDO_)
    3975 #if !defined(_NLF_)
     4286#if defined(_INDOPRO_)
    39764287                copy_index_domain(res, arg1, ind_dom);
    3977 #else
     4288#endif
     4289#if defined(_NONLIND_)
     4290                arg_index[res] = arg_index[arg1];               
     4291#endif
     4292#if defined(_NLF_)
    39784293                arg_index[res] = arg_index[arg1];               
    39794294#endif
     
    41954510
    41964511#if defined(_INDO_)
    4197 #if !defined(_NLF_)
     4512#if defined(_INDOPRO_)
    41984513    for(i=0;i<max_ind_dom;i++)
    41994514      {
     
    42014516      }
    42024517    free(ind_dom);
    4203 #else
    4204 
     4518#endif
     4519#if defined(_NONLIND_)
    42054520    for( i=0; i < indcheck; i++) {
    4206       traverse_crs(&fod2[i],&csod[i]);
     4521      traverse_crs(&nonl_dom[i],&sod[i],indcheck+1);
     4522      free_tree(&nonl_dom[i],indcheck+1);
     4523      crs[i] = (unsigned int*) malloc(sizeof(unsigned int) * (sod[i].entry+1));
     4524      crs[i][0] = sod[i].entry;
     4525      temp = sod[i].left;
     4526      for( ii=1; ii <=sod[i].entry; ii++)
     4527        {
     4528          crs[i][ii] = temp->entry;
     4529          temp1 = temp->left;
     4530          free(temp);
     4531          temp = temp1;
     4532        }
     4533    }
     4534
     4535    free(sod);
     4536    free(nonl_dom);
     4537    free(fod);
     4538    free(arg_index);
     4539
     4540#endif
     4541#if defined(_NLF_)
     4542
     4543    for( i=0; i < indcheck; i++) {
     4544      traverse_crs(&fod2[i],&csod[i],maxopind+1);
     4545      free_tree(&fod2[i],maxopind+1);
    42074546      crs[i] = (unsigned int*) malloc(sizeof(unsigned int) * (csod[i].entry+1));
    42084547      crs[i][0] = csod[i].entry;
     
    42224561    free(csod);
    42234562    free(arg_index);
    4224 #endif
    4225 
    4226 #if defined(_NONLIND_)
    4227 
    4228     for( i=0; i < indcheck; i++) {
    4229        crs[i] = (unsigned int*) malloc(sizeof(unsigned int) * (nonl_dom[i][0]+1));
    4230        crs[i][0] = nonl_dom[i][0];
    4231        for(l=1; l < crs[i][0]+1; l++)
    4232           crs[i][l] = nonl_dom[i][l+1];
    4233        free(nonl_dom[i]);
    4234     }
    4235     free(nonl_dom);
    4236 
    42374563#endif
    42384564#endif
     
    44494775
    44504776/****************************************************************************/
    4451 /* set operations for propagation of index domains                          */
    4452 
    4453 /*--------------------------------------------------------------------------*/
    4454 /* operations on index domains                                              */
     4777/* set operations for propagation of nonlinear interaction domains          */
    44554778
    44564779#if defined(_TIGHT_)
    44574780
    4458 void traverse_nlf(IndexElement* tree, char * nlfdomain)
     4781void free_tree(IndexElement* tree, int num)
     4782{
     4783
     4784  if (tree->left != NULL)
     4785    {
     4786      free_tree(tree->left,num);
     4787    }
     4788  if (tree->right != NULL)
     4789    {
     4790      free_tree(tree->right,num);
     4791     }
     4792    {
     4793      if (tree->entry == num)
     4794        free(tree);
     4795
     4796    }
     4797 
     4798}
     4799
     4800void traverse(IndexElement* tree)
     4801{
     4802
     4803  if (tree->left != NULL)
     4804    {
     4805      traverse(tree->left);
     4806      if (tree->right != NULL)
     4807        traverse(tree->right);
     4808     }
     4809  else
     4810    {
     4811      printf(" %d ",tree->entry);
     4812    }
     4813}
     4814
     4815void traverse_nlf(IndexElement* tree, char* nlfdomain)
    44594816{
    44604817
     
    44674824  else
    44684825    {
    4469       nlfdomain[tree->entry+1] = 1;
     4826      nlfdomain[tree->entry] = 1;
    44704827    }
    44714828}
    44724829
    4473 void traverse_crs(IndexElement* tree,  IndexElement* csod)
     4830void traverse_crs(IndexElement* tree,  IndexElement_csod* csod, int num)
    44744831{
    44754832
    4476   IndexElement *temp, *temp1;
     4833  IndexElement_csod *temp, *temp1;
    44774834  int ii;
    44784835
    44794836  if (tree->left != NULL)
    4480       traverse_crs(tree->left, csod);
     4837    {
     4838      traverse_crs(tree->left, csod, num);
     4839    }
    44814840  if (tree->right != NULL)
    4482           traverse_crs(tree->right, csod);
    4483   if (tree->entry+1)
     4841    {
     4842      traverse_crs(tree->right, csod, num);
     4843    }
     4844  if (tree->entry < num)
    44844845    {
    44854846      temp = csod->left;
    44864847      if (temp == NULL)
    44874848        {
    4488           temp = (struct IndexElement*) malloc(sizeof(struct IndexElement));
     4849          temp = (struct IndexElement_csod*) malloc(sizeof(struct IndexElement_csod));
    44894850          temp->left = NULL;
    44904851          temp->entry = tree->entry;
     
    45034864              if(temp->entry < tree->entry)
    45044865                {
    4505                   temp->left = (struct IndexElement*) malloc(sizeof(struct IndexElement));
     4866                  temp->left = (struct IndexElement_csod*) malloc(sizeof(struct IndexElement_csod));
    45064867                  temp = temp->left;
    45074868                  temp->left = NULL;
     
    45114872              if(temp->entry > tree->entry)
    45124873                {
    4513                   temp->left = (struct IndexElement*) malloc(sizeof(struct IndexElement));
     4874                  temp->left = (struct IndexElement_csod*) malloc(sizeof(struct IndexElement_csod));
    45144875                  temp->left->entry = temp->entry;
    45154876                  temp->left->left = NULL;
     
    45224883              if (temp->entry > tree->entry)
    45234884                {
    4524                   temp1 = (struct IndexElement*) malloc(sizeof(struct IndexElement));
     4885                  temp1 = (struct IndexElement_csod*) malloc(sizeof(struct IndexElement_csod));
    45254886                  temp1->left = temp->left;
    45264887                  temp1->entry = temp->entry;
     
    45354896}
    45364897
    4537 void traverse_fod(IndexElement* tree,  IndexElement* fod,  int i, IndexElement* fod2)
     4898void traverse_fod(IndexElement* tree,  IndexElement* fod,  int i, IndexElement* fod2, int num)
    45384899{
    45394900  IndexElement *temp;
     
    45414902  if (tree->left != NULL)
    45424903    {
    4543       traverse_fod(tree->left, fod, i, fod2);
     4904      traverse_fod(tree->left, fod, i, fod2, num);
    45444905      if (tree->right != NULL)
    45454906        {
    4546           traverse_fod(tree->right, fod, i, fod2);
     4907          traverse_fod(tree->right, fod, i, fod2, num);
    45474908        }
    45484909     }
     
    45524913      temp->right = &fod[i];
    45534914      temp->left = fod2[tree->entry].left;
    4554       temp->entry= -1;
     4915      temp->entry= num;
    45554916      fod2[tree->entry].left = temp;
    45564917    }
     
    45594920#endif
    45604921#endif
     4922#if defined(_NLF_)
     4923
     4924/****************************************************************************/
     4925/* set operations for propagation of index domains                          */
     4926
     4927/*--------------------------------------------------------------------------*/
     4928/* operations on index domains                                              */
     4929
     4930#if defined(_TIGHT_)
     4931
     4932void traverse_unary(IndexElement* tree,  IndexElement* nonl_dom,  IndexElement* fodi, int num)
     4933{
     4934  IndexElement *temp;
     4935
     4936  if (tree->left != NULL)
     4937    {
     4938      traverse_unary(tree->left, nonl_dom, fodi, num);
     4939      if (tree->right != NULL)
     4940        {
     4941          traverse_unary(tree->right, nonl_dom, fodi, num);
     4942        }
     4943     }
     4944  else
     4945    {
     4946      temp = (struct IndexElement*) malloc(sizeof(struct IndexElement));
     4947      temp->right = fodi;
     4948      temp->left = nonl_dom[tree->entry].left;
     4949      temp->entry= num;
     4950      nonl_dom[tree->entry].left = temp;
     4951    }
     4952}
     4953
     4954#endif
     4955#endif
    45614956
    45624957END_C_DECLS
  • branches/NLF/ADOL-C/src/usrparms.h

    r248 r279  
    2222/*--------------------------------------------------------------------------*/
    2323/* Buffer sizes */
    24 #define OBUFSIZE  524288 /* 16384 or  65536  */
    25 #define LBUFSIZE  524288 /* 16384 or  65536  */
    26 #define VBUFSIZE 524288 /* 16384 or  65536  */
     24#define OBUFSIZE 10000000 /* 16384 or  65536  */
     25#define LBUFSIZE 10000000 /* 16384 or  65536  */
     26#define VBUFSIZE 10000000 /* 524288 /* 16384 or  65536  */
    2727
    2828/*--------------------------------------------------------------------------*/
    2929/* Buffer size for temporary Taylor store */
    30 #define TBUFSIZE 524288 /* 16384 or  65536  */
     30#define TBUFSIZE 10000000 /* 524288 /* 16384 or  65536  */
    3131
    3232/*--------------------------------------------------------------------------*/
Note: See TracChangeset for help on using the changeset viewer.