Beispiel #1
0
        static void Main(string[] args)
        {
            using (var qsim = new QuantumSimulator())
            {
                // Try initial values
                Result[] initials = new Result[] { Result.Zero, Result.One };
                foreach (Result initial in initials)
                {
                    var res = BellTest.Run(qsim, 1000, initial).Result;

                    /**
                     * Using estimator estimate of how many resources (qubits or certain gates) the program will use on a quantum computer
                     */
                    // var estimator = new ResourcesEstimator();
                    // var res = BellTest.Run(estimator, 1000, initial).Result;
                    // System.Console.WriteLine(estimator.ToTSV());

                    var(numZeros, numOnes, agree) = res;
                    System.Console.WriteLine(
                        $"Init:{initial,-4} 0s={numZeros,-4} 1s={numOnes,-4} agree={agree,-4}");
                }
            }

            System.Console.WriteLine("Press any key to continue...");
            Console.ReadKey();
        }
 static void Main(string[] args)
 {
     // The C# driver has four parts:+
     // Construct a quantum simulator. In the example, sim is the simulator.
     // Compute any arguments required for the quantum algorithm.In the example, count is fixed at a 1000 and initial is the initial value of the qubit.
     // Run the quantum algorithm. Each Q# operation generates a C# class with the same name. This class has a Run method that asynchronously executes the operation.
     // The execution is asynchronous because execution on actual hardware will be asynchronous.
     // Because the Run method is asynchronous, we fetch the Result property; this blocks execution until the task completes and returns the result synchronously.
     // Process the result of the operation. In the example, res receives the result of the operation.
     // Here the result is a tuple of the number of zeros(numZeros) and number of ones(numOnes) measured by the simulator.
     // This is returned as a ValueTuple in C#. We deconstruct the tuple to get the two fields, print the results, and then wait for a keypress.
     using (var sim = new QuantumSimulator())
     {
         // Try initial values
         Result[] initals = new Result[] { Result.Zero, Result.One };
         foreach (Result initial in initals)
         {
             var res = BellTest.Run(sim, 1000, initial).Result;
             var(numZeros, numOnes, agree) = res;
             Console.WriteLine($"Init: {initial, -4} 0s={numZeros, -4} 1s={numOnes, -4} agree={agree, -4}");
         }
     }
     Console.WriteLine("Press any key to continue...");
     Console.ReadKey();
 }
Beispiel #3
0
 static void Main(string[] args)
 {
     // construct the quantum simulator
     using (var sim = new QuantumSimulator())
     {
         // Try initial values
         Result[] initials = new Result[] { Result.Zero, Result.One };
         foreach (Result initial in initials)
         {
             // we pass the simulator, initial count of 1000, and an initial qubit value
             // Note that the run method is asynchronous.
             // Each Q# operation has a corresponding C# class, for which a Run method belongs to the class
             // the Run method performs asynchronous executions of the given operations
             // note that our results for BellTest are strored in a tuple
             var results1 = XGate.Run(sim, 1000, initial).Result;
             // here we perform a Hadamard gate operation, for which our qubit is placed from the ground or exited state into
             // a superposition state of either |0> or |1>
             var results2 = HGate.Run(sim, 1000, initial).Result;
             // Places two bits a Bell State, which is in essence a superposition of two qubits that are entangled
             var res = BellTest.Run(sim, 1000, initial).Result;
             // caste results into a tuple, for easy access
             var(numZeros, numOnes, agree) = res;
             var play = Playground.Run(sim, 1000, initial).Result;
             var(nOnes, nZeros, agreement) = play;
             // System.Console.WriteLine($"Init:{initial,-4} 0s={numZeros,-4} 1s={numOnes,-4} agree={agree, -4}");
             System.Console.WriteLine($"Init:{initial,-4} 0s={nZeros,-4} 1s={nOnes,-4} agree={agreement,-4}");
         }
     }
     System.Console.WriteLine("Press any key to continue...");
     System.Console.ReadKey();
 }
        static void Main(string[] args)
        {
            //Construct a quantum simulator sim -- scope inside using statement only
            using (var sim = new QuantumSimulator())
            {
                Result[] initials = new Result[] { Result.Zero, Result.One };
                foreach (Result initial in initials)
                {
                    //Run method is used to call Quantum operation from C#-- it is asynchronously execution -- it means when fetch the Result property of Q# operation BellTest to variable res, this blocks execution until the task complets and return result synchronously
                    var res = BellTest.Run(sim, 1000, initial).Result;
                    var(numZeros, numOnes) = res;
                    System.Console.WriteLine($"Init:{initial,-4} 0s={numZeros,-4} 1s={numOnes,-4}");
                }
            }

            using (var sim = new QuantumSimulator())
            {
                Result[] initials = new Result[] { Result.Zero, Result.One };
                foreach (Result initial in initials)
                {
                    //Run method is used to call Quantum operation from C#-- it is asynchronously execution -- it means when fetch the Result property of Q# operation BellTest2 to variable res, this blocks execution until the task complets and return result synchronously
                    var res = BellTest_2.Run(sim, 1000, initial).Result;
                    var(numZeros, numOnes, agree) = res;
                    System.Console.WriteLine($"Init:{initial,-4} 0s={numZeros,-4} 1s={numOnes,-4} agree={agree,-4}");
                }
            }

            System.Console.WriteLine("Press any key to continue...");
            System.Console.ReadKey();
        }
