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

/***************************************************************************
 *   Copyright (C) 2008 by Yann LeCun, Pierre Sermanet, Koray Kavukcuoglu *
 *   yann@cs.nyu.edu, pierre.sermanet@gmail.com, koray@cs.nyu.edu *
 *
 * 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_TESTER_H_
#define EBL_TESTER_H_

#include <stdio.h>
#include <iostream>
#include <sstream>
#include <ostream>

#include "libidx.h"
#include "ebl_states.h"
#include "ebl_basic.h"
#include "ebl_arch.h"

namespace ebl {

  template <class T> class module_tester {
  public:
    module_tester(double thres = 1e-6, T rrange_min = -1.0, T rrange_max = 1.0,
                  FILE* out = stdout);
    virtual ~module_tester();

    idx<double> test_jacobian(module_1_1<T> &m, bbstate_idx<T> &in, 
                              bbstate_idx<T> &out);
    idx<double> test_jacobian_param(parameter<bbstate_idx<T> > &p, 
                                    module_1_1<T>& m, 
                                    bbstate_idx<T> &in, bbstate_idx<T> &out);
    idx<double> test_hessian(module_1_1<T> &m, bbstate_idx<T> &in, 
                             bbstate_idx<T> &out);
    idx<double> test_hessian_param(parameter<bbstate_idx<T> > &p, 
                                   module_1_1<T>& m, 
                                   bbstate_idx<T> &in, bbstate_idx<T> &out);
    double get_acc_thres() const;
    void set_acc_thres(double acc_thres);
    T get_rrange() const;
    void set_rrange(T rrange);
    FILE* get_out() const;
    void set_out(FILE* out);
    
    // protected methods ///////////////////////////////////////////////////////
  protected:

    void get_jacobian_fprop(module_1_1<T> &m, bbstate_idx<T> &in, 
                            bbstate_idx<T> &out, idx<T>& jac);
    void get_jacobian_fprop_param(parameter<bbstate_idx<T> > &p, 
                                  module_1_1<T> &m, bbstate_idx<T> &in, 
                                  bbstate_idx<T> &out, idx<T>& jac);
    void get_jacobian_bprop(module_1_1<T> &m, bbstate_idx<T> &in, 
                            bbstate_idx<T> &out, idx<T>& jac);
    void get_jacobian_bprop_param(parameter<bbstate_idx<T> > &p, 
                                  module_1_1<T> &m, bbstate_idx<T> &in, 
                                  bbstate_idx<T> &out, idx<T>& jac);

    void get_hessian_fprop(module_1_1<T> &m, bbstate_idx<T> &in, 
                           bbstate_idx<T> &out, idx<T>& jac);
    void get_hessian_fprop_param(parameter<bbstate_idx<T> > &p, 
                                 module_1_1<T> &m, bbstate_idx<T> &in, 
                                 bbstate_idx<T> &out, idx<T>& jac);
    void get_hessian_bprop(module_1_1<T> &m, bbstate_idx<T> &in, 
                           bbstate_idx<T> &out, idx<T>& jac);
    void get_hessian_bprop_param(parameter<bbstate_idx<T> > &p, 
                                  module_1_1<T> &m, bbstate_idx<T> &in, 
                                 bbstate_idx<T> &out, idx<T>& jac);
    
    void report_err(idx<T>& a, idx<T>& b, const char* msg);
    idx<double> get_errs(idx<T>& a, idx<T>& b);

    // protected members ///////////////////////////////////////////////////////
  protected:
    double acc_thres; 
    T rrange_min, rrange_max; 
    FILE* out; 
    idx<T> jac_fprop, jac_bprop, jac_bbprop; 
    idx<T> jac_pfprop, jac_pbprop, jac_pbbprop; 
    idx<T> hes_fprop, hes_bprop, hes_bbprop; 
    idx<T> hes_pfprop, hes_pbprop, hes_pbbprop; 
  };


  template <class T> class Jacobian_tester {
  public:
    Jacobian_tester() {};
    ~Jacobian_tester() {};
    // this function take any module_1_1 with a fprop et bprop implemented,
    // and tests if the jacobian is correct (by pertubation) 
    // (on a fstate_idx with 3 dimensions)
    void test(module_1_1<T> &module);
  };


  template <class T> class Bbprop_tester {
  public:
    Bbprop_tester() {};
    ~Bbprop_tester() {};
    // this function take any module_1_1 with a fprop et bbprop implemented, 
    // and tests if the Bbprop is correct (by pertubation) 
    // (on a fstate_idx with 3 dimensions)
    void test(module_1_1<T> &module);
  };


  template <class T> class Bprop_tester {
  public:
    Bprop_tester() {};
    ~Bprop_tester() {};
    // this function take any module_1_1 with a fprop et bprop implemented, 
    // and tests if the bprop is correct (by pertubation) 
    // (on a fstate_idx with 3 dimensions)
    void test(module_1_1<T> &module);
  };

} // namespace ebl {

#include "ebl_tester.hpp"

#endif /* EBL_TESTER_H_ */