离散均匀分布代码实现_commons math离散均匀分布-CSDN博客

本文链接：https://blog.csdn.net/weixin_42496466/article/details/122106733

public class DiscreteUniformDistribution : DiscreteDistribution
{
private int minValue;

private int maxValue;

public int MinValue => this.minValue;

public int MaxValue => this.maxValue;

public override double Mean => (this.maxValue + this.minValue) / 2;

       public override double Variance
       {
           get
           {
               int num;
               num = this.maxValue - this.minValue;
               return num * num / 12;
           }
       }

public override double Skewness => 0.0;

       public override double Kurtosis
       {
           get
           {
               int num;
               num = this.maxValue - this.minValue;
               return -1.2 * (double)(num * num + 1) / (double)(num * num - 1);
           }
       }

       private void Initialize(int minValue, int maxValue)
       {
           if (maxValue < minValue)
           {
               ThrowException.ArgumentOutOfRange("maxValue");
           }
           this.minValue = minValue;
           this.maxValue = maxValue;
       }

       public static int GetRandomVariate(System.Random random, int minValue, int maxValue)
       {
           if (random == null)
           {
               ThrowException.ArgumentNull("random");
           }
           return new DiscreteUniformDistribution(minValue, maxValue).GetRandomVariate(random);
       }

       public static int GetRandomVariate(System.Random random, int maxValue)
       {
           if (random == null)
           {
               ThrowException.ArgumentNull("random");
           }
           return new DiscreteUniformDistribution(0, maxValue).GetRandomVariate(random);
       }

       public DiscreteUniformDistribution(int maxValue)
       {
           this.Initialize(0, maxValue);
       }

       public DiscreteUniformDistribution(int minValue, int maxValue)
       {
           this.Initialize(minValue, maxValue);
       }

       public DiscreteUniformDistribution(NumericalVariable variable)
       {
           if (variable == null)
           {
               ThrowException.ArgumentNull("variable");
           }
           if (variable.Length == 0)
           {
               throw new InsufficientDataException(1, 0);
           }
           this.minValue = (int)Math.Floor(variable.Minimum);
           this.maxValue = (int)(1.0 + Math.Ceiling(variable.Maximum));
       }

       public override double Probability(int n)
       {
           if (n < this.minValue || n >= this.maxValue)
           {
               return 0.0;
           }
           return 1.0 / (double)(this.maxValue - this.minValue);
       }

       public override double Probability(int lowerBound, int upperBound)
       {
           if (lowerBound < this.minValue)
           {
               lowerBound = this.minValue;
           }
           if (upperBound >= this.maxValue)
           {
               upperBound = this.maxValue;
           }
           if (upperBound < lowerBound)
           {
               return 0.0;
           }
           return (double)(upperBound - lowerBound) / (double)(this.maxValue - this.minValue);
       }

       public override int InverseDistributionFunction(double probability)
       {
           if (probability < 0.0 || probability > 1.0)
           {
               ThrowException.ArgumentOutOfRange("probability");
           }
           if (probability == 1.0)
           {
               return this.maxValue - 1;
           }
           return this.minValue + (int)Math.Floor(probability * (double)(this.maxValue - this.minValue)) - 1;
       }

       public override double DistributionFunction(int n)
       {
           if (n < this.minValue)
           {
               return 0.0;
           }
           if (n >= this.maxValue)
           {
               return 1.0;
           }
           return (double)(n - this.minValue + 1) / (double)(this.maxValue - this.minValue);
       }

       public override int GetRandomVariate(System.Random random)
       {
           if (random == null)
           {
               ThrowException.ArgumentNull("random");
           }
           return random.Next(this.minValue, this.maxValue);
       }

       public Histogram GetExpectedHistogram(double numberOfSamples)
       {
           return base.GetExpectedHistogram(this.minValue, this.maxValue, numberOfSamples);
       }
   }

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