authorgravatar for andrew@ziglang.orgAndrew Kelley <andrew@ziglang.org> 2020-04-28 16:25:40-04:00
committergravatar for noreply@github.comGitHub <noreply@github.com> 2020-04-28 16:25:40-04:00
log5929e5ca0ebde636dd69d52d648df8cff59e6d96
tree1ac7f32bf08840ac72bb5cf6a5eb2d694c2e192e
parent03dd1fca94526f78400c662b6b1e712c05aee849
parent0673a8d5763bf0fec007d8ed05128310a9e66719
signature Signed by PGP key 4AEE18F83AFDEB23

Merge pull request #5196 from tadeokondrak/@vector-to-@type-vector

`@Vector` -> `@Type(.Vector)`

22 files changed, 140 insertions(+), 130 deletions(-)

doc/langref.html.in+5-16
......@@ -1850,8 +1850,8 @@ test "null terminated array" {
18501850 {#header_open|Vectors#}
18511851 <p>
18521852 A vector is a group of {#link|Integers#}, {#link|Floats#}, or {#link|Pointers#} which are operated on
1853 in parallel using a single instruction ({#link|SIMD#}). Vector types are created with the builtin
1854 function {#link|@Vector#}.
1853 in parallel using a single instruction ({#link|SIMD#}). Vector types are created with the builtin function {#link|@Type#},
1854 or using the shorthand as {#syntax#}std.meta.Vector{#endsyntax#}.
18551855 </p>
18561856 <p>
18571857 TODO talk about C ABI interop
......@@ -7910,7 +7910,7 @@ test "@setRuntimeSafety" {
79107910 {#header_close#}
79117911
79127912 {#header_open|@shuffle#}
7913 <pre>{#syntax#}@shuffle(comptime E: type, a: @Vector(a_len, E), b: @Vector(b_len, E), comptime mask: @Vector(mask_len, i32)) @Vector(mask_len, E){#endsyntax#}</pre>
7913 <pre>{#syntax#}@shuffle(comptime E: type, a: std.meta.Vector(a_len, E), b: std.meta.Vector(b_len, E), comptime mask: std.meta.Vector(mask_len, i32)) std.meta.Vector(mask_len, E){#endsyntax#}</pre>
79147914 <p>
79157915 Constructs a new {#link|vector|Vectors#} by selecting elements from {#syntax#}a{#endsyntax#} and
79167916 {#syntax#}b{#endsyntax#} based on {#syntax#}mask{#endsyntax#}.
......@@ -7966,7 +7966,7 @@ test "@setRuntimeSafety" {
79667966 {#header_close#}
79677967
79687968 {#header_open|@splat#}
7969 <pre>{#syntax#}@splat(comptime len: u32, scalar: var) @Vector(len, @TypeOf(scalar)){#endsyntax#}</pre>
7969 <pre>{#syntax#}@splat(comptime len: u32, scalar: var) std.meta.Vector(len, @TypeOf(scalar)){#endsyntax#}</pre>
79707970 <p>
79717971 Produces a vector of length {#syntax#}len{#endsyntax#} where each element is the value
79727972 {#syntax#}scalar{#endsyntax#}:
......@@ -7978,7 +7978,7 @@ const assert = std.debug.assert;
79787978test "vector @splat" {
79797979 const scalar: u32 = 5;
79807980 const result = @splat(4, scalar);
7981 comptime assert(@TypeOf(result) == @Vector(4, u32));
7981 comptime assert(@TypeOf(result) == std.meta.Vector(4, u32));
79827982 assert(std.mem.eql(u32, &@as([4]u32, result), &[_]u32{ 5, 5, 5, 5 }));
79837983}
79847984 {#code_end#}
......@@ -8336,17 +8336,6 @@ fn foo(comptime T: type, ptr: *T) T {
83368336 {#syntax#}@unionInit{#endsyntax#} forwards its {#link|result location|Result Location Semantics#} to {#syntax#}init_expr{#endsyntax#}.
83378337 </p>
83388338 {#header_close#}
8339
8340 {#header_open|@Vector#}
8341 <pre>{#syntax#}@Vector(comptime len: u32, comptime ElemType: type) type{#endsyntax#}</pre>
8342 <p>
8343 This function returns a vector type for {#link|SIMD#}.
8344 </p>
8345 <p>
8346 {#syntax#}ElemType{#endsyntax#} must be an {#link|integer|Integers#}, a {#link|float|Floats#}, or a
8347 {#link|pointer|Pointers#}.
8348 </p>
8349 {#header_close#}
83508339 {#header_close#}
83518340
83528341 {#header_open|Opaque Types#}
lib/std/fmt.zig+3-3
......@@ -1670,9 +1670,9 @@ test "vector" {
16701670 return error.SkipZigTest;
16711671 }
16721672
1673 const vbool: @Vector(4, bool) = [_]bool{ true, false, true, false };
1674 const vi64: @Vector(4, i64) = [_]i64{ -2, -1, 0, 1 };
1675 const vu64: @Vector(4, u64) = [_]u64{ 1000, 2000, 3000, 4000 };
1673 const vbool: std.meta.Vector(4, bool) = [_]bool{ true, false, true, false };
1674 const vi64: std.meta.Vector(4, i64) = [_]i64{ -2, -1, 0, 1 };
1675 const vu64: std.meta.Vector(4, u64) = [_]u64{ 1000, 2000, 3000, 4000 };
16761676
16771677 try testFmt("{ true, false, true, false }", "{}", .{vbool});
16781678 try testFmt("{ -2, -1, 0, 1 }", "{}", .{vi64});
lib/std/hash/auto_hash.zig+4-4
......@@ -359,13 +359,13 @@ test "testHash vector" {
359359 // Disabled because of #3317
360360 if (@import("builtin").arch == .mipsel or @import("builtin").arch == .mips) return error.SkipZigTest;
361361
362 const a: @Vector(4, u32) = [_]u32{ 1, 2, 3, 4 };
363 const b: @Vector(4, u32) = [_]u32{ 1, 2, 3, 5 };
362 const a: meta.Vector(4, u32) = [_]u32{ 1, 2, 3, 4 };
363 const b: meta.Vector(4, u32) = [_]u32{ 1, 2, 3, 5 };
364364 testing.expect(testHash(a) == testHash(a));
365365 testing.expect(testHash(a) != testHash(b));
366366
367 const c: @Vector(4, u31) = [_]u31{ 1, 2, 3, 4 };
368 const d: @Vector(4, u31) = [_]u31{ 1, 2, 3, 5 };
367 const c: meta.Vector(4, u31) = [_]u31{ 1, 2, 3, 4 };
368 const d: meta.Vector(4, u31) = [_]u31{ 1, 2, 3, 5 };
369369 testing.expect(testHash(c) == testHash(c));
370370 testing.expect(testHash(c) != testHash(d));
371371}
lib/std/meta.zig+9
......@@ -650,3 +650,12 @@ pub fn IntType(comptime is_signed: bool, comptime bit_count: u16) type {
650650 },
651651 });
652652}
653
654pub fn Vector(comptime len: u32, comptime child: type) type {
655 return @Type(TypeInfo{
656 .Vector = .{
657 .len = len,
658 .child = child,
659 },
660 });
661}
lib/std/special/compiler_rt.zig+1-1
......@@ -291,7 +291,7 @@ comptime {
291291 @export(@import("compiler_rt/umodti3.zig").__umodti3, .{ .name = "__umodti3", .linkage = linkage });
292292 },
293293 .x86_64 => {
294 // The "ti" functions must use @Vector(2, u64) parameter types to adhere to the ABI
294 // The "ti" functions must use Vector(2, u64) parameter types to adhere to the ABI
295295 // that LLVM expects compiler-rt to have.
296296 @export(@import("compiler_rt/divti3.zig").__divti3_windows_x86_64, .{ .name = "__divti3", .linkage = linkage });
297297 @export(@import("compiler_rt/modti3.zig").__modti3_windows_x86_64, .{ .name = "__modti3", .linkage = linkage });
lib/std/special/compiler_rt/divti3.zig+1-1
......@@ -15,7 +15,7 @@ pub fn __divti3(a: i128, b: i128) callconv(.C) i128 {
1515 return (@bitCast(i128, r) ^ s) -% s;
1616}
1717
18const v128 = @Vector(2, u64);
18const v128 = @import("std").meta.Vector(2, u64);
1919pub fn __divti3_windows_x86_64(a: v128, b: v128) callconv(.C) v128 {
2020 return @bitCast(v128, @call(.{ .modifier = .always_inline }, __divti3, .{
2121 @bitCast(i128, a),
lib/std/special/compiler_rt/modti3.zig+1-1
......@@ -20,7 +20,7 @@ pub fn __modti3(a: i128, b: i128) callconv(.C) i128 {
2020 return (@bitCast(i128, r) ^ s_a) -% s_a; // negate if s == -1
2121}
2222
23const v128 = @Vector(2, u64);
23const v128 = @import("std").meta.Vector(2, u64);
2424pub fn __modti3_windows_x86_64(a: v128, b: v128) callconv(.C) v128 {
2525 return @bitCast(v128, @call(.{ .modifier = .always_inline }, __modti3, .{
2626 @bitCast(i128, a),
lib/std/special/compiler_rt/multi3.zig+1-1
......@@ -14,7 +14,7 @@ pub fn __multi3(a: i128, b: i128) callconv(.C) i128 {
1414 return r.all;
1515}
1616
17const v128 = @Vector(2, u64);
17const v128 = @import("std").meta.Vector(2, u64);
1818pub fn __multi3_windows_x86_64(a: v128, b: v128) callconv(.C) v128 {
1919 return @bitCast(v128, @call(.{ .modifier = .always_inline }, __multi3, .{
2020 @bitCast(i128, a),
lib/std/special/compiler_rt/udivmodti4.zig+1-1
......@@ -7,7 +7,7 @@ pub fn __udivmodti4(a: u128, b: u128, maybe_rem: ?*u128) callconv(.C) u128 {
77 return udivmod(u128, a, b, maybe_rem);
88}
99
10const v128 = @Vector(2, u64);
10const v128 = @import("std").meta.Vector(2, u64);
1111pub fn __udivmodti4_windows_x86_64(a: v128, b: v128, maybe_rem: ?*u128) callconv(.C) v128 {
1212 @setRuntimeSafety(builtin.is_test);
1313 return @bitCast(v128, udivmod(u128, @bitCast(u128, a), @bitCast(u128, b), maybe_rem));
lib/std/special/compiler_rt/udivti3.zig+1-1
......@@ -6,7 +6,7 @@ pub fn __udivti3(a: u128, b: u128) callconv(.C) u128 {
66 return udivmodti4.__udivmodti4(a, b, null);
77}
88
9const v128 = @Vector(2, u64);
9const v128 = @import("std").meta.Vector(2, u64);
1010pub fn __udivti3_windows_x86_64(a: v128, b: v128) callconv(.C) v128 {
1111 @setRuntimeSafety(builtin.is_test);
1212 return udivmodti4.__udivmodti4_windows_x86_64(a, b, null);
lib/std/special/compiler_rt/umodti3.zig+1-1
......@@ -9,7 +9,7 @@ pub fn __umodti3(a: u128, b: u128) callconv(.C) u128 {
99 return r;
1010}
1111
12const v128 = @Vector(2, u64);
12const v128 = @import("std").meta.Vector(2, u64);
1313pub fn __umodti3_windows_x86_64(a: v128, b: v128) callconv(.C) v128 {
1414 return @bitCast(v128, @call(.{ .modifier = .always_inline }, __umodti3, .{
1515 @bitCast(u128, a),
lib/std/target.zig+4-4
......@@ -488,8 +488,8 @@ pub const Target = struct {
488488
489489 /// Adds the specified feature set but not its dependencies.
490490 pub fn addFeatureSet(set: *Set, other_set: Set) void {
491 set.ints = @as(@Vector(usize_count, usize), set.ints) |
492 @as(@Vector(usize_count, usize), other_set.ints);
491 set.ints = @as(std.meta.Vector(usize_count, usize), set.ints) |
492 @as(std.meta.Vector(usize_count, usize), other_set.ints);
493493 }
494494
495495 /// Removes the specified feature but not its dependents.
......@@ -501,8 +501,8 @@ pub const Target = struct {
501501
502502 /// Removes the specified feature but not its dependents.
503503 pub fn removeFeatureSet(set: *Set, other_set: Set) void {
504 set.ints = @as(@Vector(usize_count, usize), set.ints) &
505 ~@as(@Vector(usize_count, usize), other_set.ints);
504 set.ints = @as(std.meta.Vector(usize_count, usize), set.ints) &
505 ~@as(std.meta.Vector(usize_count, usize), other_set.ints);
506506 }
507507
508508 pub fn populateDependencies(set: *Set, all_features_list: []const Cpu.Feature) void {
src/ir.cpp+4
......@@ -25426,6 +25426,10 @@ static ZigType *type_info_to_type(IrAnalyze *ira, IrInst *source_instr, ZigTypeI
2542625426 assert(payload->type == ir_type_info_get_type(ira, "Vector", nullptr));
2542725427 BigInt *len = get_const_field_lit_int(ira, source_instr->source_node, payload, "len", 0);
2542825428 ZigType *child_type = get_const_field_meta_type(ira, source_instr->source_node, payload, "child", 1);
25429 Error err;
25430 if ((err = ir_validate_vector_elem_type(ira, source_instr->source_node, child_type))) {
25431 return ira->codegen->invalid_inst_gen->value->type;
25432 }
2542925433 return get_vector_type(ira->codegen, bigint_as_u32(len), child_type);
2543025434 }
2543125435 case ZigTypeIdAnyFrame: {
test/compile_errors.zig+11-9
......@@ -984,7 +984,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
984984
985985 cases.add("store vector pointer with unknown runtime index",
986986 \\export fn entry() void {
987 \\ var v: @Vector(4, i32) = [_]i32{ 1, 5, 3, undefined };
987 \\ var v: @import("std").meta.Vector(4, i32) = [_]i32{ 1, 5, 3, undefined };
988988 \\
989989 \\ var i: u32 = 0;
990990 \\ storev(&v[i], 42);
......@@ -999,7 +999,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
999999
10001000 cases.add("load vector pointer with unknown runtime index",
10011001 \\export fn entry() void {
1002 \\ var v: @Vector(4, i32) = [_]i32{ 1, 5, 3, undefined };
1002 \\ var v: @import("std").meta.Vector(4, i32) = [_]i32{ 1, 5, 3, undefined };
10031003 \\
10041004 \\ var i: u32 = 0;
10051005 \\ var x = loadv(&v[i]);
......@@ -1885,8 +1885,8 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
18851885
18861886 cases.addTest("comptime vector overflow shows the index",
18871887 \\comptime {
1888 \\ var a: @Vector(4, u8) = [_]u8{ 1, 2, 255, 4 };
1889 \\ var b: @Vector(4, u8) = [_]u8{ 5, 6, 1, 8 };
1888 \\ var a: @import("std").meta.Vector(4, u8) = [_]u8{ 1, 2, 255, 4 };
1889 \\ var b: @import("std").meta.Vector(4, u8) = [_]u8{ 5, 6, 1, 8 };
18901890 \\ var x = a + b;
18911891 \\}
18921892 , &[_][]const u8{
......@@ -6846,8 +6846,8 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
68466846
68476847 cases.addTest("@shuffle with selected index past first vector length",
68486848 \\export fn entry() void {
6849 \\ const v: @Vector(4, u32) = [4]u32{ 10, 11, 12, 13 };
6850 \\ const x: @Vector(4, u32) = [4]u32{ 14, 15, 16, 17 };
6849 \\ const v: @import("std").meta.Vector(4, u32) = [4]u32{ 10, 11, 12, 13 };
6850 \\ const x: @import("std").meta.Vector(4, u32) = [4]u32{ 14, 15, 16, 17 };
68516851 \\ var z = @shuffle(u32, v, x, [8]i32{ 0, 1, 2, 3, 7, 6, 5, 4 });
68526852 \\}
68536853 , &[_][]const u8{
......@@ -6858,11 +6858,13 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
68586858
68596859 cases.addTest("nested vectors",
68606860 \\export fn entry() void {
6861 \\ const V = @Vector(4, @Vector(4, u8));
6862 \\ var v: V = undefined;
6861 \\ const V1 = @import("std").meta.Vector(4, u8);
6862 \\ const V2 = @Type(@import("builtin").TypeInfo{ .Vector = .{ .len = 4, .child = V1 } });
6863 \\ var v: V2 = undefined;
68636864 \\}
68646865 , &[_][]const u8{
6865 "tmp.zig:2:26: error: vector element type must be integer, float, bool, or pointer; '@Vector(4, u8)' is invalid",
6866 "tmp.zig:3:49: error: vector element type must be integer, float, bool, or pointer; '@Vector(4, u8)' is invalid",
6867 "tmp.zig:3:16: note: referenced here",
68666868 });
68676869
68686870 cases.addTest("bad @splat type",
test/runtime_safety.zig+20-20
......@@ -472,11 +472,11 @@ pub fn addCases(cases: *tests.CompareOutputContext) void {
472472 \\ @import("std").os.exit(126);
473473 \\}
474474 \\pub fn main() void {
475 \\ var a: @Vector(4, i32) = [_]i32{ 1, 2, 2147483643, 4 };
476 \\ var b: @Vector(4, i32) = [_]i32{ 5, 6, 7, 8 };
475 \\ var a: @import("std").meta.Vector(4, i32) = [_]i32{ 1, 2, 2147483643, 4 };
476 \\ var b: @import("std").meta.Vector(4, i32) = [_]i32{ 5, 6, 7, 8 };
477477 \\ const x = add(a, b);
478478 \\}
479 \\fn add(a: @Vector(4, i32), b: @Vector(4, i32)) @Vector(4, i32) {
479 \\fn add(a: @import("std").meta.Vector(4, i32), b: @import("std").meta.Vector(4, i32)) @import("std").meta.Vector(4, i32) {
480480 \\ return a + b;
481481 \\}
482482 );
......@@ -486,11 +486,11 @@ pub fn addCases(cases: *tests.CompareOutputContext) void {
486486 \\ @import("std").os.exit(126);
487487 \\}
488488 \\pub fn main() void {
489 \\ var a: @Vector(4, u32) = [_]u32{ 1, 2, 8, 4 };
490 \\ var b: @Vector(4, u32) = [_]u32{ 5, 6, 7, 8 };
489 \\ var a: @import("std").meta.Vector(4, u32) = [_]u32{ 1, 2, 8, 4 };
490 \\ var b: @import("std").meta.Vector(4, u32) = [_]u32{ 5, 6, 7, 8 };
491491 \\ const x = sub(b, a);
492492 \\}
493 \\fn sub(a: @Vector(4, u32), b: @Vector(4, u32)) @Vector(4, u32) {
493 \\fn sub(a: @import("std").meta.Vector(4, u32), b: @import("std").meta.Vector(4, u32)) @import("std").meta.Vector(4, u32) {
494494 \\ return a - b;
495495 \\}
496496 );
......@@ -500,11 +500,11 @@ pub fn addCases(cases: *tests.CompareOutputContext) void {
500500 \\ @import("std").os.exit(126);
501501 \\}
502502 \\pub fn main() void {
503 \\ var a: @Vector(4, u8) = [_]u8{ 1, 2, 200, 4 };
504 \\ var b: @Vector(4, u8) = [_]u8{ 5, 6, 2, 8 };
503 \\ var a: @import("std").meta.Vector(4, u8) = [_]u8{ 1, 2, 200, 4 };
504 \\ var b: @import("std").meta.Vector(4, u8) = [_]u8{ 5, 6, 2, 8 };
505505 \\ const x = mul(b, a);
506506 \\}
507 \\fn mul(a: @Vector(4, u8), b: @Vector(4, u8)) @Vector(4, u8) {
507 \\fn mul(a: @import("std").meta.Vector(4, u8), b: @import("std").meta.Vector(4, u8)) @import("std").meta.Vector(4, u8) {
508508 \\ return a * b;
509509 \\}
510510 );
......@@ -514,10 +514,10 @@ pub fn addCases(cases: *tests.CompareOutputContext) void {
514514 \\ @import("std").os.exit(126);
515515 \\}
516516 \\pub fn main() void {
517 \\ var a: @Vector(4, i16) = [_]i16{ 1, -32768, 200, 4 };
517 \\ var a: @import("std").meta.Vector(4, i16) = [_]i16{ 1, -32768, 200, 4 };
518518 \\ const x = neg(a);
519519 \\}
520 \\fn neg(a: @Vector(4, i16)) @Vector(4, i16) {
520 \\fn neg(a: @import("std").meta.Vector(4, i16)) @import("std").meta.Vector(4, i16) {
521521 \\ return -a;
522522 \\}
523523 );
......@@ -579,12 +579,12 @@ pub fn addCases(cases: *tests.CompareOutputContext) void {
579579 \\ @import("std").os.exit(126);
580580 \\}
581581 \\pub fn main() !void {
582 \\ var a: @Vector(4, i16) = [_]i16{ 1, 2, -32768, 4 };
583 \\ var b: @Vector(4, i16) = [_]i16{ 1, 2, -1, 4 };
582 \\ var a: @import("std").meta.Vector(4, i16) = [_]i16{ 1, 2, -32768, 4 };
583 \\ var b: @import("std").meta.Vector(4, i16) = [_]i16{ 1, 2, -1, 4 };
584584 \\ const x = div(a, b);
585585 \\ if (x[2] == 32767) return error.Whatever;
586586 \\}
587 \\fn div(a: @Vector(4, i16), b: @Vector(4, i16)) @Vector(4, i16) {
587 \\fn div(a: @import("std").meta.Vector(4, i16), b: @import("std").meta.Vector(4, i16)) @import("std").meta.Vector(4, i16) {
588588 \\ return @divTrunc(a, b);
589589 \\}
590590 );
......@@ -658,11 +658,11 @@ pub fn addCases(cases: *tests.CompareOutputContext) void {
658658 \\ @import("std").os.exit(126);
659659 \\}
660660 \\pub fn main() void {
661 \\ var a: @Vector(4, i32) = [4]i32{111, 222, 333, 444};
662 \\ var b: @Vector(4, i32) = [4]i32{111, 0, 333, 444};
661 \\ var a: @import("std").meta.Vector(4, i32) = [4]i32{111, 222, 333, 444};
662 \\ var b: @import("std").meta.Vector(4, i32) = [4]i32{111, 0, 333, 444};
663663 \\ const x = div0(a, b);
664664 \\}
665 \\fn div0(a: @Vector(4, i32), b: @Vector(4, i32)) @Vector(4, i32) {
665 \\fn div0(a: @import("std").meta.Vector(4, i32), b: @import("std").meta.Vector(4, i32)) @import("std").meta.Vector(4, i32) {
666666 \\ return @divTrunc(a, b);
667667 \\}
668668 );
......@@ -685,11 +685,11 @@ pub fn addCases(cases: *tests.CompareOutputContext) void {
685685 \\ @import("std").os.exit(126);
686686 \\}
687687 \\pub fn main() !void {
688 \\ var a: @Vector(4, i32) = [4]i32{111, 222, 333, 444};
689 \\ var b: @Vector(4, i32) = [4]i32{111, 222, 333, 441};
688 \\ var a: @import("std").meta.Vector(4, i32) = [4]i32{111, 222, 333, 444};
689 \\ var b: @import("std").meta.Vector(4, i32) = [4]i32{111, 222, 333, 441};
690690 \\ const x = divExact(a, b);
691691 \\}
692 \\fn divExact(a: @Vector(4, i32), b: @Vector(4, i32)) @Vector(4, i32) {
692 \\fn divExact(a: @import("std").meta.Vector(4, i32), b: @import("std").meta.Vector(4, i32)) @import("std").meta.Vector(4, i32) {
693693 \\ return @divExact(a, b);
694694 \\}
695695 );
test/stage1/behavior/byteswap.zig+2-2
......@@ -55,8 +55,8 @@ test "@byteSwap vectors" {
5555 fn t(
5656 comptime I: type,
5757 comptime n: comptime_int,
58 input: @Vector(n, I),
59 expected_vector: @Vector(n, I),
58 input: std.meta.Vector(n, I),
59 expected_vector: std.meta.Vector(n, I),
6060 ) void {
6161 const actual_output: [n]I = @byteSwap(I, input);
6262 const expected_output: [n]I = expected_vector;
test/stage1/behavior/floatop.zig+13-12
......@@ -3,6 +3,7 @@ const expect = std.testing.expect;
33const math = std.math;
44const pi = std.math.pi;
55const e = std.math.e;
6const Vector = std.meta.Vector;
67
78const epsilon = 0.000001;
89
......@@ -36,7 +37,7 @@ fn testSqrt() void {
3637 // expect(@sqrt(a) == 7);
3738 //}
3839 {
39 var v: @Vector(4, f32) = [_]f32{ 1.1, 2.2, 3.3, 4.4 };
40 var v: Vector(4, f32) = [_]f32{ 1.1, 2.2, 3.3, 4.4 };
4041 var result = @sqrt(v);
4142 expect(math.approxEq(f32, @sqrt(@as(f32, 1.1)), result[0], epsilon));
4243 expect(math.approxEq(f32, @sqrt(@as(f32, 2.2)), result[1], epsilon));
......@@ -86,7 +87,7 @@ fn testSin() void {
8687 expect(@sin(a) == 0);
8788 }
8889 {
89 var v: @Vector(4, f32) = [_]f32{ 1.1, 2.2, 3.3, 4.4 };
90 var v: Vector(4, f32) = [_]f32{ 1.1, 2.2, 3.3, 4.4 };
9091 var result = @sin(v);
9192 expect(math.approxEq(f32, @sin(@as(f32, 1.1)), result[0], epsilon));
9293 expect(math.approxEq(f32, @sin(@as(f32, 2.2)), result[1], epsilon));
......@@ -116,7 +117,7 @@ fn testCos() void {
116117 expect(@cos(a) == 1);
117118 }
118119 {
119 var v: @Vector(4, f32) = [_]f32{ 1.1, 2.2, 3.3, 4.4 };
120 var v: Vector(4, f32) = [_]f32{ 1.1, 2.2, 3.3, 4.4 };
120121 var result = @cos(v);
121122 expect(math.approxEq(f32, @cos(@as(f32, 1.1)), result[0], epsilon));
122123 expect(math.approxEq(f32, @cos(@as(f32, 2.2)), result[1], epsilon));
......@@ -146,7 +147,7 @@ fn testExp() void {
146147 expect(@exp(a) == 1);
147148 }
148149 {
149 var v: @Vector(4, f32) = [_]f32{ 1.1, 2.2, 0.3, 0.4 };
150 var v: Vector(4, f32) = [_]f32{ 1.1, 2.2, 0.3, 0.4 };
150151 var result = @exp(v);
151152 expect(math.approxEq(f32, @exp(@as(f32, 1.1)), result[0], epsilon));
152153 expect(math.approxEq(f32, @exp(@as(f32, 2.2)), result[1], epsilon));
......@@ -176,7 +177,7 @@ fn testExp2() void {
176177 expect(@exp2(a) == 4);
177178 }
178179 {
179 var v: @Vector(4, f32) = [_]f32{ 1.1, 2.2, 0.3, 0.4 };
180 var v: Vector(4, f32) = [_]f32{ 1.1, 2.2, 0.3, 0.4 };
180181 var result = @exp2(v);
181182 expect(math.approxEq(f32, @exp2(@as(f32, 1.1)), result[0], epsilon));
182183 expect(math.approxEq(f32, @exp2(@as(f32, 2.2)), result[1], epsilon));
......@@ -208,7 +209,7 @@ fn testLog() void {
208209 expect(@log(a) == 1 or @log(a) == @bitCast(f64, @as(u64, 0x3ff0000000000000)));
209210 }
210211 {
211 var v: @Vector(4, f32) = [_]f32{ 1.1, 2.2, 0.3, 0.4 };
212 var v: Vector(4, f32) = [_]f32{ 1.1, 2.2, 0.3, 0.4 };
212213 var result = @log(v);
213214 expect(math.approxEq(f32, @log(@as(f32, 1.1)), result[0], epsilon));
214215 expect(math.approxEq(f32, @log(@as(f32, 2.2)), result[1], epsilon));
......@@ -238,7 +239,7 @@ fn testLog2() void {
238239 expect(@log2(a) == 2);
239240 }
240241 {
241 var v: @Vector(4, f32) = [_]f32{ 1.1, 2.2, 0.3, 0.4 };
242 var v: Vector(4, f32) = [_]f32{ 1.1, 2.2, 0.3, 0.4 };
242243 var result = @log2(v);
243244 expect(math.approxEq(f32, @log2(@as(f32, 1.1)), result[0], epsilon));
244245 expect(math.approxEq(f32, @log2(@as(f32, 2.2)), result[1], epsilon));
......@@ -268,7 +269,7 @@ fn testLog10() void {
268269 expect(@log10(a) == 3);
269270 }
270271 {
271 var v: @Vector(4, f32) = [_]f32{ 1.1, 2.2, 0.3, 0.4 };
272 var v: Vector(4, f32) = [_]f32{ 1.1, 2.2, 0.3, 0.4 };
272273 var result = @log10(v);
273274 expect(math.approxEq(f32, @log10(@as(f32, 1.1)), result[0], epsilon));
274275 expect(math.approxEq(f32, @log10(@as(f32, 2.2)), result[1], epsilon));
......@@ -304,7 +305,7 @@ fn testFabs() void {
304305 expect(@fabs(b) == 2.5);
305306 }
306307 {
307 var v: @Vector(4, f32) = [_]f32{ 1.1, -2.2, 0.3, -0.4 };
308 var v: Vector(4, f32) = [_]f32{ 1.1, -2.2, 0.3, -0.4 };
308309 var result = @fabs(v);
309310 expect(math.approxEq(f32, @fabs(@as(f32, 1.1)), result[0], epsilon));
310311 expect(math.approxEq(f32, @fabs(@as(f32, -2.2)), result[1], epsilon));
......@@ -334,7 +335,7 @@ fn testFloor() void {
334335 expect(@floor(a) == 3);
335336 }
336337 {
337 var v: @Vector(4, f32) = [_]f32{ 1.1, -2.2, 0.3, -0.4 };
338 var v: Vector(4, f32) = [_]f32{ 1.1, -2.2, 0.3, -0.4 };
338339 var result = @floor(v);
339340 expect(math.approxEq(f32, @floor(@as(f32, 1.1)), result[0], epsilon));
340341 expect(math.approxEq(f32, @floor(@as(f32, -2.2)), result[1], epsilon));
......@@ -364,7 +365,7 @@ fn testCeil() void {
364365 expect(@ceil(a) == 4);
365366 }
366367 {
367 var v: @Vector(4, f32) = [_]f32{ 1.1, -2.2, 0.3, -0.4 };
368 var v: Vector(4, f32) = [_]f32{ 1.1, -2.2, 0.3, -0.4 };
368369 var result = @ceil(v);
369370 expect(math.approxEq(f32, @ceil(@as(f32, 1.1)), result[0], epsilon));
370371 expect(math.approxEq(f32, @ceil(@as(f32, -2.2)), result[1], epsilon));
......@@ -394,7 +395,7 @@ fn testTrunc() void {
394395 expect(@trunc(a) == -3);
395396 }
396397 {
397 var v: @Vector(4, f32) = [_]f32{ 1.1, -2.2, 0.3, -0.4 };
398 var v: Vector(4, f32) = [_]f32{ 1.1, -2.2, 0.3, -0.4 };
398399 var result = @trunc(v);
399400 expect(math.approxEq(f32, @trunc(@as(f32, 1.1)), result[0], epsilon));
400401 expect(math.approxEq(f32, @trunc(@as(f32, -2.2)), result[1], epsilon));
test/stage1/behavior/math.zig+4-4
......@@ -649,8 +649,8 @@ fn comptimeAdd(comptime a: comptime_int, comptime b: comptime_int) comptime_int
649649test "vector integer addition" {
650650 const S = struct {
651651 fn doTheTest() void {
652 var a: @Vector(4, i32) = [_]i32{ 1, 2, 3, 4 };
653 var b: @Vector(4, i32) = [_]i32{ 5, 6, 7, 8 };
652 var a: std.meta.Vector(4, i32) = [_]i32{ 1, 2, 3, 4 };
653 var b: std.meta.Vector(4, i32) = [_]i32{ 5, 6, 7, 8 };
654654 var result = a + b;
655655 var result_array: [4]i32 = result;
656656 const expected = [_]i32{ 6, 8, 10, 12 };
......@@ -693,8 +693,8 @@ test "128-bit multiplication" {
693693test "vector comparison" {
694694 const S = struct {
695695 fn doTheTest() void {
696 var a: @Vector(6, i32) = [_]i32{ 1, 3, -1, 5, 7, 9 };
697 var b: @Vector(6, i32) = [_]i32{ -1, 3, 0, 6, 10, -10 };
696 var a: std.meta.Vector(6, i32) = [_]i32{ 1, 3, -1, 5, 7, 9 };
697 var b: std.meta.Vector(6, i32) = [_]i32{ -1, 3, 0, 6, 10, -10 };
698698 expect(mem.eql(bool, &@as([6]bool, a < b), &[_]bool{ false, false, true, true, true, false }));
699699 expect(mem.eql(bool, &@as([6]bool, a <= b), &[_]bool{ false, true, true, true, true, false }));
700700 expect(mem.eql(bool, &@as([6]bool, a == b), &[_]bool{ false, true, false, false, false, false }));
test/stage1/behavior/shuffle.zig+15-14
......@@ -1,13 +1,14 @@
11const std = @import("std");
22const mem = std.mem;
33const expect = std.testing.expect;
4const Vector = std.meta.Vector;
45
56test "@shuffle" {
67 const S = struct {
78 fn doTheTest() void {
8 var v: @Vector(4, i32) = [4]i32{ 2147483647, -2, 30, 40 };
9 var x: @Vector(4, i32) = [4]i32{ 1, 2147483647, 3, 4 };
10 const mask: @Vector(4, i32) = [4]i32{ 0, ~@as(i32, 2), 3, ~@as(i32, 3) };
9 var v: Vector(4, i32) = [4]i32{ 2147483647, -2, 30, 40 };
10 var x: Vector(4, i32) = [4]i32{ 1, 2147483647, 3, 4 };
11 const mask: Vector(4, i32) = [4]i32{ 0, ~@as(i32, 2), 3, ~@as(i32, 3) };
1112 var res = @shuffle(i32, v, x, mask);
1213 expect(mem.eql(i32, &@as([4]i32, res), &[4]i32{ 2147483647, 3, 40, 4 }));
1314
......@@ -16,28 +17,28 @@ test "@shuffle" {
1617 expect(mem.eql(i32, &@as([4]i32, res), &[4]i32{ 2147483647, 3, 40, 4 }));
1718
1819 // Undefined
19 const mask2: @Vector(4, i32) = [4]i32{ 3, 1, 2, 0 };
20 const mask2: Vector(4, i32) = [4]i32{ 3, 1, 2, 0 };
2021 res = @shuffle(i32, v, undefined, mask2);
2122 expect(mem.eql(i32, &@as([4]i32, res), &[4]i32{ 40, -2, 30, 2147483647 }));
2223
2324 // Upcasting of b
24 var v2: @Vector(2, i32) = [2]i32{ 2147483647, undefined };
25 const mask3: @Vector(4, i32) = [4]i32{ ~@as(i32, 0), 2, ~@as(i32, 0), 3 };
25 var v2: Vector(2, i32) = [2]i32{ 2147483647, undefined };
26 const mask3: Vector(4, i32) = [4]i32{ ~@as(i32, 0), 2, ~@as(i32, 0), 3 };
2627 res = @shuffle(i32, x, v2, mask3);
2728 expect(mem.eql(i32, &@as([4]i32, res), &[4]i32{ 2147483647, 3, 2147483647, 4 }));
2829
2930 // Upcasting of a
30 var v3: @Vector(2, i32) = [2]i32{ 2147483647, -2 };
31 const mask4: @Vector(4, i32) = [4]i32{ 0, ~@as(i32, 2), 1, ~@as(i32, 3) };
31 var v3: Vector(2, i32) = [2]i32{ 2147483647, -2 };
32 const mask4: Vector(4, i32) = [4]i32{ 0, ~@as(i32, 2), 1, ~@as(i32, 3) };
3233 res = @shuffle(i32, v3, x, mask4);
3334 expect(mem.eql(i32, &@as([4]i32, res), &[4]i32{ 2147483647, 3, -2, 4 }));
3435
3536 // bool
3637 // Disabled because of #3317
3738 if (@import("builtin").arch != .mipsel and std.Target.current.cpu.arch != .mips) {
38 var x2: @Vector(4, bool) = [4]bool{ false, true, false, true };
39 var v4: @Vector(2, bool) = [2]bool{ true, false };
40 const mask5: @Vector(4, i32) = [4]i32{ 0, ~@as(i32, 1), 1, 2 };
39 var x2: Vector(4, bool) = [4]bool{ false, true, false, true };
40 var v4: Vector(2, bool) = [2]bool{ true, false };
41 const mask5: Vector(4, i32) = [4]i32{ 0, ~@as(i32, 1), 1, 2 };
4142 var res2 = @shuffle(bool, x2, v4, mask5);
4243 expect(mem.eql(bool, &@as([4]bool, res2), &[4]bool{ false, false, true, false }));
4344 }
......@@ -45,9 +46,9 @@ test "@shuffle" {
4546 // TODO re-enable when LLVM codegen is fixed
4647 // https://github.com/ziglang/zig/issues/3246
4748 if (false) {
48 var x2: @Vector(3, bool) = [3]bool{ false, true, false };
49 var v4: @Vector(2, bool) = [2]bool{ true, false };
50 const mask5: @Vector(4, i32) = [4]i32{ 0, ~@as(i32, 1), 1, 2 };
49 var x2: Vector(3, bool) = [3]bool{ false, true, false };
50 var v4: Vector(2, bool) = [2]bool{ true, false };
51 const mask5: Vector(4, i32) = [4]i32{ 0, ~@as(i32, 1), 1, 2 };
5152 var res2 = @shuffle(bool, x2, v4, mask5);
5253 expect(mem.eql(bool, &@as([4]bool, res2), &[4]bool{ false, false, true, false }));
5354 }
test/stage1/behavior/type.zig+3
......@@ -200,6 +200,9 @@ test "Type.Vector" {
200200 @Vector(0, u8),
201201 @Vector(4, u8),
202202 @Vector(8, *u8),
203 std.meta.Vector(0, u8),
204 std.meta.Vector(4, u8),
205 std.meta.Vector(8, *u8),
203206 });
204207}
205208
test/stage1/behavior/type_info.zig+1-1
......@@ -296,7 +296,7 @@ test "type info: vectors" {
296296}
297297
298298fn testVector() void {
299 const vec_info = @typeInfo(@Vector(4, i32));
299 const vec_info = @typeInfo(std.meta.Vector(4, i32));
300300 expect(vec_info == .Vector);
301301 expect(vec_info.Vector.len == 4);
302302 expect(vec_info.Vector.child == i32);
test/stage1/behavior/vector.zig+35-34
......@@ -3,11 +3,12 @@ const mem = std.mem;
33const math = std.math;
44const expect = std.testing.expect;
55const expectEqual = std.testing.expectEqual;
6const Vector = std.meta.Vector;
67
78test "implicit cast vector to array - bool" {
89 const S = struct {
910 fn doTheTest() void {
10 const a: @Vector(4, bool) = [_]bool{ true, false, true, false };
11 const a: Vector(4, bool) = [_]bool{ true, false, true, false };
1112 const result_array: [4]bool = a;
1213 expect(mem.eql(bool, &result_array, &[4]bool{ true, false, true, false }));
1314 }
......@@ -19,12 +20,12 @@ test "implicit cast vector to array - bool" {
1920test "vector wrap operators" {
2021 const S = struct {
2122 fn doTheTest() void {
22 var v: @Vector(4, i32) = [4]i32{ 2147483647, -2, 30, 40 };
23 var x: @Vector(4, i32) = [4]i32{ 1, 2147483647, 3, 4 };
23 var v: Vector(4, i32) = [4]i32{ 2147483647, -2, 30, 40 };
24 var x: Vector(4, i32) = [4]i32{ 1, 2147483647, 3, 4 };
2425 expect(mem.eql(i32, &@as([4]i32, v +% x), &[4]i32{ -2147483648, 2147483645, 33, 44 }));
2526 expect(mem.eql(i32, &@as([4]i32, v -% x), &[4]i32{ 2147483646, 2147483647, 27, 36 }));
2627 expect(mem.eql(i32, &@as([4]i32, v *% x), &[4]i32{ 2147483647, 2, 90, 160 }));
27 var z: @Vector(4, i32) = [4]i32{ 1, 2, 3, -2147483648 };
28 var z: Vector(4, i32) = [4]i32{ 1, 2, 3, -2147483648 };
2829 expect(mem.eql(i32, &@as([4]i32, -%z), &[4]i32{ -1, -2, -3, -2147483648 }));
2930 }
3031 };
......@@ -35,8 +36,8 @@ test "vector wrap operators" {
3536test "vector bin compares with mem.eql" {
3637 const S = struct {
3738 fn doTheTest() void {
38 var v: @Vector(4, i32) = [4]i32{ 2147483647, -2, 30, 40 };
39 var x: @Vector(4, i32) = [4]i32{ 1, 2147483647, 30, 4 };
39 var v: Vector(4, i32) = [4]i32{ 2147483647, -2, 30, 40 };
40 var x: Vector(4, i32) = [4]i32{ 1, 2147483647, 30, 4 };
4041 expect(mem.eql(bool, &@as([4]bool, v == x), &[4]bool{ false, false, true, false }));
4142 expect(mem.eql(bool, &@as([4]bool, v != x), &[4]bool{ true, true, false, true }));
4243 expect(mem.eql(bool, &@as([4]bool, v < x), &[4]bool{ false, true, false, false }));
......@@ -52,8 +53,8 @@ test "vector bin compares with mem.eql" {
5253test "vector int operators" {
5354 const S = struct {
5455 fn doTheTest() void {
55 var v: @Vector(4, i32) = [4]i32{ 10, 20, 30, 40 };
56 var x: @Vector(4, i32) = [4]i32{ 1, 2, 3, 4 };
56 var v: Vector(4, i32) = [4]i32{ 10, 20, 30, 40 };
57 var x: Vector(4, i32) = [4]i32{ 1, 2, 3, 4 };
5758 expect(mem.eql(i32, &@as([4]i32, v + x), &[4]i32{ 11, 22, 33, 44 }));
5859 expect(mem.eql(i32, &@as([4]i32, v - x), &[4]i32{ 9, 18, 27, 36 }));
5960 expect(mem.eql(i32, &@as([4]i32, v * x), &[4]i32{ 10, 40, 90, 160 }));
......@@ -67,8 +68,8 @@ test "vector int operators" {
6768test "vector float operators" {
6869 const S = struct {
6970 fn doTheTest() void {
70 var v: @Vector(4, f32) = [4]f32{ 10, 20, 30, 40 };
71 var x: @Vector(4, f32) = [4]f32{ 1, 2, 3, 4 };
71 var v: Vector(4, f32) = [4]f32{ 10, 20, 30, 40 };
72 var x: Vector(4, f32) = [4]f32{ 1, 2, 3, 4 };
7273 expect(mem.eql(f32, &@as([4]f32, v + x), &[4]f32{ 11, 22, 33, 44 }));
7374 expect(mem.eql(f32, &@as([4]f32, v - x), &[4]f32{ 9, 18, 27, 36 }));
7475 expect(mem.eql(f32, &@as([4]f32, v * x), &[4]f32{ 10, 40, 90, 160 }));
......@@ -82,8 +83,8 @@ test "vector float operators" {
8283test "vector bit operators" {
8384 const S = struct {
8485 fn doTheTest() void {
85 var v: @Vector(4, u8) = [4]u8{ 0b10101010, 0b10101010, 0b10101010, 0b10101010 };
86 var x: @Vector(4, u8) = [4]u8{ 0b11110000, 0b00001111, 0b10101010, 0b01010101 };
86 var v: Vector(4, u8) = [4]u8{ 0b10101010, 0b10101010, 0b10101010, 0b10101010 };
87 var x: Vector(4, u8) = [4]u8{ 0b11110000, 0b00001111, 0b10101010, 0b01010101 };
8788 expect(mem.eql(u8, &@as([4]u8, v ^ x), &[4]u8{ 0b01011010, 0b10100101, 0b00000000, 0b11111111 }));
8889 expect(mem.eql(u8, &@as([4]u8, v | x), &[4]u8{ 0b11111010, 0b10101111, 0b10101010, 0b11111111 }));
8990 expect(mem.eql(u8, &@as([4]u8, v & x), &[4]u8{ 0b10100000, 0b00001010, 0b10101010, 0b00000000 }));
......@@ -96,7 +97,7 @@ test "vector bit operators" {
9697test "implicit cast vector to array" {
9798 const S = struct {
9899 fn doTheTest() void {
99 var a: @Vector(4, i32) = [_]i32{ 1, 2, 3, 4 };
100 var a: Vector(4, i32) = [_]i32{ 1, 2, 3, 4 };
100101 var result_array: [4]i32 = a;
101102 result_array = a;
102103 expect(mem.eql(i32, &result_array, &[4]i32{ 1, 2, 3, 4 }));
......@@ -109,7 +110,7 @@ test "implicit cast vector to array" {
109110test "array to vector" {
110111 var foo: f32 = 3.14;
111112 var arr = [4]f32{ foo, 1.5, 0.0, 0.0 };
112 var vec: @Vector(4, f32) = arr;
113 var vec: Vector(4, f32) = arr;
113114}
114115
115116test "vector casts of sizes not divisable by 8" {
......@@ -119,22 +120,22 @@ test "vector casts of sizes not divisable by 8" {
119120 const S = struct {
120121 fn doTheTest() void {
121122 {
122 var v: @Vector(4, u3) = [4]u3{ 5, 2, 3, 0 };
123 var v: Vector(4, u3) = [4]u3{ 5, 2, 3, 0 };
123124 var x: [4]u3 = v;
124125 expect(mem.eql(u3, &x, &@as([4]u3, v)));
125126 }
126127 {
127 var v: @Vector(4, u2) = [4]u2{ 1, 2, 3, 0 };
128 var v: Vector(4, u2) = [4]u2{ 1, 2, 3, 0 };
128129 var x: [4]u2 = v;
129130 expect(mem.eql(u2, &x, &@as([4]u2, v)));
130131 }
131132 {
132 var v: @Vector(4, u1) = [4]u1{ 1, 0, 1, 0 };
133 var v: Vector(4, u1) = [4]u1{ 1, 0, 1, 0 };
133134 var x: [4]u1 = v;
134135 expect(mem.eql(u1, &x, &@as([4]u1, v)));
135136 }
136137 {
137 var v: @Vector(4, bool) = [4]bool{ false, false, true, false };
138 var v: Vector(4, bool) = [4]bool{ false, false, true, false };
138139 var x: [4]bool = v;
139140 expect(mem.eql(bool, &x, &@as([4]bool, v)));
140141 }
......@@ -149,7 +150,7 @@ test "vector @splat" {
149150 fn doTheTest() void {
150151 var v: u32 = 5;
151152 var x = @splat(4, v);
152 expect(@TypeOf(x) == @Vector(4, u32));
153 expect(@TypeOf(x) == Vector(4, u32));
153154 var array_x: [4]u32 = x;
154155 expect(array_x[0] == 5);
155156 expect(array_x[1] == 5);
......@@ -164,7 +165,7 @@ test "vector @splat" {
164165test "load vector elements via comptime index" {
165166 const S = struct {
166167 fn doTheTest() void {
167 var v: @Vector(4, i32) = [_]i32{ 1, 2, 3, undefined };
168 var v: Vector(4, i32) = [_]i32{ 1, 2, 3, undefined };
168169 expect(v[0] == 1);
169170 expect(v[1] == 2);
170171 expect(loadv(&v[2]) == 3);
......@@ -181,7 +182,7 @@ test "load vector elements via comptime index" {
181182test "store vector elements via comptime index" {
182183 const S = struct {
183184 fn doTheTest() void {
184 var v: @Vector(4, i32) = [_]i32{ 1, 5, 3, undefined };
185 var v: Vector(4, i32) = [_]i32{ 1, 5, 3, undefined };
185186
186187 v[2] = 42;
187188 expect(v[1] == 5);
......@@ -204,7 +205,7 @@ test "store vector elements via comptime index" {
204205test "load vector elements via runtime index" {
205206 const S = struct {
206207 fn doTheTest() void {
207 var v: @Vector(4, i32) = [_]i32{ 1, 2, 3, undefined };
208 var v: Vector(4, i32) = [_]i32{ 1, 2, 3, undefined };
208209 var i: u32 = 0;
209210 expect(v[i] == 1);
210211 i += 1;
......@@ -221,7 +222,7 @@ test "load vector elements via runtime index" {
221222test "store vector elements via runtime index" {
222223 const S = struct {
223224 fn doTheTest() void {
224 var v: @Vector(4, i32) = [_]i32{ 1, 5, 3, undefined };
225 var v: Vector(4, i32) = [_]i32{ 1, 5, 3, undefined };
225226 var i: u32 = 2;
226227 v[i] = 1;
227228 expect(v[1] == 5);
......@@ -238,7 +239,7 @@ test "store vector elements via runtime index" {
238239
239240test "initialize vector which is a struct field" {
240241 const Vec4Obj = struct {
241 data: @Vector(4, f32),
242 data: Vector(4, f32),
242243 };
243244
244245 const S = struct {
......@@ -256,8 +257,8 @@ test "vector comparison operators" {
256257 const S = struct {
257258 fn doTheTest() void {
258259 {
259 const v1: @Vector(4, bool) = [_]bool{ true, false, true, false };
260 const v2: @Vector(4, bool) = [_]bool{ false, true, false, true };
260 const v1: Vector(4, bool) = [_]bool{ true, false, true, false };
261 const v2: Vector(4, bool) = [_]bool{ false, true, false, true };
261262 expectEqual(@splat(4, true), v1 == v1);
262263 expectEqual(@splat(4, false), v1 == v2);
263264 expectEqual(@splat(4, true), v1 != v2);
......@@ -265,7 +266,7 @@ test "vector comparison operators" {
265266 }
266267 {
267268 const v1 = @splat(4, @as(u32, 0xc0ffeeee));
268 const v2: @Vector(4, c_uint) = v1;
269 const v2: Vector(4, c_uint) = v1;
269270 const v3 = @splat(4, @as(u32, 0xdeadbeef));
270271 expectEqual(@splat(4, true), v1 == v2);
271272 expectEqual(@splat(4, false), v1 == v3);
......@@ -280,7 +281,7 @@ test "vector comparison operators" {
280281
281282test "vector division operators" {
282283 const S = struct {
283 fn doTheTestDiv(comptime T: type, x: @Vector(4, T), y: @Vector(4, T)) void {
284 fn doTheTestDiv(comptime T: type, x: Vector(4, T), y: Vector(4, T)) void {
284285 if (!comptime std.meta.trait.isSignedInt(T)) {
285286 const d0 = x / y;
286287 for (@as([4]T, d0)) |v, i| {
......@@ -301,7 +302,7 @@ test "vector division operators" {
301302 }
302303 }
303304
304 fn doTheTestMod(comptime T: type, x: @Vector(4, T), y: @Vector(4, T)) void {
305 fn doTheTestMod(comptime T: type, x: Vector(4, T), y: Vector(4, T)) void {
305306 if ((!comptime std.meta.trait.isSignedInt(T)) and @typeInfo(T) != .Float) {
306307 const r0 = x % y;
307308 for (@as([4]T, r0)) |v, i| {
......@@ -362,7 +363,7 @@ test "vector division operators" {
362363
363364test "vector bitwise not operator" {
364365 const S = struct {
365 fn doTheTestNot(comptime T: type, x: @Vector(4, T)) void {
366 fn doTheTestNot(comptime T: type, x: Vector(4, T)) void {
366367 var y = ~x;
367368 for (@as([4]T, y)) |v, i| {
368369 expectEqual(~x[i], v);
......@@ -392,8 +393,8 @@ test "vector shift operators" {
392393 const TX = @typeInfo(@TypeOf(x)).Array.child;
393394 const TY = @typeInfo(@TypeOf(y)).Array.child;
394395
395 var xv = @as(@Vector(N, TX), x);
396 var yv = @as(@Vector(N, TY), y);
396 var xv = @as(Vector(N, TX), x);
397 var yv = @as(Vector(N, TY), y);
397398
398399 var z0 = xv >> yv;
399400 for (@as([N]TX, z0)) |v, i| {
......@@ -409,8 +410,8 @@ test "vector shift operators" {
409410 const TX = @typeInfo(@TypeOf(x)).Array.child;
410411 const TY = @typeInfo(@TypeOf(y)).Array.child;
411412
412 var xv = @as(@Vector(N, TX), x);
413 var yv = @as(@Vector(N, TY), y);
413 var xv = @as(Vector(N, TX), x);
414 var yv = @as(Vector(N, TY), y);
414415
415416 var z = if (dir == .Left) @shlExact(xv, yv) else @shrExact(xv, yv);
416417 for (@as([N]TX, z)) |v, i| {