public int[,] GetMatriceDistances(Corpus corpus, Graphe g, int t)
{
int[,] matrice = new int[corpus.concepts.Count, corpus.concepts.Count];
for (int i = 0; i < corpus.concepts.Count; i++)
{
for (int j = 0; j < corpus.concepts.Count; j++)
{
matrice[i, j] = (i == j) ? 0 : int.MaxValue;
}
}
for (int i = 0; i < corpus.concepts.Count; i++)
{
HashSet <string> servicesOld = new HashSet <string>();
HashSet <string> servicesNew = new HashSet <string>();
HashSet <string> conceptsOld = new HashSet <string>();
HashSet <string> conceptsNew = new HashSet <string>();
conceptsNew.Add(corpus.concepts[i].id);
conceptsOld.Add(corpus.concepts[i].id);
for (int currentLevel = 0; currentLevel < t; currentLevel++)
{
servicesNew.Clear();
foreach (string c in conceptsNew)
{
foreach (string s in g.inputServices[c])
{
if (servicesOld.Contains(s) == false)
{
servicesNew.Add(s);
servicesOld.Add(s);
}
}
}
conceptsNew.Clear();
foreach (string s in servicesNew)
{
foreach (string c in g.serviceOutputs[s])
{
if (conceptsOld.Contains(c) == false)
{
conceptsNew.Add(c);
conceptsOld.Add(c);
matrice[i, corpus.conceptIndex[c]] = currentLevel + 1;
}
}
}
}
}
return(matrice);
}
public bool Optimiser(Corpus c)
{
for (int i = 0; i < this.input.Count; i++)
{
//this.input[i] = this.input[i].ToUpper().Trim();
if (c.allConcepts.ContainsKey(this.input[i]))
{
this.input[i] = c.allConcepts[this.input[i]].id;
}
else
{
this.input[i] = "X";
}
}
for (int i = 0; i < this.output.Count; i++)
{
//this.output[i] = this.output[i].ToUpper().Trim();
if (c.allConcepts.ContainsKey(this.output[i]))
{
this.output[i] = c.allConcepts[this.output[i]].id;
}
else
{
this.output[i] = "X";
}
}
if (this.input.Contains("X") || this.output.Contains("X"))
{
return(false);
}
foreach (string i in this.input)
{
if (this.output.Contains(i))
{
while (this.output.Remove(i))
{
;
}
}
}
if (this.input.Count == 0 || this.output.Count == 0)
{
return(false);
}
return(true);
}
public ResultsDecouverte RechercheServices(string json, string inputs, string outputs)
{
results = new ResultsDecouverte();
corpus = Corpus.charger(json);
requete = Requete.charger(inputs, outputs);
if (ValidationInputs() != "true")
{
results.error = true;
results.message = "Error : Corpus Null";
return(results);
}
foreach (Service s in corpus.services)
{
bool conditionInputs = true;
bool conditionOutputs = true;
foreach (string i in s.input)
{
//if (Matching.Include(corpus, requete.input, i) == false)
if (requete.input.Contains(i) == false)
{
conditionInputs = false;
}
}
foreach (string o in requete.output)
{
//if (Matching.Include(corpus, s.output, o) == false)
if (s.output.Contains(o) == false)
{
conditionOutputs = false;
}
}
if (conditionInputs && conditionOutputs)
{
results.services.Add(s);
}
}
if (results.services.Count == 0)
{
results.error = true;
results.message = "Error : No Results";
}
return(results);
}
public static bool Include(Corpus c, List <string> v, string s)
{
foreach (string a in v)
{
switch (Comparer(c, a, s))
{
case Match.Exact:
case Match.Plugin:
case Match.Subsumant:
case Match.Sibling:
return(true);
}
}
return(false);
}
public ResultsComposition RechercheCompositions(string json, string inputs, string outputs, int nmax, int tmax)
{
results = new ResultsComposition();
corpus = Corpus.charger(json);
requete = Requete.charger(inputs, outputs);
if (ValidationInputs() != "true")
{
results.error = true;
results.message = ValidationInputs();
return(results);
}
initEspaceRecherche(tmax);
time = DateTime.Now;
//CompositionLargeur(tmax, nmax);
CompositionProfondeur(tmax, nmax);
results.timeTotal = (DateTime.Now - time).TotalSeconds;
if (results.compositions.Count == 0)
{
results.error = true;
results.message = "Error : No Results.";
}
else
{
results.countCompositions = results.compositions.Count;
}
return(results);
}
public ResultsComposition RechercheCompositions(string json, string inputs, string outputs, int nmax, int tmax)
{
results = new ResultsComposition();
corpus = Corpus.charger(json);
requete = Requete.charger(inputs, outputs);
if (ValidationInputs() != "true")
{
results.error = true;
results.message = ValidationInputs();
return(results);
}
time = DateTime.Now;
initEspaceRecherche(tmax);
results.countCompositions = 0;
List <Composition> levelCurrent = new List <Composition>();
List <Composition> levelNext = new List <Composition>();
levelCurrent.Add(new Composition(corpus, requete));
solutions = new List <List <string> >();
int numberCompositionsTested = 0;
int distance = 0;
while (levelCurrent.Count > 0 && tmax > distance++ && nmax > 0)
{
levelNext = new List <Composition>();
//espaceRecherche = corpus.services;
espaceRecherche = new List <Service>();
foreach (string s in servicesPertinants[distance - 1])
{
espaceRecherche.Add(corpus.hs[s]);
}
Composition bestNode = GetBestNode(levelCurrent);
for (int i = 0; i < levelCurrent.Count && nmax > 0; i++)
{
List <Composition> cpp = ConstructionComposition(levelCurrent[i]);
numberCompositionsTested += cpp.Count();
foreach (Composition newComposition in cpp)
{
if (newComposition.Complete())
{
solutions.Add(newComposition.services);
results.compositions.Add(newComposition);
if (--nmax <= 0)
{
break;
}
}
else if (levelNext.Contains(newComposition) == false)
{
levelNext.Add(newComposition);
}
}
}
levelCurrent.Clear();
levelCurrent.AddRange(levelNext);
}
foreach (Composition c in results.compositions)
{
c.AddEnd();
}
if (results.compositions.Count == 0)
{
results.error = true;
results.message = "Error : No Results in " + numberCompositionsTested + " compositions.";
}
else
{
results.countCompositions = results.compositions.Count;
}
results.timeTotal = (DateTime.Now - time).TotalSeconds;
return(results);
}
