public void TestMatrixInverse()
{
//A = new SparseMatrix(2, 2);
//A[0, 0] = 4;
//A[0, 1] = 7;
//A[1, 0] = 2;
//A[1, 1] = 6;
IMatrix Ainv = QRSolver.Invert(A);
IMatrix Ipi = A.Multiply(Ainv);
//for (int row = 0; row < 2; ++row)
//{
// Console.WriteLine(Ipi[row]);
//}
Assert.Equal(A.Identity(3), Ipi);
Ipi = Ainv.Multiply(A);
//for (int row = 0; row < 2; ++row)
//{
// Console.WriteLine(Ipi[row]);
//}
Assert.Equal(A.Identity(3), Ipi);
}
public void TestQRSolver()
{
IVector x = new SparseVector(new double[] { 2, 4, 1 });
IVector b = A.Multiply(x);
IVector x_pi = QRSolver.Solve(A, b);
Assert.Equal(x, x_pi);
}
protected void UpdateStatistics(double[] W)
{
IMatrix AtWA = At.ScalarMultiply(W).Multiply(A);
IMatrix AtWAInv = QRSolver.Invert(AtWA);
int n = AtWAInv.RowCount;
int m = b.Dimension;
for (int i = 0; i < n; ++i)
{
mStats.StandardErrors[i] = System.Math.Sqrt(AtWAInv[i, i]);
for (int j = 0; j < n; ++j)
{
mStats.VCovMatrix[i][j] = AtWAInv[i, j];
}
}
double[] outcomes = new double[m];
for (int i = 0; i < m; i++)
{
double cross_prod = 0;
for (int j = 0; j < n; ++j)
{
cross_prod += A[i, j] * mX[j];
}
mStats.Residuals[i] = b[i] - mLinkFunc.GetInvLink(cross_prod);
outcomes[i] = b[i];
}
mStats.ResidualStdDev = StdDev.GetStdDev(mStats.Residuals, 0);
mStats.ResponseMean = Mean.GetMean(outcomes);
mStats.ResponseVariance = System.Math.Pow(StdDev.GetStdDev(outcomes, mStats.ResponseMean), 2);
mStats.R2 = 1 - mStats.ResidualStdDev * mStats.ResidualStdDev / mStats.ResponseVariance;
mStats.AdjustedR2 = 1 - mStats.ResidualStdDev * mStats.ResidualStdDev / mStats.ResponseVariance * (n - 1) / (n - mX.Length - 1);
}
/// <summary>
/// In this particular instance, it is assumed that W = sigma^(-2) I, that is e is identical and uncorrelated
/// </summary>
/// <param name="A"></param>
/// <param name="b"></param>
/// <param name="x"></param>
public GlmStatistics(double[][] A, double[] b, double[] x)
{
int m = A.GetLength(0);
int n = A.GetLength(1);
mResiduals = new double[m];
for (int i = 0; i < m; ++i)
{
double cross_prod = 0;
for (int j = 0; j < n; ++j)
{
cross_prod += A[i][j] * x[j];
}
mResiduals[i] = b[i] - cross_prod;
}
double residual_mu = 0;
mResidualStdDev = StdDev.GetStdDev(mResiduals, residual_mu);
mResponseMean = Mean.GetMean(b);
mResponseVariance = System.Math.Pow(StdDev.GetStdDev(b, mResponseMean), 2);
// (A.transpose * A).inverse * sigma^2
IMatrix AtA = new SparseMatrix(n, n);
for (int i = 0; i < n; ++i)
{
for (int j = 0; j < n; ++j)
{
double cross_prod = 0;
for (int k = 0; k < m; ++k)
{
cross_prod += A[i][k] * A[k][j];
}
AtA[i, j] = cross_prod;
}
}
IMatrix AtAInv = QRSolver.Invert(AtA);
double sigmaSq = mResidualStdDev * mResidualStdDev;
mVcovMatrix = new double[n][];
for (int i = 0; i < n; ++i)
{
mVcovMatrix[i] = new double[n];
for (int j = 0; j < n; ++j)
{
mVcovMatrix[i][j] = AtAInv[i, j] * sigmaSq;
}
}
mStandardErrors = new double[n];
for (int i = 0; i < n; ++i)
{
mStandardErrors[i] = System.Math.Sqrt(mVcovMatrix[i][i]);
}
mR2 = 1 - sigmaSq / mResponseVariance;
mAdjustedR2 = 1 - sigmaSq / mResponseVariance * (n - 1) / (n - x.Length - 1);
}
public override double[] Solve()
{
int m = A.RowCount;
int n = A.ColCount;
IVector x = new SparseVector(n);
for (int i = 0; i < n; ++i)
{
x[i] = 0;
}
IMatrix W = null;
IMatrix AtWAInv = null;
for (int j = 0; j < mMaxIters; ++j)
{
IVector eta = A.Multiply(x);
IVector z = new SparseVector(m);
double[] g = new double[m];
double[] gprime = new double[m];
for (int k = 0; k < m; ++k)
{
g[k] = mLinkFunc.GetInvLink(eta[k]);
gprime[k] = mLinkFunc.GetInvLinkDerivative(eta[k]);
z[k] = eta[k] + (b[k] - g[k]) / gprime[k];
}
W = A.Identity(m);
for (int k = 0; k < m; ++k)
{
double g_variance = GetVariance(g[k]);
if (g_variance == 0)
{
Environment.Exit(0);
}
W[k, k] = gprime[k] * gprime[k] / g_variance;
}
IVector x_old = x;
IMatrix AtW = At.Multiply(W);
// solve x for At * W * A * x = At * W * z
IMatrix AtWA = AtW.Multiply(A);
AtWAInv = QRSolver.Invert(AtWA);
x = AtWAInv.Multiply(AtW).Multiply(z);
double cost = x.Minus(x_old).Norm(2);
if (j % 10 == 0)
{
Console.WriteLine("Iteration: {0}, Cost: {1}", j, cost);
}
if (cost < mTol)
{
break;
}
}
mX = new double[n];
for (int i = 0; i < n; ++i)
{
mX[i] = x[i];
}
UpdateStatistics(AtWAInv, W);
return(mX);
}
