/// <summary> /// Sets the current array of distributions to the given array of distributions /// </summary> /// <param name="value"></param> public void SetTo(DistributionArray <T> value) { if (IsValueType) { // Array.Copy does not work properly with reference types. if (value.Count != this.Count) { throw new ArgumentException("value.Count (" + value.Count + ") != this.Count (" + this.Count + ")"); } Array.Copy(value.array, array, array.Length); } else { ModifyAll(value.array, delegate(T item, T aItem) { if (object.ReferenceEquals(item, null)) { return((T)aItem.Clone()); } else { item.SetTo(aItem); } return(item); }); } }
public static double EvaluateLn <DistributionType, DomainType>(DistributionArray <DistributionType> darray, DomainType[,] array) where DistributionType : CanGetLogProb <DomainType>, ICloneable, SettableTo <DistributionType>, SettableToUniform, Diffable, SettableToProduct <DistributionType>, SettableToRatio <DistributionType>, SettableToPower <DistributionType>, SettableToWeightedSum <DistributionType>, CanGetLogAverageOf <DistributionType>, CanGetAverageLog <DistributionType> { if (darray.array2D == null) { throw new ArgumentException("DistributionArray has rank " + darray.array.Rank + ", point has rank " + array.Rank); } if (darray.array2D.GetLength(0) != array.GetLength(0)) { throw new ArgumentException("DistributionArray lengths (" + StringUtil.CollectionToString(darray.GetLengths(), ",") + ") do not match array lengths (" + StringUtil.CollectionToString(StringUtil.ArrayDimensions(array), ",") + ")"); } double sum = 0.0; for (int i = 0; i < array.GetLength(0); i++) { for (int j = 0; j < array.GetLength(1); j++) { sum += darray[i, j].GetLogProb(array[i, j]); } } return(sum); }
public static DistributionArray <T> FromCloning(T value, params int[] lengths) { DistributionArray <T> result = FromLength(lengths); result.InitializeTo(value); return(result); }
/// <summary> /// Clones the array and all items in the array. /// </summary> /// <returns>A new DistributionArray.</returns> public object Clone() { Array newArray = (Array)array.Clone(); DistributionArray <T> result = new DistributionArray <T>(newArray); result.ModifyAll(delegate(T item) { return((T)item.Clone()); }); return(result); }
/// <summary> /// Sets the current instance to an array of distributions each element /// of which is a power of the corresponding element in a source distribution array /// </summary> /// <param name="a">The source distribution array</param> /// <param name="exponent">The exponent</param> public void SetToPower(DistributionArray <T> a, double exponent) { ModifyAll(a.array, delegate(T item, T aItem) { item.SetToPower(aItem, exponent); return(item); }); }
/// <summary> /// Sets the current instance to an array of distributions each element /// of which is a product of the corresponding distributions in two given /// distribution arrays /// </summary> /// <param name="a">The first distribution array</param> /// <param name="b">The second distribution array</param> public void SetToProduct(DistributionArray <T> a, DistributionArray <T> b) { ModifyAll(a.array, b.array, delegate(T item, T aItem, T bItem) { item.SetToProduct(aItem, bItem); return(item); }); }
/// <summary> /// Sets the current instance to an array of distributions each element /// of which is a weighted sum of the corresponding distributions in two given /// distribution arrays /// </summary> /// <param name="weight1">The first weight</param> /// <param name="a">The first distribution array</param> /// <param name="weight2">The second weight</param> /// <param name="b">The second distribution array</param> public void SetToSum(double weight1, DistributionArray <T> a, double weight2, DistributionArray <T> b) { ModifyAll(a.array, b.array, delegate(T item, T aItem, T bItem) { item.SetToSum(weight1, aItem, weight2, bItem); return(item); }); }
/// <summary> /// Sets the current instance to an array of distributions each element /// of which is a ratio of the corrresponding distributions in two given /// distribution arrays /// </summary> /// <param name="numerator">The numerator distribution array</param> /// <param name="denominator">The denominator distribution array</param> public void SetToRatio(DistributionArray <T> numerator, DistributionArray <T> denominator) { ModifyAll(numerator.array, denominator.array, delegate(T item, T aItem, T bItem) { item.SetToRatio(aItem, bItem); return(item); }); }
/// <summary> /// The maximum difference in parameter values between this distribution and that distribution /// </summary> /// <param name="that">That distribution</param> /// <returns>The maximum difference</returns> public virtual double MaxDiff(object that) { DistributionArray <T> thatd = that as DistributionArray <T>; if ((object)thatd == null) { return(Double.PositiveInfinity); } return(Distribution.MaxDiff(this.array, thatd.array)); }
public static DistributionArray <T> CloneElementsOf(Array array) { DistributionArray <T> result = new DistributionArray <T>(StringUtil.ArrayDimensions(array)); result.ModifyAll(array, delegate(T item, T aItem) { return((T)aItem.Clone()); }); return(result); }
/// <summary> /// 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>This is also known as the cross entropy. /// For a DistributionArray, this specializes to: /// <c>sum_i sum_x this[i].Evaluate(x)*Math.Log(that[i].Evaluate(x))</c> /// = <c>sum_i this[i].GetAverageLog(that[i])</c> /// </remarks> public double GetAverageLog(DistributionArray <T> that) { double sum = 0.0; ForEach(that.array, delegate(T item, T thatItem) { sum += item.GetAverageLog(thatItem); }); return(sum); }
public static DistributionArray <T> CloneElementsOfCollection(ICollection <T> array) { DistributionArray <T> result = new DistributionArray <T>(array.Count); int i = 0; foreach (T item in array) { result.array1D[i++] = (T)item.Clone(); } return(result); }
/// <summary> /// The maximum difference across all corresponding distributions in /// this distribution array and that distribution array /// </summary> /// <param name="that">That distribution array</param> /// <returns>The maximum difference</returns> public double MaxDiff(object that) { DistributionArray <T> thatd = that as DistributionArray <T>; if ((object)thatd == null) { return(Double.PositiveInfinity); } try { double diff = 0.0; ForEach(thatd.array, delegate(T item, T bItem) { diff = Math.Max(diff, item.MaxDiff(bItem)); }); return(diff); } catch { return(Double.PositiveInfinity); } }
/// <summary> /// Sets the current instance to an array of distributions each element /// of which is a power of the corresponding element in a source distribution array /// </summary> /// <param name="a">The source distribution array</param> /// <param name="exponent">The exponent</param> public void SetToPower(DistributionArray <T> a, double exponent) { Distribution.SetToPower(array, a.array, exponent); }
/// <summary> /// Sets the current instance to an array of distributions each element /// of which is a product of the corresponding distributions in two given /// distribution arrays /// </summary> /// <param name="a">The first distribution array</param> /// <param name="b">The second distribution array</param> public void SetToProduct(DistributionArray <T> a, DistributionArray <T> b) { Distribution.SetToProduct(array, a.array, b.array); }
/// <summary> /// 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>This is also known as the cross entropy. /// For a DistributionArray, this specializes to: /// <c>sum_i sum_x this[i].Evaluate(x)*Math.Log(that[i].Evaluate(x))</c> /// = <c>sum_i this[i].GetAverageLog(that[i])</c> /// </remarks> public double GetAverageLog(DistributionArray <T> that) { return(Distribution.GetAverageLog(array, that.array)); }
/// <summary> /// Copy constructor. /// </summary> /// <param name="that"></param> public DistributionArray(DistributionArray <T> that) : this(that.GetLengths()) { InitializeTo(that); }
/// <summary> /// Sets the current instance to an array of distributions each element /// of which is a weighted sum of the corresponding distributions in two given /// distribution arrays /// </summary> /// <param name="weight1">The first weight</param> /// <param name="a">The first distribution array</param> /// <param name="weight2">The second weight</param> /// <param name="b">The second distribution array</param> public void SetToSum(double weight1, DistributionArray <T> a, double weight2, DistributionArray <T> b) { Distribution.SetToSum(array, weight1, a.array, weight2, b.array); }
public void InitializeTo(DistributionArray <T> that) { if (IsValueType) { //ModifyAll(that.array, delegate(T item, T thatItem) { return thatItem; }); if (array1D != null) { for (int i = 0; i < array1D.Length; i++) { array1D[i] = that.array1D[i]; } } else if (array2D != null) { for (int i = 0; i < array2D.GetLength(0); i++) { for (int j = 0; j < array2D.GetLength(1); j++) { array2D[i, j] = that.array2D[i, j]; } } } else { int[] mIndex = new int[array.Rank]; for (int index = 0; index < Count; index++) { StringUtil.LinearIndexToMultidimensionalIndex(index, strides, mIndex); T item = (T)that.array.GetValue(mIndex); array.SetValue(item, mIndex); } } } else { //ModifyAll(that.array, delegate(T item, T thatItem) { return (T)thatItem.Clone(); }); if (array1D != null) { for (int i = 0; i < array1D.Length; i++) { array1D[i] = (T)that.array1D[i].Clone(); } } else if (array2D != null) { for (int i = 0; i < array2D.GetLength(0); i++) { for (int j = 0; j < array2D.GetLength(1); j++) { array2D[i, j] = (T)that.array2D[i, j].Clone(); } } } else { int[] mIndex = new int[array.Rank]; for (int index = 0; index < Count; index++) { StringUtil.LinearIndexToMultidimensionalIndex(index, strides, mIndex); T item = (T)that.array.GetValue(mIndex); array.SetValue((T)item.Clone(), mIndex); } } } }
public void SetTo(DistributionArray <T> that) { base.SetTo(that); }
/// <summary> /// Sets the current instance to an array of distributions each element /// of which is a ratio of the corrresponding distributions in two given /// distribution arrays /// </summary> /// <param name="numerator">The numerator distribution array</param> /// <param name="denominator">The denominator distribution array</param> public void SetToRatio(DistributionArray <T> numerator, DistributionArray <T> denominator) { Distribution.SetToRatio(array, numerator.array, denominator.array); }