---

kernel.h

Go to the documentation of this file.

#ifndef __KERNEL_H__
#define __KERNEL_H__

#include <vector>

#include "globals.h" 
#include "tristate.h"
#include "matrix.h"



/******************************************************************************/
/* Defines and typedefs                                                       */
/******************************************************************************/

#define PARTIAL_LAT_INDEX(ui,uj,k,radius,width) (((k)-(ui)+(radius))*(width)-(uj)+(radius))
#define FULL_LAT_INDEX(partial_index,l) ((partial_index)+(l))
#define LAT_INDEX(ui,uj,k,l,radius,width) FULL_LAT_INDEX(PARTIAL_LAT_INDEX((ui),(uj),(k),(radius),(width)),(l))



/* MAP/LOCAL ROW CONVERSION:  These hide how rows are distributed to PEs      */

#define MAPROW(localrow) (ARBITRARY_MAPROW((localrow),MyPE))
#define ARBITRARY_MAPROW(localrow,pe) (pe+(localrow)*NPEs)

#define LOCALROW(maprow) ((maprow)/NPEs)

#define PEFORROW(maprow) ((maprow)%NPEs)

#define ROWISLOCAL(maprow) (ARBITRARY_ROWISLOCAL((maprow),MyPE))
#define ARBITRARY_ROWISLOCAL(maprow,pe) ((pe)==PEFORROW(maprow))


/* #define VERIFY_WEIGHT_SAVES */



#define PARTIAL_INP_INDEX(eye,x) ((eye)*(RN*RN)+(x)*(RN))
#define FULL_INP_INDEX(partial_inp_index,y) ((partial_inp_index)+(y))
#define INP_INDEX(eye,x,y) FULL_INP_INDEX(PARTIAL_INP_INDEX((eye),(x)),(y))
#define INP_INDEX_OTHER_EYE(eye,first_inp_index) ((first_inp_index) + ((eye)*RN*RN))



/******************************************************************************/
/* BasicLissomMap                                                             */
/******************************************************************************/


class BasicLissomMap {
public:
  BasicLissomMap(int height, int width,
                 // These parameters should instead be deduced from
                 // add_input, but doing so would require breaking up
                 // init_weights, which would change the stream of 
                 // random numbers generated to initialize the weights,
                 // which would change every simulations' results,
                 // so it has been put off until other things settle
                 // down.
                 int num_aff_, int RN_, int rf_rad_, int exc_rad_, int inh_rad_, int NPEs) :
    exc_rad(exc_rad_), inh_rad(inh_rad_), rf_radius(rf_rad_),
    N(width), RN(RN_),
    aff_array_width(2*rf_radius+1),
    exc_array_width(2*exc_rad+1),
    inh_array_width(2*inh_rad+1),
    lat_exc_dimension(exc_array_width * exc_array_width),
    lat_inh_dimension(inh_array_width * inh_array_width),
    perows(N/NPEs),
  
#ifdef VERIFY_WEIGHT_SAVES
  Orig_map(height,width),
  Orig_wts(perows,width),
#endif
    
    cortex_map(height,width),
    wts(perows,width),
    reference_wts(num_aff_,aff_array_width,exc_array_width,inh_array_width)
    {
      (void)height;  assert (height==width);

      /* Copy addresses into map structure */
      for (int i=0; i< perows; i++)
        for (int j=0; j<N; j++){               
          
          wts[i][j] = Wts(num_aff_,aff_array_width,exc_array_width,inh_array_width);
            
          cortex_map[MAPROW(i)][j].lat_exc_wts = &(wts[i][j].lat_exc_wts[0]);
          cortex_map[MAPROW(i)][j].lat_inh_wts = &(wts[i][j].lat_inh_wts[0]);
          cortex_map[MAPROW(i)][j].weights     = &(wts[i][j].weights);
          
#ifdef VERIFY_WEIGHT_SAVES
          Orig_wts[i][j] = Wts(num_aff_,aff_array_width,exc_array_width,inh_array_width);
            
          /* Copy addresses into duplicate map structure */
          Orig_map[MAPROW(i)][j].lat_exc_wts = &(Orig_wts[i][j].lat_exc_wts[0]);
          Orig_map[MAPROW(i)][j].lat_inh_wts = &(Orig_wts[i][j].lat_inh_wts[0]);
          Orig_map[MAPROW(i)][j].weights     = &(Orig_wts[i][j].weights);
#endif
        }
  }
  
  virtual ~BasicLissomMap() { }

  typedef float a_weight;
  typedef float l_weight;
  typedef MatrixType<a_weight>::rectangular  AfferentWeights;
  typedef std::vector<AfferentWeights>       AfferentWeightsList;
  
  /* The record type for neurons in a map */
  struct Neuron {
    int centerx, centery         ; 
    AfferentWeightsList* weights ; 
    l_weight *lat_exc_wts        ; 
    l_weight *lat_inh_wts        ; 
  };

  
  struct Wts {
    Wts() { }
    
    Wts(int num_aff, int aff_width, int exc_width, int inh_width)
      : lat_exc_wts(exc_width*exc_width),
        lat_inh_wts(inh_width*inh_width) {
      for (int i=0; i<num_aff; i++)
        weights.push_back(AfferentWeights(aff_width,aff_width));
    }

    AfferentWeightsList weights;
    
    typedef std::vector<l_weight> LateralWeights;
    LateralWeights lat_exc_wts;
    LateralWeights lat_inh_wts;
  };
  
  virtual int    num_aff_inputs() const=0;
  
  /* Publically-accessible variables */
  int exc_rad; /* Can be changed */
  const int inh_rad;
  const int rf_radius;
  const int N;
  const int RN;
  
  const int aff_array_width;
  const int exc_array_width;
  const int inh_array_width;
  const int lat_exc_dimension;
  const int lat_inh_dimension;
  const int perows;

  typedef MatrixType<Neuron>::rectangular  MapType;
  typedef MatrixType<Wts>::rectangular     WtsType;

#ifdef VERIFY_WEIGHT_SAVES
  MapType Orig_map;
  WtsType Orig_wts;
#endif

  MapType cortex_map;
  WtsType wts;

protected:
  Wts reference_wts; 
};



#endif

---