-
Notifications
You must be signed in to change notification settings - Fork 0
/
Copy pathDoubleTests.cpp
2785 lines (2507 loc) · 189 KB
/
DoubleTests.cpp
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
827
828
829
830
831
832
833
834
835
836
837
838
839
840
841
842
843
844
845
846
847
848
849
850
851
852
853
854
855
856
857
858
859
860
861
862
863
864
865
866
867
868
869
870
871
872
873
874
875
876
877
878
879
880
881
882
883
884
885
886
887
888
889
890
891
892
893
894
895
896
897
898
899
900
901
902
903
904
905
906
907
908
909
910
911
912
913
914
915
916
917
918
919
920
921
922
923
924
925
926
927
928
929
930
931
932
933
934
935
936
937
938
939
940
941
942
943
944
945
946
947
948
949
950
951
952
953
954
955
956
957
958
959
960
961
962
963
964
965
966
967
968
969
970
971
972
973
974
975
976
977
978
979
980
981
982
983
984
985
986
987
988
989
990
991
992
993
994
995
996
997
998
999
1000
/*
BSD 3-Clause License
Copyright (c) 2022, Thomas DiModica
All rights reserved.
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are met:
* Redistributions of source code must retain the above copyright notice, this
list of conditions and the following disclaimer.
* Redistributions in binary form must reproduce the above copyright notice,
this list of conditions and the following disclaimer in the documentation
and/or other materials provided with the distribution.
* Neither the name of the copyright holder nor the names of its
contributors may be used to endorse or promote products derived from
this software without specific prior written permission.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#include "gtest/gtest.h"
#include <cmath>
#ifndef MISRAbleC
#include "dm_double.h"
#define DM_DOUBLE_PACK(sign, exponent, significand) ((((uint64_t)(exponent)) << 54) | ((significand) - MIN_SIGNIFICAND) | ((sign) ? SIGN_BIT : 0))
#define DM_DOUBLE_PACK_ALT(sign, exponent, significand) ((((uint64_t)(exponent)) << 54) | (significand) | ((sign) ? SIGN_BIT : 0))
const int16_t SPECIAL_EXPONENT = -512;
const uint64_t DM_INFINITY = 0x1FFFFFFFFFFFFFULL;
const uint64_t SIGN_BIT = 0x20000000000000ULL;
const uint64_t MIN_SIGNIFICAND = 1000000000000000ULL;
#else /* The MISRAbleC version */
#include "dm_double_m.h"
#define DM_DOUBLE_PACK(sign, exponent, significand) ((((uint64_t)(exponent - SPECIAL_EXPONENT)) << 53) | ((significand) - MIN_SIGNIFICAND) | ((sign) ? SIGN_BIT : 0))
#define DM_DOUBLE_PACK_ALT(sign, exponent, significand) ((((uint64_t)(exponent - SPECIAL_EXPONENT)) << 53) | (significand) | ((sign) ? SIGN_BIT : 0))
const int16_t SPECIAL_EXPONENT = -512;
const uint64_t DM_INFINITY = 0x1FFFFFFFFFFFFFULL;
const uint64_t SIGN_BIT = 0x8000000000000000ULL;
const uint64_t MIN_SIGNIFICAND = 1000000000000000ULL;
#endif /* MISRAbleC */
#include "dm_double_pretty.h"
TEST(DMDoubleTest, testComparisons) // It was super easy to copy and modify this code from the SlowFloat tests
{
dm_double positiveZero = DM_DOUBLE_PACK_ALT(0, SPECIAL_EXPONENT, 0U); // Special exponent, zero significand : zero
dm_double negativeZero = DM_DOUBLE_PACK_ALT(1, SPECIAL_EXPONENT, 0U);
dm_double positiveOne = DM_DOUBLE_PACK(0, 0, 1000000000000000ULL);
dm_double negativeOne = DM_DOUBLE_PACK(1, 0, 1000000000000000ULL);
dm_double positiveTwo = DM_DOUBLE_PACK(0, 0, 2000000000000000ULL);
dm_double negativeTwo = DM_DOUBLE_PACK(1, 0, 2000000000000000ULL);
dm_double positiveTen = DM_DOUBLE_PACK(0, 1, 1000000000000000ULL);
dm_double negativeTen = DM_DOUBLE_PACK(1, 1, 1000000000000000ULL);
dm_double positiveInf = DM_DOUBLE_PACK_ALT(0, SPECIAL_EXPONENT, DM_INFINITY); // Special exponent, ones significand : infinity
dm_double negativeInf = DM_DOUBLE_PACK_ALT(1, SPECIAL_EXPONENT, DM_INFINITY);
dm_double nan = DM_DOUBLE_PACK_ALT(0, SPECIAL_EXPONENT, 1U); // Special exponent, any other significand : NaN
EXPECT_EQ(1, dm_double_isequal(positiveZero, positiveZero));
EXPECT_EQ(1, dm_double_isequal(positiveZero, negativeZero));
EXPECT_EQ(0, dm_double_isequal(positiveZero, positiveOne));
EXPECT_EQ(0, dm_double_isequal(positiveZero, negativeOne));
EXPECT_EQ(0, dm_double_isequal(positiveZero, positiveTwo));
EXPECT_EQ(0, dm_double_isequal(positiveZero, negativeTwo));
EXPECT_EQ(0, dm_double_isequal(positiveZero, positiveTen));
EXPECT_EQ(0, dm_double_isequal(positiveZero, negativeTen));
EXPECT_EQ(0, dm_double_isequal(positiveZero, positiveInf));
EXPECT_EQ(0, dm_double_isequal(positiveZero, negativeInf));
EXPECT_EQ(0, dm_double_isequal(positiveZero, nan));
EXPECT_EQ(1, dm_double_isequal(negativeZero, positiveZero));
EXPECT_EQ(1, dm_double_isequal(negativeZero, negativeZero));
EXPECT_EQ(0, dm_double_isequal(negativeZero, positiveOne));
EXPECT_EQ(0, dm_double_isequal(negativeZero, negativeOne));
EXPECT_EQ(0, dm_double_isequal(negativeZero, positiveTwo));
EXPECT_EQ(0, dm_double_isequal(negativeZero, negativeTwo));
EXPECT_EQ(0, dm_double_isequal(negativeZero, positiveTen));
EXPECT_EQ(0, dm_double_isequal(negativeZero, negativeTen));
EXPECT_EQ(0, dm_double_isequal(negativeZero, positiveInf));
EXPECT_EQ(0, dm_double_isequal(negativeZero, negativeInf));
EXPECT_EQ(0, dm_double_isequal(negativeZero, nan));
EXPECT_EQ(0, dm_double_isequal(positiveOne, positiveZero));
EXPECT_EQ(0, dm_double_isequal(positiveOne, negativeZero));
EXPECT_EQ(1, dm_double_isequal(positiveOne, positiveOne));
EXPECT_EQ(0, dm_double_isequal(positiveOne, negativeOne));
EXPECT_EQ(0, dm_double_isequal(positiveOne, positiveTwo));
EXPECT_EQ(0, dm_double_isequal(positiveOne, negativeTwo));
EXPECT_EQ(0, dm_double_isequal(positiveOne, positiveTen));
EXPECT_EQ(0, dm_double_isequal(positiveOne, negativeTen));
EXPECT_EQ(0, dm_double_isequal(positiveOne, positiveInf));
EXPECT_EQ(0, dm_double_isequal(positiveOne, negativeInf));
EXPECT_EQ(0, dm_double_isequal(positiveOne, nan));
EXPECT_EQ(0, dm_double_isequal(negativeOne, positiveZero));
EXPECT_EQ(0, dm_double_isequal(negativeOne, negativeZero));
EXPECT_EQ(0, dm_double_isequal(negativeOne, positiveOne));
EXPECT_EQ(1, dm_double_isequal(negativeOne, negativeOne));
EXPECT_EQ(0, dm_double_isequal(negativeOne, positiveTwo));
EXPECT_EQ(0, dm_double_isequal(negativeOne, negativeTwo));
EXPECT_EQ(0, dm_double_isequal(negativeOne, positiveTen));
EXPECT_EQ(0, dm_double_isequal(negativeOne, negativeTen));
EXPECT_EQ(0, dm_double_isequal(negativeOne, positiveInf));
EXPECT_EQ(0, dm_double_isequal(negativeOne, negativeInf));
EXPECT_EQ(0, dm_double_isequal(negativeOne, nan));
EXPECT_EQ(0, dm_double_isequal(positiveTwo, positiveZero));
EXPECT_EQ(0, dm_double_isequal(positiveTwo, negativeZero));
EXPECT_EQ(0, dm_double_isequal(positiveTwo, positiveOne));
EXPECT_EQ(0, dm_double_isequal(positiveTwo, negativeOne));
EXPECT_EQ(1, dm_double_isequal(positiveTwo, positiveTwo));
EXPECT_EQ(0, dm_double_isequal(positiveTwo, negativeTwo));
EXPECT_EQ(0, dm_double_isequal(positiveTwo, positiveTen));
EXPECT_EQ(0, dm_double_isequal(positiveTwo, negativeTen));
EXPECT_EQ(0, dm_double_isequal(positiveTwo, positiveInf));
EXPECT_EQ(0, dm_double_isequal(positiveTwo, negativeInf));
EXPECT_EQ(0, dm_double_isequal(positiveTwo, nan));
EXPECT_EQ(0, dm_double_isequal(negativeTwo, positiveZero));
EXPECT_EQ(0, dm_double_isequal(negativeTwo, negativeZero));
EXPECT_EQ(0, dm_double_isequal(negativeTwo, positiveOne));
EXPECT_EQ(0, dm_double_isequal(negativeTwo, negativeOne));
EXPECT_EQ(0, dm_double_isequal(negativeTwo, positiveTwo));
EXPECT_EQ(1, dm_double_isequal(negativeTwo, negativeTwo));
EXPECT_EQ(0, dm_double_isequal(negativeTwo, positiveTen));
EXPECT_EQ(0, dm_double_isequal(negativeTwo, negativeTen));
EXPECT_EQ(0, dm_double_isequal(negativeTwo, positiveInf));
EXPECT_EQ(0, dm_double_isequal(negativeTwo, negativeInf));
EXPECT_EQ(0, dm_double_isequal(negativeTwo, nan));
EXPECT_EQ(0, dm_double_isequal(positiveTen, positiveZero));
EXPECT_EQ(0, dm_double_isequal(positiveTen, negativeZero));
EXPECT_EQ(0, dm_double_isequal(positiveTen, positiveOne));
EXPECT_EQ(0, dm_double_isequal(positiveTen, negativeOne));
EXPECT_EQ(0, dm_double_isequal(positiveTen, positiveTwo));
EXPECT_EQ(0, dm_double_isequal(positiveTen, negativeTwo));
EXPECT_EQ(1, dm_double_isequal(positiveTen, positiveTen));
EXPECT_EQ(0, dm_double_isequal(positiveTen, negativeTen));
EXPECT_EQ(0, dm_double_isequal(positiveTen, positiveInf));
EXPECT_EQ(0, dm_double_isequal(positiveTen, negativeInf));
EXPECT_EQ(0, dm_double_isequal(positiveTen, nan));
EXPECT_EQ(0, dm_double_isequal(negativeTen, positiveZero));
EXPECT_EQ(0, dm_double_isequal(negativeTen, negativeZero));
EXPECT_EQ(0, dm_double_isequal(negativeTen, positiveOne));
EXPECT_EQ(0, dm_double_isequal(negativeTen, negativeOne));
EXPECT_EQ(0, dm_double_isequal(negativeTen, positiveTwo));
EXPECT_EQ(0, dm_double_isequal(negativeTen, negativeTwo));
EXPECT_EQ(0, dm_double_isequal(negativeTen, positiveTen));
EXPECT_EQ(1, dm_double_isequal(negativeTen, negativeTen));
EXPECT_EQ(0, dm_double_isequal(negativeTen, positiveInf));
EXPECT_EQ(0, dm_double_isequal(negativeTen, negativeInf));
EXPECT_EQ(0, dm_double_isequal(negativeTen, nan));
EXPECT_EQ(0, dm_double_isequal(positiveInf, positiveZero));
EXPECT_EQ(0, dm_double_isequal(positiveInf, negativeZero));
EXPECT_EQ(0, dm_double_isequal(positiveInf, positiveOne));
EXPECT_EQ(0, dm_double_isequal(positiveInf, negativeOne));
EXPECT_EQ(0, dm_double_isequal(positiveInf, positiveTwo));
EXPECT_EQ(0, dm_double_isequal(positiveInf, negativeTwo));
EXPECT_EQ(0, dm_double_isequal(positiveInf, positiveTen));
EXPECT_EQ(0, dm_double_isequal(positiveInf, negativeTen));
EXPECT_EQ(1, dm_double_isequal(positiveInf, positiveInf));
EXPECT_EQ(0, dm_double_isequal(positiveInf, negativeInf));
EXPECT_EQ(0, dm_double_isequal(positiveInf, nan));
EXPECT_EQ(0, dm_double_isequal(negativeInf, positiveZero));
EXPECT_EQ(0, dm_double_isequal(negativeInf, negativeZero));
EXPECT_EQ(0, dm_double_isequal(negativeInf, positiveOne));
EXPECT_EQ(0, dm_double_isequal(negativeInf, negativeOne));
EXPECT_EQ(0, dm_double_isequal(negativeInf, positiveTwo));
EXPECT_EQ(0, dm_double_isequal(negativeInf, negativeTwo));
EXPECT_EQ(0, dm_double_isequal(negativeInf, positiveTen));
EXPECT_EQ(0, dm_double_isequal(negativeInf, negativeTen));
EXPECT_EQ(0, dm_double_isequal(negativeInf, positiveInf));
EXPECT_EQ(1, dm_double_isequal(negativeInf, negativeInf));
EXPECT_EQ(0, dm_double_isequal(negativeInf, nan));
EXPECT_EQ(0, dm_double_isequal(nan, positiveZero));
EXPECT_EQ(0, dm_double_isequal(nan, negativeZero));
EXPECT_EQ(0, dm_double_isequal(nan, positiveOne));
EXPECT_EQ(0, dm_double_isequal(nan, negativeOne));
EXPECT_EQ(0, dm_double_isequal(nan, positiveTwo));
EXPECT_EQ(0, dm_double_isequal(nan, negativeTwo));
EXPECT_EQ(0, dm_double_isequal(nan, positiveTen));
EXPECT_EQ(0, dm_double_isequal(nan, negativeTen));
EXPECT_EQ(0, dm_double_isequal(nan, positiveInf));
EXPECT_EQ(0, dm_double_isequal(nan, negativeInf));
EXPECT_EQ(0, dm_double_isequal(nan, nan));
EXPECT_EQ(0, dm_double_isunequal(positiveZero, positiveZero));
EXPECT_EQ(0, dm_double_isunequal(positiveZero, negativeZero));
EXPECT_EQ(1, dm_double_isunequal(positiveZero, positiveOne));
EXPECT_EQ(1, dm_double_isunequal(positiveZero, negativeOne));
EXPECT_EQ(1, dm_double_isunequal(positiveZero, positiveTwo));
EXPECT_EQ(1, dm_double_isunequal(positiveZero, negativeTwo));
EXPECT_EQ(1, dm_double_isunequal(positiveZero, positiveTen));
EXPECT_EQ(1, dm_double_isunequal(positiveZero, negativeTen));
EXPECT_EQ(1, dm_double_isunequal(positiveZero, positiveInf));
EXPECT_EQ(1, dm_double_isunequal(positiveZero, negativeInf));
EXPECT_EQ(1, dm_double_isunequal(positiveZero, nan));
EXPECT_EQ(0, dm_double_isunequal(negativeZero, positiveZero));
EXPECT_EQ(0, dm_double_isunequal(negativeZero, negativeZero));
EXPECT_EQ(1, dm_double_isunequal(negativeZero, positiveOne));
EXPECT_EQ(1, dm_double_isunequal(negativeZero, negativeOne));
EXPECT_EQ(1, dm_double_isunequal(negativeZero, positiveTwo));
EXPECT_EQ(1, dm_double_isunequal(negativeZero, negativeTwo));
EXPECT_EQ(1, dm_double_isunequal(negativeZero, positiveTen));
EXPECT_EQ(1, dm_double_isunequal(negativeZero, negativeTen));
EXPECT_EQ(1, dm_double_isunequal(negativeZero, positiveInf));
EXPECT_EQ(1, dm_double_isunequal(negativeZero, negativeInf));
EXPECT_EQ(1, dm_double_isunequal(negativeZero, nan));
EXPECT_EQ(1, dm_double_isunequal(positiveOne, positiveZero));
EXPECT_EQ(1, dm_double_isunequal(positiveOne, negativeZero));
EXPECT_EQ(0, dm_double_isunequal(positiveOne, positiveOne));
EXPECT_EQ(1, dm_double_isunequal(positiveOne, negativeOne));
EXPECT_EQ(1, dm_double_isunequal(positiveOne, positiveTwo));
EXPECT_EQ(1, dm_double_isunequal(positiveOne, negativeTwo));
EXPECT_EQ(1, dm_double_isunequal(positiveOne, positiveTen));
EXPECT_EQ(1, dm_double_isunequal(positiveOne, negativeTen));
EXPECT_EQ(1, dm_double_isunequal(positiveOne, positiveInf));
EXPECT_EQ(1, dm_double_isunequal(positiveOne, negativeInf));
EXPECT_EQ(1, dm_double_isunequal(positiveOne, nan));
EXPECT_EQ(1, dm_double_isunequal(negativeOne, positiveZero));
EXPECT_EQ(1, dm_double_isunequal(negativeOne, negativeZero));
EXPECT_EQ(1, dm_double_isunequal(negativeOne, positiveOne));
EXPECT_EQ(0, dm_double_isunequal(negativeOne, negativeOne));
EXPECT_EQ(1, dm_double_isunequal(negativeOne, positiveTwo));
EXPECT_EQ(1, dm_double_isunequal(negativeOne, negativeTwo));
EXPECT_EQ(1, dm_double_isunequal(negativeOne, positiveTen));
EXPECT_EQ(1, dm_double_isunequal(negativeOne, negativeTen));
EXPECT_EQ(1, dm_double_isunequal(negativeOne, positiveInf));
EXPECT_EQ(1, dm_double_isunequal(negativeOne, negativeInf));
EXPECT_EQ(1, dm_double_isunequal(negativeOne, nan));
EXPECT_EQ(1, dm_double_isunequal(positiveTwo, positiveZero));
EXPECT_EQ(1, dm_double_isunequal(positiveTwo, negativeZero));
EXPECT_EQ(1, dm_double_isunequal(positiveTwo, positiveOne));
EXPECT_EQ(1, dm_double_isunequal(positiveTwo, negativeOne));
EXPECT_EQ(0, dm_double_isunequal(positiveTwo, positiveTwo));
EXPECT_EQ(1, dm_double_isunequal(positiveTwo, negativeTwo));
EXPECT_EQ(1, dm_double_isunequal(positiveTwo, positiveTen));
EXPECT_EQ(1, dm_double_isunequal(positiveTwo, negativeTen));
EXPECT_EQ(1, dm_double_isunequal(positiveTwo, positiveInf));
EXPECT_EQ(1, dm_double_isunequal(positiveTwo, negativeInf));
EXPECT_EQ(1, dm_double_isunequal(positiveTwo, nan));
EXPECT_EQ(1, dm_double_isunequal(negativeTwo, positiveZero));
EXPECT_EQ(1, dm_double_isunequal(negativeTwo, negativeZero));
EXPECT_EQ(1, dm_double_isunequal(negativeTwo, positiveOne));
EXPECT_EQ(1, dm_double_isunequal(negativeTwo, negativeOne));
EXPECT_EQ(1, dm_double_isunequal(negativeTwo, positiveTwo));
EXPECT_EQ(0, dm_double_isunequal(negativeTwo, negativeTwo));
EXPECT_EQ(1, dm_double_isunequal(negativeTwo, positiveTen));
EXPECT_EQ(1, dm_double_isunequal(negativeTwo, negativeTen));
EXPECT_EQ(1, dm_double_isunequal(negativeTwo, positiveInf));
EXPECT_EQ(1, dm_double_isunequal(negativeTwo, negativeInf));
EXPECT_EQ(1, dm_double_isunequal(negativeTwo, nan));
EXPECT_EQ(1, dm_double_isunequal(positiveTen, positiveZero));
EXPECT_EQ(1, dm_double_isunequal(positiveTen, negativeZero));
EXPECT_EQ(1, dm_double_isunequal(positiveTen, positiveOne));
EXPECT_EQ(1, dm_double_isunequal(positiveTen, negativeOne));
EXPECT_EQ(1, dm_double_isunequal(positiveTen, positiveTwo));
EXPECT_EQ(1, dm_double_isunequal(positiveTen, negativeTwo));
EXPECT_EQ(0, dm_double_isunequal(positiveTen, positiveTen));
EXPECT_EQ(1, dm_double_isunequal(positiveTen, negativeTen));
EXPECT_EQ(1, dm_double_isunequal(positiveTen, positiveInf));
EXPECT_EQ(1, dm_double_isunequal(positiveTen, negativeInf));
EXPECT_EQ(1, dm_double_isunequal(positiveTen, nan));
EXPECT_EQ(1, dm_double_isunequal(negativeTen, positiveZero));
EXPECT_EQ(1, dm_double_isunequal(negativeTen, negativeZero));
EXPECT_EQ(1, dm_double_isunequal(negativeTen, positiveOne));
EXPECT_EQ(1, dm_double_isunequal(negativeTen, negativeOne));
EXPECT_EQ(1, dm_double_isunequal(negativeTen, positiveTwo));
EXPECT_EQ(1, dm_double_isunequal(negativeTen, negativeTwo));
EXPECT_EQ(1, dm_double_isunequal(negativeTen, positiveTen));
EXPECT_EQ(0, dm_double_isunequal(negativeTen, negativeTen));
EXPECT_EQ(1, dm_double_isunequal(negativeTen, positiveInf));
EXPECT_EQ(1, dm_double_isunequal(negativeTen, negativeInf));
EXPECT_EQ(1, dm_double_isunequal(negativeTen, nan));
EXPECT_EQ(1, dm_double_isunequal(positiveInf, positiveZero));
EXPECT_EQ(1, dm_double_isunequal(positiveInf, negativeZero));
EXPECT_EQ(1, dm_double_isunequal(positiveInf, positiveOne));
EXPECT_EQ(1, dm_double_isunequal(positiveInf, negativeOne));
EXPECT_EQ(1, dm_double_isunequal(positiveInf, positiveTwo));
EXPECT_EQ(1, dm_double_isunequal(positiveInf, negativeTwo));
EXPECT_EQ(1, dm_double_isunequal(positiveInf, positiveTen));
EXPECT_EQ(1, dm_double_isunequal(positiveInf, negativeTen));
EXPECT_EQ(0, dm_double_isunequal(positiveInf, positiveInf));
EXPECT_EQ(1, dm_double_isunequal(positiveInf, negativeInf));
EXPECT_EQ(1, dm_double_isunequal(positiveInf, nan));
EXPECT_EQ(1, dm_double_isunequal(negativeInf, positiveZero));
EXPECT_EQ(1, dm_double_isunequal(negativeInf, negativeZero));
EXPECT_EQ(1, dm_double_isunequal(negativeInf, positiveOne));
EXPECT_EQ(1, dm_double_isunequal(negativeInf, negativeOne));
EXPECT_EQ(1, dm_double_isunequal(negativeInf, positiveTwo));
EXPECT_EQ(1, dm_double_isunequal(negativeInf, negativeTwo));
EXPECT_EQ(1, dm_double_isunequal(negativeInf, positiveTen));
EXPECT_EQ(1, dm_double_isunequal(negativeInf, negativeTen));
EXPECT_EQ(1, dm_double_isunequal(negativeInf, positiveInf));
EXPECT_EQ(0, dm_double_isunequal(negativeInf, negativeInf));
EXPECT_EQ(1, dm_double_isunequal(negativeInf, nan));
EXPECT_EQ(1, dm_double_isunequal(nan, positiveZero));
EXPECT_EQ(1, dm_double_isunequal(nan, negativeZero));
EXPECT_EQ(1, dm_double_isunequal(nan, positiveOne));
EXPECT_EQ(1, dm_double_isunequal(nan, negativeOne));
EXPECT_EQ(1, dm_double_isunequal(nan, positiveTwo));
EXPECT_EQ(1, dm_double_isunequal(nan, negativeTwo));
EXPECT_EQ(1, dm_double_isunequal(nan, positiveTen));
EXPECT_EQ(1, dm_double_isunequal(nan, negativeTen));
EXPECT_EQ(1, dm_double_isunequal(nan, positiveInf));
EXPECT_EQ(1, dm_double_isunequal(nan, negativeInf));
EXPECT_EQ(1, dm_double_isunequal(nan, nan));
EXPECT_EQ(0, dm_double_islessgreater(positiveZero, positiveZero));
EXPECT_EQ(0, dm_double_islessgreater(positiveZero, negativeZero));
EXPECT_EQ(1, dm_double_islessgreater(positiveZero, positiveOne));
EXPECT_EQ(1, dm_double_islessgreater(positiveZero, negativeOne));
EXPECT_EQ(1, dm_double_islessgreater(positiveZero, positiveTwo));
EXPECT_EQ(1, dm_double_islessgreater(positiveZero, negativeTwo));
EXPECT_EQ(1, dm_double_islessgreater(positiveZero, positiveTen));
EXPECT_EQ(1, dm_double_islessgreater(positiveZero, negativeTen));
EXPECT_EQ(1, dm_double_islessgreater(positiveZero, positiveInf));
EXPECT_EQ(1, dm_double_islessgreater(positiveZero, negativeInf));
EXPECT_EQ(0, dm_double_islessgreater(positiveZero, nan));
EXPECT_EQ(0, dm_double_islessgreater(negativeZero, positiveZero));
EXPECT_EQ(0, dm_double_islessgreater(negativeZero, negativeZero));
EXPECT_EQ(1, dm_double_islessgreater(negativeZero, positiveOne));
EXPECT_EQ(1, dm_double_islessgreater(negativeZero, negativeOne));
EXPECT_EQ(1, dm_double_islessgreater(negativeZero, positiveTwo));
EXPECT_EQ(1, dm_double_islessgreater(negativeZero, negativeTwo));
EXPECT_EQ(1, dm_double_islessgreater(negativeZero, positiveTen));
EXPECT_EQ(1, dm_double_islessgreater(negativeZero, negativeTen));
EXPECT_EQ(1, dm_double_islessgreater(negativeZero, positiveInf));
EXPECT_EQ(1, dm_double_islessgreater(negativeZero, negativeInf));
EXPECT_EQ(0, dm_double_islessgreater(negativeZero, nan));
EXPECT_EQ(1, dm_double_islessgreater(positiveOne, positiveZero));
EXPECT_EQ(1, dm_double_islessgreater(positiveOne, negativeZero));
EXPECT_EQ(0, dm_double_islessgreater(positiveOne, positiveOne));
EXPECT_EQ(1, dm_double_islessgreater(positiveOne, negativeOne));
EXPECT_EQ(1, dm_double_islessgreater(positiveOne, positiveTwo));
EXPECT_EQ(1, dm_double_islessgreater(positiveOne, negativeTwo));
EXPECT_EQ(1, dm_double_islessgreater(positiveOne, positiveTen));
EXPECT_EQ(1, dm_double_islessgreater(positiveOne, negativeTen));
EXPECT_EQ(1, dm_double_islessgreater(positiveOne, positiveInf));
EXPECT_EQ(1, dm_double_islessgreater(positiveOne, negativeInf));
EXPECT_EQ(0, dm_double_islessgreater(positiveOne, nan));
EXPECT_EQ(1, dm_double_islessgreater(negativeOne, positiveZero));
EXPECT_EQ(1, dm_double_islessgreater(negativeOne, negativeZero));
EXPECT_EQ(1, dm_double_islessgreater(negativeOne, positiveOne));
EXPECT_EQ(0, dm_double_islessgreater(negativeOne, negativeOne));
EXPECT_EQ(1, dm_double_islessgreater(negativeOne, positiveTwo));
EXPECT_EQ(1, dm_double_islessgreater(negativeOne, negativeTwo));
EXPECT_EQ(1, dm_double_islessgreater(negativeOne, positiveTen));
EXPECT_EQ(1, dm_double_islessgreater(negativeOne, negativeTen));
EXPECT_EQ(1, dm_double_islessgreater(negativeOne, positiveInf));
EXPECT_EQ(1, dm_double_islessgreater(negativeOne, negativeInf));
EXPECT_EQ(0, dm_double_islessgreater(negativeOne, nan));
EXPECT_EQ(1, dm_double_islessgreater(positiveTwo, positiveZero));
EXPECT_EQ(1, dm_double_islessgreater(positiveTwo, negativeZero));
EXPECT_EQ(1, dm_double_islessgreater(positiveTwo, positiveOne));
EXPECT_EQ(1, dm_double_islessgreater(positiveTwo, negativeOne));
EXPECT_EQ(0, dm_double_islessgreater(positiveTwo, positiveTwo));
EXPECT_EQ(1, dm_double_islessgreater(positiveTwo, negativeTwo));
EXPECT_EQ(1, dm_double_islessgreater(positiveTwo, positiveTen));
EXPECT_EQ(1, dm_double_islessgreater(positiveTwo, negativeTen));
EXPECT_EQ(1, dm_double_islessgreater(positiveTwo, positiveInf));
EXPECT_EQ(1, dm_double_islessgreater(positiveTwo, negativeInf));
EXPECT_EQ(0, dm_double_islessgreater(positiveTwo, nan));
EXPECT_EQ(1, dm_double_islessgreater(negativeTwo, positiveZero));
EXPECT_EQ(1, dm_double_islessgreater(negativeTwo, negativeZero));
EXPECT_EQ(1, dm_double_islessgreater(negativeTwo, positiveOne));
EXPECT_EQ(1, dm_double_islessgreater(negativeTwo, negativeOne));
EXPECT_EQ(1, dm_double_islessgreater(negativeTwo, positiveTwo));
EXPECT_EQ(0, dm_double_islessgreater(negativeTwo, negativeTwo));
EXPECT_EQ(1, dm_double_islessgreater(negativeTwo, positiveTen));
EXPECT_EQ(1, dm_double_islessgreater(negativeTwo, negativeTen));
EXPECT_EQ(1, dm_double_islessgreater(negativeTwo, positiveInf));
EXPECT_EQ(1, dm_double_islessgreater(negativeTwo, negativeInf));
EXPECT_EQ(0, dm_double_islessgreater(negativeTwo, nan));
EXPECT_EQ(1, dm_double_islessgreater(positiveTen, positiveZero));
EXPECT_EQ(1, dm_double_islessgreater(positiveTen, negativeZero));
EXPECT_EQ(1, dm_double_islessgreater(positiveTen, positiveOne));
EXPECT_EQ(1, dm_double_islessgreater(positiveTen, negativeOne));
EXPECT_EQ(1, dm_double_islessgreater(positiveTen, positiveTwo));
EXPECT_EQ(1, dm_double_islessgreater(positiveTen, negativeTwo));
EXPECT_EQ(0, dm_double_islessgreater(positiveTen, positiveTen));
EXPECT_EQ(1, dm_double_islessgreater(positiveTen, negativeTen));
EXPECT_EQ(1, dm_double_islessgreater(positiveTen, positiveInf));
EXPECT_EQ(1, dm_double_islessgreater(positiveTen, negativeInf));
EXPECT_EQ(0, dm_double_islessgreater(positiveTen, nan));
EXPECT_EQ(1, dm_double_islessgreater(negativeTen, positiveZero));
EXPECT_EQ(1, dm_double_islessgreater(negativeTen, negativeZero));
EXPECT_EQ(1, dm_double_islessgreater(negativeTen, positiveOne));
EXPECT_EQ(1, dm_double_islessgreater(negativeTen, negativeOne));
EXPECT_EQ(1, dm_double_islessgreater(negativeTen, positiveTwo));
EXPECT_EQ(1, dm_double_islessgreater(negativeTen, negativeTwo));
EXPECT_EQ(1, dm_double_islessgreater(negativeTen, positiveTen));
EXPECT_EQ(0, dm_double_islessgreater(negativeTen, negativeTen));
EXPECT_EQ(1, dm_double_islessgreater(negativeTen, positiveInf));
EXPECT_EQ(1, dm_double_islessgreater(negativeTen, negativeInf));
EXPECT_EQ(0, dm_double_islessgreater(negativeTen, nan));
EXPECT_EQ(1, dm_double_islessgreater(positiveInf, positiveZero));
EXPECT_EQ(1, dm_double_islessgreater(positiveInf, negativeZero));
EXPECT_EQ(1, dm_double_islessgreater(positiveInf, positiveOne));
EXPECT_EQ(1, dm_double_islessgreater(positiveInf, negativeOne));
EXPECT_EQ(1, dm_double_islessgreater(positiveInf, positiveTwo));
EXPECT_EQ(1, dm_double_islessgreater(positiveInf, negativeTwo));
EXPECT_EQ(1, dm_double_islessgreater(positiveInf, positiveTen));
EXPECT_EQ(1, dm_double_islessgreater(positiveInf, negativeTen));
EXPECT_EQ(0, dm_double_islessgreater(positiveInf, positiveInf));
EXPECT_EQ(1, dm_double_islessgreater(positiveInf, negativeInf));
EXPECT_EQ(0, dm_double_islessgreater(positiveInf, nan));
EXPECT_EQ(1, dm_double_islessgreater(negativeInf, positiveZero));
EXPECT_EQ(1, dm_double_islessgreater(negativeInf, negativeZero));
EXPECT_EQ(1, dm_double_islessgreater(negativeInf, positiveOne));
EXPECT_EQ(1, dm_double_islessgreater(negativeInf, negativeOne));
EXPECT_EQ(1, dm_double_islessgreater(negativeInf, positiveTwo));
EXPECT_EQ(1, dm_double_islessgreater(negativeInf, negativeTwo));
EXPECT_EQ(1, dm_double_islessgreater(negativeInf, positiveTen));
EXPECT_EQ(1, dm_double_islessgreater(negativeInf, negativeTen));
EXPECT_EQ(1, dm_double_islessgreater(negativeInf, positiveInf));
EXPECT_EQ(0, dm_double_islessgreater(negativeInf, negativeInf));
EXPECT_EQ(0, dm_double_islessgreater(negativeInf, nan));
EXPECT_EQ(0, dm_double_islessgreater(nan, positiveZero));
EXPECT_EQ(0, dm_double_islessgreater(nan, negativeZero));
EXPECT_EQ(0, dm_double_islessgreater(nan, positiveOne));
EXPECT_EQ(0, dm_double_islessgreater(nan, negativeOne));
EXPECT_EQ(0, dm_double_islessgreater(nan, positiveTwo));
EXPECT_EQ(0, dm_double_islessgreater(nan, negativeTwo));
EXPECT_EQ(0, dm_double_islessgreater(nan, positiveTen));
EXPECT_EQ(0, dm_double_islessgreater(nan, negativeTen));
EXPECT_EQ(0, dm_double_islessgreater(nan, positiveInf));
EXPECT_EQ(0, dm_double_islessgreater(nan, negativeInf));
EXPECT_EQ(0, dm_double_islessgreater(nan, nan));
EXPECT_EQ(0, dm_double_isunordered(positiveZero, positiveZero));
EXPECT_EQ(0, dm_double_isunordered(positiveZero, negativeZero));
EXPECT_EQ(0, dm_double_isunordered(positiveZero, positiveOne));
EXPECT_EQ(0, dm_double_isunordered(positiveZero, negativeOne));
EXPECT_EQ(0, dm_double_isunordered(positiveZero, positiveTwo));
EXPECT_EQ(0, dm_double_isunordered(positiveZero, negativeTwo));
EXPECT_EQ(0, dm_double_isunordered(positiveZero, positiveTen));
EXPECT_EQ(0, dm_double_isunordered(positiveZero, negativeTen));
EXPECT_EQ(0, dm_double_isunordered(positiveZero, positiveInf));
EXPECT_EQ(0, dm_double_isunordered(positiveZero, negativeInf));
EXPECT_EQ(1, dm_double_isunordered(positiveZero, nan));
EXPECT_EQ(0, dm_double_isunordered(negativeZero, positiveZero));
EXPECT_EQ(0, dm_double_isunordered(negativeZero, negativeZero));
EXPECT_EQ(0, dm_double_isunordered(negativeZero, positiveOne));
EXPECT_EQ(0, dm_double_isunordered(negativeZero, negativeOne));
EXPECT_EQ(0, dm_double_isunordered(negativeZero, positiveTwo));
EXPECT_EQ(0, dm_double_isunordered(negativeZero, negativeTwo));
EXPECT_EQ(0, dm_double_isunordered(negativeZero, positiveTen));
EXPECT_EQ(0, dm_double_isunordered(negativeZero, negativeTen));
EXPECT_EQ(0, dm_double_isunordered(negativeZero, positiveInf));
EXPECT_EQ(0, dm_double_isunordered(negativeZero, negativeInf));
EXPECT_EQ(1, dm_double_isunordered(negativeZero, nan));
EXPECT_EQ(0, dm_double_isunordered(positiveOne, positiveZero));
EXPECT_EQ(0, dm_double_isunordered(positiveOne, negativeZero));
EXPECT_EQ(0, dm_double_isunordered(positiveOne, positiveOne));
EXPECT_EQ(0, dm_double_isunordered(positiveOne, negativeOne));
EXPECT_EQ(0, dm_double_isunordered(positiveOne, positiveTwo));
EXPECT_EQ(0, dm_double_isunordered(positiveOne, negativeTwo));
EXPECT_EQ(0, dm_double_isunordered(positiveOne, positiveTen));
EXPECT_EQ(0, dm_double_isunordered(positiveOne, negativeTen));
EXPECT_EQ(0, dm_double_isunordered(positiveOne, positiveInf));
EXPECT_EQ(0, dm_double_isunordered(positiveOne, negativeInf));
EXPECT_EQ(1, dm_double_isunordered(positiveOne, nan));
EXPECT_EQ(0, dm_double_isunordered(negativeOne, positiveZero));
EXPECT_EQ(0, dm_double_isunordered(negativeOne, negativeZero));
EXPECT_EQ(0, dm_double_isunordered(negativeOne, positiveOne));
EXPECT_EQ(0, dm_double_isunordered(negativeOne, negativeOne));
EXPECT_EQ(0, dm_double_isunordered(negativeOne, positiveTwo));
EXPECT_EQ(0, dm_double_isunordered(negativeOne, negativeTwo));
EXPECT_EQ(0, dm_double_isunordered(negativeOne, positiveTen));
EXPECT_EQ(0, dm_double_isunordered(negativeOne, negativeTen));
EXPECT_EQ(0, dm_double_isunordered(negativeOne, positiveInf));
EXPECT_EQ(0, dm_double_isunordered(negativeOne, negativeInf));
EXPECT_EQ(1, dm_double_isunordered(negativeOne, nan));
EXPECT_EQ(0, dm_double_isunordered(positiveTwo, positiveZero));
EXPECT_EQ(0, dm_double_isunordered(positiveTwo, negativeZero));
EXPECT_EQ(0, dm_double_isunordered(positiveTwo, positiveOne));
EXPECT_EQ(0, dm_double_isunordered(positiveTwo, negativeOne));
EXPECT_EQ(0, dm_double_isunordered(positiveTwo, positiveTwo));
EXPECT_EQ(0, dm_double_isunordered(positiveTwo, negativeTwo));
EXPECT_EQ(0, dm_double_isunordered(positiveTwo, positiveTen));
EXPECT_EQ(0, dm_double_isunordered(positiveTwo, negativeTen));
EXPECT_EQ(0, dm_double_isunordered(positiveTwo, positiveInf));
EXPECT_EQ(0, dm_double_isunordered(positiveTwo, negativeInf));
EXPECT_EQ(1, dm_double_isunordered(positiveTwo, nan));
EXPECT_EQ(0, dm_double_isunordered(negativeTwo, positiveZero));
EXPECT_EQ(0, dm_double_isunordered(negativeTwo, negativeZero));
EXPECT_EQ(0, dm_double_isunordered(negativeTwo, positiveOne));
EXPECT_EQ(0, dm_double_isunordered(negativeTwo, negativeOne));
EXPECT_EQ(0, dm_double_isunordered(negativeTwo, positiveTwo));
EXPECT_EQ(0, dm_double_isunordered(negativeTwo, negativeTwo));
EXPECT_EQ(0, dm_double_isunordered(negativeTwo, positiveTen));
EXPECT_EQ(0, dm_double_isunordered(negativeTwo, negativeTen));
EXPECT_EQ(0, dm_double_isunordered(negativeTwo, positiveInf));
EXPECT_EQ(0, dm_double_isunordered(negativeTwo, negativeInf));
EXPECT_EQ(1, dm_double_isunordered(negativeTwo, nan));
EXPECT_EQ(0, dm_double_isunordered(positiveTen, positiveZero));
EXPECT_EQ(0, dm_double_isunordered(positiveTen, negativeZero));
EXPECT_EQ(0, dm_double_isunordered(positiveTen, positiveOne));
EXPECT_EQ(0, dm_double_isunordered(positiveTen, negativeOne));
EXPECT_EQ(0, dm_double_isunordered(positiveTen, positiveTwo));
EXPECT_EQ(0, dm_double_isunordered(positiveTen, negativeTwo));
EXPECT_EQ(0, dm_double_isunordered(positiveTen, positiveTen));
EXPECT_EQ(0, dm_double_isunordered(positiveTen, negativeTen));
EXPECT_EQ(0, dm_double_isunordered(positiveTen, positiveInf));
EXPECT_EQ(0, dm_double_isunordered(positiveTen, negativeInf));
EXPECT_EQ(1, dm_double_isunordered(positiveTen, nan));
EXPECT_EQ(0, dm_double_isunordered(negativeTen, positiveZero));
EXPECT_EQ(0, dm_double_isunordered(negativeTen, negativeZero));
EXPECT_EQ(0, dm_double_isunordered(negativeTen, positiveOne));
EXPECT_EQ(0, dm_double_isunordered(negativeTen, negativeOne));
EXPECT_EQ(0, dm_double_isunordered(negativeTen, positiveTwo));
EXPECT_EQ(0, dm_double_isunordered(negativeTen, negativeTwo));
EXPECT_EQ(0, dm_double_isunordered(negativeTen, positiveTen));
EXPECT_EQ(0, dm_double_isunordered(negativeTen, negativeTen));
EXPECT_EQ(0, dm_double_isunordered(negativeTen, positiveInf));
EXPECT_EQ(0, dm_double_isunordered(negativeTen, negativeInf));
EXPECT_EQ(1, dm_double_isunordered(negativeTen, nan));
EXPECT_EQ(0, dm_double_isunordered(positiveInf, positiveZero));
EXPECT_EQ(0, dm_double_isunordered(positiveInf, negativeZero));
EXPECT_EQ(0, dm_double_isunordered(positiveInf, positiveOne));
EXPECT_EQ(0, dm_double_isunordered(positiveInf, negativeOne));
EXPECT_EQ(0, dm_double_isunordered(positiveInf, positiveTwo));
EXPECT_EQ(0, dm_double_isunordered(positiveInf, negativeTwo));
EXPECT_EQ(0, dm_double_isunordered(positiveInf, positiveTen));
EXPECT_EQ(0, dm_double_isunordered(positiveInf, negativeTen));
EXPECT_EQ(0, dm_double_isunordered(positiveInf, positiveInf));
EXPECT_EQ(0, dm_double_isunordered(positiveInf, negativeInf));
EXPECT_EQ(1, dm_double_isunordered(positiveInf, nan));
EXPECT_EQ(0, dm_double_isunordered(negativeInf, positiveZero));
EXPECT_EQ(0, dm_double_isunordered(negativeInf, negativeZero));
EXPECT_EQ(0, dm_double_isunordered(negativeInf, positiveOne));
EXPECT_EQ(0, dm_double_isunordered(negativeInf, negativeOne));
EXPECT_EQ(0, dm_double_isunordered(negativeInf, positiveTwo));
EXPECT_EQ(0, dm_double_isunordered(negativeInf, negativeTwo));
EXPECT_EQ(0, dm_double_isunordered(negativeInf, positiveTen));
EXPECT_EQ(0, dm_double_isunordered(negativeInf, negativeTen));
EXPECT_EQ(0, dm_double_isunordered(negativeInf, positiveInf));
EXPECT_EQ(0, dm_double_isunordered(negativeInf, negativeInf));
EXPECT_EQ(1, dm_double_isunordered(negativeInf, nan));
EXPECT_EQ(1, dm_double_isunordered(nan, positiveZero));
EXPECT_EQ(1, dm_double_isunordered(nan, negativeZero));
EXPECT_EQ(1, dm_double_isunordered(nan, positiveOne));
EXPECT_EQ(1, dm_double_isunordered(nan, negativeOne));
EXPECT_EQ(1, dm_double_isunordered(nan, positiveTwo));
EXPECT_EQ(1, dm_double_isunordered(nan, negativeTwo));
EXPECT_EQ(1, dm_double_isunordered(nan, positiveTen));
EXPECT_EQ(1, dm_double_isunordered(nan, negativeTen));
EXPECT_EQ(1, dm_double_isunordered(nan, positiveInf));
EXPECT_EQ(1, dm_double_isunordered(nan, negativeInf));
EXPECT_EQ(1, dm_double_isunordered(nan, nan));
EXPECT_EQ(0, dm_double_isless(positiveZero, positiveZero));
EXPECT_EQ(0, dm_double_isless(positiveZero, negativeZero));
EXPECT_EQ(1, dm_double_isless(positiveZero, positiveOne));
EXPECT_EQ(0, dm_double_isless(positiveZero, negativeOne));
EXPECT_EQ(1, dm_double_isless(positiveZero, positiveTwo));
EXPECT_EQ(0, dm_double_isless(positiveZero, negativeTwo));
EXPECT_EQ(1, dm_double_isless(positiveZero, positiveTen));
EXPECT_EQ(0, dm_double_isless(positiveZero, negativeTen));
EXPECT_EQ(1, dm_double_isless(positiveZero, positiveInf));
EXPECT_EQ(0, dm_double_isless(positiveZero, negativeInf));
EXPECT_EQ(0, dm_double_isless(positiveZero, nan));
EXPECT_EQ(0, dm_double_isless(negativeZero, positiveZero));
EXPECT_EQ(0, dm_double_isless(negativeZero, negativeZero));
EXPECT_EQ(1, dm_double_isless(negativeZero, positiveOne));
EXPECT_EQ(0, dm_double_isless(negativeZero, negativeOne));
EXPECT_EQ(1, dm_double_isless(negativeZero, positiveTwo));
EXPECT_EQ(0, dm_double_isless(negativeZero, negativeTwo));
EXPECT_EQ(1, dm_double_isless(negativeZero, positiveTen));
EXPECT_EQ(0, dm_double_isless(negativeZero, negativeTen));
EXPECT_EQ(1, dm_double_isless(negativeZero, positiveInf));
EXPECT_EQ(0, dm_double_isless(negativeZero, negativeInf));
EXPECT_EQ(0, dm_double_isless(negativeZero, nan));
EXPECT_EQ(0, dm_double_isless(positiveOne, positiveZero));
EXPECT_EQ(0, dm_double_isless(positiveOne, negativeZero));
EXPECT_EQ(0, dm_double_isless(positiveOne, positiveOne));
EXPECT_EQ(0, dm_double_isless(positiveOne, negativeOne));
EXPECT_EQ(1, dm_double_isless(positiveOne, positiveTwo));
EXPECT_EQ(0, dm_double_isless(positiveOne, negativeTwo));
EXPECT_EQ(1, dm_double_isless(positiveOne, positiveTen));
EXPECT_EQ(0, dm_double_isless(positiveOne, negativeTen));
EXPECT_EQ(1, dm_double_isless(positiveOne, positiveInf));
EXPECT_EQ(0, dm_double_isless(positiveOne, negativeInf));
EXPECT_EQ(0, dm_double_isless(positiveOne, nan));
EXPECT_EQ(1, dm_double_isless(negativeOne, positiveZero));
EXPECT_EQ(1, dm_double_isless(negativeOne, negativeZero));
EXPECT_EQ(1, dm_double_isless(negativeOne, positiveOne));
EXPECT_EQ(0, dm_double_isless(negativeOne, negativeOne));
EXPECT_EQ(1, dm_double_isless(negativeOne, positiveTwo));
EXPECT_EQ(0, dm_double_isless(negativeOne, negativeTwo));
EXPECT_EQ(1, dm_double_isless(negativeOne, positiveTen));
EXPECT_EQ(0, dm_double_isless(negativeOne, negativeTen));
EXPECT_EQ(1, dm_double_isless(negativeOne, positiveInf));
EXPECT_EQ(0, dm_double_isless(negativeOne, negativeInf));
EXPECT_EQ(0, dm_double_isless(negativeOne, nan));
EXPECT_EQ(0, dm_double_isless(positiveTwo, positiveZero));
EXPECT_EQ(0, dm_double_isless(positiveTwo, negativeZero));
EXPECT_EQ(0, dm_double_isless(positiveTwo, positiveOne));
EXPECT_EQ(0, dm_double_isless(positiveTwo, negativeOne));
EXPECT_EQ(0, dm_double_isless(positiveTwo, positiveTwo));
EXPECT_EQ(0, dm_double_isless(positiveTwo, negativeTwo));
EXPECT_EQ(1, dm_double_isless(positiveTwo, positiveTen));
EXPECT_EQ(0, dm_double_isless(positiveTwo, negativeTen));
EXPECT_EQ(1, dm_double_isless(positiveTwo, positiveInf));
EXPECT_EQ(0, dm_double_isless(positiveTwo, negativeInf));
EXPECT_EQ(0, dm_double_isless(positiveTwo, nan));
EXPECT_EQ(1, dm_double_isless(negativeTwo, positiveZero));
EXPECT_EQ(1, dm_double_isless(negativeTwo, negativeZero));
EXPECT_EQ(1, dm_double_isless(negativeTwo, positiveOne));
EXPECT_EQ(1, dm_double_isless(negativeTwo, negativeOne));
EXPECT_EQ(1, dm_double_isless(negativeTwo, positiveTwo));
EXPECT_EQ(0, dm_double_isless(negativeTwo, negativeTwo));
EXPECT_EQ(1, dm_double_isless(negativeTwo, positiveTen));
EXPECT_EQ(0, dm_double_isless(negativeTwo, negativeTen));
EXPECT_EQ(1, dm_double_isless(negativeTwo, positiveInf));
EXPECT_EQ(0, dm_double_isless(negativeTwo, negativeInf));
EXPECT_EQ(0, dm_double_isless(negativeTwo, nan));
EXPECT_EQ(0, dm_double_isless(positiveTen, positiveZero));
EXPECT_EQ(0, dm_double_isless(positiveTen, negativeZero));
EXPECT_EQ(0, dm_double_isless(positiveTen, positiveOne));
EXPECT_EQ(0, dm_double_isless(positiveTen, negativeOne));
EXPECT_EQ(0, dm_double_isless(positiveTen, positiveTwo));
EXPECT_EQ(0, dm_double_isless(positiveTen, negativeTwo));
EXPECT_EQ(0, dm_double_isless(positiveTen, positiveTen));
EXPECT_EQ(0, dm_double_isless(positiveTen, negativeTen));
EXPECT_EQ(1, dm_double_isless(positiveTen, positiveInf));
EXPECT_EQ(0, dm_double_isless(positiveTen, negativeInf));
EXPECT_EQ(0, dm_double_isless(positiveTen, nan));
EXPECT_EQ(1, dm_double_isless(negativeTen, positiveZero));
EXPECT_EQ(1, dm_double_isless(negativeTen, negativeZero));
EXPECT_EQ(1, dm_double_isless(negativeTen, positiveOne));
EXPECT_EQ(1, dm_double_isless(negativeTen, negativeOne));
EXPECT_EQ(1, dm_double_isless(negativeTen, positiveTwo));
EXPECT_EQ(1, dm_double_isless(negativeTen, negativeTwo));
EXPECT_EQ(1, dm_double_isless(negativeTen, positiveTen));
EXPECT_EQ(0, dm_double_isless(negativeTen, negativeTen));
EXPECT_EQ(1, dm_double_isless(negativeTen, positiveInf));
EXPECT_EQ(0, dm_double_isless(negativeTen, negativeInf));
EXPECT_EQ(0, dm_double_isless(negativeTen, nan));
EXPECT_EQ(0, dm_double_isless(positiveInf, positiveZero));
EXPECT_EQ(0, dm_double_isless(positiveInf, negativeZero));
EXPECT_EQ(0, dm_double_isless(positiveInf, positiveOne));
EXPECT_EQ(0, dm_double_isless(positiveInf, negativeOne));
EXPECT_EQ(0, dm_double_isless(positiveInf, positiveTwo));
EXPECT_EQ(0, dm_double_isless(positiveInf, negativeTwo));
EXPECT_EQ(0, dm_double_isless(positiveInf, positiveTen));
EXPECT_EQ(0, dm_double_isless(positiveInf, negativeTen));
EXPECT_EQ(0, dm_double_isless(positiveInf, positiveInf));
EXPECT_EQ(0, dm_double_isless(positiveInf, negativeInf));
EXPECT_EQ(0, dm_double_isless(positiveInf, nan));
EXPECT_EQ(1, dm_double_isless(negativeInf, positiveZero));
EXPECT_EQ(1, dm_double_isless(negativeInf, negativeZero));
EXPECT_EQ(1, dm_double_isless(negativeInf, positiveOne));
EXPECT_EQ(1, dm_double_isless(negativeInf, negativeOne));
EXPECT_EQ(1, dm_double_isless(negativeInf, positiveTwo));
EXPECT_EQ(1, dm_double_isless(negativeInf, negativeTwo));
EXPECT_EQ(1, dm_double_isless(negativeInf, positiveTen));
EXPECT_EQ(1, dm_double_isless(negativeInf, negativeTen));
EXPECT_EQ(1, dm_double_isless(negativeInf, positiveInf));
EXPECT_EQ(0, dm_double_isless(negativeInf, negativeInf));
EXPECT_EQ(0, dm_double_isless(negativeInf, nan));
EXPECT_EQ(0, dm_double_isless(nan, positiveZero));
EXPECT_EQ(0, dm_double_isless(nan, negativeZero));
EXPECT_EQ(0, dm_double_isless(nan, positiveOne));
EXPECT_EQ(0, dm_double_isless(nan, negativeOne));
EXPECT_EQ(0, dm_double_isless(nan, positiveTwo));
EXPECT_EQ(0, dm_double_isless(nan, negativeTwo));
EXPECT_EQ(0, dm_double_isless(nan, positiveTen));
EXPECT_EQ(0, dm_double_isless(nan, negativeTen));
EXPECT_EQ(0, dm_double_isless(nan, positiveInf));
EXPECT_EQ(0, dm_double_isless(nan, negativeInf));
EXPECT_EQ(0, dm_double_isless(nan, nan));
EXPECT_EQ(0, dm_double_isgreater(positiveZero, positiveZero));
EXPECT_EQ(0, dm_double_isgreater(positiveZero, negativeZero));
EXPECT_EQ(0, dm_double_isgreater(positiveZero, positiveOne));
EXPECT_EQ(1, dm_double_isgreater(positiveZero, negativeOne));
EXPECT_EQ(0, dm_double_isgreater(positiveZero, positiveTwo));
EXPECT_EQ(1, dm_double_isgreater(positiveZero, negativeTwo));
EXPECT_EQ(0, dm_double_isgreater(positiveZero, positiveTen));
EXPECT_EQ(1, dm_double_isgreater(positiveZero, negativeTen));
EXPECT_EQ(0, dm_double_isgreater(positiveZero, positiveInf));
EXPECT_EQ(1, dm_double_isgreater(positiveZero, negativeInf));
EXPECT_EQ(0, dm_double_isgreater(positiveZero, nan));
EXPECT_EQ(0, dm_double_isgreater(negativeZero, positiveZero));
EXPECT_EQ(0, dm_double_isgreater(negativeZero, negativeZero));
EXPECT_EQ(0, dm_double_isgreater(negativeZero, positiveOne));
EXPECT_EQ(1, dm_double_isgreater(negativeZero, negativeOne));
EXPECT_EQ(0, dm_double_isgreater(negativeZero, positiveTwo));
EXPECT_EQ(1, dm_double_isgreater(negativeZero, negativeTwo));
EXPECT_EQ(0, dm_double_isgreater(negativeZero, positiveTen));
EXPECT_EQ(1, dm_double_isgreater(negativeZero, negativeTen));
EXPECT_EQ(0, dm_double_isgreater(negativeZero, positiveInf));
EXPECT_EQ(1, dm_double_isgreater(negativeZero, negativeInf));
EXPECT_EQ(0, dm_double_isgreater(negativeZero, nan));
EXPECT_EQ(1, dm_double_isgreater(positiveOne, positiveZero));
EXPECT_EQ(1, dm_double_isgreater(positiveOne, negativeZero));
EXPECT_EQ(0, dm_double_isgreater(positiveOne, positiveOne));
EXPECT_EQ(1, dm_double_isgreater(positiveOne, negativeOne));
EXPECT_EQ(0, dm_double_isgreater(positiveOne, positiveTwo));
EXPECT_EQ(1, dm_double_isgreater(positiveOne, negativeTwo));
EXPECT_EQ(0, dm_double_isgreater(positiveOne, positiveTen));
EXPECT_EQ(1, dm_double_isgreater(positiveOne, negativeTen));
EXPECT_EQ(0, dm_double_isgreater(positiveOne, positiveInf));
EXPECT_EQ(1, dm_double_isgreater(positiveOne, negativeInf));
EXPECT_EQ(0, dm_double_isgreater(positiveOne, nan));
EXPECT_EQ(0, dm_double_isgreater(negativeOne, positiveZero));
EXPECT_EQ(0, dm_double_isgreater(negativeOne, negativeZero));
EXPECT_EQ(0, dm_double_isgreater(negativeOne, positiveOne));
EXPECT_EQ(0, dm_double_isgreater(negativeOne, negativeOne));
EXPECT_EQ(0, dm_double_isgreater(negativeOne, positiveTwo));
EXPECT_EQ(1, dm_double_isgreater(negativeOne, negativeTwo));
EXPECT_EQ(0, dm_double_isgreater(negativeOne, positiveTen));
EXPECT_EQ(1, dm_double_isgreater(negativeOne, negativeTen));
EXPECT_EQ(0, dm_double_isgreater(negativeOne, positiveInf));
EXPECT_EQ(1, dm_double_isgreater(negativeOne, negativeInf));
EXPECT_EQ(0, dm_double_isgreater(negativeOne, nan));
EXPECT_EQ(1, dm_double_isgreater(positiveTwo, positiveZero));
EXPECT_EQ(1, dm_double_isgreater(positiveTwo, negativeZero));
EXPECT_EQ(1, dm_double_isgreater(positiveTwo, positiveOne));
EXPECT_EQ(1, dm_double_isgreater(positiveTwo, negativeOne));
EXPECT_EQ(0, dm_double_isgreater(positiveTwo, positiveTwo));
EXPECT_EQ(1, dm_double_isgreater(positiveTwo, negativeTwo));
EXPECT_EQ(0, dm_double_isgreater(positiveTwo, positiveTen));
EXPECT_EQ(1, dm_double_isgreater(positiveTwo, negativeTen));
EXPECT_EQ(0, dm_double_isgreater(positiveTwo, positiveInf));
EXPECT_EQ(1, dm_double_isgreater(positiveTwo, negativeInf));
EXPECT_EQ(0, dm_double_isgreater(positiveTwo, nan));
EXPECT_EQ(0, dm_double_isgreater(negativeTwo, positiveZero));
EXPECT_EQ(0, dm_double_isgreater(negativeTwo, negativeZero));
EXPECT_EQ(0, dm_double_isgreater(negativeTwo, positiveOne));
EXPECT_EQ(0, dm_double_isgreater(negativeTwo, negativeOne));
EXPECT_EQ(0, dm_double_isgreater(negativeTwo, positiveTwo));
EXPECT_EQ(0, dm_double_isgreater(negativeTwo, negativeTwo));
EXPECT_EQ(0, dm_double_isgreater(negativeTwo, positiveTen));
EXPECT_EQ(1, dm_double_isgreater(negativeTwo, negativeTen));
EXPECT_EQ(0, dm_double_isgreater(negativeTwo, positiveInf));
EXPECT_EQ(1, dm_double_isgreater(negativeTwo, negativeInf));
EXPECT_EQ(0, dm_double_isgreater(negativeTwo, nan));
EXPECT_EQ(1, dm_double_isgreater(positiveTen, positiveZero));
EXPECT_EQ(1, dm_double_isgreater(positiveTen, negativeZero));
EXPECT_EQ(1, dm_double_isgreater(positiveTen, positiveOne));
EXPECT_EQ(1, dm_double_isgreater(positiveTen, negativeOne));
EXPECT_EQ(1, dm_double_isgreater(positiveTen, positiveTwo));
EXPECT_EQ(1, dm_double_isgreater(positiveTen, negativeTwo));
EXPECT_EQ(0, dm_double_isgreater(positiveTen, positiveTen));
EXPECT_EQ(1, dm_double_isgreater(positiveTen, negativeTen));
EXPECT_EQ(0, dm_double_isgreater(positiveTen, positiveInf));
EXPECT_EQ(1, dm_double_isgreater(positiveTen, negativeInf));
EXPECT_EQ(0, dm_double_isgreater(positiveTen, nan));
EXPECT_EQ(0, dm_double_isgreater(negativeTen, positiveZero));
EXPECT_EQ(0, dm_double_isgreater(negativeTen, negativeZero));
EXPECT_EQ(0, dm_double_isgreater(negativeTen, positiveOne));
EXPECT_EQ(0, dm_double_isgreater(negativeTen, negativeOne));
EXPECT_EQ(0, dm_double_isgreater(negativeTen, positiveTwo));
EXPECT_EQ(0, dm_double_isgreater(negativeTen, negativeTwo));
EXPECT_EQ(0, dm_double_isgreater(negativeTen, positiveTen));
EXPECT_EQ(0, dm_double_isgreater(negativeTen, negativeTen));
EXPECT_EQ(0, dm_double_isgreater(negativeTen, positiveInf));
EXPECT_EQ(1, dm_double_isgreater(negativeTen, negativeInf));
EXPECT_EQ(0, dm_double_isgreater(negativeTen, nan));
EXPECT_EQ(1, dm_double_isgreater(positiveInf, positiveZero));
EXPECT_EQ(1, dm_double_isgreater(positiveInf, negativeZero));
EXPECT_EQ(1, dm_double_isgreater(positiveInf, positiveOne));
EXPECT_EQ(1, dm_double_isgreater(positiveInf, negativeOne));
EXPECT_EQ(1, dm_double_isgreater(positiveInf, positiveTwo));
EXPECT_EQ(1, dm_double_isgreater(positiveInf, negativeTwo));
EXPECT_EQ(1, dm_double_isgreater(positiveInf, positiveTen));
EXPECT_EQ(1, dm_double_isgreater(positiveInf, negativeTen));
EXPECT_EQ(0, dm_double_isgreater(positiveInf, positiveInf));
EXPECT_EQ(1, dm_double_isgreater(positiveInf, negativeInf));
EXPECT_EQ(0, dm_double_isgreater(positiveInf, nan));
EXPECT_EQ(0, dm_double_isgreater(negativeInf, positiveZero));
EXPECT_EQ(0, dm_double_isgreater(negativeInf, negativeZero));
EXPECT_EQ(0, dm_double_isgreater(negativeInf, positiveOne));
EXPECT_EQ(0, dm_double_isgreater(negativeInf, negativeOne));
EXPECT_EQ(0, dm_double_isgreater(negativeInf, positiveTwo));
EXPECT_EQ(0, dm_double_isgreater(negativeInf, negativeTwo));
EXPECT_EQ(0, dm_double_isgreater(negativeInf, positiveTen));
EXPECT_EQ(0, dm_double_isgreater(negativeInf, negativeTen));
EXPECT_EQ(0, dm_double_isgreater(negativeInf, positiveInf));
EXPECT_EQ(0, dm_double_isgreater(negativeInf, negativeInf));
EXPECT_EQ(0, dm_double_isgreater(negativeInf, nan));
EXPECT_EQ(0, dm_double_isgreater(nan, positiveZero));
EXPECT_EQ(0, dm_double_isgreater(nan, negativeZero));
EXPECT_EQ(0, dm_double_isgreater(nan, positiveOne));
EXPECT_EQ(0, dm_double_isgreater(nan, negativeOne));
EXPECT_EQ(0, dm_double_isgreater(nan, positiveTwo));
EXPECT_EQ(0, dm_double_isgreater(nan, negativeTwo));
EXPECT_EQ(0, dm_double_isgreater(nan, positiveTen));
EXPECT_EQ(0, dm_double_isgreater(nan, negativeTen));
EXPECT_EQ(0, dm_double_isgreater(nan, positiveInf));
EXPECT_EQ(0, dm_double_isgreater(nan, negativeInf));
EXPECT_EQ(0, dm_double_isgreater(nan, nan));
EXPECT_EQ(1, dm_double_islessequal(positiveZero, positiveZero));
EXPECT_EQ(1, dm_double_islessequal(positiveZero, negativeZero));
EXPECT_EQ(1, dm_double_islessequal(positiveZero, positiveOne));
EXPECT_EQ(0, dm_double_islessequal(positiveZero, negativeOne));
EXPECT_EQ(1, dm_double_islessequal(positiveZero, positiveTwo));
EXPECT_EQ(0, dm_double_islessequal(positiveZero, negativeTwo));
EXPECT_EQ(1, dm_double_islessequal(positiveZero, positiveTen));
EXPECT_EQ(0, dm_double_islessequal(positiveZero, negativeTen));
EXPECT_EQ(1, dm_double_islessequal(positiveZero, positiveInf));
EXPECT_EQ(0, dm_double_islessequal(positiveZero, negativeInf));
EXPECT_EQ(0, dm_double_islessequal(positiveZero, nan));
EXPECT_EQ(1, dm_double_islessequal(negativeZero, positiveZero));
EXPECT_EQ(1, dm_double_islessequal(negativeZero, negativeZero));
EXPECT_EQ(1, dm_double_islessequal(negativeZero, positiveOne));
EXPECT_EQ(0, dm_double_islessequal(negativeZero, negativeOne));
EXPECT_EQ(1, dm_double_islessequal(negativeZero, positiveTwo));
EXPECT_EQ(0, dm_double_islessequal(negativeZero, negativeTwo));
EXPECT_EQ(1, dm_double_islessequal(negativeZero, positiveTen));
EXPECT_EQ(0, dm_double_islessequal(negativeZero, negativeTen));
EXPECT_EQ(1, dm_double_islessequal(negativeZero, positiveInf));
EXPECT_EQ(0, dm_double_islessequal(negativeZero, negativeInf));
EXPECT_EQ(0, dm_double_islessequal(negativeZero, nan));
EXPECT_EQ(0, dm_double_islessequal(positiveOne, positiveZero));
EXPECT_EQ(0, dm_double_islessequal(positiveOne, negativeZero));
EXPECT_EQ(1, dm_double_islessequal(positiveOne, positiveOne));
EXPECT_EQ(0, dm_double_islessequal(positiveOne, negativeOne));
EXPECT_EQ(1, dm_double_islessequal(positiveOne, positiveTwo));
EXPECT_EQ(0, dm_double_islessequal(positiveOne, negativeTwo));
EXPECT_EQ(1, dm_double_islessequal(positiveOne, positiveTen));
EXPECT_EQ(0, dm_double_islessequal(positiveOne, negativeTen));
EXPECT_EQ(1, dm_double_islessequal(positiveOne, positiveInf));
EXPECT_EQ(0, dm_double_islessequal(positiveOne, negativeInf));
EXPECT_EQ(0, dm_double_islessequal(positiveOne, nan));
EXPECT_EQ(1, dm_double_islessequal(negativeOne, positiveZero));
EXPECT_EQ(1, dm_double_islessequal(negativeOne, negativeZero));
EXPECT_EQ(1, dm_double_islessequal(negativeOne, positiveOne));
EXPECT_EQ(1, dm_double_islessequal(negativeOne, negativeOne));
EXPECT_EQ(1, dm_double_islessequal(negativeOne, positiveTwo));
EXPECT_EQ(0, dm_double_islessequal(negativeOne, negativeTwo));
EXPECT_EQ(1, dm_double_islessequal(negativeOne, positiveTen));
EXPECT_EQ(0, dm_double_islessequal(negativeOne, negativeTen));
EXPECT_EQ(1, dm_double_islessequal(negativeOne, positiveInf));
EXPECT_EQ(0, dm_double_islessequal(negativeOne, negativeInf));
EXPECT_EQ(0, dm_double_islessequal(negativeOne, nan));
EXPECT_EQ(0, dm_double_islessequal(positiveTwo, positiveZero));
EXPECT_EQ(0, dm_double_islessequal(positiveTwo, negativeZero));
EXPECT_EQ(0, dm_double_islessequal(positiveTwo, positiveOne));
EXPECT_EQ(0, dm_double_islessequal(positiveTwo, negativeOne));
EXPECT_EQ(1, dm_double_islessequal(positiveTwo, positiveTwo));
EXPECT_EQ(0, dm_double_islessequal(positiveTwo, negativeTwo));
EXPECT_EQ(1, dm_double_islessequal(positiveTwo, positiveTen));
EXPECT_EQ(0, dm_double_islessequal(positiveTwo, negativeTen));
EXPECT_EQ(1, dm_double_islessequal(positiveTwo, positiveInf));
EXPECT_EQ(0, dm_double_islessequal(positiveTwo, negativeInf));
EXPECT_EQ(0, dm_double_islessequal(positiveTwo, nan));
EXPECT_EQ(1, dm_double_islessequal(negativeTwo, positiveZero));
EXPECT_EQ(1, dm_double_islessequal(negativeTwo, negativeZero));
EXPECT_EQ(1, dm_double_islessequal(negativeTwo, positiveOne));
EXPECT_EQ(1, dm_double_islessequal(negativeTwo, negativeOne));
EXPECT_EQ(1, dm_double_islessequal(negativeTwo, positiveTwo));
EXPECT_EQ(1, dm_double_islessequal(negativeTwo, negativeTwo));
EXPECT_EQ(1, dm_double_islessequal(negativeTwo, positiveTen));
EXPECT_EQ(0, dm_double_islessequal(negativeTwo, negativeTen));
EXPECT_EQ(1, dm_double_islessequal(negativeTwo, positiveInf));
EXPECT_EQ(0, dm_double_islessequal(negativeTwo, negativeInf));
EXPECT_EQ(0, dm_double_islessequal(negativeTwo, nan));
EXPECT_EQ(0, dm_double_islessequal(positiveTen, positiveZero));
EXPECT_EQ(0, dm_double_islessequal(positiveTen, negativeZero));
EXPECT_EQ(0, dm_double_islessequal(positiveTen, positiveOne));
EXPECT_EQ(0, dm_double_islessequal(positiveTen, negativeOne));
EXPECT_EQ(0, dm_double_islessequal(positiveTen, positiveTwo));
EXPECT_EQ(0, dm_double_islessequal(positiveTen, negativeTwo));
EXPECT_EQ(1, dm_double_islessequal(positiveTen, positiveTen));
EXPECT_EQ(0, dm_double_islessequal(positiveTen, negativeTen));
EXPECT_EQ(1, dm_double_islessequal(positiveTen, positiveInf));
EXPECT_EQ(0, dm_double_islessequal(positiveTen, negativeInf));
EXPECT_EQ(0, dm_double_islessequal(positiveTen, nan));
EXPECT_EQ(1, dm_double_islessequal(negativeTen, positiveZero));
EXPECT_EQ(1, dm_double_islessequal(negativeTen, negativeZero));
EXPECT_EQ(1, dm_double_islessequal(negativeTen, positiveOne));
EXPECT_EQ(1, dm_double_islessequal(negativeTen, negativeOne));
EXPECT_EQ(1, dm_double_islessequal(negativeTen, positiveTwo));
EXPECT_EQ(1, dm_double_islessequal(negativeTen, negativeTwo));
EXPECT_EQ(1, dm_double_islessequal(negativeTen, positiveTen));
EXPECT_EQ(1, dm_double_islessequal(negativeTen, negativeTen));
EXPECT_EQ(1, dm_double_islessequal(negativeTen, positiveInf));
EXPECT_EQ(0, dm_double_islessequal(negativeTen, negativeInf));
EXPECT_EQ(0, dm_double_islessequal(negativeTen, nan));
EXPECT_EQ(0, dm_double_islessequal(positiveInf, positiveZero));
EXPECT_EQ(0, dm_double_islessequal(positiveInf, negativeZero));
EXPECT_EQ(0, dm_double_islessequal(positiveInf, positiveOne));
EXPECT_EQ(0, dm_double_islessequal(positiveInf, negativeOne));
EXPECT_EQ(0, dm_double_islessequal(positiveInf, positiveTwo));
EXPECT_EQ(0, dm_double_islessequal(positiveInf, negativeTwo));
EXPECT_EQ(0, dm_double_islessequal(positiveInf, positiveTen));
EXPECT_EQ(0, dm_double_islessequal(positiveInf, negativeTen));
EXPECT_EQ(1, dm_double_islessequal(positiveInf, positiveInf));
EXPECT_EQ(0, dm_double_islessequal(positiveInf, negativeInf));
EXPECT_EQ(0, dm_double_islessequal(positiveInf, nan));
EXPECT_EQ(1, dm_double_islessequal(negativeInf, positiveZero));
EXPECT_EQ(1, dm_double_islessequal(negativeInf, negativeZero));
EXPECT_EQ(1, dm_double_islessequal(negativeInf, positiveOne));
EXPECT_EQ(1, dm_double_islessequal(negativeInf, negativeOne));
EXPECT_EQ(1, dm_double_islessequal(negativeInf, positiveTwo));
EXPECT_EQ(1, dm_double_islessequal(negativeInf, negativeTwo));
EXPECT_EQ(1, dm_double_islessequal(negativeInf, positiveTen));
EXPECT_EQ(1, dm_double_islessequal(negativeInf, negativeTen));
EXPECT_EQ(1, dm_double_islessequal(negativeInf, positiveInf));
EXPECT_EQ(1, dm_double_islessequal(negativeInf, negativeInf));
EXPECT_EQ(0, dm_double_islessequal(negativeInf, nan));
EXPECT_EQ(0, dm_double_islessequal(nan, positiveZero));
EXPECT_EQ(0, dm_double_islessequal(nan, negativeZero));
EXPECT_EQ(0, dm_double_islessequal(nan, positiveOne));
EXPECT_EQ(0, dm_double_islessequal(nan, negativeOne));
EXPECT_EQ(0, dm_double_islessequal(nan, positiveTwo));
EXPECT_EQ(0, dm_double_islessequal(nan, negativeTwo));
EXPECT_EQ(0, dm_double_islessequal(nan, positiveTen));