binarychromosome.cpp

遗传算法做图像的模式匹配

		// Frees used memory
		GaBinaryChromosome::~GaBinaryChromosome()
		{
			if( _bits )
				delete[] _bits;

			if( _backupBits )
				delete[] _backupBits;
		}

		// Make new chromosome of this type but with random characteristic
		GaChromosomePtr GaBinaryChromosome::MakeNewFromPrototype() const
		{
			// make chromosome with exact setup
			GaChromosomePtr newPtr = MakeCopy( true );
			GaBinaryChromosome* newChromosome = dynamic_cast<GaBinaryChromosome*>( &( *newPtr ) );

			// generate random chromosome code
			if( _codeSize )
			{
				newChromosome->_bits = new bool[ _codeSize ];
				newChromosome->_codeSize = _codeSize;

				for( int i = 0; i < _codeSize; i++ )
					newChromosome->_bits[ i ] = GaGlobalRandomBoolGenerator->
					Generate( ( (const GaBinaryChromosomeParams&)_configBlock->GetParameters() ).GetProbabilityOfSetState() );
			}

			return newPtr;
		}

		// Sets or clears bit of chromosome's code
		void GaBinaryChromosome::SetBitState(int bit,
			bool state)
		{
			if( bit >= 0 && bit < _codeSize )
				_bits[ bit ] = state;
		}

		// Returns state of selected bit of chromosome's code
		bool GaBinaryChromosome::GetBit(int bit)
		{
			if( bit >= 0 && bit < _codeSize )
				return _bits[ bit ];

			return false;
		}

		// Copy data and setup from given source chromosome
		GaChromosome& GaBinaryChromosome::operator =(const GaChromosome& rhs)
		{
			const GaBinaryChromosome& r = dynamic_cast<const GaBinaryChromosome&>( rhs );
			bool* bits = r._bits;
			_codeSize = r._codeSize;

			// allocate memory for new code
			if( _bits )
				delete[] _bits;
			_bits = new bool[ _codeSize ];

			// copy code
			for( int i = 0; i < _codeSize; i++ )
				_bits[ i ] = bits[ i ];

			return GaDefaultChromosome::operator =( rhs );
		}

		// Compares two chromosomes and returns how much are they simular in percent
		float GaBinaryChromosome::operator ==(const GaChromosome& c) const
		{
			const GaBinaryChromosome& r = dynamic_cast<const GaBinaryChromosome&>( c );
			bool* bits = r._bits;
			int s = r._codeSize;

			int sim = 0, t = s + _codeSize;

			// get shorter chromosome
			if( s > _codeSize )
				s = _codeSize;

			// compare codes
			for( int i = 0; i < s; i++ )
			{
				if( bits[ i ] == _bits[ i ] )
					sim += 2;
			}

			return ( (float)sim / t ) * 100;
		}

		// Returns char made based on bit stream
		char GaBinaryChromosome::GetChar(int pos/* = 0*/) const
		{
			if( pos < 0 || pos > _codeSize )
				return 0;

			char res = 0;

			for( int i = 0; pos + i < _codeSize && i < sizeof( char ); i++ )
				res = ( res << 1 ) | (char)_bits[ pos + i ];

			return res;
		}

		// Return array of chars made based on bit stream
		void GaBinaryChromosome::GetChar(char* output,
			int pos/* = 0*/,
			int size/* = 0*/) const
		{
			for( int i = 0; i < size; i++ )
				output[ i ] = GetChar( pos + i * sizeof( char ) );
		}

		// Returns short int made based on bit stream
		short GaBinaryChromosome::GetShort(int pos/* = 0*/) const
		{
			if( pos < 0 || pos > _codeSize )
				return 0;

			short res = 0;

			for( int i = 0; pos + i < _codeSize && i < sizeof( short ); i++ )
				res = ( res << 1 ) | (short)_bits[ pos + i ];

			return res;
		}

		// Return array of short ints made based on bit stream
		void GaBinaryChromosome::GetShort(short* output,
			int pos/* = 0*/,
			int size/* = 0*/) const
		{
			for( int i = 0; i < size; i++ )
				output[ i ] = GetShort( pos + i * sizeof( short ) );
		}

		// Returns int made based on bit stream
		int GaBinaryChromosome::GetInt(int pos/* = 0*/) const
		{			
			if( pos < 0 || pos > _codeSize )
				return 0;

			int res = 0;

			for( int i = 0; pos + i < _codeSize && i < sizeof( int ); i++ )
				res = ( res << 1 ) | (int)_bits[ pos + i ];

			return res;
		}

		// Return array of ints made based on bit stream
		void GaBinaryChromosome::GetInt(int* output,
			int pos/* = 0*/,
			int size/* = 0*/) const
		{
			for( int i = 0; i < size; i++ )
				output[ i ] = GetInt( pos + i * sizeof( int ) );
		}

		// Returns float made based on bit stream
		float GaBinaryChromosome::GetFloat(int pos/* = 0*/) const
		{
			if( pos < 0 || pos > _codeSize )
				return 0;

			int res = 0;

			for( int i = 0; pos + i < _codeSize && i < sizeof( int ); i++ )
				res = ( res << 1 ) | (int)_bits[ pos + i ];

			return *( (float*)&res );
		}

		// Return array of floats made based on bit stream
		void GaBinaryChromosome::GetFloat(float* output,
			int pos/* = 0*/,
			int size/* = 0*/) const
		{
			for( int i = 0; i < size; i++ )
				output[ i ] = GetFloat( pos + i * sizeof( float ) );
		}

		// Returns double made based on bit stream
		double GaBinaryChromosome::GetDouble(int pos/* = 0*/) const
		{
			if( pos < 0 || pos > _codeSize )
				return 0;

			long long res = 0;
 
			for( int i = 0; pos + i < _codeSize && i < sizeof( long long ); i++ )
				res = ( res << 1 ) | (int)_bits[ pos + i ];

			return *( (double*)&res );
		}

		// Return array of doubles made based on bit stream
		void GaBinaryChromosome::GetDouble(double* output,
			int pos/* = 0*/,
			int size/* = 0*/) const
		{
			for( int i = 0; i < size; i++ )
				output[ i ] = GetDouble( pos + i * sizeof( double ) );
		}

		// Creates array of bit from char.
		// Caller is responsible for array's memory.
		bool* GaBinaryChromosome::FromChar(char* input,
			int size)
		{
			if( !input || size <= 0 )
				return NULL;

			bool* bits = new bool[ size * sizeof( char ) ];

			for( int i = 0, k = 0; i < size; i++ )
			{
				for( int j = 0; j < sizeof( char ); j++, k++ )
					bits[ k ] = ( input[ i ] & ( 1 << j ) ) != 0;
			}

			return bits;
		}

		// Creates array of bit from short.
		// Caller is responsible for array's memory.
		bool* GaBinaryChromosome::FromShort(short* input,
			int size)
		{
			if( !input || size <= 0 )
				return NULL;

			bool* bits = new bool[ size * sizeof( short ) ];

			for( int i = 0, k = 0; i < size; i++ )
			{
				for( int j = 0; j < sizeof( short ); j++, k++ )
					bits[ k ] = ( input[ i ] & ( 1 << j ) ) != 0;
			}

			return bits;
		}

		// Creates array of bit from int.
		// Caller is responsible for array's memory.
		bool* GaBinaryChromosome::FromInt(int* input,
			int size)
		{
			if( !input || size <= 0 )
				return NULL;

			bool* bits = new bool[ size * sizeof( int ) ];

			for( int i = 0, k = 0; i < size; i++ )
			{
				for( int j = 0; j < sizeof( int ); j++, k++ )
					bits[ k ] = ( input[ i ] & ( 1 << j ) ) != 0;
			}

			return bits;
		}

		// Creates array of bit from float.
		// Caller is responsible for array's memory.
		bool* GaBinaryChromosome::FromFloat(float* input,
			int size)
		{
			if( !input || size <= 0 )
				return NULL;

			bool* bits = new bool[ size * sizeof( float ) ];

			for( int i = 0, k = 0; i < size; i++ )
			{
				for( int j = 0; j < sizeof( float ); j++, k++ )
					bits[ k ] = ( ( (int*)input )[ i ] & ( 1 << j ) ) != 0;
			}

			return bits;
		}

		// Creates array of bit from double.
		// Caller is responsible for array's memory.
		bool* GaBinaryChromosome::FromDouble(double* input,
			int size)
		{
			if( !input || size <= 0 )
				return NULL;

			bool* bits = new bool[ size * sizeof( double ) ];

			for( int i = 0, k = 0; i < size; i++ )
			{
				for( int j = 0; j < sizeof( double ); j++, k++ )
					bits[ k ] = ( ( (long long*)input )[ i ] & ( 1LL << j ) ) != 0;
			}

			return bits;
		}

		// Saves current chromosome's code before mutation
		void GaBinaryChromosome::PreapareForMutation()
		{
			_backupSize = _codeSize;

			_backupBits = new bool[ _codeSize ];
			memcpy( _backupBits, _bits, _codeSize );
		}

		// Accepts mutation and deletes backuped code
		void GaBinaryChromosome::AcceptMutation()
		{
			delete[] _backupBits;
			_backupBits = NULL;
		}

		// Rejects mutation and restores backuped chromosome's code
		void GaBinaryChromosome::RejectMutation()
		{
			delete[] _bits;
			_bits = _backupBits;
			_backupBits = NULL;

			_codeSize = _backupSize;
		}

	} // Representation
} // Chromosome