Changeset 325


Ignore:
Timestamp:
Jun 5, 2012 11:05:30 AM (8 years ago)
Author:
awalther
Message:

first try: new hess patt version

File:
1 edited

Legend:

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

    r322 r325  
    1414           hov_forward (higher-order-vector forward mode):    define _HOV_
    1515           hov_wk_forward (higher-order-vector forward mode): define _HOV_WK_
    16         int_forward_safe:                                  define _INT_FOR_ and _NTIGHT__
     16           int_forward_safe:                                  define _INT_FOR_ and _NTIGHT__
    1717
    1818           Uses the preprocessor to compile the 7 different object files
     
    3939#include <math.h>
    4040
    41 #include <time.h>
    42 #include <sys/time.h>
    43 #include <string.h>
    44 #include <stdio.h>
    45 #include <stdlib.h>
    46 
    4741#if defined(ADOLC_DEBUG)
    4842#include <string.h>
     
    148142#if defined(_NONLIND_)
    149143
    150 /*
    151  * This is the type used for the list elements. The entry is either a counter
    152  * (first element of the NID list) or the index of an independent variable.
    153  */
    154 
    155 void extend_nonlinearity_domain_binary_step
    156 (int arg1, int arg2, locint **ind_dom, locint **nonl_dom);
    157 void extend_nonlinearity_domain_unary
    158 (int arg, locint **ind_dom, locint **nonl_dom);
    159 void extend_nonlinearity_domain_binary
    160 (int arg1, int arg2, locint **ind_dom, locint **nonl_dom);
    161 
     144typedef struct IndexElement {
     145    locint  entry;
     146    struct IndexElement* left;
     147    struct IndexElement* right;
     148}
     149IndexElement;
     150
     151typedef struct IndexElement_sod {
     152    locint  entry;
     153    struct IndexElement_sod* left;
     154}
     155IndexElement_sod;
    162156
    163157#if defined(_TIGHT_)
     158void free_tree(IndexElement* nlf, int num);
     159void traverse_crs(IndexElement* fod2, IndexElement_sod* sod, int num);
     160void traverse_unary(IndexElement* fod, IndexElement* nonl_dom,  IndexElement* fodi, int num, int maxopind);
     161
    164162#define GENERATED_FILENAME "nonl_ind_forward_t"
    165163#endif
     
    596594    const double     *basepoint,  /* independent variable values   (in)   */
    597595    unsigned int     **crs)        /* returned row index storage (out)     */
    598 
    599 /* indopro_forward_tight( tag, m, n, x[n], *crs[m]),
    600 
    601   */
    602596
    603597#endif
     
    745739    int l=0;
    746740    int max_ind_dom;
     741#if defined(_INDOPRO_)
     742    /* index domains */
    747743    locint** ind_dom;
    748     locint* ind_dom_dum;
     744#endif
    749745#if defined(_NONLIND_)
    750746    /* nonlinear interaction domains */
    751     locint** nonl_dom;
    752     locint*  temp;
    753     locint*  temp1;
     747    locint* arg_index;
     748    IndexElement* fod;
     749    IndexElement* nonl_dom;
     750    IndexElement_sod* sod;
     751    IndexElement_sod* temp;
     752    IndexElement_sod* temp1;
     753    int maxopind;
     754    int opind;
     755    int ii;
    754756#endif
    755757#endif
     
    971973#else                                                                /* INDOPRO */
    972974#if defined(_INDO_)
     975#if defined(_INDOPRO_)
    973976    /* index domains */
    974977    ind_dom = (locint **)  malloc(sizeof(locint*) * ADOLC_CURRENT_TAPE_INFOS.stats[NUM_MAX_LIVES]);
    975 
    976     for(i=0;i<ADOLC_CURRENT_TAPE_INFOS.stats[NUM_MAX_LIVES];i++)
     978    max_ind_dom = ADOLC_CURRENT_TAPE_INFOS.stats[NUM_MAX_LIVES];
     979
     980    for(i=0;i<max_ind_dom;i++)
    977981    {
    978982        ind_dom[i] = (locint *)  malloc(sizeof(locint) * (NUMNNZ+2));
     
    980984        ind_dom[i][1] = NUMNNZ;
    981985    }
    982 
    983     max_ind_dom = ADOLC_CURRENT_TAPE_INFOS.stats[NUM_MAX_LIVES];
    984 #if defined(_NONLIND_)
    985 
    986     nonl_dom = (locint**) malloc(sizeof(locint*) * indcheck);
    987     for(i=0;i<indcheck;i++){
    988           nonl_dom[i] = (locint*) malloc(sizeof(locint)*(NUMNNZ+2));
    989           nonl_dom[i][0]=0;
    990           nonl_dom[i][1]=NUMNNZ;
    991        }
    992 #endif
    993 /* #if defined(_INDOPRO_) */
    994 /*     clock_gettime(CLOCK_MONOTONIC, &start3 ); */
    995 /* #endif */
     986#endif
     987#if defined(_NONLIND_)
     988        maxopind=ADOLC_CURRENT_TAPE_INFOS.stats[NUM_OPERATIONS]+ADOLC_CURRENT_TAPE_INFOS.stats[NUM_EQ_PROD];
     989        fod = (struct IndexElement*) malloc(sizeof(struct IndexElement) * maxopind);
     990        nonl_dom = (struct IndexElement*) malloc(sizeof(struct IndexElement) * indcheck);
     991        arg_index = (locint *)  malloc(sizeof(locint) * (ADOLC_CURRENT_TAPE_INFOS.stats[NUM_MAX_LIVES]));
     992        opind = 0;
     993        sod = (struct IndexElement_sod*) malloc(sizeof(struct IndexElement_sod) * indcheck);
     994
     995        for(i=0;i<indcheck;i++)
     996          {
     997            sod[i].entry = 0;
     998            sod[i].left = NULL;
     999            nonl_dom[i].entry = indcheck+2;
     1000            nonl_dom[i].left = NULL;
     1001            nonl_dom[i].right = NULL;
     1002          }
     1003#endif
    9961004
    9971005    /*--------------------------------------------------------------------------*/
     
    12211229
    12221230#if defined(_INDO_)
     1231#if defined(_INDOPRO_)
    12231232                copy_index_domain(res, arg, ind_dom);
     1233#endif
     1234#if defined(_NONLIND_)
     1235                arg_index[res] = arg_index[arg];               
     1236#endif           
    12241237#else
    12251238#if !defined(_ZOS_) /* BREAK_ZOS */
     
    12461259
    12471260#if defined(_INDO_)
    1248           ind_dom[res][0]=0;
     1261#if defined(_INDOPRO_)
     1262                ind_dom[res][0]=0;
     1263#endif
     1264#if defined(_NONLIND_)
     1265                fod[opind].entry = maxopind+2;
     1266                fod[opind].left = NULL;
     1267                fod[opind].right = NULL;
     1268                arg_index[res] = opind++;               
     1269#endif
    12491270#else
    12501271#if !defined(_ZOS_) /* BREAK_ZOS */
     
    12691290
    12701291#if defined(_INDO_)
    1271           ind_dom[res][0]=0;
     1292#if defined(_INDOPRO_)
     1293                ind_dom[res][0]=0;
     1294#endif
     1295#if defined(_NONLIND_)
     1296                fod[opind].entry = maxopind+2;
     1297                fod[opind].left = NULL;
     1298                fod[opind].right = NULL;
     1299                arg_index[res] = opind++;               
     1300#endif
    12721301#else
    12731302#if !defined(_ZOS_) /* BREAK_ZOS */
     
    12921321
    12931322#if defined(_INDO_)
    1294           ind_dom[res][0]=0;
     1323#if defined(_INDOPRO_)
     1324                ind_dom[res][0]=0;
     1325#endif
     1326#if defined(_NONLIND_)
     1327                fod[opind].entry = maxopind+2;
     1328                fod[opind].left = NULL;
     1329                fod[opind].right = NULL;
     1330                arg_index[res] = opind++;               
     1331#endif
    12951332#else
    12961333#if !defined(_ZOS_) /* BREAK_ZOS */
     
    13161353
    13171354#if defined(_INDO_)
    1318           ind_dom[res][0] = 1;
    1319           ind_dom[res][2] = indexi;
     1355#if defined(_INDOPRO_)
     1356                ind_dom[res][0] = 1;
     1357                ind_dom[res][2] = indexi;
     1358#endif         
     1359#if defined(_NONLIND_)
     1360                fod[opind].entry = indexi;
     1361                fod[opind].left = NULL;
     1362                fod[opind].right = NULL;
     1363                arg_index[res] = opind++;               
     1364#endif         
    13201365#else
    13211366#if !defined(_ZOS_) /* BREAK_ZOS */
     
    13431388#if !defined(_NTIGHT_)
    13441389                if ( valuepoint != NULL )
    1345             valuepoint[indexd] = dp_T0[res];
     1390                  valuepoint[indexd] = dp_T0[res];
    13461391#endif /* !_NTIGHT_ */
    13471392#endif
     
    14101455
    14111456#if defined(_INDO_)
     1457#if defined(_INDOPRO_)
    14121458                merge_2_index_domains(res, arg, ind_dom);
     1459#endif
     1460#if defined(_NONLIND_)
     1461                fod[opind].entry = maxopind+2;
     1462                fod[opind].left = &fod[arg_index[res]];
     1463                fod[opind].right = &fod[arg_index[arg]];
     1464                arg_index[res] = opind++;               
     1465#endif
    14131466#else
    14141467#if !defined(_ZOS_) /* BREAK_ZOS */
     
    14531506
    14541507#if defined(_INDO_)
     1508#if defined(_INDOPRO_)
    14551509                merge_2_index_domains(res, arg, ind_dom);
     1510#endif
     1511#if defined(_NONLIND_)
     1512                fod[opind].entry = maxopind+2;
     1513                fod[opind].left = &fod[arg_index[res]];
     1514                fod[opind].right = &fod[arg_index[arg]];
     1515                arg_index[res] = opind++;               
     1516#endif
    14561517#else
    14571518#if !defined(_ZOS_) /* BREAK_ZOS */
     
    15051566
    15061567#if defined(_INDO_)
     1568#if defined(_INDOPRO_)
    15071569                merge_2_index_domains(res, arg, ind_dom);
    1508 #if defined(_NONLIND_)
    1509                 extend_nonlinearity_domain_binary(res, arg, ind_dom, nonl_dom);
     1570#endif
     1571#if defined(_NONLIND_)
     1572                fod[opind].entry = maxopind+2;
     1573                fod[opind].left = &fod[arg_index[res]];
     1574                fod[opind].right = &fod[arg_index[arg]];
     1575                traverse_unary(&fod[arg_index[res]], nonl_dom, &fod[arg_index[arg]], indcheck+1,maxopind+2);
     1576                traverse_unary(&fod[arg_index[arg]], nonl_dom, &fod[arg_index[res]], indcheck+1,maxopind+2);
     1577                arg_index[res] = opind++;               
    15101578#endif
    15111579#else
     
    15781646
    15791647#if !defined(_NTIGHT_)
    1580                 dp_T0[res] = dp_T0[arg1] +
    1581                                                dp_T0[arg2];
     1648                dp_T0[res] = dp_T0[arg1] + dp_T0[arg2];
    15821649#endif /* !_NTIGHT_ */
    15831650
    15841651#if defined(_INDO_)
     1652#if defined(_INDOPRO_)
    15851653                combine_2_index_domains(res, arg1, arg2, ind_dom);
     1654#endif     
     1655#if defined(_NONLIND_)
     1656                fod[opind].entry = maxopind+2;
     1657                fod[opind].left = &fod[arg_index[arg1]];
     1658                fod[opind].right = &fod[arg_index[arg2]];
     1659                arg_index[res] = opind++;               
     1660#endif
    15861661#else
    15871662#if !defined(_ZOS_) /* BREAK_ZOS */
     
    16151690
    16161691#if defined(_INDO_)
     1692#if defined(_INDOPRO_)
    16171693                copy_index_domain(res, arg, ind_dom);
     1694#endif
     1695#if defined(_NONLIND_)
     1696                arg_index[res] = arg_index[arg];
     1697#endif               
    16181698#else
    16191699#if !defined(_ZOS_) /* BREAK_ZOS */
     
    16421722
    16431723
    1644 #if defined(_INDO_)
     1724#if defined(_INDO_)   
     1725#if defined(_INDOPRO_)
    16451726                combine_2_index_domains(res, arg1, arg2, ind_dom);
     1727#endif
     1728#if defined(_NONLIND_)
     1729                fod[opind].entry = maxopind+2;
     1730                fod[opind].left = &fod[arg_index[arg1]];
     1731                fod[opind].right = &fod[arg_index[arg2]];
     1732                arg_index[res] = opind++;               
     1733#endif
    16461734#else
    16471735#if !defined(_ZOS_) /* BREAK_ZOS */
     
    16751763
    16761764#if defined(_INDO_)
     1765#if defined(_INDOPRO_)
    16771766                copy_index_domain(res, arg, ind_dom);
     1767#endif
     1768#if defined(_NONLIND_)
     1769                arg_index[res] = arg_index[arg];               
     1770#endif
    16781771#else
    16791772#if !defined(_ZOS_) /* BREAK_ZOS */
     
    17011794
    17021795#if defined(_INDO_)
     1796#if defined(_INDOPRO_)
    17031797                combine_2_index_domains(res, arg1, arg2, ind_dom);
    1704 #if defined(_NONLIND_)
    1705           extend_nonlinearity_domain_binary(arg1, arg2, ind_dom, nonl_dom);
     1798#endif
     1799#if defined(_NONLIND_)
     1800                fod[opind].entry = maxopind+2;
     1801                fod[opind].left = &fod[arg_index[arg1]];
     1802                fod[opind].right = &fod[arg_index[arg2]];
     1803                traverse_unary(&fod[arg_index[arg1]], nonl_dom, &fod[arg_index[arg2]], indcheck+1,maxopind+2);
     1804                traverse_unary(&fod[arg_index[arg2]], nonl_dom, &fod[arg_index[arg1]], indcheck+1,maxopind+2);
     1805                arg_index[res] = opind++;               
    17061806#endif
    17071807#else
     
    17531853
    17541854#if defined(_INDO_)
     1855#if defined(_INDOPRO_)
    17551856                merge_3_index_domains(res, arg1, arg2, ind_dom);
    1756 #if defined(_NONLIND_)
    1757                 extend_nonlinearity_domain_binary(arg1, arg2, ind_dom, nonl_dom);
     1857#endif
     1858#if defined(_NONLIND_)
     1859                // operation: v = v+u*w
     1860                // first step: z = u*w, index domains
     1861                fod[opind].entry = maxopind+2;
     1862                fod[opind].left = &fod[arg_index[arg1]];
     1863                fod[opind].right = &fod[arg_index[arg2]];
     1864                // first step: z = u*w,
     1865                traverse_unary(&fod[arg_index[arg1]], nonl_dom, &fod[opind], indcheck+1,maxopind+2);
     1866                traverse_unary(&fod[arg_index[arg2]], nonl_dom, &fod[opind], indcheck+1,maxopind+2);
     1867                opind++;
     1868                // second step: v = v+z, index domains
     1869                fod[opind].entry = maxopind+2;
     1870                fod[opind].left = &fod[arg_index[res]];
     1871                fod[opind].right = &fod[opind-1];
     1872                // second step: v = v+z,
     1873                arg_index[res] = opind++;               
    17581874#endif
    17591875#else
     
    18041920
    18051921#if defined(_INDO_)
     1922#if defined(_INDOPRO_)
    18061923                merge_3_index_domains(res, arg1, arg2, ind_dom);
    1807 #if defined(_NONLIND_)
    1808                 extend_nonlinearity_domain_binary(arg1, arg2, ind_dom, nonl_dom);
     1924#endif
     1925#if defined(_NONLIND_)
     1926                // operation: v = v-u*w
     1927                // first step: z = u*w, index domains
     1928                fod[opind].entry = maxopind+2;
     1929                fod[opind].left = &fod[arg_index[arg1]];
     1930                fod[opind].right = &fod[arg_index[arg2]];
     1931                // first step: z = u*w,
     1932                traverse_unary(&fod[arg_index[arg1]], nonl_dom, &fod[opind], indcheck+1,maxopind+2);
     1933                traverse_unary(&fod[arg_index[arg2]], nonl_dom, &fod[opind], indcheck+1,maxopind+2);
     1934                opind++;
     1935                // second step: v = v-z, index domains
     1936                fod[opind].entry = maxopind+2;
     1937                fod[opind].left = &fod[arg_index[res]];
     1938                fod[opind].right = &fod[opind-1];
     1939                // second step: v = v-z,
     1940                arg_index[res] = opind++;       
    18091941#endif
    18101942#else
     
    18611993
    18621994#if defined(_INDO_)
     1995#if defined(_INDOPRO_)
    18631996                copy_index_domain(res, arg, ind_dom);
     1997#endif
     1998#if defined(_NONLIND_)
     1999                arg_index[res] = arg_index[arg];               
     2000#endif
    18642001#else
    18652002#if !defined(_ZOS_) /* BREAK_ZOS */
     
    18972034
    18982035#if defined(_INDO_)
     2036#if defined(_INDOPRO_)
    18992037                combine_2_index_domains(res, arg1, arg2, ind_dom);
    1900 #if defined(_NONLIND_)
    1901                 extend_nonlinearity_domain_binary(arg1, arg2, ind_dom, nonl_dom);
    1902                 extend_nonlinearity_domain_unary(arg2, ind_dom, nonl_dom);
    1903 #endif
     2038#endif
     2039#if defined(_NONLIND_)
     2040                fod[opind].entry = maxopind+2;
     2041                fod[opind].left = &fod[arg_index[arg1]];
     2042                fod[opind].right = &fod[arg_index[arg2]];
     2043                traverse_unary(&fod[arg_index[arg1]], nonl_dom, &fod[arg_index[arg2]], indcheck+1,maxopind+2);
     2044                traverse_unary(&fod[arg_index[arg2]], nonl_dom, &fod[opind], indcheck+1,maxopind+2);
     2045                arg_index[res] = opind++;               
     2046#endif
    19042047#else
    19052048#if !defined(_ZOS_) /* BREAK_ZOS */
     
    19582101
    19592102#if defined(_INDO_)
     2103#if defined(_INDOPRO_)
    19602104                copy_index_domain(res, arg, ind_dom);
    1961 #if defined(_NONLIND_)
    1962                 extend_nonlinearity_domain_unary(arg, ind_dom, nonl_dom);
    1963 #endif
     2105#endif
     2106#if defined(_NONLIND_)
     2107                fod[opind].entry = maxopind+2;
     2108                fod[opind].left = &fod[arg_index[arg]];
     2109                fod[opind].right = NULL;
     2110                traverse_unary(&fod[opind], nonl_dom, &fod[opind], indcheck+1,maxopind+2);
     2111                arg_index[res] = opind++;               
     2112#endif
    19642113#else
    19652114#if !defined(_ZOS_) /* BREAK_ZOS */
     
    20102159
    20112160#if defined(_INDO_)
     2161#if defined(_INDOPRO_)
    20122162                copy_index_domain(res, arg, ind_dom);
     2163#endif
     2164#if defined(_NONLIND_)
     2165                arg_index[res] = arg_index[arg];                           
     2166#endif 
    20132167#else
    20142168#if !defined(_ZOS_) /* BREAK_ZOS */
     
    20342188
    20352189#if defined(_INDO_)
     2190#if defined(_INDOPRO_)
    20362191                copy_index_domain(res, arg, ind_dom);
     2192#endif
     2193#if defined(_NONLIND_)
     2194                arg_index[res] = arg_index[arg];                           
     2195#endif
    20372196#else
    20382197#if !defined(_ZOS_) /* BREAK_ZOS */
     
    20692228
    20702229#if defined(_INDO_)
     2230#if defined(_INDOPRO_)
    20712231                copy_index_domain(res, arg, ind_dom);
    2072 #if defined(_NONLIND_)
    2073                 extend_nonlinearity_domain_unary(arg, ind_dom, nonl_dom);
     2232#endif
     2233#if defined(_NONLIND_)
     2234                fod[opind].entry = maxopind+2;
     2235                fod[opind].left = &fod[arg_index[arg]];
     2236                fod[opind].right = NULL;
     2237                traverse_unary(&fod[opind], nonl_dom, &fod[opind], indcheck+1,maxopind+2);
     2238                arg_index[res] = opind++;               
    20742239#endif
    20752240#else
     
    21092274            /*--------------------------------------------------------------------------*/
    21102275        case sin_op:                              /* sine operation    sin_op */
    2111             arg1 = get_locint_f();
     2276                arg1 = get_locint_f();
    21122277                arg2 = get_locint_f();
    21132278                res  = get_locint_f();
     
    21252290
    21262291#if defined(_INDO_)
     2292#if defined(_INDOPRO_)
    21272293                copy_index_domain(res, arg1, ind_dom);
    2128 #if defined(_NONLIND_)
    2129                 extend_nonlinearity_domain_unary(arg1, ind_dom, nonl_dom);
     2294#endif
     2295#if defined(_NONLIND_)
     2296                fod[opind].entry = maxopind+2;
     2297                fod[opind].left = &fod[arg_index[arg1]];
     2298                fod[opind].right = NULL;
     2299                traverse_unary(&fod[opind], nonl_dom, &fod[opind], indcheck+1,maxopind+2);
     2300                arg_index[res] = opind++;               
    21302301#endif
    21312302#else
     
    21912362
    21922363#if defined(_INDO_)
     2364#if defined(_INDOPRO_)
    21932365                copy_index_domain(res, arg1, ind_dom);
    2194 #if defined(_NONLIND_)
    2195                 extend_nonlinearity_domain_unary(arg1, ind_dom, nonl_dom);
    2196 #endif
     2366#endif
     2367#if defined(_NONLIND_)
     2368                fod[opind].entry = maxopind+2;
     2369                fod[opind].left = &fod[arg_index[arg1]];
     2370                fod[opind].right = NULL;
     2371                traverse_unary(&fod[opind], nonl_dom, &fod[opind], indcheck+1,maxopind+2);
     2372                arg_index[res] = opind++;               
     2373#endif
     2374
    21972375#else
    21982376#if !defined(_ZOS_) /* BREAK_ZOS */
     
    22542432
    22552433#if defined(_INDO_)
     2434#if defined(_INDOPRO_)
    22562435                copy_index_domain(res, arg1, ind_dom);
    2257 #if defined(_NONLIND_)
    2258                 extend_nonlinearity_domain_unary(arg1, ind_dom, nonl_dom);
     2436#endif
     2437#if defined(_NONLIND_)
     2438                fod[opind].entry = maxopind+2;
     2439                fod[opind].left = &fod[arg_index[arg1]];
     2440                fod[opind].right = NULL;
     2441                traverse_unary(&fod[opind], nonl_dom, &fod[opind], indcheck+1,maxopind+2);
     2442                arg_index[res] = opind++;               
    22592443#endif
    22602444#else
     
    23092493
    23102494#if defined(_INDO_)
     2495#if defined(_INDOPRO_)
    23112496                copy_index_domain(res, arg1, ind_dom);
    2312 #if defined(_NONLIND_)
    2313                 extend_nonlinearity_domain_unary(arg1, ind_dom, nonl_dom);
     2497#endif
     2498#if defined(_NONLIND_)
     2499                fod[opind].entry = maxopind+2;
     2500                fod[opind].left = &fod[arg_index[arg1]];
     2501                fod[opind].right = NULL;
     2502                traverse_unary(&fod[opind], nonl_dom, &fod[opind], indcheck+1,maxopind+2);
     2503                arg_index[res] = opind++;               
    23142504#endif
    23152505#else
     
    23892579            /*--------------------------------------------------------------------------*/
    23902580        case acos_op:                                              /* acos_op */
    2391             arg1 = get_locint_f();
     2581                arg1 = get_locint_f();
    23922582                arg2 = get_locint_f();
    23932583                res  = get_locint_f();
     
    24022592
    24032593#if defined(_INDO_)
     2594#if defined(_INDOPRO_)
    24042595                copy_index_domain(res, arg1, ind_dom);
    2405 #if defined(_NONLIND_)
    2406                 extend_nonlinearity_domain_unary(arg1, ind_dom, nonl_dom);
     2596#endif
     2597#if defined(_NONLIND_)
     2598                fod[opind].entry = maxopind+2;
     2599                fod[opind].left = &fod[arg_index[arg1]];
     2600                fod[opind].right = NULL;
     2601                traverse_unary(&fod[opind], nonl_dom, &fod[opind], indcheck+1,maxopind+2);
     2602                arg_index[res] = opind++;               
    24072603#endif
    24082604#else
     
    24842680            /*--------------------------------------------------------------------------*/
    24852681        case asinh_op:                                            /* asinh_op */
    2486             arg1 = get_locint_f();
     2682                arg1 = get_locint_f();
    24872683                arg2 = get_locint_f();
    24882684                res  = get_locint_f();
     
    24972693
    24982694#if defined(_INDO_)
     2695#if defined(_INDOPRO_)
    24992696                copy_index_domain(res, arg1, ind_dom);
    2500 #if defined(_NONLIND_)
    2501                 extend_nonlinearity_domain_unary(arg1, ind_dom, nonl_dom);
     2697#endif
     2698#if defined(_NONLIND_)
     2699                fod[opind].entry = maxopind+2;
     2700                fod[opind].left = &fod[arg_index[arg1]];
     2701                fod[opind].right = NULL;
     2702                traverse_unary(&fod[opind], nonl_dom, &fod[opind], indcheck+1,maxopind+2);
     2703                arg_index[res] = opind++;               
    25022704#endif
    25032705#else
     
    25392741            /*--------------------------------------------------------------------------*/
    25402742        case acosh_op:                                           /* acosh_op */
    2541             arg1 = get_locint_f();
     2743                arg1 = get_locint_f();
    25422744                arg2 = get_locint_f();
    25432745                res  = get_locint_f();
     
    25522754
    25532755#if defined(_INDO_)
     2756#if defined(_INDOPRO_)
    25542757                copy_index_domain(res, arg1, ind_dom);
    2555 #if defined(_NONLIND_)
    2556                 extend_nonlinearity_domain_unary(arg1, ind_dom, nonl_dom);
     2758#endif
     2759#if defined(_NONLIND_)
     2760                fod[opind].entry = maxopind+2;
     2761                fod[opind].left = &fod[arg_index[arg1]];
     2762                fod[opind].right = NULL;
     2763                traverse_unary(&fod[opind], nonl_dom, &fod[opind], indcheck+1,maxopind+2);
     2764                arg_index[res] = opind++;               
    25572765#endif
    25582766#else
     
    26162824            /*--------------------------------------------------------------------------*/
    26172825        case atanh_op:                                            /* atanh_op */
    2618             arg1 = get_locint_f();
     2826                arg1 = get_locint_f();
    26192827                arg2 = get_locint_f();
    26202828                res  = get_locint_f();
     
    26292837
    26302838#if defined(_INDO_)
     2839#if defined(_INDOPRO_)
    26312840                copy_index_domain(res, arg1, ind_dom);
    2632 #if defined(_NONLIND_)
    2633                 extend_nonlinearity_domain_unary(arg1, ind_dom, nonl_dom);
     2841#endif
     2842#if defined(_NONLIND_)
     2843                fod[opind].entry = maxopind+2;
     2844                fod[opind].left = &fod[arg_index[arg1]];
     2845                fod[opind].right = NULL;
     2846                traverse_unary(&fod[opind], nonl_dom, &fod[opind], indcheck+1,maxopind+2);
     2847                arg_index[res] = opind++;               
    26342848#endif
    26352849#else
     
    27152929            /*--------------------------------------------------------------------------*/
    27162930        case erf_op:                                                /* erf_op */
    2717             arg1 = get_locint_f();
     2931                arg1 = get_locint_f();
    27182932                arg2 = get_locint_f();
    27192933                res  = get_locint_f();
     
    27272941                ADOLC_OPENMP_RESTORE_THREAD_NUMBER;
    27282942#if defined(_INDO_)
     2943#if defined(_INDOPRO_)
    27292944                copy_index_domain(res, arg1, ind_dom);
     2945#endif
     2946#if defined(_NONLIND_)
     2947                fod[opind].entry = maxopind+2;
     2948                fod[opind].left = &fod[arg_index[arg1]];
     2949                fod[opind].right = NULL;
     2950                traverse_unary(&fod[opind], nonl_dom, &fod[opind], indcheck+1,maxopind+2);
     2951                arg_index[res] = opind++;               
     2952#endif       
    27302953#else
    27312954#if !defined(_ZOS_) /* BREAK_ZOS */
     
    27682991            /*--------------------------------------------------------------------------*/
    27692992        case log_op:                                                /* log_op */
    2770             arg = get_locint_f();
     2993                arg = get_locint_f();
    27712994                res = get_locint_f();
    27722995
     
    27742997
    27752998#if defined(_INDO_)
     2999#if defined(_INDOPRO_)
    27763000                copy_index_domain(res, arg, ind_dom);
    2777 #if defined(_NONLIND_)
    2778                 extend_nonlinearity_domain_unary(arg, ind_dom, nonl_dom);
     3001#endif
     3002#if defined(_NONLIND_)
     3003                fod[opind].entry = maxopind+2;
     3004                fod[opind].left = &fod[arg_index[arg]];
     3005                fod[opind].right = NULL;
     3006                traverse_unary(&fod[opind], nonl_dom, &fod[opind], indcheck+1,maxopind+2);
     3007                arg_index[res] = opind++;               
    27793008#endif
    27803009#else
     
    28523081                ADOLC_OPENMP_RESTORE_THREAD_NUMBER;
    28533082#if defined(_INDO_)
     3083#if defined(_INDOPRO_)
    28543084                copy_index_domain(res, arg, ind_dom);
    2855 #if defined(_NONLIND_)
    2856                 extend_nonlinearity_domain_unary(arg, ind_dom, nonl_dom);
     3085#endif
     3086#if defined(_NONLIND_)
     3087                fod[opind].entry = maxopind+2;
     3088                fod[opind].left = &fod[arg_index[arg]];
     3089                fod[opind].right = NULL;
     3090                traverse_unary(&fod[opind], nonl_dom, &fod[opind], indcheck+1,maxopind+2);
     3091                arg_index[res] = opind++;               
    28573092#endif
    28583093#else
     
    29873222
    29883223#if defined(_INDO_)
     3224#if defined(_INDOPRO_)
    29893225                copy_index_domain(res, arg, ind_dom);
    2990 #if defined(_NONLIND_)
    2991                 extend_nonlinearity_domain_unary(arg, ind_dom, nonl_dom);
     3226#endif
     3227#if defined(_NONLIND_)
     3228                fod[opind].entry = maxopind+2;
     3229                fod[opind].left = &fod[arg_index[arg]];
     3230                fod[opind].right = NULL;
     3231                traverse_unary(&fod[opind], nonl_dom, &fod[opind], indcheck+1,maxopind+2);
     3232                arg_index[res] = opind++;               
    29923233#endif
    29933234#else
     
    31373378#endif /* !_NTIGHT_ */
    31383379
    3139 #if defined(_INDO_)
    3140 #ifdef _TIGHT_
     3380#if defined (_INDO_)
     3381#if defined (_INDOPRO_)
     3382#if defined (_TIGHT_)
    31413383                    if (dp_T0[arg1] < dp_T0[arg2])
    31423384                        copy_index_domain(res, arg1, ind_dom);
     
    31503392                    combine_2_index_domains(res, arg1, arg2, ind_dom);
    31513393#endif
     3394#endif
     3395#if defined(_NONLIND_)
     3396#ifdef _TIGHT_
     3397                    if (dp_T0[arg1] < dp_T0[arg2])
     3398                      {
     3399                        fod[opind].entry = maxopind+2;
     3400                        fod[opind].left = &fod[arg_index[arg1]];
     3401                        fod[opind].right = NULL;
     3402                        arg_index[res] = opind++;               
     3403                      }           
     3404                    else {
     3405                        if (dp_T0[arg1] > dp_T0[arg2])
     3406                          {
     3407                            fod[opind].entry = maxopind+2;
     3408                            fod[opind].left = &fod[arg_index[arg2]];
     3409                            fod[opind].right = NULL;
     3410                            arg_index[res] = opind++;           
     3411
     3412                          }               
     3413                        else
     3414                          {
     3415                            fod[opind].entry = maxopind+2;
     3416                            fod[opind].left = &fod[arg_index[arg1]];
     3417                            fod[opind].right = &fod[arg_index[arg2]];
     3418                            arg_index[res] = opind++;           
     3419                          }
     3420                    }
     3421#else
     3422                    fod[opind].entry = maxopind+2;
     3423                    fod[opind].left = &fod[arg_index[arg1]];
     3424                    fod[opind].right = &fod[arg_index[arg2]];
     3425                    arg_index[res] = opind++;           
     3426                    arg_index[res] = opind++;           
     3427#endif
     3428#endif
    31523429#else
    31533430#if !defined(_ZOS_) /* BREAK_ZOS */
     
    31683445                { Targ = Tqo;
    31693446                  if (Targ == NULL) /* e.g. T0[arg1] == T0[arg2] */
    3170               { Targ1OP = Targ1;
    3171                   Targ2OP = Targ2;
    3172                   if (TARG1 > TARG2)
     3447                    { Targ1OP = Targ1;
     3448                      Targ2OP = Targ2;
     3449                      if (TARG1 > TARG2)
    31733450                          Targ = Targ2OP;
    31743451                      else
     
    31843461
    31853462                  if (Tqo)
    3186                   Tqo++;
     3463                    Tqo++;
    31873464                }
    31883465
     
    32663543
    32673544#if defined(_INDO_)
    3268           copy_index_domain(res, arg, ind_dom);
     3545#if defined(_INDOPRO_)
     3546                copy_index_domain(res, arg, ind_dom);
     3547#endif
     3548#if defined(_NONLIND_)
     3549                arg_index[res] = arg_index[arg];               
     3550#endif
    32693551#else
    32703552#if !defined(_ZOS_) /* BREAK_ZOS */
     
    33403622
    33413623#if defined(_INDO_)
    3342           copy_index_domain(res, arg, ind_dom);
     3624#if defined(_INDOPRO_)
     3625                copy_index_domain(res, arg, ind_dom);
     3626#endif
     3627#if defined(_NONLIND_)
     3628                arg_index[res] = arg_index[arg];               
     3629#endif
    33433630#else
    33443631#if !defined(_ZOS_) /* BREAK_ZOS */
     
    33673654
    33683655#if defined(_INDO_)
    3369           copy_index_domain(res, arg, ind_dom);
     3656#if defined(_INDOPRO_)
     3657                copy_index_domain(res, arg, ind_dom);
     3658#endif
     3659#if defined(_NONLIND_)
     3660                arg_index[res] = arg_index[arg];               
     3661#endif
    33703662#else
    33713663#if !defined(_ZOS_) /* BREAK_ZOS */
     
    33933685
    33943686                /* olvo 980924 changed order to allow reflexive ops */
    3395 #if defined(_INDO_)
    3396 #ifdef _TIGHT_
     3687#if defined (_INDO_)
     3688#if defined (_INDOPRO_)
     3689#if defined (_TIGHT_)
    33973690                if (dp_T0[arg] > 0) {
    33983691                    if (coval <= 0.0)
     
    34003693                    dp_T0[res] = dp_T0[arg1];
    34013694
    3402               combine_2_index_domains(res, arg1, arg2, ind_dom);
    3403 #else
    3404                         copy_index_domain(res, arg1, ind_dom);
    3405 #endif
    3406 #ifdef _TIGHT_
     3695                    copy_index_domain(res, arg1, ind_dom);
     3696
    34073697                } else {
    34083698                    if (coval > 0.0)
     
    34113701                        MINDEC(ret_c,0);
    34123702                    dp_T0[res] = dp_T0[arg2];
    3413 
    3414                         combine_2_index_domains(res, arg1, arg2, ind_dom);
     3703                    copy_index_domain(res, arg2, ind_dom);
    34153704                }
    34163705#else
    3417                         copy_index_domain(res, arg2, ind_dom);
     3706                    combine_2_index_domains(res, arg1, arg2, ind_dom);
     3707#endif
     3708#endif
     3709#if defined (_NONLIND_)
     3710#ifdef _TIGHT_
     3711                if (dp_T0[arg] > 0) {
     3712                    if (coval <= 0.0)
     3713                        MINDEC(ret_c,2);
     3714                    dp_T0[res] = dp_T0[arg1];
     3715
     3716                    arg_index[res] = arg_index[arg1];           
     3717                } else {
     3718                    if (coval > 0.0)
     3719                        MINDEC(ret_c,2);
     3720                    if (dp_T0[arg] == 0)
     3721                        MINDEC(ret_c,0);
     3722                    dp_T0[res] = dp_T0[arg2];
     3723
     3724                    arg_index[res] = arg_index[arg2];           
     3725                }
     3726
     3727#else
     3728               arg_index[res] = opind++;               
     3729#endif
    34183730#endif
    34193731#else
     
    34873799                /* olvo 980924 changed order to allow reflexive ops */
    34883800#if defined(_INDO_)
    3489                     copy_index_domain(res, arg1, ind_dom);
     3801#if defined(_INDOPRO_)
     3802                copy_index_domain(res, arg1, ind_dom);
     3803#endif
     3804#if defined(_NONLIND_)
     3805                arg_index[res] = arg_index[arg1];               
     3806#endif
    34903807#else
    34913808#if !defined(_ZOS_) /* BREAK_ZOS */
     
    37054022
    37064023#if defined(_INDO_)
    3707 
     4024#if defined(_INDOPRO_)
    37084025    for(i=0;i<max_ind_dom;i++)
    37094026      {
    3710      free(ind_dom[i]);
     4027        free(ind_dom[i]);
    37114028      }
    37124029    free(ind_dom);
    3713 
    3714 #if defined(_NONLIND_)
    3715 
     4030#endif
     4031#if defined(_NONLIND_)
    37164032    for( i=0; i < indcheck; i++) {
    3717        crs[i] = (unsigned int*) malloc(sizeof(unsigned int) * (nonl_dom[i][0]+1));
    3718        crs[i][0] = nonl_dom[i][0];
    3719        for(l=1; l < crs[i][0]+1; l++)
    3720           crs[i][l] = nonl_dom[i][l+1];
    3721        free(nonl_dom[i]);
     4033      traverse_crs(&nonl_dom[i],&sod[i],indcheck+1);
     4034      free_tree(&nonl_dom[i],indcheck+1);
     4035      crs[i] = (unsigned int*) malloc(sizeof(unsigned int) * (sod[i].entry+1));
     4036      crs[i][0] = sod[i].entry;
     4037      temp = sod[i].left;
     4038      for( ii=1; ii <=sod[i].entry; ii++)
     4039        {
     4040          crs[i][ii] = temp->entry;
     4041          temp1 = temp->left;
     4042          free(temp);
     4043          temp = temp1;
     4044        }
    37224045    }
     4046
     4047    free(sod);
    37234048    free(nonl_dom);
     4049    free(fod);
     4050    free(arg_index);
    37244051
    37254052#endif
     
    38494176#if defined(_TIGHT_)
    38504177
    3851 void extend_nonlinearity_domain_binary_step
    3852 (int arg1, int arg2, locint **ind_dom, locint **nonl_dom)
     4178void free_tree(IndexElement* tree, int num)
    38534179{
    3854   int index,num,num1, num2, i,j,k,l,m;
    3855   locint *temp_nonl, *index_nonl_dom, *arg1_ind_dom, *arg2_ind_dom;
    3856 
    3857   num = ind_dom[arg2][0];
    3858 
    3859   for(m=2;m<ind_dom[arg1][0]+2;m++)
     4180
     4181  if (tree->left != NULL)
    38604182    {
    3861       index = ind_dom[arg1][m];
    3862       index_nonl_dom = nonl_dom[index];
    3863 
    3864       if (index_nonl_dom[0] == 0)  /* empty list */
    3865      {
    3866        if ( index_nonl_dom[1] < num)
    3867          {
    3868            free(index_nonl_dom);
    3869            index_nonl_dom = (locint*) malloc(sizeof(locint)*2*(num+1) );
    3870            index_nonl_dom[1] = 2*num;
    3871          }
    3872        for(i=2;i<num+2;i++)      /* append index domain list of "arg" */
    3873          index_nonl_dom[i] = ind_dom[arg2][i];
    3874        index_nonl_dom[0] = num;
     4183      free_tree(tree->left,num);
     4184    }
     4185  if (tree->right != NULL)
     4186    {
     4187      free_tree(tree->right,num);
    38754188     }
     4189    {
     4190      if (tree->entry == num)
     4191        free(tree);
     4192
     4193    }
     4194 
     4195}
     4196void traverse_crs(IndexElement* tree,  IndexElement_sod* sod, int num)
     4197{
     4198
     4199  IndexElement_sod *temp, *temp1;
     4200  int ii;
     4201
     4202  if (tree->left != NULL)
     4203    {
     4204      traverse_crs(tree->left, sod, num);
     4205    }
     4206  if (tree->right != NULL)
     4207    {
     4208      traverse_crs(tree->right, sod, num);
     4209    }
     4210  if (tree->entry < num)
     4211    {
     4212      temp = sod->left;
     4213      if (temp == NULL)
     4214        {
     4215          temp = (struct IndexElement_sod*) malloc(sizeof(struct IndexElement_sod));
     4216          temp->left = NULL;
     4217          temp->entry = tree->entry;
     4218          sod->entry++;
     4219          sod->left=temp;
     4220        }
    38764221      else
    3877      { /* merge lists */
    3878        num1 = index_nonl_dom[0];
    3879        num2 = index_nonl_dom[1];
    3880 
    3881        if (num1+num > num2)
    3882          num2 = num1+num;
    3883 
    3884        temp_nonl = (locint*) malloc(sizeof(locint)*(num2+2));
    3885        temp_nonl[1] = num2;
    3886 
    3887        i = 2;
    3888        k = 2;
    3889        j = 2;
    3890        num1 +=2;
    3891        num2 = num+2;
    3892        while ((i<num1) && (j < num2)){
    3893          if (ind_dom[arg2][j] < index_nonl_dom[i]) /* < */ {
    3894            temp_nonl[k] = ind_dom[arg2][j];
    3895            j++; k++;
    3896          } else {
    3897            if (ind_dom[arg2][j] == index_nonl_dom[i])  /* == */ {
    3898           temp_nonl[k] = ind_dom[arg2][j];
    3899           j++; k++; i++;
    3900            } else {
    3901           temp_nonl[k] = index_nonl_dom[i];
    3902           i++; k++;
    3903            }
    3904          }
    3905        }
    3906        for(l = j;l<num2;l++) {
    3907          temp_nonl[k] = ind_dom[arg2][l];
    3908          k++;
    3909        }
    3910        for(l = i;l<num1;l++) {
    3911          temp_nonl[k] = index_nonl_dom[l];
    3912          k++;
    3913        }
    3914        temp_nonl[0] = k-2;
    3915        free((char*) nonl_dom[index]);
    3916        nonl_dom[index] = temp_nonl;
    3917      }
     4222        {
     4223          while ((temp->entry < tree->entry) && (temp->left != NULL))
     4224            {
     4225              temp1 = temp;
     4226              temp = temp->left;
     4227            }
     4228          if (temp->left == NULL)
     4229            {
     4230              if(temp->entry < tree->entry)
     4231                {
     4232                  temp->left = (struct IndexElement_sod*) malloc(sizeof(struct IndexElement_sod));
     4233                  temp = temp->left;
     4234                  temp->left = NULL;
     4235                  temp->entry = tree->entry;
     4236                  sod->entry++;
     4237                }
     4238              if(temp->entry > tree->entry)
     4239                {
     4240                  temp->left = (struct IndexElement_sod*) malloc(sizeof(struct IndexElement_sod));
     4241                  temp->left->entry = temp->entry;
     4242                  temp->left->left = NULL;
     4243                  temp->entry = tree->entry;
     4244                  sod->entry++;
     4245                }
     4246            }
     4247          else
     4248            {
     4249              if (temp->entry > tree->entry)
     4250                {
     4251                  temp1 = (struct IndexElement_sod*) malloc(sizeof(struct IndexElement_sod));
     4252                  temp1->left = temp->left;
     4253                  temp1->entry = temp->entry;
     4254                  temp->entry = tree->entry;
     4255                  temp->left=temp1;
     4256                  sod->entry++;
     4257                }
     4258             
     4259            }
     4260        }
    39184261    }
    39194262}
    39204263
    3921 void extend_nonlinearity_domain_unary
    3922 (int arg, locint **ind_dom, locint **nonl_dom) {
    3923     extend_nonlinearity_domain_binary_step(arg, arg, ind_dom, nonl_dom);
     4264void traverse_unary(IndexElement* tree,  IndexElement* nonl_dom,  IndexElement* fodi, int num, int maxopind)
     4265{
     4266  IndexElement *temp;
     4267
     4268  if (tree->left != NULL)
     4269    {
     4270      traverse_unary(tree->left, nonl_dom, fodi, num, maxopind);
     4271      if (tree->right != NULL)
     4272        {
     4273          traverse_unary(tree->right, nonl_dom, fodi, num, maxopind);
     4274        }
     4275     }
     4276  else
     4277    {
     4278      if(tree->entry<maxopind)
     4279        {
     4280          temp = (struct IndexElement*) malloc(sizeof(struct IndexElement));
     4281          temp->right = fodi;
     4282          temp->left = nonl_dom[tree->entry].left;
     4283          temp->entry= num;
     4284          nonl_dom[tree->entry].left = temp;
     4285        }
     4286    }
    39244287}
    39254288
    3926 void extend_nonlinearity_domain_binary
    3927 (int arg1, int arg2, locint **ind_dom, locint **nonl_dom) {
    3928     extend_nonlinearity_domain_binary_step(arg1, arg2, ind_dom, nonl_dom);
    3929     extend_nonlinearity_domain_binary_step(arg2, arg1, ind_dom, nonl_dom);
    3930 }
    3931 
    3932 
    39334289#endif
    39344290#endif
Note: See TracChangeset for help on using the changeset viewer.