arith.h

Go to the documentation of this file.

/***************************************************************************
 *                                                                         *
 *   This library is free software; you can redistribute it and/or         *
 *   modify it under the terms of the GNU Lesser General Public            *
 *   License as published by the Free Software Foundation; either          *
 *   version 2.1 of the License, or (at your option) any later version.    *
 *                                                                         *
 *   This library is distributed in the hope that it will be useful,       *
 *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU     *
 *   Lesser General Public License for more details.                       *
 *                                                                         *
 *   You should have received a copy of the GNU Lesser General Public      *
 *   License along with this library; if not, write to the Free Software   *
 *   Foundation, Inc., 59 Temple Place, Suite 330, Boston,                 *
 *   MA  02111-1307  USA                                                   *
 *                                                                         *
 ***************************************************************************/
#ifndef MIMOLIB_ARITH_H
#define MIMOLIB_ARITH_H

#include <simthetic/basicdevicefactory.h>
#include <simthetic/basicdevice.h>
#include <simthetic/phbib.h>
#include <simthetic/signals.h>
#include <simthetic/phrand.h>

#include "matrix.h"


using namespace simth;
//using namespace simthlib;
namespace mimo {

class Multiply : public Device
{
  protected:
    Multiply(int deviceID, DeviceSystemIntf* system, 
         const simth::PropertyList& pl,
         unsigned input_ports);
    unsigned iports;
    
  public:
    virtual void updateInputLengths();
    virtual void updateOutputLengths();

    static void init(const std::string& fileName, 
             Device** dev, 
             DeviceSystemIntf* sysPtr, 
             int ID,
             const std::string& regionQualifier);
};



template<class seqTM, class seqTV>
class MultiplyTM : public Multiply
{
  public:
    MultiplyTM(int deviceID, DeviceSystemIntf* system, 
           const simth::PropertyList& pl,
           unsigned input_ports, size_t dimension);

    void process();
};


template<class seqTM>
class SquareTM : public Multiply
{
  public:
    SquareTM(int deviceID, DeviceSystemIntf* system, 
         const simth::PropertyList& pl,
         unsigned input_ports, size_t dimension);

    void process();
};


template<class seqTM, class seqTV>
class MultiplyInvTM : public Multiply
{
  public:
    MultiplyInvTM(int deviceID, DeviceSystemIntf* system, 
          const simth::PropertyList& pl,
          size_t dim_in, size_t dim_out);

    void process();
};


template<class seqT_in, class seqT_out>
class CalcCapacity : public Device
{
   protected:
      unsigned int rows, cols;

   private:
      double noise;

   public:
      CalcCapacity(int deviceID, DeviceSystemIntf* system, 
           const PropertyList& pl);

      void setSNR(double snr);
      void setNoisePower(double n) { noise = n; };

      void updateInputLengths()
      {
     setInputLength(outputLength());
      };
      void updateOutputLengths()
      {
     setOutputLength(inputLength());
      };
      
      void process();
};

class CalcSVDValues : public Device
{
   protected:
      unsigned int rows, cols, nr_svds;

   public:
      CalcSVDValues(int deviceID, DeviceSystemIntf* system, 
            const PropertyList& pl);

      void updateInputLengths()
      { setInputLength(outputLength()); };
      void updateOutputLengths()
      { setOutputLength(inputLength()); };
      
      void process();
};

// ////////////////////////////////////////////////////////////

class CalcConditionNr : public Device
{
   protected:
      unsigned int rows, cols;

   public:
      CalcConditionNr(int deviceID, DeviceSystemIntf* system, 
              const PropertyList& pl);

      void updateInputLengths()
      { setInputLength(outputLength()); };
      void updateOutputLengths()
      { setOutputLength(inputLength()); };
      
      void process();
};

class CalcRank : public CalcConditionNr
{
   public:
      CalcRank(int deviceID, DeviceSystemIntf* system, 
           const PropertyList& pl);
      void process();
};

// ////////////////////////////////////////////////////////////

template<class seqT_in, class seqT_out>
class CalcMax : public Device
{
   protected:
      unsigned int length;
      
   public:
      CalcMax(int deviceID, DeviceSystemIntf* system, 
          const PropertyList& pl);

      void updateInputLengths()
      {
     setInputLength(outputLength());
      };
      void updateOutputLengths()
      {
     setOutputLength(inputLength());
      };
      
      void process();
};






namespace Invert {
   void init(const std::string& fileName, 
         Device** dev, 
         DeviceSystemIntf* sysPtr, 
         int ID,
         const std::string& regionQualifier);
}



template<class seqT>
class InvertTM : public Multiply
{
  public:
    InvertTM(int deviceID, DeviceSystemIntf* system, 
         const simth::PropertyList& pl,
         size_t dim1, size_t dim2);

    void process();
};


class AwgnGenerator : public simth::Device
{
  public:

    AwgnGenerator(int deviceID, simth::DeviceSystemIntf* system,
                          const simth::PropertyList& pl = simth::PropertyList());

    ~AwgnGenerator();

    virtual void process();

    virtual void setSNR(double snr);

    void updateInputLengths();
    void updateOutputLengths();
    void startOfSimulation();

  private:

    double getGauss() const;

    simth::GaussRng gauss;
};

} // namespace mimo


#endif /* MIMOLIB_ARITH_H */

---