Beispiel #5
0
        static void Main(string[] args)
        {
            // Estimate quantum resources.
            Console.WriteLine("Resource estimation");
            Console.WriteLine("-------------------");
            var estimator = new ResourcesEstimator();

            BellTest.Run(estimator, 1000, Result.Zero).Wait();
            Console.WriteLine(estimator.ToTSV());

            // Actually run the experiment (assuming the resources are enough).
            Console.WriteLine();
            Console.WriteLine("Experiment");
            Console.WriteLine("----------");
            using (var qsim = new QuantumSimulator())
            {
                // Try initial values
                var initials = new Result[] { Result.Zero, Result.One };
                foreach (var initial in initials)
                {
                    var res = BellTest.Run(qsim, 1000, initial).Result;
                    var(numZeros, numOnes, agree) = res;
                    Console.WriteLine(
                        $"Init:{initial,-4} 0s={numZeros,-4} 1s={numOnes,-4} agree={agree,-4}");
                }
            }

            Console.WriteLine();
            Console.WriteLine("Press any key to continue...");
            Console.ReadKey();
        }
Beispiel #6
0
        // Bell Test
        private static void Bell()
        {
            System.Console.WriteLine("Press any key to measure some Bell states");
            System.Console.ReadKey();
            var n = 1000;

            using (var sim = new QuantumSimulator())
            {
                System.Console.WriteLine($" ========== Bell State & Teleportation ==========");
                System.Console.WriteLine($"The following uses a Hadamard gate (no entanglement), " +
                                         $"to get a superposition of states that, when measured, agree ~50% of the time");
                // Try initial values
                Result[] initials = new Result[] { Result.Zero, Result.One };
                foreach (Result initial in initials)
                {
                    var res = BellTest.Run(sim, n, initial, false).Result;
                    var(numZeros, numOnes, agree) = res;
                    System.Console.WriteLine(
                        $"Init:{initial,-4} 0s={numZeros,-4} 1s={numOnes,-4} agree={agree * 100 / n}%");
                }

                System.Console.WriteLine($"Now we add a CNOT Gate to get entanglement, and get agreement 100% of the time");
                System.Console.WriteLine("Press any key...");
                System.Console.ReadKey();
                foreach (Result initial in initials)
                {
                    var res = BellTest.Run(sim, n, initial, true).Result;
                    var(numZeros, numOnes, agree) = res;
                    System.Console.WriteLine(
                        $"Init:{initial,-4} 0s={numZeros,-4} 1s={numOnes,-4} agree={agree * 100/n}%");
                }
            }
            System.Console.ReadKey();
            System.Console.WriteLine();
        }
Beispiel #7
0
 private static void RunBellTest(SimulatorBase simulator)
 {
     // Try initial values
     Result[] initials = new Result[] { Result.Zero, Result.One };
     foreach (Result initial in initials)
     {
         var res = BellTest.Run(simulator, 1000, initial).Result;
         var(numZeros, numOnes, agree) = res;
         Console.WriteLine($"Init:{initial,-4} 0s={numZeros,-4} 1s={numOnes,-4} agree={agree,-4}");
     }
 }
        static void Main(string[] args)
        {
            var estimator = new ResourcesEstimator();

            BellTest.Run(estimator, 1000, Result.Zero).Wait();

            System.Console.WriteLine(estimator.ToTSV());

            System.Console.WriteLine("Press any key to continue...");
            Console.ReadKey();
        }
        static void Main(string[] args)
        {
            Task <(long, long)> task = null;

            using (var qsim = new QuantumSimulator())
            {
                task = BellTest.Run(qsim, 100, Result.One);
                task.Wait();
            }

            Console.WriteLine("Num of zeroes : {0}, num of ones : {1}", task.Result.Item1, task.Result.Item2);
            Console.ReadLine();
        }
Beispiel #10
0
 static void Main(string[] args)
 {
     using (var qsim = new QuantumSimulator())
     {
         // Try initial values
         var res = BellTest.Run(qsim).Result;
         var(numZeros, numOnes, agree) = res;
         Console.WriteLine($"# of 0s={numZeros,-4}");
         Console.WriteLine($"# of 1s={numOnes,-4}");
         Console.WriteLine($"agree={agree,-4}");
         System.Console.WriteLine();
     }
 }
