//------------------------------------------------------------------------------------------------
/// <summary>
/// Gives a string representation of the mapping vector given a reference list for the element
/// of origin and another reference list for the elements to which the belief will be propagated.
/// </summary>
/// <param name="refListFrom">The origin reference list.</param>
/// <param name="refListTo">The recipient reference list.</param>
/// <returns>Returns a string representation of the mapping vector.</returns>
public string ToString(StringReferenceList refListFrom, StringReferenceList refListTo)
{
StringBuilder toReturn = new StringBuilder(String.Format("DiscreteMappingVector: From = {0} to:\n", From.ToString(refListFrom)));
for (int i = 0; i < _to.Count; i++)
{
if (i == _to.Count)
{
toReturn.Append(_to[i].ToString(refListTo));
}
else
{
toReturn.Append(String.Format("{0}\n", _to[i].ToString(refListTo)));
}
}
return(toReturn.ToString());
}
//------------------------------------------------------------------------------------------------
/// <summary>
/// Gives a string representation of the current focal belief model given a reference list.
/// </summary>
/// <param name="refList">The reference list to give sensor to the states/worlds.</param>
/// <returns>Returns a string representation of the current focal belief model.</returns>
public string ToString(StringReferenceList refList)
{
StringBuilder toReturn = new StringBuilder(String.Format("Element = {0}\n", Element.ToString(refList)));
for (int i = 0; i < Belief.Count; i++)
{
if (i == Belief.Count - 1)
{
toReturn.Append(Belief[i]);
}
else
{
toReturn.Append(String.Format("{0}\n", Belief[i]));
}
}
return(toReturn.ToString());
}
//------------------------------------------------------------------------------------------------
/// <summary>
/// Gives a string representation of the current evidential mapping given a reference list for the
/// recipient frame of discernment.
/// </summary>
/// <param name="refList">The reference list for the recipient frame of discernment.</param>
/// <returns>Returns a string representation of the current evidential mapping.</returns>
public string ToString(StringReferenceList refList)
{
StringBuilder toReturn = new StringBuilder(String.Format("//// \\\\\\\\\nDiscreteEvidentialMapping: <SourceFrameName = {0}>\n{1}\n\n", FrameName, _refList));
for (int i = 0; i < _vectors.Count; i++)
{
if (i == _vectors.Count)
{
toReturn.Append(_vectors[i].ToString(References, refList));
}
else
{
toReturn.Append(String.Format("{0}\n", _vectors[i].ToString(References, refList)));
}
}
toReturn.Append("\\\\\\\\ ////\n");
return(toReturn.ToString());
}
//------------------------------------------------------------------------------------------------
private void ParseDiscreteEvidentialMapping(XmlNode node)
{
//Create the ReferenceList:
XmlNode frame = node.SelectSingleNode("subframe");
if (frame == null)
{
throw new InvalidBeliefModelException("The xml model element \"evidential-mapping\" should contain an element called \"subframe\" to define the frame of discernment!");
}
string frameName = frame.Attributes["name"].InnerText;
StringReferenceList references = new StringReferenceList();
try
{
foreach (XmlNode n in frame.ChildNodes)
{
references.Add(n.InnerText);
}
}
catch (IncompatibleReferenceListException)
{
throw new InvalidBeliefModelException("The xml model element file \"evidential-mapping\" has a state defined multiple times in the frame node!");
}
DiscreteEvidentialMapping mapping = new DiscreteEvidentialMapping(frameName, references);
//Load evidential vectors:
XmlNodeList vectors = node.SelectNodes("mapping-vector");
if (vectors == null)
{
throw new InvalidBeliefModelException("An evidential mapping should contain mapping vectors!");
}
foreach (XmlNode n in vectors)
{
XmlNode fr = n.SelectSingleNode("from");
DiscreteMappingVector mp = new DiscreteMappingVector(new DiscreteElement(references, fr.Attributes["element"].InnerText.Split(' ')));
XmlNodeList to = n.SelectNodes("to");
foreach (XmlNode t in to)
{
mp.AddPoint(new DiscreteMappingPoint(new DiscreteElement(_refList, t.Attributes["element"].InnerText.Split(' ')), Convert.ToDouble(t.InnerText)));
}
mapping.AddVector(mp);
}
_mappings.Add(mapping);
}
//------------------------------------------------------------------------------------------------
/// <summary>
/// Gives a string representation of the current model given a reference list for the elements.
/// </summary>
/// <param name="refList">The reference list to give sense to the elements.</param>
/// <returns>Returns a string represenation of the current model.</returns>
public string ToString(StringReferenceList refList)
{
StringBuilder toReturn = new StringBuilder(String.Format("//// \\\\\\\\\nSensorBelief: <SensorName = {0}>\n", SensorType));
if (OptionFlags.Count == 0)
{
toReturn.Append("Options: none\n");
}
else
{
toReturn.Append("Options: \n");
for (int i = 0; i < OptionFlags.Count; i++)
{
switch (OptionFlags[i])
{
case DiscreteSensorOption.Option_Flags.OP_TEMPO_FUSION:
toReturn.Append(String.Format("Tempo-fusion: {0}s\n", OptionParams[i]));
break;
case DiscreteSensorOption.Option_Flags.OP_TEMPO_SPECIFICITY:
toReturn.Append(String.Format("Tempo-specificity: {0}s\n", OptionParams[i]));
break;
case DiscreteSensorOption.Option_Flags.OP_VARIATION:
toReturn.Append(String.Format("Variation: {0} measures\n", OptionParams[i]));
break;
}
}
}
toReturn.Append("Focals: \n");
for (int i = 0; i < FocalBeliefs.Count; i++)
{
if (i == FocalBeliefs.Count)
{
toReturn.Append(String.Format("{0}", FocalBeliefs[i].ToString(refList)));
}
else
{
toReturn.Append(String.Format("{0}\n", FocalBeliefs[i].ToString(refList)));
}
}
toReturn.Append("\\\\\\\\ ////\n");
return(toReturn.ToString());
}
public static void TestCase()
{
StringReferenceList refList = new StringReferenceList("Yes", "No");
StringReferenceList refList2 = new StringReferenceList("Resources/B-eliefsFromSensors/test/values");
Console.WriteLine("\n\n" +
"+--------------------------------------------------------------------+\n" +
"| StringReferenceList Tests |\n" +
"+--------------------------------------------------------------------+"
);
Console.WriteLine("\n\n----------------------------------------------------------------------");
Console.WriteLine("Construction tests:");
Console.WriteLine(refList);
Console.WriteLine(refList2);
Console.WriteLine("----------------------------------------------------------------------");
Console.WriteLine("refList2.Contains(\"Aka\") = {0}", refList2.Contains("Aka"));
Console.WriteLine("refList2.Contains(\"Yes\") = {0}", refList2.Contains("Yes"));
Console.WriteLine("----------------------------------------------------------------------");
Console.WriteLine("refList2.GetIndex(\"Aka\") = {0}", refList2.IndexOf("Aka"));
Console.WriteLine("refList2.GetIndex(\"Coq\") = {0}", refList2.IndexOf("Coq"));
Console.WriteLine("refList2.GetIndex(\"Yes\") = {0}", refList2.IndexOf("Yes"));
Console.WriteLine("----------------------------------------------------------------------");
}
//------------------------------------------------------------------------------------------------
//------------------------------------------------------------------------------------------------
//------------------------------------------------------------------------------------------------
/*
* Methods
*/
#region IBeliefModel
/// <summary>
/// <para>Loads the model from the given path with the given format.</para>
/// <para>If the format is of type <see cref="ModelFormat.MODEL_CUSTOM_DIRECTORY"/>, the path should
/// indicate the path to the directory where the model is stored.</para>
/// <para>If the format is of type <see cref="ModelFormat.MODEL_XML_FILE"/>, the path should be
/// the name of the XML file to load.</para>
/// </summary>
/// <param name="path">Where to find the model.</param>
/// <param name="mt">The format in which the model is.</param>
/// <exception cref="InvalidBeliefModelException">Thrown if anything is wrong with the model.
/// The exception message should be explicit enough to know what's wrong.</exception>
public void LoadModel(string path, ModelFormat mt)
{
switch (mt)
{
case (ModelFormat.MODEL_CUSTOM_DIRECTORY):
if (!Directory.Exists(path))
{
throw new InvalidBeliefModelException(String.Format("The given path ({0}) does not exist (or you don't have permission to read it)!", path));
}
FrameName = new DirectoryInfo(path).Name;
//Load the reference list:
string refListFileName = path + Path.DirectorySeparatorChar + "values";
if (!File.Exists(refListFileName))
{
throw new InvalidBeliefModelException("The custom directory model should contain a file named \"values\" with the names of the possible worlds (one per line)!");
}
_refList = new StringReferenceList(refListFileName);
//Load the models:
_mappings = new List <DiscreteEvidentialMapping>();
foreach (string dir in Directory.EnumerateDirectories(path))
{
LoadDiscreteEvidentialMapping(dir);
}
break;
case (ModelFormat.MODEL_XML_FILE):
if (!File.Exists(path))
{
throw new InvalidBeliefModelException(String.Format("The given xml file \"{0}\" does not exist (or you don't have permission to read it)!", path));
}
//Load the file:
XmlDocument doc = new XmlDocument();
doc.Load(path);
//Create the ReferenceList:
XmlNode frame = doc.DocumentElement.SelectSingleNode("/belief-from-beliefs/frame");
if (frame == null)
{
throw new InvalidBeliefModelException(String.Format("The xml file \"{0}\" should contain an element called \"frame\" to define the frame of discernment!", path));
}
this.FrameName = frame.Attributes["name"].InnerText;
this._refList = new StringReferenceList();
try
{
foreach (XmlNode n in frame.ChildNodes)
{
this._refList.Add(n.InnerText);
}
}
catch (IncompatibleReferenceListException)
{
throw new InvalidBeliefModelException(String.Format("The xml file \"{0}\" has a state defined multiple times in the frame node!", path));
}
//Load the models:
_mappings = new List <DiscreteEvidentialMapping>();
XmlNode models = doc.DocumentElement.SelectSingleNode("/belief-from-beliefs/evidential-mappings");
if (models == null)
{
throw new InvalidBeliefModelException(String.Format("The xml file \"{0}\" does not seem to contain models!", path));
}
try
{
foreach (XmlNode n in models.ChildNodes)
{
ParseDiscreteEvidentialMapping(n);
}
}
catch (FormatException)
{
throw new InvalidBeliefModelException(String.Format("The numbers in the file \"{0}\" are not in the proper format or at the wrong place!", path));
}
break;
}
}
public static void TestCase()
{
DiscreteElement peuh = new DiscreteElement(5, 3);
DiscreteElement peuh2 = new DiscreteElement(5, 9);
StringReferenceList refList = new StringReferenceList("Aka", "Bea", "Coq", "Dad", "Elf");
Console.WriteLine("\n\n" +
"+--------------------------------------------------------------------+\n" +
"| DiscreteElement Tests |\n" +
"+--------------------------------------------------------------------+"
);
Console.WriteLine(refList);
Console.WriteLine("----------------------------------------------------------------------");
Console.WriteLine("Building Element from strings Aka, Coq, Elf");
Console.WriteLine("Element: {0}", (new DiscreteElement(refList, new string[] { "Aka", "Coq", "Elf" })).ToString());
Console.WriteLine("Element: {0}", (new DiscreteElement(refList, "Aka", "Coq", "Elf").ToString(refList)));
Console.WriteLine("Building Element of size 68 with 4 2 0");
Console.WriteLine("Element: {0}", (new DiscreteElement(68, 4, 2, 0)));
Console.WriteLine("Building Element of size 36 with 0 2");
Console.WriteLine("Element: {0}", (new DiscreteElement(36, 0, 2)));
Console.WriteLine("----------------------------------------------------------------------");
Console.WriteLine("Element 1: {0}", peuh);
Console.WriteLine("Element 2: {0}", peuh2);
Console.WriteLine("Conjunction: {0}", peuh.Conjunction(peuh2));
Console.WriteLine("----------------------------------------------------------------------");
Console.WriteLine("Element 1: {0}", peuh);
Console.WriteLine("Element 2: {0}", peuh2);
Console.WriteLine("Conjunction: {0}", peuh & peuh2);
Console.WriteLine("----------------------------------------------------------------------");
Console.WriteLine("Element 1: {0}", peuh.ToString(refList));
Console.WriteLine("Element 2: {0}", peuh2.ToString(refList));
Console.WriteLine("Conjunction: {0}", peuh.Conjunction(peuh2).ToString(refList));
Console.WriteLine("----------------------------------------------------------------------");
Console.WriteLine("Element 1: {0}", peuh.ToString(refList));
Console.WriteLine("Element 2: {0}", peuh2.ToString(refList));
Console.WriteLine("Conjunction: {0}", (peuh & peuh2).ToString(refList));
Console.WriteLine("----------------------------------------------------------------------");
Console.WriteLine("Element 1: {0}", peuh);
Console.WriteLine("Element 2: {0}", peuh2);
Console.WriteLine("Disjunction: {0}", peuh.Disjunction(peuh2));
Console.WriteLine("----------------------------------------------------------------------");
Console.WriteLine("Element 1: {0}", peuh);
Console.WriteLine("Element 2: {0}", peuh2);
Console.WriteLine("Disjunction: {0}", peuh | peuh2);
Console.WriteLine("----------------------------------------------------------------------");
Console.WriteLine("Element 1: {0}", peuh.ToString(refList));
Console.WriteLine("Element 2: {0}", peuh2.ToString(refList));
Console.WriteLine("Disjunction: {0}", peuh.Disjunction(peuh2).ToString(refList));
Console.WriteLine("----------------------------------------------------------------------");
Console.WriteLine("Element 1: {0}", peuh.ToString(refList));
Console.WriteLine("Element 2: {0}", peuh2.ToString(refList));
Console.WriteLine("Disjunction: {0}", (peuh | peuh2).ToString(refList));
Console.WriteLine("----------------------------------------------------------------------");
Console.WriteLine("Element 1: {0}", peuh);
Console.WriteLine("Opposite 1: {0}", peuh.Opposite());
Console.WriteLine("Element 2: {0}", peuh2);
Console.WriteLine("Opposite 2: {0}", peuh2.Opposite());
Console.WriteLine("----------------------------------------------------------------------");
Console.WriteLine("Element 1: {0}", peuh);
Console.WriteLine("Element 2: {0}", peuh2);
Console.WriteLine("Equals (false) : {0}", peuh.Equals(peuh2));
Console.WriteLine("----------------------------------------------------------------------");
Console.WriteLine("Element 1: {0}", peuh);
Console.WriteLine("Element 2: {0}", peuh);
Console.WriteLine("Equals (true) : {0}", peuh.Equals(peuh));
Console.WriteLine("----------------------------------------------------------------------");
Console.WriteLine("Element 1: {0}", peuh);
Console.WriteLine("Element 2: {0}", peuh2);
Console.WriteLine("IsASubset (false) : {0}", peuh.IsASubset(peuh2));
Console.WriteLine("----------------------------------------------------------------------");
Console.WriteLine("Element 1: {0}", peuh);
Console.WriteLine("Element 2: {0}", peuh.Conjunction(peuh2));
Console.WriteLine("IsASubset (true) : {0}", peuh.Conjunction(peuh2).IsASubset(peuh));
Console.WriteLine("----------------------------------------------------------------------");
peuh = new DiscreteElement(68, 68);
peuh2 = new DiscreteElement(68, 75);
DiscreteElement peuh3 = peuh.Conjunction(peuh2);
Console.WriteLine("Test of really big elements:");
Console.WriteLine("Element of size 68: {0}", peuh);
Console.WriteLine("Opposite: {0}", peuh.Opposite());
Console.WriteLine("----------------------------------------------------------------------");
Console.WriteLine("Element 1: {0}", peuh);
Console.WriteLine("Element 2: {0}", peuh2);
Console.WriteLine("Conjunction: {0}", peuh.Conjunction(peuh2));
Console.WriteLine("----------------------------------------------------------------------");
Console.WriteLine("Element 1: {0}", peuh);
Console.WriteLine("Element 2: {0}", peuh2);
Console.WriteLine("Disjunction: {0}", peuh.Disjunction(peuh2));
Console.WriteLine("----------------------------------------------------------------------");
Console.WriteLine("Element 1: {0}", peuh);
Console.WriteLine("Opposite 1: {0}", peuh.Opposite());
Console.WriteLine("Element 2: {0}", peuh2);
Console.WriteLine("Opposite 2: {0}", peuh2.Opposite());
Console.WriteLine("----------------------------------------------------------------------");
Console.WriteLine("Element 1: {0}", peuh);
Console.WriteLine("Element 2: {0}", peuh2);
Console.WriteLine("Equals (false) : {0}", peuh.Equals(peuh2));
Console.WriteLine("----------------------------------------------------------------------");
Console.WriteLine("Element 1: {0}", peuh);
Console.WriteLine("Element 2: {0}", peuh);
Console.WriteLine("Equals (true) : {0}", peuh.Equals(peuh));
Console.WriteLine("----------------------------------------------------------------------");
Console.WriteLine("Element 1: {0}", peuh);
Console.WriteLine("Element 2: {0}", peuh2);
Console.WriteLine("IsASubset (false) : {0}", peuh.IsASubset(peuh2));
Console.WriteLine("----------------------------------------------------------------------");
Console.WriteLine("Element 1: {0}", peuh);
Console.WriteLine("Element 2: {0}", peuh.Conjunction(peuh2));
Console.WriteLine("IsASubset (true) : {0}", peuh.Conjunction(peuh2).IsASubset(peuh));
Console.WriteLine("----------------------------------------------------------------------");
Console.WriteLine("Get the complete set: {0}", DiscreteElement.GetCompleteElement(68));
Console.WriteLine("Get the emptyset: {0}", DiscreteElement.GetEmptyElement(68));
Console.WriteLine("----------------------------------------------------------------------");
//Performance tests:
DiscreteElement small1 = new DiscreteElement(5, 27);
DiscreteElement small2 = new DiscreteElement(5, 13);
DiscreteElement small3 = new DiscreteElement(64, 49227);
DiscreteElement small4 = new DiscreteElement(64, 987543);
int nbIterations = 1000000;
Stopwatch watch = Stopwatch.StartNew();
//Small conjunction test:
for (int i = 0; i < nbIterations; i++)
{
small1.Conjunction(small2);
}
Console.WriteLine("Small conjunctions ({1}): {0}ms", watch.ElapsedMilliseconds, nbIterations);
watch = Stopwatch.StartNew();
//Small conjunction test:
for (int i = 0; i < nbIterations; i++)
{
small3.Conjunction(small4);
}
Console.WriteLine("Big conjunctions ({1}): {0}ms", watch.ElapsedMilliseconds, nbIterations);
Console.WriteLine("----------------------------------------------------------------------");
watch = Stopwatch.StartNew();
//Small conjunction test:
for (int i = 0; i < nbIterations; i++)
{
small1.Disjunction(small2);
}
Console.WriteLine("Small disjunctions ({1}): {0}ms", watch.ElapsedMilliseconds, nbIterations);
watch = Stopwatch.StartNew();
//Small conjunction test:
for (int i = 0; i < nbIterations; i++)
{
small3.Disjunction(small4);
}
Console.WriteLine("Big disjunctions ({1}): {0}ms", watch.ElapsedMilliseconds, nbIterations);
Console.WriteLine("----------------------------------------------------------------------");
}
public static void TestCase()
{
DiscreteSet s = new DiscreteSet();
DiscreteElement peuh = new DiscreteElement(5, 3);
DiscreteElement peuh2 = new DiscreteElement(5, 9);
StringReferenceList refList = new StringReferenceList("Aka", "Bea", "Coq", "Dad", "Elf");
Console.WriteLine("\n\n" +
"+--------------------------------------------------------------------+\n" +
"| DiscreteSet Tests |\n" +
"+--------------------------------------------------------------------+"
);
Console.WriteLine(refList);
Console.WriteLine("----------------------------------------------------------------------");
Console.WriteLine("Empty set: {0}", s.ToString(refList));
Console.WriteLine("Adding the element {0}", peuh.ToString(refList));
s.Add(peuh);
Console.WriteLine("Resulting set: {0}", s.ToString(refList));
Console.WriteLine("Adding the element {0}", peuh.ToString(refList));
s.Add(peuh);
Console.WriteLine("Resulting set: {0}", s.ToString(refList));
Console.WriteLine("Adding the element {0}", peuh2.ToString(refList));
s.Add(peuh2);
Console.WriteLine("Resulting set: {0}", s.ToString(refList));
Console.WriteLine("Removing the element {0}", peuh.ToString(refList));
s.Remove(peuh);
Console.WriteLine("Resulting set: {0}", s.ToString(refList));
Console.WriteLine("Removing the element {0}", peuh2.ToString(refList));
s.Remove(peuh2);
Console.WriteLine("Resulting set: {0}", s.ToString(refList));
Console.WriteLine("----------------------------------------------------------------------");
Console.WriteLine("Empty set: {0}", s.ToString(refList));
Console.WriteLine("Adding the element {0}", peuh.ToString(refList));
s += peuh;
Console.WriteLine("Resulting set: {0}", s.ToString(refList));
Console.WriteLine("Adding the element {0}", peuh.ToString(refList));
s += peuh;
Console.WriteLine("Resulting set: {0}", s.ToString(refList));
Console.WriteLine("Adding the element {0}", peuh2.ToString(refList));
s += peuh2;
Console.WriteLine("Resulting set: {0}", s.ToString(refList));
Console.WriteLine("Removing the element {0}", peuh.ToString(refList));
s -= peuh;
Console.WriteLine("Resulting set: {0}", s.ToString(refList));
Console.WriteLine("Removing the element {0}", peuh2.ToString(refList));
s -= peuh2;
Console.WriteLine("Resulting set: {0}", s.ToString(refList));
Console.WriteLine("----------------------------------------------------------------------");
Console.WriteLine("Generating a set of 4 atoms.");
s = DiscreteSet.GenerateSetOfAtoms(4);
Console.WriteLine("Resulting set: {0}", s);
Console.WriteLine("Number of elements: {0}", s.Card);
Console.WriteLine("Size of elements: {0}", s.ElementSize);
Console.WriteLine("----------------------------------------------------------------------");
Console.WriteLine("Generating a set of 6 atoms.");
s = DiscreteSet.GenerateSetOfAtoms(6);
Console.WriteLine("Resulting set: {0}", s);
Console.WriteLine("Number of elements: {0}", s.Card);
Console.WriteLine("Size of elements: {0}", s.ElementSize);
Console.WriteLine("----------------------------------------------------------------------");
Console.WriteLine("Generating a set of 68 atoms.");
s = DiscreteSet.GenerateSetOfAtoms(68);
Console.WriteLine("Resulting set: {0}", s.ToStringOnePerLine());
Console.WriteLine("Number of elements: {0}", s.Card);
Console.WriteLine("Size of elements: {0}", s.ElementSize);
Console.WriteLine("----------------------------------------------------------------------");
Console.WriteLine("Generating a powerset with 4 worlds.");
s = DiscreteSet.GeneratePowerSet(4);
Console.WriteLine("Resulting set: {0}", s.ToStringOnePerLine());
Console.WriteLine("Number of elements: {0}", s.Card);
Console.WriteLine("Size of elements: {0}", s.ElementSize);
Console.WriteLine("----------------------------------------------------------------------");
Console.WriteLine("Generating a powerset with 6 worlds.");
s = DiscreteSet.GeneratePowerSet(6);
Console.WriteLine("Resulting set: {0}", s.ToStringOnePerLine());
Console.WriteLine("Number of elements: {0}", s.Card);
Console.WriteLine("Size of elements: {0}", s.ElementSize);
Console.WriteLine("----------------------------------------------------------------------");
}
/// <summary>
/// Builds an empty evidential mapping with just a frame name and a reference list.
/// </summary>
/// <param name="frameName">The name of the frame of discernment of origin.</param>
/// <param name="refList">The reference list for this frame.</param>
public DiscreteEvidentialMapping(string frameName, StringReferenceList refList)
{
this._frameName = frameName;
this._refList = refList;
this._vectors = new List <DiscreteMappingVector>();
}
public static void TestCase()
{
StringReferenceList refList = new StringReferenceList("Yes", "No");
DiscreteMassFunction m1 = new DiscreteMassFunction();
m1.AddMass(new DiscreteElement(2, 1), 0.1);
m1.AddMass(new DiscreteElement(2, 2), 0.3);
m1.AddMass(new DiscreteElement(2, 3), 0.6);
m1.AddMass(new DiscreteElement(2, 3), 0.4);
Console.WriteLine("\n\n" +
"+--------------------------------------------------------------------+\n" +
"| DiscreteMassFunction Tests |\n" +
"+--------------------------------------------------------------------+"
);
Console.WriteLine(refList);
Console.WriteLine("----------------------------------------------------------------------");
Console.WriteLine(m1);
Console.WriteLine("----------------------------------------------------------------------");
Console.WriteLine(m1.ToString(refList));
Console.WriteLine("----------------------------------------------------------------------");
Console.WriteLine("Removing 0.4 to the total ignorance.");
m1.RemoveMass(DiscreteElement.GetCompleteElement(2), 0.4);
Console.WriteLine(m1.ToString(refList));
Console.WriteLine("----------------------------------------------------------------------");
DiscreteElement yes = new DiscreteElement(2, 1);
DiscreteElement no = new DiscreteElement(2, 2);
DiscreteElement yesUNo = new DiscreteElement(2, 3);
Console.WriteLine("Belief tests:");
Console.WriteLine("bel({0}) = {1} (should be 0.1)", yes, m1.Bel(yes));
Console.WriteLine("bel({0}) = {1} (should be 0.3)", no, m1.Bel(no));
Console.WriteLine("bel({0}) = {1} (should be 1.0)", yesUNo, m1.Bel(yesUNo));
Console.WriteLine("----------------------------------------------------------------------");
Console.WriteLine("BetP tests:");
Console.WriteLine("BetP({0}) = {1} (should be 0.4)", yes, m1.BetP(yes));
Console.WriteLine("BetP({0}) = {1} (should be 0.6)", no, m1.BetP(no));
Console.WriteLine("BetP({0}) = {1} (should be 1.0)", yesUNo, m1.BetP(yesUNo));
Console.WriteLine("----------------------------------------------------------------------");
Console.WriteLine("Plausibility tests:");
Console.WriteLine("pl({0}) = {1} (should be 0.7)", yes, m1.Pl(yes));
Console.WriteLine("pl({0}) = {1} (should be 0.9)", no, m1.Pl(no));
Console.WriteLine("pl({0}) = {1} (should be 1.0)", yesUNo, m1.Pl(yesUNo));
Console.WriteLine("----------------------------------------------------------------------");
Console.WriteLine("Commonality tests:");
Console.WriteLine("q({0}) = {1} (should be 0.7)", yes, m1.Q(yes));
Console.WriteLine("q({0}) = {1} (should be 0.9)", no, m1.Q(no));
Console.WriteLine("q({0}) = {1} (should be 0.6)", yesUNo, m1.Q(yesUNo));
Console.WriteLine("----------------------------------------------------------------------");
Console.WriteLine("Conditioning test:");
Console.WriteLine(m1.ToString(refList));
Console.WriteLine("Conditioning by {0}...", yes.ToString(refList));
m1 = m1.Conditioning(yes);
Console.WriteLine(m1.ToString(refList));
Console.WriteLine("----------------------------------------------------------------------");
Console.WriteLine("Conditioning test:");
Console.WriteLine(m1.ToString(refList));
Console.WriteLine("Conditioning by {0}...", no.ToString(refList));
m1 = m1.Conditioning(no);
Console.WriteLine(m1.ToString(refList));
Console.WriteLine("----------------------------------------------------------------------");
m1 = new DiscreteMassFunction();
m1.AddMass(new DiscreteElement(2, 1), 0.1);
m1.AddMass(new DiscreteElement(2, 2), 0.3);
m1.AddMass(new DiscreteElement(2, 3), 0.6);
Console.WriteLine("Conditioning test:");
Console.WriteLine(m1.ToString(refList));
Console.WriteLine("Conditioning by {0}...", no.ToString(refList));
m1 = m1.Conditioning(no);
Console.WriteLine(m1.ToString(refList));
Console.WriteLine("----------------------------------------------------------------------");
Console.WriteLine("Conditioning test:");
Console.WriteLine(m1.ToString(refList));
Console.WriteLine("Conditioning by {0}...", yes.ToString(refList));
m1 = m1.Conditioning(yes);
Console.WriteLine(m1.ToString(refList));
Console.WriteLine("----------------------------------------------------------------------");
m1 = new DiscreteMassFunction();
m1.AddMass(new DiscreteElement(2, 1), 0.1);
m1.AddMass(new DiscreteElement(2, 2), 0.3);
m1.AddMass(new DiscreteElement(2, 3), 0.6);
Console.WriteLine("Weakening test:");
Console.WriteLine(m1.ToString(refList));
m1 = m1.Weakening(0.1);
Console.WriteLine("Weakened by with alpha = 0.1");
Console.WriteLine(m1.ToString(refList));
Console.WriteLine("----------------------------------------------------------------------");
m1 = new DiscreteMassFunction();
m1.AddMass(new DiscreteElement(2, 1), 0.1);
m1.AddMass(new DiscreteElement(2, 2), 0.3);
m1.AddMass(new DiscreteElement(2, 3), 0.6);
Console.WriteLine("Discounting test:");
Console.WriteLine(m1.ToString(refList));
m1 = m1.Discounting(0.1);
Console.WriteLine("Disounting by with alpha = 0.1");
Console.WriteLine(m1.ToString(refList));
Console.WriteLine("----------------------------------------------------------------------");
m1 = new DiscreteMassFunction();
m1.AddMass(new DiscreteElement(2, 1), 0.0);
m1.AddMass(new DiscreteElement(2, 2), 0.3);
m1.AddMass(new DiscreteElement(2, 3), 0.7);
Console.WriteLine("Cleaning test:");
Console.WriteLine(m1.ToString(refList));
m1.Clean();
Console.WriteLine("After cleaning:");
Console.WriteLine(m1.ToString(refList));
Console.WriteLine("----------------------------------------------------------------------");
m1 = new DiscreteMassFunction();
m1.AddMass(new DiscreteElement(2, 1), 0.33);
m1.AddMass(new DiscreteElement(2, 2), 0.66);
m1.AddMass(new DiscreteElement(2, 3), 1.01);
Console.WriteLine("Normalization test");
Console.WriteLine(m1.ToString(refList));
m1.Normalise();
Console.WriteLine("After normalization:");
Console.WriteLine(m1.ToString(refList));
Console.WriteLine("----------------------------------------------------------------------");
m1 = new DiscreteMassFunction();
m1.AddMass(new DiscreteElement(2, 1), 0.2);
m1.AddMass(new DiscreteElement(2, 2), 0.2);
m1.AddMass(new DiscreteElement(2, 3), 0.6);
DiscreteMassFunction m2 = new DiscreteMassFunction();
m2.AddMass(new DiscreteElement(2, 1), 0.2);
m2.AddMass(new DiscreteElement(2, 2), 0.6);
m2.AddMass(new DiscreteElement(2, 3), 0.2);
Console.WriteLine("Smets combination test:");
Console.WriteLine("m1: {0}\nm2: {1}", m1, m2);
Console.WriteLine("Combination:\n{0}", m1.CombinationSmets(m2));
Console.WriteLine("----------------------------------------------------------------------");
DiscreteMassFunction m3 = new DiscreteMassFunction();
m3.AddMass(new DiscreteElement(2, 1), 0.8);
m3.AddMass(new DiscreteElement(2, 2), 0.2);
Console.WriteLine("Smets combination test:");
Console.WriteLine("Adding a mass function: {0}", m3);
Console.WriteLine("Combination:\n{0}", m1.CombinationSmets(m2, m3));
Console.WriteLine("----------------------------------------------------------------------");
Console.WriteLine("Dempster combination test:");
Console.WriteLine("m1: {0}\nm2: {1}", m1, m2);
Console.WriteLine("Combination:\n{0}", m1.CombinationDempster(m2));
Console.WriteLine("----------------------------------------------------------------------");
Console.WriteLine("Dempster combination test:");
Console.WriteLine("Adding a mass function: {0}", m3);
Console.WriteLine("Combination:\n{0}", m1.CombinationDempster(m2, m3));
Console.WriteLine("----------------------------------------------------------------------");
Console.WriteLine("Disjunctive combination test:");
Console.WriteLine("m1: {0}\nm2: {1}", m1, m2);
Console.WriteLine("Combination:\n{0}", m1.CombinationDisjunctive(m2));
Console.WriteLine("----------------------------------------------------------------------");
Console.WriteLine("Disjunctive combination test:");
Console.WriteLine("Adding a mass function: {0}", m3);
Console.WriteLine("Combination:\n{0}", m1.CombinationDisjunctive(m2, m3));
Console.WriteLine("----------------------------------------------------------------------");
Console.WriteLine("Yager combination test:");
Console.WriteLine("m1: {0}\nm2: {1}", m1, m2);
Console.WriteLine("Combination:\n{0}", m1.CombinationYager(m2));
Console.WriteLine("----------------------------------------------------------------------");
Console.WriteLine("Yager combination test:");
Console.WriteLine("Adding a mass function: {0}", m3);
Console.WriteLine("Combination:\n{0}", m1.CombinationYager(m2, m3));
Console.WriteLine("----------------------------------------------------------------------");
Console.WriteLine("Average combination test:");
Console.WriteLine("m1: {0}\nm2: {1}", m1, m2);
Console.WriteLine("Combination:\n{0}", m1.CombinationAverage(m2));
Console.WriteLine("----------------------------------------------------------------------");
Console.WriteLine("Average combination test:");
Console.WriteLine("Adding a mass function: {0}", m3);
Console.WriteLine("Combination:\n{0}", m1.CombinationAverage(m2, m3));
Console.WriteLine("----------------------------------------------------------------------");
Console.WriteLine("Murphy combination test:");
Console.WriteLine("m1: {0}\nm2: {1}", m1, m2);
Console.WriteLine("Combination:\n{0}", m1.CombinationMurphy(m2));
Console.WriteLine("----------------------------------------------------------------------");
Console.WriteLine("Murphy combination test:");
Console.WriteLine("Adding a mass function: {0}", m3);
Console.WriteLine("Combination:\n{0}", m1.CombinationMurphy(m2, m3));
Console.WriteLine("----------------------------------------------------------------------");
Console.WriteLine("Chen combination test:");
Console.WriteLine("m1: {0}\nm2: {1}", m1, m2);
Console.WriteLine("Combination:\n{0}", m1.CombinationChen(m2));
Console.WriteLine("----------------------------------------------------------------------");
Console.WriteLine("Chen combination test:");
Console.WriteLine("Adding a mass function: {0}", m3);
Console.WriteLine("Combination:\n{0}", m1.CombinationChen(m2, m3));
Console.WriteLine("----------------------------------------------------------------------");
Console.WriteLine("GetTreeOfFocals test with previous mass functions:");
List <List <DiscreteElement> > tree = DiscreteMassFunction.GetTreeOfFocals(m1, m2);
foreach (List <DiscreteElement> list in tree)
{
Console.Write("< ");
foreach (DiscreteElement e in list)
{
Console.Write("{0} ", e);
}
Console.Write(">\n");
}
Console.WriteLine("----------------------------------------------------------------------");
Console.WriteLine("DuboisPrade combination test:");
Console.WriteLine("m1: {0}\nm2: {1}", m1, m2);
Console.WriteLine("Combination:\n{0}", m1.CombinationDuboisPrade(m2));
Console.WriteLine("----------------------------------------------------------------------");
Console.WriteLine("GetTreeOfFocals test with previous mass functions:");
tree = DiscreteMassFunction.GetTreeOfFocals(m1, m2, m3);
foreach (List <DiscreteElement> list in tree)
{
Console.Write("< ");
foreach (DiscreteElement e in list)
{
Console.Write("{0} ", e);
}
Console.Write(">\n");
}
Console.WriteLine("----------------------------------------------------------------------");
Console.WriteLine("DuboisPrade combination test:");
Console.WriteLine("Adding a mass function: {0}", m3);
Console.WriteLine("Combination:\n{0}", m1.CombinationDuboisPrade(m2, m3));
Console.WriteLine("----------------------------------------------------------------------");
Console.WriteLine("Distance trivial test:\n{0}", m1);
Console.WriteLine("Distance with itself: {0}", m1.Distance(m1));
Console.WriteLine("----------------------------------------------------------------------");
DiscreteMassFunction trivial1 = new DiscreteMassFunction();
trivial1.AddMass(new DiscreteElement(3, 0), 1);
DiscreteMassFunction trivial2 = new DiscreteMassFunction();
trivial2.AddMass(new DiscreteElement(3, 7), 1);
Console.WriteLine("Distance trivial test 2:\n{0}\nand {1}", trivial1, trivial2);
Console.WriteLine("Distance between both: {0}", trivial1.Distance(trivial2));
Console.WriteLine("----------------------------------------------------------------------");
Console.WriteLine("Distance test:\n{0}\n{1}", m1, m2);
Console.WriteLine("Distance between both: {0}", m1.Distance(m2));
Console.WriteLine("----------------------------------------------------------------------");
Console.WriteLine("Distance test:\n{0}\n{1}", m1, m2);
Console.WriteLine("Distance between both + m1: {0}", m1.Distance(m1, m2));
Console.WriteLine("----------------------------------------------------------------------");
Console.WriteLine("Auto-conflict test:\n{0}", m1);
Console.WriteLine("Auto-conflict:\nDegree 1: {0}", m1.AutoConflict(1));
Console.WriteLine("Degree 2: {0}", m1.AutoConflict(2));
Console.WriteLine("Degree 3: {0}", m1.AutoConflict(3));
Console.WriteLine("Degree 4: {0}", m1.AutoConflict(4));
Console.WriteLine("Degree 5: {0}", m1.AutoConflict(5));
Console.WriteLine("----------------------------------------------------------------------");
Console.WriteLine("GetMax test:");
Console.WriteLine(m1.ToString(refList));
Console.WriteLine();
List <FocalElement <DiscreteElement> > max;
max = m1.GetMax(m1.M, 1);
Console.WriteLine("Max of m(), maxCard = 1:");
foreach (FocalElement <DiscreteElement> fe in max)
{
Console.WriteLine("Element: {0}, Value: {1}", fe.Element.ToString(refList), fe.Value);
}
Console.WriteLine();
max = m1.GetMax(m1.M, 2);
Console.WriteLine("Max of m(), maxCard = 2:");
foreach (FocalElement <DiscreteElement> fe in max)
{
Console.WriteLine("Element: {0}, Value: {1}", fe.Element.ToString(refList), fe.Value);
}
Console.WriteLine();
max = m1.GetMax(m1.Bel, 1);
Console.WriteLine("Max of bel(), maxCard = 1:");
foreach (FocalElement <DiscreteElement> fe in max)
{
Console.WriteLine("Element: {0}, Value: {1}", fe.Element.ToString(refList), fe.Value);
}
Console.WriteLine();
max = m1.GetMax(m1.Bel, 2);
Console.WriteLine("Max of bel(), maxCard = 2:");
foreach (FocalElement <DiscreteElement> fe in max)
{
Console.WriteLine("Element: {0}, Value: {1}", fe.Element.ToString(refList), fe.Value);
}
Console.WriteLine();
max = m1.GetMax(m1.BetP, 1);
Console.WriteLine("Max of BetP(), maxCard = 1:");
foreach (FocalElement <DiscreteElement> fe in max)
{
Console.WriteLine("Element: {0}, Value: {1}", fe.Element.ToString(refList), fe.Value);
}
Console.WriteLine();
max = m1.GetMax(m1.BetP, 2);
Console.WriteLine("Max of BetP(), maxCard = 2:");
foreach (FocalElement <DiscreteElement> fe in max)
{
Console.WriteLine("Element: {0}, Value: {1}", fe.Element.ToString(refList), fe.Value);
}
Console.WriteLine();
max = m1.GetMax(m1.Pl, 1);
Console.WriteLine("Max of pl(), maxCard = 1:");
foreach (FocalElement <DiscreteElement> fe in max)
{
Console.WriteLine("Element: {0}, Value: {1}", fe.Element.ToString(refList), fe.Value);
}
Console.WriteLine();
max = m1.GetMax(m1.Pl, 2);
Console.WriteLine("Max of pl(), maxCard = 2:");
foreach (FocalElement <DiscreteElement> fe in max)
{
Console.WriteLine("Element: {0}, Value: {1}", fe.Element.ToString(refList), fe.Value);
}
Console.WriteLine();
max = m1.GetMax(m1.Q, 1);
Console.WriteLine("Max of q(), maxCard = 1:");
foreach (FocalElement <DiscreteElement> fe in max)
{
Console.WriteLine("Element: {0}, Value: {1}", fe.Element.ToString(refList), fe.Value);
}
Console.WriteLine();
max = m1.GetMax(m1.Q, 2);
Console.WriteLine("Max of q(), maxCard = 2:");
foreach (FocalElement <DiscreteElement> fe in max)
{
Console.WriteLine("Element: {0}, Value: {1}", fe.Element.ToString(refList), fe.Value);
}
Console.WriteLine("----------------------------------------------------------------------");
Console.WriteLine("GetMin test:");
Console.WriteLine(m1.ToString(refList));
Console.WriteLine();
List <FocalElement <DiscreteElement> > min;
min = m1.GetMin(m1.M, 1);
Console.WriteLine("Min of m(), maxCard = 1:");
foreach (FocalElement <DiscreteElement> fe in min)
{
Console.WriteLine("Element: {0}, Value: {1}", fe.Element.ToString(refList), fe.Value);
}
Console.WriteLine();
min = m1.GetMin(m1.M, 2);
Console.WriteLine("Min of m(), maxCard = 2:");
foreach (FocalElement <DiscreteElement> fe in min)
{
Console.WriteLine("Element: {0}, Value: {1}", fe.Element.ToString(refList), fe.Value);
}
Console.WriteLine();
min = m1.GetMin(m1.Bel, 1);
Console.WriteLine("Min of bel(), maxCard = 1:");
foreach (FocalElement <DiscreteElement> fe in min)
{
Console.WriteLine("Element: {0}, Value: {1}", fe.Element.ToString(refList), fe.Value);
}
Console.WriteLine();
min = m1.GetMin(m1.Bel, 2);
Console.WriteLine("Min of bel(), maxCard = 2:");
foreach (FocalElement <DiscreteElement> fe in min)
{
Console.WriteLine("Element: {0}, Value: {1}", fe.Element.ToString(refList), fe.Value);
}
Console.WriteLine();
min = m1.GetMin(m1.BetP, 1);
Console.WriteLine("Min of BetP(), maxCard = 1:");
foreach (FocalElement <DiscreteElement> fe in min)
{
Console.WriteLine("Element: {0}, Value: {1}", fe.Element.ToString(refList), fe.Value);
}
Console.WriteLine();
min = m1.GetMin(m1.BetP, 2);
Console.WriteLine("Min of BetP(), maxCard = 2:");
foreach (FocalElement <DiscreteElement> fe in min)
{
Console.WriteLine("Element: {0}, Value: {1}", fe.Element.ToString(refList), fe.Value);
}
Console.WriteLine();
min = m1.GetMin(m1.Pl, 1);
Console.WriteLine("Min of pl(), maxCard = 1:");
foreach (FocalElement <DiscreteElement> fe in min)
{
Console.WriteLine("Element: {0}, Value: {1}", fe.Element.ToString(refList), fe.Value);
}
Console.WriteLine();
min = m1.GetMin(m1.Pl, 2);
Console.WriteLine("Min of pl(), maxCard = 2:");
foreach (FocalElement <DiscreteElement> fe in min)
{
Console.WriteLine("Element: {0}, Value: {1}", fe.Element.ToString(refList), fe.Value);
}
Console.WriteLine();
min = m1.GetMin(m1.Q, 1);
Console.WriteLine("Min of q(), maxCard = 1:");
foreach (FocalElement <DiscreteElement> fe in min)
{
Console.WriteLine("Element: {0}, Value: {1}", fe.Element.ToString(refList), fe.Value);
}
Console.WriteLine();
min = m1.GetMin(m1.Q, 2);
Console.WriteLine("Min of q(), maxCard = 2:");
foreach (FocalElement <DiscreteElement> fe in min)
{
Console.WriteLine("Element: {0}, Value: {1}", fe.Element.ToString(refList), fe.Value);
}
Console.WriteLine("----------------------------------------------------------------------");
}
//------------------------------------------------------------------------------------------------
/// <summary>
/// Gives a string representation of the current mapping point given a reference list.
/// </summary>
/// <param name="refList">The reference list to give sense to the states/worlds.</param>
/// <returns>Returns a string representation of the current mapping point.</returns>
public string ToString(StringReferenceList refList)
{
return(String.Format("[Element={0}, MappingFactor={1}]", Element.ToString(refList), MappingFactor));
}
