Changeset 230


Ignore:
Timestamp:
Jun 8, 2011 8:12:19 AM (8 years ago)
Author:
kulshres
Message:

Merge stable version with revision 229

Location:
stable/2.2
Files:
7 edited

Legend:

Unmodified
Added
Removed
  • stable/2.2/ADOL-C/src/tape_handling.cpp

    r206 r230  
    4242  store = 0;
    4343  storeSize = 0;
    44   numLives = 0;
     44  numLives = 1;
    4545  storeManagerPtr = new StoreManagerLocint(store, storeSize, numLives);
    4646}
     
    101101    head = loc;
    102102    --anzahl;
    103     storePtr[loc] = 0.0;
    104103#ifdef ADOLC_DEBUG
    105104    std::cerr << "free_loc: " << loc << " fill: " << size() << "max: " << maxSize() << endl;
  • stable/2.2/ADOL-C/src/taping.c

    r208 r230  
    406406    FILE *configFile = NULL;
    407407    char inputLine[ADOLC_LINE_LENGTH + 1];
    408     char *pos1 = NULL, *pos2 = NULL, *pos3 = NULL, *pos4 = NULL, *end = NULL;
     408    char *pos1 = NULL, *pos2 = NULL, *pos3 = NULL, *pos4 = NULL, *start = NULL, *end = NULL;
     409    int base;
    409410    long int number = 0;
    410411    char *path = NULL;
     
    454455                            "in .adolcrc ignored!\n");
    455456            } else {
    456                 number = strtol(pos3 + 1, &end, 10);
    457                 if (end == (pos3 + 1)) {
     457                if (*(pos3 + 1) == '0' && (*(pos3 + 2) == 'x' || *(pos3 + 2) == 'X')) {
     458                    start = pos3 + 3;
     459                    base = 16;
     460                } else if (*(pos3 + 1) == '0') {
     461                    start = pos3 + 2;
     462                    base = 8;
     463                } else {
     464                    start = pos3 + 1;
     465                    base = 10;
     466                }
     467                number = strtol(start, &end, base);
     468                if (end == start) {
    458469                    *pos2 = 0;
    459470                    *pos4 = 0;
  • stable/2.2/ADOL-C/src/uni5_for.c

    r191 r230  
    88
    99 Contents: Contains the routines :
    10            zos_forward (zero-order-scalar forward mode):      define _ZOS_   
     10           zos_forward (zero-order-scalar forward mode):      define _ZOS_
    1111           fos_forward (first-order-scalar forward mode):     define _FOS_
    1212           hos_forward (higher-order-scalar forward mode):    define _HOS_
     
    1818           Uses the preprocessor to compile the 7 different object files
    1919           with/without "keep" parameter:                     define _KEEP_
    20  
    21  Copyright (c) Andrea Walther, Andreas Griewank, Andreas Kowarz,
    22                Hristo Mitev, Sebastian Schlenkrich, Jean Utke, Olaf Vogel
     20
     21 Copyright (c) Andrea Walther, Andreas Griewank, Andreas Kowarz,
     22               Hristo Mitev, Sebastian Schlenkrich, Jean Utke, Olaf Vogel,
     23               Benjamin Letschert
    2324
    2425 This file is part of ADOL-C. This software is provided as open source.
    25  Any use, reproduction, or distribution of the software constitutes 
     26 Any use, reproduction, or distribution of the software constitutes
    2627 recipient's acceptance of the terms of the accompanying license file.
    27  
     28
    2829----------------------------------------------------------------------------*/
    2930
     
    4243#endif /* ADOLC_DEBUG */
    4344
     45
    4446/****************************************************************************/
    4547/*                                                                   MACROS */
     
    122124#else
    123125#if defined(_INDO_)
    124 
    125126void copy_index_domain(int res, int arg, locint **ind_dom);
    126127void merge_2_index_domains(int res, int arg, locint **ind_dom);
     
    146147 */
    147148
    148 typedef struct IndexElement {
    149     locint  entry;
    150     struct IndexElement* next;
    151 }
    152 IndexElement;
    153 
    154149void extend_nonlinearity_domain_binary_step
    155 (int arg1, int arg2, locint **ind_dom, IndexElement **nonl_dom);
     150(int arg1, int arg2, locint **ind_dom, locint **nonl_dom);
    156151void extend_nonlinearity_domain_unary
    157 (int arg, locint **ind_dom, IndexElement **nonl_dom);
     152(int arg, locint **ind_dom, locint **nonl_dom);
    158153void extend_nonlinearity_domain_binary
    159 (int arg1, int arg2, locint **ind_dom, IndexElement **nonl_dom);
     154(int arg1, int arg2, locint **ind_dom, locint **nonl_dom);
     155
    160156
    161157#if defined(_TIGHT_)
     
    509505
    510506/* int_forward_tight( tag, m, n, p, x[n], X[n][p], y[m], Y[m][p]),
    511    
     507
    512508     nBV = number of Boolean Vectors to be packed
    513509                      (see Chapter Dependence Analysis, ADOL-C Documentation)
    514510     bits_per_long = 8*sizeof(unsigned long int)
    515511     p = nBV / bits_per_long + ( (nBV % bits_per_long) != 0 )
    516  
     512
    517513     The order of the indices in argument and taylors is [var][taylor]
    518  
    519      For the full Jacobian matrix set 
     514
     515     For the full Jacobian matrix set
    520516     p = indep / bits_per_long + ((indep % bits_per_long) != 0)
    521517     and pass a bit pattern version of the identity matrix as an argument   */
     
    562558
    563559/* indopro_forward_tight( tag, m, n, x[n], *crs[m]),
    564    
     560
    565561  */
    566562
     
    579575
    580576/* indopro_forward_safe( tag, m, n, x[n], *crs[m]),
    581    
     577
    582578  */
    583579#endif
     
    596592
    597593/* indopro_forward_tight( tag, m, n, x[n], *crs[m]),
    598    
     594
    599595  */
    600596
     
    612608
    613609/* indopro_forward_safe( tag, m, n, x[n], *crs[m]),
    614    
     610
    615611  */
    616612#endif
     
    744740#if defined(_NONLIND_)
    745741    /* nonlinear interaction domains */
    746     IndexElement** nonl_dom;
    747     IndexElement*  temp;
    748     IndexElement*  temp1;
     742    locint** nonl_dom;
     743    locint*  temp;
     744    locint*  temp1;
    749745#endif
    750746#endif
     
    981977    max_ind_dom = ADOLC_CURRENT_TAPE_INFOS.stats[NUM_MAX_LIVES];
    982978#if defined(_NONLIND_)
    983     nonl_dom = (struct IndexElement**) malloc(sizeof(struct IndexElement*) * indcheck);
    984     for(i=0;i<indcheck;i++)
    985         nonl_dom[i] = NULL;
     979
     980    nonl_dom = (locint**) malloc(sizeof(locint*) * indcheck);
     981    for(i=0;i<indcheck;i++){
     982          nonl_dom[i] = (locint*) malloc(sizeof(locint)*(NUMNNZ+2));
     983          nonl_dom[i][0]=0;
     984          nonl_dom[i][1]=NUMNNZ;
     985       }
    986986#endif
    987987
     
    10471047#endif /* ADOLC_DEBUG */
    10481048    while (operation !=end_of_tape) {
    1049      
     1049
    10501050      switch (operation) {
    1051    
     1051
    10521052
    10531053                /****************************************************************************/
     
    18501850
    18511851#if defined(_INDO_)
    1852                 copy_index_domain(res, arg, ind_dom);               
     1852                copy_index_domain(res, arg, ind_dom);
    18531853#else
    18541854#if !defined(_ZOS_) /* BREAK_ZOS */
     
    28322832#if !defined(_INT_FOR_)
    28332833                T0arg   = dp_T0[arg];
    2834 #endif 
     2834#endif
    28352835#endif /* ALL_TOGETHER_AGAIN */
    28362836
     
    34483448                    FOR_0_LE_l_LT_pk
    34493449                    TRES_INC = TARG2_INC;
    3450 #endif 
     3450#endif
    34513451
    34523452                if (dp_T0[arg] > 0) {
     
    36373637                break;
    36383638#endif
    3639 
    3640                 /*--------------------------------------------------------------------------*/
     3639                /*--------------------------------------------------------------------------*/
     3640
    36413641            default:                                                   /* default */
    36423642                /* Die here, we screwed up */
     
    36563656#endif /* ADOLC_DEBUG */
    36573657    }  /* endwhile */
    3658 
    36593658
    36603659#if defined(ADOLC_DEBUG)
     
    37023701
    37033702#if defined(_NONLIND_)
    3704     for(i=0;i<indcheck;i++) {
    3705         if (nonl_dom[i] != NULL) {
    3706             crs[i] = (unsigned int*) malloc(sizeof(unsigned int) * (nonl_dom[i]->entry+1));
    3707             temp1 = nonl_dom[i];
    3708             temp = nonl_dom[i]->next;
    3709             crs[i][0] = nonl_dom[i]->entry;
    3710             free(temp1);
    3711             for(l=1;l<=crs[i][0];l++) {
    3712                 crs[i][l] = temp->entry;
    3713                 temp1 = temp;
    3714                 temp = temp->next;
    3715                 free(temp1);
    3716             }
    3717         } else {
    3718             crs[i] = (unsigned int *) malloc(sizeof(unsigned int));
    3719             crs[i][0] = 0;
    3720         }
     3703
     3704    for( i=0; i < indcheck; i++) {
     3705       crs[i] = (unsigned int*) malloc(sizeof(unsigned int) * (nonl_dom[i][0]+1));
     3706       crs[i][0] = nonl_dom[i][0];
     3707       for(l=1; l < crs[i][0]+1; l++)
     3708          crs[i][l] = nonl_dom[i][l+1];
     3709       free(nonl_dom[i]);
    37213710    }
    37223711    free(nonl_dom);
     
    37373726/* operations on index domains                                              */
    37383727
    3739 #ifdef _TIGHT_
     3728#if defined(_TIGHT_)
    37403729void copy_index_domain(int res, int arg, locint **ind_dom) {
    37413730
     
    37433732
    37443733   if (ind_dom[arg][0] > ind_dom[res][1]-2)
    3745     {
    3746         free(ind_dom[res]);
    3747         ind_dom[res] = (locint *)  malloc(sizeof(locint) * 2*ind_dom[arg][0]);
    3748         ind_dom[res][1] = 2*ind_dom[arg][0];
    3749     }
    3750    
     3734     {
     3735       free(ind_dom[res]);
     3736       ind_dom[res] = (locint *)  malloc(sizeof(locint) * 2*(ind_dom[arg][0])+1);
     3737       ind_dom[res][1] = 2*ind_dom[arg][0];
     3738     }
     3739
     3740
    37513741    for(i=2;i<ind_dom[arg][0]+2;i++)
    3752         ind_dom[res][i] = ind_dom[arg][i];
     3742       ind_dom[res][i] = ind_dom[arg][i];
    37533743    ind_dom[res][0] = ind_dom[arg][0];
    37543744}
    37553745
    37563746
    3757 void merge_2_index_domains(int res, int arg, locint **ind_dom) {
    3758 
    3759     int num,num1,i,j,k,l;
    3760     locint *temp_array, *temp_array1;
    3761 
    3762     if (ind_dom[res][0] == 0)
    3763         copy_index_domain(res,arg,ind_dom);
    3764     else
     3747void merge_2_index_domains(int res, int arg, locint **ind_dom)
     3748{
     3749
     3750  int num,num1,num2, i,j,k,l;
     3751  locint *temp_array, *arg_ind_dom, *res_ind_dom;
     3752
     3753  if (ind_dom[res][0] == 0)
     3754    copy_index_domain(res,arg,ind_dom);
     3755  else
    37653756    {
    3766         num = ind_dom[res][0];
    3767         temp_array = (locint *)  malloc(sizeof(locint)* num);
    3768         num1 = ind_dom[arg][0];
    3769         temp_array1 = (locint *)  malloc(sizeof(locint) * num1);
    3770        
    3771         for(i=0;i<num;i++)
    3772             temp_array[i] = ind_dom[res][i+2];
    3773         for(i=0;i<num1;i++)
    3774             temp_array1[i] = ind_dom[arg][i+2];
    3775 
    3776         if (num1+num > ind_dom[res][1]-2)
     3757      if (res != arg)
    37773758        {
    3778           i = 2*(num1+num);
    3779           free(ind_dom[res]);
    3780           ind_dom[res] = (locint *)  malloc(sizeof(locint) * i);
    3781           ind_dom[res][1] = i;
    3782         }
    3783         i = 0;
    3784         j = 0;
    3785         k = 2;
    3786         while ((i< num) && (j < num1))
     3759          arg_ind_dom = ind_dom[arg];
     3760          res_ind_dom = ind_dom[res];
     3761
     3762          num  = ind_dom[res][0];
     3763          num1 = arg_ind_dom[0];
     3764          num2 = ind_dom[res][1];
     3765
     3766          if (num2 < num1+num)
     3767            num2 = num1+num;
     3768         
     3769          temp_array = (locint *)  malloc(sizeof(locint)* (num2+2));
     3770          temp_array[1] = num2;
     3771
     3772          i = 2;
     3773          j = 2;
     3774          k = 2;
     3775          num += 2;
     3776          num1 += 2;
     3777          while ((i< num) && (j < num1))
    37873778            {
    3788               if (temp_array[i] < temp_array1[j])
     3779              if (res_ind_dom[i] < arg_ind_dom[j])
    37893780                {
    3790                   ind_dom[res][k] = temp_array[i];
     3781                  temp_array[k] = res_ind_dom[i];
    37913782                  i++; k++;
    37923783                }
    37933784              else
    3794               {
    3795                   if (temp_array[i] == temp_array1[j])
     3785                {
     3786                  if (res_ind_dom[i] == arg_ind_dom[j])
    37963787                    {
    3797                       ind_dom[res][k] = temp_array1[j];
     3788                      temp_array[k] = arg_ind_dom[j];
    37983789                      i++;j++;k++;
    37993790                    }
    38003791                  else
    38013792                    {
    3802                       ind_dom[res][k] = temp_array1[j];
     3793                      temp_array[k] = arg_ind_dom[j];
    38033794                      j++;k++;               
    38043795                    }
     
    38063797            }
    38073798          for(l = i;l<num;l++)
    3808           {
    3809               ind_dom[res][k] = temp_array[l];
     3799            {
     3800              temp_array[k] = res_ind_dom[l];
    38103801              k++;
    3811           }
     3802            }
    38123803          for(l = j;l<num1;l++)
    3813           {
    3814               ind_dom[res][k] = temp_array1[l];
     3804            {
     3805              temp_array[k] = arg_ind_dom[l];
    38153806              k++;
    3816           }
    3817           ind_dom[res][0] = k-2;
    3818           free(temp_array);
    3819           free(temp_array1);
     3807            }
     3808          temp_array[0] = k-2;
     3809          free(ind_dom[res]);
     3810          ind_dom[res]=temp_array;
     3811        }
    38203812    }
    38213813
     3814
    38223815}
    38233816
     
    38253818
    38263819    if (res != arg1)
    3827         copy_index_domain(res, arg1, ind_dom);
     3820       copy_index_domain(res, arg1, ind_dom);
    38283821
    38293822    merge_2_index_domains(res, arg2, ind_dom);
     
    38343827    merge_2_index_domains(res, arg2, ind_dom);
    38353828}
     3829
     3830
     3831
    38363832#endif
    38373833#endif
     
    38423838
    38433839void extend_nonlinearity_domain_binary_step
    3844 (int arg1, int arg2, locint **ind_dom, IndexElement **nonl_dom) {
    3845 
    3846     int index;
    3847     int num,num1, i,j,l,m;
    3848     IndexElement* temp_nonl;
    3849     IndexElement* nonl_num;
    3850     IndexElement* temp1;
    3851 
    3852     num = ind_dom[arg2][0];
    3853 
    3854     for(m=2;m<ind_dom[arg1][0]+2;m++)
     3840(int arg1, int arg2, locint **ind_dom, locint **nonl_dom)
     3841{
     3842  int index,num,num1, num2, i,j,k,l,m;
     3843  locint *temp_nonl, *index_nonl_dom, *arg1_ind_dom, *arg2_ind_dom;
     3844
     3845  num = ind_dom[arg2][0];
     3846
     3847  for(m=2;m<ind_dom[arg1][0]+2;m++)
    38553848    {
    3856         index = ind_dom[arg1][m];
    3857         temp_nonl = nonl_dom[index];
    3858         if (temp_nonl == NULL) {
    3859             temp_nonl = (struct IndexElement*)
    3860                 malloc(sizeof(struct IndexElement));
    3861             nonl_dom[index] = temp_nonl;
    3862             temp_nonl->entry = 0;
    3863             temp_nonl->next = NULL;
    3864         }
    3865         nonl_num = temp_nonl; /* kept for updating the element count */
    3866         if (nonl_num->entry == 0) { /* empty list */
     3849      index = ind_dom[arg1][m];
     3850      index_nonl_dom = nonl_dom[index];
     3851
     3852      if (index_nonl_dom[0] == 0)  /* empty list */
     3853        {
     3854          if ( index_nonl_dom[1] < num)
     3855            {
     3856              free(index_nonl_dom);
     3857              index_nonl_dom = (locint*) malloc(sizeof(locint)*2*(num+1) );
     3858              index_nonl_dom[1] = 2*num;
     3859            }
    38673860          for(i=2;i<num+2;i++)      /* append index domain list of "arg" */
    3868             {
    3869               temp_nonl->next = (struct IndexElement*) malloc(sizeof(struct IndexElement));
    3870               temp_nonl = temp_nonl->next;
    3871               temp_nonl->entry = ind_dom[arg2][i];
    3872               temp_nonl->next = NULL;
    3873               nonl_num->entry++;
     3861            index_nonl_dom[i] = ind_dom[arg2][i];
     3862          index_nonl_dom[0] = num;
     3863        }
     3864      else
     3865        { /* merge lists */
     3866          num1 = index_nonl_dom[0];
     3867          num2 = index_nonl_dom[1];
     3868         
     3869          if (num1+num > num2)
     3870            num2 = num1+num;
     3871         
     3872          temp_nonl = (locint*) malloc(sizeof(locint)*(num2+2));
     3873          temp_nonl[1] = num2;
     3874         
     3875          i = 2;
     3876          k = 2;
     3877          j = 2;
     3878          num1 +=2;
     3879          num2 = num+2;
     3880          while ((i<num1) && (j < num2)){
     3881            if (ind_dom[arg2][j] < index_nonl_dom[i]) /* < */ {
     3882              temp_nonl[k] = ind_dom[arg2][j];
     3883              j++; k++;
     3884            } else {
     3885              if (ind_dom[arg2][j] == index_nonl_dom[i])  /* == */ {
     3886                temp_nonl[k] = ind_dom[arg2][j];
     3887                j++; k++; i++;
     3888              } else {
     3889                temp_nonl[k] = index_nonl_dom[i];
     3890                i++; k++;
     3891              }
    38743892            }
     3893          }
     3894          for(l = j;l<num2;l++) {
     3895            temp_nonl[k] = ind_dom[arg2][l];
     3896            k++;
     3897          }
     3898          for(l = i;l<num1;l++) {
     3899            temp_nonl[k] = index_nonl_dom[l];
     3900            k++;
     3901          }
     3902          temp_nonl[0] = k-2;
     3903          free((char*) nonl_dom[index]);
     3904          nonl_dom[index] = temp_nonl;
    38753905        }
    3876        else /* merge lists */
    3877          {
    3878            num1 = temp_nonl->entry;
    3879            temp_nonl = temp_nonl->next; /* skip counter */
    3880            i = 0;
    3881            j = 2;
    3882            temp_nonl = nonl_num;
    3883            temp_nonl = temp_nonl->next;
    3884            while ((i<num1) && (j < num+2))
    3885              {
    3886                if (ind_dom[arg2][j] < temp_nonl->entry) /* < */
    3887                  {
    3888                    temp1 = (struct IndexElement*) malloc(sizeof(struct IndexElement));
    3889                    temp1->next = temp_nonl->next;
    3890                    temp1->entry = temp_nonl->entry;
    3891                    temp_nonl->entry = ind_dom[arg2][j];
    3892                    temp_nonl->next = temp1;
    3893                    temp_nonl=temp_nonl->next;
    3894                    nonl_num->entry++;
    3895                    j++;
    3896                  }
    3897                else
    3898                  {
    3899                    if (ind_dom[arg2][j] == temp_nonl->entry)  /* == */
    3900                      {
    3901                        j++;
    3902                      }
    3903                    else
    3904                      {
    3905                        i++;
    3906                        if (i<num1)
    3907                          temp_nonl = temp_nonl->next;
    3908                      }
    3909                  }
    3910              }
    3911            for(l = j;l<num+2;l++)
    3912              {
    3913                temp1 = (struct IndexElement*) malloc(sizeof(struct IndexElement));
    3914                temp_nonl->next = temp1;
    3915                temp_nonl = temp_nonl->next;
    3916                temp_nonl->entry = ind_dom[arg2][l];
    3917                temp_nonl->next = NULL;
    3918                nonl_num->entry++;
    3919              }
    3920          }
    39213906    }
    39223907}
    39233908
    39243909void extend_nonlinearity_domain_unary
    3925 (int arg, locint **ind_dom, IndexElement **nonl_dom) {
     3910(int arg, locint **ind_dom, locint **nonl_dom) {
    39263911    extend_nonlinearity_domain_binary_step(arg, arg, ind_dom, nonl_dom);
    39273912}
    39283913
    39293914void extend_nonlinearity_domain_binary
    3930 (int arg1, int arg2, locint **ind_dom, IndexElement **nonl_dom) {
     3915(int arg1, int arg2, locint **ind_dom, locint **nonl_dom) {
    39313916    extend_nonlinearity_domain_binary_step(arg1, arg2, ind_dom, nonl_dom);
    39323917    extend_nonlinearity_domain_binary_step(arg2, arg1, ind_dom, nonl_dom);
    39333918}
    39343919
     3920
    39353921#endif
    39363922#endif
  • stable/2.2/Makefile.am

    r161 r230  
    2424                       autoconf/shave.in autoconf/shave-libtool.in \
    2525                       autoconf/dolt.m4 autoconf/shave.m4 \
    26                        windows/adolc.sln windows/adolc.vcxproj \
    27                        windows/sparse/config.h.in windows/nosparse/config.h.in \
    28                        windows/x64/sparse/config.h.in windows/x64/nosparse/config.h.in \
    29                        windows/sparse/config.h windows/nosparse/config.h \
    30                        windows/x64/sparse/config.h windows/x64/nosparse/config.h \
    31                        windows/Readme_VC++.txt \
    32                        windows/vcredist_x86.exe windows/x64/vcredist_x64.exe \
    33                        windows/installer.sh \
     26                       MSVisualStudio/v10/adolc.sln MSVisualStudio/v10/adolc.vcxproj \
     27                       MSVisualStudio/v10/sparse/config.h.in MSVisualStudio/v10/nosparse/config.h.in \
     28                       MSVisualStudio/v10/x64/sparse/config.h.in MSVisualStudio/v10/x64/nosparse/config.h.in \
     29                       MSVisualStudio/v10/sparse/config.h MSVisualStudio/v10/nosparse/config.h \
     30                       MSVisualStudio/v10/x64/sparse/config.h MSVisualStudio/v10/x64/nosparse/config.h \
     31                       MSVisualStudio/v10/Readme_VC++.txt \
     32                       MSVisualStudio/v10/installer.sh \
    3433                       adolc.spec.in adolc.spec \
    3534                       update_versions.sh \
    3635                       ThirdParty/ColPack/ColPack.vcxproj \
    37                        ThirdParty/ColPack/colpack_vcxcompile.patch \
    3836                       ThirdParty/ColPack/Readme_VC++.txt
    3937
  • stable/2.2/Makefile.in

    r202 r230  
    270270                       autoconf/shave.in autoconf/shave-libtool.in \
    271271                       autoconf/dolt.m4 autoconf/shave.m4 \
    272                        windows/adolc.sln windows/adolc.vcxproj \
    273                        windows/sparse/config.h.in windows/nosparse/config.h.in \
    274                        windows/x64/sparse/config.h.in windows/x64/nosparse/config.h.in \
    275                        windows/sparse/config.h windows/nosparse/config.h \
    276                        windows/x64/sparse/config.h windows/x64/nosparse/config.h \
    277                        windows/Readme_VC++.txt \
    278                        windows/vcredist_x86.exe windows/x64/vcredist_x64.exe \
    279                        windows/installer.sh \
     272                       MSVisualStudio/v10/adolc.sln MSVisualStudio/v10/adolc.vcxproj \
     273                       MSVisualStudio/v10/sparse/config.h.in MSVisualStudio/v10/nosparse/config.h.in \
     274                       MSVisualStudio/v10/x64/sparse/config.h.in MSVisualStudio/v10/x64/nosparse/config.h.in \
     275                       MSVisualStudio/v10/sparse/config.h MSVisualStudio/v10/nosparse/config.h \
     276                       MSVisualStudio/v10/x64/sparse/config.h MSVisualStudio/v10/x64/nosparse/config.h \
     277                       MSVisualStudio/v10/Readme_VC++.txt \
     278                       MSVisualStudio/v10/installer.sh \
    280279                       adolc.spec.in adolc.spec \
    281280                       update_versions.sh \
    282281                       ThirdParty/ColPack/ColPack.vcxproj \
    283                        ThirdParty/ColPack/colpack_vcxcompile.patch \
    284282                       ThirdParty/ColPack/Readme_VC++.txt
    285283
Note: See TracChangeset for help on using the changeset viewer.