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); }