Changeset 258 for trunk/ADOL-C


Ignore:
Timestamp:
Jul 1, 2011 9:49:58 AM (9 years ago)
Author:
awalther
Message:

first full version of sparsity estimation based on fod

File:
1 edited

Legend:

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

    r257 r258  
    142142
    143143#if defined(_CSOD_)
     144void copy_fod(int res, int arg, locint **fod);
     145void append_fod(int res, int arg, locint **fod);
     146void copy_index_domain_2_fod(int res, locint **fod, locint **ind_dom);
     147void append_index_domain_2_fod(int res, int offset, int arg1, int arg2,locint **fod, locint **ind_dom);
     148void combine_2_fod(int res, int arg1, int arg2, locint **fod);
    144149#if defined(_TIGHT_)
    145150#define GENERATED_FILENAME "csod_forward_t"
     
    12931298                copy_index_domain(res, arg, ind_dom);
    12941299#if defined(_CSOD_)
    1295                 if (fod[arg][2]>fod[res][1])
    1296                   {
    1297                     free(fod[res]);
    1298                     fod[res] = (locint *)  malloc(sizeof(locint) * (2*fod[arg][2]+3));
    1299                     fod[res][1] = 2*fod[arg][2];
    1300                   }
    1301                  
    1302                 for(i=0;i<fod[arg][2]+3;i++)
    1303                   {
    1304                     fod[res][i] = fod[arg][i];
    1305                   }
    1306                 printf("fod \n");
    1307                 for(i=0;i<fod[res][2]+3;i++)
    1308                   printf(" %d ",fod[res][i]);
    1309                 printf("\n");
     1300                copy_fod(res, arg, fod);
    13101301#endif
    13111302#else
     
    15651556                merge_2_index_domains(res, arg, ind_dom);
    15661557#if defined(_CSOD_)
    1567                 if (fod[arg][2]+fod[res][2]>fod[res][1])
    1568                   {
    1569                     fod[res]=realloc(fod[res],sizeof(locint) * (2*(fod[arg][2]+fod[res][2])+3));
    1570                     fod[res][1] = 2*(fod[arg][2]+fod[res][2]);
    1571                   }
    1572 
    1573                 index = fod[res][2]+3;
    1574 
    1575                 if (fod[arg][3] > 0)
    1576                   {
    1577                     fod[res][0] += fod[arg][0];
    1578                     fod[res][2] += fod[arg][2];
    1579                     for(i=3;i<fod[arg][2]+3;i++)
    1580                       {
    1581                         fod[res][index++] = fod[arg][i];
    1582                       }
    1583                   }
    1584                 printf("fod \n");
    1585                 for(i=0;i<fod[res][2]+3;i++)
    1586                   printf(" %d ",fod[res][i]);
    1587                 printf("\n");
     1558                append_fod(res,arg,fod);
    15881559#endif
    15891560#else
     
    16311602                merge_2_index_domains(res, arg, ind_dom);
    16321603#if defined(_CSOD_)
    1633                 if (fod[arg][2]+fod[res][2]>fod[res][1])
    1634                   {
    1635                     fod[res]=realloc(fod[res],sizeof(locint) * (2*(fod[arg][2]+fod[res][2])+3));
    1636                     fod[res][1] = 2*(fod[arg][2]+fod[res][2]);
    1637                   }
    1638 
    1639                 index = fod[res][2]+3;
    1640 
    1641                 if (fod[arg][3] > 0)
    1642                   {
    1643                     fod[res][0] += fod[arg][0];
    1644                     fod[res][2] += fod[arg][2];
    1645                     for(i=3;i<fod[arg][2]+3;i++)
    1646                       {
    1647                         fod[res][index++] = fod[arg][i];
    1648                       }
    1649                   }
    1650                 printf("fod \n");
    1651                 for(i=0;i<fod[res][2]+3;i++)
    1652                   printf(" %d ",fod[res][i]);
    1653                 printf("\n");
     1604                append_fod(res,arg,fod);
    16541605#endif
    16551606#else
     
    17061657                merge_2_index_domains(res, arg, ind_dom);
    17071658#if defined(_CSOD_)
    1708                 fod[res][0] = 0;
    1709                 index=3;
    1710                 if (ind_dom[res][0] > 0)
    1711                   {
    1712                     if (ind_dom[res][0]>fod[res][1])
    1713                       {
    1714                         free(fod[res]);
    1715                         fod[res] = (locint *)  malloc(sizeof(locint) * (2*ind_dom[res][0]+3));
    1716                         fod[res][1] = 2*ind_dom[res][0];
    1717                       }
    1718                     fod[res][0]++;
    1719                     fod[res][index++] = ind_dom[res][0];
    1720                     for(l=2;l<ind_dom[res][0]+2;l++)
    1721                       fod[res][index++]=ind_dom[res][l];
    1722                     fod[res][2]+=ind_dom[res][0]+1;
    1723                    
    1724                   }
    1725                 printf("fod \n");
    1726                 for(i=0;i<fod[res][2]+3;i++)
    1727                   printf(" %d ",fod[res][i]);
    1728                 printf("\n");
     1659                copy_index_domain_2_fod(res,fod,ind_dom);
    17291660#endif
    17301661#if defined(_NONLIND_)
     
    18051736#if defined(_INDO_)
    18061737                combine_2_index_domains(res, arg1, arg2, ind_dom);
    1807 #if defined(_CSOD_)   // XXXX   
    1808                 for(i=0;i<fod[arg1][2]+3;i++)
    1809                   {
    1810                     fod[res][i] = fod[arg1][i];
    1811                   }
    1812                 index = fod[res][2]+3;
    1813                 for(i=3;i<fod[arg2][2]+3;i++)
    1814                   {
    1815                     fod[res][index++] = fod[arg2][i];
    1816                   }
    1817                 fod[res][2]+=fod[arg2][2];
    1818                 fod[res][0]+=fod[arg2][0];
    1819 
    1820                 printf("fod \n");
    1821                 for(i=0;i<fod[res][2]+3;i++)
    1822                   printf(" %d ",fod[res][i]);
    1823                 printf("\n");
     1738#if defined(_CSOD_)     
     1739                combine_2_fod(res, arg1, arg2, fod);
    18241740#endif
    18251741#else
     
    18561772                copy_index_domain(res, arg, ind_dom);
    18571773#if defined(_CSOD_)
    1858                 for(i=0;i<fod[arg][2]+3;i++)
    1859                   {
    1860                     fod[res][i] = fod[arg][i];
    1861                   }
    1862                 printf("fod \n");
    1863                 for(i=0;i<fod[res][2]+3;i++)
    1864                   printf(" %d ",fod[res][i]);
    1865                 printf("\n");
     1774                copy_fod(res, arg, fod);
    18661775#endif
    18671776#else
     
    18941803                combine_2_index_domains(res, arg1, arg2, ind_dom);
    18951804#if defined(_CSOD_)
    1896                 /* combine_2_index_domains(res, arg1, arg2, nlf); */
     1805                combine_2_fod(res, arg1, arg2, fod);
    18971806#endif
    18981807#else
     
    19291838                copy_index_domain(res, arg, ind_dom);
    19301839#if defined(_CSOD_)
    1931                 /* copy_index_domain(res, arg, nlf); */
     1840                copy_fod(res, arg, fod);
    19321841#endif
    19331842#else
     
    19581867                combine_2_index_domains(res, arg1, arg2, ind_dom);
    19591868#if defined(_CSOD_)
    1960                 fod[res][0] = 0;
    1961                 index=3;
    1962                 if (ind_dom[res][0] > 0)
    1963                   {
    1964                     fod[res][0]++;
    1965                     fod[res][index++] = ind_dom[res][0];
    1966                     for(l=2;l<ind_dom[res][0]+2;l++)
    1967                       fod[res][index++]=ind_dom[res][l];
    1968                     fod[res][2]+=ind_dom[res][0]+1;
    1969                    
    1970                   }
    1971                 printf("fod \n");
    1972                 for(i=0;i<fod[res][2]+3;i++)
    1973                   printf(" %d ",fod[res][i]);
    1974                 printf("\n");
    1975 
     1869                copy_index_domain_2_fod(res,fod,ind_dom);
    19761870#endif
    19771871#if defined(_NONLIND_)
     
    20281922                merge_3_index_domains(res, arg1, arg2, ind_dom);
    20291923#if defined(_CSOD_)
    2030                 // take
    2031                 combine_2_index_domains(offset, arg1, arg2, ind_dom);
    2032                 index = fod[res][2]+3;
    2033                 if (ind_dom[offset][0] > 0)
    2034                   {
    2035                     fod[res][0]++;
    2036                     fod[res][index++] = ind_dom[offset][0];
    2037                     for(l=2;l<ind_dom[offset][0]+2;l++)
    2038                       fod[res][index++]=ind_dom[offset][l];
    2039                     fod[res][2]+=ind_dom[offset][0]+1;
    2040                    
    2041                   }
    2042                 printf("fod \n");
    2043                 for(i=0;i<fod[res][2]+3;i++)
    2044                   printf(" %d ",fod[res][i]);
    2045                 printf("\n");
     1924                append_index_domain_2_fod(res, offset, arg1, arg2, fod, ind_dom);
    20461925#endif
    20471926#if defined(_NONLIND_)
     
    20971976                merge_3_index_domains(res, arg1, arg2, ind_dom);
    20981977#if defined(_CSOD_)
    2099                 /* copy_index_domain(res, arg1, nlf); */
     1978                append_index_domain_2_fod(res, offset, arg1, arg2, fod, ind_dom);
    21001979#endif
    21011980#if defined(_NONLIND_)
     
    21572036                copy_index_domain(res, arg, ind_dom);
    21582037#if defined(_CSOD_)
    2159 
    2160                 for(i=0;i<fod[arg][2]+3;i++)
    2161                   {
    2162                     fod[res][i] = fod[arg][i];
    2163                   }
    2164                 printf("fod \n");
    2165                 for(i=0;i<fod[res][2]+3;i++)
    2166                   printf(" %d ",fod[res][i]);
    2167                 printf("\n");
     2038                copy_fod(res, arg, fod);
    21682039#endif
    21692040#else
     
    22042075                combine_2_index_domains(res, arg1, arg2, ind_dom);
    22052076#if defined(_CSOD_)
    2206                 /* nlf[res][0] = 1; */
    2207                 /* nlf[res][2] = res; */
     2077                copy_index_domain_2_fod(res,fod,ind_dom);
    22082078#endif
    22092079#if defined(_NONLIND_)
     
    22692139                copy_index_domain(res, arg, ind_dom);
    22702140#if defined(_CSOD_)
    2271                 /* nlf[res][0] = 1; */
    2272                 /* nlf[res][2] = res; */
     2141                copy_fod(res, arg, fod);
    22732142#endif
    22742143#if defined(_NONLIND_)
     
    23252194                copy_index_domain(res, arg, ind_dom);
    23262195#if defined(_CSOD_)
    2327                 /* copy_index_domain(res, arg, nlf); */
     2196                copy_fod(res, arg, fod);
    23282197#endif
    23292198#else
     
    23522221                copy_index_domain(res, arg, ind_dom);
    23532222#if defined(_CSOD_)
    2354                 /* copy_index_domain(res, arg, nlf); */
     2223                copy_fod(res, arg, fod);
    23552224#endif
    23562225#else
     
    23902259                copy_index_domain(res, arg, ind_dom);
    23912260#if defined(_CSOD_)
    2392                 /* nlf[res][0] = 1; */
    2393                 /* nlf[res][2] = res; */
     2261                copy_fod(res, arg, fod);
    23942262#endif
    23952263#if defined(_NONLIND_)
     
    24502318                copy_index_domain(res, arg1, ind_dom);
    24512319#if defined(_CSOD_)
    2452                 for(i=0;i<fod[arg][2]+3;i++)
    2453                   {
    2454                     fod[res][i] = fod[arg][i];
    2455                   }
    2456                 printf("fod \n");
    2457                 for(i=0;i<fod[res][2]+3;i++)
    2458                   printf(" %d ",fod[res][i]);
    2459                 printf("\n");
     2320                copy_fod(res, arg1, fod);
    24602321#endif
    24612322#if defined(_NONLIND_)
     
    25262387                copy_index_domain(res, arg1, ind_dom);
    25272388#if defined(_CSOD_)
    2528                 for(i=0;i<fod[arg1][2]+3;i++)
    2529                   {
    2530                     fod[res][i] = fod[arg1][i];
    2531                   }
    2532                 printf("fod \n");
    2533                 for(i=0;i<fod[res][2]+3;i++)
    2534                   printf(" %d ",fod[res][i]);
    2535                 printf("\n");
     2389                copy_fod(res, arg1, fod);
    25362390#endif
    25372391#if defined(_NONLIND_)
     
    25992453                copy_index_domain(res, arg1, ind_dom);
    26002454#if defined(_CSOD_)
    2601                 /* nlf[res][0] = 1; */
    2602                 /* nlf[res][2] = res; */
     2455                copy_fod(res, arg1, fod);
    26032456#endif
    26042457#if defined(_NONLIND_)
     
    26582511                copy_index_domain(res, arg1, ind_dom);
    26592512#if defined(_CSOD_)
    2660                 /* nlf[res][0] = 1; */
    2661                 /* nlf[res][2] = res; */
     2513                copy_fod(res, arg1, fod);
    26622514#endif
    26632515#if defined(_NONLIND_)
     
    27552607                copy_index_domain(res, arg1, ind_dom);
    27562608#if defined(_CSOD_)
    2757                 /* nlf[res][0] = 1; */
    2758                 /* nlf[res][2] = res; */
     2609                copy_fod(res, arg1, fod);
    27592610#endif
    27602611#if defined(_NONLIND_)
     
    28542705                copy_index_domain(res, arg1, ind_dom);
    28552706#if defined(_CSOD_)
    2856                 /* nlf[res][0] = 1; */
    2857                 /* nlf[res][2] = res; */
     2707                copy_fod(res, arg1, fod);
    28582708#endif
    28592709#if defined(_NONLIND_)
     
    29132763                copy_index_domain(res, arg1, ind_dom);
    29142764#if defined(_CSOD_)
    2915                 /* nlf[res][0] = 1; */
    2916                 /* nlf[res][2] = res; */
     2765                copy_fod(res, arg1, fod);
    29172766#endif
    29182767#if defined(_NONLIND_)
     
    29942843                copy_index_domain(res, arg1, ind_dom);
    29952844#if defined(_CSOD_)
    2996                 /* nlf[res][0] = 1; */
    2997                 /* nlf[res][2] = res; */
     2845                copy_fod(res, arg1, fod);
    29982846#endif
    29992847#if defined(_NONLIND_)
     
    30962944                copy_index_domain(res, arg1, ind_dom);
    30972945#if defined(_CSOD_)
    3098                 /* nlf[res][0] = 1; */
    3099                 /* nlf[res][2] = res; */
     2946                copy_fod(res, arg1, fod);
    31002947#endif
    31012948#else
     
    31472994                copy_index_domain(res, arg, ind_dom);
    31482995#if defined(_CSOD_)
    3149                 /* nlf[res][0] = 1; */
    3150                 /* nlf[res][2] = res; */
     2996                copy_fod(res, arg, fod);
    31512997#endif
    31522998#if defined(_NONLIND_)
     
    32293075                copy_index_domain(res, arg, ind_dom);
    32303076#if defined(_CSOD_)
    3231                 /* nlf[res][0] = 1; */
    3232                 /* nlf[res][2] = res; */
     3077                copy_fod(res, arg, fod);
    32333078#endif
    32343079#if defined(_NONLIND_)
     
    33683213                copy_index_domain(res, arg, ind_dom);
    33693214#if defined(_CSOD_)
    3370                 /* nlf[res][0] = 1; */
    3371                 /* nlf[res][2] = res; */
     3215                copy_fod(res, arg, fod);
    33723216#endif
    33733217#if defined(_NONLIND_)
     
    35353379#if defined(_CSOD_)
    35363380#ifdef _TIGHT_
    3537 /*                     if (dp_T0[arg1] < dp_T0[arg2]) */
    3538 /*                         copy_index_domain(res, arg1, nlf); */
    3539 /*                     else { */
    3540 /*                         if (dp_T0[arg1] > dp_T0[arg2]) */
    3541 /*                             copy_index_domain(res, arg2, nlf); */
    3542 /*                         else */
    3543 /*                             combine_2_index_domains(res, arg1, arg2, nlf); */
    3544 /*                     } */
    3545 /* #else */
    3546 /*                     combine_2_index_domains(res, arg1, arg2, nlf); */
     3381                    if (dp_T0[arg1] < dp_T0[arg2])
     3382                      copy_fod(res, arg1, fod);
     3383                    else {
     3384                        if (dp_T0[arg1] > dp_T0[arg2])
     3385                          copy_fod(res, arg2, fod);
     3386                        else
     3387                          combine_2_fod(res, arg1, arg2, fod);
     3388                    }
     3389#else
     3390                    combine_2_fod(res, arg1, arg2, fod);
    35473391#endif
    35483392#endif
     
    36663510                copy_index_domain(res, arg, ind_dom);
    36673511#if defined(_CSOD_)
    3668                 /* copy_index_domain(res, arg, nlf); */
     3512                copy_fod(res, arg, fod);
    36693513#endif
    36703514#else
     
    37433587                copy_index_domain(res, arg, ind_dom);
    37443588#if defined(_CSOD_)
    3745                 /* copy_index_domain(res, arg, nlf); */
     3589                copy_fod(res, arg, fod);
    37463590#endif
    37473591#else
     
    37733617                copy_index_domain(res, arg, ind_dom);
    37743618#if defined(_CSOD_)
    3775                 /* copy_index_domain(res, arg, nlf); */
     3619                copy_fod(res, arg, fod);
    37763620#endif
    37773621#else
     
    38073651                    dp_T0[res] = dp_T0[arg1];
    38083652
    3809                     combine_2_index_domains(res, arg1, arg2, ind_dom);
    3810 #if defined(_CSOD_)
    3811                     /* combine_2_index_domains(res, arg1, arg2, nlf); */
    3812 #endif
    3813 #else
    38143653                    copy_index_domain(res, arg1, ind_dom);
    3815 #if defined(_CSOD_)
    3816                     /* copy_index_domain(res, arg1, nlf); */
    3817 #endif
    3818 #endif
    3819 #ifdef _TIGHT_
     3654
     3655#if defined(_CSOD_)
     3656                    copy_fod(res, arg1, fod);
     3657#endif
    38203658                } else {
    38213659                    if (coval > 0.0)
     
    38243662                        MINDEC(ret_c,0);
    38253663                    dp_T0[res] = dp_T0[arg2];
    3826 
    3827                         combine_2_index_domains(res, arg1, arg2, ind_dom);
    3828 #if defined(_CSOD_)
    3829                     /* combine_2_index_domains(res, arg1, arg2, nlf); */
     3664                    copy_index_domain(res, arg2, ind_dom);
     3665#if defined(_CSOD_)
     3666                    copy_fod(res, arg2, fod);
    38303667#endif
    38313668                }
    3832 #else
    3833                         copy_index_domain(res, arg2, ind_dom);
    3834 #if defined(_CSOD_)
    3835                     /* copy_index_domain(res, arg1, nlf); */
     3669
     3670#else
     3671                    combine_2_index_domains(res, arg1, arg2, ind_dom);
     3672#if defined(_CSOD_)
     3673                    combine_2_fod(res, arg1, arg2, fod);
    38363674#endif
    38373675#endif
     
    39063744                /* olvo 980924 changed order to allow reflexive ops */
    39073745#if defined(_INDO_)
    3908                     copy_index_domain(res, arg1, ind_dom);
    3909 #if defined(_CSOD_)
     3746                copy_index_domain(res, arg1, ind_dom);
     3747#if defined(_CSOD_)
     3748                copy_fod(res, arg1, fod);
    39103749#endif
    39113750#else
     
    40823921        } /* endswitch */
    40833922
    4084      printf("op %d \n",operation);
    4085 
    4086 #if defined (_CSOD_)
    4087       printf(" ind_dom: \n");
    4088       for(l=0;l<max_ind_dom;l++)
    4089         {
    4090           printf(" %d : ",l);
    4091           for(i=2;i<ind_dom[l][0]+2;i++)
    4092             printf(" %d ",ind_dom[l][i]);
    4093           printf("\n");
    4094         }
    4095 #endif
    40963923
    40973924        /* Read the next operation */
     
    43884215#endif
    43894216#endif
     4217
     4218/****************************************************************************/
     4219
     4220#if defined(_CSOD_)
     4221
     4222/****************************************************************************/
     4223/* set operations for propagation of fod                                    */
     4224
     4225/*--------------------------------------------------------------------------*/
     4226/* operations on index domains                                              */
     4227
     4228#if defined(_TIGHT_)
     4229void copy_fod(int res, int arg, locint **fod) {
     4230
     4231  int i;
     4232
     4233  if (fod[arg][2]>fod[res][1])
     4234    {
     4235      free(fod[res]);
     4236      fod[res] = (locint *)  malloc(sizeof(locint) * (2*fod[arg][2]+3));
     4237      fod[res][1] = 2*fod[arg][2];
     4238    }
     4239 
     4240  for(i=0;i<fod[arg][2]+3;i++)
     4241    {
     4242      fod[res][i] = fod[arg][i];
     4243    }
     4244}
     4245
     4246void append_fod(int res, int arg, locint **fod) {
     4247 
     4248  int i, index;
     4249 
     4250  if (fod[arg][2]+fod[res][2]>fod[res][1])
     4251    {
     4252      fod[res]=realloc(fod[res],sizeof(locint) * (2*(fod[arg][2]+fod[res][2])+3));
     4253      fod[res][1] = 2*(fod[arg][2]+fod[res][2]);
     4254    }
     4255 
     4256  index = fod[res][2]+3;
     4257 
     4258  if (fod[arg][3] > 0)
     4259    {
     4260      fod[res][0] += fod[arg][0];
     4261      fod[res][2] += fod[arg][2];
     4262      for(i=3;i<fod[arg][2]+3;i++)
     4263        {
     4264          fod[res][index++] = fod[arg][i];
     4265        }
     4266    }
     4267}
     4268
     4269void copy_index_domain_2_fod(int res, locint **fod, locint **ind_dom) {
     4270 
     4271  int i, index;
     4272 
     4273  fod[res][0] = 0;
     4274  index=3;
     4275  if (ind_dom[res][0] > 0)
     4276    {
     4277      if (ind_dom[res][0]>fod[res][1])
     4278        {
     4279          free(fod[res]);
     4280          fod[res] = (locint *)  malloc(sizeof(locint) * (2*ind_dom[res][0]+3));
     4281          fod[res][0] = 0;
     4282          fod[res][1] = 2*ind_dom[res][0];
     4283        }
     4284      fod[res][0]++;
     4285      fod[res][index++] = ind_dom[res][0];
     4286      for(i=2;i<ind_dom[res][0]+2;i++)
     4287        fod[res][index++]=ind_dom[res][i];
     4288      fod[res][2]=ind_dom[res][0]+1;
     4289                   
     4290    }
     4291}
     4292
     4293void append_index_domain_2_fod(int res, int offset, int arg1, int arg2, locint **fod, locint **ind_dom) {
     4294
     4295  int i, index;
     4296
     4297  combine_2_index_domains(offset, arg1, arg2, ind_dom);
     4298  index = fod[res][2]+3;
     4299  if (ind_dom[offset][0] > 0)
     4300    {
     4301      if (ind_dom[offset][0]>fod[res][1])
     4302        {
     4303          fod[res]=realloc(fod[res],sizeof(locint) * (2*(fod[res][2]+ind_dom[offset][0])+3));
     4304          fod[res][1] = 2*(fod[res][2]+ind_dom[offset][0]);
     4305        }
     4306      fod[res][0]++;
     4307      fod[res][index++] = ind_dom[offset][0];
     4308      for(i=2;i<ind_dom[offset][0]+2;i++)
     4309        fod[res][index++]=ind_dom[offset][i];
     4310      fod[res][2]+=ind_dom[offset][0]+1;
     4311     
     4312    }
     4313}
     4314
     4315void combine_2_fod(int res, int arg1, int arg2, locint **fod) {
     4316 
     4317  int i, index;
     4318 
     4319  if (res == arg1)
     4320    {
     4321      if (fod[arg1][2]+fod[arg2][2] > 0)
     4322        {
     4323          if (fod[arg1][2]+fod[arg2][2]>fod[res][1])
     4324            {
     4325              fod[res]=realloc(fod[res],sizeof(locint) * (2*(fod[arg1][2]+fod[arg2][2])+3));
     4326              fod[res][1] = 2*(fod[arg1][2]+fod[arg2][2]);
     4327            }
     4328          index = fod[res][2]+3;
     4329          for(i=3;i<fod[arg2][2]+3;i++)
     4330            {
     4331              fod[res][index++] = fod[arg2][i];
     4332            }
     4333          fod[res][2]+=fod[arg2][2];
     4334          fod[res][0]+=fod[arg2][0];
     4335        }
     4336    }
     4337  else
     4338    {
     4339      if (res == arg2)
     4340        {
     4341          if (fod[arg1][2]+fod[arg2][2] > 0)
     4342            {
     4343              if (fod[arg1][2]+fod[arg2][2]>fod[res][1])
     4344                {
     4345                  fod[res]=realloc(fod[res],sizeof(locint) * (2*(fod[arg1][2]+fod[arg2][2])+3));
     4346                  fod[res][1] = 2*(fod[arg1][2]+fod[arg2][2]);
     4347                }
     4348              index = fod[res][2]+3;
     4349              for(i=3;i<fod[arg1][2]+3;i++)
     4350                {
     4351                  fod[res][index++] = fod[arg1][i];
     4352                }
     4353              fod[res][2]+=fod[arg1][2];
     4354              fod[res][0]+=fod[arg1][0];
     4355            }
     4356        }
     4357      else
     4358        {
     4359          if (fod[arg1][2]+fod[arg2][2] > 0)
     4360            {
     4361              if (fod[arg1][2]+fod[arg2][2]>fod[res][1])
     4362                {
     4363                  free(fod[res]);
     4364                  fod[res] = (locint *)  malloc(sizeof(locint) * (2*(fod[arg1][2]+fod[arg2][2])+3));
     4365                  fod[res][1] = 2*fod[arg1][2]+fod[arg2][2];
     4366                }
     4367              for(i=0;i<fod[arg1][2]+3;i++)
     4368                {
     4369                  fod[res][i] = fod[arg1][i];
     4370                }
     4371              index = fod[res][2]+3;
     4372              for(i=3;i<fod[arg2][2]+3;i++)
     4373                {
     4374                  fod[res][index++] = fod[arg2][i];
     4375                }
     4376              fod[res][2]+=fod[arg2][2];
     4377              fod[res][0]+=fod[arg2][0];
     4378            }
     4379        }
     4380    }
     4381}
     4382
     4383#endif
     4384#endif
     4385
    43904386END_C_DECLS
Note: See TracChangeset for help on using the changeset viewer.