1 // Copyright ©2015 The Gonum Authors. All rights reserved.
2 // Use of this source code is governed by a BSD-style
3 // license that can be found in the LICENSE file.
11 "gonum.org/v1/gonum/blas"
12 "gonum.org/v1/gonum/floats"
18 type DoubleOneVectorCase struct {
27 DscalCases []DScalCase
30 type DScalCase struct {
36 var DoubleOneVectorCases = []DoubleOneVectorCase{
39 X: []float64{6, 5, 4, 2, 6},
44 Dnrm2: 10.81665382639196787935766380241148783875388972153573863813135,
46 DscalCases: []DScalCase{
49 Ans: []float64{0, 0, 0, 0, 0},
53 Ans: []float64{6, 5, 4, 2, 6},
57 Ans: []float64{-12, -10, -8, -4, -12},
70 DscalCases: []DScalCase{
81 Ans: []float64{0, -2},
87 X: []float64{6, 5, 9, 0, 6},
92 Dnrm2: 13.34166406412633371248943627250846646911846482744007727141318,
94 DscalCases: []DScalCase{
97 Ans: []float64{-12, -10, -18, 0, -12},
103 X: []float64{6, 5, -9, 0, 10},
108 Dnrm2: 15.55634918610404553681857596630667886426639062914642880494347,
110 DscalCases: []DScalCase{
113 Ans: []float64{-12, -10, 18, 0, -20},
119 X: []float64{-6, -5, -4, -2, -6},
124 Dnrm2: 10.81665382639196787935766380241148783875388972153573863813135,
126 DscalCases: []DScalCase{
129 Ans: []float64{12, 10, 8, 4, 12},
135 X: []float64{-6, 5, 4, -2, -6},
140 Dnrm2: 10.81665382639196787935766380241148783875388972153573863813135,
142 DscalCases: []DScalCase{
145 Ans: []float64{12, -10, -8, 4, 12},
151 X: []float64{-6, 5, 4, -2, -6},
158 DscalCases: []DScalCase{
161 Ans: []float64{-6, 5, 4, -2, -6},
167 X: []float64{-6, 5, 4, -2, -6},
174 DscalCases: []DScalCase{
177 Ans: []float64{12, 5, 4, -2, -6},
182 Name: "PositiveExactInc",
183 X: []float64{-6, 5, 10, -2, -5},
188 Dnrm2: 12.68857754044952038019377274608948979173952662752515253090272,
190 DscalCases: []DScalCase{
193 Ans: []float64{12, 5, -20, -2, 10},
198 Name: "PositiveOffInc",
199 X: []float64{-6, 5, 4, -2, -6, 8, 10, 11},
204 Dnrm2: 11.83215956619923208513465658312323409683100246158868064575943,
206 DscalCases: []DScalCase{
209 Ans: []float64{12, 5, 4, 4, -6, 8, -20, 11},
214 Name: "PositiveShortInc",
215 X: []float64{-6, 5, 4, -2, -6, 8, 10, 11},
220 Dnrm2: 6.324555320336758663997787088865437067439110278650433653715009,
222 DscalCases: []DScalCase{
225 Ans: []float64{12, 5, 4, 4, -6, 8, 10, 11},
231 X: []float64{-6, 5, 4, -2, -6},
238 DscalCases: []DScalCase{
241 Ans: []float64{-6, 5, 4, -2, -6},
246 Name: "NegativeExactInc",
247 X: []float64{-6, 5, 4, -2, -6},
254 DscalCases: []DScalCase{
257 Ans: []float64{-6, 5, 4, -2, -6},
262 Name: "NegativeOffInc",
263 X: []float64{-6, 5, 4, -2, -6, 8, 10, 11},
270 DscalCases: []DScalCase{
273 Ans: []float64{-6, 5, 4, -2, -6, 8, 10, 11},
278 Name: "NegativeShortInc",
279 X: []float64{-6, 5, 4, -2, -6, 8, 10, 11},
286 DscalCases: []DScalCase{
289 Ans: []float64{-6, 5, 4, -2, -6, 8, 10, 11},
295 X: []float64{-6, 5, 4, -2, -6},
299 DscalCases: []DScalCase{
302 Ans: []float64{-6, 5, 4, -2, -6},
308 X: []float64{-6, 5, 4, -2, -6},
312 DscalCases: []DScalCase{
315 Ans: []float64{-6, 5, 4, -2, -6},
321 X: []float64{-6, 5, 4, -2, -6},
325 DscalCases: []DScalCase{
328 Ans: []float64{-6, 5, 4, -2, -6},
333 Name: "NegativeOutOfBounds",
334 X: []float64{-6, 5, 4, -2, -6},
341 DscalCases: []DScalCase{
344 Ans: []float64{-6, 5, 4, -2, -6},
350 X: []float64{math.NaN(), 2.0},
357 DscalCases: []DScalCase{
360 Ans: []float64{math.NaN(), -4.0},
364 Ans: []float64{0, 0},
370 X: []float64{math.NaN(), math.NaN(), 2.0},
377 DscalCases: []DScalCase{
380 Ans: []float64{math.NaN(), math.NaN(), -4.0},
384 Ans: []float64{0, math.NaN(), 0},
397 DscalCases: []DScalCase{
409 Name: "EmptyZeroInc",
417 DscalCases: []DScalCase{
429 Name: "EmptyReverse",
437 DscalCases: []DScalCase{
450 X: []float64{5, math.Inf(1), math.Inf(-1), 8, 9},
457 DscalCases: []DScalCase{
460 Ans: []float64{-10, math.Inf(-1), math.Inf(1), -16, -18},
464 Ans: []float64{0, 0, 0, 0, 0},
470 X: []float64{5, math.NaN(), math.Inf(-1), 8, 9},
477 DscalCases: []DScalCase{
480 Ans: []float64{-10, math.NaN(), math.Inf(1), -16, -18},
484 Ans: []float64{0, 0, 0, 0, 0},
490 X: []float64{5, math.Inf(1), math.NaN(), 8, 9},
497 DscalCases: []DScalCase{
500 Ans: []float64{-10, math.Inf(-1), math.NaN(), -16, -18},
504 Ans: []float64{0, 0, 0, 0, 0},
510 type DoubleTwoVectorCase struct {
521 DaxpyCases []DaxpyCase
523 DswapAns DTwoVecAnswer
524 DcopyAns DTwoVecAnswer
526 DrotmCases []DrotmCase
529 type DaxpyCase struct {
534 type DrotCase struct {
541 type DrotmCase struct {
548 type DTwoVecAnswer struct {
553 var DoubleTwoVectorCases = []DoubleTwoVectorCase{
556 X: []float64{10, 15, -6, 3, 14, 7},
557 Y: []float64{8, -2, 4, 7, 6, -3},
558 XTmp: []float64{0, 0, 0, 0, 0, 0},
559 YTmp: []float64{0, 0, 0, 0, 0, 0},
564 DaxpyCases: []DaxpyCase{
567 Ans: []float64{18, 13, -2, 10, 20, 4},
571 Ans: []float64{28, 28, -8, 13, 34, 11},
575 Ans: []float64{-22, -47, 22, -2, -36, -24},
579 Ans: []float64{8, -2, 4, 7, 6, -3},
583 DswapAns: DTwoVecAnswer{
584 X: []float64{8, -2, 4, 7, 6, -3},
585 Y: []float64{10, 15, -6, 3, 14, 7},
587 DcopyAns: DTwoVecAnswer{
588 X: []float64{10, 15, -6, 3, 14, 7},
589 Y: []float64{10, 15, -6, 3, 14, 7},
591 DrotCases: []DrotCase{
595 XAns: []float64{10, 15, -6, 3, 14, 7},
596 YAns: []float64{8, -2, 4, 7, 6, -3},
599 C: math.Cos(25 * math.Pi / 180),
600 S: math.Sin(25 * math.Pi / 180),
601 XAns: []float64{12.444023964292095, 12.749380282068351, -3.7473736752571014, 5.677251193294846, 15.224018588957296, 5.076299724034451},
602 YAns: []float64{3.024279678886205, -8.151889500183792, 6.160940718590796, 5.076299724034451, -0.4788089421498931, -5.677251193294846},
605 C: math.Cos(0.5 * math.Pi),
606 S: math.Sin(0.5 * math.Pi),
607 XAns: []float64{8, -2, 4, 7, 6, -3},
608 YAns: []float64{-10, -15, 6, -3, -14, -7},
611 C: math.Cos(math.Pi),
612 S: math.Sin(math.Pi),
613 XAns: []float64{-10, -15, 6, -3, -14, -7},
614 YAns: []float64{-8, 2, -4, -7, -6, 3},
617 DrotmCases: []DrotmCase{
621 H: [4]float64{0.9, 0.1, -0.1, 0.5},
623 XAns: []float64{10, 15, -6, 3, 14, 7},
624 YAns: []float64{8, -2, 4, 7, 6, -3},
629 Flag: blas.Rescaling,
630 H: [4]float64{0.9, 0.1, -0.1, 0.5},
632 XAns: []float64{8.2, 13.7, -5.8, 2, 12, 6.6},
633 YAns: []float64{5, 0.5, 1.4, 3.8, 4.4, -0.8},
638 Flag: blas.OffDiagonal,
639 H: [4]float64{1, 0.1, -0.1, 1},
641 XAns: []float64{9.2, 15.2, -6.4, 2.3, 13.4, 7.3},
642 YAns: []float64{9, -0.5, 3.4, 7.3, 7.4, -2.3},
648 H: [4]float64{0.5, -1, 1, 0.7},
650 XAns: []float64{13, 5.5, 1, 8.5, 13, 0.5},
651 YAns: []float64{-4.4, -16.4, 8.8, 1.9, -9.8, -9.1},
657 Name: "UnitaryIncLong",
658 X: []float64{10, 15, -6, 3, 14, 7, 8, -9, 10},
659 Y: []float64{8, -2, 4, 7, 6, -3, 7, -6},
660 XTmp: []float64{0, 0, 0, 0, 0, 0, 0, 0, 0},
661 YTmp: []float64{0, 0, 0, 0, 0, 0, 0, 0},
666 DaxpyCases: []DaxpyCase{
669 Ans: []float64{18, 13, -2, 10, 20, 4, 7, -6},
673 Ans: []float64{28, 28, -8, 13, 34, 11, 7, -6},
677 Ans: []float64{-22, -47, 22, -2, -36, -24, 7, -6},
681 Ans: []float64{8, -2, 4, 7, 6, -3, 7, -6},
685 DswapAns: DTwoVecAnswer{
686 X: []float64{8, -2, 4, 7, 6, -3, 8, -9, 10},
687 Y: []float64{10, 15, -6, 3, 14, 7, 7, -6},
689 DcopyAns: DTwoVecAnswer{
690 X: []float64{10, 15, -6, 3, 14, 7, 8, -9, 10},
691 Y: []float64{10, 15, -6, 3, 14, 7, 7, -6},
693 DrotCases: []DrotCase{
697 XAns: []float64{10, 15, -6, 3, 14, 7, 8, -9, 10},
698 YAns: []float64{8, -2, 4, 7, 6, -3, 7, -6},
701 C: math.Cos(25 * math.Pi / 180),
702 S: math.Sin(25 * math.Pi / 180),
703 XAns: []float64{12.444023964292095, 12.749380282068351, -3.7473736752571014, 5.677251193294846, 15.224018588957296, 5.076299724034451, 8, -9, 10},
704 YAns: []float64{3.024279678886205, -8.151889500183792, 6.160940718590796, 5.076299724034451, -0.4788089421498931, -5.677251193294846, 7, -6},
707 C: math.Cos(0.5 * math.Pi),
708 S: math.Sin(0.5 * math.Pi),
709 XAns: []float64{8, -2, 4, 7, 6, -3, 8, -9, 10},
710 YAns: []float64{-10, -15, 6, -3, -14, -7, 7, -6},
713 C: math.Cos(math.Pi),
714 S: math.Sin(math.Pi),
715 XAns: []float64{-10, -15, 6, -3, -14, -7, 8, -9, 10},
716 YAns: []float64{-8, 2, -4, -7, -6, 3, 7, -6},
719 DrotmCases: []DrotmCase{
723 H: [4]float64{0.9, 0.1, -0.1, 0.5},
725 XAns: []float64{10, 15, -6, 3, 14, 7, 8, -9, 10},
726 YAns: []float64{8, -2, 4, 7, 6, -3, 7, -6},
731 Flag: blas.Rescaling,
732 H: [4]float64{0.9, 0.1, -0.1, 0.5},
734 XAns: []float64{8.2, 13.7, -5.8, 2, 12, 6.6, 8, -9, 10},
735 YAns: []float64{5, 0.5, 1.4, 3.8, 4.4, -0.8, 7, -6},
740 Flag: blas.OffDiagonal,
741 H: [4]float64{1, 0.1, -0.1, 1},
743 XAns: []float64{9.2, 15.2, -6.4, 2.3, 13.4, 7.3, 8, -9, 10},
744 YAns: []float64{9, -0.5, 3.4, 7.3, 7.4, -2.3, 7, -6},
750 H: [4]float64{0.5, -1, 1, 0.7},
752 XAns: []float64{13, 5.5, 1, 8.5, 13, 0.5, 8, -9, 10},
753 YAns: []float64{-4.4, -16.4, 8.8, 1.9, -9.8, -9.1, 7, -6},
760 X: []float64{10, 15, -6, 3, 14, 7},
761 Y: []float64{8, -2, 4, 7, 6, -3, -4, 10},
762 XTmp: []float64{0, 0, 0, 0, 0, 0},
763 YTmp: []float64{0, 0, 0, 0, 0, 0, 0, 0},
768 DaxpyCases: []DaxpyCase{
771 Ans: []float64{28, -2, 4, -5, 6, -3, 24, 10},
775 DswapAns: DTwoVecAnswer{
776 X: []float64{8, 15, 7, 3, -4, 7},
777 Y: []float64{10, -2, 4, -6, 6, -3, 14, 10},
779 DcopyAns: DTwoVecAnswer{
780 X: []float64{10, 15, -6, 3, 14, 7},
781 Y: []float64{10, -2, 4, -6, 6, -3, 14, 10},
783 DrotCases: []DrotCase{
785 C: math.Cos(25 * math.Pi / 180),
786 S: math.Sin(25 * math.Pi / 180),
787 XAns: []float64{12.444023964292095, 15, -2.479518890035003, 3, 10.997835971550302, 7},
788 YAns: []float64{3.024279678886205, -2, 4, 8.879864079700745, 6, -3, -9.541886812516392, 10},
791 DrotmCases: []DrotmCase{
794 Flag: blas.Rescaling,
795 H: [4]float64{0.9, 0.1, -0.1, 0.5},
797 XAns: []float64{8.2, 15, -6.1, 3, 13, 7},
798 YAns: []float64{5, -2, 4, 2.9, 6, -3, -0.6, 10},
802 Flag: blas.OffDiagonal,
803 H: [4]float64{1, 0.1, -0.1, 1},
805 XAns: []float64{9.2, 15, -6.7, 3, 14.4, 7},
806 YAns: []float64{9, -2, 4, 6.4, 6, -3, -2.6, 10},
811 H: [4]float64{0.5, -1, 1, 0.7},
813 XAns: []float64{13, 15, 4, 3, 3, 7},
814 YAns: []float64{-4.4, -2, 4, 10.9, 6, -3, -16.8, 10},
820 X: []float64{10, 15, -6, 3, 14, 7},
821 Y: []float64{8, -2, 4, 7, 6, -3, -4, 10},
822 XTmp: []float64{0, 0, 0, 0, 0, 0},
823 YTmp: []float64{0, 0, 0, 0, 0, 0, 0, 0},
828 DaxpyCases: []DaxpyCase{
831 Ans: []float64{28, -2, 4, -5, 6, -3, 24, 10},
835 DswapAns: DTwoVecAnswer{
836 X: []float64{8, 15, 7, 3, -4, 7},
837 Y: []float64{10, -2, 4, -6, 6, -3, 14, 10},
839 DcopyAns: DTwoVecAnswer{
840 X: []float64{10, 15, -6, 3, 14, 7},
841 Y: []float64{10, -2, 4, -6, 6, -3, 14, 10},
843 DrotCases: []DrotCase{
845 C: math.Cos(25 * math.Pi / 180),
846 S: math.Sin(25 * math.Pi / 180),
847 XAns: []float64{12.444023964292095, 15, -2.479518890035003, 3, 10.997835971550302, 7},
848 YAns: []float64{3.024279678886205, -2, 4, 8.879864079700745, 6, -3, -9.541886812516392, 10},
851 DrotmCases: []DrotmCase{
854 Flag: blas.Rescaling,
855 H: [4]float64{0.9, 0.1, -0.1, 0.5},
857 XAns: []float64{8.2, 15, -6.1, 3, 13, 7},
858 YAns: []float64{5, -2, 4, 2.9, 6, -3, -0.6, 10},
862 Flag: blas.OffDiagonal,
863 H: [4]float64{1, 0.1, -0.1, 1},
865 XAns: []float64{9.2, 15, -6.7, 3, 14.4, 7},
866 YAns: []float64{9, -2, 4, 6.4, 6, -3, -2.6, 10},
871 H: [4]float64{0.5, -1, 1, 0.7},
873 XAns: []float64{13, 15, 4, 3, 3, 7},
874 YAns: []float64{-4.4, -2, 4, 10.9, 6, -3, -16.8, 10},
880 X: []float64{10, 15, -6, 3, 14, 7},
881 Y: []float64{8, -2, 4, 7, 6, -3, -4, 10},
882 XTmp: []float64{0, 0, 0, 0, 0, 0},
883 YTmp: []float64{0, 0, 0, 0, 0, 0, 0, 0},
888 DaxpyCases: []DaxpyCase{
891 Ans: []float64{36, -2, 4, -5, 6, -3, 16, 10},
895 DswapAns: DTwoVecAnswer{
896 X: []float64{-4, 15, 7, 3, 8, 7},
897 Y: []float64{14, -2, 4, -6, 6, -3, 10, 10},
899 DcopyAns: DTwoVecAnswer{
900 X: []float64{10, 15, -6, 3, 14, 7},
901 Y: []float64{14, -2, 4, -6, 6, -3, 10, 10},
903 DrotCases: []DrotCase{
905 C: math.Cos(25 * math.Pi / 180),
906 S: math.Sin(25 * math.Pi / 180),
907 XAns: []float64{7.372604823403701, 15, -2.479518890035003, 3, 16.069255112438693, 7},
908 YAns: []float64{1.333806631923407, -2, 4, 8.879864079700745, 6, -3, -7.851413765553595, 10},
911 DrotmCases: []DrotmCase{
914 Flag: blas.Rescaling,
915 H: [4]float64{0.9, 0.1, -0.1, 0.5},
917 XAns: []float64{9.4, 15, -6.1, 3, 11.8, 7},
918 YAns: []float64{5.4, -2, 4, 2.9, 6, -3, -1, 10},
922 Flag: blas.OffDiagonal,
923 H: [4]float64{1, 0.1, -0.1, 1},
925 XAns: []float64{10.4, 15, -6.7, 3, 13.2, 7},
926 YAns: []float64{9.4, -2, 4, 6.4, 6, -3, -3, 10},
931 H: [4]float64{0.5, -1, 1, 0.7},
933 XAns: []float64{1, 15, 4, 3, 15, 7},
934 YAns: []float64{-8.4, -2, 4, 10.9, 6, -3, -12.8, 10},
940 X: []float64{10, 15, -6, 3, 14, 7},
941 Y: []float64{8, -2, 4, 7, 6, -3, -4, 10},
942 XTmp: []float64{0, 0, 0, 0, 0, 0},
943 YTmp: []float64{0, 0, 0, 0, 0, 0, 0, 0},
948 DaxpyCases: []DaxpyCase{
951 Ans: []float64{36, -2, 4, -5, 6, -3, 16, 10},
955 DswapAns: DTwoVecAnswer{
956 X: []float64{-4, 15, 7, 3, 8, 7},
957 Y: []float64{14, -2, 4, -6, 6, -3, 10, 10},
959 DcopyAns: DTwoVecAnswer{
960 X: []float64{10, 15, -6, 3, 14, 7},
961 Y: []float64{14, -2, 4, -6, 6, -3, 10, 10},
963 DrotCases: []DrotCase{
965 C: math.Cos(25 * math.Pi / 180),
966 S: math.Sin(25 * math.Pi / 180),
967 XAns: []float64{7.372604823403701, 15, -2.479518890035003, 3, 16.069255112438693, 7},
968 YAns: []float64{1.333806631923407, -2, 4, 8.879864079700745, 6, -3, -7.851413765553595, 10},
971 DrotmCases: []DrotmCase{
974 Flag: blas.Rescaling,
975 H: [4]float64{0.9, 0.1, -0.1, 0.5},
977 XAns: []float64{9.4, 15, -6.1, 3, 11.8, 7},
978 YAns: []float64{5.4, -2, 4, 2.9, 6, -3, -1, 10},
982 Flag: blas.OffDiagonal,
983 H: [4]float64{1, 0.1, -0.1, 1},
985 XAns: []float64{10.4, 15, -6.7, 3, 13.2, 7},
986 YAns: []float64{9.4, -2, 4, 6.4, 6, -3, -3, 10},
991 H: [4]float64{0.5, -1, 1, 0.7},
993 XAns: []float64{1, 15, 4, 3, 15, 7},
994 YAns: []float64{-8.4, -2, 4, 10.9, 6, -3, -12.8, 10},
1000 X: []float64{10, 15, -6, 3, 14, 7},
1001 Y: []float64{8, -2, 4, 7, 6, -3, -4, 10},
1002 XTmp: []float64{0, 0, 0, 0, 0, 0},
1003 YTmp: []float64{0, 0, 0, 0, 0, 0, 0, 0},
1008 DaxpyCases: []DaxpyCase{
1011 Ans: []float64{8, -2, 4, 7, 6, -3, -4, 10},
1014 DswapAns: DTwoVecAnswer{
1015 X: []float64{10, 15, -6, 3, 14, 7},
1016 Y: []float64{8, -2, 4, 7, 6, -3, -4, 10},
1018 DcopyAns: DTwoVecAnswer{
1019 X: []float64{10, 15, -6, 3, 14, 7},
1020 Y: []float64{8, -2, 4, 7, 6, -3, -4, 10},
1022 DrotCases: []DrotCase{
1024 C: math.Cos(25 * math.Pi / 180),
1025 S: math.Sin(25 * math.Pi / 180),
1026 XAns: []float64{10, 15, -6, 3, 14, 7},
1027 YAns: []float64{8, -2, 4, 7, 6, -3, -4, 10},
1030 DrotmCases: []DrotmCase{
1032 P: blas.DrotmParams{
1033 Flag: blas.Rescaling,
1034 H: [4]float64{0.9, 0.1, -0.1, 0.5},
1036 XAns: []float64{10, 15, -6, 3, 14, 7},
1037 YAns: []float64{8, -2, 4, 7, 6, -3, -4, 10},
1043 X: []float64{10, 15, -6, 3, 14, 7},
1044 Y: []float64{8, -2, 4, 7, 6, -3, -4, 10},
1045 XTmp: []float64{0, 0, 0, 0, 0, 0},
1046 YTmp: []float64{0, 0, 0, 0, 0, 0, 0, 0},
1051 DaxpyCases: []DaxpyCase{
1054 Ans: []float64{36, -2, 4, -5, 6, -3, 16, 10},
1057 DrotCases: []DrotCase{
1059 C: math.Cos(25 * math.Pi / 180),
1060 S: math.Sin(25 * math.Pi / 180),
1061 XAns: []float64{10, 15, -6, 3, 14, 7},
1062 YAns: []float64{8, -2, 4, 7, 6, -3, -4, 10},
1065 DrotmCases: []DrotmCase{
1067 P: blas.DrotmParams{
1068 Flag: blas.Rescaling,
1069 H: [4]float64{0.9, 0.1, -0.1, 0.5},
1071 XAns: []float64{8.2, 13.7, -5.8, 2, 12, 6.6},
1072 YAns: []float64{5, 0.5, 1.4, 3.8, 4.4, -0.8},
1078 X: []float64{10, 15, -6, 3, 14, 7},
1079 Y: []float64{8, -2, 4, 7, 6, -3, -4, 10},
1080 XTmp: []float64{0, 0, 0, 0, 0, 0},
1081 YTmp: []float64{0, 0, 0, 0, 0, 0, 0, 0},
1086 DaxpyCases: []DaxpyCase{
1089 Ans: []float64{36, -2, 4, -5, 6, -3, 16, 10},
1092 DrotCases: []DrotCase{
1094 C: math.Cos(25 * math.Pi / 180),
1095 S: math.Sin(25 * math.Pi / 180),
1096 XAns: []float64{10, 15, -6, 3, 14, 7},
1097 YAns: []float64{8, -2, 4, 7, 6, -3, -4, 10},
1100 DrotmCases: []DrotmCase{
1102 P: blas.DrotmParams{
1103 Flag: blas.Rescaling,
1104 H: [4]float64{0.9, 0.1, -0.1, 0.5},
1106 XAns: []float64{8.2, 13.7, -5.8, 2, 12, 6.6},
1107 YAns: []float64{5, 0.5, 1.4, 3.8, 4.4, -0.8},
1113 X: []float64{10, 15, -6, 3, 14, 7},
1114 Y: []float64{8, -2, 4, 7, 6, -3, -4, 10},
1115 XTmp: []float64{0, 0, 0, 0, 0, 0},
1116 YTmp: []float64{0, 0, 0, 0, 0, 0, 0, 0},
1121 DaxpyCases: []DaxpyCase{
1124 Ans: []float64{36, -2, 4, -5, 6, -3, 16, 10},
1127 DrotCases: []DrotCase{
1129 C: math.Cos(25 * math.Pi / 180),
1130 S: math.Sin(25 * math.Pi / 180),
1131 XAns: []float64{10, 15, -6, 3, 14, 7},
1132 YAns: []float64{8, -2, 4, 7, 6, -3, -4, 10},
1135 DrotmCases: []DrotmCase{
1137 P: blas.DrotmParams{
1138 Flag: blas.Rescaling,
1139 H: [4]float64{0.9, 0.1, -0.1, 0.5},
1141 XAns: []float64{8.2, 13.7, -5.8, 2, 12, 6.6},
1142 YAns: []float64{5, 0.5, 1.4, 3.8, 4.4, -0.8},
1147 Name: "OutOfBoundsX",
1148 X: []float64{10, 15, -6, 3, 14, 7},
1149 Y: []float64{8, -2, 4, 7, 6, -3, -4, 10},
1150 XTmp: []float64{0, 0, 0, 0, 0, 0},
1151 YTmp: []float64{0, 0, 0, 0, 0, 0, 0, 0},
1156 DaxpyCases: []DaxpyCase{
1159 Ans: []float64{36, -2, 4, -5, 6, -3, 16, 10},
1162 DrotCases: []DrotCase{
1164 C: math.Cos(25 * math.Pi / 180),
1165 S: math.Sin(25 * math.Pi / 180),
1166 XAns: []float64{10, 15, -6, 3, 14, 7},
1167 YAns: []float64{8, -2, 4, 7, 6, -3, -4, 10},
1170 DrotmCases: []DrotmCase{
1172 P: blas.DrotmParams{
1173 Flag: blas.Rescaling,
1174 H: [4]float64{0.9, 0.1, -0.1, 0.5},
1176 XAns: []float64{8.2, 13.7, -5.8, 2, 12, 6.6},
1177 YAns: []float64{5, 0.5, 1.4, 3.8, 4.4, -0.8},
1182 Name: "OutOfBoundsY",
1183 X: []float64{10, 15, -6, 3, 14, 7},
1184 Y: []float64{8, -2, 4, 7, 6, -3, -4, 10},
1185 XTmp: []float64{0, 0, 0, 0, 0, 0},
1186 YTmp: []float64{0, 0, 0, 0, 0, 0, 0, 0},
1191 DaxpyCases: []DaxpyCase{
1194 Ans: []float64{36, -2, 4, -5, 6, -3, 16, 10},
1197 DrotCases: []DrotCase{
1199 C: math.Cos(25 * math.Pi / 180),
1200 S: math.Sin(25 * math.Pi / 180),
1201 XAns: []float64{10, 15, -6, 3, 14, 7},
1202 YAns: []float64{8, -2, 4, 7, 6, -3, -4, 10},
1205 DrotmCases: []DrotmCase{
1207 P: blas.DrotmParams{
1208 Flag: blas.Rescaling,
1209 H: [4]float64{0.9, 0.1, -0.1, 0.5},
1211 XAns: []float64{10, 15, -6, 3, 14, 7},
1212 YAns: []float64{8, -2, 4, 7, 6, -3, -4, 10},
1224 DaxpyCases: []DaxpyCase{
1230 DrotCases: []DrotCase{
1232 C: math.Cos(25 * math.Pi / 180),
1233 S: math.Sin(25 * math.Pi / 180),
1238 DrotmCases: []DrotmCase{
1240 P: blas.DrotmParams{
1241 Flag: blas.Rescaling,
1242 H: [4]float64{0.9, 0.1, -0.1, 0.5},
1250 Name: "EmptyZeroIncX",
1257 DaxpyCases: []DaxpyCase{
1263 DrotCases: []DrotCase{
1265 C: math.Cos(25 * math.Pi / 180),
1266 S: math.Sin(25 * math.Pi / 180),
1271 DrotmCases: []DrotmCase{
1273 P: blas.DrotmParams{
1274 Flag: blas.Rescaling,
1275 H: [4]float64{0.9, 0.1, -0.1, 0.5},
1283 Name: "EmptyZeroIncY",
1290 DaxpyCases: []DaxpyCase{
1296 DrotCases: []DrotCase{
1298 C: math.Cos(25 * math.Pi / 180),
1299 S: math.Sin(25 * math.Pi / 180),
1304 DrotmCases: []DrotmCase{
1306 P: blas.DrotmParams{
1307 Flag: blas.Rescaling,
1308 H: [4]float64{0.9, 0.1, -0.1, 0.5},
1316 Name: "EmptyReverse",
1323 DaxpyCases: []DaxpyCase{
1329 DrotCases: []DrotCase{
1331 C: math.Cos(25 * math.Pi / 180),
1332 S: math.Sin(25 * math.Pi / 180),
1337 DrotmCases: []DrotmCase{
1339 P: blas.DrotmParams{
1340 Flag: blas.Rescaling,
1341 H: [4]float64{0.9, 0.1, -0.1, 0.5},
1350 type Ddotter interface {
1351 Ddot(n int, x []float64, incX int, y []float64, incY int) float64
1354 func DdotTest(t *testing.T, d Ddotter) {
1356 for _, c := range DoubleTwoVectorCases {
1357 dCopyTwoTmp(c.X, c.XTmp, c.Y, c.YTmp)
1359 f := func() { ddot(c.N, c.XTmp, c.Incx, c.YTmp, c.Incy) }
1360 testpanics(f, c.Name, t)
1363 dot := ddot(c.N, c.XTmp, c.Incx, c.YTmp, c.Incy)
1364 if !dTolEqual(dot, c.DdotAns) {
1365 t.Errorf("ddot: mismatch %v: expected %v, found %v", c.Name, c.DdotAns, dot)
1369 // check it works for 16-byte unaligned slices
1370 x := []float64{1, 1, 1, 1, 1}
1371 if n := ddot(4, x[:4], 1, x[1:], 1); n != 4 {
1372 t.Errorf("ddot: mismatch Unaligned: expected %v, found %v", 4, n)
1374 if n := ddot(2, x[:4], 2, x[1:], 2); n != 2 {
1375 t.Errorf("ddot: mismatch Unaligned: expected %v, found %v", 2, n)
1377 if n := ddot(2, x[:4], 3, x[1:], 3); n != 2 {
1378 t.Errorf("ddot: mismatch Unaligned: expected %v, found %v", 2, n)
1382 type Dnrm2er interface {
1383 Dnrm2(n int, x []float64, incX int) float64
1386 func Dnrm2Test(t *testing.T, blasser Dnrm2er) {
1387 dnrm2 := blasser.Dnrm2
1388 for _, c := range DoubleOneVectorCases {
1390 f := func() { dnrm2(c.N, c.X, c.Incx) }
1391 testpanics(f, c.Name, t)
1394 v := dnrm2(c.N, c.X, c.Incx)
1395 if !dTolEqual(v, c.Dnrm2) {
1396 t.Errorf("dnrm2: mismatch %v: expected %v, found %v", c.Name, c.Dnrm2, v)
1401 type Dasumer interface {
1402 Dasum(n int, x []float64, incX int) float64
1405 func DasumTest(t *testing.T, blasser Dasumer) {
1406 dasum := blasser.Dasum
1407 for _, c := range DoubleOneVectorCases {
1409 f := func() { dasum(c.N, c.X, c.Incx) }
1410 testpanics(f, c.Name, t)
1413 v := dasum(c.N, c.X, c.Incx)
1414 if !dTolEqual(v, c.Dasum) {
1415 t.Errorf("dasum: mismatch %v: expected %v, found %v", c.Name, c.Dasum, v)
1420 type Idamaxer interface {
1421 Idamax(n int, x []float64, incX int) int
1424 func IdamaxTest(t *testing.T, blasser Idamaxer) {
1425 idamax := blasser.Idamax
1426 for _, c := range DoubleOneVectorCases {
1428 f := func() { idamax(c.N, c.X, c.Incx) }
1429 testpanics(f, c.Name, t)
1432 v := idamax(c.N, c.X, c.Incx)
1434 s := fmt.Sprintf("idamax: mismatch %v: expected %v, found %v", c.Name, c.Idamax, v)
1435 if floats.HasNaN(c.X) {
1444 type Dswapper interface {
1445 Dswap(n int, x []float64, incX int, y []float64, incY int)
1448 func DswapTest(t *testing.T, d Dswapper) {
1450 for _, c := range DoubleTwoVectorCases {
1451 dCopyTwoTmp(c.X, c.XTmp, c.Y, c.YTmp)
1453 f := func() { dswap(c.N, c.XTmp, c.Incx, c.YTmp, c.Incy) }
1454 testpanics(f, c.Name, t)
1457 dswap(c.N, c.XTmp, c.Incx, c.YTmp, c.Incy)
1458 if !dSliceTolEqual(c.XTmp, c.DswapAns.X) {
1459 t.Errorf("dswap: x mismatch %v: expected %v, found %v", c.Name, c.DswapAns.X, c.XTmp)
1461 if !dSliceTolEqual(c.YTmp, c.DswapAns.Y) {
1462 t.Errorf("dswap: y mismatch %v: expected %v, found %v", c.Name, c.DswapAns.Y, c.YTmp)
1467 type Dcopier interface {
1468 Dcopy(n int, x []float64, incX int, y []float64, incY int)
1471 func DcopyTest(t *testing.T, d Dcopier) {
1473 for _, c := range DoubleTwoVectorCases {
1474 dCopyTwoTmp(c.X, c.XTmp, c.Y, c.YTmp)
1476 f := func() { dcopy(c.N, c.XTmp, c.Incx, c.YTmp, c.Incy) }
1477 testpanics(f, c.Name, t)
1480 dcopy(c.N, c.XTmp, c.Incx, c.YTmp, c.Incy)
1481 if !dSliceTolEqual(c.XTmp, c.DcopyAns.X) {
1482 t.Errorf("dswap: x mismatch %v: expected %v, found %v", c.Name, c.DcopyAns.X, c.XTmp)
1484 if !dSliceTolEqual(c.YTmp, c.DcopyAns.Y) {
1485 t.Errorf("dswap: y mismatch %v: expected %v, found %v", c.Name, c.DcopyAns.Y, c.YTmp)
1490 type Daxpyer interface {
1491 Daxpy(n int, alpha float64, x []float64, incX int, y []float64, incY int)
1494 func DaxpyTest(t *testing.T, d Daxpyer) {
1496 for _, c := range DoubleTwoVectorCases {
1497 for _, kind := range c.DaxpyCases {
1498 dCopyTwoTmp(c.X, c.XTmp, c.Y, c.YTmp)
1500 f := func() { daxpy(c.N, kind.Alpha, c.XTmp, c.Incx, c.YTmp, c.Incy) }
1501 testpanics(f, c.Name, t)
1504 daxpy(c.N, kind.Alpha, c.XTmp, c.Incx, c.YTmp, c.Incy)
1505 if !dSliceTolEqual(c.YTmp, kind.Ans) {
1506 t.Errorf("daxpy: mismatch %v: expected %v, found %v", c.Name, kind.Ans, c.YTmp)
1512 type DrotgTestStruct struct {
1518 var DrotgTests = []DrotgTestStruct{
1550 Name: "PosA_PosB_AGTB",
1553 C: 0.99820484546577868593549038000,
1554 S: 0.05989229072794672115612942280,
1555 R: 5.00899191454727744602429072688,
1556 Z: 0.05989229072794672115612942280,
1559 Name: "PosA_PosB_ALTB",
1569 Name: "PosA_NegB_AGTB",
1572 C: 0.94498607344025815971847507095,
1573 S: -0.32711056388316628605639521686,
1574 R: 2.751363298439520872718790879655,
1575 Z: -0.3271105638831662860563952168,
1578 Name: "PosA_NegB_ALTB",
1581 C: -0.6675450157520258540548049558,
1582 S: 0.7445694406464903756765132200,
1583 R: -3.8948684188300893100043812234,
1584 Z: 1 / -0.6675450157520258540548049558,
1587 Name: "NegA_PosB_AGTB",
1590 C: 0.7419981952497362418487847947,
1591 S: -0.6704018781642353764072353847,
1592 R: -15.363918770938617534070671122,
1593 Z: -0.6704018781642353764072353847,
1596 Name: "NegA_PosB_ALTB",
1599 C: -0.1346838895922121112404717523,
1600 S: 0.9908886162855605326977564640,
1601 R: 10.394710193170370442523552032,
1602 Z: 1 / -0.1346838895922121112404717523,
1605 Name: "NegA_NegB_AGTB",
1608 C: 0.7419981952497362418487847947,
1609 S: -0.6704018781642353764072353847,
1610 R: -15.363918770938617534070671122,
1611 Z: -0.6704018781642353764072353847,
1614 Name: "NegA_NegB_ALTB",
1617 C: 0.1346838895922121112404717523,
1618 S: 0.9908886162855605326977564640,
1619 R: -10.394710193170370442523552032,
1620 Z: 1 / 0.1346838895922121112404717523,
1624 type Drotger interface {
1625 Drotg(a, b float64) (c, s, r, z float64)
1628 func DrotgTest(t *testing.T, d Drotger) {
1630 for _, test := range DrotgTests {
1631 c, s, r, z := drotg(test.A, test.B)
1632 if !dTolEqual(c, test.C) {
1633 t.Errorf("drotg: c mismatch %v: expected %v, found %v", test.Name, test.C, c)
1635 if !dTolEqual(s, test.S) {
1636 t.Errorf("drotg: s mismatch %v: expected %v, found %v", test.Name, test.S, s)
1638 if !dTolEqual(r, test.R) {
1639 t.Errorf("drotg: r mismatch %v: expected %v, found %v", test.Name, test.R, r)
1641 if !dTolEqual(z, test.Z) {
1642 t.Errorf("drotg: z mismatch %v: expected %v, found %v", test.Name, test.Z, z)
1647 type DrotmgTestStruct struct {
1649 D1, D2, X1, Y1 float64
1651 Rd1, Rd2, Rx1 float64
1654 var DrotmgTests = []DrotmgTestStruct{
1657 P: &blas.DrotmParams{
1658 Flag: blas.Rescaling,
1667 P: &blas.DrotmParams{
1668 Flag: blas.Identity,
1678 P: &blas.DrotmParams{
1679 Flag: blas.Identity,
1689 Name: "NegQ2_and_AQ1_LT_AQ2",
1690 P: &blas.DrotmParams{
1691 Flag: blas.Rescaling,
1703 P: &blas.DrotmParams{
1704 Flag: blas.Diagonal,
1705 H: [4]float64{0, 0, 0, 2},
1716 Name: "AbsQ1_GT_AbsQU__D2_Pos",
1717 P: &blas.DrotmParams{
1718 Flag: blas.OffDiagonal,
1719 H: [4]float64{0, -0.625, 0.9375, 0},
1725 Rd1: 1.2610837438423645,
1726 Rd2: 1.8916256157635467,
1730 Name: "AbsQ1_GT_AbsQU__D2_Neg",
1731 P: &blas.DrotmParams{
1732 Flag: blas.OffDiagonal,
1733 H: [4]float64{0, -0.625, -0.9375, 0},
1739 Rd1: 4.830188679245283,
1740 Rd2: -7.245283018867925,
1744 Name: "AbsQ1_LT_AbsQU__D2_Pos",
1745 P: &blas.DrotmParams{
1746 Flag: blas.Diagonal,
1747 H: [4]float64{5.0 / 12, 0, 0, 0.625},
1753 Rd1: 2.3801652892561984,
1754 Rd2: 1.586776859504132,
1758 Name: "D1=D2_X1=X2",
1759 P: &blas.DrotmParams{
1760 Flag: blas.Diagonal,
1761 H: [4]float64{1, 0, 0, 1},
1772 Name: "RD1_Big_RD2_Big_Flag_0",
1773 P: &blas.DrotmParams{
1774 Flag: blas.Rescaling,
1775 H: [4]float64{4096, -3584, 1792, 4096},
1781 Rd1: 68.96627824858757,
1782 Rd2: 34.483139124293785,
1786 Name: "RD1_Big_RD2_Big_Flag_1",
1787 P: &blas.DrotmParams{
1788 Flag: blas.Rescaling,
1789 H: [4]float64{2340.5714285714284, -4096, 4096, 4681.142857142857},
1795 Rd1: 57.6914092640818,
1796 Rd2: 28.8457046320409,
1797 Rx1: 47396.57142857142,
1800 Name: "RD1_Big_RD2_Med_Flag_0",
1801 P: &blas.DrotmParams{
1802 Flag: blas.Rescaling,
1803 H: [4]float64{4096, -1, 0.0004096, 1},
1809 Rd1: 1.1920927762985347,
1810 Rd2: 1.9999998000000199,
1814 Name: "RD1_Big_RD2_Med_Flag_1",
1815 P: &blas.DrotmParams{
1816 Flag: blas.Rescaling,
1817 H: [4]float64{4.096e-17, -1, 4096, 1e-10},
1823 Rd1: 1192.0928955078125,
1828 // TODO: Add D1 big, D2 small, Flag = 0
1830 Name: "D1_Big_D2_Small_Flag_1",
1831 P: &blas.DrotmParams{
1832 Flag: blas.Rescaling,
1833 H: [4]float64{2.8671999999999997e-26, -0.000244140625, 4096, 2.44140625e-16},
1839 Rd1: 119.20928955078125,
1845 Name: "RD1_Med_RD2_Big_Flag_0",
1846 P: &blas.DrotmParams{
1847 Flag: blas.Rescaling,
1848 H: [4]float64{1, -0.0004096, 1000, 4096},
1854 Rd1: 1.9998000199980002,
1855 Rd2: 1191.9736981379988,
1859 Name: "D1_Med_D2_Big_Flag_1",
1860 P: &blas.DrotmParams{
1861 Flag: blas.Rescaling,
1862 H: [4]float64{50, -4096, 1, 4.096e-06},
1867 Y1: 80000000000000000,
1868 Rd1: 0.39999998000000103,
1869 Rd2: 1192.092835903171,
1873 Name: "RD1_Med_RD2_Small_Flag_0",
1874 P: &blas.DrotmParams{
1875 Flag: blas.Rescaling,
1876 H: [4]float64{1, -0.0007233796296296296, 1.1111111111111111e-10, 0.000244140625},
1882 Rd1: 1.1999999996049382,
1883 Rd2: 0.0007549747197514486,
1884 Rx1: 2.700000000888889,
1887 Name: "RD1_Med_RD2_Small_Flag_1",
1888 P: &blas.DrotmParams{
1889 Flag: blas.Rescaling,
1890 H: [4]float64{0.0002197265625, -1, 0.000244140625, 3.375e-11},
1896 Rd1: 0.0007549747199770676,
1897 Rd2: 1.19999999996355,
1898 Rx1: 1.9531250000593264e+07,
1900 // TODO: Add Small, Big, 0 case
1902 Name: "D1_Small_D2_Big_Flag_1",
1903 P: &blas.DrotmParams{
1904 Flag: blas.Rescaling,
1905 H: [4]float64{2.3731773997569866e+10, -1.6777216e+07, 0.000244140625, 1.6777216e-07},
1907 D1: 120000000000000000,
1908 D2: 0.000000000012345,
1911 Rd1: 0.00010502490698765249,
1912 Rd2: 216.1836123957717,
1913 Rx1: 3.8516669198055897e+09,
1916 Name: "RD1_Small_RD2_Med_Flag_0",
1917 P: &blas.DrotmParams{
1918 Flag: blas.Rescaling,
1919 H: [4]float64{0.000244140625, -1e-08, 0.24414062499999997, 1},
1925 Rd1: 0.003355409645903541,
1926 Rd2: 19.99980000199998,
1927 Rx1: 0.000195314453125,
1930 Name: "RD1_Small_RD2_Med_Flag_1",
1931 P: &blas.DrotmParams{
1932 Flag: blas.Rescaling,
1933 H: [4]float64{0.0012207031250000002, -1, 0.000244140625, 1e-09},
1939 Rd1: 6.710886366445568e-05,
1940 Rd2: 0.019999999900000003,
1941 Rx1: 1953.125009765625,
1943 // TODO: Add Small, Small, 0 case
1944 // TODO: Add Small, Small, 1 case
1947 type Drotmger interface {
1948 Drotmg(d1, d2, x1, y1 float64) (p blas.DrotmParams, rd1, rd2, rx1 float64)
1951 func DrotmgTest(t *testing.T, d Drotmger) {
1952 for _, test := range DrotmgTests {
1954 p, rd1, rd2, rx1 := d.Drotmg(test.D1, test.D2, test.X1, test.Y1)
1956 if p.Flag != test.P.Flag {
1957 t.Errorf("drotmg flag mismatch %v: expected %v, found %v", test.Name, test.P.Flag, p.Flag)
1959 for i, val := range p.H {
1960 if !dTolEqual(test.P.H[i], val) {
1961 t.Errorf("drotmg H mismatch %v: expected %v, found %v", test.Name, test.P.H, p.H)
1965 if !dTolEqual(rd1, test.Rd1) {
1966 t.Errorf("drotmg rd1 mismatch %v: expected %v, found %v", test.Name, test.Rd1, rd1)
1968 if !dTolEqual(rd2, test.Rd2) {
1969 t.Errorf("drotmg rd2 mismatch %v: expected %v, found %v", test.Name, test.Rd2, rd2)
1971 if !dTolEqual(rx1, test.Rx1) {
1972 t.Errorf("drotmg rx1 mismatch %v: expected %v, found %v", test.Name, test.Rx1, rx1)
1977 type Droter interface {
1978 Drot(n int, x []float64, incX int, y []float64, incY int, c, s float64)
1981 func DrotTest(t *testing.T, d Droter) {
1983 for _, c := range DoubleTwoVectorCases {
1984 for _, kind := range c.DrotCases {
1985 dCopyTwoTmp(c.X, c.XTmp, c.Y, c.YTmp)
1987 f := func() { drot(c.N, c.XTmp, c.Incx, c.YTmp, c.Incy, kind.C, kind.S) }
1988 testpanics(f, c.Name, t)
1991 drot(c.N, c.XTmp, c.Incx, c.YTmp, c.Incy, kind.C, kind.S)
1992 if !dSliceTolEqual(c.XTmp, kind.XAns) {
1993 t.Errorf("drot: x mismatch %v: expected %v, found %v", c.Name, kind.XAns, c.XTmp)
1995 if !dSliceTolEqual(c.YTmp, kind.YAns) {
1996 t.Errorf("drot: y mismatch %v: expected %v, found %v", c.Name, kind.YAns, c.YTmp)
2002 type Drotmer interface {
2003 Drotm(n int, x []float64, incX int, y []float64, incY int, p blas.DrotmParams)
2006 func DrotmTest(t *testing.T, d Drotmer) {
2008 for _, c := range DoubleTwoVectorCases {
2009 for _, kind := range c.DrotmCases {
2010 dCopyTwoTmp(c.X, c.XTmp, c.Y, c.YTmp)
2012 f := func() { drotm(c.N, c.XTmp, c.Incx, c.YTmp, c.Incy, kind.P) }
2013 testpanics(f, c.Name+", "+kind.Name, t)
2016 drotm(c.N, c.XTmp, c.Incx, c.YTmp, c.Incy, kind.P)
2017 if !dSliceTolEqual(c.XTmp, kind.XAns) {
2018 t.Errorf("drotm: mismatch %v: expected %v, found %v", c.Name, kind.XAns, c.XTmp)
2020 if !dSliceTolEqual(c.YTmp, kind.YAns) {
2021 t.Errorf("drotm: mismatch %v: expected %v, found %v", c.Name, kind.YAns, c.YTmp)
2027 type Dscaler interface {
2028 Dscal(n int, alpha float64, x []float64, incX int)
2031 func DscalTest(t *testing.T, blasser Dscaler) {
2032 dscal := blasser.Dscal
2033 for _, c := range DoubleOneVectorCases {
2034 for _, kind := range c.DscalCases {
2035 xTmp := make([]float64, len(c.X))
2038 f := func() { dscal(c.N, kind.Alpha, xTmp, c.Incx) }
2039 testpanics(f, c.Name, t)
2042 dscal(c.N, kind.Alpha, xTmp, c.Incx)
2043 if !dSliceTolEqual(xTmp, kind.Ans) {
2044 t.Errorf("dscal: mismatch %v, %v: expected %v, found %v", c.Name, kind.Name, kind.Ans, xTmp)