Beispiel #11
0
 static void Main(string[] args)
 {
     using (var qsim = new QuantumSimulator())
     {
         Result[] initals = new Result[] { Result.Zero, Result.One };
         foreach (Result inital in initals)
         {
             var res = BellTest.Run(qsim, 1000, inital).Result;
             Console.WriteLine("for inital of {2} ==> 0: {0} 1: {1} - Agree:{3}", res.Item1, res.Item2, inital, res.Item3);
         }
         Console.ReadKey();
     }
 }
        static void Main(string[] args)
        {
            using (var sim = new QuantumSimulator())
            {
                for (int i = 0; i < 100; i++)
                {
                    var(s1, s2) = BellTest.Run(sim).Result;
                    Console.WriteLine($"第{i}次:Q1状态 {s1,-5} Q2状态 {s2,-5}");
                }
            }

            Console.WriteLine("按任意键继续...");
            Console.ReadKey();
        }
        static void Main(string[] args)
        {
            /*
             *  Объявление переменной `sim`, отвечающей за квантовый симулятор.
             *  После выхода из блока `using` память, выделенная под `sim`, освобождается.
             */
            using (var sim = new QuantumSimulator())
            {
                /*
                 *  Объявление массива из двух элементов типа `Result`:
                 *  `Zero` и `One`.
                 */
                Result[] initials = new Result[] { Result.Zero, Result.One };

                /*
                 *  Для каждого элемента массива `initials` провести 1000
                 *  экспериментов программы `BellTest`.
                 */
                foreach (Result initial in initials)
                {
                    /*
                     *  `BellTest` представляет собой класс, у которого есть
                     *  метод `Run` - для запуска эксперимента на симуляторе `sim`.
                     *
                     *  Следующими аргументами передаются параметры для самой
                     *  операции `BellTest` из Q#-файла `Bell.qs` - число
                     *  экспериментов и начальное состояние нулевого кубита.
                     */
                    var res = BellTest.Run(sim, 1000, initial).Result;

                    /*
                     *  Переменная `res` - это кортеж (tuple) из:
                     * числа измерений, в которых был получен ноль (|0>),
                     * числа измерений, в которых была получена единица (|1>),
                     * числа измерений, в которых состояния нулевого и первого кубитов совпадают.
                     */
                    var(numZeros, numOnes, agree) = res;

                    /*
                     *  Вывод на экран.
                     */
                    System.Console.WriteLine(
                        $"Init: {initial,-4} 0s={numZeros,-4} 1s={numOnes,-4} agree={agree,-4}"
                        );
                }
            }

            System.Console.WriteLine("Press any key to continue...");
            System.Console.ReadKey();
        }
Beispiel #14
0
 static void Main(string[] args)
 {
     using (var sim = new QuantumSimulator())
     {
         Result[] initials = new Result[] { Result.Zero, Result.One };
         foreach (Result initial in initials)
         {
             var res = BellTest.Run(sim, 1000, initial).Result;
             var(numZeros, numOnes) = res;
             System.Console.WriteLine($"Init:{initial,-4} 0s={numZeros,-4} 1s={numOnes,-4}");
         }
     }
     System.Console.WriteLine("Press any key to continue");
     System.Console.ReadKey();
 }
Beispiel #15
0
 static void Main(string[] args)
 {
     using (var qsim = new QuantumSimulator())
     {
         // Try initial values
         Result[] initials = new Result[] { Result.Zero, Result.One };
         foreach (Result initial in initials)
         {
             var res = BellTest.Run(qsim, 1000, initial).Result;
             var(numZeros, numOnes) = res;
             System.Console.WriteLine(
                 $"Init:{initial,-4} 0s={numZeros,-4} 1s={numOnes,-4}");
         }
     }
 }
Beispiel #16
0
        static void Main(string[] args)
        {
            using (var qsim = new QuantumSimulator())
            {
                var initials = new [] { Result.Zero, Result.One };
                foreach (Result initial in initials)
                {
                    var res = BellTest.Run(qsim, 1000, initial).Result;
                    var(numZeros, numOnes, agree) = res;
                    Console.WriteLine($"初期状態:{initial,-4} |0>={numZeros,-4} |1>={numOnes,-4} 同一={agree,-4}");
                }
            }

            Console.WriteLine("キーを押したら終了します...");
            Console.ReadKey();
        }
