GitVita
New repositoryImport repositoryNew issue
Your repositories Your dashboard Sign in

microsoft/qdk

Public

mirrored from https://github.com/microsoft/qdkAvailable

Watch0Fork0Star0
CodeCommitsIssuesPull requestsActionsInsightsSecurity
v1.18.0

Branches

Tags

  • No tags available.
0Branches0Tags
Go to file
Add file
Code

Clone

HTTPS

Download ZIP

qdk/library/src/tests

library/src/tests/arrays.rs

991lines · modecode

RawDownload
Latest commit unavailable.
1// Copyright (c) Microsoft Corporation.
2// Licensed under the MIT License.
3
4use super::test_expression;
5use num_bigint::BigInt;
6use qsc::interpret::Value;
7
8// Tests for Microsoft.Quantum.Arrays namespace
9
10#[test]
11fn check_all() {
12 test_expression(
13 "Microsoft.Quantum.Arrays.All(x -> x != 0, [1, 2, 3, 4, 5])",
14 &Value::Bool(true),
15 );
16 test_expression(
17 "Microsoft.Quantum.Arrays.All(x -> x != 0, [1, 2, 0, 4, 5])",
18 &Value::Bool(false),
19 );
20 test_expression(
21 "Microsoft.Quantum.Arrays.All(x -> x == One, [One, One, One])",
22 &Value::Bool(true),
23 );
24 test_expression(
25 "Microsoft.Quantum.Arrays.All(x -> x == One, [One, One, Zero])",
26 &Value::Bool(false),
27 );
28}
29
30#[test]
31fn check_any() {
32 test_expression(
33 "Microsoft.Quantum.Arrays.Any(x -> x % 2 == 0, [1, 3, 6, 7, 9])",
34 &Value::Bool(true),
35 );
36 test_expression(
37 "Microsoft.Quantum.Arrays.Any(x -> x % 2 == 0, [1, 3, 5, 7, 9])",
38 &Value::Bool(false),
39 );
40}
41
42#[test]
43fn check_chunks() {
44 test_expression(
45 "Microsoft.Quantum.Arrays.Chunks(1, [10, 11, 12, 13, 14, 15])",
46 &Value::Array(
47 vec![
48 Value::Array(vec![Value::Int(10)].into()),
49 Value::Array(vec![Value::Int(11)].into()),
50 Value::Array(vec![Value::Int(12)].into()),
51 Value::Array(vec![Value::Int(13)].into()),
52 Value::Array(vec![Value::Int(14)].into()),
53 Value::Array(vec![Value::Int(15)].into()),
54 ]
55 .into(),
56 ),
57 );
58 test_expression(
59 "{
60 let empty: Int[] = [];
61 Microsoft.Quantum.Arrays.Chunks(2, empty)
62 }",
63 &Value::Array(vec![].into()),
64 );
65 test_expression(
66 "Microsoft.Quantum.Arrays.Chunks(2, [10])",
67 &Value::Array(vec![Value::Array(vec![Value::Int(10)].into())].into()),
68 );
69 test_expression(
70 "Microsoft.Quantum.Arrays.Chunks(2, [10, 11, 12, 13, 14, 15])",
71 &Value::Array(
72 vec![
73 Value::Array(vec![Value::Int(10), Value::Int(11)].into()),
74 Value::Array(vec![Value::Int(12), Value::Int(13)].into()),
75 Value::Array(vec![Value::Int(14), Value::Int(15)].into()),
76 ]
77 .into(),
78 ),
79 );
80 test_expression(
81 "Microsoft.Quantum.Arrays.Chunks(3, [10, 11, 12, 13, 14, 15])",
82 &Value::Array(
83 vec![
84 Value::Array(vec![Value::Int(10), Value::Int(11), Value::Int(12)].into()),
85 Value::Array(vec![Value::Int(13), Value::Int(14), Value::Int(15)].into()),
86 ]
87 .into(),
88 ),
89 );
90 test_expression(
91 "Microsoft.Quantum.Arrays.Chunks(4, [10, 11, 12, 13, 14, 15])",
92 &Value::Array(
93 vec![
94 Value::Array(
95 vec![
96 Value::Int(10),
97 Value::Int(11),
98 Value::Int(12),
99 Value::Int(13),
100 ]
101 .into(),
102 ),
103 Value::Array(vec![Value::Int(14), Value::Int(15)].into()),
104 ]
105 .into(),
106 ),
107 );
108}
109
110#[test]
111fn check_circularly_shifted() {
112 test_expression(
113 "Microsoft.Quantum.Arrays.CircularlyShifted(0, [10, 11, 12])",
114 &Value::Array(vec![Value::Int(10), Value::Int(11), Value::Int(12)].into()),
115 );
116 test_expression(
117 "Microsoft.Quantum.Arrays.CircularlyShifted(1, [10, 11, 12])",
118 &Value::Array(vec![Value::Int(12), Value::Int(10), Value::Int(11)].into()),
119 );
120 test_expression(
121 "Microsoft.Quantum.Arrays.CircularlyShifted(-1, [10, 11, 12])",
122 &Value::Array(vec![Value::Int(11), Value::Int(12), Value::Int(10)].into()),
123 );
124 test_expression(
125 "Microsoft.Quantum.Arrays.CircularlyShifted(500, [10, 11, 12])",
126 &Value::Array(vec![Value::Int(11), Value::Int(12), Value::Int(10)].into()),
127 );
128 test_expression(
129 "Microsoft.Quantum.Arrays.CircularlyShifted(-500, [10, 11, 12])",
130 &Value::Array(vec![Value::Int(12), Value::Int(10), Value::Int(11)].into()),
131 );
132}
133
134#[test]
135fn check_column_at() {
136 test_expression(
137 "Microsoft.Quantum.Arrays.ColumnAt(0, [[1, 2, 3], [4, 5, 6], [7, 8, 9]])",
138 &Value::Array(vec![Value::Int(1), Value::Int(4), Value::Int(7)].into()),
139 );
140 test_expression(
141 "Microsoft.Quantum.Arrays.ColumnAt(2, [[true, true, true], [false, false, false]])",
142 &Value::Array(vec![Value::Bool(true), Value::Bool(false)].into()),
143 );
144 test_expression(
145 "Microsoft.Quantum.Arrays.ColumnAt(1, [[One, One], [Zero, Zero], [Zero, One]])",
146 &Value::Array(vec![Value::RESULT_ONE, Value::RESULT_ZERO, Value::RESULT_ONE].into()),
147 );
148}
149
150#[test]
151fn check_count() {
152 test_expression(
153 "Microsoft.Quantum.Arrays.Count(x -> x % 2 != 0, [1, 3, 6, 7, 9])",
154 &Value::Int(4),
155 );
156 test_expression(
157 "Microsoft.Quantum.Arrays.Count(x -> x % 2 == 0, [1, 3, 6, 7, 9])",
158 &Value::Int(1),
159 );
160}
161
162#[test]
163fn check_diagnonal() {
164 test_expression(
165 "{
166 let empty: Int[][] = [];
167 Microsoft.Quantum.Arrays.Diagonal(empty)
168 }",
169 &Value::Array(vec![].into()),
170 );
171 test_expression(
172 "Microsoft.Quantum.Arrays.Diagonal([[1]])",
173 &Value::Array(vec![Value::Int(1)].into()),
174 );
175 test_expression(
176 "Microsoft.Quantum.Arrays.Diagonal([[1, 2, 3], [4, 5, 6], [7, 8, 9]])",
177 &Value::Array(vec![Value::Int(1), Value::Int(5), Value::Int(9)].into()),
178 );
179 test_expression(
180 "Microsoft.Quantum.Arrays.Diagonal([[1, 2, 3], [4, 5, 6]])",
181 &Value::Array(vec![Value::Int(1), Value::Int(5)].into()),
182 );
183 test_expression(
184 "Microsoft.Quantum.Arrays.Diagonal([[1, 2], [3, 4], [5, 6]])",
185 &Value::Array(vec![Value::Int(1), Value::Int(4)].into()),
186 );
187}
188
189#[test]
190fn check_draw_many() {
191 test_expression(
192 "{
193 use qubit = Qubit();
194 let results = Microsoft.Quantum.Arrays.DrawMany(q => {X(q); M(q)}, 3, qubit);
195 Reset(qubit);
196 results
197 }",
198 &Value::Array(vec![Value::RESULT_ONE, Value::RESULT_ZERO, Value::RESULT_ONE].into()),
199 );
200}
201
202#[test]
203fn check_excluding() {
204 test_expression(
205 "{
206 let empty: Int[] = [];
207 Microsoft.Quantum.Arrays.Excluding(empty, empty)
208 }",
209 &Value::Array(vec![].into()),
210 );
211 test_expression(
212 "Microsoft.Quantum.Arrays.Excluding([], [10, 11, 12, 13, 14, 15])",
213 &Value::Array(
214 vec![
215 Value::Int(10),
216 Value::Int(11),
217 Value::Int(12),
218 Value::Int(13),
219 Value::Int(14),
220 Value::Int(15),
221 ]
222 .into(),
223 ),
224 );
225 test_expression(
226 "Microsoft.Quantum.Arrays.Excluding([1, 3, 4], [10, 11, 12, 13, 14, 15])",
227 &Value::Array(vec![Value::Int(10), Value::Int(12), Value::Int(15)].into()),
228 );
229 test_expression(
230 "Microsoft.Quantum.Arrays.Excluding([3, 1, 4, 1], [10, 11, 12, 13, 14, 15])",
231 &Value::Array(vec![Value::Int(10), Value::Int(12), Value::Int(15)].into()),
232 );
233}
234
235#[test]
236fn check_enumerated() {
237 test_expression(
238 "Microsoft.Quantum.Arrays.Enumerated([false, true, false])",
239 &Value::Array(
240 vec![
241 Value::Tuple(vec![Value::Int(0), Value::Bool(false)].into()),
242 Value::Tuple(vec![Value::Int(1), Value::Bool(true)].into()),
243 Value::Tuple(vec![Value::Int(2), Value::Bool(false)].into()),
244 ]
245 .into(),
246 ),
247 );
248}
249
250#[test]
251fn check_filtered() {
252 test_expression(
253 "Microsoft.Quantum.Arrays.Filtered(x -> x % 2 == 0, [0, 1, 2, 3, 4])",
254 &Value::Array(vec![Value::Int(0), Value::Int(2), Value::Int(4)].into()),
255 );
256 test_expression(
257 "Microsoft.Quantum.Arrays.Filtered(x -> x % 2 != 0, [1, 2, 3, 4, 5])",
258 &Value::Array(vec![Value::Int(1), Value::Int(3), Value::Int(5)].into()),
259 );
260}
261
262#[test]
263fn check_flat_mapped() {
264 test_expression(
265 "Microsoft.Quantum.Arrays.FlatMapped(x -> Repeated(x, 2), [1, 2, 3])",
266 &Value::Array(
267 vec![
268 Value::Int(1),
269 Value::Int(1),
270 Value::Int(2),
271 Value::Int(2),
272 Value::Int(3),
273 Value::Int(3),
274 ]
275 .into(),
276 ),
277 );
278}
279
280#[test]
281fn check_flattened() {
282 test_expression(
283 "Microsoft.Quantum.Arrays.Flattened([[1, 2], [3], [4, 5, 6]])",
284 &Value::Array(
285 vec![
286 Value::Int(1),
287 Value::Int(2),
288 Value::Int(3),
289 Value::Int(4),
290 Value::Int(5),
291 Value::Int(6),
292 ]
293 .into(),
294 ),
295 );
296}
297
298#[test]
299fn check_fold() {
300 test_expression(
301 "Microsoft.Quantum.Arrays.Fold((x, y) -> x + y, 0, [1, 2, 3, 4, 5])",
302 &Value::Int(15),
303 );
304 test_expression(
305 "Microsoft.Quantum.Arrays.Fold((x, y) -> x or y, false, [true, false, true])",
306 &Value::Bool(true),
307 );
308 test_expression(
309 "Microsoft.Quantum.Arrays.Fold((x, y) -> x and y, true, [true, false, true])",
310 &Value::Bool(false),
311 );
312}
313
314#[test]
315fn check_for_each() {
316 test_expression(
317 "{
318 use register = Qubit[3];
319 Microsoft.Quantum.Arrays.ForEach
320 (q => {X(q); Microsoft.Quantum.Measurement.MResetZ(q)},
321 register)
322 }",
323 &Value::Array(vec![Value::RESULT_ONE, Value::RESULT_ONE, Value::RESULT_ONE].into()),
324 );
325}
326
327#[test]
328fn check_head() {
329 test_expression("Microsoft.Quantum.Arrays.Head([5,6,7,8])", &Value::Int(5));
330}
331
332#[test]
333fn check_head_and_rest() {
334 test_expression(
335 "Microsoft.Quantum.Arrays.HeadAndRest([5,6,7,8])",
336 &Value::Tuple(
337 vec![
338 Value::Int(5),
339 Value::Array(vec![Value::Int(6), Value::Int(7), Value::Int(8)].into()),
340 ]
341 .into(),
342 ),
343 );
344}
345
346#[test]
347fn check_index_of() {
348 test_expression(
349 "Microsoft.Quantum.Arrays.IndexOf(x -> x % 2 != 0, [10, 8, 6, 5, 4])",
350 &Value::Int(3),
351 );
352 test_expression(
353 "Microsoft.Quantum.Arrays.IndexOf(x -> x % 2 == 0, [1, 3, 4, 5, 7])",
354 &Value::Int(2),
355 );
356 test_expression(
357 "Microsoft.Quantum.Arrays.IndexOf(x -> x % 2 == 0, [1, 3, 5, 7, 9])",
358 &Value::Int(-1),
359 );
360}
361
362#[test]
363fn check_index_range() {
364 test_expression(
365 "Microsoft.Quantum.Arrays.IndexRange([7,6,5,4])::Start",
366 &Value::Int(0),
367 );
368 test_expression(
369 "Microsoft.Quantum.Arrays.IndexRange([7,6,5,4])::Step",
370 &Value::Int(1),
371 );
372 test_expression(
373 "Microsoft.Quantum.Arrays.IndexRange([7,6,5,4])::End",
374 &Value::Int(3),
375 );
376}
377
378#[test]
379fn check_interleaved() {
380 test_expression(
381 "Microsoft.Quantum.Arrays.Interleaved([1, 2, 3], [-1, -2, -3])",
382 &Value::Array(
383 vec![
384 Value::Int(1),
385 Value::Int(-1),
386 Value::Int(2),
387 Value::Int(-2),
388 Value::Int(3),
389 Value::Int(-3),
390 ]
391 .into(),
392 ),
393 );
394 test_expression(
395 "Microsoft.Quantum.Arrays.Interleaved([true, true], [false])",
396 &Value::Array(vec![Value::Bool(true), Value::Bool(false), Value::Bool(true)].into()),
397 );
398}
399
400#[test]
401fn check_is_empty() {
402 test_expression(
403 "{
404 let empty: Int[] = [];
405 Microsoft.Quantum.Arrays.IsEmpty(empty)
406 }",
407 &Value::Bool(true),
408 );
409 test_expression("Microsoft.Quantum.Arrays.IsEmpty([1])", &Value::Bool(false));
410 test_expression(
411 "Microsoft.Quantum.Arrays.IsEmpty([1, 2, 3, 4, 5])",
412 &Value::Bool(false),
413 );
414}
415
416#[test]
417fn check_is_rectangular_array() {
418 test_expression(
419 "{
420 let empty: Int[] = [];
421 Microsoft.Quantum.Arrays.IsRectangularArray([empty])
422 }",
423 &Value::Bool(true),
424 );
425 test_expression(
426 "Microsoft.Quantum.Arrays.IsRectangularArray([[1]])",
427 &Value::Bool(true),
428 );
429 test_expression(
430 "Microsoft.Quantum.Arrays.IsRectangularArray([[1, 2], [3, 4]])",
431 &Value::Bool(true),
432 );
433 test_expression(
434 "Microsoft.Quantum.Arrays.IsRectangularArray([[1, 2, 3], [4, 5, 6]])",
435 &Value::Bool(true),
436 );
437 test_expression(
438 "Microsoft.Quantum.Arrays.IsRectangularArray([[1, 2], [3, 4, 5]])",
439 &Value::Bool(false),
440 );
441}
442
443#[test]
444fn check_is_sorted() {
445 test_expression(
446 "{
447 let empty: Int[] = [];
448 Microsoft.Quantum.Arrays.IsSorted((x, y) -> x <= y, empty)
449 }",
450 &Value::Bool(true),
451 );
452 test_expression(
453 "Microsoft.Quantum.Arrays.IsSorted((x, y) -> x <= y, [1])",
454 &Value::Bool(true),
455 );
456 test_expression(
457 "Microsoft.Quantum.Arrays.IsSorted((x, y) -> x <= y, [1, 2, 3, 4, 5])",
458 &Value::Bool(true),
459 );
460 test_expression(
461 "Microsoft.Quantum.Arrays.IsSorted((x, y) -> x >= y, [5, 4, 3, 2, 1])",
462 &Value::Bool(true),
463 );
464 test_expression(
465 "Microsoft.Quantum.Arrays.IsSorted((x, y) -> x <= y, [1, 2, 3, 5, 4])",
466 &Value::Bool(false),
467 );
468 test_expression(
469 "Microsoft.Quantum.Arrays.IsSorted((x, y) -> x <= y, [5, 4, 3, 2, 1])",
470 &Value::Bool(false),
471 );
472}
473
474#[test]
475fn check_is_square_array() {
476 test_expression(
477 "{
478 let empty: Int[][] = [];
479 Microsoft.Quantum.Arrays.IsSquareArray(empty)
480 }",
481 &Value::Bool(true),
482 );
483 test_expression(
484 "Microsoft.Quantum.Arrays.IsSquareArray([[1]])",
485 &Value::Bool(true),
486 );
487 test_expression(
488 "Microsoft.Quantum.Arrays.IsSquareArray([[1, 2], [3, 4]])",
489 &Value::Bool(true),
490 );
491 test_expression(
492 "Microsoft.Quantum.Arrays.IsSquareArray([[1, 2, 3], [4, 5, 6]])",
493 &Value::Bool(false),
494 );
495 test_expression(
496 "Microsoft.Quantum.Arrays.IsSquareArray([[1, 2], [3, 4], [5, 6]])",
497 &Value::Bool(false),
498 );
499}
500
501#[test]
502fn check_mapped() {
503 test_expression(
504 "Microsoft.Quantum.Arrays.Mapped(i -> i * 2, [0, 1, 2])",
505 &Value::Array(vec![Value::Int(0), Value::Int(2), Value::Int(4)].into()),
506 );
507}
508
509#[test]
510fn check_mapped_by_index() {
511 test_expression(
512 "Microsoft.Quantum.Arrays.MappedByIndex((index, element) -> index == element ,[0, -1, 2])",
513 &Value::Array(vec![Value::Bool(true), Value::Bool(false), Value::Bool(true)].into()),
514 );
515}
516
517#[test]
518fn check_mapped_over_range() {
519 test_expression(
520 "Microsoft.Quantum.Arrays.MappedOverRange(x -> x + 1, 0..2..10)",
521 &Value::Array(
522 vec![
523 Value::Int(1),
524 Value::Int(3),
525 Value::Int(5),
526 Value::Int(7),
527 Value::Int(9),
528 Value::Int(11),
529 ]
530 .into(),
531 ),
532 );
533 test_expression(
534 "Microsoft.Quantum.Arrays.MappedOverRange(x -> x * 2, 3..-1..1)",
535 &Value::Array(vec![Value::Int(6), Value::Int(4), Value::Int(2)].into()),
536 );
537}
538
539#[test]
540fn check_most() {
541 test_expression(
542 "Microsoft.Quantum.Arrays.Most([5, 6, 7, 8])",
543 &Value::Array(vec![Value::Int(5), Value::Int(6), Value::Int(7)].into()),
544 );
545}
546
547#[test]
548fn check_most_and_tail() {
549 test_expression(
550 "Microsoft.Quantum.Arrays.MostAndTail([5, 6, 7, 8])",
551 &Value::Tuple(
552 vec![
553 Value::Array(vec![Value::Int(5), Value::Int(6), Value::Int(7)].into()),
554 Value::Int(8),
555 ]
556 .into(),
557 ),
558 );
559}
560
561#[test]
562fn check_padded() {
563 test_expression(
564 "Microsoft.Quantum.Arrays.Padded(-5, 2, [10, 11, 12])",
565 &Value::Array(
566 vec![
567 Value::Int(10),
568 Value::Int(11),
569 Value::Int(12),
570 Value::Int(2),
571 Value::Int(2),
572 ]
573 .into(),
574 ),
575 );
576 test_expression(
577 "Microsoft.Quantum.Arrays.Padded(5, 2, [10, 11, 12])",
578 &Value::Array(
579 vec![
580 Value::Int(2),
581 Value::Int(2),
582 Value::Int(10),
583 Value::Int(11),
584 Value::Int(12),
585 ]
586 .into(),
587 ),
588 );
589 test_expression(
590 "Microsoft.Quantum.Arrays.Padded(3, 2, [10, 11, 12])",
591 &Value::Array(vec![Value::Int(10), Value::Int(11), Value::Int(12)].into()),
592 );
593 test_expression(
594 "Microsoft.Quantum.Arrays.Padded(-3, 2, [10, 11, 12])",
595 &Value::Array(vec![Value::Int(10), Value::Int(11), Value::Int(12)].into()),
596 );
597}
598
599#[test]
600fn check_partitioned() {
601 test_expression(
602 "Microsoft.Quantum.Arrays.Partitioned([2, 1], [2, 3, 5, 7])",
603 &Value::Array(
604 vec![
605 Value::Array(vec![Value::Int(2), Value::Int(3)].into()),
606 Value::Array(vec![Value::Int(5)].into()),
607 Value::Array(vec![Value::Int(7)].into()),
608 ]
609 .into(),
610 ),
611 );
612 test_expression(
613 "Microsoft.Quantum.Arrays.Partitioned([2, 2], [2, 3, 5, 7])",
614 &Value::Array(
615 vec![
616 Value::Array(vec![Value::Int(2), Value::Int(3)].into()),
617 Value::Array(vec![Value::Int(5), Value::Int(7)].into()),
618 Value::Array(vec![].into()),
619 ]
620 .into(),
621 ),
622 );
623}
624
625#[test]
626fn check_sequence_i() {
627 test_expression(
628 "Microsoft.Quantum.Arrays.SequenceI(0, 3)",
629 &Value::Array(vec![Value::Int(0), Value::Int(1), Value::Int(2), Value::Int(3)].into()),
630 );
631 test_expression(
632 "Microsoft.Quantum.Arrays.SequenceI(-5, -2)",
633 &Value::Array(
634 vec![
635 Value::Int(-5),
636 Value::Int(-4),
637 Value::Int(-3),
638 Value::Int(-2),
639 ]
640 .into(),
641 ),
642 );
643}
644
645#[test]
646fn check_sequence_l() {
647 test_expression(
648 "Microsoft.Quantum.Arrays.SequenceL(0L, 3L)",
649 &Value::Array(
650 vec![
651 Value::BigInt(BigInt::from(0)),
652 Value::BigInt(BigInt::from(1)),
653 Value::BigInt(BigInt::from(2)),
654 Value::BigInt(BigInt::from(3)),
655 ]
656 .into(),
657 ),
658 );
659 test_expression(
660 "Microsoft.Quantum.Arrays.SequenceL(-5L, -2L)",
661 &Value::Array(
662 vec![
663 Value::BigInt(BigInt::from(-5)),
664 Value::BigInt(BigInt::from(-4)),
665 Value::BigInt(BigInt::from(-3)),
666 Value::BigInt(BigInt::from(-2)),
667 ]
668 .into(),
669 ),
670 );
671}
672
673#[test]
674fn check_sorted() {
675 test_expression(
676 "{
677 let empty: Int[] = [];
678 Microsoft.Quantum.Arrays.Sorted((x, y) -> x <= y, empty)
679 }",
680 &Value::Array(vec![].into()),
681 );
682 test_expression(
683 "Microsoft.Quantum.Arrays.Sorted((x, y) -> x <= y, [-1])",
684 &Value::Array(vec![Value::Int(-1)].into()),
685 );
686 test_expression(
687 "Microsoft.Quantum.Arrays.Sorted((x, y) -> x <= y, [1, 2, 0, 4, 3])",
688 &Value::Array(
689 vec![
690 Value::Int(0),
691 Value::Int(1),
692 Value::Int(2),
693 Value::Int(3),
694 Value::Int(4),
695 ]
696 .into(),
697 ),
698 );
699 test_expression(
700 "Microsoft.Quantum.Arrays.Sorted((x, y) -> x >= y, [1, 2, 0, 4, 3])",
701 &Value::Array(
702 vec![
703 Value::Int(4),
704 Value::Int(3),
705 Value::Int(2),
706 Value::Int(1),
707 Value::Int(0),
708 ]
709 .into(),
710 ),
711 );
712 test_expression(
713 "Microsoft.Quantum.Arrays.Sorted((x, y) -> x <= y, [-1, 2, 0, 1, -2])",
714 &Value::Array(
715 vec![
716 Value::Int(-2),
717 Value::Int(-1),
718 Value::Int(0),
719 Value::Int(1),
720 Value::Int(2),
721 ]
722 .into(),
723 ),
724 );
725}
726
727#[test]
728fn check_rest() {
729 test_expression(
730 "Microsoft.Quantum.Arrays.Rest([5,6,7,8])",
731 &Value::Array(vec![Value::Int(6), Value::Int(7), Value::Int(8)].into()),
732 );
733}
734
735#[test]
736fn check_reversed() {
737 test_expression(
738 "Microsoft.Quantum.Arrays.Reversed([5,6,7,8])",
739 &Value::Array(vec![Value::Int(8), Value::Int(7), Value::Int(6), Value::Int(5)].into()),
740 );
741}
742
743#[test]
744fn check_subarray() {
745 test_expression(
746 "Microsoft.Quantum.Arrays.Subarray([3, 0, 2, 1], [1, 2, 3, 4])",
747 &Value::Array(vec![Value::Int(4), Value::Int(1), Value::Int(3), Value::Int(2)].into()),
748 );
749 test_expression(
750 "Microsoft.Quantum.Arrays.Subarray([1, 2, 2], [1, 2, 3, 4])",
751 &Value::Array(vec![Value::Int(2), Value::Int(3), Value::Int(3)].into()),
752 );
753 test_expression(
754 "Microsoft.Quantum.Arrays.Subarray([0, 0, 0, 0, 0], [false])",
755 &Value::Array(
756 vec![
757 Value::Bool(false),
758 Value::Bool(false),
759 Value::Bool(false),
760 Value::Bool(false),
761 Value::Bool(false),
762 ]
763 .into(),
764 ),
765 );
766}
767
768#[test]
769fn check_swapped() {
770 test_expression(
771 "Microsoft.Quantum.Arrays.Swapped(1, 3, [0, 1, 2, 3, 4])",
772 &Value::Array(
773 vec![
774 Value::Int(0),
775 Value::Int(3),
776 Value::Int(2),
777 Value::Int(1),
778 Value::Int(4),
779 ]
780 .into(),
781 ),
782 );
783}
784
785#[test]
786fn check_tail() {
787 test_expression("Microsoft.Quantum.Arrays.Tail([5,6,7,8])", &Value::Int(8));
788}
789
790#[test]
791fn check_transposed() {
792 test_expression(
793 "Microsoft.Quantum.Arrays.Transposed([[1, 2, 3], [4, 5, 6]])",
794 &Value::Array(
795 vec![
796 Value::Array(vec![Value::Int(1), Value::Int(4)].into()),
797 Value::Array(vec![Value::Int(2), Value::Int(5)].into()),
798 Value::Array(vec![Value::Int(3), Value::Int(6)].into()),
799 ]
800 .into(),
801 ),
802 );
803 test_expression(
804 "Microsoft.Quantum.Arrays.Transposed([[1, 4], [2, 5], [3, 6]])",
805 &Value::Array(
806 vec![
807 Value::Array(vec![Value::Int(1), Value::Int(2), Value::Int(3)].into()),
808 Value::Array(vec![Value::Int(4), Value::Int(5), Value::Int(6)].into()),
809 ]
810 .into(),
811 ),
812 );
813}
814
815#[test]
816fn check_unzipped() {
817 test_expression(
818 "{
819 let empty: (Int, Int)[] = [];
820 Microsoft.Quantum.Arrays.Unzipped(empty)
821 }",
822 &Value::Tuple(vec![Value::Array(vec![].into()), Value::Array(vec![].into())].into()),
823 );
824 test_expression(
825 "Microsoft.Quantum.Arrays.Unzipped([(5, true), (4, false), (3, true), (2, true), (1, false)])",
826 &Value::Tuple(
827 vec![
828 Value::Array(vec![Value::Int(5), Value::Int(4), Value::Int(3), Value::Int(2), Value::Int(1)].into()),
829 Value::Array(
830 vec![
831 Value::Bool(true),
832 Value::Bool(false),
833 Value::Bool(true),
834 Value::Bool(true),
835 Value::Bool(false)
836 ]
837 .into()
838 ),
839 ]
840 .into()
841 ),
842 );
843 test_expression(
844 "Microsoft.Quantum.Arrays.Unzipped([(true, 5), (false, 4), (true, 3), (true, 2), (false, 1)])",
845 &Value::Tuple(
846 vec![
847 Value::Array(
848 vec![
849 Value::Bool(true),
850 Value::Bool(false),
851 Value::Bool(true),
852 Value::Bool(true),
853 Value::Bool(false)
854 ]
855 .into()
856 ),
857 Value::Array(vec![Value::Int(5), Value::Int(4), Value::Int(3), Value::Int(2), Value::Int(1)].into()),
858 ]
859 .into()
860 ),
861 );
862}
863
864#[test]
865fn check_where() {
866 test_expression(
867 "Microsoft.Quantum.Arrays.Where(x -> x % 2 == 0, [0, 1, 2, 3, 4])",
868 &Value::Array(vec![Value::Int(0), Value::Int(2), Value::Int(4)].into()),
869 );
870 test_expression(
871 "Microsoft.Quantum.Arrays.Where(x -> x % 2 != 0, [1, 2, 3, 4, 5])",
872 &Value::Array(vec![Value::Int(0), Value::Int(2), Value::Int(4)].into()),
873 );
874}
875
876#[test]
877fn check_windows() {
878 test_expression(
879 "Microsoft.Quantum.Arrays.Windows(1, [1, 2, 3, 4, 5])",
880 &Value::Array(
881 vec![
882 Value::Array(vec![Value::Int(1)].into()),
883 Value::Array(vec![Value::Int(2)].into()),
884 Value::Array(vec![Value::Int(3)].into()),
885 Value::Array(vec![Value::Int(4)].into()),
886 Value::Array(vec![Value::Int(5)].into()),
887 ]
888 .into(),
889 ),
890 );
891 test_expression(
892 "Microsoft.Quantum.Arrays.Windows(3, [1, 2, 3, 4, 5])",
893 &Value::Array(
894 vec![
895 Value::Array(vec![Value::Int(1), Value::Int(2), Value::Int(3)].into()),
896 Value::Array(vec![Value::Int(2), Value::Int(3), Value::Int(4)].into()),
897 Value::Array(vec![Value::Int(3), Value::Int(4), Value::Int(5)].into()),
898 ]
899 .into(),
900 ),
901 );
902 test_expression(
903 "Microsoft.Quantum.Arrays.Windows(5, [1, 2, 3, 4, 5])",
904 &Value::Array(
905 vec![Value::Array(
906 vec![
907 Value::Int(1),
908 Value::Int(2),
909 Value::Int(3),
910 Value::Int(4),
911 Value::Int(5),
912 ]
913 .into(),
914 )]
915 .into(),
916 ),
917 );
918}
919
920#[test]
921fn check_zipped() {
922 test_expression(
923 "{
924 let empty: Int[] = [];
925 Microsoft.Quantum.Arrays.Zipped(empty, empty)
926 }",
927 &Value::Array(vec![].into()),
928 );
929 test_expression(
930 "{
931 let empty: Int[] = [];
932 Microsoft.Quantum.Arrays.Zipped([1], empty)
933 }",
934 &Value::Array(vec![].into()),
935 );
936 test_expression(
937 "{
938 let empty: Int[] = [];
939 Microsoft.Quantum.Arrays.Zipped(empty, [false])
940 }",
941 &Value::Array(vec![].into()),
942 );
943 test_expression(
944 "Microsoft.Quantum.Arrays.Zipped([1, 2, 3, 4, 5], [false, true, true, false, true])",
945 &Value::Array(
946 vec![
947 Value::Tuple(vec![Value::Int(1), Value::Bool(false)].into()),
948 Value::Tuple(vec![Value::Int(2), Value::Bool(true)].into()),
949 Value::Tuple(vec![Value::Int(3), Value::Bool(true)].into()),
950 Value::Tuple(vec![Value::Int(4), Value::Bool(false)].into()),
951 Value::Tuple(vec![Value::Int(5), Value::Bool(true)].into()),
952 ]
953 .into(),
954 ),
955 );
956 test_expression(
957 "Microsoft.Quantum.Arrays.Zipped([false, true, true, false, true], [1, 2, 3, 4, 5])",
958 &Value::Array(
959 vec![
960 Value::Tuple(vec![Value::Bool(false), Value::Int(1)].into()),
961 Value::Tuple(vec![Value::Bool(true), Value::Int(2)].into()),
962 Value::Tuple(vec![Value::Bool(true), Value::Int(3)].into()),
963 Value::Tuple(vec![Value::Bool(false), Value::Int(4)].into()),
964 Value::Tuple(vec![Value::Bool(true), Value::Int(5)].into()),
965 ]
966 .into(),
967 ),
968 );
969 test_expression(
970 "Microsoft.Quantum.Arrays.Zipped([1, 2, 3], [false, true, true, false, true])",
971 &Value::Array(
972 vec![
973 Value::Tuple(vec![Value::Int(1), Value::Bool(false)].into()),
974 Value::Tuple(vec![Value::Int(2), Value::Bool(true)].into()),
975 Value::Tuple(vec![Value::Int(3), Value::Bool(true)].into()),
976 ]
977 .into(),
978 ),
979 );
980 test_expression(
981 "Microsoft.Quantum.Arrays.Zipped([1, 2, 3, 4, 5], [false, true, true])",
982 &Value::Array(
983 vec![
984 Value::Tuple(vec![Value::Int(1), Value::Bool(false)].into()),
985 Value::Tuple(vec![Value::Int(2), Value::Bool(true)].into()),
986 Value::Tuple(vec![Value::Int(3), Value::Bool(true)].into()),
987 ]
988 .into(),
989 ),
990 );
991}
992