GrayCode_base.hpp

Go to the documentation of this file.

#ifndef GRAYCODE_BASE_H
#define GRAYCODE_BASE_H

#include "matrix_base.hpp"




template <typename intType>
class GrayCode_base : public matrix_base<intType> {

public:

#if CACHELINE>=64
private:
    uint8_t padding[CACHELINE-sizeof(matrix_base<intType>)-sizeof(intType)];
#endif

    matrix_base<intType> n_ary_limits;


public:

GrayCode_base() : matrix_base<intType>() {
    this->rows = 0;
    this->cols = 0;

    n_ary_limits = matrix_base<intType>();
}

GrayCode_base( intType* data_in, matrix_base<intType> n_ary_limits_) : matrix_base<intType>(data_in, 1, n_ary_limits_.size()) {

    n_ary_limits = n_ary_limits_;

}


GrayCode_base( matrix_base<intType> n_ary_limits_) : matrix_base<intType>(1, n_ary_limits_.size()) {

    n_ary_limits = n_ary_limits_;

}


GrayCode_base( intType value, matrix_base<intType>& n_ary_limits_) : matrix_base<intType>(1, n_ary_limits_.size()) {

    if (value == 0) {
        memset(this->data, value, n_ary_limits_.size()*sizeof(intType));
    }
    else {
        for (size_t idx=0; idx < this->size(); idx ++) {
            this->data[idx] = value;
        }
    }

    n_ary_limits = n_ary_limits_;

}


GrayCode_base(const GrayCode_base &in) : matrix_base<intType>(in) {

    n_ary_limits = in.n_ary_limits;

}

bool
operator==( const GrayCode_base &gcode) const {

    if (this->cols != gcode.cols) {
        return false;
    }


    for (intType idx=0; idx<this->cols; idx++) {
        if ( this->data[idx] != gcode[idx] ) {
            return false;
        }

        if ( n_ary_limits[idx] != gcode.n_ary_limits[idx] ) {
            return false;
        }
    }

    return true;

}


intType&
operator[](size_t idx) {
    return this->data[idx];
}

const intType&
operator[](size_t idx) const {
    return this->data[idx];
}



void
operator= (const GrayCode_base &gcode ) {

    matrix_base<intType>::operator=( gcode );

    n_ary_limits = gcode.n_ary_limits;

}


GrayCode_base
copy() const {

     GrayCode_base ret = GrayCode_base(this->n_ary_limits);

    // logical variable indicating whether the matrix needs to be conjugated in CBLAS operations
    ret.conjugated = this->conjugated;
    // logical variable indicating whether the matrix needs to be transposed in CBLAS operations
    ret.transposed = this->transposed;
    // logical value indicating whether the class instance is the owner of the stored data or not. (If true, the data array is released in the destructor)
    ret.owner = true;

    memcpy( ret.data, this->data, this->rows*this->cols*sizeof(intType));


    ret.n_ary_limits = n_ary_limits.copy();

    return ret;

}




matrix_base<intType>
get_Limits() const {

    return n_ary_limits.copy();

}



GrayCode_base
add_Digit( const intType n_ary_limit) const {

    matrix_base<intType> n_ary_limits_new( 1, n_ary_limits.size() + 1 );
    memcpy( n_ary_limits_new.get_data(), n_ary_limits.get_data(), n_ary_limits.size()*sizeof(intType) );
    
    n_ary_limits_new[ n_ary_limits_new.size() -1 ] = n_ary_limit;
    
    GrayCode_base<intType> gcode_ret( n_ary_limits_new );
    
    memcpy( gcode_ret.get_data(), this->data, this->size()*sizeof(intType) );
    gcode_ret[ gcode_ret.size()-1 ] = 0;
    
    return gcode_ret;
   

}



GrayCode_base
remove_Digit( const int idx) const {

    matrix_base<intType> n_ary_limits_new( 1, n_ary_limits.size() - 1 );
    memcpy( n_ary_limits_new.get_data(), n_ary_limits.get_data(), idx*sizeof(intType) );
    memcpy( n_ary_limits_new.get_data()+idx, n_ary_limits.get_data()+idx+1, (n_ary_limits.size()-idx-1)*sizeof(intType) );
    
    
    GrayCode_base<intType> gcode_ret( n_ary_limits_new );
    
    memcpy( gcode_ret.get_data(), this->data, idx*sizeof(intType) );
    memcpy( gcode_ret.get_data()+idx, this->data+idx+1, (this->size()-idx-1)*sizeof(intType) );  
    
    return gcode_ret;
   

}





};



#endif // GRAYCODE_BASE_HPP