private GPSolutionDefinition CreateSampleDefinition(string listName)
{
GPSolutionDefinition definition = new GPSolutionDefinition(config);
definition.CreateListByName(listName, config.minLevels, config.maxLevels);
definition.AddSemanticaToList(listName, definition.GetSemantica(GPConsts.BOOL_AND));
SemanticaList listSemantic = definition.GetListByName(listName);
Assert.IsNotNull(listSemantic);
Assert.IsTrue(listSemantic.Contains(definition.GetSemantica(GPConsts.BOOL_AND)));
//Assert.IsFalse(listSemantic.Contains(definition.GetSemantica(GPConsts.BOOL_NOT)));
// definition.AddSemanticaToList(listName, definition.GetSemantica(GPConsts.BOOL_NOT));
//Assert.IsTrue(listSemantic.Contains(definition.GetSemantica(GPConsts.BOOL_NOT)));
definition.AddSemanticaToList(listName, definition.GetSemantica(GPConsts.BOOL_OR));
definition.AddSemanticaToList(listName, definition.GetSemantica(GPConsts.COMP_DIF));
definition.AddSemanticaToList(listName, definition.GetSemantica(GPConsts.COMP_EQUAL));
definition.AddSemanticaToList(listName, definition.GetSemantica(GPConsts.COMP_GREATER));
definition.AddSemanticaToList(listName, definition.GetSemantica(GPConsts.COMP_GREATER_EQ));
definition.AddSemanticaToList(listName, definition.GetSemantica(GPConsts.COMP_LOWER));
definition.AddSemanticaToList(listName, definition.GetSemantica(GPConsts.COMP_LOWER_EQ));
definition.AddSemanticaToList(listName, definition.GetSemantica(GPConsts.OPER_ADD));
definition.AddSemanticaToList(listName, definition.GetSemantica(GPConsts.OPER_DIVIDE));
definition.AddSemanticaToList(listName, definition.GetSemantica(GPConsts.OPER_MULTIPLY));
definition.AddSemanticaToList(listName, definition.GetSemantica(GPConsts.OPER_SUBTRACT));
definition.AddSemanticaToList(listName, definition.GetSemantica(GPConsts.NUMBER_DEFAULT));
return(definition);
}
private static SemanticaList CriaListaDefault(GPSolutionDefinition sh)
{
string listName = "default";
sh.CreateListByName(listName, config.minLevels, config.maxLevels);
GPSemantica semanticaF1 = new GPSemanticaFormula("f1", 2, 3);
GPSemantica semanticaF2 = new GPSemanticaFormula("f2", 2, 2);
GPSemantica semanticaF3 = new GPSemanticaFormula("f3", 2, 3);
GPSemantica semanticaF4 = new GPSemanticaFormula("f4", 1, 1);
GPSemantica semanticaF5 = new GPSemanticaFormula("f5", 0, 0);
GPSemanticaNumber semanticaN1 = new GPSemanticaNumber("0 a 100", 0, 100);
sh.AddSemanticaToList(listName, semanticaF1);
sh.AddSemanticaToList(listName, semanticaF2);
sh.AddSemanticaToList(listName, semanticaF3);
sh.AddSemanticaToList(listName, semanticaF5);
sh.AddSemanticaToList(listName, semanticaN1);
SemanticaList lista = sh.GetListByName(listName);
lista.minLevels = config.minLevels;
lista.maxLevels = config.maxLevels;
Assert.IsTrue(lista.Contains(semanticaF1));
Assert.IsTrue(lista.Contains(semanticaF2));
Assert.IsTrue(lista.Contains(semanticaF3));
Assert.IsFalse(lista.Contains(semanticaF4));
sh.AddSemanticaToList(listName, semanticaF4);
Assert.IsTrue(lista.Contains(semanticaF4));
return(lista);
}
public void TestGPTemplate()
{
GPSolutionDefinition holder = new GPSolutionDefinition(config);
/*
* vou simular um template com 4 formulas(nodes) e 2 variaveis numéricas
* f1(NODE,NUMBER)
* F2(NODE,NODE)
* F3
* F4(NUMBER)
*/
SemanticaList listaFormulas = CriaListaDefault(holder);
//Lista Numerica
SemanticaList listaNumerica = CriaListaNumerica(holder);
//Templates: possuem propriedades evolutivas, cada uma apontando para uma lista de semantica
GPTemplate template = CreateTestTemplate(config, listaFormulas, listaNumerica);
GPSolution solution = template.CreateRandomSolution();
Assert.IsNotNull(solution);
GPAbstractNode p1 = solution.GetValue("prop1");
Assert.IsNotNull(p1);
GPAbstractNode p2 = solution.GetValue("prop2");
Assert.IsNotNull(p2);
GPAbstractNode p3 = solution.GetValue("prop3");
Assert.IsNotNull(p3);
GPAbstractNode p4 = solution.GetValue("prop4");
Assert.IsNotNull(p4);
GPAbstractNode n1 = solution.GetValue("number1");
Assert.IsNotNull(n1);
GPAbstractNode n2 = solution.GetValue("number2");
Assert.IsNotNull(n2);
GPAbstractNode clonep1 = p1.Clone();
Assert.IsNotNull(clonep1);
Assert.IsFalse(clonep1 == p1);
Assert.IsTrue(clonep1.ToString() == p1.ToString());
GPSolution cloneSolution = solution.Clone();
GPSolution solution2 = template.CreateRandomSolution();
GPSolution childSolution2 = null;
GPSolution childSolution = solution.CreateChildWith(solution2, out childSolution2);
Assert.IsNotNull(childSolution);
Assert.IsNotNull(childSolution2);
}
public void TestGPInicial()
{
GPSolutionDefinition sh = new GPSolutionDefinition(config);
SemanticaList listaFormulas = CriaListaDefault(sh);
SemanticaList listaNumerica = CriaListaNumerica(sh);
GPTemplate template = CreateTestTemplate(config, listaFormulas, listaNumerica);
GPPool pool = new GPPool(config);
Assert.IsTrue(config.poolSize > 0);
Assert.IsTrue(config.elitismRange > 0);
Assert.IsTrue(config.mutationRatePerc > 0);
Assert.IsTrue(config.mutationRange > 0);
Assert.IsTrue(config.poolSize > 0);
pool.InitPool(template);
Assert.IsTrue(pool.solutions.Count > 0);
//randomizo valores iniciais para fazer ordenação
Random rnd = new Random();
for (int i = 0; i < pool.solutions.Count; i++)
{
GPSolution solution = pool.solutions[i];
solution.fitnessResult = rnd.Next(1, 10000);
}
pool.SortFitness();
for (int i = 1; i < pool.solutions.Count; i++)
{
Assert.IsTrue(pool.solutions[i - 1].fitnessResult >= pool.solutions[i].fitnessResult);
}
GPSolution sol1 = pool.solutions[1];
GPSolution sol2 = pool.solutions[2];
string splicedKey = sol1.SpliceWith(sol2);
Assert.IsNotNull(splicedKey);
string strOriginal = sol1.GetValue(splicedKey).ToString();
sol1.Mutate(sol1.GetValue(splicedKey), splicedKey);
string strMutated = sol1.GetValue(splicedKey).ToString();
//Assert.IsFalse(strOriginal == strMutated,"Não mutou: "+strOriginal);
GPSolution badSolution = pool.solutions[pool.solutions.Count - 1];
pool.Mutate();
Assert.IsFalse(pool.solutions.Contains(badSolution));
Assert.IsTrue(pool.solutions.Count == config.poolSize, pool.solutions.Count + "<>" + config.poolSize);
}
public override void Mutate(SemanticaList semanticaList)
{
if (children.Count == 0 || Utils.RandomInt(0, 100) < 50)
{
semantica = semanticaList.GetEquivalent(semantica, children.Count);
}
else
{
int rnd = Utils.RandomInt(0, children.Count);
children[rnd].Mutate(semanticaList);
}
}
public override void Mutate(SemanticaList semanticaList)
{
//tratamento especial para booleanos...
if (semanticaNumber.maxValue == 1 && semanticaNumber.minValue == 0)
{
valor = valor < 1 ? 1 : 0;
return;
}
float rnd = Utils.Random(-semanticaNumber.maxValue / 10f, semanticaNumber.maxValue / 10f);
valor += rnd;
}
private static GPTemplate CreateTestTemplate(GPConfig config, SemanticaList listaFormulas, SemanticaList listaNumerica)
{
GPTemplate template = new GPTemplate(config);
template.AddProperty("prop1", listaFormulas);
Assert.IsTrue(template.GetProperty("prop1") == listaFormulas);
template.AddProperty("prop2", listaFormulas);
template.AddProperty("prop3", listaFormulas);
template.AddProperty("prop4", listaFormulas);
template.AddProperty("number1", listaNumerica);
template.AddProperty("number2", listaNumerica);
return(template);
}
private SemanticaList CriaListaNumerica(GPSolutionDefinition holder)
{
string listName = "numericList";
GPSemanticaNumber semanticaN1 = new GPSemanticaNumber("0 a 100", 0, 100);
GPSolutionDefinition sh = new GPSolutionDefinition(config);
sh.CreateListByName(listName, 0, 0);
sh.AddSemanticaToList(listName, semanticaN1);
SemanticaList lista = sh.GetListByName(listName);
Assert.IsTrue(lista.Contains(semanticaN1));
return(lista);
}
public void TestaGPCriacaoPelaLista()
{
GPPool pool = new GPPool(config);
string listDefault = "default";
GPSolutionDefinition definition = CreateSampleDefinition(listDefault);
SemanticaList listaFormulas = CriaListaDefault(definition);
SemanticaList listSemantic = definition.GetListByName(listDefault);
listSemantic.maxLevels = 3;
listSemantic.minLevels = 2;
GPAbstractNode nodeRandom = listSemantic.CreateRandomNode(config, false);
Assert.IsNotNull(nodeRandom);
string toString = nodeRandom.ToString();
Assert.IsTrue(nodeRandom.SizeLevel() >= listSemantic.minLevels && nodeRandom.SizeLevel() <= listSemantic.maxLevels, "SizeLevel:" + nodeRandom.SizeLevel());
}
public void TestaGPSolutionDefinition()
{
string listDefault = "default";
GPSolutionDefinition definition = CreateSampleDefinition(listDefault);
SemanticaList listSemantic = definition.GetListByName(listDefault);
}
public abstract void Mutate(SemanticaList semanticaList);
public override GPTemplate CreateTemplate()
{
GPTemplate template = new GPTemplate(gpConfig);
SemanticaList listaFormula = definitions.GetListByName(GPConsts.LISTA_FORMULA);
SemanticaList listaNumeros = definitions.GetListByName(GPConsts.LISTA_NUMEROS);
SemanticaList listaBooleanos = definitions.GetListByName(GPConsts.LISTA_NUMEROS_BOOLEANOS);
SemanticaList listaNumerosGrandes = definitions.GetListByName(GPConsts.LISTA_NUMEROS_GRANDES);
SemanticaList listaNumerosPercentuais = definitions.GetListByName(GPConsts.LISTA_NUMEROS_PERCENTUAIS);// 0 a 100
// template.AddProperty(PROP_COND_ENTRADA_C,)
listFormulas.Add(PROP_COND_TARGET_SAIDA);
template.AddProperty(PROP_COND_TARGET_SAIDA, listaNumerosPercentuais);
if (config.flagCompra)
{
listFormulas.Add(PROP_COND_ENTRADA_C);
listFormulas.Add(PROP_SIZING_C);
listFormulas.Add(PROP_COND_SAIDA_C);
listFormulas.Add(PROP_COND_STOP_MOVEL_C);
listFormulas.Add(PROP_COND_STOP_INICIAL_C);
template.AddProperty(PROP_COND_ENTRADA_C, listaFormula);
template.AddProperty(PROP_SIZING_C, listaFormula);
template.AddProperty(PROP_COND_SAIDA_C, listaFormula);
template.AddProperty(PROP_COND_STOP_MOVEL_C, listaFormula);
template.AddProperty(PROP_COND_STOP_INICIAL_C, listaFormula);
}
if (config.flagVenda)
{
listFormulas.Add(PROP_SIZING_V);
listFormulas.Add(PROP_COND_ENTRADA_V);
listFormulas.Add(PROP_COND_SAIDA_V);
listFormulas.Add(PROP_COND_STOP_MOVEL_V);
listFormulas.Add(PROP_COND_STOP_INICIAL_V);
template.AddProperty(PROP_COND_ENTRADA_V, listaFormula);
template.AddProperty(PROP_SIZING_V, listaFormula);
template.AddProperty(PROP_COND_SAIDA_V, listaFormula);
template.AddProperty(PROP_COND_STOP_MOVEL_V, listaFormula);
template.AddProperty(PROP_COND_STOP_INICIAL_V, listaFormula);
}
listVariaveis.Add(Consts.VAR_STOP_GAP);
listVariaveis.Add(Consts.VAR_RISCO_TRADE);
listVariaveis.Add(Consts.VAR_STOP_MENSAL);
listVariaveis.Add(Consts.VAR_MAX_CAPITAL_TRADE);
listVariaveis.Add(Consts.VAR_PERC_TRADE);
listVariaveis.Add(Consts.VAR_USA_STOP_MOVEL);
listVariaveis.Add(Consts.VAR_RISCO_GLOBAL);
listVariaveis.Add(Consts.VAR_MULTIPLAS_ENTRADAS);
// listVariaveis.Add(Consts.VAR_MULTIPLAS_SAIDAS);
template.AddProperty(Consts.VAR_STOP_GAP, listaNumerosPercentuais);
template.AddProperty(Consts.VAR_RISCO_TRADE, listaNumerosPercentuais);
template.AddProperty(Consts.VAR_STOP_MENSAL, listaNumerosPercentuais);
template.AddProperty(Consts.VAR_MAX_CAPITAL_TRADE, listaNumerosGrandes);
template.AddProperty(Consts.VAR_PERC_TRADE, listaNumerosPercentuais);
template.AddProperty(Consts.VAR_USA_STOP_MOVEL, listaBooleanos);
template.AddProperty(Consts.VAR_RISCO_GLOBAL, listaNumerosPercentuais);
template.AddProperty(Consts.VAR_MULTIPLAS_ENTRADAS, listaBooleanos);
template.AddProperty(Consts.VAR_MULTIPLAS_SAIDAS, listaBooleanos);
return(template);
}
