platz/libs/ga.py

"""
Enthaelt alle Datenstrukturen um die einen genetischen Algorithmus darzustellen

"""
from random import *
from itertools import chain
from copy import deepcopy
from functools import total_ordering
import configparser, os


__author__ = "Michael Stangl"
__version__ = "$Revision: $"
__date__ = "$Date: $"
__copyright__ = "Copyright (c) 2005 Michael Stangl"
__license__ = "Python"

@total_ordering
class Loesung:
	"""ein einfaches Loesungsobjekt. Taugt um es als Superklasse zu ueberladen"""
	def __init__(self, *Argumente, **keywords):
		self.Id = -1 * randint(1,100)
		self.value = self.Id
		print(" initialisiere Loesung " + repr(self.Id))
	def mutieren(self):
		print(" mutiere Loesung " + repr(self.Id))
		self.Id = -1 * randint(1,100)
		self.value = self.Id
		return self
	def kreuzen(self,obj):
		print(" kreuze Loesung " + repr(self.Id))
	def laden(self):
		print(" lade Loesung " + repr(self.Id))
	def speichern(self):
		print(" speichere Loesung " + repr(self.Id))
	def __repr__(self):
		return ' L '+ repr(self.Id)
	def __eq__(self,other):
		return self.value == other.value
	def __lt__(self,other):
		return self.value < other.value

class Zyklus:
	"""Definiert wie ein Zyklus ablaufen soll:
	
		wann sollen Objekte generiert, gekreuzt, mutiert und selektiert werden
		wieviele sind davon jeweils betroffen
	"""
	def __init__(self, 	Name='default',
						Abfolge='e,m,s',
						Anzahl='10,10,10'):
		self.Name = Name
		self.Abfolge = Abfolge.split(',')
		self.Anzahl  = Anzahl.split(',')
	def __repr__(self):
		return( "Zyklus: %s\n"
				" Zyklusabfolge: %s\n"
				" Anzahl       : %s\n"
		% ( self.Name,
			self.Abfolge,
			self.Anzahl ) )
	def laden(self, FileName, ZyklusName):
		config = configparser.ConfigParser()
		ZyklusPath= os.path.split( FileName ) 
		ZyklusPath= os.path.join( FileName ) 
		config.read( ZyklusPath )
		self.Name = ZyklusName
		Abfolge = eval( config.get( ZyklusName, 'Abfolge' ))
		Anzahl  = eval( config.get( ZyklusName, 'Anzahl' ))
		self.Abfolge = Abfolge.split(',')
		self.Anzahl = Anzahl.split(',')
		pass

class Farm:
	"""enthaelt und pflegt Loesungsobjekte, kreuzt, mutiert, selektiert sie"""
	def __init__(self, Zyklus, Klasse, *Arguments, **keywords):
		"""initialisiere die Farm
	
		mit einem definerten Zyklus fuer die Zucht und dem gewunschten zu Zuchtobjekt
		"""
		self.Position = 0
		self.Pool = []
		self.PoolNeu = []
		self.Zyklus = Zyklus
		self.Klasse = Klasse
		for Aktion, Zahl in zip(Zyklus.Abfolge,Zyklus.Anzahl):
			#print 'Aktion:',Aktion
			#print 'Zahl:',Zahl
			self.Position = self.Position + 1
			if   Aktion == 'e':
				self.LoesungenErzeugen(int(Zahl), Klasse, *Arguments, **keywords)
			elif Aktion == 'm':
				self.LoesungenMutieren(int(Zahl))
			elif Aktion == 's':
				self.LoesungenAuswaehlen(int(Zahl))
			elif Aktion == 'S':
				self.LoesungenZufaelligAuswaehlen(int(Zahl))
			elif Aktion == 'j':
				self.LoesungenBehalten()
			elif Aktion == 'z':
				self.NeueGeneration()
			else:
				pass
	def LoesungenErzeugen(self, N, Klasse, *Arguments, **keywords):
		""" Erzeuge Loesungen"""
		for i in range(N):
			L = Klasse( *Arguments, **keywords )
			self.Pool.append(L)
		#print(repr(len(self.Pool)) + ' Loesungsobjekte erzeugt')
	def LoesungenKreuzen(self,N):
		"""mache aus zwei Loesungen eine neue"""
		#print("+ Loesungen kreuzen")
		for i in range(N):
			self.Pool.append(self.Pool[i].kreuzen())
	def LoesungenMutieren(self, N):
		"""veraendere die Loesung, so dass sie hoffentlich besser wird"""
		print("+ Loesungen mutieren: ", N)
		for n in range(N):
			#print(" -"+repr(n+1)+" mal")
			for L in chain(self.Pool):
				O = deepcopy(L)
				self.PoolNeu.append(O.mutieren())
		#print(self)
	def LoesungenBehalten(self):
		"""Behalte alle Eltern aus dem alten Pool"""
		print("+ alten Loesungspool behalten")
		self.PoolNeu = self.PoolNeu + self.Pool
		#print(self)
	def NeueGeneration(self):
		"""Loesche alle bisherigen Eltern und mache einen neuen Zyklus"""
		print("+ Neue Generation erzeugen")
		self.Pool = self.PoolNeu
		self.PoolNeu = []
		#print(self)
		#print("---------------")
	def LoesungenAuswaehlen(self, N):
		"""Selektiere die besten Loesungen"""
		print("+ die besten -", repr(N) +" - Loesungen auswaehlen -")
		for i in range(N):
			L = max(self.Pool)
			self.PoolNeu.append(L)
			self.Pool.remove(L)
		#print(self)
	def LoesungenZufaelligAuswaehlen(self, N):
		"""Selektiere zufaellig Loesungen"""
		print("+ zufaellig auswaehlen -"+ repr(N) + "-")
		for i in range(N):
			self.PoolNeu.append(choice(self.Pool))
		#print(self)
	def __repr__(self):
		"""Drucke die Farm am Bildschirm aus"""
		return( " gewaehlte Objekte (%d): %s\n"
				" Elternobjekte (%d)    : %s\n"
		% ( len(self.PoolNeu),  self.PoolNeu,
			len(self.Pool), self.Pool))
	def laden(self):
		print("+ laden")
	def speichern(self):
		print("+ speichern")
	def Bester(self):
		return  max(self.Pool)


if __name__ == '__main__':
	print("\n-- Erzeuge Zyklus:")
	#Z = Zyklus( Name='Easy',
				#Abfolge='e,s,+,m,j,S,+',
				#Anzahl='10,5,x,2,x,5,x'
				#)
	Z = Zyklus( Name='Easy',
				Abfolge='e,'+'s,z,m,j,z,'*3+'s',
				Anzahl='10,'+'5,x,2,x,x,'*3+'1'
				)
	print(Z)

	print("\n-- Erzeuge Loesungen:")
	L1 = Loesung()
	L2 = Loesung()
	L3 = Loesung()
	print(L1, L2, L3)
	print('L1 > L2 =', L1 > L2)
	print('L2 > L3 =', L2 > L3)
	print('L1 > L3 =', L1 > L3)

	A=2
	B=3

	print("\n-- Erzeuge Farm:")
	F1 = Farm( Z, Loesung, Arg1=A, Arg2=B, Arg3=L1 )
	print(F1)

else:
	pass