public static Gaussian UsesAverageLogarithm(NonconjugateGaussian[] Uses, Gaussian Def, Gaussian result) { NonconjugateGaussian prod = Uses[0]; for (int i = 1; i < Uses.Length; i++) prod.SetToProduct(prod, Uses[i]); result = prod.GetGaussian(true); result.SetToProduct(result, Def); return result; }
/*-------------- Nonconjugate Gaussian --------------------*/ /// <summary>VMP message to <c>value</c>.</summary> /// <param name="copy">Incoming message from <c>copy</c>.</param> /// <param name="value">Incoming message from <c>value</c>.</param> /// <param name="to_value">Previous outgoing message to <c>value</c>.</param> /// <returns>The outgoing VMP message to the <c>value</c> argument.</returns> /// <remarks> /// <para>The outgoing message is the factor viewed as a function of <c>value</c> with <c>copy</c> integrated out. The formula is <c>sum_copy p(copy) factor(copy,value)</c>.</para> /// </remarks> /// <remarks><para> /// We reverse the direction of factor to get the behaviour we want here. /// </para></remarks> public static Gaussian ValueAverageLogarithm(NonconjugateGaussian copy, Gaussian value, Gaussian to_value) { var a = value / to_value; copy *= new NonconjugateGaussian(a); var result = copy.GetGaussian(true) / a; return(result); }
public static Gamma ExpAverageLogarithm([Proper] NonconjugateGaussian d) { double mD, vD; d.GetMeanAndVariance(out mD, out vD); double lm = mD + vD / 2; //return Gamma.FromMeanAndVariance(Math.Exp(lm), Math.Exp(2*lm)*(Math.Exp(vD)-1)); return(Gamma.FromLogMeanAndMeanLog(lm, mD)); }
public static Gaussian UsesAverageLogarithm(NonconjugateGaussian[] Uses, Gaussian Def, Gaussian result) { NonconjugateGaussian prod = Uses[0]; for (int i = 1; i < Uses.Length; i++) { prod.SetToProduct(prod, Uses[i]); } result = prod.GetGaussian(true); result.SetToProduct(result, Def); return(result); }
/// <summary>VMP message to <c>copy</c>.</summary> /// <param name="value">Incoming message from <c>value</c>.</param> /// <param name="copy">Incoming message from <c>copy</c>.</param> /// <param name="to_value">Previous outgoing message to <c>value</c>.</param> /// <returns>The outgoing VMP message to the <c>copy</c> argument.</returns> /// <remarks> /// <para>The outgoing message is a distribution matching the moments of <c>copy</c> as the random arguments are varied. The formula is <c>proj[sum_(value) p(value) factor(copy,value)]</c>.</para> /// </remarks> /// <remarks><para> /// This message should include the previous contribution. /// </para></remarks> public static NonconjugateGaussian CopyAverageLogarithm(Gaussian value, NonconjugateGaussian copy, Gaussian to_value) { return(new NonconjugateGaussian(value / to_value)); }
/// <summary>VMP message to <c>b</c>.</summary> /// <param name="ProductExp">Incoming message from <c>productExp</c>. Must be a proper distribution. If uniform, the result will be uniform.</param> /// <param name="A">Constant value for <c>a</c>.</param> /// <param name="B">Incoming message from <c>b</c>. Must be a proper distribution. If uniform, the result will be uniform.</param> /// <param name="to_B">Previous outgoing message to <c>B</c>.</param> /// <param name="result">Modified to contain the outgoing message.</param> /// <returns> /// <paramref name="result" /> /// </returns> /// <remarks> /// <para>The outgoing message is the factor viewed as a function of <c>b</c> with <c>productExp</c> integrated out. The formula is <c>sum_productExp p(productExp) factor(productExp,a,b)</c>.</para> /// </remarks> /// <exception cref="ImproperMessageException"> /// <paramref name="ProductExp" /> is not a proper distribution.</exception> /// <exception cref="ImproperMessageException"> /// <paramref name="B" /> is not a proper distribution.</exception> public static NonconjugateGaussian BAverageLogarithm( [SkipIfUniform] Gaussian ProductExp, double A, [Proper] Gaussian B, NonconjugateGaussian to_B, NonconjugateGaussian result) { return(BAverageLogarithm(ProductExp, Gaussian.PointMass(A), B, to_B, result)); }
/// <summary>VMP message to <c>b</c>.</summary> /// <param name="ProductExp">Incoming message from <c>productExp</c>. Must be a proper distribution. If uniform, the result will be uniform.</param> /// <param name="A">Incoming message from <c>a</c>. Must be a proper distribution. If uniform, the result will be uniform.</param> /// <param name="B">Incoming message from <c>b</c>. Must be a proper distribution. If uniform, the result will be uniform.</param> /// <param name="to_B">Previous outgoing message to <c>B</c>.</param> /// <param name="result">Modified to contain the outgoing message.</param> /// <returns> /// <paramref name="result" /> /// </returns> /// <remarks> /// <para>The outgoing message is the exponential of the average log-factor value, where the average is over all arguments except <c>b</c>. Because the factor is deterministic, <c>productExp</c> is integrated out before taking the logarithm. The formula is <c>exp(sum_(a) p(a) log(sum_productExp p(productExp) factor(productExp,a,b)))</c>.</para> /// </remarks> /// <exception cref="ImproperMessageException"> /// <paramref name="ProductExp" /> is not a proper distribution.</exception> /// <exception cref="ImproperMessageException"> /// <paramref name="A" /> is not a proper distribution.</exception> /// <exception cref="ImproperMessageException"> /// <paramref name="B" /> is not a proper distribution.</exception> public static NonconjugateGaussian BAverageLogarithm( [SkipIfUniform] Gaussian ProductExp, [Proper, SkipIfUniform] Gaussian A, [Proper, SkipIfUniform] Gaussian B, NonconjugateGaussian to_B, NonconjugateGaussian result) { if (B.IsPointMass) { return(NonconjugateGaussian.Uniform()); } if (ProductExp.IsPointMass) { return(BAverageLogarithm(ProductExp.Point, A)); } if (!B.IsProper()) { throw new ImproperMessageException(B); } // catch uniform case to avoid 0*Inf if (ProductExp.IsUniform()) { return(NonconjugateGaussian.Uniform()); } double mx, vx, m, v, mz, vz; ProductExp.GetMeanAndVariance(out mz, out vz); A.GetMeanAndVariance(out mx, out vx); B.GetMeanAndVariance(out m, out v); //if (mx * mz < 0) //{ // Console.WriteLine("Warning: mx*mz < 0, setting to uniform"); // result.SetToUniform(); // return result; //} double Ex2 = mx * mx + vx; double grad2_S_m2 = -2 * Ex2 * Math.Exp(2 * m + 2 * v) / vz + mx * mz * Math.Exp(m + .5 * v) / vz; double grad_m = -Ex2 *Math.Exp(2 *m + 2 *v) / vz + mx * mz * Math.Exp(m + .5 * v) / vz; double threshold = 10; double mf, vf, afm1, bf; if (grad2_S_m2 >= -threshold && mx * mz > 0) { mf = Math.Log(mx * mz / Ex2) - 1.5 * v; vf = (mf - m) / grad_m; } else { vf = -1 / grad2_S_m2; mf = m - grad_m / grad2_S_m2; } Gaussian priorG; if (result.IsUniform()) { priorG = B; } else { var prior = new NonconjugateGaussian(); prior.SetToRatio((new NonconjugateGaussian(B)), to_B); priorG = prior.GetGaussian(); } result.MeanTimesPrecision = mf / vf; result.Precision = 1 / vf; var updatedM = new Gaussian(mf, vf) * priorG; m = updatedM.GetMean(); double grad_S2_v2 = -2 * Ex2 * Math.Exp(2 * m + 2 * v) / vz + .25 * mx * mz * Math.Exp(m + .5 * v) / vz; double grad_S_v = -Ex2 *Math.Exp(2 *m + 2 *v) / vz + .5 * mx * mz * Math.Exp(m + .5 * v) / vz; afm1 = -1; bf = -1; if (grad2_S_m2 >= -threshold) { afm1 = -v * v * grad_S2_v2; bf = -grad_S_v + afm1 / v; } if ((afm1 < 0 || bf < 0) && mx * mz > 0) { double v_opt = 2 / 3 * (Math.Log(mx * mz / Ex2 / 2) - m); if (v_opt != v) { bf = v * grad_S_v / (v_opt - v); afm1 = v_opt * bf; } } if (afm1 < 0 || bf < 0) { afm1 = -v * v * grad_S2_v2; bf = -grad_S_v + afm1 / v; } if (afm1 < 0 || bf < 0) { result.Shape = 1; result.Rate = 0; } else { result.Shape = afm1 + 1; result.Rate = bf; } if (!result.IsProper()) { throw new ApplicationException("improper"); } return(result); // REMEMBER TO ADD ENTROPY TERM IN REPLICATE OP }
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")); } }
public static NonconjugateGaussian DNonconjugateAverageLogarithm([Proper] Gamma exp, [Proper, SkipIfUniform] Gaussian d, NonconjugateGaussian result) { var vf = -1.0; var a = exp.Shape; var v_opt = 1.0 / (a - 1.0); var b = exp.Rate; double m = 0.0, v = 0.0; d.GetMeanAndVariance(out m, out v); if (a > 1) { var mf = Math.Log((a - 1) / b) - .5 * v_opt; if (mf != m) { var grad_S_m = -b *Math.Exp(m + v / 2) + a - 1; vf = (mf - m) / grad_S_m; result.MeanTimesPrecision = mf / vf; result.Precision = 1 / vf; } } //m = (mp + prior_mp)/(p + prior_p); if (vf < 0) { result.Precision = b * Math.Exp(m + v / 2); result.MeanTimesPrecision = (m - 1) * result.Precision + a - 1; } double bf = -1, afm1 = -1; if (a <= 1) { v_opt = FindMinimumInV(b * Math.Exp(m)); } if (v_opt != v) { var grad_S_v = -.5 * b * Math.Exp(m + v / 2); bf = v * grad_S_v / (v_opt - v); afm1 = v_opt * bf; } if (afm1 < 0 || bf < 0) { afm1 = b * v * v * Math.Exp(m + v / 2) / 4; bf = b * (1 + v / 2) * Math.Exp(m + v / 2) / 2; } result.Shape = afm1 + 1; result.Rate = bf; if (!result.IsProper()) { throw new ApplicationException("improper message calculated by ExpOp.DNonconjugateAverageLogarithm"); } return(result); }
public static NonconjugateGaussian DAverageLogarithm([Proper] Gamma exp, [Proper, SkipIfUniform] NonconjugateGaussian d, NonconjugateGaussian result) { return(DNonconjugateAverageLogarithm(exp, d.GetGaussian(true), result)); }
public static Gaussian MarginalAverageLogarithm(NonconjugateGaussian[] Uses, Gaussian Def, Gaussian result) { return UsesAverageLogarithm(Uses, Def, result); }
/// <summary> /// VMP message to 'b' /// </summary> /// <param name="ProductExp">Incoming message from 'productExp'. Must be a proper distribution. If uniform, the result will be uniform.</param> /// <param name="A">Constant value for 'a'.</param> /// <param name="B">Incoming message from 'b'. Must be a proper distribution. If uniform, the result will be uniform.</param> /// <param name="to_B">Previous outgoing message to 'B'.</param> /// <param name="result">Modified to contain the outgoing message</param> /// <returns><paramref name="result"/></returns> /// <remarks><para> /// The outgoing message is the factor viewed as a function of 'b' with 'productExp' integrated out. /// The formula is <c>sum_productExp p(productExp) factor(productExp,a,b)</c>. /// </para></remarks> /// <exception cref="ImproperMessageException"><paramref name="ProductExp"/> is not a proper distribution</exception> /// <exception cref="ImproperMessageException"><paramref name="B"/> is not a proper distribution</exception> public static NonconjugateGaussian BAverageLogarithm([SkipIfUniform] Gaussian ProductExp, double A, [Proper] Gaussian B, NonconjugateGaussian to_B, NonconjugateGaussian result) { return BAverageLogarithm(ProductExp, Gaussian.PointMass(A), B, to_B, result); }
/// <summary> /// VMP message to 'b' /// </summary> /// <param name="ProductExp">Incoming message from 'productExp'. Must be a proper distribution. If uniform, the result will be uniform.</param> /// <param name="A">Incoming message from 'a'. Must be a proper distribution. If uniform, the result will be uniform.</param> /// <param name="B">Incoming message from 'b'. Must be a proper distribution. If uniform, the result will be uniform.</param> /// <param name="to_B">Previous outgoing message to 'B'.</param> /// <param name="result">Modified to contain the outgoing message</param> /// <returns><paramref name="result"/></returns> /// <remarks><para> /// The outgoing message is the exponential of the average log-factor value, where the average is over all arguments except 'b'. /// Because the factor is deterministic, 'productExp' is integrated out before taking the logarithm. /// The formula is <c>exp(sum_(a) p(a) log(sum_productExp p(productExp) factor(productExp,a,b)))</c>. /// </para></remarks> /// <exception cref="ImproperMessageException"><paramref name="ProductExp"/> is not a proper distribution</exception> /// <exception cref="ImproperMessageException"><paramref name="A"/> is not a proper distribution</exception> /// <exception cref="ImproperMessageException"><paramref name="B"/> is not a proper distribution</exception> public static NonconjugateGaussian BAverageLogarithm([SkipIfUniform] Gaussian ProductExp, [Proper, SkipIfUniform] Gaussian A, [Proper, SkipIfUniform] Gaussian B, NonconjugateGaussian to_B, NonconjugateGaussian result) { if (B.IsPointMass) return NonconjugateGaussian.Uniform(); if (ProductExp.IsPointMass) return BAverageLogarithm(ProductExp.Point, A); if (!B.IsProper()) throw new ImproperMessageException(B); // catch uniform case to avoid 0*Inf if (ProductExp.IsUniform()) return NonconjugateGaussian.Uniform(); double mx, vx, m, v, mz, vz; ProductExp.GetMeanAndVariance(out mz, out vz); A.GetMeanAndVariance(out mx, out vx); B.GetMeanAndVariance(out m, out v); //if (mx * mz < 0) //{ // Console.WriteLine("Warning: mx*mz < 0, setting to uniform"); // result.SetToUniform(); // return result; //} double Ex2 = mx * mx + vx; double grad2_S_m2 = -2 * Ex2 * Math.Exp(2 * m + 2 * v) / vz + mx * mz * Math.Exp(m + .5 * v) / vz; double grad_m = -Ex2 * Math.Exp(2 * m + 2 * v) / vz + mx * mz * Math.Exp(m + .5 * v) / vz; double threshold = 10; double mf, vf, afm1, bf; if (grad2_S_m2 >= -threshold && mx * mz > 0) { mf = Math.Log(mx * mz / Ex2) - 1.5 * v; vf = (mf - m) / grad_m; } else { vf = -1 / grad2_S_m2; mf = m - grad_m / grad2_S_m2; } Gaussian priorG; if (result.IsUniform()) priorG = B; else { var prior = new NonconjugateGaussian(); prior.SetToRatio((new NonconjugateGaussian(B)), to_B); priorG = prior.GetGaussian(); } result.MeanTimesPrecision = mf / vf ; result.Precision = 1 / vf; var updatedM = new Gaussian(mf,vf) * priorG; m = updatedM.GetMean(); double grad_S2_v2 = -2 * Ex2 * Math.Exp(2 * m + 2 * v) / vz + .25 * mx * mz * Math.Exp(m + .5 * v) / vz; double grad_S_v = -Ex2 * Math.Exp(2 * m + 2 * v) / vz + .5 * mx * mz * Math.Exp(m + .5 * v) / vz; afm1 = -1; bf = -1; if (grad2_S_m2 >= -threshold) { afm1 = -v * v * grad_S2_v2; bf = -grad_S_v + afm1 / v; } if ((afm1 < 0 || bf < 0) && mx * mz > 0) { double v_opt = 2 / 3 * (Math.Log(mx * mz / Ex2 / 2) - m); if (v_opt != v) { bf = v * grad_S_v / (v_opt - v); afm1 = v_opt * bf; } } if (afm1 < 0 || bf < 0) { afm1 = -v * v * grad_S2_v2; bf = -grad_S_v + afm1 / v; } if (afm1 < 0 || bf < 0) { result.Shape = 1; result.Rate = 0; } else { result.Shape = afm1 + 1; result.Rate = bf; } if (!result.IsProper()) throw new ApplicationException("improper"); return result; // REMEMBER TO ADD ENTROPY TERM IN REPLICATE OP }
public static NonconjugateGaussian DNonconjugateAverageLogarithm([Proper] Gamma exp, [Proper, SkipIfUniform] Gaussian d, NonconjugateGaussian result) { var vf = -1.0; var a = exp.Shape; var v_opt = 1.0 / (a - 1.0); var b = exp.Rate; double m = 0.0, v = 0.0; d.GetMeanAndVariance(out m, out v); if (a > 1) { var mf = Math.Log((a - 1) / b) - .5 * v_opt; if (mf != m) { var grad_S_m = -b * Math.Exp(m + v / 2) + a - 1; vf = (mf - m) / grad_S_m; result.MeanTimesPrecision = mf / vf; result.Precision = 1 / vf; } } //m = (mp + prior_mp)/(p + prior_p); if (vf < 0) { result.Precision = b * Math.Exp(m + v / 2); result.MeanTimesPrecision = (m - 1) * result.Precision + a - 1; } double bf = -1, afm1 = -1; if (a <= 1) v_opt = FindMinimumInV(b * Math.Exp(m)); if (v_opt != v) { var grad_S_v = -.5 * b * Math.Exp(m + v / 2); bf = v * grad_S_v / (v_opt - v); afm1 = v_opt * bf; } if (afm1 < 0 || bf < 0) { afm1 = b * v * v * Math.Exp(m + v / 2) / 4; bf = b * (1 + v / 2) * Math.Exp(m + v / 2) / 2; } result.Shape = afm1 + 1; result.Rate = bf; if (!result.IsProper()) throw new ApplicationException("improper message calculated by ExpOp.DNonconjugateAverageLogarithm"); return result; }
public static NonconjugateGaussian DAverageLogarithm([Proper] Gamma exp, [Proper, SkipIfUniform] NonconjugateGaussian d, NonconjugateGaussian result) { return DNonconjugateAverageLogarithm(exp, d.GetGaussian(true), 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); }