GitVita
New repositoryImport repositoryNew issue
Your repositories Your dashboard Sign in

microsoft/qdk

Public

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

Watch0Fork0Star0
CodeCommitsIssuesPull requestsActionsInsightsSecurity
cesarzc/ssa-panic

Branches

Tags

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

Clone

HTTPS

Download ZIP

qdk/compiler/qsc_eval/src/state

compiler/qsc_eval/src/state/tests.rs

926lines · modecode

RawDownload
Latest commit unavailable.
1// Copyright (c) Microsoft Corporation.
2// Licensed under the MIT License.
3
4#![allow(clippy::needless_raw_string_hashes)]
5
6use super::{
7 get_latex, write_latex_for_algebraic_number, write_latex_for_cartesian_form,
8 write_latex_for_decimal_number, write_latex_for_polar_form, write_latex_for_real_number,
9 write_latex_for_term, AlgebraicNumber, CartesianForm, ComplexNumber, DecimalNumber, PolarForm,
10 RationalNumber, RealNumber, Term,
11};
12use crate::state::{is_fractional_part_significant, is_significant};
13use expect_test::{expect, Expect};
14use num_complex::Complex64;
15use std::{f64::consts::PI, time::Instant};
16
17#[test]
18fn check_is_significant() {
19 assert!(!is_significant(0.0));
20 assert!(!is_significant(1e-10));
21 assert!(!is_significant(-1e-10));
22 assert!(is_significant(1.1e-9));
23 assert!(is_significant(-1.1e-9));
24 assert!(is_significant(1.0));
25 assert!(is_significant(-1.0));
26}
27
28#[test]
29fn check_is_fractional_part_significant() {
30 assert!(!is_fractional_part_significant(0.0));
31 assert!(!is_fractional_part_significant(1e-10));
32 assert!(!is_fractional_part_significant(-1e-10));
33 assert!(is_fractional_part_significant(1.1e-9));
34 assert!(is_fractional_part_significant(-1.1e-9));
35 assert!(!is_fractional_part_significant(1.000_000_000_1));
36 assert!(!is_fractional_part_significant(-1.000_000_000_1));
37 assert!(is_fractional_part_significant(1.000_000_001));
38 assert!(is_fractional_part_significant(-1.000_000_001));
39}
40
41fn assert_rational_value(x: Option<RationalNumber>, expected: (i64, i64, i64)) {
42 match x {
43 None => panic!("Expected rational number."),
44 Some(r) => assert!(
45 r.sign == expected.0 && r.numerator == expected.1 && r.denominator == expected.2
46 ),
47 }
48}
49
50#[test]
51fn check_construct_rational() {
52 assert_rational_value(Some(RationalNumber::new(1, 2)), (1, 1, 2));
53 assert_rational_value(Some(RationalNumber::new(-1, 2)), (-1, 1, 2));
54 assert_rational_value(Some(RationalNumber::new(1, -2)), (-1, 1, 2));
55 assert_rational_value(Some(RationalNumber::new(-1, -2)), (1, 1, 2));
56 // Although 0 is never used in the code we check it for completeness.
57 assert_rational_value(Some(RationalNumber::new(0, 1)), (0, 0, 1));
58 expect!([r"
59 RationalNumber {
60 sign: 1,
61 numerator: 1,
62 denominator: 2,
63 }
64 "])
65 .assert_debug_eq(&RationalNumber::new(1, 2));
66}
67
68#[test]
69fn check_abs_rational() {
70 assert_rational_value(Some(RationalNumber::new(1, 2).abs()), (1, 1, 2));
71 assert_rational_value(Some(RationalNumber::new(-1, 2).abs()), (1, 1, 2));
72 assert_rational_value(Some(RationalNumber::new(1, -2).abs()), (1, 1, 2));
73 assert_rational_value(Some(RationalNumber::new(-1, -2).abs()), (1, 1, 2));
74 // Although 0 is never used in the code we check it for completeness.
75 assert_rational_value(Some(RationalNumber::new(0, 1).abs()), (0, 0, 1));
76}
77
78#[test]
79fn check_recognize_rational() {
80 assert_rational_value(RationalNumber::recognize(1.0 / 1.0), (1, 1, 1));
81 assert_rational_value(RationalNumber::recognize(1.0 / 2.0), (1, 1, 2));
82 assert_rational_value(RationalNumber::recognize(1.0 / 3.0), (1, 1, 3));
83 assert_rational_value(RationalNumber::recognize(-5.0 / 7.0), (-1, 5, 7));
84 assert!(RationalNumber::recognize(1.0 / 1000.0).is_none());
85 assert!(RationalNumber::recognize(1000.0 / 1.0).is_none());
86 // Although 0 is never used in the code we check it for completeness.
87 assert_rational_value(RationalNumber::recognize(0.0), (0, 0, 1));
88}
89
90fn assert_algebraic_value(x: Option<AlgebraicNumber>, expected: (i64, i64, i64, i64, i64)) {
91 match x {
92 None => panic!("Expected algebraic number."),
93 Some(a) => assert!(
94 a.sign == expected.0
95 && a.fraction.sign == expected.1
96 && a.fraction.numerator == expected.2
97 && a.fraction.denominator == expected.3
98 && a.root == expected.4
99 ),
100 }
101}
102
103#[test]
104fn check_construct_algebraic() {
105 assert_algebraic_value(
106 Some(AlgebraicNumber::new(&RationalNumber::new(1, 2), 3)),
107 (1, 1, 1, 2, 3),
108 );
109 assert_algebraic_value(
110 Some(AlgebraicNumber::new(&RationalNumber::new(-1, 2), 3)),
111 (-1, 1, 1, 2, 3),
112 );
113 assert_algebraic_value(
114 Some(AlgebraicNumber::new(&RationalNumber::new(1, -2), 3)),
115 (-1, 1, 1, 2, 3),
116 );
117 assert_algebraic_value(
118 Some(AlgebraicNumber::new(&RationalNumber::new(-1, -2), 3)),
119 (1, 1, 1, 2, 3),
120 );
121 expect!([r"
122 AlgebraicNumber {
123 sign: 1,
124 fraction: RationalNumber {
125 sign: 1,
126 numerator: 1,
127 denominator: 2,
128 },
129 root: 3,
130 }
131 "])
132 .assert_debug_eq(&AlgebraicNumber::new(&RationalNumber::new(1, 2), 3));
133}
134
135#[test]
136fn check_recognize_algebraic() {
137 assert_algebraic_value(AlgebraicNumber::recognize(5.0), (1, 1, 5, 1, 1));
138 assert_algebraic_value(AlgebraicNumber::recognize(1.0 / 7.0), (1, 1, 1, 7, 1));
139 assert_algebraic_value(AlgebraicNumber::recognize(7.0 / 10.0), (1, 1, 7, 10, 1));
140 assert_algebraic_value(
141 AlgebraicNumber::recognize(2.0 * 2.0_f64.sqrt()),
142 (1, 1, 2, 1, 2),
143 );
144 assert_algebraic_value(AlgebraicNumber::recognize(8.0_f64.sqrt()), (1, 1, 2, 1, 2));
145 assert_algebraic_value(
146 AlgebraicNumber::recognize(5.0_f64.sqrt() / 15.0),
147 (1, 1, 1, 15, 5),
148 );
149 assert_algebraic_value(
150 AlgebraicNumber::recognize(3.0 / 5.0 * 2.0_f64.sqrt()),
151 (1, 1, 3, 5, 2),
152 );
153 assert_algebraic_value(
154 AlgebraicNumber::recognize(-3.0 / 5.0 * 2.0_f64.sqrt()),
155 (-1, 1, 3, 5, 2),
156 );
157}
158
159fn assert_decimal_value(x: &DecimalNumber, expected: (i64, f64)) {
160 assert!(x.sign == expected.0 && (x.value - expected.1).abs() < f64::EPSILON);
161}
162
163#[test]
164fn check_construct_decimal() {
165 assert_decimal_value(&DecimalNumber::new(0.777), (1, 0.777));
166 assert_decimal_value(&DecimalNumber::new(-0.777), (-1, 0.777));
167 expect!([r"
168 DecimalNumber {
169 sign: 1,
170 value: 1.0,
171 }
172 "])
173 .assert_debug_eq(&DecimalNumber::new(1.0));
174}
175
176#[test]
177fn check_recognize_decimal() {
178 assert_decimal_value(&DecimalNumber::recognize(0.777), (1, 0.777));
179 assert_decimal_value(&DecimalNumber::recognize(-0.777), (-1, 0.777));
180}
181
182#[test]
183fn check_recognize_real_number() {
184 expect!([r"
185 Zero
186 "])
187 .assert_debug_eq(&RealNumber::recognize(0.0));
188
189 expect!([r"
190 Algebraic(
191 AlgebraicNumber {
192 sign: 1,
193 fraction: RationalNumber {
194 sign: 1,
195 numerator: 5,
196 denominator: 3,
197 },
198 root: 2,
199 },
200 )
201 "])
202 .assert_debug_eq(&RealNumber::recognize(5.0 * 2.0_f64.sqrt() / 3.0));
203
204 expect!([r"
205 Algebraic(
206 AlgebraicNumber {
207 sign: 1,
208 fraction: RationalNumber {
209 sign: 1,
210 numerator: 7,
211 denominator: 10,
212 },
213 root: 1,
214 },
215 )
216 "])
217 .assert_debug_eq(&RealNumber::recognize(7.0 / 10.0));
218
219 expect!([r"
220 Decimal(
221 DecimalNumber {
222 sign: 1,
223 value: 0.00558659217877095,
224 },
225 )
226 "])
227 .assert_debug_eq(&RealNumber::recognize(1.0 / 179.0));
228
229 expect!([r"
230 Algebraic(
231 AlgebraicNumber {
232 sign: -1,
233 fraction: RationalNumber {
234 sign: 1,
235 numerator: 2,
236 denominator: 3,
237 },
238 root: 1,
239 },
240 )
241 "])
242 .assert_debug_eq(&RealNumber::recognize(-2.0 / 3.0));
243
244 expect!([r"
245 Algebraic(
246 AlgebraicNumber {
247 sign: -1,
248 fraction: RationalNumber {
249 sign: 1,
250 numerator: 5,
251 denominator: 7,
252 },
253 root: 3,
254 },
255 )
256 "])
257 .assert_debug_eq(&RealNumber::recognize(-5.0 * 3.0_f64.sqrt() / 7.0));
258}
259
260#[test]
261fn check_recognize_polar() {
262 expect!([r"
263 Some(
264 PolarForm {
265 sign: 1,
266 magnitude: AlgebraicNumber {
267 sign: 1,
268 fraction: RationalNumber {
269 sign: 1,
270 numerator: 5,
271 denominator: 2,
272 },
273 root: 1,
274 },
275 phase_multiplier: RationalNumber {
276 sign: 1,
277 numerator: 1,
278 denominator: 3,
279 },
280 },
281 )
282 "])
283 .assert_debug_eq(&PolarForm::recognize(
284 5.0 / 2.0 * (PI / 3.0).cos(),
285 5.0 / 2.0 * (PI / 3.0).sin(),
286 ));
287 expect!([r"
288 Some(
289 PolarForm {
290 sign: 1,
291 magnitude: AlgebraicNumber {
292 sign: 1,
293 fraction: RationalNumber {
294 sign: 1,
295 numerator: 5,
296 denominator: 2,
297 },
298 root: 1,
299 },
300 phase_multiplier: RationalNumber {
301 sign: -1,
302 numerator: 1,
303 denominator: 3,
304 },
305 },
306 )
307 "])
308 .assert_debug_eq(&PolarForm::recognize(
309 5.0 / 2.0 * (PI / 3.0).cos(),
310 5.0 / 2.0 * (-PI / 3.0).sin(),
311 ));
312}
313
314#[test]
315fn check_recognize_cartesian() {
316 expect!([r"
317 CartesianForm {
318 sign: -1,
319 real_part: Zero,
320 imaginary_part: Algebraic(
321 AlgebraicNumber {
322 sign: 1,
323 fraction: RationalNumber {
324 sign: 1,
325 numerator: 5,
326 denominator: 3,
327 },
328 root: 2,
329 },
330 ),
331 }
332 "])
333 .assert_debug_eq(&CartesianForm::recognize(0.0, -5.0 / 3.0 * 2.0_f64.sqrt()));
334 expect!([r"
335 CartesianForm {
336 sign: -1,
337 real_part: Algebraic(
338 AlgebraicNumber {
339 sign: 1,
340 fraction: RationalNumber {
341 sign: 1,
342 numerator: 7,
343 denominator: 3,
344 },
345 root: 1,
346 },
347 ),
348 imaginary_part: Algebraic(
349 AlgebraicNumber {
350 sign: -1,
351 fraction: RationalNumber {
352 sign: 1,
353 numerator: 2,
354 denominator: 9,
355 },
356 root: 3,
357 },
358 ),
359 }
360 "])
361 .assert_debug_eq(&CartesianForm::recognize(
362 -7.0 / 3.0,
363 2.0 / 9.0 * 3.0_f64.sqrt(),
364 ));
365}
366
367#[test]
368fn check_recognize_complex() {
369 expect!([r"
370 Cartesian(
371 CartesianForm {
372 sign: -1,
373 real_part: Zero,
374 imaginary_part: Algebraic(
375 AlgebraicNumber {
376 sign: 1,
377 fraction: RationalNumber {
378 sign: 1,
379 numerator: 5,
380 denominator: 3,
381 },
382 root: 2,
383 },
384 ),
385 },
386 )
387 "])
388 .assert_debug_eq(&ComplexNumber::recognize(0.0, -5.0 / 3.0 * 2.0_f64.sqrt()));
389
390 expect!([r"
391 Cartesian(
392 CartesianForm {
393 sign: -1,
394 real_part: Algebraic(
395 AlgebraicNumber {
396 sign: 1,
397 fraction: RationalNumber {
398 sign: 1,
399 numerator: 7,
400 denominator: 3,
401 },
402 root: 1,
403 },
404 ),
405 imaginary_part: Algebraic(
406 AlgebraicNumber {
407 sign: -1,
408 fraction: RationalNumber {
409 sign: 1,
410 numerator: 2,
411 denominator: 9,
412 },
413 root: 3,
414 },
415 ),
416 },
417 )
418 "])
419 .assert_debug_eq(&ComplexNumber::recognize(
420 -7.0 / 3.0,
421 2.0 / 9.0 * 3.0_f64.sqrt(),
422 ));
423
424 expect!([r"
425 Polar(
426 PolarForm {
427 sign: 1,
428 magnitude: AlgebraicNumber {
429 sign: 1,
430 fraction: RationalNumber {
431 sign: 1,
432 numerator: 5,
433 denominator: 2,
434 },
435 root: 1,
436 },
437 phase_multiplier: RationalNumber {
438 sign: 1,
439 numerator: 1,
440 denominator: 3,
441 },
442 },
443 )
444 "])
445 .assert_debug_eq(&ComplexNumber::recognize(
446 5.0 / 2.0 * (PI / 3.0).cos(),
447 5.0 / 2.0 * (PI / 3.0).sin(),
448 ));
449}
450
451fn assert_latex_for_algebraic(
452 expected: &Expect,
453 numerator: i64,
454 denominator: i64,
455 root: i64,
456 render_one: bool,
457) {
458 let number = AlgebraicNumber::new(&RationalNumber::new(numerator, denominator), root);
459 let mut latex = String::with_capacity(50);
460 write_latex_for_algebraic_number(&mut latex, &number, render_one);
461 expected.assert_debug_eq(&latex);
462}
463
464#[test]
465fn check_get_latex_for_algebraic() {
466 assert_latex_for_algebraic(
467 &expect!([r#"
468 "\\frac{5 \\sqrt{2}}{3}"
469 "#]),
470 5,
471 3,
472 2,
473 false,
474 );
475 assert_latex_for_algebraic(
476 &expect!([r#"
477 "\\frac{5 \\sqrt{2}}{3}"
478 "#]),
479 -5,
480 3,
481 2,
482 false,
483 );
484 assert_latex_for_algebraic(
485 &expect!([r#"
486 "\\frac{\\sqrt{2}}{3}"
487 "#]),
488 1,
489 3,
490 2,
491 false,
492 );
493 assert_latex_for_algebraic(
494 &expect!([r#"
495 "5 \\sqrt{2}"
496 "#]),
497 5,
498 1,
499 2,
500 false,
501 );
502 assert_latex_for_algebraic(
503 &expect!([r#"
504 "\\frac{5}{3}"
505 "#]),
506 5,
507 3,
508 1,
509 false,
510 );
511 assert_latex_for_algebraic(
512 &expect!([r#"
513 "\\sqrt{2}"
514 "#]),
515 1,
516 1,
517 2,
518 false,
519 );
520 assert_latex_for_algebraic(
521 &expect!([r#"
522 "5"
523 "#]),
524 5,
525 1,
526 1,
527 false,
528 );
529 assert_latex_for_algebraic(
530 &expect!([r#"
531 "\\frac{1}{3}"
532 "#]),
533 1,
534 3,
535 1,
536 false,
537 );
538 assert_latex_for_algebraic(
539 &expect!([r#"
540 ""
541 "#]),
542 1,
543 1,
544 1,
545 false,
546 );
547 assert_latex_for_algebraic(
548 &expect!([r#"
549 "1"
550 "#]),
551 1,
552 1,
553 1,
554 true,
555 );
556}
557
558fn assert_latex_for_decimal(expected: &Expect, number: f64, render_one: bool) {
559 let number = DecimalNumber::new(number);
560 let mut latex = String::with_capacity(50);
561 write_latex_for_decimal_number(&mut latex, &number, render_one);
562 expected.assert_debug_eq(&latex);
563}
564
565#[test]
566fn check_get_latex_for_decimal() {
567 assert_latex_for_decimal(
568 &expect!([r#"
569 "0.25"
570 "#]),
571 0.25,
572 false,
573 );
574 assert_latex_for_decimal(
575 &expect!([r#"
576 "0.25"
577 "#]),
578 -0.25,
579 false,
580 );
581 assert_latex_for_decimal(
582 &expect!([r#"
583 ""
584 "#]),
585 -1.0,
586 false,
587 );
588 assert_latex_for_decimal(
589 &expect!([r#"
590 ""
591 "#]),
592 1.0,
593 false,
594 );
595 assert_latex_for_decimal(
596 &expect!([r#"
597 "1"
598 "#]),
599 1.0,
600 true,
601 );
602}
603
604fn assert_latex_for_real(expected: &Expect, x: f64, render_one: bool) {
605 let number = RealNumber::recognize(x);
606 let mut latex = String::with_capacity(50);
607 write_latex_for_real_number(&mut latex, &number, render_one);
608 expected.assert_debug_eq(&latex);
609}
610
611#[test]
612fn check_get_latex_for_real() {
613 assert_latex_for_real(
614 &expect!([r#"
615 "\\frac{1}{4}"
616 "#]),
617 1.0 / 4.0,
618 false,
619 );
620 assert_latex_for_real(
621 &expect!([r#"
622 "\\frac{1}{4}"
623 "#]),
624 -1.0 / 4.0,
625 false,
626 );
627 assert_latex_for_real(
628 &expect!([r#"
629 ""
630 "#]),
631 1.0,
632 false,
633 );
634 assert_latex_for_real(
635 &expect!([r#"
636 "1"
637 "#]),
638 1.0,
639 true,
640 );
641 assert_latex_for_real(
642 &expect!([r#"
643 "0"
644 "#]),
645 0.0,
646 false,
647 );
648 assert_latex_for_real(
649 &expect!([r#"
650 "0.0003"
651 "#]),
652 1.0 / 4000.0,
653 false,
654 );
655}
656
657fn assert_latex_for_cartesian(expected: &Expect, re: f64, im: f64, render_plus: bool) {
658 let number = CartesianForm::recognize(re, im);
659 let mut latex = String::with_capacity(50);
660 write_latex_for_cartesian_form(&mut latex, &number, render_plus);
661 expected.assert_debug_eq(&latex);
662}
663
664#[test]
665fn check_get_latex_for_cartesian() {
666 assert_latex_for_cartesian(
667 &expect!([r#"
668 "\\left( \\frac{1}{2}+\\frac{1}{2}i \\right)"
669 "#]),
670 0.5,
671 0.5,
672 false,
673 );
674 assert_latex_for_cartesian(
675 &expect!([r#"
676 "-\\left( \\frac{1}{2}-\\frac{1}{2}i \\right)"
677 "#]),
678 -0.5,
679 0.5,
680 false,
681 );
682 assert_latex_for_cartesian(
683 &expect!([r#"
684 "\\left( \\frac{1}{2}-\\frac{1}{2}i \\right)"
685 "#]),
686 0.5,
687 -0.5,
688 false,
689 );
690 assert_latex_for_cartesian(
691 &expect!([r#"
692 "-\\left( \\frac{1}{2}+\\frac{1}{2}i \\right)"
693 "#]),
694 -0.5,
695 -0.5,
696 false,
697 );
698 assert_latex_for_cartesian(
699 &expect!([r#"
700 "-\\frac{1}{2}i"
701 "#]),
702 0.0,
703 -0.5,
704 false,
705 );
706 assert_latex_for_cartesian(
707 &expect!([r#"
708 "-\\frac{1}{2}"
709 "#]),
710 -0.5,
711 0.0,
712 false,
713 );
714 assert_latex_for_cartesian(
715 &expect!([r#"
716 ""
717 "#]),
718 1.0,
719 0.0,
720 false,
721 );
722 assert_latex_for_cartesian(
723 &expect!([r#"
724 "+"
725 "#]),
726 1.0,
727 0.0,
728 true,
729 );
730}
731
732fn assert_latex_for_polar(expected: &Expect, re: f64, im: f64, render_plus: bool) {
733 let number = PolarForm::recognize(re, im).expect("Polar form not recognized.");
734 let mut latex = String::with_capacity(50);
735 write_latex_for_polar_form(&mut latex, &number, render_plus);
736 expected.assert_debug_eq(&latex);
737}
738
739#[test]
740fn check_get_latex_for_polar() {
741 assert_latex_for_polar(
742 &expect!([r#"
743 "+\\frac{1}{2} e^{ i \\pi / 3}"
744 "#]),
745 1.0 / 2.0 * (PI / 3.0).cos(),
746 1.0 / 2.0 * (PI / 3.0).sin(),
747 true,
748 );
749 assert_latex_for_polar(
750 &expect!([r#"
751 "+ e^{ i \\pi / 3}"
752 "#]),
753 (PI / 3.0).cos(),
754 (PI / 3.0).sin(),
755 true,
756 );
757 assert_latex_for_polar(
758 &expect!([r#"
759 "+\\frac{1}{2} e^{- i \\pi / 3}"
760 "#]),
761 1.0 / 2.0 * (-PI / 3.0).cos(),
762 1.0 / 2.0 * (-PI / 3.0).sin(),
763 true,
764 );
765 assert_latex_for_polar(
766 &expect!([r#"
767 "+\\frac{1}{2} e^{2 i \\pi / 3}"
768 "#]),
769 1.0 / 2.0 * (2.0 * PI / 3.0).cos(),
770 1.0 / 2.0 * (2.0 * PI / 3.0).sin(),
771 true,
772 );
773 assert_latex_for_polar(
774 &expect!([r#"
775 "+\\frac{1}{2} e^{-2 i \\pi / 3}"
776 "#]),
777 1.0 / 2.0 * (-2.0 * PI / 3.0).cos(),
778 1.0 / 2.0 * (-2.0 * PI / 3.0).sin(),
779 true,
780 );
781 assert_latex_for_polar(
782 &expect!([r#"
783 "\\frac{1}{2} e^{-2 i \\pi / 3}"
784 "#]),
785 1.0 / 2.0 * (-2.0 * PI / 3.0).cos(),
786 1.0 / 2.0 * (-2.0 * PI / 3.0).sin(),
787 false,
788 );
789}
790
791fn assert_latex_for_term(expected: &Expect, re: f64, im: f64, render_plus: bool) {
792 let t: Term = Term {
793 basis_vector: 0_u8.into(),
794 coordinate: ComplexNumber::recognize(re, im),
795 };
796 let mut latex = String::with_capacity(50);
797 write_latex_for_term(&mut latex, &t, render_plus);
798 expected.assert_debug_eq(&latex);
799}
800
801#[test]
802fn check_get_latex_for_term() {
803 assert_latex_for_term(
804 &expect!([r#"
805 "+\\frac{1}{2} e^{ i \\pi / 3}"
806 "#]),
807 1.0 / 2.0 * (PI / 3.0).cos(),
808 1.0 / 2.0 * (PI / 3.0).sin(),
809 true,
810 );
811 assert_latex_for_term(
812 &expect!([r#"
813 "+\\left( \\frac{1}{2}+\\frac{1}{2}i \\right)"
814 "#]),
815 1.0 / 2.0,
816 1.0 / 2.0,
817 true,
818 );
819 assert_latex_for_term(
820 &expect!([r#"
821 "\\left( \\frac{1}{2}+\\frac{1}{2}i \\right)"
822 "#]),
823 1.0 / 2.0,
824 1.0 / 2.0,
825 false,
826 );
827 assert_latex_for_term(
828 &expect!([r#"
829 "-\\left( \\frac{1}{2}-\\frac{1}{2}i \\right)"
830 "#]),
831 -1.0 / 2.0,
832 1.0 / 2.0,
833 true,
834 );
835 assert_latex_for_term(
836 &expect!([r#"
837 "-\\left( \\frac{1}{2}-\\frac{1}{2}i \\right)"
838 "#]),
839 -1.0 / 2.0,
840 1.0 / 2.0,
841 false,
842 );
843}
844
845#[test]
846fn check_get_latex() {
847 expect!([r#"
848 "$|\\psi\\rangle = \\left( \\frac{1}{2}+\\frac{1}{2}i \\right)|00\\rangle$"
849 "#])
850 .assert_debug_eq(&get_latex(
851 &vec![(0_u8.into(), Complex64::new(0.5, 0.5))],
852 2,
853 ));
854 expect!([r#"
855 "$|\\psi\\rangle = -|00\\rangle$"
856 "#])
857 .assert_debug_eq(&get_latex(
858 &vec![(0_u8.into(), Complex64::new(-1.0, 0.0))],
859 2,
860 ));
861 expect!([r#"
862 "$|\\psi\\rangle = -i|00\\rangle$"
863 "#])
864 .assert_debug_eq(&get_latex(
865 &vec![(0_u8.into(), Complex64::new(0.0, -1.0))],
866 2,
867 ));
868 expect!([r#"
869 "$|\\psi\\rangle = e^{-2 i \\pi / 3}|00\\rangle$"
870 "#])
871 .assert_debug_eq(&get_latex(
872 &vec![(
873 0_u8.into(),
874 Complex64::new((-2.0 * PI / 3.0).cos(), (-2.0 * PI / 3.0).sin()),
875 )],
876 2,
877 ));
878 expect!([r#"
879 "$|\\psi\\rangle = \\left( 1+\\frac{\\sqrt{2}}{2}i \\right)|00\\rangle+\\left( 1+\\frac{\\sqrt{2}}{2}i \\right)|10\\rangle$"
880 "#])
881 .assert_debug_eq(&get_latex(
882 &vec![
883 (0_u8.into(), Complex64::new(1.0, 1.0 / 2.0_f64.sqrt())),
884 (2_u8.into(), Complex64::new(1.0, 1.0 / 2.0_f64.sqrt())),
885 ],
886 2,
887 ));
888}
889
890#[test]
891fn check_get_latex_perf() {
892 // This is not a CI gate for performance, just prints out data.
893 let state = vec![
894 (0_u8.into(), Complex64::new(1.0 / 2.0, 0.0)),
895 (
896 1_u8.into(),
897 Complex64::new(0.353_553_390_593_273_8, 0.353_553_390_593_273_8),
898 ),
899 (2_u8.into(), Complex64::new(0.0, 1.0 / 2.0)),
900 (
901 3_u8.into(),
902 Complex64::new(-0.353_553_390_593_273_8, 0.353_553_390_593_273_8),
903 ),
904 ];
905
906 expect!([r#"
907 "$|\\psi\\rangle = \\frac{1}{2}|00\\rangle+\\frac{1}{2} e^{ i \\pi / 4}|01\\rangle+\\frac{1}{2}i|10\\rangle+\\frac{1}{2} e^{3 i \\pi / 4}|11\\rangle$"
908 "#])
909 .assert_debug_eq(&get_latex(
910 &state,
911 2,
912 ));
913
914 print!("Start...");
915 let start = Instant::now();
916 let mut l: usize = 0;
917 for _ in 0..1_000 {
918 let s = get_latex(&state, 2);
919 l += s.len();
920 }
921 println!(
922 "Done. {} bytes in {:?}.",
923 l,
924 Instant::now().duration_since(start)
925 );
926}
927