//-- Max product ----------------------------------------------------------------------
/// <summary>
///
/// </summary>
/// <param name="B">Incoming message from 'b'.</param>
/// <param name="logCost">Constant value for 'logCost'.</param>
/// <param name="result">Modified to contain the outgoing message</param>
/// <returns><paramref name="result"/></returns>
/// <remarks><para>
///
/// </para></remarks>
public static UnnormalizedDiscrete AMaxConditional(UnnormalizedDiscrete B, double logCost, UnnormalizedDiscrete result)
{
double max = B.GetWorkspace().Max();
double[] source = B.GetWorkspace().SourceArray;
double[] target = result.GetWorkspace().SourceArray;
for (int i=0; i<target.Length; i++) target[i] = Math.Max(max - logCost, source[i]);
return result;
}
//-- Max product ----------------------------------------------------------------------
/// <summary>
///
/// </summary>
/// <param name="B">Incoming message from 'b'.</param>
/// <param name="logCost">Constant value for 'logCost'.</param>
/// <param name="result">Modified to contain the outgoing message</param>
/// <returns><paramref name="result"/></returns>
/// <remarks><para>
///
/// </para></remarks>
public static UnnormalizedDiscrete AMaxConditional(UnnormalizedDiscrete B, double logCost, UnnormalizedDiscrete result)
{
double max = B.GetWorkspace().Max();
double[] source = B.GetWorkspace().SourceArray;
double[] target = result.GetWorkspace().SourceArray;
for (int i = 0; i < target.Length; i++)
{
target[i] = Math.Max(max - logCost, source[i]);
}
return(result);
}
//-- Max product ----------------------------------------------------------------------
/// <summary>
///
/// </summary>
/// <param name="B">Incoming message from 'b'.</param>
/// <param name="logUnitCost">Constant value for 'logUnitCost'.</param>
/// <param name="result">Modified to contain the outgoing message</param>
/// <returns><paramref name="result"/></returns>
/// <remarks><para>
///
/// </para></remarks>
public static UnnormalizedDiscrete AMaxConditional(UnnormalizedDiscrete B, double logUnitCost, UnnormalizedDiscrete result)
{
double[] source = B.GetWorkspace().SourceArray;
double[] target = result.GetWorkspace().SourceArray;
// forward pass
target[0] = source[0];
for (int i = 1; i < target.Length; i++)
{
target[i] = Math.Max(source[i], target[i - 1] - logUnitCost);
}
// reverse pass
for (int i = target.Length - 2; i >= 0; i--)
{
target[i] = Math.Max(target[i], target[i + 1] - logUnitCost);
}
return(result);
}
/// <summary>
///
/// </summary>
/// <param name="A">Incoming message from 'a'.</param>
/// <param name="logUnitCost">Constant value for 'logUnitCost'.</param>
/// <param name="maxCost">Constant value for 'maxCost'.</param>
/// <param name="result">Modified to contain the outgoing message</param>
/// <returns><paramref name="result"/></returns>
/// <remarks><para>
///
/// </para></remarks>
public static UnnormalizedDiscrete BMaxConditional(UnnormalizedDiscrete A, double logUnitCost, double maxCost, UnnormalizedDiscrete result)
{
return AMaxConditional(A, logUnitCost, maxCost, result);
}
//-- Max product ----------------------------------------------------------------------
/// <summary>
///
/// </summary>
/// <param name="B">Incoming message from 'b'.</param>
/// <param name="logUnitCost">Constant value for 'logUnitCost'.</param>
/// <param name="maxCost">Constant value for 'maxCost'.</param>
/// <param name="result">Modified to contain the outgoing message</param>
/// <returns><paramref name="result"/></returns>
/// <remarks><para>
///
/// </para></remarks>
public static UnnormalizedDiscrete AMaxConditional(UnnormalizedDiscrete B, double logUnitCost, double maxCost, UnnormalizedDiscrete result)
{
double[] source = B.GetWorkspace().SourceArray;
double[] target = result.GetWorkspace().SourceArray;
// forward pass
target[0] = source[0];
double max = source[0];
for (int i=1; i<target.Length; i++)
{
max = Math.Max(max, source[i]);
target[i] = Math.Max(source[i], target[i-1] - logUnitCost);
}
// reverse pass
double maxLessCost = max-maxCost;
target[target.Length-1] = Math.Max(target[target.Length-1],maxLessCost);
for (int i=target.Length-2; i>=0; i--)
{
target[i] = Math.Max( Math.Max(target[i], target[i+1] - logUnitCost), maxLessCost) ;
}
return result;
}
public void Initialize(bool skipStringDistributions = false)
{
// DO NOT make this a constructor, because it makes the test not notice complete lack of serialization as an empty object is set up exactly as the thing
// you are trying to deserialize.
this.pareto = new Pareto(1.2, 3.5);
this.poisson = new Poisson(2.3);
this.wishart = new Wishart(20, new PositiveDefiniteMatrix(new double[, ] {
{ 22, 21 }, { 21, 23 }
}));
this.vectorGaussian = new VectorGaussian(Vector.FromArray(13, 14), new PositiveDefiniteMatrix(new double[, ] {
{ 16, 15 }, { 15, 17 }
}));
this.unnormalizedDiscrete = UnnormalizedDiscrete.FromLogProbs(DenseVector.FromArray(5.1, 5.2, 5.3));
this.pointMass = PointMass <double> .Create(1.1);
this.gaussian = new Gaussian(11.0, 12.0);
this.nonconjugateGaussian = new NonconjugateGaussian(1.2, 2.3, 3.4, 4.5);
this.gamma = new Gamma(9.0, 10.0);
this.gammaPower = new GammaPower(5.6, 2.8, 3.4);
this.discrete = new Discrete(6.0, 7.0, 8.0);
this.conjugateDirichlet = new ConjugateDirichlet(1.2, 2.3, 3.4, 4.5);
this.dirichlet = new Dirichlet(3.0, 4.0, 5.0);
this.beta = new Beta(2.0, 1.0);
this.binomial = new Binomial(5, 0.8);
this.bernoulli = new Bernoulli(0.6);
this.sparseBernoulliList = SparseBernoulliList.Constant(4, new Bernoulli(0.1));
this.sparseBernoulliList[1] = new Bernoulli(0.9);
this.sparseBernoulliList[3] = new Bernoulli(0.7);
this.sparseBetaList = SparseBetaList.Constant(5, new Beta(2.0, 2.0));
this.sparseBetaList[0] = new Beta(3.0, 4.0);
this.sparseBetaList[1] = new Beta(5.0, 6.0);
this.sparseGaussianList = SparseGaussianList.Constant(6, Gaussian.FromMeanAndPrecision(0.1, 0.2));
this.sparseGaussianList[4] = Gaussian.FromMeanAndPrecision(0.3, 0.4);
this.sparseGaussianList[5] = Gaussian.FromMeanAndPrecision(0.5, 0.6);
this.sparseGammaList = SparseGammaList.Constant(1, Gamma.FromShapeAndRate(1.0, 2.0));
this.truncatedGamma = new TruncatedGamma(1.2, 2.3, 3.4, 4.5);
this.truncatedGaussian = new TruncatedGaussian(1.2, 3.4, 5.6, 7.8);
this.wrappedGaussian = new WrappedGaussian(1.2, 2.3, 3.4);
ga = Distribution <double> .Array(new[] { this.gaussian, this.gaussian });
vga = Distribution <Vector> .Array(new[] { this.vectorGaussian, this.vectorGaussian });
ga2D = Distribution <double> .Array(new[, ] {
{ this.gaussian, this.gaussian }, { this.gaussian, this.gaussian }
});
vga2D = Distribution <Vector> .Array(new[, ] {
{ this.vectorGaussian, this.vectorGaussian }, { this.vectorGaussian, this.vectorGaussian }
});
gaJ = Distribution <double> .Array(new[] { new[] { this.gaussian, this.gaussian }, new[] { this.gaussian, this.gaussian } });
vgaJ = Distribution <Vector> .Array(new[] { new[] { this.vectorGaussian, this.vectorGaussian }, new[] { this.vectorGaussian, this.vectorGaussian } });
var gp = new GaussianProcess(new ConstantFunction(0), new SquaredExponential(0));
var basis = Util.ArrayInit(2, i => Vector.FromArray(1.0 * i));
this.sparseGp = new SparseGP(new SparseGPFixed(gp, basis));
this.quantileEstimator = new QuantileEstimator(0.01);
this.quantileEstimator.Add(5);
this.outerQuantiles = OuterQuantiles.FromDistribution(3, this.quantileEstimator);
this.innerQuantiles = InnerQuantiles.FromDistribution(3, this.outerQuantiles);
if (!skipStringDistributions)
{
// String distributions can not be serialized by some formatters (namely BinaryFormatter)
// That is fine because this combination is never used in practice
this.stringDistribution1 = StringDistribution.String("aa")
.Append(StringDistribution.OneOf("b", "ccc")).Append("dddd");
this.stringDistribution2 = new StringDistribution();
this.stringDistribution2.SetToProduct(StringDistribution.OneOf("a", "b"),
StringDistribution.OneOf("b", "c"));
}
}
/// <summary />
/// <param name="dist">Incoming message from <c>dist</c>. Must be a proper distribution. If uniform, the result will be uniform.</param>
/// <returns />
/// <remarks>
/// <para />
/// </remarks>
/// <exception cref="ImproperMessageException">
/// <paramref name="dist" /> is not a proper distribution.</exception>
public static UnnormalizedDiscrete RandomMaxConditional([SkipIfUniform] Discrete dist)
{
return(UnnormalizedDiscrete.FromDiscrete(dist));
}
/// <summary>
///
/// </summary>
/// <param name="A">Incoming message from 'a'.</param>
/// <param name="logUnitCost">Constant value for 'logUnitCost'.</param>
/// <param name="maxCost">Constant value for 'maxCost'.</param>
/// <param name="result">Modified to contain the outgoing message</param>
/// <returns><paramref name="result"/></returns>
/// <remarks><para>
///
/// </para></remarks>
public static UnnormalizedDiscrete BMaxConditional(UnnormalizedDiscrete A, double logUnitCost, double maxCost, UnnormalizedDiscrete result)
{
return(AMaxConditional(A, logUnitCost, maxCost, result));
}
public void Initialize()
{
// DO NOT make this a constructor, because it makes the test not notice complete lack of serialization as an empty object is set up exactly as the thing
// you are trying to deserialize.
this.pareto = new Pareto(1.2, 3.5);
this.poisson = new Poisson(2.3);
this.wishart = new Wishart(20, new PositiveDefiniteMatrix(new double[, ] {
{ 22, 21 }, { 21, 23 }
}));
this.vectorGaussian = new VectorGaussian(Vector.FromArray(13, 14), new PositiveDefiniteMatrix(new double[, ] {
{ 16, 15 }, { 15, 17 }
}));
this.unnormalizedDiscrete = UnnormalizedDiscrete.FromLogProbs(DenseVector.FromArray(5.1, 5.2, 5.3));
this.pointMass = PointMass <double> .Create(1.1);
this.gaussian = new Gaussian(11.0, 12.0);
this.nonconjugateGaussian = new NonconjugateGaussian(1.2, 2.3, 3.4, 4.5);
this.gamma = new Gamma(9.0, 10.0);
this.gammaPower = new GammaPower(5.6, 2.8, 3.4);
this.discrete = new Discrete(6.0, 7.0, 8.0);
this.conjugateDirichlet = new ConjugateDirichlet(1.2, 2.3, 3.4, 4.5);
this.dirichlet = new Dirichlet(3.0, 4.0, 5.0);
this.beta = new Beta(2.0, 1.0);
this.binomial = new Binomial(5, 0.8);
this.bernoulli = new Bernoulli(0.6);
this.sparseBernoulliList = SparseBernoulliList.Constant(4, new Bernoulli(0.1));
this.sparseBernoulliList[1] = new Bernoulli(0.9);
this.sparseBernoulliList[3] = new Bernoulli(0.7);
this.sparseBetaList = SparseBetaList.Constant(5, new Beta(2.0, 2.0));
this.sparseBetaList[0] = new Beta(3.0, 4.0);
this.sparseBetaList[1] = new Beta(5.0, 6.0);
this.sparseGaussianList = SparseGaussianList.Constant(6, Gaussian.FromMeanAndPrecision(0.1, 0.2));
this.sparseGaussianList[4] = Gaussian.FromMeanAndPrecision(0.3, 0.4);
this.sparseGaussianList[5] = Gaussian.FromMeanAndPrecision(0.5, 0.6);
this.sparseGammaList = SparseGammaList.Constant(1, Gamma.FromShapeAndRate(1.0, 2.0));
this.truncatedGamma = new TruncatedGamma(1.2, 2.3, 3.4, 4.5);
this.truncatedGaussian = new TruncatedGaussian(1.2, 3.4, 5.6, 7.8);
this.wrappedGaussian = new WrappedGaussian(1.2, 2.3, 3.4);
ga = Distribution <double> .Array(new[] { this.gaussian, this.gaussian });
vga = Distribution <Vector> .Array(new[] { this.vectorGaussian, this.vectorGaussian });
ga2D = Distribution <double> .Array(new[, ] {
{ this.gaussian, this.gaussian }, { this.gaussian, this.gaussian }
});
vga2D = Distribution <Vector> .Array(new[, ] {
{ this.vectorGaussian, this.vectorGaussian }, { this.vectorGaussian, this.vectorGaussian }
});
gaJ = Distribution <double> .Array(new[] { new[] { this.gaussian, this.gaussian }, new[] { this.gaussian, this.gaussian } });
vgaJ = Distribution <Vector> .Array(new[] { new[] { this.vectorGaussian, this.vectorGaussian }, new[] { this.vectorGaussian, this.vectorGaussian } });
var gp = new GaussianProcess(new ConstantFunction(0), new SquaredExponential(0));
var basis = Util.ArrayInit(2, i => Vector.FromArray(1.0 * i));
this.sparseGp = new SparseGP(new SparseGPFixed(gp, basis));
this.quantileEstimator = new QuantileEstimator(0.01);
this.quantileEstimator.Add(5);
}
