╭ muladd.zig ───────────────────────────────────────────────────╮ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ ╰───────────────────────────────────────────────────────────────╯
🬂🬂🬒 🬂🬰🬂 🬑🬂🬀 ╭master╮ master xeubie: 🬋 🬋 🬃🬇🬋 │files │ commits refs discuss issues patches new login 🬯🬭🬭 🬭🬰🬭 🬟🬭🬑 ╰──────╯ (15882) user
╭ find file ─ ─ ─ ─ ─ ─ ─ ─ ─ ─╮ ╭────╮ ╭ clone ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ╮ │ │ │http│ ssh │ │ ╰ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─╯ ╰────╯ ╰ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ╯
.. conflicting_externs/ hasdecl/ import/ namespace_depends_on_compile_var/ pub_enum/ x86_64/ zon/ abs.zig addrspace_and_linksection.zig align.zig alignof.zig array.zig asm.zig atomics.zig backing_int.zig basic.zig bit_shifting.zig bitcast.zig bitreverse.zig bool.zig builtin_functions_returning_void_ byteswap.zig byval_arg_var.zig call.zig cast.zig cast_int.zig comptime_memory.zig const_slice_child.zig decl_literals.zig decltest.zig defer.zig destructure.zig duplicated_test_names.zig enum.zig error.zig eval.zig export_builtin.zig export_c_keywords.zig export_keyword.zig export_self_referential_type_info extern.zig extern_struct_zero_size_fields.zi field_parent_ptr.zig file_to_embed.txt floatop.zig fn.zig fn_delegation.zig fn_in_struct_in_comptime.zig for.zig generics.zig globals.zig hasdecl.zig hasfield.zig if.zig import.zig import_c_keywords.zig incomplete_struct_param_tld.zig inline_switch.zig int128.zig int_comparison_elision.zig ir_block_deps.zig lower_strlit_to_vector.zig math.zig maximum_minimum.zig member_func.zig memcpy.zig memmove.zig memset.zig merge_error_sets.zig ╭─────────────────────────────────╮ │muladd.zig │ ╰─────────────────────────────────╯ multiple_externs_with_conflicting namespace_depends_on_compile_var. nan.zig null.zig optional.zig overlapping_assign.zig packed-struct.zig packed-union.zig packed_struct_explicit_backing_in pointers.zig popcount.zig prefetch.zig ptrcast.zig ptrfromint.zig pub_enum.zig ref_var_in_if_after_if_2nd_switch reflection.zig return_address.zig saturating_arithmetic.zig select.zig shuffle.zig sizeof_and_typeof.zig slice.zig slice_sentinel_comptime.zig spirv.zig splat.zig src.zig string_literals.zig struct.zig struct_contains_null_ptr_itself.z struct_contains_slice_of_itself.z switch.zig switch_loop.zig switch_on_captured_error.zig switch_prong_err_enum.zig switch_prong_implicit_cast.zig this.zig threadlocal.zig truncate.zig try.zig tuple.zig tuple_declarations.zig type.zig type_info.zig typename.zig undefined.zig underscore.zig union.zig var_args.zig vector.zig void.zig wasm.zig while.zig widening.zig wrapping_arithmetic.zig x86_64.zig zero.bin zon.zig
1 const std = @import("std"); 2 const builtin = @import("builtin"); 3 const expect = std.testing.expect; 4 5 test "@mulAdd" { 6 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO 7 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO 8 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest; 9 10 try comptime testMulAdd(); 11 try testMulAdd(); 12 } 13 14 fn testMulAdd() !void { 15 { 16 var a: f32 = 5.5; 17 var b: f32 = 2.5; 18 var c: f32 = 6.25; 19 _ = .{ &a, &b, &c }; 20 try expect(@mulAdd(f32, a, b, c) == 20); 21 } 22 { 23 var a: f64 = 5.5; 24 var b: f64 = 2.5; 25 var c: f64 = 6.25; 26 _ = .{ &a, &b, &c }; 27 try expect(@mulAdd(f64, a, b, c) == 20); 28 } 29 } 30 31 test "@mulAdd f16" { 32 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO 33 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO 34 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest; 35 36 try comptime testMulAdd16(); 37 try testMulAdd16(); 38 } 39 40 fn testMulAdd16() !void { 41 var a: f16 = 5.5; 42 var b: f16 = 2.5; 43 var c: f16 = 6.25; 44 _ = .{ &a, &b, &c }; 45 try expect(@mulAdd(f16, a, b, c) == 20); 46 } 47 48 test "@mulAdd f80" { 49 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO 50 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO 51 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest; 52 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest; 53 54 try comptime testMulAdd80(); 55 try testMulAdd80(); 56 } 57 58 fn testMulAdd80() !void { 59 var a: f16 = 5.5; 60 var b: f80 = 2.5; 61 var c: f80 = 6.25; 62 _ = .{ &a, &b, &c }; 63 try expect(@mulAdd(f80, a, b, c) == 20); 64 } 65 66 test "@mulAdd f128" { 67 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO 68 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO 69 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest; 70 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest; 71 72 try comptime testMulAdd128(); 73 try testMulAdd128(); 74 } 75 76 fn testMulAdd128() !void { 77 var a: f16 = 5.5; 78 var b: f128 = 2.5; 79 var c: f128 = 6.25; 80 _ = .{ &a, &b, &c }; 81 try expect(@mulAdd(f128, a, b, c) == 20); 82 } 83 84 fn vector16() !void { 85 var a = @Vector(4, f16){ 5.5, 5.5, 5.5, 5.5 }; 86 var b = @Vector(4, f16){ 2.5, 2.5, 2.5, 2.5 }; 87 var c = @Vector(4, f16){ 6.25, 6.25, 6.25, 6.25 }; 88 _ = .{ &a, &b, &c }; 89 const x = @mulAdd(@Vector(4, f16), a, b, c); 90 91 try expect(x[0] == 20); 92 try expect(x[1] == 20); 93 try expect(x[2] == 20); 94 try expect(x[3] == 20); 95 } 96 97 test "vector f16" { 98 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; 99 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO 100 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO 101 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest; 102 103 try comptime vector16(); 104 try vector16(); 105 } 106 107 fn vector32() !void { 108 var a = @Vector(4, f32){ 5.5, 5.5, 5.5, 5.5 }; 109 var b = @Vector(4, f32){ 2.5, 2.5, 2.5, 2.5 }; 110 var c = @Vector(4, f32){ 6.25, 6.25, 6.25, 6.25 }; 111 _ = .{ &a, &b, &c }; 112 const x = @mulAdd(@Vector(4, f32), a, b, c); 113 114 try expect(x[0] == 20); 115 try expect(x[1] == 20); 116 try expect(x[2] == 20); 117 try expect(x[3] == 20); 118 } 119 120 test "vector f32" { 121 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; 122 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO 123 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO 124 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest; 125 126 try comptime vector32(); 127 try vector32(); 128 } 129 130 fn vector64() !void { 131 var a = @Vector(4, f64){ 5.5, 5.5, 5.5, 5.5 }; 132 var b = @Vector(4, f64){ 2.5, 2.5, 2.5, 2.5 }; 133 var c = @Vector(4, f64){ 6.25, 6.25, 6.25, 6.25 }; 134 _ = .{ &a, &b, &c }; 135 const x = @mulAdd(@Vector(4, f64), a, b, c); 136 137 try expect(x[0] == 20); 138 try expect(x[1] == 20); 139 try expect(x[2] == 20); 140 try expect(x[3] == 20); 141 } 142 143 test "vector f64" { 144 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; 145 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO 146 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO 147 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest; 148 149 try comptime vector64(); 150 try vector64(); 151 } 152 153 fn vector80() !void { 154 var a = @Vector(4, f80){ 5.5, 5.5, 5.5, 5.5 }; 155 var b = @Vector(4, f80){ 2.5, 2.5, 2.5, 2.5 }; 156 var c = @Vector(4, f80){ 6.25, 6.25, 6.25, 6.25 }; 157 _ = .{ &a, &b, &c }; 158 const x = @mulAdd(@Vector(4, f80), a, b, c); 159 try expect(x[0] == 20); 160 try expect(x[1] == 20); 161 try expect(x[2] == 20); 162 try expect(x[3] == 20); 163 } 164 165 test "vector f80" { 166 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; 167 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO 168 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO 169 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest; 170 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest; 171 172 try comptime vector80(); 173 try vector80(); 174 } 175 176 fn vector128() !void { 177 var a = @Vector(4, f128){ 5.5, 5.5, 5.5, 5.5 }; 178 var b = @Vector(4, f128){ 2.5, 2.5, 2.5, 2.5 }; 179 var c = @Vector(4, f128){ 6.25, 6.25, 6.25, 6.25 }; 180 _ = .{ &a, &b, &c }; 181 const x = @mulAdd(@Vector(4, f128), a, b, c); 182 183 try expect(x[0] == 20); 184 try expect(x[1] == 20); 185 try expect(x[2] == 20); 186 try expect(x[3] == 20); 187 } 188 189 test "vector f128" { 190 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; 191 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO 192 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO 193 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest; 194 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest; 195 196 try comptime vector128(); 197 try vector128(); 198 } 199