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/conditional-probabilistic-reasoning), we concluded that the predicates and projections used by `Where` and `Select` on discrete distributions be *pure* functions: 
1. They must complete normally, produce no side effects, consume no external state, and never change their behavior. 
2. They must produce the same result when called with the same argument, every time. 

If we make these restrictions then we can get some big performance wins out of Where and Select. Let’s see how.

---
# Dealing With the "Long-Running Loop"
The biggest problem we face is that possibly-long-running loop in the `Where`. We are "*rejection sampling*" the distribution, and we know that can take a long time. Is there a way to directly produce a new distribution that can be efficiently sampled?

Of course, there is. Let’s make a helper method:
```C#
public static IDiscreteDistribution<T> ToWeighted<T>(this IEnumerable<T> items, IEnumerable<int> weights)
{
  var list = items.ToList();
  return WeightedInteger.Distribution(weights).Select(i => list[i]);
}
```
There’s an additional helper method that we are going to need in a couple of lessons, so let’s just make it now:

```C#
public static IDiscreteDistribution<T> ToWeighted<T>(this IEnumerable<T> items, 
  params int[] weights) => items.ToWeighted((IEnumerable<int>)weights);
```

And now we can delete our `Conditioned` class altogether, and replace it with:

```C#
public static IDiscreteDistribution<T> Where<T>(this IDiscreteDistribution<T> d, Func<T, bool> predicate)
{
  var s = d.Support().Where(predicate).ToList();
  return s.ToWeighted(s.Select(t => d.Weight(t)));
}
```

Recall that the `WeightedInteger` factory will throw an exception if the support is empty, and return a `Singleton` or `Bernoulli` if its size one or two.

> **Exercise:** We’re doing probabilistic workflows here; it seems strange that we are either 100% rejecting or 100% accepting in `Where`. Can you write an optimized implementation of this method?

```C#
public static IDiscreteDistribution<T> Where<T>
(this IDiscreteDistribution<T> d, Func<T, IDiscreteDistribution<bool>> predicate)
```

>That is, we accept each `T` with a probability distribution given by a probabilistic predicate.



In this lesson we will learn how to implement the conditioned distribution from the previous lesson without using rejection sampling; we want to avoid the possibly-long-running loop.

Efficiently Sampling a Conditioned Distribution

Introduction to System.Random in C#

Introduction to Fixing Random

Fixing Random - Discrete Distribution

Fixing Random - Continuous Distribution

Conclusion

Appendix

Efficiently Sampling a Conditioned Distribution

Dealing With the “Long-Running Loop”