public void AssignPValue()
{
var callCount = 1;
double pValue = VariantQualityCalculator.AssignPValue(callCount, 100, 20);
Assert.Equal(0.6321, pValue, 4);
//If observed call count is 0, return 1
callCount = 0;
pValue = VariantQualityCalculator.AssignPValue(callCount, 100, 20);
Assert.Equal(1, pValue, 4);
}
public void Pisces_AssignPValue()
{
List <int[]> SampleValues = new List <int[]>() //coverage,var calls}
{
new int[] { 100, 0 },
new int[] { 100, 1 },
new int[] { 100, 5 },
new int[] { 200, 10 },
new int[] { 500, 25 },
new int[] { 5000, 250 },
};
List <double[]> ReturnedValues = new List <double[]>(); { }//p,Q
foreach (int[] item in SampleValues)
{
double pValue = VariantQualityCalculator.AssignPValue(item[1], item[0], 20);
double Qscore = MathOperations.PtoQ(pValue);
double FinalQValue = VariantQualityCalculator.AssignPoissonQScore(item[1], item[0], 20, 100);
double[] Result = new double[] { pValue, Qscore, FinalQValue };
ReturnedValues.Add(Result);
}
Assert.Equal(ReturnedValues[0][0], 1, 4);
Assert.Equal(ReturnedValues[0][2], 0, 4);
Assert.Equal(ReturnedValues[1][0], 0.6321, 4);
Assert.Equal(ReturnedValues[1][2], 2, 4);
Assert.Equal(ReturnedValues[2][0], 0.003659, 4);
Assert.Equal(ReturnedValues[2][2], 24, 4);
Assert.Equal(ReturnedValues[3][0], 4.65 * Math.Pow(10, -5), 5);
Assert.Equal(ReturnedValues[3][2], 43, 4);
Assert.Equal(ReturnedValues[4][0], 1.599 * Math.Pow(10, -10), 10);
Assert.Equal(ReturnedValues[4][2], 98, 4);
Assert.Equal(ReturnedValues[5][0], 0.0, 10);
Assert.Equal(ReturnedValues[5][2], 100, 4);
}
public void CheckQScoresWithParameters(int depth)
{
var outputFile = Path.Combine(UnitTestPaths.TestDataDirectory, "QScoreCalculations_depth" + depth + ".csv");
if (!Directory.Exists(UnitTestPaths.TestDataDirectory))
{
Directory.CreateDirectory(UnitTestPaths.TestDataDirectory);
}
if (File.Exists(outputFile))
{
File.Delete(outputFile);
}
List <int[]> SampleValues = new List <int[]>()
{
}; //coverage,var calls
double noise = 0.01;
for (int i = 5; i < depth;)
{
SampleValues.Add(new int[] { depth, i });
i = i + 5;
}
List <double[]> BasicReturnedValues = new List <double[]>();
List <double[]> RawReturnedValues = new List <double[]>();
List <double[]> TriangleValues = new List <double[]>();
List <double[]> ChernoffReturnedValues = new List <double[]>();
{ }//p,Q
foreach (int[] item in SampleValues)
{
double pValue = VariantQualityCalculator.AssignPValue(item[1], item[0], 20);
double Qscore = MathOperations.PtoQ(pValue);
double[] Result = new double[] { pValue, Qscore };
BasicReturnedValues.Add(Result);
TriangleValues.Add(
Triangle_AssignQValue(item[0], noise, item[1]));
ChernoffReturnedValues.Add(ChernoffBd_AssignQValue(item[0], noise, item[1] - 1));
RawReturnedValues.Add(new double[]
{ VariantQualityCalculator.AssignRawPoissonQScore(item[1], item[0], 20) });
}
using (StreamWriter sw = new StreamWriter(outputFile))
{
sw.WriteLine("noise, depth, call count,vf, exact p, exact Q, triangle approx, chrenoff approx,new Q");
var excelValuesForDepth500 = GetExcelValuesForDepth500();
var cherValuesForDepth10000 = GetExpectedValuesForDepth10000();
for (int i = 0; i < SampleValues.Count; i++)
{
sw.WriteLine(string.Join(",", noise.ToString(),
SampleValues[i][0].ToString(), SampleValues[i][1].ToString(), ((double)SampleValues[i][1] / SampleValues[i][0]).ToString(),
BasicReturnedValues[i][0], BasicReturnedValues[i][1],
TriangleValues[i][1], ChernoffReturnedValues[i][1], RawReturnedValues[i][0]
));
//check this never goes to NAN over our range
Assert.False(TriangleValues[i][1] == double.NaN);
if ((depth == 500) && (i < 6))//this list only has 6 values, before excel looses its lunch due to precision
{
//noise depth call count exact P exact Q
Assert.Equal(excelValuesForDepth500[i][3], BasicReturnedValues[i][0], 4);
Assert.Equal(excelValuesForDepth500[i][4], BasicReturnedValues[i][1], 4);
}
}
if (depth == 10000)//checks we have a good dynamic range, but have not wandered off much from the limit.
{
Assert.Equal(cherValuesForDepth10000[0][4], ChernoffReturnedValues[1998][1], 4);
Assert.Equal(cherValuesForDepth10000[0][5], RawReturnedValues[1998][0], 4);
double error = (ChernoffReturnedValues[1998][1] - RawReturnedValues[1998][0]) / ChernoffReturnedValues[1998][1];
Assert.True(error <= 0.03);
}
}
}
