public void ReplicateMessageFcnInfo()
{
FactorManager.FactorInfo info = FactorManager.GetFactorInfo(new MethodReference(typeof(Factor), "Replicate<>", typeof(bool)).GetMethodInfo());
IDictionary <string, Type> parameterTypes = new Dictionary <string, Type>();
parameterTypes["Uses"] = typeof(DistributionArray <Bernoulli>);
parameterTypes["Def"] = typeof(Bernoulli);
parameterTypes["result"] = typeof(Bernoulli); //typeof(DistributionArray<Bernoulli>);
MessageFcnInfo fcninfo = info.GetMessageFcnInfo(factorManager, "AverageLogarithm", "Def", parameterTypes);
Console.WriteLine(fcninfo);
CheckMessageFcnInfo(fcninfo, info);
parameterTypes["Uses"] = typeof(Bernoulli[]);
fcninfo = info.GetMessageFcnInfo(factorManager, "AverageLogarithm", "Def", parameterTypes);
Console.WriteLine(fcninfo);
CheckMessageFcnInfo(fcninfo, info);
DependencyInformation depInfo;
depInfo = FactorManager.GetDependencyInfo(fcninfo.Method);
Console.WriteLine("Dependencies:");
Console.WriteLine(StringUtil.ToString(depInfo.Dependencies));
Console.WriteLine("Requirements:");
Console.WriteLine(StringUtil.ToString(depInfo.Requirements));
Console.WriteLine("Triggers:");
Console.WriteLine(StringUtil.ToString(depInfo.Triggers));
}
public void IsPositiveFactorInfo()
{
FactorManager.FactorInfo info = FactorManager.GetFactorInfo(new Func <double, bool>(Factor.IsPositive));
Assert.True(info.IsDeterministicFactor);
var parameterTypes = new Dictionary <string, Type>
{
["isPositive"] = typeof(bool),
["x"] = typeof(Gaussian)
};
MessageFcnInfo fcninfo = info.GetMessageFcnInfo(factorManager, "AverageConditional", "x", parameterTypes);
Assert.True(fcninfo.NotSupportedMessage == null);
CheckMessageFcnInfo(fcninfo, info);
DependencyInformation depInfo = FactorManager.GetDependencyInfo(fcninfo.Method);
Assert.Throws <NotSupportedException>(() =>
{
fcninfo = info.GetMessageFcnInfo(factorManager, "AverageLogarithm", "x", parameterTypes);
});
bool found = false;
foreach (MessageFcnInfo fcninfo2 in info.GetMessageFcnInfos("AverageLogarithm", null, null))
{
CheckMessageFcnInfo(fcninfo2, info);
if (fcninfo2.TargetParameter.Equals("x"))
{
Assert.True(fcninfo2.NotSupportedMessage != null);
found = true;
}
}
Assert.True(found);
fcninfo = info.GetMessageFcnInfo(factorManager, "LogAverageFactor", "", parameterTypes);
CheckMessageFcnInfo(fcninfo, info);
}
public void ReplicateFactorInfo()
{
DependencyInformation depInfo;
FactorManager.FactorInfo info = FactorManager.GetFactorInfo(new MethodReference(typeof(Clone), "Replicate<>", typeof(bool)).GetMethodInfo());
Assert.True(info.IsDeterministicFactor);
var parameterTypes = new Dictionary <string, Type>
{
["Uses"] = typeof(Bernoulli[]),
["Def"] = typeof(Bernoulli),
["resultIndex"] = typeof(int),
["result"] = typeof(Bernoulli)
};
for (int i = 0; i < 3; i++)
{
MessageFcnInfo fcninfo = info.GetMessageFcnInfo(factorManager, "AverageConditional", "Uses", parameterTypes);
Assert.True(fcninfo.PassResult);
Assert.True(fcninfo.PassResultIndex);
Assert.Equal(2, fcninfo.Dependencies.Count);
Assert.Equal(1, fcninfo.Requirements.Count);
Assert.True(fcninfo.SkipIfAllUniform);
if (i == 0)
{
depInfo = FactorManager.GetDependencyInfo(fcninfo.Method);
}
}
parameterTypes.Remove("resultIndex");
MessageFcnInfo fcninfo3 = info.GetMessageFcnInfo(factorManager, "AverageConditional", "Def", parameterTypes);
Assert.True(fcninfo3.SkipIfAllUniform);
bool verbose = false;
if (verbose)
{
Console.WriteLine("All AverageConditional MessageFcnInfos:");
}
int count = 0;
foreach (MessageFcnInfo fcninfo2 in info.GetMessageFcnInfos("AverageConditional", null, null))
{
if (verbose)
{
Console.WriteLine(fcninfo2);
}
CheckMessageFcnInfo(fcninfo2, info);
count++;
}
//Assert.Equal(4, count);
}
private MessageFcnInfo GetMessageFcnInfo(FactorManager.FactorInfo info, string methodSuffix, string targetParameter, IReadOnlyDictionary <string, Type> parameterTypes)
{
var factoryParameters = new List <KeyValuePair <string, Type> >();
MessageFcnInfo fcninfo = info.GetMessageFcnInfo(factorManager, methodSuffix, targetParameter, parameterTypes);
ParameterInfo[] parameters = fcninfo.Method.GetParameters();
foreach (ParameterInfo parameter in parameters)
{
if (parameterTypes.ContainsKey(parameter.Name))
{
continue;
}
if (IsFactoryType(parameter.ParameterType))
{
Type[] typeArgs = parameter.ParameterType.GetGenericArguments();
Type itemType = typeArgs[0];
Type arrayType = Distribution.MakeDistributionArrayType(itemType, 1);
Type factoryType = typeof(IArrayFactory <,>).MakeGenericType(itemType, arrayType);
factoryParameters.Add(new KeyValuePair <string, Type>(parameter.Name, factoryType));
}
}
if (factoryParameters.Count > 0)
{
return(GetMessageFcnInfo(info, methodSuffix, targetParameter, Append(parameterTypes, factoryParameters)));
}
else
{
return(fcninfo);
}
}
public void ConstrainEqualRandomFactorInfo()
{
FactorManager.FactorInfo info =
FactorManager.GetFactorInfo(new MethodReference(typeof(Constrain), "EqualRandom<,>", typeof(bool), typeof(Bernoulli)).GetMethodInfo());
Assert.Equal(2, info.ParameterNames.Count);
Console.WriteLine(info);
IDictionary <string, Type> parameterTypes = new Dictionary <string, Type>();
parameterTypes["value"] = typeof(Bernoulli);
parameterTypes["dist"] = typeof(Bernoulli);
parameterTypes["result"] = typeof(Bernoulli);
MessageFcnInfo fcninfo = info.GetMessageFcnInfo(factorManager, "AverageConditional", "value", parameterTypes);
Console.WriteLine(fcninfo);
Assert.False(fcninfo.PassResult);
Assert.False(fcninfo.PassResultIndex);
Assert.Equal(1, fcninfo.Dependencies.Count);
Assert.Equal(1, fcninfo.Requirements.Count);
Console.WriteLine();
Console.WriteLine("All MessageFcnInfos:");
int count = 0;
foreach (MessageFcnInfo fcninfo2 in info.GetMessageFcnInfos())
{
Console.WriteLine(fcninfo2);
CheckMessageFcnInfo(fcninfo2, info);
count++;
}
//Assert.Equal(4, count);
}
public void UsesEqualDefFactorInfo()
{
DependencyInformation depInfo;
FactorManager.FactorInfo info = FactorManager.GetFactorInfo(new MethodReference(typeof(Factor), "UsesEqualDef<>", typeof(bool)).GetMethodInfo());
Assert.True(!info.IsDeterministicFactor);
IDictionary <string, Type> parameterTypes = new Dictionary <string, Type>();
parameterTypes["Uses"] = typeof(Bernoulli[]);
parameterTypes["Def"] = typeof(Bernoulli);
parameterTypes["resultIndex"] = typeof(int);
parameterTypes["result"] = typeof(Bernoulli);
for (int i = 0; i < 3; i++)
{
MessageFcnInfo fcninfo = info.GetMessageFcnInfo(factorManager, "AverageLogarithm", "Uses", parameterTypes);
Assert.True(fcninfo.PassResult);
Assert.True(fcninfo.PassResultIndex);
Assert.Equal(2, fcninfo.Dependencies.Count);
Assert.Equal(1, fcninfo.Requirements.Count);
Assert.True(fcninfo.SkipIfAllUniform);
Assert.Equal(1, fcninfo.Triggers.Count);
if (i == 0)
{
depInfo = FactorManager.GetDependencyInfo(fcninfo.Method);
Console.WriteLine("Dependencies:");
Console.WriteLine(StringUtil.ToString(depInfo.Dependencies));
Console.WriteLine("Requirements:");
Console.WriteLine(StringUtil.ToString(depInfo.Requirements));
Console.WriteLine("Triggers:");
Console.WriteLine(StringUtil.ToString(depInfo.Triggers));
}
}
parameterTypes.Remove("resultIndex");
MessageFcnInfo fcninfo2 = info.GetMessageFcnInfo(factorManager, "AverageLogarithm", "Def", parameterTypes);
Assert.True(fcninfo2.SkipIfAllUniform);
Assert.Equal(1, fcninfo2.Triggers.Count);
depInfo = FactorManager.GetDependencyInfo(fcninfo2.Method);
Console.WriteLine("Dependencies:");
Console.WriteLine(StringUtil.ToString(depInfo.Dependencies));
Console.WriteLine("Requirements:");
Console.WriteLine(StringUtil.ToString(depInfo.Requirements));
Console.WriteLine("Triggers:");
Console.WriteLine(StringUtil.ToString(depInfo.Triggers));
}
public void IsPositiveFactorInfo()
{
FactorManager.FactorInfo info = FactorManager.GetFactorInfo(new Func <double, bool>(Factor.IsPositive));
Console.WriteLine(info);
Assert.True(info.IsDeterministicFactor);
IDictionary <string, Type> parameterTypes = new Dictionary <string, Type>();
parameterTypes["isPositive"] = typeof(bool);
parameterTypes["x"] = typeof(Gaussian);
MessageFcnInfo fcninfo = info.GetMessageFcnInfo(factorManager, "AverageConditional", "x", parameterTypes);
Assert.True(fcninfo.NotSupportedMessage == null);
CheckMessageFcnInfo(fcninfo, info);
DependencyInformation depInfo = FactorManager.GetDependencyInfo(fcninfo.Method);
Console.WriteLine("Dependencies:");
Console.WriteLine(StringUtil.ToString(depInfo.Dependencies));
Console.WriteLine("Requirements:");
Console.WriteLine(StringUtil.ToString(depInfo.Requirements));
try
{
fcninfo = info.GetMessageFcnInfo(factorManager, "AverageLogarithm", "x", parameterTypes);
Assert.True(false, "did not throw exception");
}
catch (NotSupportedException ex)
{
Console.WriteLine("Correctly failed with exception: " + ex);
}
bool found = false;
foreach (MessageFcnInfo fcninfo2 in info.GetMessageFcnInfos("AverageLogarithm", null, null))
{
CheckMessageFcnInfo(fcninfo2, info);
if (fcninfo2.TargetParameter.Equals("x"))
{
Assert.True(fcninfo2.NotSupportedMessage != null);
found = true;
}
}
Assert.True(found);
fcninfo = info.GetMessageFcnInfo(factorManager, "LogAverageFactor", "", parameterTypes);
CheckMessageFcnInfo(fcninfo, info);
}
//[Fact]
// should take 140ms
// turn on PrintStatistics in Binding.cs
internal void SpeedTest()
{
FactorManager.FactorInfo info = FactorManager.GetFactorInfo(new MethodReference(typeof(Factor), "ReplicateWithMarginal<>", typeof(bool[])).GetMethodInfo());
IDictionary <string, Type> parameterTypes = new Dictionary <string, Type>();
Type ba = typeof(DistributionStructArray <Bernoulli, bool>);
Type baa = typeof(DistributionRefArray <DistributionStructArray <Bernoulli, bool>, bool[]>);
parameterTypes["Uses"] = baa;
parameterTypes["Def"] = ba;
parameterTypes["Marginal"] = ba;
parameterTypes["result"] = baa;
MessageFcnInfo fcninfo;
fcninfo = info.GetMessageFcnInfo(factorManager, "AverageConditional", "Uses", parameterTypes);
parameterTypes["result"] = ba;
parameterTypes["resultIndex"] = typeof(int);
fcninfo = info.GetMessageFcnInfo(factorManager, "AverageConditional", "Uses", parameterTypes);
}
public void ReplicateMessageFcnInfo()
{
FactorManager.FactorInfo info = FactorManager.GetFactorInfo(new MethodReference(typeof(Clone), "Replicate<>", typeof(bool)).GetMethodInfo());
var parameterTypes = new Dictionary <string, Type>
{
["Uses"] = typeof(DistributionArray <Bernoulli>),
["Def"] = typeof(Bernoulli),
["result"] = typeof(Bernoulli) //typeof(DistributionArray<Bernoulli>);
};
MessageFcnInfo fcninfo = info.GetMessageFcnInfo(factorManager, "AverageLogarithm", "Def", parameterTypes);
CheckMessageFcnInfo(fcninfo, info);
parameterTypes["Uses"] = typeof(Bernoulli[]);
fcninfo = info.GetMessageFcnInfo(factorManager, "AverageLogarithm", "Def", parameterTypes);
CheckMessageFcnInfo(fcninfo, info);
DependencyInformation depInfo;
depInfo = FactorManager.GetDependencyInfo(fcninfo.Method);
}
public void MissingMethodFailure()
{
FactorManager.FactorInfo info = FactorManager.GetFactorInfo(new Func <double, double, double>(Factor.Gaussian));
Dictionary <string, Type> parameterTypes = new Dictionary <string, Type>();
parameterTypes["sample"] = typeof(Gaussian);
parameterTypes["mean"] = typeof(Gaussian);
parameterTypes["precision"] = typeof(Gaussian);
Assert.Throws <ArgumentException>(() =>
{
MessageFcnInfo fcninfo = info.GetMessageFcnInfo(factorManager, "AverageConditional", "Sample", parameterTypes);
});
}
public void TypeConstraintFailureFactorInfo()
{
FactorManager.FactorInfo info = FactorManager.GetFactorInfo(new MethodReference(typeof(ShiftAlpha), "ToFactor<>").GetMethodInfo());
Console.WriteLine(info);
Dictionary <string, Type> parameterTypes = new Dictionary <string, Type>();
parameterTypes["factor"] = typeof(double);
parameterTypes["result"] = typeof(double);
Assert.Throws <ArgumentException>(() =>
{
MessageFcnInfo fcninfo = info.GetMessageFcnInfo(factorManager, "AverageConditional", "Variable", parameterTypes);
});
}
internal void ToMessageTest()
{
FactorManager.FactorInfo info = FactorManager.GetFactorInfo(new Func <double, bool>(Factor.IsPositive));
var parameterTypes = new Dictionary <string, Type>
{
["isPositive"] = typeof(bool),
["x"] = typeof(Gaussian)
};
MessageFcnInfo fcninfo;
fcninfo = info.GetMessageFcnInfo(factorManager, "LogEvidenceRatio2", "", parameterTypes);
CheckMessageFcnInfo(fcninfo, info);
DependencyInformation depInfo = FactorManager.GetDependencyInfo(fcninfo.Method);
}
public void ProductFactorInfo()
{
FactorManager.FactorInfo info = FactorManager.GetFactorInfo(new FactorMethod <double, double, double>(Factor.Product));
Console.WriteLine(info);
Assert.True(info.IsDeterministicFactor);
IDictionary <string, Type> parameterTypes = new Dictionary <string, Type>();
parameterTypes["product"] = typeof(Gaussian);
parameterTypes["a"] = typeof(Gaussian);
parameterTypes["b"] = typeof(Gaussian);
//parameterTypes["result"] = typeof(Gaussian);
MessageFcnInfo fcninfo = info.GetMessageFcnInfo("AverageConditional", "product", parameterTypes);
CheckMessageFcnInfo(fcninfo, info);
}
public void UnaryFactorInfo()
{
FactorManager.FactorInfo info = FactorManager.GetFactorInfo(new MethodReference(typeof(Factor), "Random<>", typeof(bool), typeof(Bernoulli)).GetMethodInfo());
Assert.False(info.IsDeterministicFactor);
var parameterTypes = new Dictionary <string, Type>
{
["Random"] = typeof(Bernoulli),
["dist"] = typeof(Bernoulli),
["result"] = typeof(Bernoulli)
};
MessageFcnInfo fcninfo = info.GetMessageFcnInfo(factorManager, "AverageConditional", "Random", parameterTypes);
Assert.False(fcninfo.PassResult);
Assert.False(fcninfo.PassResultIndex);
Assert.Equal(1, fcninfo.Dependencies.Count);
}
public void MissingMethodFailure()
{
FactorManager.FactorInfo info = FactorManager.GetFactorInfo(new Func <double, double, double>(Factor.Gaussian));
Dictionary <string, Type> parameterTypes = new Dictionary <string, Type>();
parameterTypes["sample"] = typeof(Gaussian);
parameterTypes["mean"] = typeof(Gaussian);
parameterTypes["precision"] = typeof(Gaussian);
try
{
MessageFcnInfo fcninfo = info.GetMessageFcnInfo(factorManager, "AverageConditional", "Sample", parameterTypes);
Assert.True(false, "Did not throw an exception");
}
catch (ArgumentException ex)
{
Console.WriteLine("Correctly failed with exception: " + ex);
}
}
public void TypeConstraintFailureFactorInfo()
{
FactorManager.FactorInfo info = FactorManager.GetFactorInfo(new MethodReference(typeof(ShiftAlpha), "ToFactor<>").GetMethodInfo());
Console.WriteLine(info);
Dictionary <string, Type> parameterTypes = new Dictionary <string, Type>();
parameterTypes["factor"] = typeof(double);
parameterTypes["result"] = typeof(double);
try
{
MessageFcnInfo fcninfo = info.GetMessageFcnInfo(factorManager, "AverageConditional", "Variable", parameterTypes);
Assert.True(false, "Did not throw an exception");
}
catch (ArgumentException ex)
{
Console.WriteLine("Correctly failed with exception: " + ex);
}
}
public void NotFactorInfo()
{
FactorManager.FactorInfo info = FactorManager.GetFactorInfo(new MethodReference(typeof(Factor), "Not").GetMethodInfo());
Console.WriteLine(info);
Assert.True(info.IsDeterministicFactor);
IDictionary <string, Type> parameterTypes = new Dictionary <string, Type>();
parameterTypes["Not"] = typeof(Bernoulli);
parameterTypes["B"] = typeof(Bernoulli);
parameterTypes["result"] = typeof(Bernoulli);
MessageFcnInfo fcninfo = info.GetMessageFcnInfo(factorManager, "AverageConditional", "Not", parameterTypes);
Assert.False(fcninfo.PassResult);
Assert.False(fcninfo.PassResultIndex);
Assert.Equal(1, fcninfo.Dependencies.Count);
Assert.Equal(1, fcninfo.Requirements.Count);
Console.WriteLine(fcninfo);
}
internal void CheckMessageFcnInfo(MessageFcnInfo fcninfo, FactorManager.FactorInfo info)
{
Assert.True(fcninfo.Suffix != null);
Assert.True(fcninfo.TargetParameter != null);
Dictionary <string, Type> parameterTypes = new Dictionary <string, Type>();
foreach (KeyValuePair <string, Type> parameter in fcninfo.GetParameterTypes())
{
parameterTypes[parameter.Key] = parameter.Value;
}
try
{
MessageFcnInfo fcninfo2 = info.GetMessageFcnInfo(factorManager, fcninfo.Suffix, fcninfo.TargetParameter, parameterTypes);
Assert.Equal(fcninfo2.Method, fcninfo.Method);
}
catch (NotSupportedException)
{
Assert.True(fcninfo.NotSupportedMessage != null);
}
}
private MessageFcnInfo GetMessageFcnInfo(FactorManager.FactorInfo info, string methodSuffix, string targetParameter, IDictionary <string, Type> parameterTypes)
{
List <string> factoryParameters = new List <string>();
while (true)
{
MessageFcnInfo fcninfo = info.GetMessageFcnInfo(factorManager, methodSuffix, targetParameter, parameterTypes);
ParameterInfo[] parameters = fcninfo.Method.GetParameters();
bool newFactoryParameters = false;
foreach (ParameterInfo parameter in parameters)
{
if (parameterTypes.ContainsKey(parameter.Name))
{
continue;
}
if (IsFactoryType(parameter.ParameterType))
{
newFactoryParameters = true;
Type[] typeArgs = parameter.ParameterType.GetGenericArguments();
Type itemType = typeArgs[0];
Type arrayType = Distribution.MakeDistributionArrayType(itemType, 1);
Type factoryType = typeof(IArrayFactory <,>).MakeGenericType(itemType, arrayType);
parameterTypes[parameter.Name] = factoryType;
factoryParameters.Add(parameter.Name);
}
}
if (newFactoryParameters)
{
continue;
}
foreach (string factoryParameter in factoryParameters)
{
parameterTypes.Remove(factoryParameter);
}
return(fcninfo);
}
}
public void DifferenceFactorInfo()
{
FactorManager.FactorInfo info = FactorManager.GetFactorInfo(new MethodReference(typeof(Factor), "Difference").GetMethodInfo());
Console.WriteLine(info);
Assert.True(info.IsDeterministicFactor);
IDictionary <string, Type> parameterTypes = new Dictionary <string, Type>();
parameterTypes["Difference"] = typeof(Gaussian);
parameterTypes["A"] = typeof(Gaussian);
parameterTypes["B"] = typeof(Gaussian);
//parameterTypes["result"] = typeof(Gaussian);
MessageFcnInfo fcninfo = info.GetMessageFcnInfo(factorManager, "AverageConditional", "Difference", parameterTypes);
Assert.False(fcninfo.PassResult);
Assert.False(fcninfo.PassResultIndex);
Assert.Equal(2, fcninfo.Dependencies.Count);
Assert.Equal(2, fcninfo.Requirements.Count);
Console.WriteLine(fcninfo);
Console.WriteLine("Parameter types:");
Console.WriteLine(StringUtil.CollectionToString(fcninfo.GetParameterTypes(), ","));
Console.WriteLine();
try
{
fcninfo = info.GetMessageFcnInfo(factorManager, "Rubbish", "Difference", parameterTypes);
Assert.True(false, "Did not throw an exception");
}
catch (ArgumentException ex)
{
if (!ex.Message.Contains("MissingMethodException"))
{
Assert.True(false, "Correctly threw exception, but with wrong message");
}
Console.WriteLine("Different exception: " + ex);
}
Console.WriteLine();
try
{
parameterTypes["result"] = typeof(double);
fcninfo = info.GetMessageFcnInfo(factorManager, "AverageConditional", "Difference", parameterTypes);
Assert.True(false, "Did not throw an exception");
}
catch (ArgumentException ex)
{
Console.WriteLine("Correctly failed with exception: " + ex);
}
Console.WriteLine();
Console.WriteLine("All messages to A:");
int count = 0;
foreach (MessageFcnInfo fcninfo2 in info.GetMessageFcnInfos(null, "A", null))
{
Console.WriteLine(fcninfo2);
CheckMessageFcnInfo(fcninfo2, info);
count++;
}
//Assert.Equal(8, count);
Console.WriteLine();
Console.WriteLine("All messages to Difference:");
count = 0;
foreach (MessageFcnInfo fcninfo2 in info.GetMessageFcnInfos(null, "Difference", null))
{
Console.WriteLine(fcninfo2);
CheckMessageFcnInfo(fcninfo2, info);
count++;
}
Assert.Equal(8, count);
Console.WriteLine();
Console.WriteLine("All AverageConditionals:");
count = 0;
foreach (MessageFcnInfo fcninfo2 in info.GetMessageFcnInfos("AverageConditional", null, null))
{
Console.WriteLine(fcninfo2);
CheckMessageFcnInfo(fcninfo2, info);
count++;
}
Assert.Equal(12, count);
Console.WriteLine();
Console.WriteLine("All MessageFcnInfos:");
count = 0;
foreach (MessageFcnInfo fcninfo2 in info.GetMessageFcnInfos())
{
Console.WriteLine(fcninfo2);
CheckMessageFcnInfo(fcninfo2, info);
count++;
}
//Assert.Equal(26, count);
}