Beispiel #17
0
 static void Main(string[] args)
 {
     // Task 2 - add code here
     using (var sim = new QuantumSimulator())
     {
         Result[] initials = new Result[] { Result.Zero, Result.One };
         foreach (Result initial in initials)
         {
             var count = 1000;
             var (numZeros, numOnes, same) = BellTest.Run(sim, count, initial).Result;
             System.Console.WriteLine($"Init:{initial,-4} 0s={numZeros, -4} 1s={numOnes, -4} same={same, -4}");
             // System.Console.WriteLine("Press any key to continue...");
             // System.Console.ReadKey();
         }
     }
 }
        static void Main(string[] args)
        {
            using (var qsim = new QuantumSimulator())
            {
                // Try initial values
                Result[] initials = new Result[] { Result.Zero, Result.One };
                foreach (Result initial in initials)
                {
                    var res = BellTest.Run(qsim, 1000, initial).Result;
                    var(numZeros, numOnes, agree) = res;
                    Console.WriteLine($"Init: {initial, -4} 0s={numZeros, -4} 1s={numOnes, -4}, agree={agree, -4}");
                }
            }

            Console.WriteLine("Press any key to continue...");
            Console.ReadLine();
        }
Beispiel #19
0
 private static void Main()
 {
     using (var qsim = new QuantumSimulator())
     {
         Clear();
         HelloQ.Run(qsim).Wait();
         // prova i valori iniziali
         Result[] initials = new Result[] { Result.Zero, Result.One };
         foreach (Result initial in initials)
         {
             var res = BellTest.Run(qsim, 1000, initial).Result;
             var(numZeros, numOnes, agree) = res;
             WriteLine($"Init:{initial,-4} 0s={numZeros,-4} 1s={numOnes,-4} agree={agree,-4}");
         }
     }
     ReadKey();
 }
Beispiel #20
0
 static void Main(string[] args)
 {
     //Erzeugen des Quantumsimulators
     using (var quantumSimulator = new QuantumSimulator())
     {
         //Erzeugung zweier anfänglicher Messergebnisse(Resultate) von Null und Eins
         Result[] initials = new Result[] { Result.Zero, Result.One };
         //Für jedes Messergebnis(Resultat), zwei an der Zahl, wird der Quantensimulator gestartet
         foreach (Result initial in initials)
         {
             var result = BellTest.Run(quantumSimulator, 1000, initial).Result;
             var(numZeros, numOnes, agree) = result;
             System.Console.WriteLine($"Init:{initial,-4} 0s={numZeros,-4} 1s={numOnes,-4} agree={agree, -4}");
         }
     }
     System.Console.WriteLine("Press any key to continue...");
     System.Console.ReadKey();
 }
Beispiel #21
0
 static void Main(string[] args)
 {
     using (var sim = new QuantumSimulator())                      // 'sim' is the Q# quantum simulator
     {
         // Try initial values
         Result[] initials = new Result[] { Result.Zero, Result.One };
         foreach (Result initial in initials)
         {
             var res = BellTest.Run(sim, 1000, initial).Result;    // 'Run' is the method to run the quantum simulation
                                                                   // 'Run' is asynchronous, but fetching the 'Result' property blocks
                                                                   // execution until the task completes and makes this synchronous.
             var(numZeros, numOnes, agree) = res;
             System.Console.WriteLine(
                 $"Init:{initial,-4} 0s={numZeros,-4} 1s={numOnes,-4} agree={agree,-4}");
         }
     }
     System.Console.WriteLine("Press any key to continue...");
     System.Console.ReadKey();
 }
Beispiel #22
0
 static void Main(string[] args)
 {
     using (var sim = new QuantumSimulator()) // sim is the simulator
     {
         // Try initial values
         Result[] initials = new Result[] { Result.Zero, Result.One };
         foreach (Result initial in initials)                   //Compute any arguments required for the quantum algorithm.
         {
             var res = BellTest.Run(sim, 1000, initial).Result; //In the example, count is fixed at a 1000 and initial is the initial value of the qubit.
             var(numZeros, numOnes) = res;
             // var (numZeros, numOnes, agree) = res;
             System.Console.WriteLine(
                 $"Init:{initial,-4} 0s={numZeros,-4} 1s={numOnes,-4}");
             //System.Console.WriteLine(
             // $"Init:{initial,-4} 0s={numZeros,-4} 1s={numOnes,-4} agree={agree,-4}");
         }
     }
     System.Console.WriteLine("Press any key to continue...");
     System.Console.ReadKey();
 }
Beispiel #23
0
        static void Main(string[] args)
        {
            // aloca dinamicamente um simulador para executar o código quantico
            using (var SIM = new QuantumSimulator())
            {
                Result[] estados_iniciais = new Result[] { Result.Zero, Result.One };

                foreach (Result estado in estados_iniciais)
                {
                    // computa o teste: cont=1000 inicial=estados_iniciais
                    var resp = BellTest.Run(SIM, 1000, estado).Result;

                    var(numZeros, numUns) = resp;

                    System.Console.WriteLine($"Resultado:{estado, -4} 0s={numZeros, -4} 1s={numUns, -4}");
                }
            }
            System.Console.WriteLine("Pressione qualquer tecla para continuar...");
            System.Console.ReadKey();
        }
