/home/rex/ebltrunk/core/libeblearn/include/ebl_march.h

/***************************************************************************
 *   Copyright (C) 2011 by Pierre Sermanet *
 *   pierre.sermanet@gmail.com *
 *   All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are met:
 *     * Redistributions of source code must retain the above copyright
 *       notice, this list of conditions and the following disclaimer.
 *     * Redistributions in binary form must reproduce the above copyright
 *       notice, this list of conditions and the following disclaimer in the
 *       documentation and/or other materials provided with the distribution.
 *     * Redistribution under a license not approved by the Open Source
 *       Initiative (http://www.opensource.org) must display the
 *       following acknowledgement in all advertising material:
 *        This product includes software developed at the Courant
 *        Institute of Mathematical Sciences (http://cims.nyu.edu).
 *     * The names of the authors may not be used to endorse or promote products
 *       derived from this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESS OR IMPLIED
 * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
 * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
 * DISCLAIMED. IN NO EVENT SHALL ThE AUTHORS BE LIABLE FOR ANY
 * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
 * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
 * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
 * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 ***************************************************************************/

#ifndef EBL_MARCH_H_
#define EBL_MARCH_H_

#include "ebl_arch.h"

namespace ebl {

  template<typename T, class Tin = bbstate_idx<T>, class Tout = Tin>
    class s2m_module : virtual public module_1_1<T,Tin,Tout> {
  public:
    s2m_module(uint nstates, const char *name = "s2m_module");
    virtual ~s2m_module();
    virtual void fprop(Tin &in, mstate<Tout> &out);
    virtual void bprop(Tin &in, mstate<Tout> &out);
    virtual void bbprop(Tin &in, mstate<Tout> &out);
    virtual mfidxdim bprop_size(mfidxdim &osize);
    virtual uint nstates();
  protected:
    virtual void resize_output(Tin &in, mstate<Tout> &out, idxdim *d = NULL);
    // members /////////////////////////////////////////////////////////////////
  protected:
    uint _nstates;
  };

  template<typename T, class Tin = bbstate_idx<T>, class Tout = Tin>
    class m2s_module : virtual public module_1_1<T,Tin,Tout> {
  public:
    m2s_module(uint nstates, const char *name = "m2s_module");
    virtual ~m2s_module();
    virtual void fprop(mstate<Tin> &in, Tout &out);
    virtual void bprop(mstate<Tin> &in, Tout &out);
    virtual void bbprop(mstate<Tin> &in, Tout &out);
    virtual mfidxdim bprop_size(mfidxdim &osize);
    virtual uint nstates();
    // members /////////////////////////////////////////////////////////////////
  protected:
    uint _nstates;
  };

  template<typename T, class Tstate = bbstate_idx<T> >
    class ms_module : public module_1_1<T,Tstate,Tstate> {
  public:
    // constructors ////////////////////////////////////////////////////////////
    ms_module(bool replicate_inputs = false, const char *name = "ms_module");
    ms_module(module_1_1<T,Tstate> *pipe, uint n = 1,
              bool replicate_inputs = false, const char *name = "ms_module");
    ms_module(std::vector<module_1_1<T,Tstate>*> &pipes,
              bool replicate_inputs = false, const char *name = "ms_module");
    virtual ~ms_module();

    // multi-state inputs and outputs //////////////////////////////////////////
    virtual void fprop(mstate<Tstate> &in, mstate<Tstate> &out);
    virtual void bprop(mstate<Tstate> &in, mstate<Tstate> &out);
    virtual void bbprop(mstate<Tstate> &in, mstate<Tstate> &out);
    virtual void dump_fprop(mstate<Tstate> &in, mstate<Tstate> &out);
    virtual void forget(forget_param_linear& fp);

    // sizes propagations //////////////////////////////////////////////////////
    virtual fidxdim fprop_size(fidxdim &i_size);
    virtual mfidxdim fprop_size(mfidxdim &isize);
    virtual fidxdim bprop_size(const fidxdim &o_size);
    virtual mfidxdim bprop_size(mfidxdim &o_size);

    // printing ////////////////////////////////////////////////////////////////
    virtual std::string pretty(idxdim &isize);
    virtual std::string pretty(mfidxdim &isize);
    virtual std::string describe();

    // accessors ///////////////////////////////////////////////////////////////
    virtual void set_switch(midxdim &sizes);
    virtual void set_switch(intg id);
    virtual uint npipes();
    virtual module_1_1<T,Tstate>* get_pipe(uint i);
    virtual module_1_1<T,Tstate>* last_module();

