Program.cs

// Copyright (c) Microsoft Corporation. All rights reserved.
// Licensed under the MIT License.

using System;
using Microsoft.Quantum.Simulation.Simulators;
using Microsoft.Quantum.Simulation.Core;

namespace Microsoft.Quantum.Samples.IntegerFactorization
{
 /// <summary>
 /// This is a Console program that runs Shor's algorithm 
 /// on a Quantum Simulator.
 /// </summary>
 class Program
 {
 // The console application takes up to three arguments
 // 1. numberToFactor -- number to be factored 
 // 2. nTrials -- number of trial to perform 
 // 3. useRobustPhaseEstimation -- if true uses Robust Phase Estimation, 
 // uses Quantum Phase Estimation otherwise.
 // If you build the Debug configuration, the executable will be located in 
 // Libraries\Samples\IntegerFactorization\bin\Debug\ folder;
 // for the Release configuration the folder is 
 // Libraries\Samples\IntegerFactorization\bin\Release.
 // The name of the executable is IntegerFactorization.exe.
 static void Main(string[] args)
 {
 // Default values used if no arguments are provided
 long numberToFactor = 15;
 long nTrials = 100;
 bool useRobustPhaseEstimation = true;

 // Parse the arguments provided in command line
 if( args.Length >= 1 )
 {
 // The first argument is the number to factor
 Int64.TryParse(args[0], out numberToFactor);
 }

 if (args.Length >= 2 )
 {
 // The second is the number of trials 
 Int64.TryParse(args[1], out nTrials);
 }

 if (args.Length >= 3)
 {
 // The third argument indicates if Robust or Quantum Phase Estimation 
 // should be used
 bool.TryParse(args[2], out useRobustPhaseEstimation);
 }

 // Repeat Shor's algorithm multiple times as the algorithm is 
 // probabilistic and there are several ways that it can fail.
 for (int i = 0; i < nTrials; ++i)
 {
 try
 {
 // Make sure to use simulator within using block. 
 // This ensures that all resources used by QuantumSimulator
 // are properly released if the algorithm fails and throws an exception.
 using (QuantumSimulator sim = new QuantumSimulator())
 {
 // Report the number being factored to the standard output
 Console.WriteLine($"==========================================");
 Console.WriteLine($"Factoring {numberToFactor}");

 // Compute the factors
 (long factor1, long factor2) = 
 Shor.Run(sim, numberToFactor, useRobustPhaseEstimation).Result;

 Console.WriteLine($"Factors are {factor1} and {factor2}");
 }
 }
 // Shor's algorithm is a probabilistic algorithm and can fail with certain 
 // probability in several ways. For more details see Shor.qs.
 // If the run of Shor's algorithm fails it throws ExecutionFailException.
 // However, due to the use of System.Task in .Run method,
 // the exception of interest is getting wrapped into AggregateException.
 catch (AggregateException e )
 {
 // Report the failure of the algorithm to standard output 
 Console.WriteLine($"This run of Shor's algorithm failed:");

 // Unwrap AggregateException to get the message from Q# fail statement.
 // Go through all inner exceptions.
 foreach ( Exception eInner in e.InnerExceptions )
 {
 // If the exception of type ExecutionFailException
 if (eInner is ExecutionFailException failException)
 {
 // Print the message it contains
 Console.WriteLine($" {failException.Message}");
 }
 }
 }
 }
 }
 }
}