Beispiel #24
0
        static void Main(string[] args)
        {
            var estimator = new ResourcesEstimator();

            BellTest.Run(estimator, 1000, Result.Zero).Wait();
            System.Console.WriteLine(estimator.ToTSV());

            /*using (var qsim = new QuantumSimulator())
             * {
             *  Result[] initials = new Result[] { Result.Zero, Result.One };
             *  foreach(Result initial in initials)
             *  {
             *      var res = BellTest.Run(qsim, 1000, initial).Result;
             *      var (numZeros, numOnes, agree) = res;
             *      System.Console.WriteLine(
             *          $"Init:{initial,-4} 0s={numZeros,-4} 1s={numOnes,-4} agree={agree,-4}");
             *  }
             * }*/
            System.Console.WriteLine("Press any key to continue...");
            Console.ReadKey();
        }
Beispiel #25
0
        static void Main(string[] args)
        {
            var qsim = new ResourcesEstimator();

            BellTest.Run(qsim, 1000, Result.Zero).Wait();
            System.Console.WriteLine(qsim.ToTSV());

            //using (var qsim = new QuantumSimulator())
            //{
            //    //Try initial values
            //    Result[] initials = new Result[] { Result.Zero, Result.One };
            //    foreach (Result initial in initials)
            //    {
            //        var res = BellTest.Run(qsim, 1000, initial).Result;
            //        var (numZeroes, numOnes, agree) = res;
            //        System.Console.WriteLine($"Init:{initial,-4} 0s={numZeroes,-4} 1s={numOnes,-4} agree={agree, -4}");
            //    }
            //}

            System.Console.WriteLine("Press any key to continue...");
            Console.ReadKey();
        }
Beispiel #26
0
        static void Main(string[] args)
        {
            using (var qsim = new QuantumSimulator())
            {
                Result[] initials = new Result[] { Result.Zero, Result.One };
                foreach (Result initial in initials)
                {
                    var res = BellTest.Run(qsim, 1000, initial).Result;
                    var(numZeros, numOnes, agree) = res;
                    System.Console.WriteLine(
                        $"Init:{initial,-4} 0s={numZeros,-4} 1s={numOnes,-4} agree={agree,-4}");
                }
            }

            //run this instead of the above using block for resource estimation
            //var estimator = new ResourcesEstimator();
            //BellTest.Run(estimator, 1000, Result.Zero).Wait();
            //System.Console.WriteLine(estimator.ToTSV());

            Console.WriteLine("Press any key to continue...");
            Console.ReadKey();
        }
