matrix.h

Go to the documentation of this file.

// Copyright (C) 2011 CNRS - Ecole Polytechnique - INRIA.
//
// This file is part of TIFA.
//
// TIFA is free software; you can redistribute it and/or modify it under the 
// terms of the GNU Lesser General Public License as published by the Free
// Software Foundation; either version 2.1 of the License, or (at your option)
// any later version.
//
// TIFA is distributed in the hope that it will be useful, but WITHOUT ANY
// WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
// FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for
// more details.
//
// You should have received a copy of the GNU Lesser General Public License
// along with this library; if not, write to the Free Software Foundation,
// Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301 USA.

#if !defined(_TIFA_MATRIX_H_)

#define _TIFA_MATRIX_H_

#ifdef __cplusplus
extern "C" {
#endif

#include "tifa_config.h"

#include <inttypes.h>

#include "bitstring_t.h"

#define NO_SUCH_ROW UINT32_MAX

/*
 *-----------------------------------------------------------------------------
 *              binary_matrix_t and associated functions
 *-----------------------------------------------------------------------------
 */

struct struct_binary_matrix_t {
    uint32_t nrows_alloced;
    uint32_t ncols_alloced;
    uint32_t nrows;
    uint32_t ncols;
    TIFA_BITSTRING_T** data;
};
typedef struct struct_binary_matrix_t binary_matrix_t;

binary_matrix_t* alloc_binary_matrix(uint32_t nrows, uint32_t ncols);

binary_matrix_t* clone_binary_matrix(const binary_matrix_t * const matrix);

void reset_binary_matrix(binary_matrix_t* const matrix);

void free_binary_matrix(binary_matrix_t* const matrix);

void print_binary_matrix(const binary_matrix_t* const matrix);

inline static uint8_t get_matrix_bit(uint32_t row, uint32_t col,
                                     const binary_matrix_t* const matrix) {
#if BITSTRING_T_SIZE_IS_POW_OF_TWO
    uint32_t col_offset = col & (BITSTRING_T_BITSIZE - 1);
    col_offset = BITSTRING_T_BITSIZE - 1 - col_offset;
    col        = col >> POW_TWO_BITSTRING_T_SIZE;
#else
    uint32_t col_offset = col % BITSTRING_T_BITSIZE;
    col_offset = BITSTRING_T_BITSIZE - 1 - col_offset;
    col       /= BITSTRING_T_BITSIZE;
#endif
    if (0 == ((((TIFA_BITSTRING_T)1)<<col_offset) & matrix->data[row][col])) {
        return 0;
    } else {
        return 1;
    }
}
inline static void set_matrix_bit_to_one(uint32_t row, uint32_t col,
                                         binary_matrix_t* const matrix) {
#if BITSTRING_T_SIZE_IS_POW_OF_TWO
    uint32_t col_offset = col & (BITSTRING_T_BITSIZE - 1);
    col_offset = BITSTRING_T_BITSIZE - 1 - col_offset;
    col        = col >> POW_TWO_BITSTRING_T_SIZE;
#else
    uint32_t col_offset = col % BITSTRING_T_BITSIZE;
    col_offset = BITSTRING_T_BITSIZE - 1 - col_offset;
    col       /= BITSTRING_T_BITSIZE;
#endif
    matrix->data[row][col] |= ((TIFA_BITSTRING_T)1<<col_offset);
}

inline static void set_matrix_bit_to_zero(uint32_t row, uint32_t col,
                                          binary_matrix_t* const matrix) {
#if BITSTRING_T_SIZE_IS_POW_OF_TWO
    uint32_t col_offset = col & (BITSTRING_T_BITSIZE - 1);
    col_offset = BITSTRING_T_BITSIZE - 1 - col_offset;
    col        = col >> POW_TWO_BITSTRING_T_SIZE;
#else
    uint32_t col_offset = col % BITSTRING_T_BITSIZE;
    col_offset = BITSTRING_T_BITSIZE - 1 - col_offset;
    col       /= BITSTRING_T_BITSIZE;
#endif
    matrix->data[row][col] &= !(((TIFA_BITSTRING_T)1)<<col_offset);
}

inline static void flip_matrix_bit(uint32_t row, uint32_t col,
                                   binary_matrix_t* const matrix){
#if BITSTRING_T_SIZE_IS_POW_OF_TWO
    uint32_t col_offset = col & (BITSTRING_T_BITSIZE - 1);
    col_offset = BITSTRING_T_BITSIZE - 1 - col_offset;
    col        = col >> POW_TWO_BITSTRING_T_SIZE;
#else
    uint32_t col_offset = col % BITSTRING_T_BITSIZE;
    col_offset = BITSTRING_T_BITSIZE - 1 - col_offset;
    col       /= BITSTRING_T_BITSIZE;
#endif
    matrix->data[row][col] ^= (((TIFA_BITSTRING_T)1)<<col_offset);
}
inline static uint32_t first_row_with_one_on_col(uint32_t col,
                                   const binary_matrix_t* const matrix) {
#if BITSTRING_T_SIZE_IS_POW_OF_TWO
    uint32_t col_offset = col & (BITSTRING_T_BITSIZE - 1);
    col_offset = BITSTRING_T_BITSIZE - 1 - col_offset;
    col        = col >> POW_TWO_BITSTRING_T_SIZE;
#else
    uint32_t col_offset = col % BITSTRING_T_BITSIZE;
    col_offset = BITSTRING_T_BITSIZE - 1 - col_offset;
    col       /= BITSTRING_T_BITSIZE;
#endif
    for (uint32_t irow = 0; irow < matrix->nrows; irow++) {
        if ((((TIFA_BITSTRING_T)1)<<col_offset) & matrix->data[irow][col]) {
            return irow;
        }
    }
    return NO_SUCH_ROW;
}

/*
 *-----------------------------------------------------------------------------
 *              byte_matrix_t and associated functions
 *-----------------------------------------------------------------------------
 */

struct struct_byte_matrix_t {
    uint32_t nrows_alloced;
    uint32_t ncols_alloced;
    uint32_t nrows;
    uint32_t ncols;
    unsigned char** data;
};

typedef struct struct_byte_matrix_t byte_matrix_t;

byte_matrix_t* alloc_byte_matrix(uint32_t nrows, uint32_t ncols);

byte_matrix_t* clone_byte_matrix(const byte_matrix_t * const matrix);

void reset_byte_matrix(byte_matrix_t* const matrix);

void free_byte_matrix(byte_matrix_t* const matrix);

void print_byte_matrix(const byte_matrix_t* const matrix);

#ifdef __cplusplus
}
#endif

#endif

---