Changeset 280 for branches


Ignore:
Timestamp:
Nov 30, 2011 9:52:06 AM (7 years ago)
Author:
awalther
Message:

last tests

File:
1 edited

Legend:

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

    r279 r280  
    159159#if defined(_TIGHT_)
    160160
     161void traverse(IndexElement* tree);
    161162void free_tree(IndexElement* nlf, int num);
    162163void traverse_nlf(IndexElement* nlf, char* inddomain);
     
    195196#if defined(_TIGHT_)
    196197
    197 void traverse_unary(IndexElement* fod, IndexElement* nonl_dom,  IndexElement* fodi, int num);
     198void traverse_unary(IndexElement* fod, IndexElement* nonl_dom,  IndexElement* fodi, int num, int maxopind);
    198199
    199200#define GENERATED_FILENAME "nonl_ind_forward_t"
     
    17501751                fod[opind].left = &fod[arg_index[res]];
    17511752                fod[opind].right = &fod[arg_index[arg]];
    1752                 traverse_unary(&fod[arg_index[res]], nonl_dom, &fod[opind], indcheck+1);
    1753                 traverse_unary(&fod[arg_index[arg]], nonl_dom, &fod[opind], indcheck+1);
     1753                traverse_unary(&fod[arg_index[res]], nonl_dom, &fod[arg_index[arg]], indcheck+1,maxopind+2);
     1754                traverse_unary(&fod[arg_index[arg]], nonl_dom, &fod[arg_index[res]], indcheck+1,maxopind+2);
    17541755                arg_index[res] = opind++;               
    17551756#endif
     
    20112012                fod[opind].left = &fod[arg_index[arg1]];
    20122013                fod[opind].right = &fod[arg_index[arg2]];
    2013                 traverse_unary(&fod[arg_index[arg1]], nonl_dom, &fod[opind], indcheck+1);
    2014                 traverse_unary(&fod[arg_index[arg2]], nonl_dom, &fod[opind], indcheck+1);
    2015 
     2014/*              printf(" arg1 %d \n",arg1); */
     2015/*              traverse(&fod[arg_index[arg1]]); */
     2016/*              printf("\n"); */
     2017/*              printf(" arg2 %d \n",arg2); */
     2018/*              traverse(&fod[arg_index[arg2]]); */
     2019/*              printf("\n"); */
     2020/*              for(i=0;i<indcheck;i++) */
     2021/*                { */
     2022/*                  printf(" %d:\n",i); */
     2023/*                  traverse(&nonl_dom[i]); */
     2024/*                  printf("\n"); */
     2025/*                } */
     2026                traverse_unary(&fod[arg_index[arg1]], nonl_dom, &fod[arg_index[arg2]], indcheck+1,maxopind+2);
     2027                traverse_unary(&fod[arg_index[arg2]], nonl_dom, &fod[arg_index[arg1]], indcheck+1,maxopind+2);
    20162028                arg_index[res] = opind++;               
     2029/*              for(i=0;i<indcheck;i++) */
     2030/*                { */
     2031/*                  printf(" %d:\n",i); */
     2032/*                  traverse(&nonl_dom[i]); */
     2033/*                  printf("\n"); */
     2034/*                } */
     2035
    20172036#endif
    20182037#if defined(_NLF_)
     
    20832102                fod[opind].right = &fod[arg_index[arg2]];
    20842103                // first step: z = u*w,
    2085                 traverse_unary(&fod[arg_index[arg1]], nonl_dom, &fod[opind], indcheck+1);
    2086                 traverse_unary(&fod[arg_index[arg2]], nonl_dom, &fod[opind], indcheck+1);
     2104                traverse_unary(&fod[arg_index[arg1]], nonl_dom, &fod[opind], indcheck+1,maxopind+2);
     2105                traverse_unary(&fod[arg_index[arg2]], nonl_dom, &fod[opind], indcheck+1,maxopind+2);
    20872106                opind++;
    20882107                // second step: v = v+z, index domains
     
    21712190                fod[opind].right = &fod[arg_index[arg2]];
    21722191                // first step: z = u*w,
    2173                 traverse_unary(&fod[arg_index[arg1]], nonl_dom, &fod[opind], indcheck+1);
    2174                 traverse_unary(&fod[arg_index[arg2]], nonl_dom, &fod[opind], indcheck+1);
     2192                traverse_unary(&fod[arg_index[arg1]], nonl_dom, &fod[opind], indcheck+1,maxopind+2);
     2193                traverse_unary(&fod[arg_index[arg2]], nonl_dom, &fod[opind], indcheck+1,maxopind+2);
    21752194                opind++;
    21762195                // second step: v = v-z, index domains
     
    23062325                fod[opind].left = &fod[arg_index[arg1]];
    23072326                fod[opind].right = &fod[arg_index[arg2]];
    2308                 traverse_unary(&fod[arg_index[arg1]], nonl_dom, &fod[arg_index[arg2]], indcheck+1);
    2309                 traverse_unary(&fod[arg_index[arg2]], nonl_dom, &fod[opind], indcheck+1);
     2327                traverse_unary(&fod[arg_index[arg1]], nonl_dom, &fod[arg_index[arg2]], indcheck+1,maxopind+2);
     2328                traverse_unary(&fod[arg_index[arg2]], nonl_dom, &fod[opind], indcheck+1,maxopind+2);
    23102329                arg_index[res] = opind++;               
    23112330#endif
     
    23822401                fod[opind].left = &fod[arg_index[arg]];
    23832402                fod[opind].right = NULL;
    2384                 traverse_unary(&fod[opind], nonl_dom, &fod[opind], indcheck+1);
     2403                traverse_unary(&fod[opind], nonl_dom, &fod[opind], indcheck+1,maxopind+2);
    23852404                arg_index[res] = opind++;               
    23862405#endif
     
    25242543                fod[opind].left = &fod[arg_index[arg]];
    25252544                fod[opind].right = NULL;
    2526                 traverse_unary(&fod[opind], nonl_dom, &fod[opind], indcheck+1);
     2545                traverse_unary(&fod[opind], nonl_dom, &fod[opind], indcheck+1,maxopind+2);
    25272546                arg_index[res] = opind++;               
    25282547#endif
     
    25952614                fod[opind].left = &fod[arg_index[arg1]];
    25962615                fod[opind].right = NULL;
    2597                 traverse_unary(&fod[opind], nonl_dom, &fod[opind], indcheck+1);
     2616                traverse_unary(&fod[opind], nonl_dom, &fod[opind], indcheck+1,maxopind+2);
    25982617                arg_index[res] = opind++;               
    25992618#endif
     
    26762695                fod[opind].left = &fod[arg_index[arg1]];
    26772696                fod[opind].right = NULL;
    2678                 traverse_unary(&fod[opind], nonl_dom, &fod[opind], indcheck+1);
     2697                traverse_unary(&fod[opind], nonl_dom, &fod[opind], indcheck+1,maxopind+2);
    26792698                arg_index[res] = opind++;               
    26802699#endif
     
    27542773                fod[opind].left = &fod[arg_index[arg1]];
    27552774                fod[opind].right = NULL;
    2756                 traverse_unary(&fod[opind], nonl_dom, &fod[opind], indcheck+1);
     2775                traverse_unary(&fod[opind], nonl_dom, &fod[opind], indcheck+1,maxopind+2);
    27572776                arg_index[res] = opind++;               
    27582777#endif
     
    28242843                fod[opind].left = &fod[arg_index[arg1]];
    28252844                fod[opind].right = NULL;
    2826                 traverse_unary(&fod[opind], nonl_dom, &fod[opind], indcheck+1);
     2845                traverse_unary(&fod[opind], nonl_dom, &fod[opind], indcheck+1,maxopind+2);
    28272846                arg_index[res] = opind++;               
    28282847#endif
     
    29322951                fod[opind].left = &fod[arg_index[arg1]];
    29332952                fod[opind].right = NULL;
    2934                 traverse_unary(&fod[opind], nonl_dom, &fod[opind], indcheck+1);
     2953                traverse_unary(&fod[opind], nonl_dom, &fod[opind], indcheck+1,maxopind+2);
    29352954                arg_index[res] = opind++;               
    29362955#endif
     
    30423061                fod[opind].left = &fod[arg_index[arg1]];
    30433062                fod[opind].right = NULL;
    3044                 traverse_unary(&fod[opind], nonl_dom, &fod[opind], indcheck+1);
     3063                traverse_unary(&fod[opind], nonl_dom, &fod[opind], indcheck+1,maxopind+2);
    30453064                arg_index[res] = opind++;               
    30463065#endif
     
    31123131                fod[opind].left = &fod[arg_index[arg1]];
    31133132                fod[opind].right = NULL;
    3114                 traverse_unary(&fod[opind], nonl_dom, &fod[opind], indcheck+1);
     3133                traverse_unary(&fod[opind], nonl_dom, &fod[opind], indcheck+1,maxopind+2);
    31153134                arg_index[res] = opind++;               
    31163135#endif
     
    32043223                fod[opind].left = &fod[arg_index[arg1]];
    32053224                fod[opind].right = NULL;
    3206                 traverse_unary(&fod[opind], nonl_dom, &fod[opind], indcheck+1);
     3225                traverse_unary(&fod[opind], nonl_dom, &fod[opind], indcheck+1,maxopind+2);
    32073226                arg_index[res] = opind++;               
    32083227#endif
     
    33173336                fod[opind].left = &fod[arg_index[arg1]];
    33183337                fod[opind].right = NULL;
    3319                 traverse_unary(&fod[opind], nonl_dom, &fod[opind], indcheck+1);
     3338                traverse_unary(&fod[opind], nonl_dom, &fod[opind], indcheck+1,maxopind+2);
    33203339                arg_index[res] = opind++;               
    33213340#endif
     
    33823401                fod[opind].left = &fod[arg_index[arg]];
    33833402                fod[opind].right = NULL;
    3384                 traverse_unary(&fod[opind], nonl_dom, &fod[opind], indcheck+1);
     3403                traverse_unary(&fod[opind], nonl_dom, &fod[opind], indcheck+1,maxopind+2);
    33853404                arg_index[res] = opind++;               
    33863405#endif
     
    34753494                fod[opind].left = &fod[arg_index[arg]];
    34763495                fod[opind].right = NULL;
    3477                 traverse_unary(&fod[opind], nonl_dom, &fod[opind], indcheck+1);
     3496                traverse_unary(&fod[opind], nonl_dom, &fod[opind], indcheck+1,maxopind+2);
    34783497                arg_index[res] = opind++;               
    34793498#endif
     
    36253644                fod[opind].left = &fod[arg_index[arg]];
    36263645                fod[opind].right = NULL;
    3627                 traverse_unary(&fod[opind], nonl_dom, &fod[opind], indcheck+1);
     3646                traverse_unary(&fod[opind], nonl_dom, &fod[opind], indcheck+1,maxopind+2);
    36283647                arg_index[res] = opind++;               
    36293648#endif
     
    44664485        } /* endswitch */
    44674486
    4468 
    44694487        /* Read the next operation */
    44704488        operation=get_op_f();
     
    45434561    for( i=0; i < indcheck; i++) {
    45444562      traverse_crs(&fod2[i],&csod[i],maxopind+1);
    4545       free_tree(&fod2[i],maxopind+1);
     4563/*       free_tree(&fod2[i],maxopind+1); */
    45464564      crs[i] = (unsigned int*) malloc(sizeof(unsigned int) * (csod[i].entry+1));
    45474565      crs[i][0] = csod[i].entry;
     
    45564574    }
    45574575
    4558     free(fod);
    4559     free(fod2);
    4560     free(nlf);
    4561     free(csod);
    4562     free(arg_index);
     4576/*     free(fod); */
     4577/*     free(fod2); */
     4578/*     free(nlf); */
     4579/*     free(csod); */
     4580/*     free(arg_index); */
    45634581#endif
    45644582#endif
     
    48044822    {
    48054823      traverse(tree->left);
    4806       if (tree->right != NULL)
    4807         traverse(tree->right);
    4808      }
    4809   else
     4824    }
     4825  if (tree->right != NULL)
    48104826    {
    4811       printf(" %d ",tree->entry);
     4827      traverse(tree->right);
    48124828    }
     4829  printf(" %ld ",tree->entry);
     4830 
    48134831}
    48144832
     
    49104928  else
    49114929    {
    4912       temp = (struct IndexElement*) malloc(sizeof(struct IndexElement));
    4913       temp->right = &fod[i];
    4914       temp->left = fod2[tree->entry].left;
    4915       temp->entry= num;
    4916       fod2[tree->entry].left = temp;
     4930      if(tree->entry<num)
     4931        {
     4932          temp = (struct IndexElement*) malloc(sizeof(struct IndexElement));
     4933          temp->right = &fod[i];
     4934          temp->left = fod2[tree->entry].left;
     4935          temp->entry= num;
     4936          fod2[tree->entry].left = temp;
     4937        }
    49174938    }
    49184939}
     
    49304951#if defined(_TIGHT_)
    49314952
    4932 void traverse_unary(IndexElement* tree,  IndexElement* nonl_dom,  IndexElement* fodi, int num)
     4953void traverse_unary(IndexElement* tree,  IndexElement* nonl_dom,  IndexElement* fodi, int num, int maxopind)
    49334954{
    49344955  IndexElement *temp;
     
    49364957  if (tree->left != NULL)
    49374958    {
    4938       traverse_unary(tree->left, nonl_dom, fodi, num);
     4959      traverse_unary(tree->left, nonl_dom, fodi, num, maxopind);
    49394960      if (tree->right != NULL)
    49404961        {
    4941           traverse_unary(tree->right, nonl_dom, fodi, num);
     4962          traverse_unary(tree->right, nonl_dom, fodi, num, maxopind);
    49424963        }
    49434964     }
    49444965  else
    49454966    {
    4946       temp = (struct IndexElement*) malloc(sizeof(struct IndexElement));
    4947       temp->right = fodi;
    4948       temp->left = nonl_dom[tree->entry].left;
    4949       temp->entry= num;
    4950       nonl_dom[tree->entry].left = temp;
     4967      if(tree->entry<maxopind)
     4968        {
     4969          temp = (struct IndexElement*) malloc(sizeof(struct IndexElement));
     4970          temp->right = fodi;
     4971          temp->left = nonl_dom[tree->entry].left;
     4972          temp->entry= num;
     4973          nonl_dom[tree->entry].left = temp;
     4974        }
    49514975    }
    49524976}
Note: See TracChangeset for help on using the changeset viewer.