Extends #257 (fixing #256) to QuantumProcessorDispatcher sim as well

Author: yurysudz

src/Simulation/Common/Utils.cs

@@ -2,12 +2,13 @@
 // Licensed under the MIT License.
 
 using Microsoft.Quantum.Simulation.Core;
+using System;
 using System.Collections.Generic;
 using System.Diagnostics;
 
 namespace Microsoft.Quantum.Simulation.Common
 {
-    public class CommonUtils
+    public static class CommonUtils
     {
         /// <summary>
         /// Removes PauliI terms from observable and corresponding qubits from qubits. 
@@ -25,7 +26,7 @@ public static void PruneObservable(IQArray<Pauli> observable, IQArray<Qubit> qub
         /// <summary>
         /// Returns IEnumerable&lt;T&gt; that contains sub-sequence of <paramref name="sequenceToPrune"/>[i], such that <paramref name="sequence"/>[i] is not equal to <paramref name="value"/>.
         /// </summary>
-        public static IEnumerable<T> PrunedSequence<U,T>(IQArray<U> sequence, U value, IQArray<T> sequenceToPrune )
+        public static IEnumerable<T> PrunedSequence<U,T>(IQArray<U> sequence, U value, IQArray<T> sequenceToPrune)
         {
             for (uint i = 0; i < sequence.Length; ++i)
             {
@@ -63,5 +64,19 @@ public static (long, long) Reduce(long numerator, long denominatorPower)
 
             return (numNew, denomPowerNew);
         }
+
+        public static IEnumerable<TResult> SelectAggregates<TSource, TResult>(
+            this IEnumerable<TSource> source,
+            Func<TResult, TSource, TResult> aggregate,
+            TResult initial = default
+        )
+        {
+            var acc = initial;
+            foreach (var element in source)
+            {
+                acc = aggregate(acc, element);
+                yield return acc;
+            }
+        }
     }
 }

src/Simulation/Simulators/QCTraceSimulator/InterfaceUtils.cs

@@ -74,19 +74,5 @@ public static partial class Extensions
         {
             return InterfaceType(t, typeof(IControllable<>));
         }
-        
-        internal static IEnumerable<TResult> SelectAggregates<TSource, TResult>(
-            this IEnumerable<TSource> source,
-            Func<TResult, TSource, TResult> aggregate,
-            TResult initial = default
-        )
-        {
-            var acc = initial;
-            foreach (var element in source)
-            {
-                acc = aggregate(acc, element);
-                yield return acc;
-            }
-        }
     }
 }

src/Simulation/Simulators/QuantumProcessor/random.cs

@@ -3,39 +3,45 @@
 
 using Microsoft.Quantum.Simulation.Core;
 using System;
+using System.Linq;
+using Microsoft.Quantum.Simulation.Common;
 
 namespace Microsoft.Quantum.Simulation.QuantumProcessor
 {
     public partial class QuantumProcessorDispatcher
     {
         public static long SampleDistribution(IQArray<double> unnormalizedDistribution, double uniformZeroOneSample)
         {
-            double total = 0.0;
-            foreach (double prob in unnormalizedDistribution)
+            if (unnormalizedDistribution.Any(prob => prob < 0.0))
             {
-                if (prob < 0)
-                {
-                    throw new ExecutionFailException("Random expects array of non-negative doubles.");
-                }
-                total += prob;
+                throw new ExecutionFailException("Random expects array of non-negative doubles.");
             }
 
+            var total = unnormalizedDistribution.Sum();
             if (total == 0)
             {
                 throw new ExecutionFailException("Random expects array of non-negative doubles with positive sum.");
             }
 
-            double sample = uniformZeroOneSample * total;
-            double sum = unnormalizedDistribution[0];
-            for (int i = 0; i < unnormalizedDistribution.Length - 1; ++i)
-            {
-                if (sum >= sample)
-                {
-                    return i;
-                }
-                sum += unnormalizedDistribution[i];
-            }
-            return unnormalizedDistribution.Length;
+            var sample = uniformZeroOneSample * total;
+
+            return unnormalizedDistribution
+                // Get the unnormalized CDF of the distribution.
+                .SelectAggregates((double acc, double x) => acc + x)
+                // Look for the first index at which the CDF is bigger
+                // than the random sample of 𝑈(0, 1) that we were given
+                // as a parameter.
+                .Select((cumulativeProb, idx) => (cumulativeProb, idx))
+                .Where(item => item.cumulativeProb >= sample)
+                // Cast that index to long, and default to returning
+                // the last item.
+                .Select(
+                    item => (long)item.idx
+                )
+                .DefaultIfEmpty(
+                    unnormalizedDistribution.Length - 1
+                )
+                .First();
         }
 
         public class QuantumProcessorDispatcherRandom : Quantum.Intrinsic.Random