//------------------------------------------------------------------------------------------------
/// <summary>
/// Checks if the current model will produce valid mass functions.
/// </summary>
/// <returns>Returns true if the model will produce valid mass functions, false otherwise.</returns>
public bool IsValid()
{
//Build the list of points:
List <DiscreteSensorFocalPoint> list = new List <DiscreteSensorFocalPoint>();
foreach (DiscreteSensorFocalBelief fb in _focalBeliefs)
{
foreach (DiscreteSensorFocalPoint bp in fb.Belief)
{
if (!list.Contains(bp))
{
list.Add(bp);
}
}
}
list.Sort();
//Build a mass function for each point and check it is valid:
foreach (DiscreteSensorFocalPoint bp in list)
{
DiscreteMassFunction evidence = new DiscreteMassFunction();
foreach (DiscreteSensorFocalBelief fb in FocalBeliefs)
{
evidence.AddMass(fb.Element, fb.GetEvidence(bp.SensorMeasure));
}
if (!evidence.HasAValidSum() || !evidence.HasValidValues())
{
return(false);
}
}
return(true);
}
//------------------------------------------------------------------------------------------------
/// <summary>
/// Updates the previous mass function. Valid only for the temporisation
/// options (<see cref="Option_Flags.OP_TEMPO_FUSION"/> and <see cref="Option_Flags.OP_TEMPO_SPECIFICITY"/>).
/// </summary>
/// <param name="m">The new mass function to store.</param>
/// <exception cref="NotSupportedException">Thrown if applied to another type of option that the
/// temporisation options.</exception>
public void UpdatePreviousMassFunction(DiscreteMassFunction m)
{
if (Flag != Option_Flags.OP_TEMPO_FUSION && Flag != Option_Flags.OP_TEMPO_SPECIFICITY)
{
throw new NotSupportedException("This method only applies for the temporization options!");
}
_data[1].M = m;
}
//------------------------------------------------------------------------------------------------
//------------------------------------------------------------------------------------------------
//------------------------------------------------------------------------------------------------
#region Methods
/*
* Methods:
*/
/// <summary>
/// Gives a (potentially non-valid) mass function corresponding of the propagation of the belief
/// associated to the "from" element given the mass associated to it.
/// </summary>
/// <param name="mass">The mass associated to the element from which we propagate belief.</param>
/// <returns>Returns a (potentially non-valid) mass function corresponding to the
/// propagation of the belief associated to the "from" element given the mass associated to it.</returns>
public DiscreteMassFunction GetEvidence(double mass)
{
DiscreteMassFunction toReturn = new DiscreteMassFunction();
for (int i = 0; i < _to.Count; i++)
{
toReturn.AddMass(_to[i].Element, _to[i].GetMass(mass));
}
return(toReturn);
}
//------------------------------------------------------------------------------------------------
//------------------------------------------------------------------------------------------------
//------------------------------------------------------------------------------------------------
/*
* Methods:
*/
/// <summary>
/// Propagates the given mass function to the new frame of discernment using the evidential mapping.
/// </summary>
/// <param name="m">The mass function to propagate.</param>
/// <returns>Returns a new mass function defined on the recipient frame of discernment.</returns>
public DiscreteMassFunction GetEvidence(DiscreteMassFunction m)
{
DiscreteMassFunction evidence = new DiscreteMassFunction();
foreach (FocalElement <DiscreteElement> e in m)
{
foreach (DiscreteMappingVector v in _vectors)
{
if (e.Element.Equals(v.From))
{
DiscreteMassFunction partOfEvidence = v.GetEvidence(e.Value);
foreach (FocalElement <DiscreteElement> focal in partOfEvidence)
{
evidence.AddMass(focal.Element, focal.Value);
}
}
}
}
return(evidence);
}
//------------------------------------------------------------------------------------------------
//------------------------------------------------------------------------------------------------
//------------------------------------------------------------------------------------------------
/*
* Methods:
*/
#region Belief model methods
/// <summary>
/// Gets the raw mass function from the given sensor measure. No option is applied here as
/// it requires data associated to a specific sensor. (Temporisations and variation are thus
/// applied in <see cref="DiscreteSensorData"/>.
/// </summary>
/// <param name="measure">The sensor measure which the belief is inferred from.</param>
/// <returns>Returns a new mass function given the received sensor measure.</returns>
public DiscreteMassFunction GetEvidence(double?measure)
{
// ----
//Build the new mass function:
// ---
DiscreteMassFunction evidence = new DiscreteMassFunction();
if (measure != null)
{
foreach (DiscreteSensorFocalBelief fb in FocalBeliefs)
{
evidence.AddMass(fb.Element, fb.GetEvidence((double)measure));
}
}
else
{
evidence = DiscreteMassFunction.GetVacuousMassFunction(ElementSize);
}
// ---- /Building ---
return(evidence);
}
public static void TestCase()
{
Console.WriteLine("\n\n" +
"+--------------------------------------------------------------------+\n" +
"| GeneratorBeliefFromSensors Tests |\n" +
"+--------------------------------------------------------------------+"
);
try
{
char d = Path.DirectorySeparatorChar;
GeneratorDiscreteBeliefFromSensors generator = new GeneratorDiscreteBeliefFromSensors("Sleeping");
Console.WriteLine("Loading a model with the custom directory format:");
generator.LoadModel("Resources" + d + "BeliefsFromSensors" + d + "test", ModelFormat.MODEL_CUSTOM_DIRECTORY);
Console.WriteLine(generator);
Console.WriteLine("\n----------------------------------------------------------------------");
Console.WriteLine("----------------------------------------------------------------------");
Console.WriteLine("----------------------------------------------------------------------\n");
Console.WriteLine("Loading another model from an XML file:");
generator.LoadModel("Resources" + d + "BeliefsFromSensors" + d + "XML" + d + "BFS.xml", ModelFormat.MODEL_XML_FILE);
Console.WriteLine(generator);
Console.WriteLine("\n----------------------------------------------------------------------");
Console.WriteLine("Saving the model:");
Console.Write("Saving a custom directory (Resources" + d + "BeliefsFromSensors" + d + "SavingTest)... ");
generator.SaveModel("Resources" + d + "BeliefsFromSensors" + d + "SavingTest", ModelFormat.MODEL_CUSTOM_DIRECTORY);
Console.WriteLine("done!");
Console.Write("Saving an XML file (Resources" + d + "BeliefsFromSensors" + d + "XML" + d + "SavingTest.xml)... ");
generator.SaveModel("Resources" + d + "BeliefsFromSensors" + d + "XML" + d + "SavingTest.xml", ModelFormat.MODEL_XML_FILE);
Console.WriteLine("done!");
Console.WriteLine("\n----------------------------------------------------------------------");
Console.WriteLine("Loading a model with options:");
generator.LoadModel("Resources" + d + "BeliefsFromSensors" + d + "optionTest", ModelFormat.MODEL_CUSTOM_DIRECTORY);
Console.WriteLine(generator);
Console.WriteLine("\n----------------------------------------------------------------------");
Console.WriteLine("Building mass function with tempo-specificity (2s).");
generator.AddSensor("tempo", "Test");
DiscreteMassFunction m = (generator.ConstructEvidence(new SensorMeasure("Test", 100)))[0];
Console.WriteLine(m);
for (int i = 0; i < 10; i++)
{
Console.WriteLine("Waiting for 200ms (no new measure)...");
Thread.Sleep(200);
m = (generator.ConstructEvidence(new SensorMeasure("Test", null)))[0];
Console.WriteLine(m);
}
Console.WriteLine("\n----------------------------------------------------------------------");
Console.WriteLine("New measure!");
m = (generator.ConstructEvidence(new SensorMeasure("Test", 100)))[0];
Console.WriteLine(m);
Console.WriteLine("Waiting for 200ms (no new measure)...");
Thread.Sleep(200);
m = (generator.ConstructEvidence(new SensorMeasure("Test", null)))[0];
Console.WriteLine(m);
Console.WriteLine("Waiting for 200ms (no new measure)...");
Thread.Sleep(200);
m = (generator.ConstructEvidence(new SensorMeasure("Test", null)))[0];
Console.WriteLine(m);
Console.WriteLine("New measure!");
m = (generator.ConstructEvidence(new SensorMeasure("Test", 100)))[0];
Console.WriteLine(m);
Console.WriteLine("\n----------------------------------------------------------------------");
Console.WriteLine("Building mass function with tempo-fusion (2s).");
generator.AddSensor("tempoFusion", "Test-Fusion");
m = (generator.ConstructEvidence(new SensorMeasure("Test-Fusion", 100)))[0];
Console.WriteLine(m);
for (int i = 0; i < 10; i++)
{
Console.WriteLine("Waiting for 200ms (same measure)...");
Thread.Sleep(200);
m = (generator.ConstructEvidence(new SensorMeasure("Test-Fusion", 100)))[0];
Console.WriteLine(m);
}
for (int i = 0; i < 10; i++)
{
Console.WriteLine("Waiting for 200ms (no more measure)...");
Thread.Sleep(200);
m = (generator.ConstructEvidence(new SensorMeasure("Test-Fusion", null)))[0];
Console.WriteLine(m);
}
}
catch (Exception e)
{
Console.WriteLine(e.Message);
}
}
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>
/// Builds a new discrete mass function based on the received measure and the current model. If
/// measure == null, it means that no measure has been received. The effect of options (temporisation,
/// variation) are applied here.
/// </summary>
/// <param name="measure">The sensor measure received.</param>
/// <returns>Returns a new discrete mass function based on the current model and the received
/// measurement (and if options are applied also previous measurements).</returns>
public DiscreteMassFunction GetEvidence(double?measure)
{
// ----
//If variation applies:
// ----
double?newMeasure = 0;
int variationIndex = -1;
for (int i = 0; i < Options.Count; i++)
{
if (Options[i].Flag == DiscreteSensorOption.Option_Flags.OP_VARIATION)
{
variationIndex = i;
}
}
if (variationIndex != -1)
{
double sum = 0;
int nbMeasures = 0;
for (int i = 0; i < Options[i].Param; i++)
{
if (Options[i].Data[i].Measure != null)
{
sum += measure.Value - Options[i].Data[i].Measure.Value;
nbMeasures++;
}
}
if (nbMeasures != 0)
{
newMeasure = sum / nbMeasures;
}
else
{
newMeasure = null;
}
Options[variationIndex].AddMeasure(measure);
}
else
{
newMeasure = measure;
}
// ---- /Variations ----
//Get evidence from the model:
DiscreteMassFunction evidence = _model.GetEvidence(newMeasure);
// ----
//Apply temporization if needed:
// ----
int tempo = -1;
for (int i = 0; i < Options.Count; i++)
{
if (Options[i].Flag == DiscreteSensorOption.Option_Flags.OP_TEMPO_FUSION)
{
tempo = i;
}
}
// ----
//Apply tempo fusion:
// ----
if (tempo != -1)
{
long newTime = _watch.ElapsedMilliseconds;
//First measure:
if (Options[tempo].PreviousTime == -1)
{
Options[tempo].UpdatePreviousTime(newTime);
Options[tempo].PreviousMassFunction.Clear();
foreach (FocalElement <DiscreteElement> e in evidence)
{
Options[tempo].PreviousMassFunction.AddMass(e);
}
}
else
{
//Not first measure:
long elapsedTime = newTime - Options[tempo].PreviousTime;
if (newMeasure != null)
{
if (!(elapsedTime >= Options[tempo].Param))
{
DiscreteMassFunction discounted = Options[tempo].PreviousMassFunction.Discounting((double)elapsedTime / Options[tempo].Param);
evidence = discounted.CombinationDuboisPrade(evidence);
}
Options[tempo].UpdatePreviousTime(newTime);
Options[tempo].PreviousMassFunction.Clear();
foreach (FocalElement <DiscreteElement> e in evidence)
{
Options[tempo].PreviousMassFunction.AddMass(e);
}
}
else
{
if (elapsedTime >= Options[tempo].Param)
{
evidence = DiscreteMassFunction.GetVacuousMassFunction(_model.ElementSize);
}
else
{
evidence = Options[tempo].PreviousMassFunction.Discounting((double)elapsedTime / Options[tempo].Param);
}
}
}
// --- /TempoFusion ----
}
else
{
for (int i = 0; i < Options.Count; i++)
{
if (Options[i].Flag == DiscreteSensorOption.Option_Flags.OP_TEMPO_SPECIFICITY)
{
tempo = i;
}
}
// ----
//Apply tempo specificity:
// ----
if (tempo != -1)
{
long newTime = _watch.ElapsedMilliseconds;
//First measure:
if (Options[tempo].PreviousTime == -1)
{
Options[tempo].UpdatePreviousTime(newTime);
Options[tempo].PreviousMassFunction.Clear();
foreach (FocalElement <DiscreteElement> e in evidence)
{
Options[tempo].PreviousMassFunction.AddMass(e);
}
}
else
{
//Not first measure:
long elapsedTime = newTime - Options[tempo].PreviousTime;
if (newMeasure == null)
{
if (elapsedTime >= Options[tempo].Param)
{
evidence = DiscreteMassFunction.GetVacuousMassFunction(_model.ElementSize);
}
else
{
evidence = Options[tempo].PreviousMassFunction.Discounting((double)elapsedTime / Options[tempo].Param);
}
}
else
{
if (elapsedTime >= Options[tempo].Param)
{
Options[tempo].UpdatePreviousTime(newTime);
// ----
Options[tempo].PreviousMassFunction.Clear();
foreach (FocalElement <DiscreteElement> e in evidence)
{
Options[tempo].PreviousMassFunction.AddMass(e);
}
}
else
{
DiscreteMassFunction discounted = Options[tempo].PreviousMassFunction.Discounting((double)elapsedTime / Options[tempo].Param);
if (discounted.Specificity > evidence.Specificity)
{
evidence = discounted;
}
else
{
Options[tempo].UpdatePreviousTime(newTime);
// ----
Options[tempo].PreviousMassFunction.Clear();
foreach (FocalElement <DiscreteElement> e in evidence)
{
Options[tempo].PreviousMassFunction.AddMass(e);
}
}
}
}
}
}
// ---- /TempoSpec ----
}
return(evidence);
}
