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 ARITH_H
#define ARITH_H

#include <basicdevicefactory.h>
#include <basicdevice.h>
#include <phbib.h>
#include <signals.h>
#include <freeconnectionsystem.h>

namespace simthlib
{

class Add : public simth::Device
{
  protected:
    unsigned int iports;

    Add(int deviceID, simth::DeviceSystemIntf* system,
    const simth::PropertyList& pl,
        unsigned int _iports);

  public:
    virtual void updateInputLengths();
    virtual void updateOutputLengths();

    template<class seqT>
    void process();

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

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

    static void init(simth::DeviceFactory& registration);
};

template<class seqT>
class AddT : public Add
{
   public:
      AddT(int deviceID, simth::DeviceSystemIntf* system,
       const simth::PropertyList& pl,
       unsigned int _iports);

      AddT(int deviceID,
       simth::DeviceSystemIntf* system,
       const simth::PropertyList& pl)
     : Add (deviceID, system, pl, 
        pl.simth::PropertyList::getProperty<unsigned>("input_ports"))
      {
     insertInputInterface< seqT >(iports);
     insertOutputInterface< seqT >();
      }

      void process()
      { Add::process<seqT>(); };
};




class Multiply : public simth::Device
{
  protected:
    Multiply(int deviceID, simth::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,
                     simth::Device** dev,
                     simth::DeviceSystemIntf* sysPtr,
                     int ID,
                     const std::string& regionQualifier);
};


template<class seqT>
class MultiplyT : public Multiply
{
  protected:
      typename seqT::value_type factor;

  public:
      MultiplyT(int deviceID, simth::DeviceSystemIntf* system,
        const simth::PropertyList& pl,
        typename seqT::value_type _factor,
        unsigned input_ports);

      MultiplyT(int deviceID,
        simth::DeviceSystemIntf* system,
        const simth::PropertyList& pl)
     : Multiply (deviceID, system, pl,
             pl.simth::PropertyList::getProperty<unsigned>("input_ports"))
       , factor(pl.simth::PropertyList::getProperty<typename seqT::value_type>("factor"))
      {
     insertInputInterface< seqT >(iports);
     insertOutputInterface< seqT >();
      }

      void process();
};

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

    void process();
};


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

}



#endif /* ARITH_H */

---