示例#1
0
    public static CorrelationResult correlation_besselj(FullertonLib.BesselData globaldata, FullertonLib.r8BESJ0Data data, int n, double[] rho, double rho0)

    //****************************************************************************80
    //
    //  Purpose:
    //
    //    CORRELATION_BESSELJ evaluates the Bessel J correlation function.
    //
    //  Licensing:
    //
    //    This code is distributed under the GNU LGPL license.
    //
    //  Modified:
    //
    //    11 November 2012
    //
    //  Author:
    //
    //    John Burkardt
    //
    //  Reference:
    //
    //    Petter Abrahamsen,
    //    A Review of Gaussian Random Fields and Correlation Functions,
    //    Norwegian Computing Center, 1997.
    //
    //  Parameters:
    //
    //    Input, int N, the number of arguments.
    //
    //    Input, double RHO[N], the arguments.
    //
    //    Input, double RHO0, the correlation length.
    //
    //    Output, double C[N], the correlations.
    //
    {
        int i;

        double[] c = new double[n];

        for (i = 0; i < n; i++)
        {
            double rhohat = Math.Abs(rho[i]) / rho0;
            c[i] = FullertonLib.r8_besj0(ref globaldata, ref data, rhohat);
        }

        CorrelationResult result = new() { result = c, data = globaldata, j0data = data };

        return(result);
    }
示例#2
0
    public static CorrelationResult correlation_gaussian(FullertonLib.BesselData globaldata, FullertonLib.r8BESJ0Data data, int n, double[] rho, double rho0)

    //****************************************************************************80
    //
    //  Purpose:
    //
    //    CORRELATION_GAUSSIAN evaluates the Gaussian correlation function.
    //
    //  Licensing:
    //
    //    This code is distributed under the GNU LGPL license.
    //
    //  Modified:
    //
    //    11 November 2012
    //
    //  Author:
    //
    //    John Burkardt
    //
    //  Reference:
    //
    //    Petter Abrahamsen,
    //    A Review of Gaussian Random Fields and Correlation Functions,
    //    Norwegian Computing Center, 1997.
    //
    //  Parameters:
    //
    //    Input, int N, the number of arguments.
    //
    //    Input, double RHO[N], the arguments.
    //
    //    Input, double RHO0, the correlation length.
    //
    //    Output, double C[N], the correlations.
    //
    {
        int i;

        double[] c = new double[n];

        for (i = 0; i < n; i++)
        {
            c[i] = Math.Exp(-Math.Pow(rho[i] / rho0, 2));
        }
        return(new CorrelationResult {
            result = c, data = globaldata, j0data = data
        });
    }
示例#3
0
    public static CorrelationResult correlation_damped_sine(FullertonLib.BesselData globaldata, FullertonLib.r8BESJ0Data data, int n, double[] rho, double rho0)

    //****************************************************************************80
    //
    //  Purpose:
    //
    //    CORRELATION_DAMPED_SINE evaluates the damped sine correlation function.
    //
    //  Licensing:
    //
    //    This code is distributed under the GNU LGPL license.
    //
    //  Modified:
    //
    //    11 November 2012
    //
    //  Author:
    //
    //    John Burkardt
    //
    //  Reference:
    //
    //    Petter Abrahamsen,
    //    A Review of Gaussian Random Fields and Correlation Functions,
    //    Norwegian Computing Center, 1997.
    //
    //  Parameters:
    //
    //    Input, int N, the number of arguments.
    //
    //    Input, double RHO[N], the arguments.
    //
    //    Input, double RHO0, the correlation length.
    //
    //    Output, double C[N], the correlations.
    //
    {
        int i;

        double[] c = new double[n];

        for (i = 0; i < n; i++)
        {
            switch (rho[i])
            {
            case 0.0:
                c[i] = 1.0;
                break;

            default:
                double rhohat = Math.Abs(rho[i]) / rho0;
                c[i] = Math.Sin(rhohat) / rhohat;
                break;
            }
        }

        return(new CorrelationResult {
            result = c, data = globaldata, j0data = data
        });
    }
    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);
    }