alglib::ae_matrix_wrapper Class Reference

#include <ap.h>

Inheritance diagram for alglib::ae_matrix_wrapper:

Collaboration diagram for alglib::ae_matrix_wrapper:

Public Member Functions
	ae_matrix_wrapper ()
virtual	~ae_matrix_wrapper ()
const ae_matrix_wrapper &	operator= (const ae_matrix_wrapper &rhs)
void	setlength (ae_int_t rows, ae_int_t cols)
ae_int_t	rows () const
ae_int_t	cols () const
bool	isempty () const
ae_int_t	getstride () const
void	attach_to (alglib_impl::ae_matrix *ptr)
void	allocate_own (ae_int_t rows, ae_int_t cols, alglib_impl::ae_datatype datatype)
const alglib_impl::ae_matrix *	c_ptr () const
alglib_impl::ae_matrix *	c_ptr ()

Protected Member Functions
void	create (const ae_matrix_wrapper &rhs)
void	create (const char *s, alglib_impl::ae_datatype datatype)
void	assign (const ae_matrix_wrapper &rhs)

Protected Attributes
alglib_impl::ae_matrix *	p_mat
alglib_impl::ae_matrix	mat

Detailed Description

Definition at line 1200 of file ap.h.

Constructor & Destructor Documentation

ae_matrix_wrapper()

alglib::ae_matrix_wrapper::ae_matrix_wrapper

(

)

Definition at line 6303 of file ap.cpp.

{
    p_mat = NULL;
}

~ae_matrix_wrapper()

alglib::ae_matrix_wrapper::~ae_matrix_wrapper ( )

virtual

Definition at line 6308 of file ap.cpp.

{
    if( p_mat==&mat )
        ae_matrix_clear(p_mat);
}

Member Function Documentation

allocate_own()

void alglib::ae_matrix_wrapper::allocate_own	(	ae_int_t	rows,
		ae_int_t	cols,
		alglib_impl::ae_datatype	datatype
	)

Definition at line 6454 of file ap.cpp.

{
    if( p_mat==&mat )
        ae_matrix_clear(p_mat);
    p_mat = &mat;
    if( !ae_matrix_init(p_mat, rows, cols, datatype, NULL, false) )
        throw alglib::ap_error("ALGLIB: malloc error");
}

assign()

void alglib::ae_matrix_wrapper::assign ( const ae_matrix_wrapper &  rhs )

protected

Definition at line 6371 of file ap.cpp.

{
    if( this==&rhs )
        return;
    if( p_mat==&mat || p_mat==NULL )
    {
        //
        // Assignment to non-proxy object
        //
        ae_matrix_clear(p_mat);
        if( rhs.p_mat!=NULL )
        {
            p_mat = &mat;
            if( !ae_matrix_init_copy(p_mat, rhs.p_mat, NULL, ae_false) )
                throw alglib::ap_error("ALGLIB: malloc error!");
        }
        else
            p_mat = NULL;
    }
    else
    {
        //
        // Assignment to proxy object
        //
        ae_int_t i;
        if( rhs.p_mat==NULL )
            throw alglib::ap_error("ALGLIB: incorrect assignment to array (sizes do not match)");
        if( rhs.p_mat->datatype!=p_mat->datatype )
            throw alglib::ap_error("ALGLIB: incorrect assignment to array (types do not match)");
        if( rhs.p_mat->rows!=p_mat->rows )
            throw alglib::ap_error("ALGLIB: incorrect assignment to array (sizes do not match)");
        if( rhs.p_mat->cols!=p_mat->cols )
            throw alglib::ap_error("ALGLIB: incorrect assignment to array (sizes do not match)");
        for(i=0; i<p_mat->rows; i++)
            memcpy(p_mat->ptr.pp_void[i], rhs.p_mat->ptr.pp_void[i], p_mat->cols*alglib_impl::ae_sizeof(p_mat->datatype));
    }
}

attach_to()

void alglib::ae_matrix_wrapper::attach_to

(

alglib_impl::ae_matrix *

ptr

)

Definition at line 6445 of file ap.cpp.

{
    if( ptr==&mat )
        throw alglib::ap_error("ALGLIB: attempt to attach matrix to itself");
    if( p_mat==&mat )
        ae_matrix_clear(p_mat);
    p_mat = ptr;
}

c_ptr() [1/2]

const alglib_impl::ae_matrix * alglib::ae_matrix_wrapper::c_ptr

(

)

const

Definition at line 6463 of file ap.cpp.

{
    return p_mat;
}

