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 "basicdevicefactory.h"
#include "basicdevice.h"
#include "phbib.h"
#include "signals.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();

    void print(std::ostream &os) const;

    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();
      
      void print(std::ostream & os) const {Device::print(os);};
};


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();
      
      void print(std::ostream & os) const {Device::print(os);};
};






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();
};

} // namespace mimo


#endif /* MIMOLIB_ARITH_H */

---