discrete.h

Go to the documentation of this file.

#ifndef DISCR_H
#define DISCR_H

#include "../shared_ptr.h"
#include "../base/bdmbase.h"
#include "../math/chmat.h"

namespace bdm {

// Abstract support - pokus, jen diskretni.. takze jmeno discrete support je lepci:)
// ale jediny, co by umel, je first_vec a next_vec, hmm:(
// class support : public root {

class rectangular_support: public root {
private:
        void initialize();
protected:
        Array<vec> ranges;
        ivec gridsizes;
        int dim;
        int Npoints;
        vec actvec;
        vec actvec_ind;
        vec steps;
public:
        rectangular_support() : dim ( 0 ), Npoints ( 0 ) {
        }

        void set_parameters ( const Array<vec> &ranges0, const ivec &gridsize0 );

        vec get_vec ( const ivec &inds );

        long linear_index ( const ivec inds );

        const vec& first_vec();

        const vec& next_vec();

        ivec nearest_point ( const vec &val );

        int points() const {
                return Npoints;
        }

        const vec& _steps() const {
                return steps;
        }

        void from_setting ( const Setting &set );
};
UIREGISTER ( rectangular_support );

class discrete_support: public root {
protected:
        Array<vec> Spoints;
        int idx;
public:
        discrete_support() : Spoints ( 0 ), idx ( 0 ) {}
        int points() const {
                return Spoints.length();
        }
        const vec& first_vec() {
                bdm_assert_debug ( Spoints.length() > 0, "Empty support" );
                idx = 0;
                return Spoints ( idx );
        }
        const vec& next_vec() {
                bdm_assert_debug ( Spoints.length() > idx - 1, "Out of support points" );
                return Spoints ( ++idx );
        }

        void from_setting ( const Setting &set );

        Array<vec> & _Spoints() {
                return Spoints;
        }
};
UIREGISTER ( discrete_support );

class grid_fnc: public fnc {
protected:
        rectangular_support sup;
        vec values;
public:
        void set_support ( rectangular_support &sup0 ) {
                sup = sup0;
                values = zeros ( sup.points() );
        }
        void set_values ( double ( *evalptr ) ( const vec& ) );

        double nearest_val ( const vec &val ) {
                return values ( sup.linear_index ( sup.nearest_point ( val ) ) );
        }

        vec eval ( const vec &val ) {
                return vec_1 ( nearest_val ( val ) );
        }
};
UIREGISTER ( grid_fnc );

class egrid: public epdf {
protected:
        rectangular_support sup;
        vec values;
public:
        double evallog ( const vec &val ) {
                return log ( values ( sup.linear_index ( sup.nearest_point ( val ) ) ) );
        }

};
}
#endif //DISCR_H

---