Beispiel #27
0
    private static void Main()
    //****************************************************************************80
    //
    //  Purpose:
    //
    //    MAIN is the main program for SUBSET_TEST.
    //
    //  Discussion:
    //
    //    SUBSET_TEST tests SUBSET.
    //
    //  Licensing:
    //
    //    This code is distributed under the GNU LGPL license.
    //
    //  Modified:
    //
    //    20 November 2019
    //
    //  Author:
    //
    //    John Burkardt
    //
    {
        Console.WriteLine("");
        Console.WriteLine("SUBSET_TEST");
        Console.WriteLine("  Test the SUBSET library.");

        AlternatingSignMatrixTest.asm_enum_test();
        AlternatingSignMatrixTest.asm_triangle_test();
        BellTest.bell_test();
        CatalanTest.catalan_test();
        CatalanTest.catalan_row_next_test();
        FractionTest.cfrac_to_rat_test();
        FractionTest.cfrac_to_rfrac_test();
        CombTest.comb_next_test();
        CombTest.comb_row_next_test();
        CombTest.comb_unrank_test();
        CompTest.comp_enum_test();
        CompTest.comp_next_test();
        CompTest.comp_next_grlex_test();
        CompTest.comp_random_test();
        CompTest.comp_random_grlex_test();
        CompTest.comp_rank_grlex_test();
        CompTest.comp_to_ksub_test();
        CompTest.comp_unrank_grlex_test();
        CompTest.compnz_next_test();
        CompTest.compnz_random_test();
        CompTest.compnz_to_ksub_test();
        CongruenceTest.congruence_test();
        DebruijnTest.debruijn_test();

        DecMatTest.decmat_det_test();
        DecMatTest.decmat_print_test();
        DerangeTest.derange_enum_test();
        DerangeTest.derange_enum2_test();
        DerangeTest.derange_enum3_test();
        DerangeTest.derange0_back_next_test();
        DerangeTest.derange0_check_test();
        DerangeTest.derange0_weed_next_test();
        DigraphTest.digraph_arc_euler_test();
        DigraphTest.digraph_arc_print_test();
        DiophantineTest.diophantine_test();
        DiophantineTest.diophantine_solution_minimize_test();
        DVecTest.dvec_add_test();
        DVecTest.dvec_complementx_test();
        DVecTest.dvec_mul_test();
        DVecTest.dvec_print_test();
        DVecTest.dvec_sub_test();
        DVecTest.dvec_to_i4_test();
        EquivTest.equiv_next_test();
        EquivTest.equiv_next2_test();
        EquivTest.equiv_print_test();
        EquivTest.equiv_print2_test();
        EquivTest.equiv_random_test();
        EulerTest.euler_row_test();
        FrobeniusTest.frobenius_number_order2_test();
        GrayTest.gray_next_test();
        GrayTest.gray_rank_test();
        GrayTest.gray_rank2_test();
        GrayTest.gray_unrank_test();
        GrayTest.gray_unrank2_test();
        i4Test.i4_bclr_test();
        i4Test.i4_bset_test();
        i4Test.i4_btest_test();
        i4Test.i4_choose_test();
        i4Test.i4_factor_test();
        i4Test.i4_fall_test();
        i4Test.i4_gcd_test();
        i4Test.i4_huge_test();
        i4Test.i4_log_10_test();
        i4Test.i4_modp_test();
        i4Test.i4_moebius_test();
        i4Test.i4_partition_conj_test();
        i4Test.i4_partition_count_test();
        i4Test.i4_partition_count2_test();
        i4Test.i4_partition_next_test();
        i4Test.i4_partition_next2_test();
        i4Test.i4_partition_print_test();
        i4Test.i4_partition_random_test();
        i4Test.i4_partitions_next_test();
        i4Test.i4_rise_test();
        i4Test.i4_sqrt_test();
        i4Test.i4_sqrt_cf_test();
        i4Test.i4_to_dvec_test();
        i4Test.i4_to_i4poly_test();
        i4Test.i4_to_van_der_corput_test();
        i4Test.i4mat_01_rowcolsum_test();
        i4Test.i4mat_u1_inverse_test();
        i4Test.i4mat_perm0_test();
        i4Test.i4mat_2perm0_test();
        i4Test.i4poly_test();
        i4Test.i4poly_add_test();
        i4Test.i4poly_cyclo_test();
        i4Test.i4poly_degree_test();
        i4Test.i4poly_dif_test();
        i4Test.i4poly_div_test();
        i4Test.i4poly_mul_test();
        i4Test.i4poly_print_test();
        i4Test.i4poly_to_i4_test();
        i4Test.i4vec_backtrack_test();
        i4Test.i4vec_descends_test();
        i4Test.i4vec_frac_test();
        i4Test.i4vec_index_test();
        i4Test.i4vec_maxloc_last_test();
        i4Test.i4vec_pairwise_prime_test();
        i4Test.i4vec_reverse_test();
        i4Test.i4vec_sort_bubble_a_test();
        i4Test.i4vec_sort_heap_index_d_test();
        i4Test.i4vec_transpose_print_test();
        i4Test.i4vec_uniform_ab_test();
        IndexTest.index_box_next_2d_test();
        IndexTest.index_box_next_3d_test();
        IndexTest.index_box2_next_2d_test();
        IndexTest.index_box2_next_3d_test();
        IndexTest.index_next0_test();
        IndexTest.index_next1_test();
        IndexTest.index_next2_test();
        IndexTest.index_rank0_test();
        IndexTest.index_rank1_test();
        IndexTest.index_rank2_test();
        IndexTest.index_unrank0_test();
        IndexTest.index_unrank1_test();
        IndexTest.index_unrank2_test();
        InverseTest.inverse_mod_n_test();
        PermTest.inversion_to_perm0_test();
        InvoluteTest.involute_enum_test();
        FractionTest.jfrac_to_rfrac_test();
        JosephusTest.josephus_test();
        KsubTest.ksub_next_test();
        KsubTest.ksub_next2_test();
        KsubTest.ksub_next3_test();
        KsubTest.ksub_next4_test();
        KsubTest.ksub_random_test();
        KsubTest.ksub_random2_test();
        KsubTest.ksub_random3_test();
        KsubTest.ksub_random4_test();
        KsubTest.ksub_random5_test();
        KsubTest.ksub_rank_test();
        KsubTest.ksub_to_comp_test();
        KsubTest.ksub_to_compnz_test();
        KsubTest.ksub_unrank_test();
        l4Test.l4vec_next_test();
        MatrixTest.matrix_product_opt_test();
        MoebiusMatrixTest.moebius_matrix_test();
        MonomialTest.monomial_count_test();
        MonomialTest.monomial_counts_test();
        MorseThueTest.morse_thue_test();
        MultinomialTest.multinomial_coef1_test();
        MultinomialTest.multinomial_coef2_test();
        PermTest.multiperm_enum_test();
        PermTest.multiperm_next_test();
        UnsignTest.nim_sum_test();
        PadovanTest.padovan_test();
        PellTest.pell_basic_test();
        PellTest.pell_next_test();
        PentEnumTest.pent_enum_test();
        PermTest.perm_ascend_test();
        PermTest.perm_fixed_enum_test();
        PermTest.perm0_break_count_test();
        PermTest.perm0_check_test();
        PermTest.perm0_cycle_test();
        PermTest.perm0_distance_test();
        PermTest.perm0_free_test();
        PermTest.perm0_inverse_test();
        PermTest.perm0_inverse2_test();
        PermTest.perm0_inverse3_new_test();
        PermTest.perm0_lex_next_test();
        PermTest.perm0_mul_test();
        PermTest.perm0_next_test();
        PermTest.perm0_next2_test();
        PermTest.perm0_next3_test();
        PermTest.perm0_print_test();
        PermTest.perm0_random_test();
        PermTest.perm0_random2_test();
        PermTest.perm0_rank_test();
        PermTest.perm0_sign_test();
        PermTest.perm0_to_equiv_test();
        PermTest.perm0_to_inversion_test();
        PermTest.perm0_to_ytb_test();
        PermTest.perm0_unrank_test();
        PermTest.perm1_canon_to_cycle_test();
        PermTest.perm1_check_test();
        PermTest.perm1_cycle_to_canon_test();
        PermTest.perm1_cycle_to_index_test();
        PermTest.perm1_index_to_cycle_test();
        PermTest.perm1_print_test();
        PerrinTest.perrin_test();
        PartialOrderingTest.pord_check_test();
        PowerTest.power_mod_test();
        PowerTest.power_series1_test();
        PowerTest.power_series2_test();
        PowerTest.power_series3_test();
        PowerTest.power_series4_test();
        PrimeTest.prime_test();
        PythagorusTest.pythag_triple_next_test();
        r8Test.r8_agm_test();
        r8Test.r8_choose_test();
        r8Test.r8_epsilon_test();
        r8Test.r8_fall_test();
        r8Test.r8_rise_test();
        r8Test.r8_to_cfrac_test();
        r8Test.r8_to_dec_test();
        r8Test.r8_to_rat_test();
        r8Test.r8mat_det_test();
        r8Test.r8mat_perm0_test();
        r8Test.r8mat_2perm0_test();
        r8Test.r8mat_permanent_test();
        r8Test.r8poly_test();
        r8Test.r8poly_f2p_test();
        r8Test.r8poly_fval_test();
        r8Test.r8poly_n2p_test();
        r8Test.r8poly_nval_test();
        r8Test.r8poly_nx_test();
        r8Test.r8poly_p2f_test();
        r8Test.r8poly_p2n_test();
        r8Test.r8poly_p2t_test();
        r8Test.r8poly_print_test();
        r8Test.r8poly_pval_test();
        r8Test.r8poly_t2p_test();
        r8Test.r8vec_backtrack_test();
        r8Test.r8vec_frac_test();
        r8Test.r8vec_mirror_next_test();
        RationalTest.rat_add_test();
        RationalTest.rat_div_test();
        RationalTest.rat_farey_test();
        RationalTest.rat_farey2_test();
        RationalTest.rat_mul_test();
        RationalTest.rat_normalize_test();
        RationalTest.rat_sum_formula_test();
        RationalTest.rat_to_cfrac_test();
        RationalTest.rat_to_dec_test();
        RationalTest.rat_to_r8_test();
        RationalTest.rat_to_s_test();
        RationalTest.rat_width_test();
        RationalTest.ratmat_det_test();
        RationalTest.ratmat_print_test();
        RestrictedGrowthTest.regro_next_test();
        FractionTest.rfrac_to_cfrac_test();
        FractionTest.rfrac_to_jfrac_test();
        SchroederTest.schroeder_test();
        SortHeapExternalTest.sort_heap_external_test();
        SubsetTest.subset_by_size_next_test();
        SubsetTest.subset_lex_next_test();
        SubsetTest.subset_gray_next_test();
        SubsetTest.subset_random_test();
        SubsetTest.subset_gray_rank_test();
        SubsetTest.subset_gray_unrank_test();
        SubcompTest.subcomp_next_test();
        SubcompTest.subcompnz_next_test();
        SubcompTest.subcompnz2_next_test();
        TriangleTest.subtriangle_next_test();
        Thuetest.thue_binary_next_test();
        Thuetest.thue_ternary_next_test();
        TriangTest.triang_test();
        TupleTest.tuple_next_test();
        TupleTest.tuple_next_fast_test();
        TupleTest.tuple_next_ge_test();
        TupleTest.tuple_next2_test();
        UnsignTest.ubvec_add_test();
        UnsignTest.ubvec_print_test();
        UnsignTest.ubvec_to_ui4_test();
        UnsignTest.ubvec_xor_test();
        UnsignTest.ui4_to_ubvec_test();
        VectorTest.vec_colex_next_test();
        VectorTest.vec_colex_next2_test();
        VectorTest.vec_colex_next3_test();
        VectorTest.vec_gray_next_test();
        VectorTest.vec_gray_rank_test();
        VectorTest.vec_gray_unrank_test();
        VectorTest.vec_lex_next_test();
        VectorTest.vec_random_test();
        VectorTest.vector_constrained_next_test();
        VectorTest.vector_constrained_next2_test();
        VectorTest.vector_constrained_next3_test();
        VectorTest.vector_constrained_next4_test();
        VectorTest.vector_constrained_next5_test();
        VectorTest.vector_constrained_next6_test();
        VectorTest.vector_constrained_next7_test();
        VectorTest.vector_next_test();
        YoungTableauTest.ytb_enum_test();
        YoungTableauTest.ytb_next_test();
        YoungTableauTest.ytb_random_test();
        Console.WriteLine("");
        Console.WriteLine("SUBSET_TEST");
        Console.WriteLine("  Normal end of execution.");
        Console.WriteLine("");
    }
