public double[,] GetMIps()
{
var averageMI = MIs.Average();
var length = (int)Math.Sqrt(MIs.Length);
Parallel.For(0, length, i =>
{
for (j = 0; j < length; j++)
{
APCs[i, j] = APCs[j, i] = MIs.AverageColumn(i) * MIs.AverageColumn(j) / averageMI;
MIps[i, j] = MIps[j, i] = MIs[i, j] - APCs[i, j];
}
});
Zscores = MIps.CalculateZscore();
return(Zscores);
}
public double[,] getDI()
{
const int q = 21;
var identityTable = new double[_count];
Parallel.For(0, _count, i =>
{
identityTable[i] = GetIdenticalSequences(i);
});
var rawsum = identityTable.Sum(n => 1 / n);
var mEff = Math.Round(rawsum, 2);
MIs = new double[length, length];
var frequencies = new double[length, q];
/////////// LOGIC ////////////////////////
/////////////////////////////// SINGULAR EQ [2] & [1] //////////////////////////////////
Parallel.For(0, length, i =>
{
// Take a row from base if supplied
var index1 = columns != null ? columns[i] : i;
for (j = 0; j < _count; j++)
{
var c = alg[j, index1];
frequencies[i, c.ToInt()] += 1 / identityTable[j];
}
for (j = 0; j < q; j++)
{
if (frequencies[i, j] == 0)
{
continue;
}
var addItem = mEff / q;
// Assume gamma == mEff
var divisor = 2 * mEff;
frequencies[i, j] += addItem;
frequencies[i, j] /= divisor;
}
});
////////////////////////////// PAIRS //////////////////////////////////////
Parallel.For(0, length, column1 =>
{
// Second column
for (column2 = column1 + 1; column2 < length; column2++)
{
// Take from base if supplied
int index1, index2;
if (columns != null)
{
index1 = columns[column1];
index2 = columns[column2];
}
else
{
index1 = column1;
index2 = column2;
}
var frequenciesPairs = new double[q, q];
// For each row
for (var j = 0; j < _count; j++)
{
var c1 = alg[j, index1];
var c2 = alg[j, index2];
var d1 = c1.ToInt();
var d2 = c2.ToInt();
frequenciesPairs[d1, d2] += 1 / identityTable[j];
}
// EQ [1]
for (j = 0; j < q; j++)
{
for (l = 0; l < q; l++)
{
if (frequenciesPairs[j, l] == 0)
{
continue;
}
var addItem = mEff / (q * q);
var divisor = (2 * mEff);
frequenciesPairs[j, l] += addItem;
frequenciesPairs[j, l] /= divisor;
}
}
// EQ [3]
// For every aminoacids combination
for (m = 0; m < q; m++)
{
for (l = 0; l < q; l++)
{
if (frequenciesPairs[m, l] == 0)
{
continue;
}
var number = frequenciesPairs[m, l] /
(frequencies[column1, m] * frequencies[column2, l]);
var log = Math.Log(number, Math.E);
MIs[column1, column2] += frequenciesPairs[m, l] * log;
}
}
MIs[column2, column1] = MIs[column1, column2];
}
});
var Zscores = MIs.CalculateZscore();
return(Zscores);
}
public double[,] GetZscores()
{
/////////// MIs
MIs = new double[_length, _length];
Parallel.For(0, _length, i =>
{
for (j = i + 1; j < _length; j++)
{
// ROWS
int index1, index2;
if (columns != null)
{
index1 = columns[i];
index2 = columns[j];
}
else
{
index1 = i;
index2 = j;
}
var d1 = AminoAcids.GetAminoAcidDictionaryDouble();
var d2 = AminoAcids.GetAminoAcidDictionaryDouble();
var pairs = new double[20, 20];
var total = 0;
for (var k = 0; k < _count; k++)
{
var c1 = alg[k, index1];
var c2 = alg[k, index2];
if (c1.ToInt() == 20 || c2.ToInt() == 20)
{
continue;
}
total++;
pairs[c1.ToInt(), c2.ToInt()]++;
d1[c1]++;
d2[c2]++;
}
var sumHx = d1.Values.Sum(n => n == 0.0 ? 0 : n / total * (Math.Log(n / total, 20)));
var sumHy = d2.Values.Sum(n => n == 0.0 ? 0 : n / total * (Math.Log(n / total, 20)));
var sumHxy = 0.0;
for (k = 0; k < 20; k++)
{
for (l = 0; l < 20; l++)
{
if (pairs[k, l] == 0.0)
{
continue;
}
sumHxy += pairs[k, l] / total * (Math.Log(pairs[k, l] / total) / Math.Log(20));
}
}
// Normalization: / -sumHxy
if (i == j || sumHxy == 0)
{
MIs[i, i] = 0;
}
else
{
MIs[i, j] = MIs[j, i] = (-sumHx - sumHy + sumHxy) / -sumHxy;
}
}
});
var zscores = MIs.CalculateZscore();
return(zscores);
}
