Merge remote-tracking branch 'origin/main' into swernli/issue1154

compiler/qsc_eval/src/intrinsic.rs

@@ -11,12 +11,13 @@ use crate::{
     error::PackageSpan,
     output::Receiver,
     val::{self, Qubit, Value},
-    Error,
+    Error, Rc,
 };
 use num_bigint::BigInt;
 use rand::{rngs::StdRng, Rng};
 use rustc_hash::FxHashSet;
 use std::array;
+use std::convert::TryFrom;
 
 #[allow(clippy::too_many_lines)]
 pub(crate) fn call(
@@ -36,6 +37,22 @@ pub(crate) fn call(
         #[allow(clippy::cast_precision_loss)]
         "IntAsDouble" => Ok(Value::Double(arg.unwrap_int() as f64)),
         "IntAsBigInt" => Ok(Value::BigInt(BigInt::from(arg.unwrap_int()))),
+        "DoubleAsStringWithPrecision" => {
+            let [input, prec_val] = unwrap_tuple(arg);
+            let prec_int = prec_val.unwrap_int();
+            if prec_int < 0 {
+                Err(Error::InvalidNegativeInt(prec_int, arg_span))
+            } else {
+                let precision = usize::try_from(prec_int).expect("integer value");
+                let is_zero = if precision == 0 { "." } else { "" };
+                Ok(Value::String(Rc::from(format!(
+                    "{:.*}{}",
+                    precision,
+                    input.unwrap_double(),
+                    is_zero
+                ))))
+            }
+        }
         "DumpMachine" => {
             let (state, qubit_count) = sim.capture_quantum_state();
             match out.state(state, qubit_count) {

compiler/qsc_eval/src/intrinsic/tests.rs

@@ -240,6 +240,51 @@ fn int_as_double_precision_loss() {
     );
 }
 
+#[test]
+fn double_as_string_with_precision() {
+    check_intrinsic_result(
+        "",
+        "Microsoft.Quantum.Convert.DoubleAsStringWithPrecision(0.8414709848078965, 4)",
+        &expect!["0.8415"],
+    );
+}
+
+#[test]
+fn double_as_string_with_precision_extend() {
+    check_intrinsic_result(
+        "",
+        "Microsoft.Quantum.Convert.DoubleAsStringWithPrecision(0.8, 5)",
+        &expect!["0.80000"],
+    );
+}
+
+#[test]
+fn double_as_string_with_precision_negative_error() {
+    check_intrinsic_result(
+        "",
+        "Microsoft.Quantum.Convert.DoubleAsStringWithPrecision(0.8, -5)",
+        &expect!["negative integers cannot be used here: -5"],
+    );
+}
+
+#[test]
+fn double_as_string_with_zero_precision() {
+    check_intrinsic_result(
+        "",
+        "Microsoft.Quantum.Convert.DoubleAsStringWithPrecision(0.47, 0)",
+        &expect!["0."],
+    );
+}
+
+#[test]
+fn double_as_string_with_zero_precision_rounding() {
+    check_intrinsic_result(
+        "",
+        "Microsoft.Quantum.Convert.DoubleAsStringWithPrecision(0.913, 0)",
+        &expect!["1."],
+    );
+}
+
 #[test]
 fn dump_machine() {
     check_intrinsic_output(

compiler/qsc_eval/src/tests.rs

@@ -3726,7 +3726,7 @@ fn controlled_operation_with_duplicate_controls_fails() {
                                 1,
                             ),
                             item: LocalItemId(
-                                127,
+                                128,
                             ),
                         },
                         caller: PackageId(
@@ -3776,7 +3776,7 @@ fn controlled_operation_with_target_in_controls_fails() {
                                 1,
                             ),
                             item: LocalItemId(
-                                127,
+                                128,
                             ),
                         },
                         caller: PackageId(

compiler/qsc_frontend/src/resolve.rs

@@ -73,6 +73,16 @@ pub enum Res {
     ExportedItem(ItemId, Option<Ident>),
 }
 
+impl Res {
+    #[must_use]
+    pub fn item_id(&self) -> Option<ItemId> {
+        match self {
+            Res::Item(id, _) | Res::ExportedItem(id, _) => Some(*id),
+            _ => None,
+        }
+    }
+}
+
 #[derive(Clone, Debug, Diagnostic, Error, PartialEq)]
 pub(super) enum Error {
     #[error("`{name}` could refer to the item in `{first_open}` or `{second_open}`")]
@@ -923,10 +933,26 @@ impl Resolver {
                     (false, Some(entry), _) | (true, _, Some(entry))
                         if matches!(entry.source, ItemSource::Imported(..)) =>
                     {
-                        let err =
-                            Error::ImportedDuplicate(local_name.to_string(), decl_item.name().span);
-                        self.errors.push(err);
-                        continue;
+                        // only push this error if the import is of a different item.
+                        // this is for the re-runnability of jupyter cells.
+                        // we want to be able to re-run a cell which may have an import in
+                        // it, meaning it would evaluate the same import multiple times.
+                        //
+                        // if the import is of a different item, though, then we should throw an
+                        // error because the import introduces a conflict.
+                        match (term_result, ty_result) {
+                            (Ok(res), _) | (_, Ok(res)) if res.item_id() == Some(entry.id) => {
+                                continue;
+                            }
+                            _ => {
+                                let err = Error::ImportedDuplicate(
+                                    local_name.to_string(),
+                                    decl_item.name().span,
+                                );
+                                self.errors.push(err);
+                                continue;
+                            }
+                        }
                     }
                     // special case:
                     // if this is an export of an import with an alias,

compiler/qsc_frontend/src/resolve/tests.rs

@@ -4472,6 +4472,7 @@ fn import_self() {
     );
 }
 
+// this should be allowed for jupyter cell re-runnability
 #[test]
 fn import_duplicate_symbol() {
     check(
@@ -4490,12 +4491,11 @@ fn import_duplicate_symbol() {
             namespace namespace9 {
                 operation item2() : Unit {}
             }
-
-            // ImportedDuplicate("Baz", Span { lo: 49, hi: 52 })
         "#]],
     );
 }
 
+// this should be allowed for jupyter cell re-runnability
 #[test]
 fn import_duplicate_symbol_different_name() {
     check(
@@ -4516,11 +4516,37 @@ fn import_duplicate_symbol_different_name() {
             namespace namespace9 {
                 operation item2() : Unit {}
             }
+        "#]],
+    );
+}
+
+// this should be allowed for jupyter cell re-runnability
+#[test]
+fn disallow_importing_different_items_with_same_name() {
+    check(
+        indoc! { r#"
+        namespace Main {
+            import Foo.Bar.Baz, Foo.Bar.Baz2 as Baz;
+        }
+        namespace Foo.Bar {
+            operation Baz() : Unit {}
+            operation Baz2() : Unit {}
+        }
+"# },
+        &expect![[r#"
+            namespace namespace7 {
+                import item2, item3;
+            }
+            namespace namespace9 {
+                operation item2() : Unit {}
+                operation item3() : Unit {}
+            }
 
-            // ImportedDuplicate("Baz", Span { lo: 65, hi: 68 })
+            // ImportedDuplicate("Baz", Span { lo: 57, hi: 60 })
         "#]],
     );
 }
+
 #[test]
 fn import_takes_precedence_over_local_decl() {
     check(

library/qs_source/src/std/canon.qs

@@ -348,7 +348,7 @@ namespace Microsoft.Quantum.Canon {
     /// ```
     operation ApplyPauliFromBitString(pauli : Pauli, bitApply : Bool, bits : Bool[], qubits : Qubit[]) : Unit is Adj + Ctl {
         let nBits = Length(bits);
-        Fact(nBits == Length(qubits), "Number of control bits must be equal to number of control qubits.");
+        Fact(nBits == Length(qubits), "Number of bits must be equal to number of qubits.");
         for i in 0..nBits - 1 {
             if bits[i] == bitApply {
                 ApplyP(pauli, qubits[i]);

library/qs_source/src/std/convert.qs

@@ -264,5 +264,25 @@ namespace Microsoft.Quantum.Convert {
         );
     }
 
-    export IntAsDouble, IntAsBigInt, ResultAsBool, BoolAsResult, BoolArrayAsInt, IntAsBoolArray, BoolArrayAsBigInt, BigIntAsBoolArray, ResultArrayAsInt, ResultArrayAsBoolArray, BoolArrayAsResultArray, ComplexAsComplexPolar, ComplexPolarAsComplex;
+    /// # Summary
+    /// Converts a given double-precision floating-point number to a string representation with desired precision, rounding if required.
+    ///
+    /// # Input
+    /// ## input
+    /// Double to be converted.
+    /// ## precision
+    /// Non-negative number of digits after the decimal point.
+    ///
+    /// # Example
+    /// ```qsharp
+    /// Message($"{DoubleAsStringWithPrecision(0.354, 2)}"); // Prints 0.35
+    /// Message($"{DoubleAsStringWithPrecision(0.485, 1)}"); // Prints 0.5
+    /// Message($"{DoubleAsStringWithPrecision(5.6, 4)}"); // Prints 5.6000
+    /// Message($"{DoubleAsStringWithPrecision(2.268, 0)}"); // Prints 2
+    /// ```
+    function DoubleAsStringWithPrecision(input : Double, precision : Int) : String {
+        body intrinsic;
+    }
+
+    export IntAsDouble, IntAsBigInt, ResultAsBool, BoolAsResult, BoolArrayAsInt, IntAsBoolArray, BoolArrayAsBigInt, BigIntAsBoolArray, ResultArrayAsInt, ResultArrayAsBoolArray, BoolArrayAsResultArray, ComplexAsComplexPolar, ComplexPolarAsComplex, DoubleAsStringWithPrecision;
 }

library/qs_source/src/std/internal.qs

@@ -247,6 +247,4 @@ namespace Microsoft.Quantum.Intrinsic {
 
         targets
     }
-
-    export CH, CCH, ApplyGlobalPhase, ControllableGlobalPhase, GlobalPhase, CRz, CS, CT, MapPauli, EntangleForJointMeasure, CollectControls, AdjustForSingleControl, AND, PhaseCCX, CCZ, CCY, CRxx, CRyy, CRzz, IndicesOfNonIdentity, RemovePauliI, SpreadZ;
 }

library/qs_source/src/std/math.qs

@@ -1454,5 +1454,5 @@ namespace Microsoft.Quantum.Math {
         2.0^IntAsDouble(integerBits - 1) - 2.0^(-IntAsDouble(fractionalBits))
     }
 
-    export PI, E, LogOf2, IsNaN, IsInfinite, SignI, SignD, SignL, AbsI, AbsD, AbsL, MaxI, MaxD, MaxL, MinI, MinD, MinL, Max, Min, ArcCos, ArcSin, ArcTan, ArcTan2, Cos, Cosh, Sin, Sinh, Tan, Tanh, ArcCosh, ArcSinh, ArcTanh, Sqrt, Log, Log10, Lg, Truncate, ExtendedTruncation, Ceiling, Floor, Round, DivRemI, DivRemL, ModulusI, ModulusL, ExpModI, ExpModL, InverseModI, InverseModL, GreatestCommonDivisorI, GreatestCommonDivisorL, ExtendedGreatestCommonDivisorI, ExtendedGreatestCommonDivisorL, IsCoprimeI, IsCoprimeL, ContinuedFractionConvergentI, ContinuedFractionConvergentL, RealMod, BitSizeI, BitSizeL, TrailingZeroCountI, TrailingZeroCountL, HammingWeightI, FactorialI, FactorialL, ApproximateFactorial, LogGammaD, LogFactorialD, Binom, SquaredNorm, PNorm, PNormalized, Complex, ComplexPolar, AbsSquaredComplex, AbsComplex, ArgComplex, AbsSquaredComplexPolar, AbsComplexPolar, ArgComplexPolar, NegationC, NegationCP, PlusC, PlusCP, MinusC, MinusCP, TimesC, TimesCP, PowCAsCP, PowC, PowCP, DividedByC, DividedByCP, SmallestFixedPoint, LargestFixedPoint;
+    export PI, E, LogOf2, IsNaN, IsInfinite, SignI, SignD, SignL, AbsI, AbsD, AbsL, MaxI, MaxD, MaxL, MinI, MinD, MinL, Max, Min, ArcCos, ArcSin, ArcTan, ArcTan2, Cos, Cosh, Sin, Sinh, Tan, Tanh, ArcCosh, ArcSinh, ArcTanh, Sqrt, Log, Log10, Lg, Truncate, Ceiling, Floor, Round, DivRemI, DivRemL, ModulusI, ModulusL, ExpModI, ExpModL, InverseModI, InverseModL, GreatestCommonDivisorI, GreatestCommonDivisorL, ExtendedGreatestCommonDivisorI, ExtendedGreatestCommonDivisorL, IsCoprimeI, IsCoprimeL, ContinuedFractionConvergentI, ContinuedFractionConvergentL, RealMod, BitSizeI, BitSizeL, TrailingZeroCountI, TrailingZeroCountL, HammingWeightI, FactorialI, FactorialL, ApproximateFactorial, LogGammaD, LogFactorialD, Binom, SquaredNorm, PNorm, PNormalized, Complex, ComplexPolar, AbsSquaredComplex, AbsComplex, ArgComplex, AbsSquaredComplexPolar, AbsComplexPolar, ArgComplexPolar, NegationC, NegationCP, PlusC, PlusCP, MinusC, MinusCP, TimesC, TimesCP, PowC, PowCP, DividedByC, DividedByCP, SmallestFixedPoint, LargestFixedPoint;
 }

library/qs_source/src/std/unstable_arithmetic_internal.qs

@@ -582,5 +582,4 @@ namespace Microsoft.Quantum.Unstable.Arithmetic {
             ApplyAndAssuming0Target(Tail(tgtsLeft), Tail(tgtsRight), Tail(tgts));
         }
     }
-    export ApplyActionIfGreaterThanOrEqualConstant, ApplyActionIfSumOverflows, ApplyAsSinglyControlled, PhaseGradient;
 }

library/qs_source/src/std/unstable_table_lookup.qs

@@ -274,5 +274,5 @@ namespace Microsoft.Quantum.Unstable.TableLookup {
         }
     }
 
-    export Select, WriteMemoryContents, Unlookup, MustBeFixed, EncodeUnary;
+    export Select;
 }

noisy_simulator/benches/noisy_simulator.rs

@@ -1,13 +1,12 @@
 // Copyright (c) Microsoft Corporation.
 // Licensed under the MIT License.
 
-use std::time::Duration;
-
 use criterion::{criterion_group, criterion_main, Criterion};
 use nalgebra::dmatrix;
 use noisy_simulator::{
     DensityMatrixSimulator, Error, NoisySimulator, Operation, StateVectorSimulator,
 };
+use std::time::Duration;
 
 fn ten_qubits_ten_operations<NS: NoisySimulator>() -> Result<(), Error> {
     let x_gate = Operation::new(vec![

noisy_simulator/src/density_matrix_simulator.rs

@@ -148,9 +148,7 @@ impl DensityMatrix {
         }
         self.trace_change *= trace;
         let renormalization_factor = 1.0 / trace;
-        for entry in self.data.iter_mut() {
-            *entry *= renormalization_factor;
-        }
+        self.data.scale_mut(renormalization_factor);
         Ok(())
     }