Conselhos sobre tipo de dados

[diogo.feec]

Olha, amigos. Peço-lhes conselhos quanto ao desenvolvimento de um novo tipo de dado. Eu necessito de apenas quatro valores: 0, 1, 2 e 3. Sendo que a soma entre eles sempre cairá dentro dos mesmos elementos (exemplo a soma de 2 + 2 será 0, pois ( 2 + 2 ) % 4 me retorna 0). Por essas características eu não preciso de tipos de dados unsigned int ou unsigned short int, pois eles são muitos grandes e muitos bits não serão usados. Vale lembrar que este tipo de dados será usados em vários vetores e/ou matrizes. Pensei em criar o tipo como sendo uma classe e sobrecarregar o operador de +. O que vocês me aconselham?

Grato.

[Matheus Maldi]

use o tipo int8_t (unisigned char), é o menor tipo de data possivel, porém seu tipo de dado necessita de apenas 2 bits, os outros 6 bits não serão usados...

[ScreenBlack]

Em compiladores 32bit, o tipo unsigned int ocupará 32bit (Máximo: 4.294.967.295) e o tipo unsigned shor int ocupará 16bit (Máximo: 65.535).

Se você quiser, dá pra usar tamanhos menores, como 4bit (Máximo: 7), ou então, apenas 1bit (Máximo: 1). Pra isso, terá de usar máscara de bit.

Você pretende usar isso em sistema embarcado com restrição de memória?

[diogo.feec]

Em compiladores 32bit, o tipo unsigned int ocupará 32bit (Máximo: 4.294.967.295) e o tipo unsigned shor int ocupará 16bit (Máximo: 65.535).

Se você quiser, dá pra usar tamanhos menores, como 4bit (Máximo: 7), ou então, apenas 1bit (Máximo: 1). Pra isso, terá de usar máscara de bit.

Você pretende usar isso em sistema embarcado com restrição de memória?

Olá, ScreenBlack, obrigado pela resposta. Bem, o sistema não é embarcado, porém irei trabalhar com matrizes na ordem de 49.149 X 16.383. Portanto, a memória é um fator de suma importância.

No caso, como eu farei uso das máscaras de bits? Considerando que eu necessito de apenas 2 bits?

Obrigado.

use o tipo int8_t (unisigned char), é o menor tipo de data possivel, porém seu tipo de dado necessita de apenas 2 bits, os outros 6 bits não serão usados...

Obrigado, Matheus. Sim, acabo de pesquisar esse tipo de dado e farei o uso dele. Porém, eu preciso criar um novo tipo de dado ou uso esse tipo diretamente na declaração dos vetores?

[ScreenBlack]

Aqui mesmo no fórum, tem um tópico sobre isso.

Espero que ajude.

[Jarlisson]

Sabe Matemática Discreta? Fazer operações com bits mesmo?

Pro seu caso, acho que usar 2 bits e ignorar 6 de um dado, vai fazer falta...

[Matheus Maldi]

Como você não tem memoria infinita, recomendo bitboards, segue um exemplo que guarda 64 valores booleano em 64 bits

class UnsignedLongBits
{
private:
	unsigned long long _data;

public:
	UnsignedLongBits()
	{
		_data = 0;
	}

	bool getIndex(int index)
	{
		return (_data & (1 << index) != 0);
	}

	void setIndex(int index, bool value)
	{
		if (value)
			_data |= (1 << index);
		else
			_data &= ~(1 << index);
	}
};

Todos os bits iniciam com 0(false).

A logica do codigo foi retirando do livro Microsoft Visual C# 2008 Step by Step 2008 e adaptado para o C++.

[diogo.feec]

Aqui mesmo no fórum, tem um tópico sobre isso.

Espero que ajude.

Sim, vou dar uma olhada.

Sabe Matemática Discreta? Fazer operações com bits mesmo?

Pro seu caso, acho que usar 2 bits e ignorar 6 de um dado, vai fazer falta...

Pois é mesmo matemática discreta. No caso estou implementando uma versão simplificada de um anel algébrico.

[diogo.feec]

Fiz algumas simulações e acho que tem alguma coisa errada.

usando as matrizes e vetores usando o struct o programa usou a mesma quantidade de memória quando eu mudei para o tipo unsigned int.

As matrizes e vetores do tipo unsigned short foram usadas como controle e realmente usou uma quantidade de memória menor do que as duas implementações de cima. Segue o código:

#include <boost/numeric/ublas/vector.hpp>
#include <boost/numeric/ublas/matrix.hpp>
#include <boost/numeric/ublas/io.hpp>



using namespace boost::numeric::ublas;


typedef struct
{
	unsigned int b:1;
	unsigned int a:1;
} bit_mask;

typedef union
{
	bit_mask mask;
	unsigned int valor:2;
} TUnion;

int main( void )
{
	time_t startTime =  time( NULL );


	const unsigned int nLin = 35000, nCol = 6000;

	matrix<unsigned int> mat( nLin, nCol );

	srand( time( NULL ) );

	for ( unsigned int i = 0; i != nLin; ++i )
		for ( unsigned int j = 0; j != nCol; ++j )
			mat( i, j ) = rand() % 4;

	vector<unsigned int> vec( nLin );

	 srand( time( NULL ) );

	for ( unsigned int i = 0; i != nLin; ++i )
		vec( i ) = rand() % 4;

	vector<unsigned int> res( nCol );

	for ( unsigned int i = 0; i != nLin; ++i )
		for ( unsigned int j = 0; j != nCol; ++j ) {
			res( j ) += mat( i, j ) * vec( i );
			res( j ) %= 4;
		}


	matrix<TUnion> mat( nLin, nCol );

	srand( time( NULL ) );

	for ( unsigned int i = 0; i != nLin; ++i )
		for ( unsigned int j = 0; j != nCol; ++j )
			mat( i, j ).valor = rand() % 4;

	vector<TUnion> vec( nLin );

	 srand( time( NULL ) );

	for ( unsigned int i = 0; i != nLin; ++i )
		vec( i ).valor = rand() % 4;

	vector<TUnion> res( nCol );

	for ( unsigned int i = 0; i != nLin; ++i )
		for ( unsigned int j = 0; j != nCol; ++j ) {
			res( j ).valor += mat( i, j ).valor * vec( i ).valor;
			res( j ).valor %= 4;
		}


	matrix<unsigned short> mat( nLin, nCol );

	srand( time( NULL ) );

	for ( unsigned int i = 0; i != nLin; ++i )
		for ( unsigned int j = 0; j != nCol; ++j )
			mat( i, j ) = rand() % 4;

	vector<unsigned short> vec( nLin );

	 srand( time( NULL ) );

	for ( unsigned int i = 0; i != nLin; ++i )
		vec( i ) = rand() % 4;

	vector<unsigned short> res( nCol );

	for ( unsigned int i = 0; i != nLin; ++i )
		for ( unsigned int j = 0; j != nCol; ++j ) {
			res( j ) += mat( i, j ) * vec( i );
			res( j ) %= 4;
		}
	//std::cout << res;*/

	time_t endTime =  time( NULL );
	std::cout << "\nExecution time is " << difftime( endTime, startTime ) << " seconds.\n";
	return 0;
}

Eu queria um tipo de dado que usasse somente dois bits. Pois vou usar os valores 0, 1, 2 e 3. Sendo assim a quantidade de memória usada seria inferior os tipos padrão do programa.