public static Correlation.CorrelationResult sample_paths_eigen(FullertonLib.BesselData globaldata, FullertonLib.r8BESJ0Data jdata, int n, int n2, double rhomax, double rho0,
                                                                   Func <FullertonLib.BesselData, FullertonLib.r8BESJ0Data, int, double[], double, Correlation.CorrelationResult> correlation, ref typeMethods.r8vecNormalData data, ref int seed)

    //****************************************************************************80
    //
    //  Purpose:
    //
    //    SAMPLE_PATHS_EIGEN: sample paths for stationary correlation functions.
    //
    //  Discussion:
    //
    //    This method uses the eigen-decomposition of the correlation matrix.
    //
    //  Licensing:
    //
    //    This code is distributed under the GNU LGPL license.
    //
    //  Modified:
    //
    //    12 November 2012
    //
    //  Author:
    //
    //    John Burkardt
    //
    //  Parameters:
    //
    //    Input, int N, the number of points on each path.
    //
    //    Input, int N2, the number of paths.
    //
    //    Input, double RHOMAX, the maximum value of RHO.
    //
    //    Input, double RHO0, the correlation length.
    //
    //    Input, double *CORRELATION ( int n, double rho_vec[], double rho0),
    //    the name of the function which evaluates the correlation.
    //
    //    Input/output, int &SEED, a seed for the random number
    //    generator.
    //
    //    Output, double X[N*N2], the sample paths.
    //
    {
        int i;
        int j;
        int k;
        //
        //  Choose N equally spaced sample points from 0 to RHOMAX.
        //
        const double rhomin = 0.0;

        double[] rho_vec = typeMethods.r8vec_linspace_new(n, rhomin, rhomax);
        //
        //  Evaluate the correlation function.
        //
        Correlation.CorrelationResult tr = correlation(globaldata, jdata, n, rho_vec, rho0);
        double[] cor_vec = tr.result;
        globaldata = tr.data;
        jdata      = tr.j0data;
        //
        //  Construct the correlation matrix;
        //
        //  From the vector
        //    [ C(0), C(1), C(2), ... C(N-1) ]
        //  construct the vector
        //    [ C(N-1), ..., C(2), C(1), C(0), C(1), C(2), ...  C(N-1) ]
        //  Every row of the correlation matrix can be constructed by a subvector
        //  of this vector.
        //
        double[] cor = new double[n * n];

        for (j = 0; j < n; j++)
        {
            for (i = 0; i < n; i++)
            {
                k = typeMethods.i4_wrap(Math.Abs(i - j), 0, n - 1);
                cor[i + j * n] = cor_vec[k];
            }
        }

        //
        //  Get the eigendecomposition of COR:
        //
        //    COR = V * D * V'.
        //
        //  Because COR is symmetric, V is orthogonal.
        //
        double[] d = new double[n];
        double[] w = new double[n];
        double[] v = new double[n * n];

        TRED2.tred2(n, cor, ref d, ref w, ref v);

        TQL2.tql2(n, ref d, ref w, v);
        //
        //  We assume COR is non-negative definite, and hence that there
        //  are no negative eigenvalues.
        //
        double dmin = typeMethods.r8vec_min(n, d);

        if (dmin < -Math.Sqrt(typeMethods.r8_epsilon()))
        {
            Console.WriteLine("");
            Console.WriteLine("SAMPLE_PATHS_EIGEN - Warning!");
            Console.WriteLine("  Negative eigenvalues observed as low as " + dmin + "");
        }

        for (i = 0; i < n; i++)
        {
            d[i] = Math.Max(d[i], 0.0);
        }

        //
        //  Compute the eigenvalues of the factor C.
        //
        for (i = 0; i < n; i++)
        {
            d[i] = Math.Sqrt(d[i]);
        }

        //
        //  Compute C, such that C' * C = COR.
        //
        double[] c = new double[n * n];

        for (j = 0; j < n; j++)
        {
            for (i = 0; i < n; i++)
            {
                c[i + j * n] = 0.0;
                for (k = 0; k < n; k++)
                {
                    c[i + j * n] += d[k] * v[i + k * n] * v[j + k * n];
                }
            }
        }

        //
        //  Compute N by N2 independent random normal values.
        //
        double[] r = typeMethods.r8mat_normal_01_new(n, n2, ref data, ref seed);
        //
        //  Multiply to get the variables X which have correlation COR.
        //
        double[] x = typeMethods.r8mat_mm_new(n, n, n2, c, r);

        Correlation.CorrelationResult result = new() { result = x, data = globaldata };

        return(result);
    }
    public static double[] sample_paths2_eigen(int n, int n2, double rhomin, double rhomax,
                                               double rho0, Func <int, int, double[], double[], double, double[]> correlation2, ref typeMethods.r8vecNormalData data, ref int seed)

    //****************************************************************************80
    //
    //  Purpose:
    //
    //    SAMPLE_PATHS2_EIGEN: sample paths for stationary correlation functions.
    //
    //  Discussion:
    //
    //    This method uses the eigen-decomposition of the correlation matrix.
    //
    //  Licensing:
    //
    //    This code is distributed under the GNU LGPL license.
    //
    //  Modified:
    //
    //    12 November 2012
    //
    //  Author:
    //
    //    John Burkardt
    //
    //  Parameters:
    //
    //    Input, int N, the number of points on each path.
    //
    //    Input, int N2, the number of paths.
    //
    //    Input, double RHOMIN, RHOMAX, the range of RHO.
    //
    //    Input, double RHO0, the correlation length.
    //
    //    Input, double *CORRELATION2 ( int m, int n, double s[], double t[],
    //    double rho0 ), the name of the function which evaluates the correlation.
    //
    //    Input/output, int &SEED, a seed for the random number
    //    generator.
    //
    //    Output, double X[N*N2], the sample paths.
    //
    {
        int i;
        int j;

        //
        //  Choose N equally spaced sample points from RHOMIN to RHOMAX.
        //
        double[] s = typeMethods.r8vec_linspace_new(n, rhomin, rhomax);
        //
        //  Evaluate the correlation function.
        //
        double[] cor = correlation2(n, n, s, s, rho0);
        //
        //  Get the eigendecomposition of COR:
        //
        //    COR = V * D * V'.
        //
        //  Because COR is symmetric, V is orthogonal.
        //
        double[] d = new double[n];
        double[] w = new double[n];
        double[] v = new double[n * n];

        TRED2.tred2(n, cor, ref d, ref w, ref v);

        TQL2.tql2(n, ref d, ref w, v);
        //
        //  We assume COR is non-negative definite, and hence that there
        //  are no negative eigenvalues.
        //
        double dmin = typeMethods.r8vec_min(n, d);

        if (dmin < -Math.Sqrt(typeMethods.r8_epsilon()))
        {
            Console.WriteLine("");
            Console.WriteLine("SAMPLE_PATHS2_EIGEN - Warning!");
            Console.WriteLine("  Negative eigenvalues observed as low as " + dmin + "");
        }

        for (i = 0; i < n; i++)
        {
            d[i] = Math.Max(d[i], 0.0);
        }

        //
        //  Compute the eigenvalues of the factor C.
        //
        for (i = 0; i < n; i++)
        {
            d[i] = Math.Sqrt(d[i]);
        }

        //
        //  Compute C, such that C' * C = COR.
        //
        double[] c = new double[n * n];

        for (j = 0; j < n; j++)
        {
            for (i = 0; i < n; i++)
            {
                c[i + j * n] = 0.0;
                int k;
                for (k = 0; k < n; k++)
                {
                    c[i + j * n] += d[k] * v[i + k * n] * v[j + k * n];
                }
            }
        }

        //
        //  Compute N by N2 independent random normal values.
        //
        double[] r = typeMethods.r8mat_normal_01_new(n, n2, ref data, ref seed);
        //
        //  Multiply to get the variables X which have correlation COR.
        //
        double[] x = typeMethods.r8mat_mm_new(n, n, n2, c, r);

        return(x);
    }