OperatorFunction.h

Go to the documentation of this file.

/*
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 3 of the License, or
 * (at your option) any later version.
 *
 * Written (W) 2013 Soumyajit De
 */

#ifndef OPERATOR_FUNCTION_H_
#define OPERATOR_FUNCTION_H_

#include <shogun/lib/config.h>
#include <shogun/base/SGObject.h>
#include <shogun/base/Parameter.h>
#include <shogun/mathematics/linalg/linop/LinearOperator.h>
#include <shogun/lib/computation/engine/IndependentComputationEngine.h>

namespace shogun
{

enum EOperatorFunction
{
    OF_SQRT=0,
    OF_LOG=1,
    OF_POLY=2,
    OF_UNDEFINED=3
};

template<class T> class SGVector;
class CJobResultAggregator;
template<class T> class CLinearOperator;

template<class T> class COperatorFunction : public CSGObject
{
public:
    COperatorFunction()
    : CSGObject(),
      m_function_type(OF_UNDEFINED)
    {
        init();
    }

    COperatorFunction(CLinearOperator<T>* op,
        CIndependentComputationEngine* engine,
        EOperatorFunction type=OF_UNDEFINED)
    : CSGObject(),
      m_function_type(type)
    {
        init();

        m_linear_operator=op;
        SG_REF(m_linear_operator);

        m_computation_engine=engine;
        SG_REF(m_computation_engine);
    }

    virtual ~COperatorFunction()
    {
        SG_UNREF(m_linear_operator);
        SG_UNREF(m_computation_engine);
    }

    CLinearOperator<T>* get_operator() const
    {
        return m_linear_operator;
    }

    virtual void precompute() = 0;

    virtual CJobResultAggregator* submit_jobs(SGVector<T> sample) = 0;

    virtual const char* get_name() const
    {
        return "OperatorFunction";
    }
protected:
    CLinearOperator<T>* m_linear_operator;

    CIndependentComputationEngine* m_computation_engine;

    const EOperatorFunction m_function_type;

private:
    void init()
    {
      m_linear_operator=NULL;
      m_computation_engine=NULL;

        SG_ADD((CSGObject**)&m_linear_operator, "linear_operator",
            "Linear operator of this operator function", MS_NOT_AVAILABLE);

        SG_ADD((CSGObject**)&m_computation_engine, "computation_engine",
            "Computation engine for the jobs this will generate", MS_NOT_AVAILABLE);
    }
};
}

#endif // OPERATOR_FUCNTION_H_