拉普拉斯分布代码实现

public class LaplaceDistribution : ContinuousDistribution
    {
        private double location;

        private double scale;

        public double LocationParameter => this.location;

        public double ScaleParameter => this.scale;

        public override double Mean => this.location;

        public override double Variance => 2.0 * this.scale * this.scale;

        public override double Skewness => 0.0;

        public override double Kurtosis => 3.0;

        public override bool IsSymmetrical => true;

        private void Initialize(double location, double scale)
        {
            this.scale = scale;
            this.location = location;
        }

        public LaplaceDistribution(double location, double scale)
        {
            if (scale <= 0.0)
            {
                ThrowException.ArgumentOutOfRange("scale");
            }
            this.Initialize(location, scale);
        }

        public LaplaceDistribution(NumericalVariable variable)
            : this(variable, EstimationMethod.MaximumLikelihood)
        {
        }

        public LaplaceDistribution(NumericalVariable variable, EstimationMethod method)
        {
            if (variable == null)
            {
                ThrowException.ArgumentNull("variable");
            }
            switch (method)
            {
            case EstimationMethod.Default:
            case EstimationMethod.MaximumLikelihood:
                this.Initialize(variable.Median, variable.GetMedianAbsoluteDeviation());
                break;
            case EstimationMethod.MatchingMoments:
                this.Initialize(variable.Mean, 0.70710678118654757 * variable.StandardDeviation);
                break;
            default:
                ThrowException.ArgumentOutOfRange("method");
                break;
            }
        }

        public override double DistributionFunction(double x)
        {
            x -= this.location;
            if (x <= 0.0)
            {
                return Math.Exp(x / this.scale) / 2.0;
            }
            return 1.0 - Math.Exp((0.0 - x) / this.scale) / 2.0;
        }

        public override double ProbabilityDensityFunction(double x)
        {
            x -= this.location;
            return Math.Exp(0.0 - Math.Abs(x / this.scale)) / (2.0 * Math.Abs(this.scale));
        }

        public override double InverseDistributionFunction(double probability)
        {
            if (probability < 0.0 || probability > 1.0)
            {
                ThrowException.ArgumentOutOfRange("probability");
            }
            if (probability == 0.0)
            {
                return double.NegativeInfinity;
            }
            if (probability == 1.0)
            {
                return double.PositiveInfinity;
            }
            if (probability < 0.5)
            {
                return this.location + this.scale * Math.Log(2.0 * probability);
            }
            return this.location - this.scale * Math.Log(2.0 * (1.0 - probability));
        }

        public override double GetRandomVariate(System.Random random)
        {
            if (random == null)
            {
                ThrowException.ArgumentNull("random");
            }
            double num;
            do
            {
                num = 2.0 * random.NextDouble() - 1.0;
            }
            while (num == 0.0);
            if (num < 0.0)
            {
                return this.location + this.scale * Math.Log(0.0 - num);
            }
            return this.location - this.scale * Math.Log(num);
        }
    }

  如果对您有帮忙，非常感谢您支持一下创造者的付出！

 感谢支持技术分享，请扫码点赞支持：

技术合作交流qq:2401315930