/// <summary>
/// Creates a point mass SparseBetaList
/// </summary>
/// <param name="probsTrue"></param>
/// <returns></returns>
public static SparseBetaList PointMass(SparseVector probsTrue)
{
var falseCounts = SparseVector.Constant(probsTrue.Count, double.PositiveInfinity);
SparseBetaList sbl = new SparseBetaList(probsTrue, falseCounts);
return(sbl);
}
/// <summary>
/// The maximum 'difference' between corresponding Beta elements.
/// </summary>
public double MaxDiff(object thatd)
{
SparseBetaList that = (SparseBetaList)thatd;
// differences in true counts
SparseVector trueDiff = SparseVector.Zero(Count);
trueDiff.SetToFunction(TrueCounts, that.TrueCounts, (a, b) => MMath.AbsDiff(a, b));
// differences in false counts
SparseVector falseDiff = SparseVector.Zero(Count);
falseDiff.SetToFunction(FalseCounts, that.FalseCounts, (a, b) => MMath.AbsDiff(a, b));
// max overall difference
return(Math.Max(trueDiff.Max(), falseDiff.Max()));
}
public double GetLogAverageOfPower(SparseBetaList that, double power)
{
throw new NotImplementedException();
}
/// <summary>
/// Gets the expected logarithm of that distribution under this distribution.
/// </summary>
/// <param name="that">The distribution to take the logarithm of.</param>
/// <returns><c>sum_x this.Evaluate(x)*Math.Log(that.Evaluate(x))</c></returns>
/// <remarks>Not yet implemented.</remarks>
public double GetAverageLog(SparseBetaList that)
{
throw new NotImplementedException();
}
/// <summary>
/// Sets this sparse Bernoulli list to the ratio of two others (which must be of the same size)
/// </summary>
/// <param name="numerator"></param>
/// <param name="denominator"></param>
public void SetToRatio(SparseBetaList numerator, SparseBetaList denominator)
{
throw new NotImplementedException();
}
/// <summary>
/// Sets this sparse Bernoulli list to the weighted sum of two others (which must be of the same size)
/// </summary>
/// <param name="weight1"></param>
/// <param name="value1"></param>
/// <param name="weight2"></param>
/// <param name="value2"></param>
public void SetToSum(double weight1, SparseBetaList value1, double weight2, SparseBetaList value2)
{
throw new NotImplementedException();
}
/// <summary>
/// Sets this Beta list to a copy of another Beta list.
/// </summary>
/// <param name="value">The list to copy</param>
public void SetTo(SparseBetaList value)
{
TrueCounts.SetTo(value.TrueCounts);
FalseCounts.SetTo(value.FalseCounts);
}
/// <summary>
/// Sets the parameters to represent the list of sparse Betas raised to some power.
/// </summary>
/// <param name="betaList">The list of Betas</param>
/// <param name="exponent">The exponent</param>
public void SetToPower(SparseBetaList betaList, double exponent)
{
// TODO: handle point masses
TrueCounts.SetToFunction(betaList.TrueCounts, x => exponent * (x - 1) + 1);
FalseCounts.SetToFunction(betaList.FalseCounts, x => exponent * (x - 1) + 1);
}
/// <summary>
/// Sets to the product of two sparse lists of Betas.
/// </summary>
/// <param name="a">The first sparse list of Betas</param>
/// <param name="b">The second sparse list of Betas</param>
/// <remarks>
/// The result may not be proper, i.e. its parameters may be negative.
/// For example, if you multiply Beta(0.1,0.1) by itself you get Beta(-0.8, -0.8).
/// No error is thrown in this case.
/// </remarks>
public void SetToProduct(SparseBetaList a, SparseBetaList b)
{
// TODO: handle point masses
TrueCounts.SetToFunction(a.TrueCounts, b.TrueCounts, (x, y) => x + y - 1);
FalseCounts.SetToFunction(a.FalseCounts, b.FalseCounts, (x, y) => x + y - 1);
}
