private IEnumerable <RowKeyColKeyValue <string, string, UOPair <char> > > TripleEnumerable(HashSet <string> cidExcludeList, HashSet <string> snpExcludeSet)
{
CounterWithMessages counterWithMessages = new CounterWithMessages(SnpFile, compressionRatio: GZ ? .9 : 0);
using (TextReader textReader =
#if !SILVERLIGHT
GZ ? SnpFile.UnGZip() :
#endif
SnpFile.OpenText())
{
string line;
while (null != (line = textReader.ReadLine()))
{
counterWithMessages.Increment();
string[] field = line.Split('\t');
Helper.CheckCondition(field.Length == 4, "Expect lines of snp file to have four fields. " + line);
string snp = field[0];
string cid = field[1];
string value = field[2];
double confidence = double.Parse(field[3]);
Helper.CheckCondition(value.Length == 2 && value.All(c => "ACTG".Contains(c)), () => "Expect values in snp file to be a pair of ACT or G. " + value);
if (cidExcludeList.Contains(cid) || confidence < MissingThreshold || snpExcludeSet.Contains(snp))
{
continue; //not break;
}
yield return(RowKeyColKeyValue.Create(snp, cid, UOPair.Create(value[0], value[1])));
}
}
counterWithMessages.Finished();
}
public void ValidateDensePairAnsiGetInstance()
{
ParallelOptions parOptObj = new ParallelOptions();
UOPair <char> uoPairObj = new UOPair <char>('?', '?');
DensePairAnsi dpaObj =
DensePairAnsi.CreateEmptyInstance(
new string[] { "R0", "R1", "R2" },
new string[] { "C0", "C1", "C2", "C3" },
uoPairObj);
dpaObj.WriteDensePairAnsi(Constants.FastQTempTxtFileName,
parOptObj);
Assert.AreEqual(4, dpaObj.ColCount);
Assert.AreEqual(3, dpaObj.RowCount);
Assert.AreEqual(3, dpaObj.RowKeys.Count);
Assert.AreEqual(4, dpaObj.ColKeys.Count);
if (File.Exists(Constants.FastQTempTxtFileName))
{
File.Delete(Constants.FastQTempTxtFileName);
}
Console.WriteLine(
"DensePairAnsi BVT : Validation of GetInstance() method successful");
ApplicationLog.WriteLine(
"DensePairAnsi BVT : Validation of GetInstance() method successful");
}
public void ValidateRowKeysPairAnsiGetInstanceFromPairAnsi()
{
ParallelOptions parOptObj = new ParallelOptions();
UOPair<char> uoPairObj = new UOPair<char>('?', '?');
DensePairAnsi dpaObj =
DensePairAnsi.CreateEmptyInstance(
new string[] { "R0", "R1", "R2" },
new string[] { "C0", "C1", "C2", "C3" },
uoPairObj);
dpaObj.WriteDensePairAnsi(Constants.FastQTempTxtFileName,
parOptObj);
using (RowKeysPairAnsi rkaObj =
RowKeysPairAnsi.GetInstanceFromPairAnsi(
Constants.FastQTempTxtFileName, parOptObj))
{
Assert.AreEqual(4, rkaObj.ColCount);
Assert.AreEqual(3, rkaObj.RowCount);
}
if (File.Exists(Constants.FastQTempTxtFileName))
File.Delete(Constants.FastQTempTxtFileName);
ApplicationLog.WriteLine(
"RowKeysPairAnsi BVT : Validation of GetInstanceFromPairAnsi() method successful");
}
public void ValidateRowKeysPairAnsiGetInstanceFromPairAnsiFileAccess()
{
ParallelOptions parOptObj = new ParallelOptions();
UOPair<char> uoPairObj = new UOPair<char>('?', '?');
DensePairAnsi dpaObj =
DensePairAnsi.CreateEmptyInstance(
new string[] { "R0", "R1", "R2" },
new string[] { "C0", "C1", "C2", "C3" },
uoPairObj);
dpaObj.WriteDensePairAnsi(Constants.FastQTempTxtFileName,
parOptObj);
using (RowKeysPairAnsi rkaObj =
RowKeysPairAnsi.GetInstanceFromPairAnsi(
Constants.FastQTempTxtFileName, parOptObj,
FileAccess.ReadWrite, FileShare.ReadWrite))
{
Assert.AreEqual(4, rkaObj.ColCount);
Assert.AreEqual(3, rkaObj.RowCount);
}
if (File.Exists(Constants.FastQTempTxtFileName))
File.Delete(Constants.FastQTempTxtFileName);
Console.WriteLine(
"RowKeysPairAnsi BVT : Validation of GetInstanceFromDenseAnsi(file-access) method successful");
ApplicationLog.WriteLine(
"RowKeysPairAnsi BVT : Validation of GetInstanceFromDenseAnsi(file-access) method successful");
}
public void ValidateDensePairAnsiGetInstanceFromSparseInternal()
{
UOPair <char> uoPairObjMissing = new UOPair <char>('?', '?');
UOPair <char> uoPairObjGood = new UOPair <char>('A', 'T');
RowKeyColKeyValue <string, string, UOPair <char> > rowColKey =
new RowKeyColKeyValue <string, string, UOPair <char> >("R0", "C0", uoPairObjGood);
List <RowKeyColKeyValue <string, string, UOPair <char> > > enumObj =
new List <RowKeyColKeyValue <string, string, UOPair <char> > >();
enumObj.Add(rowColKey);
DensePairAnsi dpaObj = DensePairAnsi.CreateEmptyInstance(
new string[] { "R0" },
new string[] { "C0" },
uoPairObjMissing);
dpaObj.GetInstanceFromSparseInternal(enumObj);
Assert.AreEqual("R0", dpaObj.RowKeys[0]);
Assert.AreEqual("C0", dpaObj.ColKeys[0]);
Assert.AreEqual(0, dpaObj.IndexOfRowKey["R0"]);
Console.WriteLine(
"DensePairAnsi BVT : Validation of GetInstanceFromSparseInternal() method successful");
ApplicationLog.WriteLine(
"DensePairAnsi BVT : Validation of GetInstanceFromSparseInternal() method successful");
}
public void ValidateDensePairAnsiWriteDensePairAnsi()
{
UOPair <char> uoPairObj = new UOPair <char>('?', '?');
KeyValuePair <string, UOPair <char> > keyValPair =
new KeyValuePair <string, UOPair <char> >("R0", uoPairObj);
List <KeyValuePair <string, UOPair <char> > > keyValListObj =
new List <KeyValuePair <string, UOPair <char> > >();
var enumObj = keyValListObj.GroupBy(x => x.Key);
DensePairAnsi dpaObj = DensePairAnsi.GetInstance(enumObj, '?');
ParallelOptions paObj = new ParallelOptions();
dpaObj.WriteDensePairAnsi(Constants.FastQTempTxtFileName, paObj);
DensePairAnsi newDpaObj =
DensePairAnsi.GetInstance(Constants.FastQTempTxtFileName, paObj);
Assert.IsNotNull(newDpaObj);
Console.WriteLine(
"DensePairAnsi BVT : Validation of WriteDensePairAnsi() method successful");
ApplicationLog.WriteLine(
"DensePairAnsi BVT : Validation of WriteDensePairAnsi() method successful");
}
private static LinkedList1 <UOPair <HlaMsr1> > MakeUnphased(UOPair <LinkedList1 <HlaMsr1> > phaseGrounded)
{
LinkedList1 <UOPair <HlaMsr1> > unphased = null;
foreach (var pair in SpecialFunctions.EnumerateTwo(phaseGrounded.First, phaseGrounded.Second))
{
unphased = LinkedList1 <UOPair <HlaMsr1> > .GetInstance(UOPair <HlaMsr1> .GetInstance(pair.Key, pair.Value), unphased);
}
return(unphased);
}
internal static PhasedExpansion GetInstance(UOPair <LinkedList1 <HlaMsr1> > phase, double prob, bool usedLowerResModel, string badHlaNameOrNull)
{
PhasedExpansion phasedExpansion = new PhasedExpansion();
phasedExpansion.Phase = phase;
phasedExpansion.Prob = prob;
phasedExpansion.UsedLowerResModel = usedLowerResModel;
phasedExpansion.BadHlaNameOrNull = badHlaNameOrNull;
return(phasedExpansion);
}
private UOPair <char> StringToUOPairConverter(string pairString)
{
Helper.CheckCondition(pairString.Length == 3 && pairString[1] == ' ' && pairString[0] != '?' && pairString[2] != '?', "expect pair string in tped file to be three characters long with the middle being space and neither of the others being '?'. " + pairString);
if (pairString[0] == '0' || pairString[2] == '0')
{
Helper.CheckCondition(pairString[0] == '0' && pairString[2] == '0', "if either character in a pair string is '0' they should both be. " + pairString);
return(UOPair.Create('?', '?'));
}
return(UOPair.Create(pairString[0], pairString[2]));
}
#pragma warning disable 1591
protected override UOPair <byte> SparseValToStore(string val)
#pragma warning restore 1591
{
Helper.CheckCondition(val.Length == 2, Properties.Resource.ExpectedValToContainTwoCharacters, val.Length);
if (val[0].CompareTo(val[1]) == 1)
{
new MatrixFormatException("The char pairs in the sparse file must be sorted. " + val);
}
UOPair <byte> store = new UOPair <byte>((byte)val[0], (byte)val[1]);
return(store);
}
private static IEnumerable <RowKeyColKeyValue <string, string, UOPair <char> > > TripleSequence(string genomePopFileName)
{
using (TextReader textReader = File.OpenText(genomePopFileName))
{
string firstLine = textReader.ReadLine(); //Ignore first line
Helper.CheckCondition(firstLine != null, "Expect genome pop file to contain at least one line");
string snpLine = textReader.ReadLine();
Helper.CheckCondition(snpLine != null, "Expect genome pop file to contain at least two lines");
string[] snpArray = snpLine.Split(',');
string line;
int cidIndex = -1;
while (null != (line = textReader.ReadLine()))
{
if (line == "pop")
{
continue; //not break
}
++cidIndex;
string cid = string.Format("cid{0}", cidIndex);
throw new Exception("Why did the next line have a ', StringSplitOptions.RemoveEmptyEntries'???");
string[] twoParts = line.Split(new char[] { ',' }, 2);
string[] valueArray = twoParts[1].TrimStart().Split(' ');
Helper.CheckCondition(valueArray.Length == snpArray.Length, "Expect each line to contain one entry per snp. " + cid);
for (int snpIndex = 0; snpIndex < snpArray.Length; ++snpIndex)
{
string value = valueArray[snpIndex];
string snp = snpArray[snpIndex];
switch (value)
{
case "0101":
yield return(RowKeyColKeyValue.Create(snp, cid, UOPair.Create('1', '1')));
break;
case "0102":
case "0201":
yield return(RowKeyColKeyValue.Create(snp, cid, UOPair.Create('1', '2')));
break;
case "0202":
yield return(RowKeyColKeyValue.Create(snp, cid, UOPair.Create('2', '2')));
break;
default:
throw new MatrixFormatException("Illegal value " + value);
}
}
}
}
}
internal void Prenormalize(PidAndHlaSet pidAndHlaSet, Linkdis linkdis)
{
PhaseToLogProb = new Dictionary <UOPair <LinkedList1 <HlaMsr1> >, double>();
UnphaseToLogProb = new Dictionary <LinkedList1 <UOPair <HlaMsr1> >, double>();
LogTotal = double.NegativeInfinity;
BadHlaMsr1NameOrNull = null;
UsedLowerResModel = false;
//CounterWithMessages abstractPhaseCounter = CounterWithMessages.GetInstance("\tabstract phase index = {0}", 1, null);
try
{
foreach (var phaseAbstract in pidAndHlaSet.GetPhasedEnumeration())
{
//abstractPhaseCounter.Increment();
var firstHlaListToProb = linkdis.CreateHlaListToProb(phaseAbstract.First);
var secondHlaListToProb = linkdis.CreateHlaListToProb(phaseAbstract.Second);
if (firstHlaListToProb.Count * secondHlaListToProb.Count > linkdis.CombinationLimit)
{
throw new CombinationLimitException("The combinationLimit was exceeded. " + linkdis.CombinationLimit.ToString());
}
CounterWithMessages groundPhaseCounter = CounterWithMessages.GetInstance("\t\tground phase index = {0}", 1000, null);
foreach (var firstHlaListAndProb in firstHlaListToProb)
{
foreach (var secondHlaListAndProb in secondHlaListToProb)
{
groundPhaseCounter.Increment();
var phaseGrounded = UOPair <LinkedList1 <HlaMsr1> > .GetInstance(firstHlaListAndProb.Key, secondHlaListAndProb.Key);
var unphasedGrounded = MakeUnphased(phaseGrounded);
double prob = firstHlaListAndProb.Value.Key * secondHlaListAndProb.Value.Key;
UsedLowerResModel |= firstHlaListAndProb.Value.Value || secondHlaListAndProb.Value.Value;
double logProb = Math.Log(prob);
LogSum(PhaseToLogProb, phaseGrounded, logProb);
LogSum(UnphaseToLogProb, unphasedGrounded, logProb);
LogTotal = SpecialFunctions.LogSum(LogTotal, logProb);
}
}
}
}
catch (HlaNotInModelException e)
{
CreateNoAnswerAnswer(pidAndHlaSet, e);
}
}
public void ValidateDensePairAnsiCreateEmptyInstance()
{
UOPair <char> uoPairObj = new UOPair <char>('?', '?');
DensePairAnsi dpaObj =
DensePairAnsi.CreateEmptyInstance(
new string[] { "R0", "R1", "R2" },
new string[] { "C0", "C1", "C2", "C3" },
uoPairObj);
Assert.IsNotNull(dpaObj);
ApplicationLog.WriteLine(
"DensePairAnsi BVT : Validation of CreateEmptyInstance() method successful");
}
public void ValidateDensePairAnsiCreateEmptyInstance()
{
UOPair<char> uoPairObj = new UOPair<char>('?', '?');
DensePairAnsi dpaObj =
DensePairAnsi.CreateEmptyInstance(
new string[] { "R0", "R1", "R2" },
new string[] { "C0", "C1", "C2", "C3" },
uoPairObj);
Assert.IsNotNull(dpaObj);
ApplicationLog.WriteLine(
"DensePairAnsi BVT : Validation of CreateEmptyInstance() method successful");
}
/// <summary>
/// Returns true if and only if we know for sure that this genotype matches the given Hla. Returns false if an only if we
/// know for sure that this genotype does not describe the given hla. Otherwise, returns null.
/// </summary>
/// <param name="unambiguousHla"></param>
/// <returns></returns>
public bool?Matches(HlaI unambiguousHla, MixtureSemantics mixtureSemantics = MixtureSemantics.Uncertainty)
{
Helper.CheckCondition <ArgumentException>(!unambiguousHla.IsAmbiguous, "Can only check if you have an uynambiguous Hla");
Tuple <HlaI, HlaI> locus;
switch (unambiguousHla.Locus)
{
case HlaILocus.A:
locus = AAlleles; break;
case HlaILocus.B:
locus = BAlleles; break;
case HlaILocus.C:
locus = CAlleles; break;
default:
throw new Exception("Can't get here.");
}
UOPair <HlaI> locusToCompare = UOPair.Create(locus.Item1, locus.Item2); // easier to treat as unordered pair here, since it will order the nulls.
if (locusToCompare.First == null && locusToCompare.Second == null)
{
return(null); // we know nothing about this locus
}
// note: if one of them is null, it's first. so start with second.
bool?secondIsOther = locusToCompare.Second.Matches(unambiguousHla, mixtureSemantics);
if (secondIsOther.HasValue && secondIsOther.Value)
{
return(true); // if second is a match, then we know it has it.
}
if (locusToCompare.First == null)
{
return(null); //don't know anything about first.
}
bool?firstIsOther = locusToCompare.First.Matches(unambiguousHla, mixtureSemantics);
if (firstIsOther.HasValue && firstIsOther.Value)
{
return(true); // first is a match, so we know we have it
}
if (!firstIsOther.HasValue || !secondIsOther.HasValue)
{
return(null); // neither has it, so if either is missing, we don't know
}
return(false); // if we get here, then both alleles reported false.
}
public static IEnumerable <PidAndHlaSet> GetEnumerationDense(TextReader inputTextReader)
{
foreach (var pidAndHlaRecord in SpecialFunctions.ReadDelimitedFile(inputTextReader, new { pid = "", A1 = "", A2 = "", B1 = "", B2 = "", C1 = "", C2 = "" }, new char[] { '\t' }, true))
{
PidAndHlaSet pidAndHlaSet = new PidAndHlaSet();
pidAndHlaSet.Pid = pidAndHlaRecord.pid;
pidAndHlaSet.WarningSet = new HashSet <string>();
pidAndHlaSet.HlaUopairList = LinkedList1 <UOPair <HlaMsr1> > .GetInstance(
UOPair <HlaMsr1> .GetInstance(CreateHla(pidAndHlaRecord.C1, ref pidAndHlaSet.WarningSet), CreateHla(pidAndHlaRecord.C2, ref pidAndHlaSet.WarningSet)),
UOPair <HlaMsr1> .GetInstance(CreateHla(pidAndHlaRecord.B1, ref pidAndHlaSet.WarningSet), CreateHla(pidAndHlaRecord.B2, ref pidAndHlaSet.WarningSet)),
UOPair <HlaMsr1> .GetInstance(CreateHla(pidAndHlaRecord.A1, ref pidAndHlaSet.WarningSet), CreateHla(pidAndHlaRecord.A2, ref pidAndHlaSet.WarningSet)));
pidAndHlaSet.ClassList = new List <string> {
"C", "B", "A"
};
yield return(pidAndHlaSet);
}
}
public void ValidateDensePairAnsiGetInstanceFromSparseEnum()
{
UOPair <char> uoPairObj = new UOPair <char>('?', '?');
RowKeyColKeyValue <string, string, UOPair <char> > rowColKey =
new RowKeyColKeyValue <string, string, UOPair <char> >("R0", "C0", uoPairObj);
List <RowKeyColKeyValue <string, string, UOPair <char> > > enumObj =
new List <RowKeyColKeyValue <string, string, UOPair <char> > >();
DensePairAnsi dpaObj = DensePairAnsi.GetInstanceFromSparse(enumObj);
Assert.IsNotNull(dpaObj);
Console.WriteLine(
"DensePairAnsi BVT : Validation of GetInstanceFromSparse(Ienum) method successful");
ApplicationLog.WriteLine(
"DensePairAnsi BVT : Validation of GetInstanceFromSparse(Ienum) method successful");
}
private IEnumerable <RowKeyColKeyValue <string, string, UOPair <char> > > TripleEnumerable()
{
CounterWithMessages counterWithMessages = new CounterWithMessages("Reading " + SnpFile.Name, messageIntervalOrNull: 1000);
using (TextReader textReader = SnpFile.OpenText())
{
string headerLine = textReader.ReadLine();
Helper.CheckCondition(headerLine != null, "Expect file to contain a first line");
string[] headerFields = headerLine.Split('\t');
Helper.CheckCondition(headerFields.Length > 0 && headerFields[0] == "", "Expect first column of first line to be blank");
string line;
while (null != (line = textReader.ReadLine()))
{
counterWithMessages.Increment();
string[] fields = line.Split('\t');
Helper.CheckCondition(fields.Length == headerFields.Length, "Expect all lines to have the same # of columns");
string cid = fields[0];
for (int snpIndex = 1; snpIndex < headerFields.Length; ++snpIndex) // start at one to skip over 1st column
{
string snp = headerFields[snpIndex];
string valueInFile = fields[snpIndex];
UOPair <char> uoPair;
if (valueInFile == "-")
{
continue; // not break;
}
else if (valueInFile.Length == 1)
{
char c = valueInFile[0];
Helper.CheckCondition("ACTG".Contains(c), () => "Expect values in snp file to be ACT or G. " + valueInFile);
uoPair = UOPair.Create(c, c);
}
else
{
Helper.CheckCondition(valueInFile.Length == 3 && valueInFile[1] == '/' && "ACTG".Contains(valueInFile[0]) && "ACTG".Contains(valueInFile[2]), () => "Expect longer values in snp file be of the form 'a/b' where a & b are ACT or G");
uoPair = UOPair.Create(valueInFile[0], valueInFile[2]);
}
yield return(RowKeyColKeyValue.Create(snp, cid, uoPair));
}
}
}
}
public static DensePairAnsi GetInstance(
IEnumerable <IGrouping <string, KeyValuePair <string, UOPair <char> > > > snpGroupsCidToNucPairEnumerable)
{
if (snpGroupsCidToNucPairEnumerable == null)
{
throw new ArgumentNullException("snpGroupsCidToNucPairEnumerable");
}
DensePairAnsi densePairAnsi = new DensePairAnsi();
densePairAnsi.ColSerialNumbers = new SerialNumbers <string>();
densePairAnsi.RowKeyToStoreList = new Dictionary <string, List <UOPair <byte> > >();
foreach (var snpGroupsCidToNucPair in snpGroupsCidToNucPairEnumerable)
{
List <UOPair <byte> > storeArray = Enumerable.Repeat(StaticStoreMissingValue, densePairAnsi.ColSerialNumbers.Count).ToList();
string var = snpGroupsCidToNucPair.Key;
densePairAnsi.RowKeyToStoreList.Add(var, storeArray);
foreach (var cidAndNucPair in snpGroupsCidToNucPair)
{
UOPair <char> valPair = cidAndNucPair.Value;
int colIndex = densePairAnsi.ColSerialNumbers.GetNewOrOld(cidAndNucPair.Key);
if (colIndex < storeArray.Count)
{
Helper.CheckCondition(storeArray[colIndex] == StaticStoreMissingValue, () => string.Format(CultureInfo.InvariantCulture, "Each pair of keys, i,e,.<{0},{1}>, should only be seen once", var, cidAndNucPair.Key));
storeArray[colIndex] = densePairAnsi.ValueToStore(valPair);
}
else
{
Debug.Assert(colIndex == storeArray.Count); // real assert
storeArray.Add(densePairAnsi.ValueToStore(valPair));
}
}
storeArray.TrimExcess();
}
densePairAnsi._rowKeys = densePairAnsi.RowKeyToStoreList.Keys.ToList();
densePairAnsi._indexOfRowKey = densePairAnsi.RowKeys.Select((key, index) => new { key, index }).ToDictionary(keyAndIndex => keyAndIndex.key, keyAndIndex => keyAndIndex.index);
return(densePairAnsi);
}
private static PidAndHlaSet CreatePidAndHlaSet(string previousPid, Dictionary <string, List <HlaMsr1> > classToHlaList, HashSet <string> warningSet)
{
SpecialFunctions.CheckCondition(new HashSet <string>(classToHlaList.Keys).SetEquals(new HashSet <string> {
"A", "B", "C"
}), "Expect Hla's for exactly classes A,B, & C. " + previousPid);
SpecialFunctions.CheckCondition(classToHlaList.Values.All(list => list.Count == 2), "Expect two hla lines for each Hla class. " + previousPid);
PidAndHlaSet pidAndHlaSet = new PidAndHlaSet();
pidAndHlaSet.Pid = previousPid;
pidAndHlaSet.WarningSet = warningSet;
pidAndHlaSet.HlaUopairList = LinkedList1 <UOPair <HlaMsr1> > .GetInstance(
UOPair <HlaMsr1> .GetInstance(classToHlaList["C"][0], classToHlaList["C"][1]),
UOPair <HlaMsr1> .GetInstance(classToHlaList["B"][0], classToHlaList["B"][1]),
UOPair <HlaMsr1> .GetInstance(classToHlaList["A"][0], classToHlaList["A"][1]));
pidAndHlaSet.ClassList = new List <string> {
"C", "B", "A"
};
return(pidAndHlaSet);
}
/// <summary>
/// This awkward method is provided for the sake of MatrixFactory. Right now it simply catches exceptions. Should switch and make it fail silently when doesn't work.
/// </summary>
public static bool TryGetInstance(string genomePopFileName, UOPair <char> mustProvide_StaticMissingValue_OrExceptionWillBeThrown, ParallelOptions parallelOptions, out Matrix <string, string, UOPair <char> > paddedPair)
{
paddedPair = null;
if (!mustProvide_StaticMissingValue_OrExceptionWillBeThrown.Equals(DensePairAnsi.StaticMissingValue)) //OK to use Equals because double can't be null
{
Console.Error.WriteLine("Missing value {0} doesn't match expected value {1}", DensePairAnsi.StaticMissingValue, mustProvide_StaticMissingValue_OrExceptionWillBeThrown);
return(false);
}
try
{
paddedPair = DensePairAnsi.GetInstanceFromSparse(TripleSequence(genomePopFileName));
return(true);
}
catch (Exception e)
{
Console.Error.WriteLine(e.Message);
return(false);
}
}
private void CreateNoAnswerAnswer(PidAndHlaSet pidAndHlaSet, HlaNotInModelException e)
{
PhaseToLogProb = new Dictionary <UOPair <LinkedList1 <HlaMsr1> >, double>();
UnphaseToLogProb = new Dictionary <LinkedList1 <UOPair <HlaMsr1> >, double>();
BadHlaMsr1NameOrNull = e.HlaName;
UsedLowerResModel = true;
var phaseGrounded = UOPair <LinkedList1 <HlaMsr1> > .GetInstance(
LinkedList1 <HlaMsr1> .GetInstanceFromList(pidAndHlaSet.HlaUopairList.Select(pair => pair.First).ToList()),
LinkedList1 <HlaMsr1> .GetInstanceFromList(pidAndHlaSet.HlaUopairList.Select(pair => pair.Second).ToList())
);
var unphasedGrounded = pidAndHlaSet.HlaUopairList;
double logProb = double.NaN;
LogSum(PhaseToLogProb, phaseGrounded, logProb);
LogSum(UnphaseToLogProb, unphasedGrounded, logProb);
}
public void ValidateDensePairAnsiGetInstanceIEnum()
{
UOPair <char> uoPairObj = new UOPair <char>('?', '?');
KeyValuePair <string, UOPair <char> > keyValPair =
new KeyValuePair <string, UOPair <char> >("R0", uoPairObj);
List <KeyValuePair <string, UOPair <char> > > keyValListObj =
new List <KeyValuePair <string, UOPair <char> > >();
var enumObj = keyValListObj.GroupBy(x => x.Key);
DensePairAnsi dpaObj = DensePairAnsi.GetInstance(enumObj, '?');
Assert.IsNotNull(dpaObj);
Console.WriteLine(
"DensePairAnsi BVT : Validation of GetInstance(enum, char) method successful");
ApplicationLog.WriteLine(
"DensePairAnsi BVT : Validation of GetInstance(enum, char) method successful");
}
private IEnumerable <RowKeyColKeyValue <string, string, UOPair <char> > > TripleEnumerable()
{
//int? totalLineCountOrNull = null;
//int? messageIntervalOrNull = 10000;
//using (TextReader textReader = SnpFile.OpenText())
//{
// string line = textReader.ReadLine();
// if (null != line || line.Length == 0)
// {
// totalLineCountOrNull = (int?)(SnpFile.Length / (long)(line.Length + 2 /*line end*/));
// messageIntervalOrNull = null;
// }
//}
CounterWithMessages counterWithMessages = new CounterWithMessages(SnpFile); //"Reading " + SnpFile.Name, messageIntervalOrNull, totalLineCountOrNull);
using (TextReader textReader = SnpFile.OpenText())
{
string line;
while (null != (line = textReader.ReadLine()))
{
counterWithMessages.Increment();
string[] field = line.Split('\t');
Helper.CheckCondition(field.Length == 3, "Expect lines of snp file to have three fields. " + line);
string cid = field[0];
string snp = field[1];
string value = field[2];
if (value == "00")
{
continue; //not break;
}
Helper.CheckCondition(value.Length == 2 && value.All(c => "ACTG".Contains(c)), () => "Expect values in snp file to be a pair of ACTG or 00. " + value);
yield return(RowKeyColKeyValue.Create(snp, cid, UOPair.Create(value[0], value[1])));
}
counterWithMessages.Finished();
}
}
//!!! very, very similar to other code
/// <summary>
/// Creates a DensePairAnsi object from a sequence of groupings. A grouping here is a roew
/// </summary>
/// <param name="snpGroupsCidToNucPairEnumerable"></param>
/// <param name="inputsMissingChar"></param>
/// <returns></returns>
public static DensePairAnsi GetInstance(IEnumerable <IGrouping <string, KeyValuePair <string, UOPair <char> > > >
snpGroupsCidToNucPairEnumerable, char inputsMissingChar)
{
DensePairAnsi densePairAnsi = new DensePairAnsi();
densePairAnsi.ColSerialNumbers = new SerialNumbers <string>();
densePairAnsi.RowKeyToStoreList = new Dictionary <string, List <UOPair <byte> > >();
foreach (var snpGroupsCidToNucPair in snpGroupsCidToNucPairEnumerable)
{
//!!!const
List <UOPair <byte> > storeArray = Enumerable.Repeat(StaticStoreMissingValue, densePairAnsi.ColSerialNumbers.Count).ToList();
string var = snpGroupsCidToNucPair.Key;
densePairAnsi.RowKeyToStoreList.Add(var, storeArray);
foreach (var cidAndNucPair in snpGroupsCidToNucPair)
{
UOPair <char> valPair = cidAndNucPair.Value;
int colIndex = densePairAnsi.ColSerialNumbers.GetNewOrOld(cidAndNucPair.Key);
if (colIndex < storeArray.Count)
{
storeArray[colIndex] = densePairAnsi.ValueToStore(valPair);
}
else
{
Debug.Assert(colIndex == storeArray.Count); // real assert
storeArray.Add(densePairAnsi.ValueToStore(valPair));
}
}
storeArray.TrimExcess();
}
densePairAnsi._rowKeys = densePairAnsi.RowKeyToStoreList.Keys.ToList();
densePairAnsi._indexOfRowKey = densePairAnsi.RowKeys.Select((key, index) => new { key, index }).ToDictionary(keyAndIndex => keyAndIndex.key, keyAndIndex => keyAndIndex.index);
return(densePairAnsi);
}
public void ValidateDensePairAnsiGetInstanceFromSparseInternal()
{
UOPair<char> uoPairObjMissing = new UOPair<char>('?', '?');
UOPair<char> uoPairObjGood = new UOPair<char>('A', 'T');
RowKeyColKeyValue<string, string, UOPair<char>> rowColKey =
new RowKeyColKeyValue<string, string, UOPair<char>>("R0", "C0", uoPairObjGood);
List<RowKeyColKeyValue<string, string, UOPair<char>>> enumObj =
new List<RowKeyColKeyValue<string, string, UOPair<char>>>();
enumObj.Add(rowColKey);
DensePairAnsi dpaObj = DensePairAnsi.CreateEmptyInstance(
new string[] { "R0" },
new string[] { "C0" },
uoPairObjMissing);
dpaObj.GetInstanceFromSparseInternal(enumObj);
Assert.AreEqual("R0", dpaObj.RowKeys[0]);
Assert.AreEqual("C0", dpaObj.ColKeys[0]);
Assert.AreEqual(0, dpaObj.IndexOfRowKey["R0"]);
ApplicationLog.WriteLine(
"DensePairAnsi BVT : Validation of GetInstanceFromSparseInternal() method successful");
}
/// <summary>
/// Creates an DensePairAnsi with values missing.
/// </summary>
/// <param name="rowKeySequence">A sequence of row keys. The items will become the RowKeys of the Matrix.</param>
/// <param name="colKeySequence">A sequence of colKeys. The items will come the ColKeys of the Matrix.</param>
/// <param name="missingValue">The special Missing value, which must be (UO '?','?')</param>
/// <returns>A new, empty, DensePairAnsi</returns>
static public DensePairAnsi CreateEmptyInstance(IEnumerable <string> rowKeySequence, IEnumerable <string> colKeySequence, UOPair <char> missingValue)
{
Helper.CheckCondition(missingValue.Equals(StaticMissingValue), "For DensePairAnsi the missingValue must be (UO '?', '?')"); //OK to use Equals because UOPair<char> can't be null.
DensePairAnsi densePairAnsi = new DensePairAnsi();
densePairAnsi.InternalCreateEmptyInstance(rowKeySequence, colKeySequence);
return(densePairAnsi);
}
#pragma warning disable 1591
protected override UOPair <char> StoreToValue(UOPair <byte> store)
#pragma warning restore 1591
{
return(new UOPair <char>((char)store.First, (char)store.Second));
}
internal static UOPair <byte> StaticValueToStore(UOPair <char> value)
{
return(new UOPair <byte>((byte)value.First, (byte)value.Second));
}
#pragma warning disable 1591
protected override UOPair <byte> ValueToStore(UOPair <char> value)
#pragma warning restore 1591
{
return(new UOPair <byte>((byte)value.First, (byte)value.Second));
}
/// <summary>
/// Creates an DensePairAnsi with values missing.
/// </summary>
/// <param name="rowKeySequence">A sequence of row keys. The items will become the RowKeys of the Matrix.</param>
/// <param name="colKeySequence">A sequence of colKeys. The items will come the ColKeys of the Matrix.</param>
/// <param name="missingValue">The special Missing value, which must be (UO '?','?')</param>
/// <returns>A new, empty, DensePairAnsi</returns>
static public DensePairAnsi CreateEmptyInstance(IEnumerable <string> rowKeySequence, IEnumerable <string> colKeySequence, UOPair <char> missingValue)
{
//OK to use Equals because UOPair<char> can't be null.
Helper.CheckCondition(missingValue.Equals(StaticMissingValue), Properties.Resource.DensePairAnsiMissingValueSignatureMustBe);
DensePairAnsi densePairAnsi = new DensePairAnsi();
densePairAnsi.InternalCreateEmptyInstance(rowKeySequence, colKeySequence);
return(densePairAnsi);
}
public StringToUOPairConverter() : base(s => UOPair.Create(s[0], s[1]), pair => string.Format("{0}{1}", pair.First, pair.Second))
{
}
#pragma warning disable 1591
protected override byte[] ValueOrMissingToByteArray(UOPair <char> value)
#pragma warning restore 1591
{
byte[] byteArray = new byte[] { (byte)value.First, (byte)value.Second };
return(byteArray);
}
