n_aryGrayCodeCounter.cpp

Go to the documentation of this file.

#include "n_aryGrayCodeCounter.h"
#include <cstring>
#include <iostream>



n_aryGrayCodeCounter::n_aryGrayCodeCounter()  {


   offset_max = 0;
   offset = 0;

}


n_aryGrayCodeCounter::n_aryGrayCodeCounter( matrix_base<int>& n_ary_limits_in) {

    n_ary_limits = n_ary_limits_in.copy();

    if ( n_ary_limits.size() == 0 ) {
        offset_max = 0;
        offset = 0;
        return;
    }

    offset_max = n_ary_limits[0];
    for (size_t idx=1; idx<n_ary_limits.size(); idx++) {
        offset_max *= n_ary_limits[idx];
    }

    offset_max--;
    offset = 0;

    // initialize the counter
    initialize(0);

}


n_aryGrayCodeCounter::n_aryGrayCodeCounter( matrix_base<int>& n_ary_limits_in, int64_t initial_offset) {

    n_ary_limits = n_ary_limits_in.copy();

    if ( n_ary_limits.size() == 0 ) {
        offset_max = 0;
        offset = 0;
        return;
    }

    offset_max = n_ary_limits[0];
    for (size_t idx=1; idx<n_ary_limits.size(); idx++) {
        offset_max *= n_ary_limits[idx];
    }

    offset_max--;
    offset = initial_offset;

    // initialize the counter
    initialize(initial_offset);

}




void 
n_aryGrayCodeCounter::initialize() {

    initialize(0);

}


void 
n_aryGrayCodeCounter::initialize( int64_t initial_offset ) {

    if ( initial_offset < 0 || initial_offset > offset_max ) {
        std::string error("n_aryGrayCodeCounter::initialize:  Wrong value of initial_offset");
        throw error;
    }

    // generate counter chain
    counter_chain = matrix_base<int>( 1, n_ary_limits.size() );

    for (size_t idx = 0; idx < n_ary_limits.size(); idx++) {
        counter_chain[idx] = initial_offset % n_ary_limits[idx];
        initial_offset /= n_ary_limits[idx]; 
    }

    // determine the initial gray code corresponding to the given offset
    gray_code = GrayCode( n_ary_limits );
    int parity = 0;
    for (unsigned long long jdx = n_ary_limits.size()-1; jdx != ~0ULL; jdx--) {
        gray_code[jdx] = parity ? n_ary_limits[jdx] - 1 - counter_chain[jdx] : counter_chain[jdx];
        parity = parity ^ (gray_code[jdx] & 1);
    }



}



GrayCode  
n_aryGrayCodeCounter::get() {


    return gray_code.copy();

}


int  
n_aryGrayCodeCounter::next() {

    int changed_index;

    int&& ret = next(changed_index);
    return ret;

}


int  
n_aryGrayCodeCounter::next( int& changed_index) {


    int value_prev, value;
    int&& ret = next( changed_index, value_prev, value);
    return ret;

}

int   
n_aryGrayCodeCounter::next( int& changed_index, int& value_prev, int& value) {


    // determine the index which is about to modify
    changed_index = 0;

    if ( offset >= offset_max ) {
        return 1;
    }


    bool update_counter = true;
    int counter_chain_idx = 0;
    while( update_counter ) {

        if ( counter_chain[counter_chain_idx] < n_ary_limits[counter_chain_idx]-1 ) {
            counter_chain[counter_chain_idx]++;
            update_counter = false;
        }
        else if ( counter_chain[counter_chain_idx] == n_ary_limits[counter_chain_idx]-1 ) {
            counter_chain[counter_chain_idx] = 0;
            update_counter = true;
        }

        counter_chain_idx++;

    }


    // determine the updated gray code
    int parity = 0;
    for (size_t jdx = n_ary_limits.size()-1; jdx != ~0ULL; jdx--) {
        int gray_code_new_val = parity ? n_ary_limits[jdx] - 1 - counter_chain[jdx] : counter_chain[jdx];
        parity = parity ^ (gray_code_new_val & 1);

        if ( gray_code_new_val != gray_code[jdx] ) {
            value_prev = gray_code[jdx];
            value = gray_code_new_val;
            gray_code[jdx] = gray_code_new_val;
            changed_index = jdx;
            break;
        }
    }

    offset++;

    return 0;

}



void  
n_aryGrayCodeCounter::set_offset_max( const int64_t& value ) {


    offset_max = value;

}