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#

[Previously](https://www.educative.io/courses/fixing-random-techniques-in-c-sharp/discrete-probability-distribution-type-as-a-monad), we mentioned that we will be needing the empty distribution.


# Implementing the Empty Distribution
In this lesson, we will be implementing the Empty Distribution.

```C#
public sealed class Empty<T> : IDiscreteDistribution<T>
{
  public static readonly Empty<T> Distribution = new Empty<T>();
  private Empty() { }
  public T Sample() => throw new Exception(“Cannot sample from empty distribution”);
  public IEnumerable<T> Support() => Enumerable.Empty<T>();
  public int Weight(T t) => 0;
}
```

Now that we have this, we can fix up our other distributions to use it. The `WeightedInteger` factory becomes:

```C#
public static IDiscreteDistribution<int> Distribution(IEnumerable<int> weights)
{
  List<int> w = weights.ToList();

  if (w.Any(x => x < 0))
    throw new ArgumentException();

  if (!w.Any(x => x > 0))
    return Empty<int>.Distribution;

[...]
```

And the `Bernoulli` factory becomes:
```C#
public static IDiscreteDistribution<int> Distribution(int zero, int one)
{
  if (zero < 0 || one < 0)
    throw new ArgumentException();

  if (zero == 0 && one == 0)
    return Empty<int>.Distribution;

[...]
```

And the `StandardDiscreteUniform` factory becomes:

```C#
public static IDiscreteDistribution<int> Distribution(int min, int max)
{
  if (min > max)
    return Empty<int>.Distribution;

[...]
```

And the `Projected` factory becomes:

```C#
public static IDiscreteDistribution<R> Distribution(IDiscreteDistribution<A> underlying, Func<A, R> projection)
{
  var result = new Projected<A, R>(underlying, projection);

  if (result.weights.Count == 0)
    return Empty<R>.Distribution;

[...]
}
```

And one more thing needs to change. Our computation in `SelectMany` assumed that none of the total weights are zero. Easily fixed:

```C#
int lcm = prior.Support()
  .Select(a => likelihood(a).TotalWeight())
  .Where(x => x != 0)
  .LCM();
```

We also have a division by total weight; don’t we have to worry about dividing by zero? Nope. Remember, the empty distribution’s support is the empty sequence, so when we then say:

```
var w = from a in prior.Support()
        let pb = likelihood(a)
        from b in pb.Support()
        group prior.Weight(a) * pb.Weight(b) *
          lcm / pb.TotalWeight()
        by projection(a, b);
```

If `prior.Support()` is empty, then the whole query is empty and so the division is never executed. If `prior.Support()` is not empty but one of the `pb.Support()` is empty then there is nothing from which to compute a group key. We never actually divide by total weight, and so there is no division by zero error to avoid.

That was relatively painless, but it is probably still very unclear why we’d ever need an empty distribution. It seems to be like a little bomb hiding in the program, waiting for someone to sample it. Have we just committed another "null reference" design fault? In a few lessons, we’ll see what benefits justify the costs.

# Implementation

Here is the complete implementation:

> We have added the empty distribution to implementation of the lesson [Discrete Probability Distribution Type as a Monad](https://www.educative.io/courses/fixing-random-techniques-in-c-sharp/discrete-probability-distribution-type-as-a-monad)

The output remains the same, however, some parts of the code have changed.

In this lesson, we will implement the empty distribution.

Empty Distribution

Introduction to System.Random in C#

Introduction to Fixing Random

Fixing Random - Discrete Distribution

Fixing Random - Continuous Distribution

Conclusion

Appendix

Empty Distribution