C# Normal.Samples方法代码示例

        /// <summary>
        /// Returns an array of starting vectors.
        /// </summary>
        /// <param name="maximumNumberOfStartingVectors">The maximum number of starting vectors that should be created.</param>
        /// <param name="numberOfVariables">The number of variables.</param>
        /// <returns>
        ///  An array with starting vectors. The array will never be larger than the
        ///  <paramref name="maximumNumberOfStartingVectors"/> but it may be smaller if
        ///  the <paramref name="numberOfVariables"/> is smaller than 
        ///  the <paramref name="maximumNumberOfStartingVectors"/>.
        /// </returns>
        private static IList<Vector> CreateStartingVectors(int maximumNumberOfStartingVectors, int numberOfVariables)
        {
            // Create no more starting vectors than the size of the problem - 1
            // Get random values and then orthogonalize them with
            // modified Gramm - Schmidt
            var count = NumberOfStartingVectorsToCreate(maximumNumberOfStartingVectors, numberOfVariables);

            // Get a random set of samples based on the standard normal distribution with
            // mean = 0 and sd = 1
            var distribution = new Normal();

            Matrix matrix = new DenseMatrix(numberOfVariables, count);
            for (var i = 0; i < matrix.ColumnCount; i++)
            {
                var samples = new Complex[matrix.RowCount];
                var samplesRe = distribution.Samples().Take(matrix.RowCount).ToArray();
                var samplesIm = distribution.Samples().Take(matrix.RowCount).ToArray();
                for (int j = 0; j < matrix.RowCount; j++)
                {
                    samples[j] = new Complex(samplesRe[j], samplesIm[j]);
                }

                // Set the column
                matrix.SetColumn(i, samples);
            }

            // Compute the orthogonalization.
            var gs = matrix.GramSchmidt();
            var orthogonalMatrix = gs.Q;

            // Now transfer this to vectors
            var result = new List<Vector>();
            for (var i = 0; i < orthogonalMatrix.ColumnCount; i++)
            {
                result.Add((Vector)orthogonalMatrix.Column(i));

                // Normalize the result vector
                result[i].Multiply(1 / result[i].Norm(2), result[i]);
            }

            return result;
        }

 public void CanSampleSequence()
 {
     var n = new Normal();
     var ied = n.Samples();
     ied.Take(5).ToArray();
 }

        public void CanEstimateParameters(double mean, double stddev)
        {
            var original = new Normal(mean, stddev, new Random(100));
            var estimated = Normal.Estimate(original.Samples().Take(10000));

            AssertHelpers.AlmostEqual(mean, estimated.Mean, 2);
            AssertHelpers.AlmostEqual(stddev, estimated.StdDev, 2);
        }