Gain insights into tackling uncertainty in C# programming. Delve into improving System.Random class with powerful techniques for efficient problem-solving and fewer bugs. Discover new language uses.

csharp.tar.gz

ep10

ep11

ep12

ep13

ep14

ep15

ep16

ep17

bonus01

ep18

ep20

ep21

ep22

ep24

ep23

ep25

ep26

ep27

ep28

ep29

ep30

ep31

ep32

ep33

ep34

ep36

ep37

ep38

There are a lot of problems we face in programming that deal with uncertainty, statistics, and probabilities. Unfortunately, the majority of the general-purpose languages that we use on a daily basis don’t provide a great approach to solving them.

This is particularly the case in C# with the System.Random class. The implementations of this class have been pretty poor for some time. System.Random in C# regularly leads to unexpected, buggy outcomes.

If you’re a C# fan who’s looking for new ways to use the language, then this course is for you. It proposes different approaches to improving the System.Random class, providing a number of powerful techniques that solve problems more efficiently and with fewer lines of code.

Fixing Random: Techniques in C#

In the [previous lesson](https://www.educative.io/courses/fixing-random-techniques-in-c-sharp/introduction-to-discrete-distributions), we implemented our first discrete distribution, the *"choose an integer between min and max"* distribution. In this chapter, we will explore easier discrete distributions.

---

## Introduction to Trivial Distribution 
The easiest discrete distribution of all is the **trivial distribution**. Let's have a look at its code:

```C#
public sealed class Singleton<T> : IDiscreteDistribution<T>
{
  private readonly T t;
  public static Singleton<T> Distribution(T t) => new Singleton<T>(t);
  private Singleton(T t) => this.t = t;
  public T Sample() => t;
  public IEnumerable<T> Support()
  {
    yield return t;
  }

  public int Weight(T t) => EqualityComparer<T>.Default.Equals(this.t, t) ? 1 : 0;
  public override string ToString() => $"Singleton[{t}]";
}
```

That is the probability distribution where $100\%$ of the time it returns the same value. You’ll also sometimes see distributions like this called the "Dirac delta" or the "Kronecker delta", but we’re going to call this the *singleton distribution* and be done with it.

> This is the first distribution we’ve seen that does not necessarily have some sort of number as its output. You might be thinking that maybe our distribution type should never have been generic in the first place if the only distributions we are going to come up with are either numeric-valued or trivial. In the next lessons, we’ll see how we can naturally use more complex types in probability distributions.

## Bernoulli Distribution
Let’s look at another *integer-valued* distribution. The **Bernoulli distribution** considers the question "what if we flipped a possibly-unfair coin, and scored 1 for a head and 0 for a tail?" The parameter to the distribution is traditionally the probability of heads in our coin, between $0.0$ and $1.0$. 

```C#
public sealed class Bernoulli : IDiscreteDistribution<int>
{
  public static IDiscreteDistribution<int> Distribution(int zero, int one)
  {
    if (zero < 0 || one < 0 || zero == 0 && one == 0)
      throw new ArgumentException();
    if (zero == 0) return Singleton<int>.Distribution(1);
    if (one == 0) return Singleton<int>.Distribution(0);
    return new Bernoulli(zero, one);
  }

  public int Zero { get; }
  public int One { get; }
  private Bernoulli(int zero, int one)
  {
    this.Zero = zero;
    this.One = one;
  }

  public int Sample() =>
    (SCU.Distribution.Sample() <=
      ((double)Zero) / (Zero + One)) ? 0 : 1;

  public IEnumerable<int> Support() => Enumerable.Range(0, 2);
  public int Weight(int x) => x == 0 ? Zero : x == 1 ? One : 0;
  public override string ToString() => $”Bernoulli[{this.Zero}, {this.One}]”;
}
```
And sure enough, if we graph it out:

```C#
Bernoulli.Distribution(1, 3).Histogram()
```

We get what you’d expect: three times as many heads as tails:
```
0|*************
1|****************************************
```

## Implementation
The following code snippet sums up this lesson:

In the [previous lesson](https://www.educative.io/courses/fixing-random-techniques-in-c-sharp/introduction-to-discrete-distributions), we implemented our first discrete distribution, the *"choose an integer between min and max"* distribution. In this chapter, we will explore easier discrete distributions.

---

# Introduction to Trivial Distribution 
The easiest discrete distribution of all is the **trivial distribution**. Let's have a look at its code:

```C#
public sealed class Singleton<T> : IDiscreteDistribution<T>
{
  private readonly T t;
  public static Singleton<T> Distribution(T t) => new Singleton<T>(t);
  private Singleton(T t) => this.t = t;
  public T Sample() => t;
  public IEnumerable<T> Support()
  {
    yield return t;
  }

  public int Weight(T t) => EqualityComparer<T>.Default.Equals(this.t, t) ? 1 : 0;
  public override string ToString() => $"Singleton[{t}]";
}
```

That is the probability distribution where $100\%$ of the time it returns the same value. You’ll also sometimes see distributions like this called the "Dirac delta" or the "Kronecker delta", but we’re going to call this the *singleton distribution* and be done with it.

> This is the first distribution we’ve seen that does not necessarily have some sort of number as its output. You might be thinking that maybe our distribution type should never have been generic in the first place if the only distributions we are going to come up with are either numeric-valued or trivial. In the next lessons, we’ll see how we can naturally use more complex types in probability distributions.

# Bernoulli Distribution
Let’s look at another *integer-valued* distribution. The **Bernoulli distribution** considers the question "what if we flipped a possibly-unfair coin, and scored 1 for a head and 0 for a tail?" The parameter to the distribution is traditionally the probability of heads in our coin, between $0.0$ and $1.0$. 

```C#
public sealed class Bernoulli : IDiscreteDistribution<int>
{
  public static IDiscreteDistribution<int> Distribution(int zero, int one)
  {
    if (zero < 0 || one < 0 || zero == 0 && one == 0)
      throw new ArgumentException();
    if (zero == 0) return Singleton<int>.Distribution(1);
    if (one == 0) return Singleton<int>.Distribution(0);
    return new Bernoulli(zero, one);
  }

  public int Zero { get; }
  public int One { get; }
  private Bernoulli(int zero, int one)
  {
    this.Zero = zero;
    this.One = one;
  }

  public int Sample() =>
    (SCU.Distribution.Sample() <=
      ((double)Zero) / (Zero + One)) ? 0 : 1;

  public IEnumerable<int> Support() => Enumerable.Range(0, 2);
  public int Weight(int x) => x == 0 ? Zero : x == 1 ? One : 0;
  public override string ToString() => $”Bernoulli[{this.Zero}, {this.One}]”;
}
```
And sure enough, if we graph it out:

```C#
Bernoulli.Distribution(1, 3).Histogram()
```

We get what you’d expect: three times as many heads as tails:
```
0|*************
1|****************************************
```

# Implementation
The following code snippet sums up this lesson:

In this lesson, we will explore the singleton distribution and Bernoulli distribution.

Singleton Distribution

Introduction to System.Random in C#

Introduction to Fixing Random

Fixing Random - Discrete Distribution

Fixing Random - Continuous Distribution

Conclusion

Appendix

Singleton Distribution

Introduction to Trivial Distribution