Changeset 676


Ignore:
Timestamp:
Mar 17, 2016 10:29:13 AM (4 years ago)
Author:
kulshres
Message:

add a condeqassign to test for a >= 0

since condassign only tests for a > 0, there was no equality test

Signed-off-by: Kshitij Kulshreshtha <kshitij@…>

Location:
trunk/ADOL-C
Files:
9 edited

Legend:

Unmodified
Added
Removed
  • trunk/ADOL-C/include/adolc/adouble.h

    r658 r676  
    6363                                  const double &arg );
    6464
     65void ADOLC_DLL_EXPORT condeqassign( double &res, const double &cond,
     66                                    const double &arg1, const double &arg2 );
     67void ADOLC_DLL_EXPORT condeqassign( double &res, const double &cond,
     68                                    const double &arg );
    6569
    6670/****************************************************************************/
     
    185189            const badouble &arg1, const badouble &arg2 );
    186190    friend ADOLC_DLL_EXPORT void condassign( adouble &res, const badouble &cond,
     191            const badouble &arg );
     192    friend ADOLC_DLL_EXPORT void condeqassign( adouble &res, const badouble &cond,
     193            const badouble &arg1, const badouble &arg2 );
     194    friend ADOLC_DLL_EXPORT void condeqassign( adouble &res, const badouble &cond,
    187195            const badouble &arg );
    188196
  • trunk/ADOL-C/include/adolc/adtl.h

    r631 r676  
    151151            const adouble &arg1, const adouble &arg2 );
    152152    inline friend void condassign( adouble &res, const adouble &cond,
     153            const adouble &arg );
     154    inline friend void condeqassign( adouble &res, const adouble &cond,
     155            const adouble &arg1, const adouble &arg2 );
     156    inline friend void condeqassign( adouble &res, const adouble &cond,
    153157            const adouble &arg );
    154158
     
    13231327}
    13241328
     1329inline void condeqassign( adouble &res, const adouble &cond,
     1330                          const adouble &arg1, const adouble &arg2 ) {
     1331    if (no_do_val()) {
     1332        fprintf(DIAG_OUT, "ADOL-C error: Tapeless: Incorrect mode, call setMode(enum Mode mode)\n");
     1333        throw logic_error("incorrect function call, errorcode=1");
     1334    }
     1335    if (do_val()) {
     1336        if (cond.getValue() >= 0)
     1337            res = arg1;
     1338        else
     1339            res = arg2;
     1340    }
     1341}
     1342
     1343inline void condeqassign( adouble &res, const adouble &cond,
     1344                          const adouble &arg ) {
     1345    if (no_do_val()) {
     1346        fprintf(DIAG_OUT, "ADOL-C error: Tapeless: Incorrect mode, call setMode(enum Mode mode)\n");
     1347        throw logic_error("incorrect function call, errorcode=1");
     1348    }
     1349    if (do_val()) {
     1350        if (cond.getValue() >= 0)
     1351            res = arg;
     1352    }
     1353}
     1354
    13251355
    13261356
  • trunk/ADOL-C/include/adolc/advector.h

    r658 r676  
    107107    friend ADOLC_DLL_EXPORT void condassign(adubref&, const badouble&, const badouble&, const badouble&);
    108108    friend ADOLC_DLL_EXPORT void condassign(adubref&, const badouble&, const badouble&);
     109    friend ADOLC_DLL_EXPORT void condeqassign(adubref&, const badouble&, const badouble&, const badouble&);
     110    friend ADOLC_DLL_EXPORT void condeqassign(adubref&, const badouble&, const badouble&);
    109111    ~adubref();
    110112};
  • trunk/ADOL-C/src/adouble.cpp

    r673 r676  
    4444}
    4545
     46/*--------------------------------------------------------------------------*/
     47void condeqassign( double &res, const double &cond,
     48                   const double &arg1, const double &arg2 ) {
     49    res = cond >= 0 ? arg1 : arg2;
     50}
     51
     52/*--------------------------------------------------------------------------*/
     53void condeqassign( double &res, const double &cond,
     54                   const double &arg) {
     55    res = cond >= 0 ? arg : res;
     56}
    4657/*--------------------------------------------------------------------------*/
    4758/* The remaining routines define the badouble, adub and adouble routines.   */
     
    20192030        ADOLC_GLOBAL_TAPE_VARS.store[res.loc()] = ADOLC_GLOBAL_TAPE_VARS.store[arg.loc()];
    20202031}
     2032/*--------------------------------------------------------------------------*/
     2033void condeqassign( adouble &res,         const badouble &cond,
     2034                   const badouble &arg1, const badouble &arg2 ) {
     2035    ADOLC_OPENMP_THREAD_NUMBER;
     2036    ADOLC_OPENMP_GET_THREAD_NUMBER;
     2037    if (ADOLC_CURRENT_TAPE_INFOS.traceFlag) { // old: write_condassign(res.loc(),cond.loc(),arg1.loc(),
     2038        //                   arg2.loc());
     2039        put_op(cond_eq_assign);
     2040        ADOLC_PUT_LOCINT(cond.loc()); // = arg
     2041        ADOLC_PUT_VAL(ADOLC_GLOBAL_TAPE_VARS.store[cond.loc()]);
     2042        ADOLC_PUT_LOCINT(arg1.loc()); // = arg1
     2043        ADOLC_PUT_LOCINT(arg2.loc()); // = arg2
     2044        ADOLC_PUT_LOCINT(res.loc());  // = res
     2045
     2046        ++ADOLC_CURRENT_TAPE_INFOS.numTays_Tape;
     2047        if (ADOLC_CURRENT_TAPE_INFOS.keepTaylors)
     2048            ADOLC_WRITE_SCAYLOR(ADOLC_GLOBAL_TAPE_VARS.store[res.loc()]);
     2049    }
     2050
     2051    if (ADOLC_GLOBAL_TAPE_VARS.store[cond.loc()] >= 0)
     2052        ADOLC_GLOBAL_TAPE_VARS.store[res.loc()] = ADOLC_GLOBAL_TAPE_VARS.store[arg1.loc()];
     2053    else
     2054        ADOLC_GLOBAL_TAPE_VARS.store[res.loc()] = ADOLC_GLOBAL_TAPE_VARS.store[arg2.loc()];
     2055}
     2056
     2057/*--------------------------------------------------------------------------*/
     2058void condeqassign( adouble &res, const badouble &cond, const badouble &arg ) {
     2059    ADOLC_OPENMP_THREAD_NUMBER;
     2060    ADOLC_OPENMP_GET_THREAD_NUMBER;
     2061    if (ADOLC_CURRENT_TAPE_INFOS.traceFlag) { // old: write_condassign2(res.loc(),cond.loc(),arg.loc());
     2062        put_op(cond_eq_assign_s);
     2063        ADOLC_PUT_LOCINT(cond.loc()); // = arg
     2064        ADOLC_PUT_VAL(ADOLC_GLOBAL_TAPE_VARS.store[cond.loc()]);
     2065        ADOLC_PUT_LOCINT(arg.loc());  // = arg1
     2066        ADOLC_PUT_LOCINT(res.loc());  // = res
     2067
     2068        ++ADOLC_CURRENT_TAPE_INFOS.numTays_Tape;
     2069        if (ADOLC_CURRENT_TAPE_INFOS.keepTaylors)
     2070            ADOLC_WRITE_SCAYLOR(ADOLC_GLOBAL_TAPE_VARS.store[res.loc()]);
     2071    }
     2072
     2073    if (ADOLC_GLOBAL_TAPE_VARS.store[cond.loc()] >= 0)
     2074        ADOLC_GLOBAL_TAPE_VARS.store[res.loc()] = ADOLC_GLOBAL_TAPE_VARS.store[arg.loc()];
     2075}
    20212076
    20222077/****************************************************************************/
  • trunk/ADOL-C/src/advector.cpp

    r658 r676  
    394394
    395395    if (ADOLC_GLOBAL_TAPE_VARS.store[cond.loc()] > 0)
     396        ADOLC_GLOBAL_TAPE_VARS.store[res.refloc] = ADOLC_GLOBAL_TAPE_VARS.store[arg.loc()];
     397}
     398
     399void condeqassign( adubref& res,         const badouble &cond,
     400                   const badouble &arg1, const badouble &arg2 ) {
     401    ADOLC_OPENMP_THREAD_NUMBER;
     402    ADOLC_OPENMP_GET_THREAD_NUMBER;
     403    if (ADOLC_CURRENT_TAPE_INFOS.traceFlag) { // old: write_condassign(res.location,cond.location,arg1.location,
     404        //                   arg2.location);
     405        put_op(ref_cond_eq_assign);
     406        ADOLC_PUT_LOCINT(cond.loc()); // = arg
     407        ADOLC_PUT_VAL(ADOLC_GLOBAL_TAPE_VARS.store[cond.loc()]);
     408        ADOLC_PUT_LOCINT(arg1.loc()); // = arg1
     409        ADOLC_PUT_LOCINT(arg2.loc()); // = arg2
     410        ADOLC_PUT_LOCINT(res.location);  // = res
     411
     412        ++ADOLC_CURRENT_TAPE_INFOS.numTays_Tape;
     413        if (ADOLC_CURRENT_TAPE_INFOS.keepTaylors)
     414            ADOLC_WRITE_SCAYLOR(ADOLC_GLOBAL_TAPE_VARS.store[res.refloc]);
     415    }
     416
     417    if (ADOLC_GLOBAL_TAPE_VARS.store[cond.loc()] >= 0)
     418        ADOLC_GLOBAL_TAPE_VARS.store[res.refloc] = ADOLC_GLOBAL_TAPE_VARS.store[arg1.loc()];
     419    else
     420        ADOLC_GLOBAL_TAPE_VARS.store[res.refloc] = ADOLC_GLOBAL_TAPE_VARS.store[arg2.loc()];
     421}
     422
     423void condeqassign( adubref& res, const badouble &cond, const badouble &arg ) {
     424    ADOLC_OPENMP_THREAD_NUMBER;
     425    ADOLC_OPENMP_GET_THREAD_NUMBER;
     426    if (ADOLC_CURRENT_TAPE_INFOS.traceFlag) { // old: write_condassign2(res.location,cond.location,arg.location);
     427        put_op(ref_cond_eq_assign_s);
     428        ADOLC_PUT_LOCINT(cond.loc()); // = arg
     429        ADOLC_PUT_VAL(ADOLC_GLOBAL_TAPE_VARS.store[cond.loc()]);
     430        ADOLC_PUT_LOCINT(arg.loc());  // = arg1
     431        ADOLC_PUT_LOCINT(res.location);  // = res
     432
     433        ++ADOLC_CURRENT_TAPE_INFOS.numTays_Tape;
     434        if (ADOLC_CURRENT_TAPE_INFOS.keepTaylors)
     435            ADOLC_WRITE_SCAYLOR(ADOLC_GLOBAL_TAPE_VARS.store[res.refloc]);
     436    }
     437
     438    if (ADOLC_GLOBAL_TAPE_VARS.store[cond.loc()] >= 0)
    396439        ADOLC_GLOBAL_TAPE_VARS.store[res.refloc] = ADOLC_GLOBAL_TAPE_VARS.store[arg.loc()];
    397440}
  • trunk/ADOL-C/src/fo_rev.c

    r668 r676  
    19641964                break;
    19651965
     1966        case cond_eq_assign:                                      /* cond_assign */
     1967            res    = get_locint_r();
     1968                arg2   = get_locint_r();
     1969                arg1   = get_locint_r();
     1970                arg    = get_locint_r();
     1971#if !defined(_NTIGHT_)
     1972                coval  = get_val_r();
     1973
     1974                ADOLC_GET_TAYLOR(res);
     1975#endif /* !_NTIGHT_ */
     1976
     1977                ASSIGN_A( Aarg1, ADJOINT_BUFFER[arg1])
     1978                ASSIGN_A( Ares,  ADJOINT_BUFFER[res])
     1979                ASSIGN_A( Aarg2, ADJOINT_BUFFER[arg2])
     1980
     1981#if !defined(_NTIGHT_)
     1982                /* olvo 980924 changed code a little bit */
     1983                if (TARG >= 0.0) {
     1984                    if (res != arg1)
     1985                        FOR_0_LE_l_LT_p
     1986                        { if ((coval < 0.0) && (ARES))
     1987                          MINDEC(ret_c,2);
     1988#if defined(_INT_REV_)
     1989                              AARG1_INC |= ARES;
     1990                              ARES_INC = 0;
     1991#else
     1992                          AARG1_INC += ARES;
     1993                          ARES_INC = 0.0;
     1994#endif
     1995                        } else
     1996                            FOR_0_LE_l_LT_p
     1997                            if ((coval < 0.0) && (ARES_INC))
     1998                                    MINDEC(ret_c,2);
     1999                } else {
     2000                    if (res != arg2)
     2001                        FOR_0_LE_l_LT_p
     2002                        { if ((coval < 0.0) && (ARES))
     2003                          MINDEC(ret_c,2);
     2004#if defined(_INT_REV_)
     2005                          AARG2_INC |= ARES;
     2006                          ARES_INC = 0;
     2007#else
     2008                          AARG2_INC += ARES;
     2009                          ARES_INC = 0.0;
     2010#endif
     2011                        } else
     2012                            FOR_0_LE_l_LT_p
     2013                            if ((coval < 0.0) && (ARES_INC))
     2014                                    MINDEC(ret_c,2);
     2015                }
     2016#else
     2017                    if (res != arg1) {
     2018                        FOR_0_LE_l_LT_p
     2019                        AARG1_INC |= ARES_INC;
     2020                        ASSIGN_A( Ares,  ADJOINT_BUFFER[res])
     2021                    }
     2022                    if (res != arg2) {
     2023                        FOR_0_LE_l_LT_p
     2024                        AARG2_INC |= ARES_INC;
     2025                        ASSIGN_A( Ares,  ADJOINT_BUFFER[res])
     2026                    }
     2027                    if ((res != arg1) && (res != arg2))
     2028                        FOR_0_LE_l_LT_p
     2029                        ARES_INC = 0;
     2030#endif /* !_NTIGHT_ */
     2031                break;
     2032
    19662033                /*--------------------------------------------------------------------------*/
    19672034            case cond_assign_s:                                  /* cond_assign_s */
     
    20012068                        if (ARES_INC)
    20022069                            MINDEC(ret_c,0);
     2070#else
     2071                    if (res != arg1)
     2072                        FOR_0_LE_l_LT_p
     2073                        { AARG1 |= ARES;
     2074                          ARES_INC = 0;
     2075                        }
     2076#endif /* !_NTIGHT_ */
     2077                break;
     2078
     2079            case cond_eq_assign_s:                                  /* cond_eq_assign_s */
     2080                res   = get_locint_r();
     2081                arg1  = get_locint_r();
     2082                arg   = get_locint_r();
     2083#if !defined(_NTIGHT_)
     2084                coval = get_val_r();
     2085
     2086                ADOLC_GET_TAYLOR(res);
     2087#endif /* !_NTIGHT_ */
     2088
     2089                ASSIGN_A( Aarg1, ADJOINT_BUFFER[arg1])
     2090                ASSIGN_A( Ares,  ADJOINT_BUFFER[res])
     2091
     2092#if !defined(_NTIGHT_)
     2093                /* olvo 980924 changed code a little bit */
     2094                if (TARG >= 0.0) {
     2095                    if (res != arg1)
     2096                        FOR_0_LE_l_LT_p
     2097                        { if ((coval < 0.0) && (ARES))
     2098                          MINDEC(ret_c,2);
     2099#if defined(_INT_REV_)
     2100                          AARG1_INC |= ARES;
     2101                          ARES_INC = 0.0;
     2102#else
     2103                          AARG1_INC += ARES;
     2104                          ARES_INC = 0.0;
     2105#endif
     2106                        } else
     2107                            FOR_0_LE_l_LT_p
     2108                            if ((coval < 0.0) && (ARES_INC))
     2109                                    MINDEC(ret_c,2);
     2110                }
    20032111#else
    20042112                    if (res != arg1)
     
    26032711                break;
    26042712
     2713        case ref_cond_eq_assign:                                      /* cond_eq_assign */
     2714           {
     2715#if !defined(_NTIGHT_)
     2716                locint ref    =
     2717#endif
     2718                get_locint_r();
     2719                arg2   = get_locint_r();
     2720                arg1   = get_locint_r();
     2721                arg    = get_locint_r();
     2722#if !defined(_NTIGHT_)
     2723                coval  = get_val_r();
     2724                res = (size_t)trunc(fabs(rp_T[ref]));
     2725
     2726                ADOLC_GET_TAYLOR(res);
     2727
     2728                ASSIGN_A( Aarg1, ADJOINT_BUFFER[arg1])
     2729                ASSIGN_A( Ares,  ADJOINT_BUFFER[res])
     2730                ASSIGN_A( Aarg2, ADJOINT_BUFFER[arg2])
     2731
     2732                /* olvo 980924 changed code a little bit */
     2733                if (TARG >= 0.0) {
     2734                    if (res != arg1)
     2735                        FOR_0_LE_l_LT_p
     2736                        { if ((coval < 0.0) && (ARES))
     2737                          MINDEC(ret_c,2);
     2738#if defined(_INT_REV_)
     2739                              AARG1_INC |= ARES;
     2740                              ARES_INC = 0;
     2741#else
     2742                          AARG1_INC += ARES;
     2743                          ARES_INC = 0.0;
     2744#endif
     2745                        } else
     2746                            FOR_0_LE_l_LT_p
     2747                            if ((coval < 0.0) && (ARES_INC))
     2748                                    MINDEC(ret_c,2);
     2749                } else {
     2750                    if (res != arg2)
     2751                        FOR_0_LE_l_LT_p
     2752                        { if ((coval < 0.0) && (ARES))
     2753                          MINDEC(ret_c,2);
     2754#if defined(_INT_REV_)
     2755                          AARG2_INC |= ARES;
     2756                          ARES_INC = 0;
     2757#else
     2758                          AARG2_INC += ARES;
     2759                          ARES_INC = 0.0;
     2760#endif
     2761                        } else
     2762                            FOR_0_LE_l_LT_p
     2763                            if ((coval < 0.0) && (ARES_INC))
     2764                                    MINDEC(ret_c,2);
     2765                }
     2766#else
     2767                fprintf(DIAG_OUT, "ADOL-C error: active vector element referencing does not work in safe mode, please use tight mode\n");
     2768                adolc_exit(-2,"",__func__,__FILE__,__LINE__);
     2769#endif /* !_NTIGHT_ */
     2770                }
     2771                break;
     2772
    26052773            case ref_cond_assign_s:                                  /* cond_assign_s */
    26062774                arg2   = get_locint_r();
     
    26372805                        if (ARES_INC)
    26382806                            MINDEC(ret_c,0);
     2807#else
     2808                fprintf(DIAG_OUT, "ADOL-C error: active vector element referencing does not work in safe mode, please use tight mode\n");
     2809                adolc_exit(-2,"",__func__,__FILE__,__LINE__);
     2810#endif /* !_NTIGHT_ */
     2811                break;
     2812
     2813            case ref_cond_eq_assign_s:                                  /* cond_eq_assign_s */
     2814                arg2   = get_locint_r();
     2815                arg1  = get_locint_r();
     2816                arg   = get_locint_r();
     2817#if !defined(_NTIGHT_)
     2818                coval = get_val_r();
     2819                res = (size_t)trunc(fabs(TARG2));
     2820                ADOLC_GET_TAYLOR(res);
     2821
     2822                ASSIGN_A( Aarg1, ADJOINT_BUFFER[arg1])
     2823                ASSIGN_A( Ares,  ADJOINT_BUFFER[res])
     2824
     2825                /* olvo 980924 changed code a little bit */
     2826                if (TARG >= 0.0) {
     2827                    if (res != arg1)
     2828                        FOR_0_LE_l_LT_p
     2829                        { if ((coval < 0.0) && (ARES))
     2830                          MINDEC(ret_c,2);
     2831#if defined(_INT_REV_)
     2832                          AARG1_INC |= ARES;
     2833                          ARES_INC = 0.0;
     2834#else
     2835                          AARG1_INC += ARES;
     2836                          ARES_INC = 0.0;
     2837#endif
     2838                        } else
     2839                            FOR_0_LE_l_LT_p
     2840                            if ((coval < 0.0) && (ARES_INC))
     2841                                    MINDEC(ret_c,2);
     2842                }
    26392843#else
    26402844                fprintf(DIAG_OUT, "ADOL-C error: active vector element referencing does not work in safe mode, please use tight mode\n");
  • trunk/ADOL-C/src/ho_rev.c

    r595 r676  
    22812281                break;
    22822282
     2283            case cond_eq_assign:                                      /* cond_eq_assign */
     2284                res   = get_locint_r();
     2285                arg2  = get_locint_r();
     2286                arg1  = get_locint_r();
     2287                arg   = get_locint_r();
     2288                coval = get_val_r();
     2289
     2290                GET_TAYL(res,k,p)
     2291
     2292                ASSIGN_A(Aarg1, rpp_A[arg1])
     2293                ASSIGN_A(Ares,  rpp_A[res])
     2294                ASSIGN_A(Aarg2, rpp_A[arg2])
     2295                ASSIGN_T(Targ,  rpp_T[arg])
     2296
     2297                /* olvo 980925 changed code a little bit */
     2298                if (TARG >= 0.0) {
     2299                    if (res != arg1)
     2300                        FOR_0_LE_l_LT_p
     2301                        { if (0 == ARES) {
     2302                          HOV_INC(Ares,  k1)
     2303                              HOV_INC(Aarg1, k1)
     2304                          } else {
     2305                              if (coval < 0.0)
     2306                                  MINDEC(ret_c,2);
     2307                              MAXDEC(AARG1,ARES);
     2308                              ARES_INC = 0.0;
     2309                              AARG1_INC_O;
     2310                              FOR_0_LE_i_LT_k
     2311                              { AARG1_INC += ARES;
     2312                                ARES_INC = 0;
     2313                              }
     2314                          }
     2315                    }
     2316                    else
     2317                        FOR_0_LE_l_LT_p {
     2318                            if ((coval < 0.0) && (ARES))
     2319                            MINDEC(ret_c,2);
     2320                            HOV_INC(Ares,  k1)
     2321                        }
     2322                    } else /* TARG < 0.0 */
     2323            {
     2324                if (res != arg2)
     2325                        FOR_0_LE_l_LT_p
     2326                        { if (0 == ARES) {
     2327                          HOV_INC(Ares,  k1)
     2328                              HOV_INC(Aarg2, k1)
     2329                          } else {
     2330                                  if (coval < 0.0)
     2331                                      MINDEC(ret_c,2);
     2332                                  MAXDEC(AARG2,ARES);
     2333                                  AARG2_INC_O;
     2334                              ARES_INC = 0.0;
     2335
     2336                              FOR_0_LE_i_LT_k
     2337                              { AARG2_INC += ARES;
     2338                                ARES_INC = 0;
     2339                              }
     2340                          }
     2341                      HOV_INC(Aarg1, k1)
     2342                    } else
     2343                        FOR_0_LE_l_LT_p {
     2344                            if (ARES) {
     2345                                    if (coval < 0.0)
     2346                                        MINDEC(ret_c,2);
     2347                            }
     2348                        HOV_INC(Ares,  k1)
     2349                        HOV_INC(Aarg1, k1)
     2350                        HOV_INC(Aarg2, k1)
     2351                    }
     2352                }
     2353                break;
     2354
    22832355                /*--------------------------------------------------------------------------*/
    22842356            case cond_assign_s:                                  /* cond_assign_s */
     
    23252397                            FOR_0_LE_l_LT_p {
    23262398                                if ((coval <= 0.0) && (ARES))
     2399                                MINDEC(ret_c,2);
     2400                                HOV_INC(Ares,  k1)
     2401                            }
     2402                        }
     2403            break;
     2404            case cond_eq_assign_s:                                  /* cond_eq_assign_s */
     2405                res   = get_locint_r();
     2406                arg1  = get_locint_r();
     2407                arg   = get_locint_r();
     2408                coval = get_val_r();
     2409
     2410                GET_TAYL(res,k,p)
     2411
     2412                ASSIGN_A(Aarg1, rpp_A[arg1])
     2413                ASSIGN_A(Ares,  rpp_A[res])
     2414                ASSIGN_T(Targ,  rpp_T[arg])
     2415
     2416                /* olvo 980925 changed code a little bit */
     2417                    if (TARG >= 0.0) {
     2418                        if (res != arg1)
     2419                            FOR_0_LE_l_LT_p
     2420                            { if  (0 == ARES) {
     2421                              HOV_INC(Ares,  k1)
     2422                                  HOV_INC(Aarg1, k1)
     2423                              } else {
     2424                                  if (coval < 0.0)
     2425                                      MINDEC(ret_c,2);
     2426                                  MAXDEC(AARG1,ARES);
     2427                                  ARES_INC = 0.0;
     2428                                  AARG1_INC_O;
     2429                                  FOR_0_LE_i_LT_k
     2430                                  { (AARG1_INC) += ARES;
     2431                                    ARES_INC = 0;
     2432                                  }
     2433                              }
     2434                        }
     2435                        else
     2436                            FOR_0_LE_l_LT_p {
     2437                                if ((coval < 0.0) && (ARES))
    23272438                                MINDEC(ret_c,2);
    23282439                                HOV_INC(Ares,  k1)
     
    28933004            }
    28943005                break;
     3006            case ref_cond_eq_assign:                                      /* cond_eq_assign */
     3007            {   
     3008                revreal *Tref;
     3009                locint ref   = get_locint_r();
     3010                arg2  = get_locint_r();
     3011                arg1  = get_locint_r();
     3012                arg   = get_locint_r();
     3013                coval = get_val_r();
     3014               
     3015                ASSIGN_T(Tref, rpp_T[ref])
     3016
     3017#ifdef _HIGHER_ORDER_
     3018#define TREF  *Tref
     3019#else
     3020#define TREF   rpp_T[ref]
     3021#endif   
     3022
     3023                res = (size_t)trunc(fabs(TREF));
     3024#undef TREF
     3025                GET_TAYL(res,k,p)
     3026
     3027                ASSIGN_A(Aarg1, rpp_A[arg1])
     3028                ASSIGN_A(Ares,  rpp_A[res])
     3029                ASSIGN_A(Aarg2, rpp_A[arg2])
     3030                ASSIGN_T(Targ,  rpp_T[arg])
     3031
     3032                /* olvo 980925 changed code a little bit */
     3033                if (TARG >= 0.0) {
     3034                    if (res != arg1)
     3035                        FOR_0_LE_l_LT_p
     3036                        { if (0 == ARES) {
     3037                          HOV_INC(Ares,  k1)
     3038                              HOV_INC(Aarg1, k1)
     3039                          } else {
     3040                              if (coval < 0.0)
     3041                                  MINDEC(ret_c,2);
     3042                              MAXDEC(AARG1,ARES);
     3043                              ARES_INC = 0.0;
     3044                              AARG1_INC_O;
     3045                              FOR_0_LE_i_LT_k
     3046                              { AARG1_INC += ARES;
     3047                                ARES_INC = 0;
     3048                              }
     3049                          }
     3050                    }
     3051                    else
     3052                        FOR_0_LE_l_LT_p {
     3053                            if ((coval < 0.0) && (ARES))
     3054                            MINDEC(ret_c,2);
     3055                            HOV_INC(Ares,  k1)
     3056                        }
     3057                    } else /* TARG < 0.0 */
     3058            {
     3059                if (res != arg2)
     3060                        FOR_0_LE_l_LT_p
     3061                        { if (0 == ARES) {
     3062                          HOV_INC(Ares,  k1)
     3063                              HOV_INC(Aarg2, k1)
     3064                          } else {
     3065                                  if (coval < 0.0)
     3066                                      MINDEC(ret_c,2);
     3067                                  MAXDEC(AARG2,ARES);
     3068                                  AARG2_INC_O;
     3069                              ARES_INC = 0.0;
     3070
     3071                              FOR_0_LE_i_LT_k
     3072                              { AARG2_INC += ARES;
     3073                                ARES_INC = 0;
     3074                              }
     3075                          }
     3076                      HOV_INC(Aarg1, k1)
     3077                    } else
     3078                        FOR_0_LE_l_LT_p {
     3079                            if (ARES) {
     3080                                    if (coval < 0.0)
     3081                                        MINDEC(ret_c,2);
     3082                            }
     3083                        HOV_INC(Ares,  k1)
     3084                        HOV_INC(Aarg1, k1)
     3085                        HOV_INC(Aarg2, k1)
     3086                    }
     3087                }
     3088            }
     3089                break;
    28953090
    28963091            case ref_cond_assign_s:                                  /* cond_assign_s */
     
    29463141            break;
    29473142
     3143            case ref_cond_eq_assign_s:                                  /* cond_eq_assign_s */
     3144                arg2   = get_locint_r();
     3145                arg1  = get_locint_r();
     3146                arg   = get_locint_r();
     3147                coval = get_val_r();
     3148               
     3149                ASSIGN_T(Targ2, rpp_T[arg2])
     3150                res = (size_t)trunc(fabs(TARG2));
     3151
     3152                GET_TAYL(res,k,p)
     3153
     3154                ASSIGN_A(Aarg1, rpp_A[arg1])
     3155                ASSIGN_A(Ares,  rpp_A[res])
     3156                ASSIGN_T(Targ,  rpp_T[arg])
     3157
     3158                /* olvo 980925 changed code a little bit */
     3159                    if (TARG >= 0.0) {
     3160                        if (res != arg1)
     3161                            FOR_0_LE_l_LT_p
     3162                            { if  (0 == ARES) {
     3163                              HOV_INC(Ares,  k1)
     3164                                  HOV_INC(Aarg1, k1)
     3165                              } else {
     3166                                  if (coval < 0.0)
     3167                                      MINDEC(ret_c,2);
     3168                                  MAXDEC(AARG1,ARES);
     3169                                  ARES_INC = 0.0;
     3170                                  AARG1_INC_O;
     3171                                  FOR_0_LE_i_LT_k
     3172                                  { (AARG1_INC) += ARES;
     3173                                    ARES_INC = 0;
     3174                                  }
     3175                              }
     3176                        }
     3177                        else
     3178                            FOR_0_LE_l_LT_p {
     3179                                if ((coval < 0.0) && (ARES))
     3180                                MINDEC(ret_c,2);
     3181                                HOV_INC(Ares,  k1)
     3182                            }
     3183                        }
     3184            break;
     3185
    29483186                /****************************************************************************/
    29493187                /*                                                          REMAINING STUFF */
  • trunk/ADOL-C/src/oplate.h

    r600 r676  
    4141  div_a_a,
    4242  div_d_a,
    43   exp_op,
     43  exp_op = 19,
    4444  cos_op,
    4545  sin_op,
     
    5353  acosh_op,
    5454  atanh_op,
    55   gen_quad,
     55  gen_quad = 31,
    5656  end_of_tape,
    5757  start_of_tape,
     
    5959  end_of_int,
    6060  end_of_val,
    61   cond_assign,
     61  cond_assign = 37,
    6262  cond_assign_s,
    6363  take_stock_op,
     
    6868  neg_sign_a,
    6969  pos_sign_a,
    70   min_op,
     70  min_op = 46,
    7171  abs_val,
    7272  eq_zero,
     
    7676  ge_zero,
    7777  lt_zero,
    78   eq_plus_prod,
     78  eq_plus_prod = 54,
    7979  eq_min_prod,
    8080  erf_op,
    8181  ceil_op,
    8282  floor_op,
    83   ext_diff,
     83  ext_diff = 59,
    8484  ext_diff_iArr,
    8585  ignore_me,
    8686  ext_diff_v2,
     87  cond_eq_assign = 63,
     88  cond_eq_assign_s,
    8789  subscript = 80,
    8890  subscript_ref,
     
    121123  vec_dot,
    122124  vec_axpy,
     125  ref_cond_eq_assign = 116,
     126  ref_cond_eq_assign_s,
    123127  eq_a_p = 119,
    124128  neq_a_p,
  • trunk/ADOL-C/src/uni5_for.c

    r672 r676  
    46374637                break;
    46384638
     4639            case cond_eq_assign:                                      /* cond_eq_assign */
     4640                arg   = get_locint_f();
     4641                arg1  = get_locint_f();
     4642                arg2  = get_locint_f();
     4643                res   = get_locint_f();
     4644#if !defined(_NTIGHT_)
     4645                coval =
     4646#endif
     4647                get_val_f();
     4648
     4649                IF_KEEP_WRITE_TAYLOR(res,keep,k,p)
     4650
     4651                /* olvo 980924 changed order to allow reflexive ops */
     4652#if defined (_INDO_)
     4653#if defined (_INDOPRO_)
     4654#if defined (_TIGHT_)
     4655                if (dp_T0[arg] >= 0) {
     4656                    if (coval < 0.0)
     4657                        MINDEC(ret_c,2);
     4658                    dp_T0[res] = dp_T0[arg1];
     4659
     4660                    copy_index_domain(res, arg1, ind_dom);
     4661
     4662                } else {
     4663                    if (coval >= 0.0)
     4664                        MINDEC(ret_c,2);
     4665                    dp_T0[res] = dp_T0[arg2];
     4666                    copy_index_domain(res, arg2, ind_dom);
     4667                }
     4668#else
     4669                    combine_2_index_domains(res, arg1, arg2, ind_dom);
     4670#endif
     4671#endif
     4672#if defined (_NONLIND_)
     4673#ifdef _TIGHT_
     4674                if (dp_T0[arg] >= 0) {
     4675                    if (coval < 0.0)
     4676                        MINDEC(ret_c,2);
     4677                    dp_T0[res] = dp_T0[arg1];
     4678
     4679                    arg_index[res] = arg_index[arg1];           
     4680                } else {
     4681                    if (coval >= 0.0)
     4682                        MINDEC(ret_c,2);
     4683                    dp_T0[res] = dp_T0[arg2];
     4684
     4685                    arg_index[res] = arg_index[arg2];           
     4686                }
     4687
     4688#else
     4689               arg_index[res] = opind++;               
     4690#endif
     4691#endif
     4692#else
     4693#if !defined(_ZOS_) /* BREAK_ZOS */
     4694                ASSIGN_T(Tres,  TAYLOR_BUFFER[res])
     4695                ASSIGN_T(Targ1, TAYLOR_BUFFER[arg1])
     4696                ASSIGN_T(Targ2, TAYLOR_BUFFER[arg2])
     4697#endif /* ALL_TOGETHER_AGAIN */
     4698
     4699#ifdef _INT_FOR_
     4700#ifdef _TIGHT_
     4701                coval = get_val_f();
     4702
     4703                if (dp_T0[arg] >= 0)
     4704                    FOR_0_LE_l_LT_pk
     4705                    TRES_INC = TARG1_INC;
     4706                else
     4707                    FOR_0_LE_l_LT_pk
     4708                    TRES_INC = TARG2_INC;
     4709
     4710                if (dp_T0[arg] >= 0) {
     4711                    if (coval < 0.0)
     4712                        MINDEC(ret_c,2);
     4713                    dp_T0[res] = dp_T0[arg1];
     4714                } else {
     4715                    if (coval >= 0.0)
     4716                        MINDEC(ret_c,2);
     4717                    dp_T0[res] = dp_T0[arg2];
     4718                }
     4719#endif /* _TIGHT_ */
     4720#ifdef _NTIGHT_
     4721                FOR_0_LE_l_LT_pk
     4722                TRES_INC = TARG1_INC | TARG2_INC;
     4723#endif /* _NTIGHT_ */
     4724#else
     4725#if !defined(_ZOS_) /* BREAK_ZOS */
     4726                if (dp_T0[arg] >= 0)
     4727                    FOR_0_LE_l_LT_pk
     4728                    TRES_INC = TARG1_INC;
     4729                else
     4730                    FOR_0_LE_l_LT_pk
     4731                    TRES_INC = TARG2_INC;
     4732#endif
     4733
     4734                if (dp_T0[arg] >= 0) {
     4735                    if (coval < 0.0)
     4736                        MINDEC(ret_c,2);
     4737                    dp_T0[res] = dp_T0[arg1];
     4738                } else {
     4739                    if (coval >= 0.0)
     4740                        MINDEC(ret_c,2);
     4741                    dp_T0[res] = dp_T0[arg2];
     4742                }
     4743#endif
     4744#endif /* ALL_TOGETHER_AGAIN */
     4745                break;
     4746
    46394747                /*--------------------------------------------------------------------------*/
    46404748            case cond_assign_s:                                  /* cond_assign_s */
     
    47034811                break;
    47044812
     4813
     4814            case cond_eq_assign_s:                                  /* cond_eq_assign_s */
     4815                arg   = get_locint_f();
     4816                arg1  = get_locint_f();
     4817                res   = get_locint_f();
     4818#if !defined(_NTIGHT_)
     4819                coval =
     4820#endif
     4821                get_val_f();
     4822
     4823                IF_KEEP_WRITE_TAYLOR(res,keep,k,p)
     4824
     4825                /* olvo 980924 changed order to allow reflexive ops */
     4826#if defined(_INDO_)
     4827#if defined(_INDOPRO_)
     4828#ifdef _TIGHT_
     4829                if (dp_T0[arg] >= 0)
     4830                    copy_index_domain(res, arg1, ind_dom);
     4831#else
     4832                merge_2_index_domains(res, arg1, ind_dom);
     4833#endif
     4834#endif
     4835#if defined(_NONLIND_)
     4836                arg_index[res] = arg_index[arg1];               
     4837#endif
     4838#else
     4839#if !defined(_ZOS_) /* BREAK_ZOS */
     4840                ASSIGN_T(Tres,  TAYLOR_BUFFER[res])
     4841                ASSIGN_T(Targ1, TAYLOR_BUFFER[arg1])
     4842#endif /* ALL_TOGETHER_AGAIN */
     4843
     4844#ifdef _INT_FOR_
     4845#ifdef _TIGHT_
     4846                coval = get_val_f();
     4847
     4848                if (dp_T0[arg] >= 0)
     4849#endif /* _TIGHT_ */
     4850                    FOR_0_LE_l_LT_pk
     4851                    TRES_INC = TARG1_INC;
     4852
     4853#ifdef _TIGHT_
     4854                if (dp_T0[arg] >= 0) {
     4855                    if (coval < 0.0)
     4856                        MINDEC(ret_c,2);
     4857                    dp_T0[res] = dp_T0[arg1];
     4858                }
     4859#endif /* _TIGHT_ */
     4860#else
     4861#if !defined(_ZOS_) /* BREAK_ZOS */
     4862                if (dp_T0[arg] >= 0)
     4863                    FOR_0_LE_l_LT_pk
     4864                    TRES_INC = TARG1_INC;
     4865#endif
     4866                if (dp_T0[arg] >= 0) {
     4867                    if (coval < 0.0)
     4868                        MINDEC(ret_c,2);
     4869                    dp_T0[res] = dp_T0[arg1];
     4870                }
     4871#endif
     4872#endif /* ALL_TOGETHER_AGAIN */
     4873                break;
    47054874
    47064875                /*--------------------------------------------------------------------------*/
     
    57145883                break;
    57155884
     5885            case ref_cond_eq_assign:                                      /* cond_eq_assign */
     5886                arg   = get_locint_f();
     5887                arg1  = get_locint_f();
     5888                arg2  = get_locint_f();
     5889                {
     5890#if !defined(_NTIGHT_)
     5891                    locint ref =
     5892#endif
     5893                    get_locint_f();
     5894#if !defined(_NTIGHT_)
     5895                    coval =
     5896#endif
     5897                    get_val_f();
     5898#if !defined(_NTIGHT_)
     5899                    res   = (size_t)trunc(fabs(dp_T0[ref]));
     5900
     5901                    IF_KEEP_WRITE_TAYLOR(res,keep,k,p)
     5902
     5903                /* olvo 980924 changed order to allow reflexive ops */
     5904#if defined(_INDO_)
     5905                if (dp_T0[arg] >= 0) {
     5906                    if (coval < 0.0)
     5907                        MINDEC(ret_c,2);
     5908                    dp_T0[res] = dp_T0[arg1];
     5909
     5910#if defined(_INDOPRO_)
     5911                    copy_index_domain(res, arg1, ind_dom);
     5912#endif
     5913#if defined(_NONLIND_)
     5914                    arg_index[res] = arg_index[arg1];
     5915#endif
     5916                } else {
     5917                    if (coval >= 0.0)
     5918                        MINDEC(ret_c,2);
     5919                    dp_T0[res] = dp_T0[arg2];
     5920
     5921#if defined(_INDOPRO_)
     5922                    copy_index_domain(res, arg2, ind_dom);
     5923#endif
     5924#if defined(_NONLIND_)
     5925                    arg_index[res] = arg_index[arg2];
     5926#endif
     5927                }
     5928#else
     5929#if !defined(_ZOS_) /* BREAK_ZOS */
     5930                ASSIGN_T(Tres,  TAYLOR_BUFFER[res])
     5931                ASSIGN_T(Targ1, TAYLOR_BUFFER[arg1])
     5932                ASSIGN_T(Targ2, TAYLOR_BUFFER[arg2])
     5933#endif /* ALL_TOGETHER_AGAIN */
     5934
     5935#ifdef _INT_FOR_
     5936                coval = get_val_f();
     5937
     5938                if (dp_T0[arg] >= 0)
     5939                    FOR_0_LE_l_LT_pk
     5940                    TRES_INC = TARG1_INC;
     5941                else
     5942                    FOR_0_LE_l_LT_pk
     5943                    TRES_INC = TARG2_INC;
     5944
     5945                if (dp_T0[arg] >= 0) {
     5946                    if (coval < 0.0)
     5947                        MINDEC(ret_c,2);
     5948                    dp_T0[res] = dp_T0[arg1];
     5949                } else {
     5950                    if (coval >= 0.0)
     5951                        MINDEC(ret_c,2);
     5952                    dp_T0[res] = dp_T0[arg2];
     5953                }
     5954                FOR_0_LE_l_LT_pk
     5955                TRES_INC = TARG1_INC | TARG2_INC;
     5956#else
     5957#if !defined(_ZOS_) /* BREAK_ZOS */
     5958                if (dp_T0[arg] >= 0)
     5959                    FOR_0_LE_l_LT_pk
     5960                    TRES_INC = TARG1_INC;
     5961                else
     5962                    FOR_0_LE_l_LT_pk
     5963                    TRES_INC = TARG2_INC;
     5964#endif
     5965
     5966                if (dp_T0[arg] >= 0) {
     5967                    if (coval < 0.0)
     5968                        MINDEC(ret_c,2);
     5969                    dp_T0[res] = dp_T0[arg1];
     5970                } else {
     5971                    if (coval >= 0.0)
     5972                        MINDEC(ret_c,2);
     5973                    dp_T0[res] = dp_T0[arg2];
     5974                }
     5975#endif
     5976#endif
     5977#else
     5978                fprintf(DIAG_OUT, "ADOL-C error: active vector element referencing does not work in safe mode, please use tight mode\n");
     5979                adolc_exit(-2,"",__func__,__FILE__,__LINE__);
     5980#endif /* ALL_TOGETHER_AGAIN */
     5981                }
     5982                break;
     5983
    57165984            case ref_cond_assign_s:                                  /* cond_assign_s */
    57175985                arg   = get_locint_f();
     
    57706038                    if (dp_T0[arg] == 0)
    57716039                        MINDEC(ret_c,0);
     6040#endif
     6041#endif
     6042#else
     6043                fprintf(DIAG_OUT, "ADOL-C error: active vector element referencing does not work in safe mode, please use tight mode\n");
     6044                adolc_exit(-2,"",__func__,__FILE__,__LINE__);
     6045#endif /* ALL_TOGETHER_AGAIN */
     6046                break;
     6047
     6048            case ref_cond_eq_assign_s:                                  /* cond_eq_assign_s */
     6049                arg   = get_locint_f();
     6050                arg1  = get_locint_f();
     6051                arg2   = get_locint_f();
     6052#if !defined(_NTIGHT_)
     6053                coval =
     6054#endif
     6055                get_val_f();
     6056
     6057#if !defined(_NTIGHT_)
     6058                res = (size_t)trunc(fabs(dp_T0[arg2]));
     6059                IF_KEEP_WRITE_TAYLOR(res,keep,k,p)
     6060
     6061                /* olvo 980924 changed order to allow reflexive ops */
     6062#if defined(_INDO_)
     6063                if (dp_T0[arg] >= 0) {
     6064#if defined(_INDOPRO_)
     6065                    copy_index_domain(res, arg1, ind_dom);
     6066#endif
     6067#if defined(_NONLIND_)
     6068                    arg_index[res] = arg_index[arg1];
     6069#endif
     6070                }
     6071#else
     6072#if !defined(_ZOS_) /* BREAK_ZOS */
     6073                ASSIGN_T(Tres,  TAYLOR_BUFFER[res])
     6074                ASSIGN_T(Targ1, TAYLOR_BUFFER[arg1])
     6075#endif /* ALL_TOGETHER_AGAIN */
     6076
     6077#ifdef _INT_FOR_
     6078                coval = get_val_f();
     6079
     6080                if (dp_T0[arg] >= 0)
     6081                    FOR_0_LE_l_LT_pk
     6082                    TRES_INC = TARG1_INC;
     6083
     6084                if (dp_T0[arg] >= 0) {
     6085                    if (coval < 0.0)
     6086                        MINDEC(ret_c,2);
     6087                    dp_T0[res] = dp_T0[arg1];
     6088                }
     6089#else
     6090#if !defined(_ZOS_) /* BREAK_ZOS */
     6091                if (dp_T0[arg] >= 0)
     6092                    FOR_0_LE_l_LT_pk
     6093                    TRES_INC = TARG1_INC;
     6094#endif
     6095                if (dp_T0[arg] >= 0) {
     6096                    if (coval < 0.0)
     6097                        MINDEC(ret_c,2);
     6098                    dp_T0[res] = dp_T0[arg1];
     6099                }
    57726100#endif
    57736101#endif
Note: See TracChangeset for help on using the changeset viewer.