private static void dnrm2_test()
//****************************************************************************80
//
// Purpose:
//
// DNRM2_TEST demonstrates DNRM2.
//
// Licensing:
//
// This code is distributed under the GNU LGPL license.
//
// Modified:
//
// 15 May 2006
//
// Author:
//
// John Burkardt
//
{
int N = 5;
int LDA = 10;
//
// These parameters illustrate the fact that matrices are typically
// dimensioned with more space than the user requires.
//
double[] a = new double[LDA * LDA];
double[] x = new double[N];
Console.WriteLine("");
Console.WriteLine("DNRM2_TEST");
Console.WriteLine(" DNRM2 computes the Euclidean norm of a vector.");
Console.WriteLine("");
//
// Compute the euclidean norm of a vector:
//
for (int i = 0; i < N; i++)
{
x[i] = i + 1;
}
Console.WriteLine("");
Console.WriteLine(" X =");
Console.WriteLine("");
for (int i = 0; i < N; i++)
{
Console.WriteLine(" "
+ (i + 1).ToString(CultureInfo.InvariantCulture).PadLeft(6) + " "
+ x[i].ToString(CultureInfo.InvariantCulture).PadLeft(14) + "");
}
Console.WriteLine("");
Console.WriteLine(" The 2-norm of X is " + BLAS1D.dnrm2(N, x, 1) + "");
//
// Compute the euclidean norm of a row or column of a matrix:
//
for (int i = 0; i < N; i++)
{
for (int j = 0; j < N; j++)
{
a[i + j * LDA] = i + 1 + j + 1;
}
}
Console.WriteLine("");
Console.WriteLine(" The 2-norm of row 2 of A is "
+ BLAS1D.dnrm2(N, a, LDA, +1) + "");
Console.WriteLine("");
Console.WriteLine(" The 2-norm of column 2 of A is "
+ BLAS1D.dnrm2(N, a, 1, +0 + 1 * LDA) + "");
}
public static int dchdd(ref double[] r, int ldr, int p, double[] x, ref double[] z, int ldz,
int nz, double[] y, ref double[] rho, ref double[] c, ref double[] s)
//****************************************************************************80
//
// Purpose:
//
// DCHDD downdates an augmented Cholesky decomposition.
//
// Discussion:
//
// DCHDD can also downdate the triangular factor of an augmented QR
// decomposition.
//
// Specifically, given an upper triangular matrix R of order P, a
// row vector X, a column vector Z, and a scalar Y, DCHDD
// determines an orthogonal matrix U and a scalar ZETA such that
//
// (R Z ) (RR ZZ)
// U * ( ) = ( ),
// (0 ZETA) ( X Y)
//
// where RR is upper triangular.
//
// If R and Z have been obtained from the factorization of a least squares
// problem, then RR and ZZ are the factors corresponding to the problem
// with the observation (X,Y) removed. In this case, if RHO
// is the norm of the residual vector, then the norm of
// the residual vector of the downdated problem is
// sqrt ( RHO * RHO - ZETA * ZETA ). DCHDD will simultaneously downdate
// several triplets (Z, Y, RHO) along with R.
//
// For a less terse description of what DCHDD does and how
// it may be applied, see the LINPACK guide.
//
// The matrix U is determined as the product U(1)*...*U(P)
// where U(I) is a rotation in the (P+1,I)-plane of the form
//
// ( C(I) -S(I) )
// ( ).
// ( S(I) C(I) )
//
// The rotations are chosen so that C(I) is real.
//
// The user is warned that a given downdating problem may be impossible
// to accomplish or may produce inaccurate results. For example, this
// can happen if X is near a vector whose removal will reduce the
// rank of R. Beware.
//
// Licensing:
//
// This code is distributed under the GNU LGPL license.
//
// Modified:
//
// 23 June 2009
//
// Author:
//
// Original FORTRAN77 version by Jack Dongarra, Cleve Moler, Jim Bunch,
// Pete Stewart.
// C++ version by John Burkardt.
//
// Reference:
//
// Jack Dongarra, Cleve Moler, Jim Bunch and Pete Stewart,
// LINPACK User's Guide,
// SIAM, (Society for Industrial and Applied Mathematics),
// 3600 University City Science Center,
// Philadelphia, PA, 19104-2688.
// ISBN 0-89871-172-X
//
// Parameters:
//
// Input/output, double R[LDR*P], the upper triangular matrix that
// is to be downdated. The part of R below the diagonal is not referenced.
//
// Input, int LDR, the leading dimension of the array R.
// LDR must be at least P.
//
// Input, int P, the order of the matrix R.
//
// Input, double X[P], the row vector that is to be removed from R.
//
// Input/output, double Z[LDZ*NZ], an array of NZ P-vectors
// which are to be downdated along with R.
//
// Input, int LDZ, the leading dimension of the array Z.
// LDZ must be at least P.
//
// Input, int NZ, the number of vectors to be downdated.
// NZ may be zero, in which case Z, Y, and RHO are not referenced.
//
// Input, double Y[NZ], the scalars for the downdating of
// the vectors Z.
//
// Input/output, double RHO[NZ], the norms of the residual vectors.
// On output these have been changed along with R and Z.
//
// Output, double C[P], S[P], the cosines and sines of the
// transforming rotations.
//
// Output, int DCHDD, return flag.
// 0, the entire downdating was successful.
// -1, if R could not be downdated. In this case, all quantities
// are left unaltered.
// 1, if some RHO could not be downdated. The offending RHO's are
// set to -1.
//
{
int i;
int ii;
int j;
//
// Solve R' * A = X, placing the result in the array S.
//
int info = 0;
s[0] = x[0] / r[0 + 0 * ldr];
for (j = 2; j <= p; j++)
{
s[j - 1] = x[j - 1] - BLAS1D.ddot(j - 1, r, 1, s, 1, xIndex: +0 + (j - 1) * ldr);
s[j - 1] /= r[j - 1 + (j - 1) * ldr];
}
double norm = BLAS1D.dnrm2(p, s, 1);
switch (norm)
{
case >= 1.0:
info = -1;
return(info);
}
double alpha = Math.Sqrt(1.0 - norm * norm);
//
// Determine the transformations.
//
for (ii = 1; ii <= p; ii++)
{
i = p - ii + 1;
double scale = alpha + Math.Abs(s[i - 1]);
double a = alpha / scale;
double b = s[i - 1] / scale;
norm = Math.Sqrt(a * a + b * b);
c[i - 1] = a / norm;
s[i - 1] = b / norm;
alpha = scale * norm;
}
//
// Apply the transformations to R.
//
for (j = 1; j <= p; j++)
{
double xx = 0.0;
for (ii = 1; ii <= j; ii++)
{
i = j - ii + 1;
double t = c[i - 1] * xx + s[i - 1] * r[i - 1 + (j - 1) * ldr];
r[i - 1 + (j - 1) * ldr] = c[i - 1] * r[i - 1 + (j - 1) * ldr] - s[i - 1] * xx;
xx = t;
}
}
//
// If required, downdate Z and RHO.
//
for (j = 1; j <= nz; j++)
{
double zeta = y[j - 1];
for (i = 1; i <= p; i++)
{
z[i - 1 + (j - 1) * ldz] = (z[i - 1 + (j - 1) * ldz] - s[i - 1] * zeta) / c[i - 1];
zeta = c[i - 1] * zeta - s[i - 1] * z[i - 1 + (j - 1) * ldz];
}
double azeta = Math.Abs(zeta);
if (rho[j - 1] < azeta)
{
info = 1;
rho[j - 1] = -1.0;
}
else
{
rho[j - 1] *= Math.Sqrt(1.0 - Math.Pow(azeta / rho[j - 1], 2));
}
}
return(info);
}