    // internal methods ////////////////////////////////////////////////////////
  protected:
    virtual void init();
    virtual void init_fprop(mstate<Tstate> &in, mstate<Tstate> &out);
    virtual void switch_pipes(mstate<Tstate> &in);

    // variable members ////////////////////////////////////////////////////////
  protected:
    std::vector<module_1_1<T,Tstate>*> pipes; 
    std::vector<module_1_1<T,Tstate>*> used_pipes; 
    std::vector<uint> pipes_noutputs; 
    svector<mstate<Tstate> > ins; 
    svector<mstate<Tstate> > mbuffers; 
    bool replicate_inputs; 
    midxdim switches; 
    bool bindex; 
    intg switch_id; 

    // friends /////////////////////////////////////////////////////////////////
    template <typename T1, class Ts, class Tc>
      friend EXPORT Tc* arch_find(ms_module<T1,Ts> *m, Tc *c);
    template <typename T1, class Ts, class Tc>
    friend EXPORT std::vector<Tc*> arch_find_all(ms_module<T1,Ts> *m, Tc *c,
                                                 std::vector<Tc*> *);
    template <typename T1, class Ts, class Tc>
    friend EXPORT ms_module<T1,Ts>*
      arch_narrow(ms_module<T1,Ts> *m, Tc *c, bool i, bool *f);
    friend class ms_module_gui;
  };

  template<typename T, class Tstate = bbstate_idx<T> >
    class msc_module : public ms_module<T,Tstate> {
  public:
    msc_module(std::vector<module_1_1<T,Tstate>*> &pipes, uint nsize = 1,
               uint stride = 1, uint nsize2 = 0,
               const char *name = "msc_module");
    virtual ~msc_module();
    virtual fidxdim fprop_size(fidxdim &i_size);
    virtual fidxdim bprop_size(const fidxdim &o_size);
    virtual mfidxdim bprop_size(mfidxdim &o_size);
    virtual std::string describe();

    // internal methods ////////////////////////////////////////////////////////
  protected:
    virtual void init_fprop(mstate<Tstate> &in, mstate<Tstate> &out);

  // variable members //////////////////////////////////////////////////////////
  protected:
    using ms_module<T,Tstate>::pipes;
    using ms_module<T,Tstate>::used_pipes;
    using ms_module<T,Tstate>::ins;
    using ms_module<T,Tstate>::pipes_noutputs;
    uint nsize; 
    uint stride; 
    uint nsize2; 
  };

  // arch find methods /////////////////////////////////////////////////////////

  template <typename T, class Tstate, class Tcast>
    EXPORT Tcast* arch_find(module_1_1<T,Tstate> *m, Tcast *c);
  template <typename T, class Tstate, class Tcast>
    EXPORT Tcast* arch_find(layers<T,Tstate> *m, Tcast *c);
  template <typename T, class Tstate, class Tcast>
    EXPORT Tcast* arch_find(ms_module<T,Tstate> *m, Tcast *c);

  // arch find_all methods /////////////////////////////////////////////////////

  template <typename T, class Tstate, class Tcast>
    EXPORT std::vector<Tcast*> arch_find_all(module_1_1<T,Tstate> *m, Tcast *c,
                                             std::vector<Tcast*> *v = NULL);
  template <typename T, class Tstate, class Tcast>
    EXPORT std::vector<Tcast*> arch_find_all(layers<T,Tstate> *m, Tcast *c,
                                             std::vector<Tcast*> *v = NULL);
  template <typename T, class Tstate, class Tcast>
    EXPORT std::vector<Tcast*> arch_find_all(ms_module<T,Tstate> *m, Tcast *c,
                                             std::vector<Tcast*> *v = NULL);

  // arch narrow methods ///////////////////////////////////////////////////////

  template <typename T, class Tstate, class Tcast>
    EXPORT module_1_1<T,Tstate>*
    arch_narrow(module_1_1<T,Tstate> *m, Tcast *c, bool included = true,
                bool *found = NULL);
  template <typename T, class Tstate, class Tcast>
    EXPORT layers<T,Tstate>*
    arch_narrow(layers<T,Tstate> *m, Tcast *c, bool included = true,
                bool *found = NULL);
  template <typename T, class Tstate, class Tcast>
    EXPORT ms_module<T,Tstate>*
    arch_narrow(ms_module<T,Tstate> *m, Tcast *c, bool included = true,
                bool *found = NULL);

} // namespace ebl {

#include "ebl_march.hpp"

#endif /* EBL_MARCH_H_ */