c_ptr() [2/2]

alglib_impl::ae_matrix * alglib::ae_matrix_wrapper::c_ptr

(

)

Definition at line 6468 of file ap.cpp.

{
    return p_mat;
}

cols()

alglib::ae_int_t alglib::ae_matrix_wrapper::cols

(

)

const

Definition at line 6426 of file ap.cpp.

{
    if( p_mat==NULL )
        return 0;
    return p_mat->cols;
}

create() [1/2]

void alglib::ae_matrix_wrapper::create ( const ae_matrix_wrapper &  rhs )

protected

Definition at line 6320 of file ap.cpp.

{
    if( rhs.p_mat!=NULL )
    {
        p_mat = &mat;
        if( !ae_matrix_init_copy(p_mat, rhs.p_mat, NULL, ae_false) )
            throw alglib::ap_error("ALGLIB: malloc error!");
    }
    else
        p_mat = NULL;
}

create() [2/2]

void alglib::ae_matrix_wrapper::create ( const char *  s, alglib_impl::ae_datatype  datatype  )

protected

Definition at line 6332 of file ap.cpp.

{
    std::vector< std::vector<const char*> > smat;
    size_t i, j;
    char *p = filter_spaces(s);
    try
    {
        str_matrix_create(p, &smat);
        if( smat.size()!=0 )
        {
            allocate_own((ae_int_t)(smat.size()), (ae_int_t)(smat[0].size()), datatype);
            for(i=0; i<smat.size(); i++)
                for(j=0; j<smat[0].size(); j++)
                {
                    if( datatype==alglib_impl::DT_BOOL )
                        p_mat->ptr.pp_bool[i][j]    = parse_bool_delim(smat[i][j],",]");
                    if( datatype==alglib_impl::DT_INT )
                        p_mat->ptr.pp_int[i][j]     = parse_int_delim(smat[i][j],",]");
                    if( datatype==alglib_impl::DT_REAL )
                        p_mat->ptr.pp_double[i][j]  = parse_real_delim(smat[i][j],",]");
                    if( datatype==alglib_impl::DT_COMPLEX )
                    {
                        alglib::complex t = parse_complex_delim(smat[i][j],",]");
                        p_mat->ptr.pp_complex[i][j].x = t.x;
                        p_mat->ptr.pp_complex[i][j].y = t.y;
                    }
                }
        }
        else
            allocate_own(0, 0, datatype);
        alglib_impl::ae_free(p);
    }
    catch(...)
    {
        alglib_impl::ae_free(p);
        throw;
    }
}

getstride()

alglib::ae_int_t alglib::ae_matrix_wrapper::getstride

(

)

const

Definition at line 6438 of file ap.cpp.

{
    if( p_mat==NULL )
        return 0;
    return p_mat->stride;
}

isempty()

bool alglib::ae_matrix_wrapper::isempty

(

)

const

Definition at line 6433 of file ap.cpp.

{
    return rows()==0 || cols()==0;
}

operator=()

const alglib::ae_matrix_wrapper & alglib::ae_matrix_wrapper::operator=

(

const ae_matrix_wrapper &

rhs

)

Definition at line 6314 of file ap.cpp.

{
    assign(rhs);
    return *this;
}

rows()

alglib::ae_int_t alglib::ae_matrix_wrapper::rows

(

)

const

Definition at line 6419 of file ap.cpp.

{
    if( p_mat==NULL )
        return 0;
    return p_mat->rows;
}

setlength()

void alglib::ae_matrix_wrapper::setlength	(	ae_int_t	rows,
		ae_int_t	cols
	)

Definition at line 6409 of file ap.cpp.

{
    if( p_mat==NULL )
        throw alglib::ap_error("ALGLIB: setlength() error, p_mat==NULL (array was not correctly initialized)");
    if( p_mat!=&mat )
        throw alglib::ap_error("ALGLIB: setlength() error, p_mat!=&mat (attempt to resize frozen array)");
    if( !ae_matrix_set_length(p_mat, rows, cols, NULL) )
        throw alglib::ap_error("ALGLIB: malloc error");
}

Member Data Documentation

mat

alglib_impl::ae_matrix alglib::ae_matrix_wrapper::mat

protected

Definition at line 1253 of file ap.h.

p_mat

alglib_impl::ae_matrix* alglib::ae_matrix_wrapper::p_mat

protected

Definition at line 1252 of file ap.h.

---

The documentation for this class was generated from the following files:

• xmippCore/core/alglib/ap.h
• xmippCore/core/alglib/ap.cpp