public void ValidateSufficientStatisticsCompareTo()
{
SufficientStatistics suffStat = SufficientStatistics.Parse("1");
SufficientStatistics suffStat2 = SufficientStatistics.Parse("2");
Assert.AreEqual(-1, suffStat.CompareTo(suffStat2));
}
public void ValidateSufficientStatisticsGetHashCode()
{
// Not used anymore - changes with each .NET release.
SufficientStatistics boolStat1 = SufficientStatistics.Parse("1");
Assert.AreEqual(372029325, boolStat1.GetHashCode());
}
public void ValidateBooleanStatisticsTryParse()
{
SufficientStatistics result = null;
BooleanStatistics boolStat = BooleanStatistics.GetInstance(true);
Assert.IsTrue(BooleanStatistics.TryParse("true", out result));
Assert.IsTrue(boolStat.Equals(result));
}
public void ValidateSufficientStatisticsTryParse()
{
SufficientStatistics result = null;
SufficientStatistics continousStat = SufficientStatistics.Parse("1");
Assert.IsTrue(SufficientStatistics.TryParse("1.25658", out result));
Assert.IsFalse(continousStat.Equals(result));
}
public void ValidateDiscreteStatisticsTryParse()
{
SufficientStatistics result = null;
DiscreteStatistics discreteStat = DiscreteStatistics.GetInstance(1);
Assert.IsTrue(DiscreteStatistics.TryParse("1", out result));
Assert.IsTrue(discreteStat.Equals(result));
}
public void ValidateGaussianStatisticsTryParse()
{
SufficientStatistics result = null;
GaussianStatistics gaussStat = GaussianStatistics.GetInstance(1.1, 2.3, 5);
Assert.IsTrue(GaussianStatistics.TryParse("1.1,2.3,5", out result));
Assert.IsTrue(gaussStat.Equals(result));
}
public void ValidateContinuousStatisticsTryParse()
{
SufficientStatistics result = null;
ContinuousStatistics continousStat = ContinuousStatistics.GetInstance(1.25658);
Assert.IsTrue(ContinuousStatistics.TryParse("1.25658", out result));
Assert.IsTrue(continousStat.Equals(result));
}
/// <summary>
/// Compares object with Is Missing.
/// </summary>
/// <param name="stats">Sufficient Statistics.</param>
/// <returns>Returns true if fount equals.</returns>
public override bool Equals(SufficientStatistics stats)
{
if (stats == null)
{
return false;
}
return stats.IsMissing();
}
public void ValidateMissingStatisticsTryParse()
{
SufficientStatistics result = null;
MissingStatistics missingStat = MissingStatistics.GetInstance;
Assert.IsTrue(MissingStatistics.TryParse("?", out result));
Assert.IsTrue(missingStat.Equals(result));
Assert.IsTrue(MissingStatistics.TryParse("missing", out result));
Assert.IsTrue(missingStat.Equals(result));
}
/// <summary>
/// Create Matrix from positional sequence variation.
/// </summary>
/// <typeparam name="TRow">Row type of matrix.</typeparam>
/// <typeparam name="TCol">Column type of matrix</typeparam>
/// <typeparam name="TVal">Value of matrix.</typeparam>
/// <param name="sequences">List of List of positional sequence variation.</param>
/// <param name="headerValues">Values of column headers of matrix</param>
/// <param name="keepOneValueVariables">Keeps variables with single value only.</param>
/// <param name="matrix">The matrix created</param>
/// <returns>True if the function was able to create a matrix from the information in the file; otherwise, false</returns>
private static bool TryCreateMatrix <TRow, TCol, TVal>(
IList <IList <IList <byte> > > sequences,
IEnumerable <string> headerValues,
bool keepOneValueVariables,
out Matrix <TRow, TCol, TVal> matrix)
{
IList <string> columnValues;
int maxLength = sequences.Max(seq => seq.Count);
HashSet <byte>[] positionalAminoAcidDistribution = new HashSet <byte> [maxLength];
foreach (IList <IList <byte> > sequence in sequences)
{
for (int pos = 0; pos < sequence.Count; pos++)
{
if (positionalAminoAcidDistribution[pos] == null)
{
positionalAminoAcidDistribution[pos] = new HashSet <byte>(sequence[pos]);
}
else
{
positionalAminoAcidDistribution[pos].AddNewOrOldRange(sequence[pos]);
}
}
}
IList <List <SufficientStatistics> > statistics = CreateSequenceStatistics(
positionalAminoAcidDistribution,
sequences,
keepOneValueVariables,
out columnValues);
if (ColumnType == WriteType.MultiState)
{
ConvertBinaryToMultistate(statistics, columnValues);
}
SufficientStatistics[,] matrixValues = new SufficientStatistics[statistics.Count, sequences.Count];
for (int i = 0; i < statistics.Count; i++)
{
for (int j = 0; j < sequences.Count; j++)
{
matrixValues[i, j] = statistics[i][j];
}
}
matrix = new DenseMatrix <string, string, SufficientStatistics>(
matrixValues, columnValues, headerValues, MissingStatistics.GetInstance) as DenseMatrix <TRow, TCol, TVal>;
if (matrix == null)
{
return(false);
}
else
{
return(true);
}
}
public void ValidateBooleanStatisticsConvertToBooleanStatistics()
{
BooleanStatistics boolStat1 = BooleanStatistics.GetInstance(true);
SufficientStatistics suffStats = (SufficientStatistics)boolStat1;
Dictionary <string, SufficientStatistics> testSuffStats = new Dictionary <string, SufficientStatistics>();
testSuffStats.Add("Test", suffStats);
Dictionary <string, BooleanStatistics> boolStats = BooleanStatistics.ConvertToBooleanStatistics(testSuffStats);
Assert.AreEqual(boolStat1, boolStats["Test"]);
}
/// <summary>
/// Try Parse the value.
/// </summary>
/// <param name="val">The Value.</param>
/// <param name="result">Sufficient Statistics result.</param>
/// <returns>Returns true if parsed properly.</returns>
new public static bool TryParse(string val, out SufficientStatistics result)
{
result = null;
if (string.IsNullOrEmpty(val) ||
val.Equals("missing", StringComparison.CurrentCultureIgnoreCase) ||
val.Equals("?", StringComparison.CurrentCultureIgnoreCase))
{
result = GetInstance;
}
return result != null;
}
/// <summary>
/// Try Parse.
/// </summary>
/// <param name="val">Value String.</param>
/// <param name="result">Sufficient Statistics.</param>
/// <returns>Return true in parsed properly.</returns>
new public static bool TryParse(string val, out SufficientStatistics result)
{
double valAsDouble;
if (double.TryParse(val, out valAsDouble))
{
result = ContinuousStatistics.GetInstance(valAsDouble);
return true;
}
else
{
result = null;
return false;
}
}
public static bool TryGetDenseAnsiInstance(string filename, SufficientStatistics missingValue, ParallelOptions parallelOptions, out Matrix <string, string, SufficientStatistics> matrix)
{
matrix = null;
Matrix <string, string, char> sscMatrix;
if (!DenseAnsi.TryGetInstance(filename, '?', parallelOptions, out sscMatrix))
{
return(false);
}
matrix = sscMatrix.ConvertValueView(MBT.Escience.ValueConverter.CharToSufficientStatistics, missingValue);
//matrix = sscMatrix.ConvertValueView(new ValueConverter<char, SufficientStatistics>(c => DiscreteStatistics.GetInstance((int)c), ss => (char)ss.AsDiscreteStatistics()), missingValue);
return(true);
}
public void ValidateStatisticsListGetInstance()
{
GaussianStatistics gaussStat = GaussianStatistics.GetInstance(2.33, 1.256, 7);
DiscreteStatistics discreteStat = DiscreteStatistics.GetInstance(1);
StatisticsList statList = StatisticsList.GetInstance(gaussStat);
statList.Add(discreteStat);
SufficientStatistics result = null;
foreach (SufficientStatistics stat in statList)
{
Assert.IsTrue(SufficientStatistics.TryParse(stat.ToString(), out result));
}
}
/// <summary>
/// Try to Parse the value.
/// </summary>
/// <param name="val">The value.</param>
/// <param name="result">Sufficient Statistics result.</param>
/// <returns>Returns true if parsed properly.</returns>
new public static bool TryParse(string val, out SufficientStatistics result)
{
int valAsInt;
if (int.TryParse(val, out valAsInt))
{
result = DiscreteStatistics.GetInstance(valAsInt);
return true;
}
else
{
result = null;
return false;
}
}
public void ValidateContinuousStatisticsEquals()
{
SufficientStatistics suffStat = ContinuousStatistics.GetInstance(2);
ContinuousStatistics continousStat = ContinuousStatistics.GetMissingInstance;
Assert.IsFalse(continousStat.Equals(suffStat));
suffStat = (SufficientStatistics)continousStat;
Assert.IsTrue(continousStat.Equals(suffStat));
continousStat = ContinuousStatistics.GetInstance(1.23565);
suffStat = (SufficientStatistics)continousStat;
Assert.IsTrue(continousStat.Equals(suffStat));
object suffStatObj = (object)continousStat;
Assert.IsTrue(continousStat.Equals(suffStat));
}
public void ValidateMissingStatisticsEquals()
{
SufficientStatistics suffStat = null;
MissingStatistics missingStat = MissingStatistics.GetInstance;
Assert.IsFalse(missingStat.Equals(suffStat));
suffStat = (SufficientStatistics)missingStat;
Assert.IsTrue(missingStat.Equals(suffStat));
missingStat = MissingStatistics.GetInstance;
suffStat = (SufficientStatistics)missingStat;
Assert.IsTrue(missingStat.Equals(suffStat));
object suffStatObj = (object)missingStat;
Assert.IsTrue(missingStat.Equals(suffStat));
}
public void ValidateGaussianStatisticsEquals()
{
SufficientStatistics suffStat = null;
GaussianStatistics gaussStat = GaussianStatistics.GetMissingInstance;
Assert.IsFalse(gaussStat.Equals(suffStat));
suffStat = (SufficientStatistics)gaussStat;
Assert.IsTrue(gaussStat.Equals(suffStat));
gaussStat = GaussianStatistics.GetInstance(1.1, 2.2, 3);
suffStat = (SufficientStatistics)gaussStat;
Assert.IsTrue(gaussStat.Equals(suffStat));
object suffStatObj = (object)gaussStat;
Assert.IsTrue(gaussStat.Equals(suffStat));
}
public void ValidateDiscreteStatisticsEquals()
{
SufficientStatistics suffStat = null;
DiscreteStatistics discreteStat = DiscreteStatistics.GetMissingInstance;
Assert.IsFalse(discreteStat.Equals(suffStat));
suffStat = (SufficientStatistics)discreteStat;
Assert.IsTrue(discreteStat.Equals(suffStat));
discreteStat = DiscreteStatistics.GetInstance(1);
suffStat = (SufficientStatistics)discreteStat;
Assert.IsTrue(discreteStat.Equals(suffStat));
object suffStatObj = (object)discreteStat;
Assert.IsTrue(discreteStat.Equals(suffStat));
}
public void ValidateStatisticsListTryParse()
{
StatisticsList statList = new StatisticsList();
GaussianStatistics gaussStat = GaussianStatistics.GetInstance(2.33, 1.256, 7);
DiscreteStatistics discreteStat = DiscreteStatistics.GetInstance(1);
ContinuousStatistics contStat = ContinuousStatistics.GetInstance(2.333);
MissingStatistics missingStat = MissingStatistics.GetInstance;
BooleanStatistics boolStat = BooleanStatistics.GetInstance(true);
statList.Add(gaussStat);
statList.Add(discreteStat);
statList.Add(contStat);
statList.Add(missingStat);
statList.Add(boolStat);
Assert.AreEqual(5, statList.Count);
SufficientStatistics result = null;
StatisticsList statListSubSequence = (StatisticsList)statList.SubSequence(0, 2);
Assert.IsTrue(StatisticsList.TryParse(statList.ToString(), out result));
Assert.IsTrue(StatisticsList.TryParse(statListSubSequence.ToString(), out result));
}
public void ValidateBooleanStatisticsEquals()
{
SufficientStatistics suffStat = BooleanStatistics.GetInstance(false);
BooleanStatistics boolStat = BooleanStatistics.GetMissingInstance;
Assert.IsFalse(boolStat.Equals(suffStat));
suffStat = (SufficientStatistics)boolStat;
Assert.IsTrue(boolStat.Equals(suffStat));
boolStat = BooleanStatistics.GetInstance(true);
suffStat = (SufficientStatistics)boolStat;
Assert.IsTrue(boolStat.Equals(suffStat));
boolStat = BooleanStatistics.GetInstance(false);
suffStat = (SufficientStatistics)boolStat;
Assert.IsTrue(boolStat.Equals(suffStat));
object suffStatObj = (object)boolStat;
Assert.IsTrue(boolStat.Equals(suffStat));
}
/// <summary>
/// Convert Binary To Multistate.
/// </summary>
/// <param name="statistics">statistics.</param>
/// <param name="columnValues">column Values.</param>
private static void ConvertBinaryToMultistate(IList <List <SufficientStatistics> > statistics, IList <string> columnValues)
{
var multToBinaryPositions = from binaryKey in columnValues
where binaryKey.Contains('@')
let merAndPos = GetMerAndPos(binaryKey)
let pos = (int)merAndPos.Value
group binaryKey by pos into g
select new KeyValuePair <string, IList <string> >
(
g.Key + "@" + g.StringJoin("#").Replace(g.Key + "@", ""),
g.ToList()
);
var nonAaKeys = from key in columnValues
where !key.Contains('@')
select new KeyValuePair <string, IList <string> >(key, new List <string>()
{
key
});
var allKeys = nonAaKeys.Concat(multToBinaryPositions).ToList();
Dictionary <string, List <SufficientStatistics> > values = statistics.Select((key, idx) =>
new KeyValuePair <string, List <SufficientStatistics> >(columnValues[idx], key)).ToDictionary();
columnValues.Clear();
((List <string>)columnValues).AddRange(allKeys.Select(keys => keys.Key));
statistics.Clear();
for (int index = 0; index < allKeys.Count; index++)
{
List <SufficientStatistics> posStatistics = new List <SufficientStatistics>();
for (int index1 = 0; index1 < values.First().Value.Count; index1++)
{
if (allKeys[index].Value.Count == 1)
{
posStatistics.Add(values[allKeys[index].Value.First()][index1]);
}
else
{
int state = 0;
bool valueAdded = false;
foreach (string key in allKeys[index].Value)
{
SufficientStatistics tempValue = values[key][index1];
if (ValueConverters.SufficientStatisticsToInt.ConvertForward(tempValue) == 1)
{
posStatistics.Add(ValueConverters.SufficientStatisticsToInt.ConvertBackward(state));
valueAdded = true;
break;
}
state++;
}
if (!valueAdded)
{
posStatistics.Add(MissingStatistics.GetInstance);
}
}
}
statistics.Add(posStatistics);
}
}
protected void DoLearning(LearningTask learningTask)
{
if (learningTask.LearningState == ComputationState.Done)
{
return;
}
// Grab options.
var options = learningTask.Options;
// Grab training set.
var trainingSet = learningTask.TrainingSet;
// Grab variable names.
var firstObservation = learningTask.TrainingSet.First();
var variableNames = firstObservation.VariableNames;
// Build a starter Bayesian network.
var bn = new BayesianNetwork(learningTask.TrainingSet.Name);
// Build variables for each variable in the training set.
foreach (var variableName in variableNames)
{
var space = trainingSet.Variables.TryFind(variableName).Value;
var rv = new RandomVariable(variableName, space);
bn.AddVariable(rv);
}
// Store in task so that task can send updates to its listeners.
learningTask.BayesianNetwork = bn;
learningTask.LearningState = ComputationState.Computing;
// Build Dirichlet parameters
IDictionary <string, DirichletDistribution> priors = new Dictionary <string, DirichletDistribution>();
foreach (var variableName in variableNames)
{
var space = trainingSet.Variables.TryFind(variableName).Value;
DirichletDistribution prior;
if (options.DistributionDirichletAlpha > 0)
{
prior = new DirichletDistribution();
foreach (var value in space.Values)
{
prior.SetParameter(value, options.DistributionDirichletAlpha);
}
priors[variableName] = prior;
}
}
// Initialize a sufficient statistics.
SufficientStatistics sufficientStatistics
= new SufficientStatistics(trainingSet, Utils.Some(priors));
// Learn structure.
switch (options.Structure)
{
case LearningOptions.StructureEnum.DisconnectedStructure:
break;
case LearningOptions.StructureEnum.RandomStructure:
bn.GenerateStructure(
StructureClass.Random,
Utils.Some(options.StructureSeed),
Utils.Some(options.StructureParentLimit));
break;
case LearningOptions.StructureEnum.TreeStructure:
bn.LearnStructure(
sufficientStatistics,
StructureClass.Tree,
Utils.None <int>(),
Utils.None <int>());
break;
case LearningOptions.StructureEnum.GeneralStructure:
bn.LearnStructure(
sufficientStatistics,
StructureClass.General,
Utils.None <int>(),
Utils.Some(options.StructureParentLimit));
break;
}
// Learn distributions.
bn.LearnDistributions(sufficientStatistics);
// Done.
learningTask.LearningState = ComputationState.Done;
}
protected void DoLearning(LearningTask learningTask)
{
if (learningTask.LearningState == ComputationState.Done)
{
return;
}
// Grab options.
var options = learningTask.Options;
// Grab training set.
var trainingSet = learningTask.TrainingSet;
// Grab variable names.
var firstObservation = learningTask.TrainingSet.First();
var variableNames = firstObservation.VariableNames;
// Build a starter Bayesian network.
var bn = new BayesianNetwork(learningTask.TrainingSet.Name);
// Build variables for each variable in the training set.
foreach (var variableName in variableNames)
{
var space = trainingSet.Variables.TryFind(variableName).Value;
var rv = new RandomVariable(variableName, space);
bn.AddVariable(rv);
}
// Store in task so that task can send updates to its listeners.
learningTask.BayesianNetwork = bn;
learningTask.LearningState = ComputationState.Computing;
// Build Dirichlet parameters
IDictionary<string, DirichletDistribution> priors = new Dictionary<string, DirichletDistribution>();
foreach (var variableName in variableNames)
{
var space = trainingSet.Variables.TryFind(variableName).Value;
DirichletDistribution prior;
if (options.DistributionDirichletAlpha > 0)
{
prior = new DirichletDistribution();
foreach (var value in space.Values)
{
prior.SetParameter(value, options.DistributionDirichletAlpha);
}
priors[variableName] = prior;
}
}
// Initialize a sufficient statistics.
SufficientStatistics sufficientStatistics
= new SufficientStatistics(trainingSet, Utils.Some(priors));
// Learn structure.
switch (options.Structure)
{
case LearningOptions.StructureEnum.DisconnectedStructure:
break;
case LearningOptions.StructureEnum.RandomStructure:
bn.GenerateStructure(
StructureClass.Random,
Utils.Some(options.StructureSeed),
Utils.Some(options.StructureParentLimit));
break;
case LearningOptions.StructureEnum.TreeStructure:
bn.LearnStructure(
sufficientStatistics,
StructureClass.Tree,
Utils.None<int>(),
Utils.None<int>());
break;
case LearningOptions.StructureEnum.GeneralStructure:
bn.LearnStructure(
sufficientStatistics,
StructureClass.General,
Utils.None<int>(),
Utils.Some(options.StructureParentLimit));
break;
}
// Learn distributions.
bn.LearnDistributions(sufficientStatistics);
// Done.
learningTask.LearningState = ComputationState.Done;
}
/// <summary>
/// Try Parse the value.
/// </summary>
/// <param name="val">The Value.</param>
/// <param name="result">Sufficient Statistics result.</param>
/// <returns>Returns true if parsed properly.</returns>
new public static bool TryParse(string val, out SufficientStatistics result)
{
result = null;
if (string.IsNullOrEmpty(val))
{
result = GetMissingInstance;
return false;
}
else
{
string[] fields = val.Split(',');
if (!(fields.Length == 3))
{
return false;
}
double mean, variance;
int sampleSize;
if (double.TryParse(fields[0], out mean) &&
double.TryParse(fields[1], out variance) &&
int.TryParse(fields[2], out sampleSize))
{
result = GaussianStatistics.GetInstance(mean, variance, sampleSize);
return true;
}
return false;
}
}
/// <summary>
/// Compares Sufficient Statistics with Discrete Statistics and Boolean Statistics.
/// </summary>
/// <param name="stats">Sufficient Statistics.</param>
/// <returns>Returns true if equal.</returns>
public override bool Equals(SufficientStatistics stats)
{
if (stats == null)
{
return false;
}
if (IsMissing() && stats.IsMissing())
{
return true;
}
else if (stats is DiscreteStatistics)
{
return this.Value == stats.AsDiscreteStatistics().Value;
}
else if (stats is BooleanStatistics)
{
return this.Value == stats.AsDiscreteStatistics().Value;
}
else
{
return stats.Equals(this);
}
}
/// <summary>
/// Compares Sufficient Statistics.
/// </summary>
/// <param name="stats">Sufficient Statistics.</param>
/// <returns>Returns true if equal.</returns>
public override bool Equals(SufficientStatistics stats)
{
if (stats == null)
{
return false;
}
if (IsMissing() && stats.IsMissing())
{
return true;
}
GaussianStatistics gaussStats = stats.AsGaussianStatistics();
return _mean == gaussStats._mean && _variance == gaussStats._variance && _sampleSize == gaussStats._sampleSize;
}
public void ValidateSufficientStatisticsGetHashCode()
{
SufficientStatistics boolStat1 = SufficientStatistics.Parse("1");
Assert.AreEqual(372029325, boolStat1.GetHashCode());
}
/// <summary>
/// Try converting the given string into SufficientStatistics object.
/// </summary>
/// <param name="val">string to be converted.</param>
/// <param name="result">SufficentStatistics object which corresponding to the given string.</param>
/// <returns>Whether string was successfully converted.</returns>
new public static bool TryParse(string val, out SufficientStatistics result)
{
if (string.IsNullOrEmpty(val))
{
throw new ArgumentNullException("val");
}
result = null;
if (val.Equals("true", StringComparison.CurrentCultureIgnoreCase) || val == "1")
{
result = BooleanStatistics.GetInstance(true);
}
else if (val.Equals("false", StringComparison.CurrentCultureIgnoreCase) || val == "0")
{
result = BooleanStatistics.GetInstance(false);
}
else if (val.Equals("null", StringComparison.CurrentCultureIgnoreCase) || val == "-1")
{
result = BooleanStatistics.GetMissingInstance;
}
return result != null;
}
/// <summary>
/// Compares a given SufficientStatistics object with the current object.
/// </summary>
/// <param name="stats">SufficientStatistics object to be compared</param>
/// <returns>True if both the objects are equal.</returns>
public override bool Equals(SufficientStatistics stats)
{
if (stats == null)
{
throw new ArgumentNullException("stats");
}
if (stats.IsMissing())
{
return IsMissing();
}
else if (stats is BooleanStatistics)
{
return _value == stats.AsBooleanStatistics()._value;
}
else
{
return stats.Equals(this);
}
}
/// <summary>
/// Compares a given SufficientStatistics object with the current object.
/// </summary>
/// <param name="stats">SufficientStatistics object to be compared.</param>
/// <returns>True if both the objects are equal.</returns>
public override bool Equals(SufficientStatistics stats)
{
if (stats == null)
{
throw new ArgumentNullException("stats");
}
if (IsMissing() && stats.IsMissing())
{
return true;
}
return this.AsGaussianStatistics().Equals(stats); // let the most general class decide
}
