eoOp.h

// -*- mode: c++; c-indent-level: 4; c++-member-init-indent: 8; comment-column: 35; -*-
//-----------------------------------------------------------------------------
// eoOp.h
// (c) GeNeura Team, 1998
/* 
    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 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

    Contact: todos@geneura.ugr.es, http://geneura.ugr.es
    CVS Info: $Date: 2004/08/10 17:19:46 $ $Header: /cvsroot/eodev/eo/src/eoOp.h,v 1.29 2004/08/10 17:19:46 jmerelo Exp $ $Author: jmerelo $ 
 */
//-----------------------------------------------------------------------------

#ifndef _eoOp_H
#define _eoOp_H

#include <eoObject.h>
#include <eoPrintable.h>
#include <eoFunctor.h>
#include <utils/eoRNG.h>

template<class EOType>
class eoOp
{
public:
  enum OpType { unary = 0, binary = 1, quadratic = 2, general = 3};

  eoOp(OpType _type)
    :opType( _type ) {};

  eoOp( const eoOp& _eop )
    :opType( _eop.opType ) {};

  virtual ~eoOp(){};

  OpType getType() const {return opType;};

private:

  OpType opType;
};

template <class EOType>
class eoMonOp: public eoOp<EOType>, public eoUF<EOType&, bool>
{
public:
  eoMonOp()
    : eoOp<EOType>( eoOp<EOType>::unary ) {};
  virtual std::string className() const {return "eoMonOp";};
};


template<class EOType>
class eoBinOp: public eoOp<EOType>, public eoBF<EOType&, const EOType&, bool>
{
public:
  eoBinOp()
      :eoOp<EOType>( eoOp<EOType>::binary ) {};
  virtual std::string className() const {return "eoBinOp";};
};

template<class EOType>
class eoQuadOp: public eoOp<EOType>, public eoBF<EOType&, EOType&, bool> {
public:
  eoQuadOp()
    :eoOp<EOType>( eoOp<EOType>::quadratic ) {};
  virtual std::string className() const {return "eoQuadOp";};
};

template <class EOT>
class eoQuad2BinOp: public eoBinOp<EOT>
{
public:
  eoQuad2BinOp(eoQuadOp<EOT> & _quadOp) : quadOp(_quadOp) {}

  bool operator()(EOT & _eo1, const EOT & _eo2)
  {
    EOT eoTmp = _eo2;              // a copy that can be modified
    // if the embedded eoQuadOp is not symmetrical,
    // the result might be biased - hence the flip ...
    if (eo::rng.flip(0.5))
      return quadOp(_eo1, eoTmp);          // both are modified - that's all
    else
      return quadOp(eoTmp, _eo1);          // both are modified - that's all
  }

private:
  eoQuadOp<EOT> & quadOp;
};

#endif

---