Re: program exit, while trying to initialize a class

From:

"dvir" <schdvir@gmail.com>

Newsgroups:

comp.lang.c++

Date:

7 Jun 2006 04:54:33 -0700

Message-ID:

<1149681273.572729.249600@c74g2000cwc.googlegroups.com>

Ok here is a more complete version of the code.
hope its more clear now.

main.C
------------
#include "tdagent.H"
#include "simple_env.H"
#include <vector>

int main()
{
    simple_env *env;
    env = new simple_env();
    env->create();
    tdagent *agent;
    agent = new tdagent(env);
....
}

simple_env.H
---------------------
#ifndef SIMPLE_ENV_H
#define SIMPLE_ENV_H

#include <math.h>
#include <boost/numeric/ublas/matrix.hpp>
#include <boost/numeric/ublas/vector.hpp>
#include <boost/numeric/ublas/io.hpp>
#include <boost/numeric/ublas/matrix_proxy.hpp>
#include <boost/numeric/ublas/vector_proxy.hpp>

#define PI 3.1415926535897932384626433832795

class simple_env
{
public:
    simple_env();
    ~simple_env();
    void create();
    float preform(float u);
    float get_reward();

    boost::numeric::ublas::vector<float> get_state();
    boost::numeric::ublas::vector<float> get_previous_state();
    boost::numeric::ublas::vector<float> get_final_state();
    boost::numeric::ublas::vector<float> get_cov();
    int get_actions_num();
    float get_min_reward();
    float get_max_reward();

private:
    float sigmoid(float u);
    float reward;
    boost::numeric::ublas::vector<float> state;
    boost::numeric::ublas::vector<float> prev_state;
    boost::numeric::ublas::vector<float> final_state;
    boost::numeric::ublas::vector<float> cov;

};

#endif

simple_env.C
---------------------
#include "simple_env.H"

namespace ublas = boost::numeric::ublas;
using namespace boost::numeric::ublas;

simple_env::simple_env()
{

      reward=0;
}

simple_env::~simple_env()
{

}

void simple_env::create()
{

    cov.resize(3);
    for (unsigned int i = 0; i < 3; ++ i)
        cov (i) = 1;
    vector<float> initial_state(3);
    for (unsigned int i = 0; i < initial_state.size (); ++ i)
        initial_state (i) = 0;

    final_state.resize(3);
    for (unsigned int i = 0; i < final_state.size (); ++ i)
        final_state (i) = 5;

    state=initial_state;

    return;
}

ublas::vector<float> simple_env::get_cov()
{
    return cov;
}

float simple_env::preform(float u)
{

    prev_state=state;
    for (unsigned int i = 0; i < state.size (); ++ i)
        state (i) += sigmoid(u);
    reward=norm_2(state);

    return reward;

}

float simple_env::get_reward()
{
    return reward;
}

ublas::vector<float> simple_env::get_state()
{
    return state;
}

ublas::vector<float> simple_env::get_final_state()
{
    return final_state;
}
ublas::vector<float> simple_env::get_previous_state()
{
    return prev_state;
}

float simple_env::sigmoid(float u)
{
    float s;
    s=PI/2*atanf(2/PI*u);
    return s;
}

int simple_env::get_actions_num()
{
    return 1;
}

float simple_env::get_min_reward()
{
    return 0;
}

float simple_env::get_max_reward()
{
    return 8.66;
}

tdagent.H
----------------
#ifndef TDGAENT_H
#define TDAGENT_H

#include "critic.H"
#include "actor.H"
#include "simple_env.H"

class tdagent
{

    private:

        ublas::vector<float> get_state();
        ublas::vector<float> get_previous_state();
        void set_previous_state(ublas::vector<float> curr_state);
        float get_reward();
        simple_env* env;
        critic* critic1;
        actor* actor1;
        float d;
        state x;

    public:
        tdagent(simple_env* environment);
        ~tdagent();
        std::vector<float> find_next_action();

};

#endif

tdagent.C
-----------------
#include "tdagent.H"

tdagent::tdagent(simple_env* env)
    : critic1(new critic(env->get_cov(),env->get_state())),
    actor1(new actor(env->get_cov(),env->get_state(),
env->get_actions_num(),
    env->get_min_reward(),env->get_max_reward()))

{
    x.prev=get_state();
}

....

Thanks.
Dvir