home *** CD-ROM | disk | FTP | other *** search
/ ARM Club 3 / TheARMClub_PDCD3.iso / hensa / system / hint_2 / hint / c / hkernel < prev   
Encoding:
Text File  |  1997-07-17  |  6.3 KB  |  137 lines
  1. /******************************************************************************/
  2. /* "HINT" -- Hierarchical INTegration.  SERIAL VERSION                        */
  3. /* Copyright (C) 1994 by Iowa State University Research Foundation, Inc.      */
  4. /*                                                                            */
  5. /* This program is free software; you can redistribute it and/or modify       */
  6. /* it under the terms of the GNU General Public License as published by       */
  7. /* the Free Software Foundation.  You should have received a copy of the      */
  8. /* GNU General Public License along with this program; if not, write to the   */
  9. /* Free Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.    */
  10. /*                                                                            */
  11. /* Files needed for use:                                                      */
  12. /*     * hint.c             ---- Driver source                                */
  13. /*     * hkernel.c          ---- Kernel source                                */
  14. /*     * hint.h             ---- General include file                         */
  15. /*     * typedefs.h         ---- Include file for DSIZE and ISIZE             */
  16. /*     * README             ---- These are the rules. Follow them!!!          */
  17. /******************************************************************************/
  18.  
  19. #include "hint.h"
  20.  
  21. DSIZE
  22. Hint(DSIZE *scx, DSIZE *scy, DSIZE *dmax, ISIZE *mcnt, hRECT *hRECT, 
  23.                            DSIZE *errs, ISIZE *ixes, hERROR *eflag)
  24. {
  25.     DSIZE   errio,       /* Error value for io                                */
  26.             errjo,       /* Error value for jo                                */
  27.             sh,          /* Sum of areas, high bound                          */
  28.             sl,          /* Sum of areas, low bound                           */
  29.             tm,          /* Temporary value for computing function            */
  30.             tm2;         /* Temporary value for doubling tm                   */
  31.  
  32.     ISIZE   inc, jnc,    /* Indices of queue positions                        */
  33.             io,          /* Index of left child                               */
  34.             iq,          /* Index of end of the sorted error queue            */
  35.             it,          /* Iteration counter                                 */
  36.             itmp,        /* Temporary                                         */
  37.             jo,          /* Index of right child                              */
  38.             ma;          /* Index of parent                                   */
  39.  
  40.  
  41.    /* Initialize the first interval.                                          */
  42.       hRECT[0].xl = (DSIZE)0;    
  43.       hRECT[0].xr = *scx;      
  44.       hRECT[0].dx = *scx;     
  45.       hRECT[0].fll = *scy;   
  46.       hRECT[0].flh = *scy;  
  47.       hRECT[0].frl = (DSIZE)0;
  48.       hRECT[0].frh = (DSIZE)0;
  49.       hRECT[0].ahi = *dmax;
  50.       hRECT[0].alo = (DSIZE)0;
  51.       iq = 0;
  52.       errs[iq] = hRECT[0].ahi - hRECT[0].alo;
  53.       ixes[iq] = iq;      
  54.       sh = hRECT[0].ahi;
  55.       sl = hRECT[0].alo;
  56.  
  57.       for (it = 0; ((it < *mcnt - 1) && (it <= iq)); it++) 
  58.       {
  59.           io = ma = ixes[it];        /* Head of list has maximum error        */
  60.           jo = it + 1;               /* Find right child index                */
  61.  
  62.           tm = hRECT[ma].dx; 
  63.        /* Since dx is always a power of 2, it halves evenly.                  */
  64.           hRECT[io].dx  = hRECT[jo].dx = tm / (DSIZE)2;
  65.  
  66.        /* Right child gets right boundary.                                    */
  67.           hRECT[jo].xr  = hRECT[ma].xr;
  68.        /* New point in the middle is shared by child subintervals             */
  69.           hRECT[io].xr  = hRECT[io].xl + 
  70.                          hRECT[io].dx; 
  71.           hRECT[jo].xl  = hRECT[io].xr;
  72.        /* Right child gets right f value upper and lower bounds               */
  73.           hRECT[jo].frl = hRECT[ma].frl;
  74.           hRECT[jo].frh = hRECT[ma].frh;
  75.        /* Note that the left child simply inherits much of its info from ma.  */
  76.  
  77.        /* This is the function evaluation.                                    */
  78.           tm =  (*scx + hRECT[io].xr); 
  79.           tm2 = (*scy * (*scx - hRECT[io].xr));
  80.           itmp = tm2 / tm;
  81.           hRECT[io].frl = itmp;
  82.  
  83.        /* Here we need boolean true == 1. Otherwise use if's.                 */
  84.           hRECT[io].frh = hRECT[io].frl + ((tm * hRECT[io].frl) != tm2);
  85.           hRECT[jo].fll = hRECT[io].frl;
  86.           hRECT[jo].flh = hRECT[io].frh;
  87.  
  88.        /* Compute the left daughter error.                                    */
  89.           tm = (hRECT[io].fll - hRECT[io].frh) * (hRECT[io].dx - (DSIZE)2);
  90.           if (tm < (DSIZE)0)
  91.               tm = (DSIZE)0;
  92.           errio = (hRECT[io].flh - hRECT[io].frh  + 
  93.                    hRECT[io].fll - hRECT[io].frl) * 
  94.                   (hRECT[io].dx - (DSIZE)1) - tm;
  95.  
  96.        /* Repeat for the right daughter.                                      */
  97.           tm = (hRECT[jo].fll - hRECT[jo].frh) * (hRECT[jo].dx - (DSIZE)2);
  98.           if (tm < (DSIZE)0)
  99.               tm = (DSIZE)0;
  100.           errjo = (hRECT[jo].flh - hRECT[jo].frh  + 
  101.                    hRECT[jo].fll - hRECT[jo].frl) * 
  102.                   (hRECT[jo].dx - (DSIZE)1) - tm;
  103.  
  104.        /* Compute indices for io and jo on the queue.                         */
  105.        /* This is done with a boolean. If boolean true is not 1 use if's.     */
  106.           inc = (errio < errjo) + 1;
  107.           jnc = 3 - inc;
  108.  
  109.        /* Put on both io and jo. If one is zero we will not use it.           */
  110.           errs[iq + inc] = errio;
  111.           ixes[iq + inc] = io;
  112.           errs[iq + jnc] = errjo;
  113.           ixes[iq + jnc] = jo;
  114.  
  115.        /* Decide how much to increment iq. Again we need boolean true == 1.   */
  116.           iq = iq + (errs[iq + 2] != 0) + 1;
  117.  
  118.        /* Remove parent sum contributions. Replace with child contributions.  */
  119.           tm = hRECT[ma].alo;
  120.           hRECT[io].alo = hRECT[io].frl * hRECT[io].dx;
  121.           hRECT[jo].alo = hRECT[jo].frl * hRECT[jo].dx;
  122.           sl -= tm;                    
  123.           sl += hRECT[io].alo + hRECT[jo].alo; 
  124.           tm = hRECT[ma].ahi;
  125.           hRECT[io].ahi = hRECT[io].flh * hRECT[io].dx;
  126.           hRECT[jo].ahi = hRECT[jo].flh * hRECT[jo].dx;
  127.           sh -= tm;
  128.           sh += hRECT[io].ahi + hRECT[jo].ahi;
  129.       }
  130.       if (it > iq) 
  131.           *eflag = DISCRET;
  132.       else
  133.           *eflag = NOERROR;
  134.  
  135.       return  (sh - sl);
  136. }
  137.