Fix warnings QS3302-3303 (deprecated || and &&) (#93)

microsoft · Apr 16, 2019 · 963ed6d · 963ed6d
1 parent 9128297
commit 963ed6d
Show file tree

Hide file tree

Showing 8 changed files with 18 additions and 18 deletions.
diff --git a/Measurements/ReferenceImplementation.qs b/Measurements/ReferenceImplementation.qs
@@ -119,7 +119,7 @@ namespace Quantum.Kata.Measurements {
 
         mutable firstDiff = -1;
         for (i in 0 .. Length(bits1) - 1) {
-            if (bits1[i] != bits2[i] && firstDiff == -1) {
+            if (bits1[i] != bits2[i] and firstDiff == -1) {
                 set firstDiff = i;
             }
         }
@@ -185,7 +185,7 @@ namespace Quantum.Kata.Measurements {
             }
         }
 
-        if (countOnes > 1 && countOnes < Length(qs)) {
+        if (countOnes > 1 and countOnes < Length(qs)) {
             fail $"Impossible to get {countOnes} Ones when measuring W state or GHZ state on {N} qubits";
         }
         if (countOnes == 1) {

diff --git a/Measurements/Tests.qs b/Measurements/Tests.qs
@@ -464,7 +464,7 @@ namespace Quantum.Kata.Measurements {
                 let ans = testImpl(qs[0]);
 
                 // check that the answer is actually in allowed range
-                if (ans < -1 || ans > 1) {
+                if (ans < -1 or ans > 1) {
                     fail $"state {state} led to invalid response {ans}.";
                 }
 
@@ -473,16 +473,16 @@ namespace Quantum.Kata.Measurements {
                     set nInconc = nInconc + 1;
                 }
 
-                if (ans == 0 && state == 0) {
+                if (ans == 0 and state == 0) {
                     set nConclOne = nConclOne + 1;
                 }
 
-                if (ans == 1 && state == 1) {
+                if (ans == 1 and state == 1) {
                     set nConclPlus = nConclPlus + 1;
                 }
 
                 // check if upon conclusive result the answer is actually correct
-                if (ans == 0 && state == 1 || ans == 1 && state == 0) {
+                if (ans == 0 and state == 1 or ans == 1 and state == 0) {
                     fail $"state {state} led to incorrect conclusive response {ans}.";
                 }
 

diff --git a/PhaseEstimation/ReferenceImplementation.qs b/PhaseEstimation/ReferenceImplementation.qs
@@ -152,7 +152,7 @@ namespace Quantum.Kata.PhaseEstimation {
 
                 // repeat the loop until we get both Zero and One measurement outcomes
                 // or until we're reasonably certain that we won't get a different outcome
-            } until (iter == 10 || nZero > 0 && nOne > 0)
+            } until (iter == 10 or nZero > 0 and nOne > 0)
             fixup {}
 
             Reset(eigenstate);

diff --git a/QEC_BitFlipCode/ReferenceImplementation.qs b/QEC_BitFlipCode/ReferenceImplementation.qs
@@ -51,15 +51,15 @@ namespace Quantum.Kata.QEC_BitFlipCode {
         let m1 = Measure([PauliZ, PauliZ], register[0 .. 1]);
         let m2 = Measure([PauliZ, PauliZ], register[1 .. 2]);
 
-        if (m1 == One && m2 == Zero) {
+        if (m1 == One and m2 == Zero) {
             return 1;
         }
 
-        if (m1 == One && m2 == One) {
+        if (m1 == One and m2 == One) {
             return 2;
         }
 
-        if (m1 == Zero && m2 == One) {
+        if (m1 == Zero and m2 == One) {
             return 3;
         }
 

diff --git a/QEC_BitFlipCode/Tests.qs b/QEC_BitFlipCode/Tests.qs
@@ -52,7 +52,7 @@ namespace Quantum.Kata.QEC_BitFlipCode {
     function FindFirstDiff_Reference (bits1 : Int[], bits2 : Int[]) : Int {
         mutable firstDiff = -1;
         for (i in 0 .. Length(bits1) - 1) {
-            if (bits1[i] != bits2[i] && firstDiff == -1) {
+            if (bits1[i] != bits2[i] and firstDiff == -1) {
                 set firstDiff = i;
             }
         }

diff --git a/SolveSATWithGrover/Tests.qs b/SolveSATWithGrover/Tests.qs
@@ -69,7 +69,7 @@ namespace Quantum.Kata.GroversAlgorithm {
 
     // ------------------------------------------------------
     function And (args : Bool[]) : Bool {
-        return args[0] && args[1];
+        return args[0] and args[1];
     }
 
     operation T11_Oracle_And_Test () : Unit {
@@ -83,7 +83,7 @@ namespace Quantum.Kata.GroversAlgorithm {
 
     // ------------------------------------------------------
     function Or (args : Bool[]) : Bool {
-        return args[0] || args[1];
+        return args[0] or args[1];
     }
 
     operation T12_Oracle_Or_Test () : Unit {

diff --git a/Superposition/ReferenceImplementation.qs b/Superposition/ReferenceImplementation.qs
@@ -262,7 +262,7 @@ namespace Quantum.Kata.Superposition {
     function FindFirstDiff_Reference (bits1 : Bool[], bits2 : Bool[]) : Int {
         mutable firstDiff = -1;
         for (i in 0 .. Length(bits1) - 1) {
-            if (bits1[i] != bits2[i] && firstDiff == -1) {
+            if (bits1[i] != bits2[i] and firstDiff == -1) {
                 set firstDiff = i;
             }
         }
@@ -482,7 +482,7 @@ namespace Quantum.Kata.Superposition {
                         // measure ancilla qubits; if all of the results are Zero, we get the right state on main qubits
                         mutable allZeros = true;
                         for (i in 0 .. (P - N) - 1) {
-                            set allZeros = allZeros && IsResultZero(M(anc[i]));
+                            set allZeros = allZeros and IsResultZero(M(anc[i]));
                         }
                     }
                     until (allZeros)

diff --git a/UnitaryPatterns/Tests.qs b/UnitaryPatterns/Tests.qs
@@ -231,7 +231,7 @@ namespace Quantum.Kata.UnitaryPatterns {
 
     // ------------------------------------------------------
     function XWing_Fighter_Pattern (size : Int, row : Int, col : Int) : Bool {
-        return row == col || row == (size - 1) - col;
+        return row == col or row == (size - 1) - col;
     }
 
 
@@ -245,8 +245,8 @@ namespace Quantum.Kata.UnitaryPatterns {
     // ------------------------------------------------------
     function Rhombus_Pattern (size : Int, row : Int, col : Int) : Bool {
         let s2 = size / 2;
-        return row / s2 == col / s2 && row % s2 + col % s2 == s2 - 1 || 
-               row / s2 != col / s2 && row % s2 == col % s2;
+        return row / s2 == col / s2 and row % s2 + col % s2 == s2 - 1 or 
+               row / s2 != col / s2 and row % s2 == col % s2;
     }