home *** CD-ROM | disk | FTP | other *** search
/ Collection of Education / collectionofeducationcarat1997.iso / COMPUSCI / NNUTL101.ZIP / NNSIM2 / NNCOMPET.C next >
C/C++ Source or Header  |  1993-07-31  |  4KB  |  99 lines
  1. /*-----------------------------------------------------------------------*
  2.  * Greg Stevens                                                   6/24/93*
  3.  *                              NNCOMPET.C                               *
  4.  *                                             [file 7 in a series of 7] *
  5.  *                                                                       *
  6.  * This file contains a function for updating activations in a layer in  *
  7.  * an all-or-none format per groupings of nodes.  This file also defines *
  8.  * constants for the number of clusters for each node.  The all-or-none  *
  9.  * cluster function assumes that each cluster will be of the same size,  *
  10.  * so it creates NUM_CLUSTERS_# for layer # each of size                 *
  11.  * NUMNODES[#] / NUM_CLUSTERS_# -- SO IT MUST BE EVENLY DIVISIBLE!       *
  12.  *  In the constant definitions, if a layer is not being used, the number*
  13.  * ofclusters should be set to 0.                                        *
  14.  *                                                                       *
  15.  *  To implement competative learning, all you have to do is include this*
  16.  * file in your main program instead of nnhebbln.c.                      *
  17.  *                                                                       *
  18.  *  For all the references to layers in this module, layers are numbered *
  19.  * 0 - (NUM_LAYERS-1), so the input layer is layer 0.                    *
  20.  *                                                                       *
  21.  *-----------------------------------------------------------------------*/
  22. #include "nnhebbln.c"
  23.  
  24. /* Definitions for the numbers of clusters in each layer */
  25.  
  26. #define NUM_CLUSTERS_0  1
  27. #define NUM_CLUSTERS_1  0
  28. #define NUM_CLUSTERS_2  0
  29. #define NUM_CLUSTERS_3  0
  30. #define NUM_CLUSTERS_4  0
  31. #define NUM_CLUSTERS_5  0
  32. #define NUM_CLUSTERS_6  0
  33. #define NUM_CLUSTERS_7  0
  34. #define NUM_CLUSTERS_8  0
  35. #define NUM_CLUSTERS_9  0
  36.  
  37. /* Function Prototype */
  38. NNETtype AllOrNoneLayerActs( NNETtype oldn, int l );
  39.  
  40. /* Function Definition */
  41. NNETtype AllOrNoneLayerActs( NNETtype oldn, int l )
  42. {
  43.    NNETtype n;
  44.    int u;                 /* looping variable for nodes                  */
  45.    int c;                 /* looping variable for clusters               */
  46.    int Winner;            /* index for winning node                      */
  47.    int NUMCLUSTERS;       /* stores the number of clusters in this layer */
  48.  
  49.    n = oldn;
  50.  
  51.    /* initialize NUMCLUSTERS */
  52.    if (l==1)
  53.      NUMCLUSTERS = NUM_CLUSTERS_0;
  54.    else if (l==2)
  55.      NUMCLUSTERS = NUM_CLUSTERS_1;
  56.    else if (l==3)
  57.      NUMCLUSTERS = NUM_CLUSTERS_2;
  58.    else if (l==4)
  59.      NUMCLUSTERS = NUM_CLUSTERS_3;
  60.    else if (l==5)
  61.      NUMCLUSTERS = NUM_CLUSTERS_4;
  62.    else if (l==6)
  63.      NUMCLUSTERS = NUM_CLUSTERS_5;
  64.    else if (l==7)
  65.      NUMCLUSTERS = NUM_CLUSTERS_6;
  66.    else if (l==8)
  67.      NUMCLUSTERS = NUM_CLUSTERS_7;
  68.    else if (l==9)
  69.      NUMCLUSTERS = NUM_CLUSTERS_8;
  70.    else if (l==10)
  71.      NUMCLUSTERS = NUM_CLUSTERS_9;
  72.  
  73.    /* calculate winner of each cluster  */
  74.  
  75.    u = 0;
  76.    for (c=1; (c<=NUMCLUSTERS); ++c)              /* for each cluster... */
  77.     {
  78.       Winner = u;                                /* reset winner to 0   */
  79.  
  80.       /* calculate winner */
  81.  
  82.       for (u=u; (u < (c * (NUMNODES[l]/NUMCLUSTERS))); ++u ) /* count units */
  83.        {                                                     /* this cluster*/
  84.         if (n.unit[l][u].state>n.unit[l][Winner].state)
  85.            Winner = u;
  86.        }
  87.  
  88.       /* reset values for winner takes all  */
  89.  
  90.       for (u=0; (u<NUMNODES[l]); ++u)
  91.          if (u==Winner)
  92.            n.unit[l][u].state = 1.0;
  93.          else
  94.            n.unit[l][u].state = 0.0;
  95.     }
  96.  
  97.    return( n );
  98. }
  99.