@@ -439,7 +439,7 @@ test "division" {
439
439
if (builtin .zig_backend == .stage2_aarch64 ) return error .SkipZigTest ; // TODO
440
440
if (builtin .zig_backend == .stage2_arm ) return error .SkipZigTest ; // TODO
441
441
if (builtin .zig_backend == .stage2_sparc64 ) return error .SkipZigTest ; // TODO
442
- if (builtin .zig_backend == .stage2_wasm ) return error .SkipZigTest ;
442
+ if (builtin .zig_backend == .stage2_x86_64 ) return error .SkipZigTest ; // TODO
443
443
if (builtin .zig_backend == .stage2_x86_64 and builtin .target .ofmt != .elf and builtin .target .ofmt != .macho ) return error .SkipZigTest ;
444
444
if (builtin .zig_backend == .stage2_riscv64 ) return error .SkipZigTest ;
445
445
@@ -448,23 +448,25 @@ test "division" {
448
448
return error .SkipZigTest ;
449
449
}
450
450
451
- try testDivision ();
452
- try comptime testDivision ();
451
+ try testIntDivision ();
452
+ try comptime testIntDivision ();
453
+
454
+ try testFloatDivision ();
455
+ try comptime testFloatDivision ();
453
456
}
454
457
455
- fn testDivision () ! void {
458
+ fn testIntDivision () ! void {
456
459
try expect (div (u32 , 13 , 3 ) == 4 );
457
- try expect (div (f32 , 1.0 , 2.0 ) == 0.5 );
460
+ try expect (div (u64 , 13 , 3 ) == 4 );
461
+ try expect (div (u8 , 13 , 3 ) == 4 );
458
462
459
463
try expect (divExact (u32 , 55 , 11 ) == 5 );
460
464
try expect (divExact (i32 , -55 , 11 ) == -5 );
461
- try expect (divExact (f32 , 55.0 , 11.0 ) == 5.0 );
462
- try expect (divExact (f32 , -55.0 , 11.0 ) == -5.0 );
465
+ try expect (divExact (i64 , -55 , 11 ) == -5 );
466
+ try expect (divExact (i16 , -55 , 11 ) == -5 );
463
467
464
468
try expect (divFloor (i32 , 5 , 3 ) == 1 );
465
469
try expect (divFloor (i32 , -5 , 3 ) == -2 );
466
- try expect (divFloor (f32 , 5.0 , 3.0 ) == 1.0 );
467
- try expect (divFloor (f32 , -5.0 , 3.0 ) == -2.0 );
468
470
try expect (divFloor (i32 , -0x80000000 , -2 ) == 0x40000000 );
469
471
try expect (divFloor (i32 , 0 , -0x80000000 ) == 0 );
470
472
try expect (divFloor (i32 , -0x40000001 , 0x40000000 ) == -2 );
@@ -473,18 +475,15 @@ fn testDivision() !void {
473
475
try expect (divFloor (i32 , -14 , 12 ) == -2 );
474
476
try expect (divFloor (i32 , -2 , 12 ) == -1 );
475
477
478
+ try expect (divFloor (i8 , 5 , 3 ) == 1 );
479
+ try expect (divFloor (i16 , -5 , 3 ) == -2 );
480
+ try expect (divFloor (i64 , -0x80000000 , -2 ) == 0x40000000 );
481
+ try expect (divFloor (i64 , -0x40000001 , 0x40000000 ) == -2 );
482
+
476
483
try expect (divTrunc (i32 , 5 , 3 ) == 1 );
477
484
try expect (divTrunc (i32 , -5 , 3 ) == -1 );
478
485
try expect (divTrunc (i32 , 9 , -10 ) == 0 );
479
486
try expect (divTrunc (i32 , -9 , 10 ) == 0 );
480
- try expect (divTrunc (f32 , 5.0 , 3.0 ) == 1.0 );
481
- try expect (divTrunc (f32 , -5.0 , 3.0 ) == -1.0 );
482
- try expect (divTrunc (f32 , 9.0 , -10.0 ) == 0.0 );
483
- try expect (divTrunc (f32 , -9.0 , 10.0 ) == 0.0 );
484
- try expect (divTrunc (f64 , 5.0 , 3.0 ) == 1.0 );
485
- try expect (divTrunc (f64 , -5.0 , 3.0 ) == -1.0 );
486
- try expect (divTrunc (f64 , 9.0 , -10.0 ) == 0.0 );
487
- try expect (divTrunc (f64 , -9.0 , 10.0 ) == 0.0 );
488
487
try expect (divTrunc (i32 , 10 , 12 ) == 0 );
489
488
try expect (divTrunc (i32 , -14 , 12 ) == -1 );
490
489
try expect (divTrunc (i32 , -2 , 12 ) == 0 );
@@ -496,6 +495,19 @@ fn testDivision() !void {
496
495
try expect (mod (i32 , -14 , -12 ) == -2 );
497
496
try expect (mod (i32 , -2 , -12 ) == -2 );
498
497
498
+ try expect (mod (i64 , -118 , 12 ) == 2 );
499
+ try expect (mod (u32 , 10 , 12 ) == 10 );
500
+ try expect (mod (i64 , -14 , 12 ) == 10 );
501
+ try expect (mod (i16 , -2 , 12 ) == 10 );
502
+ try expect (mod (i16 , -118 , 12 ) == 2 );
503
+ try expect (mod (i8 , -2 , 12 ) == 10 ); // TODO: fails in x86_64
504
+
505
+ try expect (rem (i64 , -118 , 12 ) == -10 );
506
+ try expect (rem (i32 , 10 , 12 ) == 10 );
507
+ try expect (rem (i32 , -14 , 12 ) == -2 );
508
+ try expect (rem (i32 , -2 , 12 ) == -2 );
509
+ try expect (rem (i16 , -118 , 12 ) == -10 );
510
+
499
511
try expect (divTrunc (i20 , 20 , -5 ) == -4 );
500
512
try expect (divTrunc (i20 , -20 , -4 ) == 5 );
501
513
@@ -524,6 +536,52 @@ fn testDivision() !void {
524
536
}
525
537
}
526
538
539
+ fn testFloatDivision () ! void {
540
+ try expect (div (f32 , 1.0 , 2.0 ) == 0.5 );
541
+
542
+ try expect (divExact (f32 , 55.0 , 11.0 ) == 5.0 );
543
+ try expect (divExact (f32 , -55.0 , 11.0 ) == -5.0 );
544
+
545
+ try expect (divFloor (f32 , 5.0 , 3.0 ) == 1.0 );
546
+ try expect (divFloor (f32 , -5.0 , 3.0 ) == -2.0 );
547
+ try expect (divFloor (f32 , 56.0 , 9.0 ) == 6.0 );
548
+ try expect (divFloor (f32 , 1053.0 , -41.0 ) == -26.0 );
549
+ try expect (divFloor (f16 , -43.0 , 12.0 ) == -4.0 );
550
+ try expect (divFloor (f64 , -90.0 , -9.0 ) == 10.0 );
551
+
552
+ try expect (divTrunc (f32 , 5.0 , 3.0 ) == 1.0 );
553
+ try expect (divTrunc (f32 , -5.0 , 3.0 ) == -1.0 );
554
+ try expect (divTrunc (f32 , 9.0 , -10.0 ) == 0.0 );
555
+ try expect (divTrunc (f32 , -9.0 , 10.0 ) == 0.0 );
556
+ try expect (divTrunc (f64 , 5.0 , 3.0 ) == 1.0 );
557
+ try expect (divTrunc (f64 , -5.0 , 3.0 ) == -1.0 );
558
+ try expect (divTrunc (f64 , 9.0 , -10.0 ) == 0.0 );
559
+ try expect (divTrunc (f64 , -9.0 , 10.0 ) == 0.0 );
560
+ }
561
+
562
+ test "large integer division" {
563
+ if (builtin .zig_backend == .stage2_x86_64 ) return error .SkipZigTest ;
564
+ if (builtin .zig_backend == .stage2_aarch64 ) return error .SkipZigTest ;
565
+ if (builtin .zig_backend == .stage2_arm ) return error .SkipZigTest ;
566
+ if (builtin .zig_backend == .stage2_sparc64 ) return error .SkipZigTest ;
567
+ if (builtin .zig_backend == .stage2_wasm ) return error .SkipZigTest ;
568
+ if (builtin .zig_backend == .stage2_spirv64 ) return error .SkipZigTest ;
569
+ if (builtin .zig_backend == .stage2_riscv64 ) return error .SkipZigTest ;
570
+
571
+ {
572
+ var numerator : u256 = 99999999999999999997315645440 ;
573
+ var divisor : u256 = 10000000000000000000000000000 ;
574
+ _ = .{ & numerator , & divisor };
575
+ try expect (numerator / divisor == 9 );
576
+ }
577
+ {
578
+ var numerator : u256 = 99999999999999999999000000000000000000000 ;
579
+ var divisor : u256 = 10000000000000000000000000000000000000000 ;
580
+ _ = .{ & numerator , & divisor };
581
+ try expect (numerator / divisor == 9 );
582
+ }
583
+ }
584
+
527
585
test "division half-precision floats" {
528
586
if (builtin .zig_backend == .stage2_aarch64 ) return error .SkipZigTest ; // TODO
529
587
if (builtin .zig_backend == .stage2_arm ) return error .SkipZigTest ; // TODO
@@ -564,6 +622,9 @@ fn divTrunc(comptime T: type, a: T, b: T) T {
564
622
fn mod (comptime T : type , a : T , b : T ) T {
565
623
return @mod (a , b );
566
624
}
625
+ fn rem (comptime T : type , a : T , b : T ) T {
626
+ return @rem (a , b );
627
+ }
567
628
568
629
test "unsigned wrapping" {
569
630
if (builtin .zig_backend == .stage2_riscv64 ) return error .SkipZigTest ;
0 commit comments