public void TestFactorialNegative()
{
int k = -1;
long result = MathExtention.Factorial(k);
Assert.AreEqual(result, 0);
}
public void TestFactorialZero()
{
int k = 0;
long result = MathExtention.Factorial(k);
Assert.AreEqual(result, 1);
}
public void TestBinomialCooeficientZero()
{
int n = 0;
int k = 0;
long result = MathExtention.BinomialCoefficient(k, n);
Assert.AreEqual(result, 1);
}
public void TestBinomialCooeficientNegative()
{
int n = -1;
int k = 2;
long result = MathExtention.BinomialCoefficient(k, n);
Assert.AreEqual(result, 0);
}
private void tql2()
{
// This is derived from the Algol procedures tql2, by
// Bowdler, Martin, Reinsch, and Wilkinson, Handbook for
// Auto. Comp., Vol.ii-Linear Algebra, and the corresponding
// Fortran subroutine in EISPACK.
for (int i = 1; i < _cols; i++)
{
_workingEigenVector2[i - 1] = _workingEigenVector2[i];
}
_workingEigenVector2[_cols - 1] = 0.0;
double f = 0.0;
double tst1 = 0.0;
double eps = Math.Pow(2.0, -52.0);
for (int l = 0; l < _cols; l++)
{
// Find small subdiagonal element
tst1 = Math.Max(tst1, Math.Abs(_workingEigenVector1[l]) + Math.Abs(_workingEigenVector2[l]));
int m = l;
while (m < _cols)
{
if (Math.Abs(_workingEigenVector2[m]) <= eps * tst1)
{
break;
}
m++;
}
// If m == l, d[l] is an eigenvalue,
// otherwise, iterate.
if (m > l)
{
int iter = 0;
do
{
iter = iter + 1; // (Could check iteration count here.)
// Compute implicit shift
double g = _workingEigenVector1[l];
double p = (_workingEigenVector1[l + 1] - g) / (2.0 * _workingEigenVector2[l]);
double r = MathExtention.Hypot(p, 1.0);
if (p < 0)
{
r = -r;
}
_workingEigenVector1[l] = _workingEigenVector2[l] / (p + r);
_workingEigenVector1[l + 1] = _workingEigenVector2[l] * (p + r);
double dl1 = _workingEigenVector1[l + 1];
double h = g - _workingEigenVector1[l];
for (int i = l + 2; i < _cols; i++)
{
_workingEigenVector1[i] -= h;
}
f = f + h;
// Implicit QL transformation.
p = _workingEigenVector1[m];
double c = 1.0;
double c2 = c;
double c3 = c;
double el1 = _workingEigenVector2[l + 1];
double s = 0.0;
double s2 = 0.0;
for (int i = m - 1; i >= l; i--)
{
c3 = c2;
c2 = c;
s2 = s;
g = c * _workingEigenVector2[i];
h = c * p;
r = MathExtention.Hypot(p, _workingEigenVector2[i]);
_workingEigenVector2[i + 1] = s * r;
s = _workingEigenVector2[i] / r;
c = p / r;
p = c * _workingEigenVector1[i] - s * g;
_workingEigenVector1[i + 1] = h + s * (c * g + s * _workingEigenVector1[i]);
// Accumulate transformation.
for (int k = 0; k < _cols; k++)
{
h = _eigenVectors[k][i + 1];
_eigenVectors[k][i + 1] = s * _eigenVectors[k][i] + c * h;
_eigenVectors[k][i] = c * _eigenVectors[k][i] - s * h;
}
}
p = (-s) * s2 * c3 * el1 * _workingEigenVector2[l] / dl1;
_workingEigenVector2[l] = s * p;
_workingEigenVector1[l] = c * p;
// Check for convergence.
}while (Math.Abs(_workingEigenVector2[l]) > eps * tst1);
}
_workingEigenVector1[l] = _workingEigenVector1[l] + f;
_workingEigenVector2[l] = 0.0;
}
// Sort eigenvalues and corresponding vectors.
for (int i = 0; i < _cols - 1; i++)
{
int k = i;
double p = _workingEigenVector1[i];
for (int j = i + 1; j < _cols; j++)
{
if (_workingEigenVector1[j] < p)
{
k = j;
p = _workingEigenVector1[j];
}
}
if (k != i)
{
_workingEigenVector1[k] = _workingEigenVector1[i];
_workingEigenVector1[i] = p;
for (int j = 0; j < _cols; j++)
{
p = _eigenVectors[j][i];
_eigenVectors[j][i] = _eigenVectors[j][k];
_eigenVectors[j][k] = p;
}
}
}
}
