NormalizeMultiply.hpp

/*
 * NormalizeMultiply.hpp
 *
 *  Created on: Oct 24, 2014
 *      Author: pschultz
 */

#ifndef NORMALIZEMULTIPLY_HPP_
#define NORMALIZEMULTIPLY_HPP_

#include "NormalizeBase.hpp"
#include "components/Weights.hpp"

namespace PV {

class NormalizeMultiply : public NormalizeBase {
   // Member functions
  protected:
   virtual void ioParam_rMinX(enum ParamsIOFlag ioFlag);

   virtual void ioParam_rMinY(enum ParamsIOFlag ioFlag);

   virtual void ioParam_nonnegativeConstraintFlag(enum ParamsIOFlag ioFlag);

   virtual void ioParam_normalize_cutoff(enum ParamsIOFlag ioFlag);

   virtual void ioParam_normalizeFromPostPerspective(enum ParamsIOFlag ioFlag);
   // If false, group all weights with a common presynaptic
   // neuron for normalizing.  If true, group all weights with a
   // common postsynaptic neuron
   // Only meaningful (at least for now) for KernelConns using sum of weights or sum of squares
   // normalization methods.
 // end of NormalizeMultiply parameters

  public:
   NormalizeMultiply(const char *name, HyPerCol *hc);
   virtual ~NormalizeMultiply();

   float getRMinX() { return mRMinX; }
   float getRMinY() { return mRMinY; }
   float getNormalizeCutoff() { return mNormalizeCutoff; }
   bool getNormalizeFromPostPerspectiveFlag() { return mNormalizeFromPostPerspective; }

   virtual int normalizeWeights() override;

  protected:
   NormalizeMultiply();
   int initialize(const char *name, HyPerCol *hc);

   virtual int ioParamsFillGroup(enum ParamsIOFlag ioFlag) override;

   int applyThreshold(
         float *dataPatchStart,
         int weights_in_patch,
         float wMax); // weights less than normalize_cutoff*max(weights) are zeroed out

   int applyRMin(
         float *dataPatchStart,
         float rMinX,
         float rMinY,
         int nxp,
         int nyp,
         int xPatchStride,
         int yPatchStride);

   static void normalizePatch(float *patchData, int weightsPerPatch, float multiplier);

   // Member variables
  protected:
   float mRMinX                       = 0.0f;
   float mRMinY                       = 0.0f;
   bool mNonnegativeConstraintFlag    = false;
   float mNormalizeCutoff             = 0.0f;
   bool mNormalizeFromPostPerspective = false;
}; // class NormalizeMultiply

} /* namespace PV */

#endif /* NORMALIZEMULTIPLY_HPP_ */