Beispiel #28
0
        static void Main(string[] args)
        {
            void PressKey(string name)
            {
                Console.WriteLine($"\n\nPress any key to start {name}\n\n");
                Console.ReadKey();
            }

            using (var qsim = new QuantumSimulator())
            {
                PressKey("Reversable gate");

                for (int i = 0; i < 5; ++i)
                {
                    var initialValue = i % 2 == 0 ? Result.Zero : Result.One;
                    var result       = ReversableGate.Run(qsim, initialValue).Result;
                    Console.WriteLine($"Reversable gate result is: " +
                                      $"{result}. Initial value: {initialValue}");
                }

                PressKey("Measurement superposition collapsing");

                for (int i = 0; i < 15; ++i)
                {
                    var initialValue = i % 2 == 0 ? Result.One : Result.Zero;
                    var result       = MeasurementCollapsingSuperposition
                                       .Run(qsim, initialValue).Result;
                    Console.WriteLine(
                        $"Reversable gate result is: {result.Item1}. " +
                        $"Result2: {result.Item2}. Inital value: {initialValue}");
                }

                PressKey("Random number generator");

                for (int i = 0; i < 10; ++i)
                {
                    var randomNumber = GenerateRandomNumber.Run(qsim).Result;
                    Console.WriteLine($"Random number is: {randomNumber}");
                }

                PressKey("Bell test");

                Result[] initials = new Result[] { Result.Zero, Result.One };
                foreach (var initial in initials)
                {
                    var res = BellTest.Run(qsim, 1000, initial).Result;

                    var(numZeros, numOnes, agrees) = res;
                    Console.WriteLine($"" +
                                      $"Init:{initial,-4} " +
                                      $"0s={numZeros,-4} " +
                                      $"1s={numOnes,-4} " +
                                      $"Agrees = {agrees,-4}");
                }

                PressKey("Deutsch-Jozsa");

                var const0Result   = Constant0.Run(qsim).Result;
                var const1Result   = Constant1.Run(qsim).Result;
                var negationResult = Negation.Run(qsim).Result;
                var identityResult = Identity.Run(qsim).Result;

                Console.WriteLine($"Const0: " +
                                  $"{const0Result.Item1} " +
                                  $"{const0Result.Item2} " +
                                  $"{const0Result.Item3}");

                Console.WriteLine($"Const1: " +
                                  $"{const1Result.Item1} " +
                                  $"{const1Result.Item2} " +
                                  $"{const1Result.Item3}");

                Console.WriteLine($"Identity: " +
                                  $"{identityResult.Item1} " +
                                  $"{identityResult.Item2} " +
                                  $"{identityResult.Item3}");

                Console.WriteLine($"Negation: " +
                                  $"{negationResult.Item1} " +
                                  $"{negationResult.Item2} " +
                                  $"{negationResult.Item3}");

                PressKey("Teleportation part 1");

                for (int i = 0; i < 5; ++i)
                {
                    Console.WriteLine($"Teleport (msg==false): " +
                                      $"{SendMessage.Run(qsim, false).Result}");
                }

                PressKey("Teleportation part 2");

                for (int i = 0; i < 5; ++i)
                {
                    Console.WriteLine($"Teleport (msg==true): " +
                                      $"{SendMessage.Run(qsim, true).Result}");
                }
            }

            Console.WriteLine("\n\nEnd");
            Console.ReadKey();
        }