authorgravatar for andrew@ziglang.orgAndrew Kelley <andrew@ziglang.org> 2020-01-02 16:10:41-05:00
committergravatar for noreply@github.comGitHub <noreply@github.com> 2020-01-02 16:10:41-05:00
loga90fa45ae146a72e2d54842eed15c4b50062eff1
tree7845fbd8a52ca2f7c6ddf9e157affd9d01c2191a
parentfe21d84c94e16db56cf6f87040a02213615873a4
parent213ff939f18f147b5d9dd164d52ebdd660dab7b4
signature Signed by PGP key 4AEE18F83AFDEB23

Merge pull request #4027 from ziglang/fix-float-ops

fix float ops with respect to vectors

10 files changed, 501 insertions(+), 281 deletions(-)

doc/langref.html.in+82-30
......@@ -8076,94 +8076,146 @@ test "vector @splat" {
80768076 {#header_close#}
80778077
80788078 {#header_open|@sqrt#}
8079 <pre>{#syntax#}@sqrt(comptime T: type, value: T) T{#endsyntax#}</pre>
8079 <pre>{#syntax#}@sqrt(value: var) @TypeOf(value){#endsyntax#}</pre>
80808080 <p>
80818081 Performs the square root of a floating point number. Uses a dedicated hardware instruction
8082 when available. Supports {#syntax#}f16{#endsyntax#}, {#syntax#}f32{#endsyntax#}, {#syntax#}f64{#endsyntax#}, and {#syntax#}f128{#endsyntax#}, as well as vectors.
8082 when available.
8083 </p>
8084 <p>
8085 Supports {#link|Floats#} and {#link|Vectors#} of floats, with the caveat that
8086 <a href="https://github.com/ziglang/zig/issues/4026">some float operations are not yet implemented for all float types</a>.
80838087 </p>
80848088 {#header_close#}
80858089 {#header_open|@sin#}
8086 <pre>{#syntax#}@sin(comptime T: type, value: T) T{#endsyntax#}</pre>
8090 <pre>{#syntax#}@sin(value: var) @TypeOf(value){#endsyntax#}</pre>
80878091 <p>
80888092 Sine trigometric function on a floating point number. Uses a dedicated hardware instruction
8089 when available. Currently supports {#syntax#}f32{#endsyntax#} and {#syntax#}f64{#endsyntax#}.
8093 when available.
8094 </p>
8095 <p>
8096 Supports {#link|Floats#} and {#link|Vectors#} of floats, with the caveat that
8097 <a href="https://github.com/ziglang/zig/issues/4026">some float operations are not yet implemented for all float types</a>.
80908098 </p>
80918099 {#header_close#}
80928100 {#header_open|@cos#}
8093 <pre>{#syntax#}@cos(comptime T: type, value: T) T{#endsyntax#}</pre>
8101 <pre>{#syntax#}@cos(value: var) @TypeOf(value){#endsyntax#}</pre>
80948102 <p>
80958103 Cosine trigometric function on a floating point number. Uses a dedicated hardware instruction
8096 when available. Currently supports {#syntax#}f32{#endsyntax#} and {#syntax#}f64{#endsyntax#}.
8104 when available.
8105 </p>
8106 <p>
8107 Supports {#link|Floats#} and {#link|Vectors#} of floats, with the caveat that
8108 <a href="https://github.com/ziglang/zig/issues/4026">some float operations are not yet implemented for all float types</a>.
80978109 </p>
80988110 {#header_close#}
80998111 {#header_open|@exp#}
8100 <pre>{#syntax#}@exp(comptime T: type, value: T) T{#endsyntax#}</pre>
8112 <pre>{#syntax#}@exp(value: var) @TypeOf(value){#endsyntax#}</pre>
81018113 <p>
81028114 Base-e exponential function on a floating point number. Uses a dedicated hardware instruction
8103 when available. Currently supports {#syntax#}f32{#endsyntax#} and {#syntax#}f64{#endsyntax#}.
8115 when available.
8116 </p>
8117 <p>
8118 Supports {#link|Floats#} and {#link|Vectors#} of floats, with the caveat that
8119 <a href="https://github.com/ziglang/zig/issues/4026">some float operations are not yet implemented for all float types</a>.
81048120 </p>
81058121 {#header_close#}
81068122 {#header_open|@exp2#}
8107 <pre>{#syntax#}@exp2(comptime T: type, value: T) T{#endsyntax#}</pre>
8123 <pre>{#syntax#}@exp2(value: var) @TypeOf(value){#endsyntax#}</pre>
81088124 <p>
81098125 Base-2 exponential function on a floating point number. Uses a dedicated hardware instruction
8110 when available. Currently supports {#syntax#}f32{#endsyntax#} and {#syntax#}f64{#endsyntax#}.
8126 when available.
8127 </p>
8128 <p>
8129 Supports {#link|Floats#} and {#link|Vectors#} of floats, with the caveat that
8130 <a href="https://github.com/ziglang/zig/issues/4026">some float operations are not yet implemented for all float types</a>.
81118131 </p>
81128132 {#header_close#}
8113 {#header_open|@ln#}
8114 <pre>{#syntax#}@ln(comptime T: type, value: T) T{#endsyntax#}</pre>
8133 {#header_open|@log#}
8134 <pre>{#syntax#}@log(value: var) @TypeOf(value){#endsyntax#}</pre>
81158135 <p>
81168136 Returns the natural logarithm of a floating point number. Uses a dedicated hardware instruction
8117 when available. Currently supports {#syntax#}f32{#endsyntax#} and {#syntax#}f64{#endsyntax#}.
8137 when available.
8138 </p>
8139 <p>
8140 Supports {#link|Floats#} and {#link|Vectors#} of floats, with the caveat that
8141 <a href="https://github.com/ziglang/zig/issues/4026">some float operations are not yet implemented for all float types</a>.
81188142 </p>
81198143 {#header_close#}
81208144 {#header_open|@log2#}
8121 <pre>{#syntax#}@log2(comptime T: type, value: T) T{#endsyntax#}</pre>
8145 <pre>{#syntax#}@log2(value: var) @TypeOf(value){#endsyntax#}</pre>
81228146 <p>
81238147 Returns the logarithm to the base 2 of a floating point number. Uses a dedicated hardware instruction
8124 when available. Currently supports {#syntax#}f32{#endsyntax#} and {#syntax#}f64{#endsyntax#}.
8148 when available.
8149 </p>
8150 <p>
8151 Supports {#link|Floats#} and {#link|Vectors#} of floats, with the caveat that
8152 <a href="https://github.com/ziglang/zig/issues/4026">some float operations are not yet implemented for all float types</a>.
81258153 </p>
81268154 {#header_close#}
81278155 {#header_open|@log10#}
8128 <pre>{#syntax#}@log10(comptime T: type, value: T) T{#endsyntax#}</pre>
8156 <pre>{#syntax#}@log10(value: var) @TypeOf(value){#endsyntax#}</pre>
81298157 <p>
81308158 Returns the logarithm to the base 10 of a floating point number. Uses a dedicated hardware instruction
8131 when available. Currently supports {#syntax#}f32{#endsyntax#} and {#syntax#}f64{#endsyntax#}.
8159 when available.
8160 </p>
8161 <p>
8162 Supports {#link|Floats#} and {#link|Vectors#} of floats, with the caveat that
8163 <a href="https://github.com/ziglang/zig/issues/4026">some float operations are not yet implemented for all float types</a>.
81328164 </p>
81338165 {#header_close#}
81348166 {#header_open|@fabs#}
8135 <pre>{#syntax#}@fabs(comptime T: type, value: T) T{#endsyntax#}</pre>
8167 <pre>{#syntax#}@fabs(value: var) @TypeOf(value){#endsyntax#}</pre>
81368168 <p>
81378169 Returns the absolute value of a floating point number. Uses a dedicated hardware instruction
8138 when available. Currently supports {#syntax#}f32{#endsyntax#} and {#syntax#}f64{#endsyntax#}.
8170 when available.
8171 </p>
8172 <p>
8173 Supports {#link|Floats#} and {#link|Vectors#} of floats, with the caveat that
8174 <a href="https://github.com/ziglang/zig/issues/4026">some float operations are not yet implemented for all float types</a>.
81398175 </p>
81408176 {#header_close#}
81418177 {#header_open|@floor#}
8142 <pre>{#syntax#}@floor(comptime T: type, value: T) T{#endsyntax#}</pre>
8178 <pre>{#syntax#}@floor(value: var) @TypeOf(value){#endsyntax#}</pre>
8179 <p>
8180 Returns the largest integral value not greater than the given floating point number.
8181 Uses a dedicated hardware instruction when available.
8182 </p>
81438183 <p>
8144 Returns the largest integral value not greater than the given floating point number. Uses a dedicated hardware instruction
8145 when available. Currently supports {#syntax#}f32{#endsyntax#} and {#syntax#}f64{#endsyntax#}.
8184 Supports {#link|Floats#} and {#link|Vectors#} of floats, with the caveat that
8185 <a href="https://github.com/ziglang/zig/issues/4026">some float operations are not yet implemented for all float types</a>.
81468186 </p>
81478187 {#header_close#}
81488188 {#header_open|@ceil#}
8149 <pre>{#syntax#}@ceil(comptime T: type, value: T) T{#endsyntax#}</pre>
8189 <pre>{#syntax#}@ceil(value: var) @TypeOf(value){#endsyntax#}</pre>
81508190 <p>
8151 Returns the largest integral value not less than the given floating point number. Uses a dedicated hardware instruction
8152 when available. Currently supports {#syntax#}f32{#endsyntax#} and {#syntax#}f64{#endsyntax#}.
8191 Returns the largest integral value not less than the given floating point number.
8192 Uses a dedicated hardware instruction when available.
8193 </p>
8194 <p>
8195 Supports {#link|Floats#} and {#link|Vectors#} of floats, with the caveat that
8196 <a href="https://github.com/ziglang/zig/issues/4026">some float operations are not yet implemented for all float types</a>.
81538197 </p>
81548198 {#header_close#}
81558199 {#header_open|@trunc#}
8156 <pre>{#syntax#}@trunc(comptime T: type, value: T) T{#endsyntax#}</pre>
8200 <pre>{#syntax#}@trunc(value: var) @TypeOf(value){#endsyntax#}</pre>
8201 <p>
8202 Rounds the given floating point number to an integer, towards zero.
8203 Uses a dedicated hardware instruction when available.
8204 </p>
81578205 <p>
8158 Rounds the given floating point number to an integer, towards zero. Uses a dedicated hardware instruction
8159 when available. Currently supports {#syntax#}f32{#endsyntax#} and {#syntax#}f64{#endsyntax#}.
8206 Supports {#link|Floats#} and {#link|Vectors#} of floats, with the caveat that
8207 <a href="https://github.com/ziglang/zig/issues/4026">some float operations are not yet implemented for all float types</a>.
81608208 </p>
81618209 {#header_close#}
81628210 {#header_open|@round#}
8163 <pre>{#syntax#}@round(comptime T: type, value: T) T{#endsyntax#}</pre>
8211 <pre>{#syntax#}@round(value: var) @TypeOf(value){#endsyntax#}</pre>
81648212 <p>
81658213 Rounds the given floating point number to an integer, away from zero. Uses a dedicated hardware instruction
8166 when available. Currently supports {#syntax#}f32{#endsyntax#} and {#syntax#}f64{#endsyntax#}.
8214 when available.
8215 </p>
8216 <p>
8217 Supports {#link|Floats#} and {#link|Vectors#} of floats, with the caveat that
8218 <a href="https://github.com/ziglang/zig/issues/4026">some float operations are not yet implemented for all float types</a>.
81678219 </p>
81688220 {#header_close#}
81698221
lib/std/math/sqrt.zig+15-78
......@@ -12,12 +12,12 @@ const maxInt = std.math.maxInt;
1212/// - sqrt(+-0) = +-0
1313/// - sqrt(x) = nan if x < 0
1414/// - sqrt(nan) = nan
15pub fn sqrt(x: var) (if (@typeId(@TypeOf(x)) == TypeId.Int) @IntType(false, @TypeOf(x).bit_count / 2) else @TypeOf(x)) {
15/// TODO Decide if all this logic should be implemented directly in the @sqrt bultin function.
16pub fn sqrt(x: var) Sqrt(@TypeOf(x)) {
1617 const T = @TypeOf(x);
17 switch (@typeId(T)) {
18 TypeId.ComptimeFloat => return @as(T, @sqrt(f64, x)), // TODO upgrade to f128
19 TypeId.Float => return @sqrt(T, x),
20 TypeId.ComptimeInt => comptime {
18 switch (@typeInfo(T)) {
19 .Float, .ComptimeFloat => return @sqrt(x),
20 .ComptimeInt => comptime {
2121 if (x > maxInt(u128)) {
2222 @compileError("sqrt not implemented for comptime_int greater than 128 bits");
2323 }
......@@ -26,83 +26,11 @@ pub fn sqrt(x: var) (if (@typeId(@TypeOf(x)) == TypeId.Int) @IntType(false, @Typ
2626 }
2727 return @as(T, sqrt_int(u128, x));
2828 },
29 TypeId.Int => return sqrt_int(T, x),
29 .Int => return sqrt_int(T, x),
3030 else => @compileError("sqrt not implemented for " ++ @typeName(T)),
3131 }
3232}
3333
34test "math.sqrt" {
35 expect(sqrt(@as(f16, 0.0)) == @sqrt(f16, 0.0));
36 expect(sqrt(@as(f32, 0.0)) == @sqrt(f32, 0.0));
37 expect(sqrt(@as(f64, 0.0)) == @sqrt(f64, 0.0));
38}
39
40test "math.sqrt16" {
41 const epsilon = 0.000001;
42
43 expect(@sqrt(f16, 0.0) == 0.0);
44 expect(math.approxEq(f16, @sqrt(f16, 2.0), 1.414214, epsilon));
45 expect(math.approxEq(f16, @sqrt(f16, 3.6), 1.897367, epsilon));
46 expect(@sqrt(f16, 4.0) == 2.0);
47 expect(math.approxEq(f16, @sqrt(f16, 7.539840), 2.745877, epsilon));
48 expect(math.approxEq(f16, @sqrt(f16, 19.230934), 4.385309, epsilon));
49 expect(@sqrt(f16, 64.0) == 8.0);
50 expect(math.approxEq(f16, @sqrt(f16, 64.1), 8.006248, epsilon));
51 expect(math.approxEq(f16, @sqrt(f16, 8942.230469), 94.563370, epsilon));
52}
53
54test "math.sqrt32" {
55 const epsilon = 0.000001;
56
57 expect(@sqrt(f32, 0.0) == 0.0);
58 expect(math.approxEq(f32, @sqrt(f32, 2.0), 1.414214, epsilon));
59 expect(math.approxEq(f32, @sqrt(f32, 3.6), 1.897367, epsilon));
60 expect(@sqrt(f32, 4.0) == 2.0);
61 expect(math.approxEq(f32, @sqrt(f32, 7.539840), 2.745877, epsilon));
62 expect(math.approxEq(f32, @sqrt(f32, 19.230934), 4.385309, epsilon));
63 expect(@sqrt(f32, 64.0) == 8.0);
64 expect(math.approxEq(f32, @sqrt(f32, 64.1), 8.006248, epsilon));
65 expect(math.approxEq(f32, @sqrt(f32, 8942.230469), 94.563370, epsilon));
66}
67
68test "math.sqrt64" {
69 const epsilon = 0.000001;
70
71 expect(@sqrt(f64, 0.0) == 0.0);
72 expect(math.approxEq(f64, @sqrt(f64, 2.0), 1.414214, epsilon));
73 expect(math.approxEq(f64, @sqrt(f64, 3.6), 1.897367, epsilon));
74 expect(@sqrt(f64, 4.0) == 2.0);
75 expect(math.approxEq(f64, @sqrt(f64, 7.539840), 2.745877, epsilon));
76 expect(math.approxEq(f64, @sqrt(f64, 19.230934), 4.385309, epsilon));
77 expect(@sqrt(f64, 64.0) == 8.0);
78 expect(math.approxEq(f64, @sqrt(f64, 64.1), 8.006248, epsilon));
79 expect(math.approxEq(f64, @sqrt(f64, 8942.230469), 94.563367, epsilon));
80}
81
82test "math.sqrt16.special" {
83 expect(math.isPositiveInf(@sqrt(f16, math.inf(f16))));
84 expect(@sqrt(f16, 0.0) == 0.0);
85 expect(@sqrt(f16, -0.0) == -0.0);
86 expect(math.isNan(@sqrt(f16, -1.0)));
87 expect(math.isNan(@sqrt(f16, math.nan(f16))));
88}
89
90test "math.sqrt32.special" {
91 expect(math.isPositiveInf(@sqrt(f32, math.inf(f32))));
92 expect(@sqrt(f32, 0.0) == 0.0);
93 expect(@sqrt(f32, -0.0) == -0.0);
94 expect(math.isNan(@sqrt(f32, -1.0)));
95 expect(math.isNan(@sqrt(f32, math.nan(f32))));
96}
97
98test "math.sqrt64.special" {
99 expect(math.isPositiveInf(@sqrt(f64, math.inf(f64))));
100 expect(@sqrt(f64, 0.0) == 0.0);
101 expect(@sqrt(f64, -0.0) == -0.0);
102 expect(math.isNan(@sqrt(f64, -1.0)));
103 expect(math.isNan(@sqrt(f64, math.nan(f64))));
104}
105
10634fn sqrt_int(comptime T: type, value: T) @IntType(false, T.bit_count / 2) {
10735 var op = value;
10836 var res: T = 0;
......@@ -134,3 +62,12 @@ test "math.sqrt_int" {
13462 expect(sqrt_int(u32, 9) == 3);
13563 expect(sqrt_int(u32, 10) == 3);
13664}
65
66/// Returns the return type `sqrt` will return given an operand of type `T`.
67pub fn Sqrt(comptime T: type) type {
68 return switch (@typeInfo(T)) {
69 .Int => |int| @IntType(false, int.bits / 2),
70 else => T,
71 };
72}
73
lib/std/special/c.zig+46
......@@ -728,6 +728,29 @@ export fn sqrt(x: f64) f64 {
728728 return @bitCast(f64, uz);
729729}
730730
731test "sqrt" {
732 const epsilon = 0.000001;
733
734 std.testing.expect(sqrt(0.0) == 0.0);
735 std.testing.expect(std.math.approxEq(f64, sqrt(2.0), 1.414214, epsilon));
736 std.testing.expect(std.math.approxEq(f64, sqrt(3.6), 1.897367, epsilon));
737 std.testing.expect(sqrt(4.0) == 2.0);
738 std.testing.expect(std.math.approxEq(f64, sqrt(7.539840), 2.745877, epsilon));
739 std.testing.expect(std.math.approxEq(f64, sqrt(19.230934), 4.385309, epsilon));
740 std.testing.expect(sqrt(64.0) == 8.0);
741 std.testing.expect(std.math.approxEq(f64, sqrt(64.1), 8.006248, epsilon));
742 std.testing.expect(std.math.approxEq(f64, sqrt(8942.230469), 94.563367, epsilon));
743}
744
745test "sqrt special" {
746 std.testing.expect(std.math.isPositiveInf(sqrt(std.math.inf(f64))));
747 std.testing.expect(sqrt(0.0) == 0.0);
748 std.testing.expect(sqrt(-0.0) == -0.0);
749 std.testing.expect(std.math.isNan(sqrt(-1.0)));
750 std.testing.expect(std.math.isNan(sqrt(std.math.nan(f64))));
751}
752
753
731754export fn sqrtf(x: f32) f32 {
732755 const tiny: f32 = 1.0e-30;
733756 const sign: i32 = @bitCast(i32, @as(u32, 0x80000000));
......@@ -803,3 +826,26 @@ export fn sqrtf(x: f32) f32 {
803826 ix += m << 23;
804827 return @bitCast(f32, ix);
805828}
829
830test "sqrtf" {
831 const epsilon = 0.000001;
832
833 std.testing.expect(sqrtf(0.0) == 0.0);
834 std.testing.expect(std.math.approxEq(f32, sqrtf(2.0), 1.414214, epsilon));
835 std.testing.expect(std.math.approxEq(f32, sqrtf(3.6), 1.897367, epsilon));
836 std.testing.expect(sqrtf(4.0) == 2.0);
837 std.testing.expect(std.math.approxEq(f32, sqrtf(7.539840), 2.745877, epsilon));
838 std.testing.expect(std.math.approxEq(f32, sqrtf(19.230934), 4.385309, epsilon));
839 std.testing.expect(sqrtf(64.0) == 8.0);
840 std.testing.expect(std.math.approxEq(f32, sqrtf(64.1), 8.006248, epsilon));
841 std.testing.expect(std.math.approxEq(f32, sqrtf(8942.230469), 94.563370, epsilon));
842}
843
844test "sqrtf special" {
845 std.testing.expect(std.math.isPositiveInf(sqrtf(std.math.inf(f32))));
846 std.testing.expect(sqrtf(0.0) == 0.0);
847 std.testing.expect(sqrtf(-0.0) == -0.0);
848 std.testing.expect(std.math.isNan(sqrtf(-1.0)));
849 std.testing.expect(std.math.isNan(sqrtf(std.math.nan(f32))));
850}
851
src/all_types.hpp+3-4
......@@ -1680,7 +1680,7 @@ enum BuiltinFnId {
16801680 BuiltinFnIdCos,
16811681 BuiltinFnIdExp,
16821682 BuiltinFnIdExp2,
1683 BuiltinFnIdLn,
1683 BuiltinFnIdLog,
16841684 BuiltinFnIdLog2,
16851685 BuiltinFnIdLog10,
16861686 BuiltinFnIdFabs,
......@@ -3840,9 +3840,8 @@ struct IrInstructionAddImplicitReturnType {
38403840struct IrInstructionFloatOp {
38413841 IrInstruction base;
38423842
3843 BuiltinFnId op;
3844 IrInstruction *type;
3845 IrInstruction *op1;
3843 BuiltinFnId fn_id;
3844 IrInstruction *operand;
38463845};
38473846
38483847struct IrInstructionCheckRuntimeScope {
src/codegen.cpp+18-19
......@@ -764,7 +764,7 @@ static LLVMValueRef get_float_fn(CodeGen *g, ZigType *type_entry, ZigLLVMFnId fn
764764 name = "fma";
765765 num_args = 3;
766766 } else if (fn_id == ZigLLVMFnIdFloatOp) {
767 name = float_op_to_name(op, true);
767 name = float_op_to_name(op);
768768 num_args = 1;
769769 } else {
770770 zig_unreachable();
......@@ -5785,10 +5785,9 @@ static LLVMValueRef ir_render_atomic_store(CodeGen *g, IrExecutable *executable,
57855785}
57865786
57875787static LLVMValueRef ir_render_float_op(CodeGen *g, IrExecutable *executable, IrInstructionFloatOp *instruction) {
5788 LLVMValueRef op = ir_llvm_value(g, instruction->op1);
5789 assert(instruction->base.value->type->id == ZigTypeIdFloat);
5790 LLVMValueRef fn_val = get_float_fn(g, instruction->base.value->type, ZigLLVMFnIdFloatOp, instruction->op);
5791 return LLVMBuildCall(g->builder, fn_val, &op, 1, "");
5788 LLVMValueRef operand = ir_llvm_value(g, instruction->operand);
5789 LLVMValueRef fn_val = get_float_fn(g, instruction->base.value->type, ZigLLVMFnIdFloatOp, instruction->fn_id);
5790 return LLVMBuildCall(g->builder, fn_val, &operand, 1, "");
57925791}
57935792
57945793static LLVMValueRef ir_render_mul_add(CodeGen *g, IrExecutable *executable, IrInstructionMulAdd *instruction) {
......@@ -8201,20 +8200,20 @@ static void define_builtin_fns(CodeGen *g) {
82018200 create_builtin_fn(g, BuiltinFnIdDivFloor, "divFloor", 2);
82028201 create_builtin_fn(g, BuiltinFnIdRem, "rem", 2);
82038202 create_builtin_fn(g, BuiltinFnIdMod, "mod", 2);
8204 create_builtin_fn(g, BuiltinFnIdSqrt, "sqrt", 2);
8205 create_builtin_fn(g, BuiltinFnIdSin, "sin", 2);
8206 create_builtin_fn(g, BuiltinFnIdCos, "cos", 2);
8207 create_builtin_fn(g, BuiltinFnIdExp, "exp", 2);
8208 create_builtin_fn(g, BuiltinFnIdExp2, "exp2", 2);
8209 create_builtin_fn(g, BuiltinFnIdLn, "ln", 2);
8210 create_builtin_fn(g, BuiltinFnIdLog2, "log2", 2);
8211 create_builtin_fn(g, BuiltinFnIdLog10, "log10", 2);
8212 create_builtin_fn(g, BuiltinFnIdFabs, "fabs", 2);
8213 create_builtin_fn(g, BuiltinFnIdFloor, "floor", 2);
8214 create_builtin_fn(g, BuiltinFnIdCeil, "ceil", 2);
8215 create_builtin_fn(g, BuiltinFnIdTrunc, "trunc", 2);
8216 create_builtin_fn(g, BuiltinFnIdNearbyInt, "nearbyInt", 2);
8217 create_builtin_fn(g, BuiltinFnIdRound, "round", 2);
8203 create_builtin_fn(g, BuiltinFnIdSqrt, "sqrt", 1);
8204 create_builtin_fn(g, BuiltinFnIdSin, "sin", 1);
8205 create_builtin_fn(g, BuiltinFnIdCos, "cos", 1);
8206 create_builtin_fn(g, BuiltinFnIdExp, "exp", 1);
8207 create_builtin_fn(g, BuiltinFnIdExp2, "exp2", 1);
8208 create_builtin_fn(g, BuiltinFnIdLog, "log", 1);
8209 create_builtin_fn(g, BuiltinFnIdLog2, "log2", 1);
8210 create_builtin_fn(g, BuiltinFnIdLog10, "log10", 1);
8211 create_builtin_fn(g, BuiltinFnIdFabs, "fabs", 1);
8212 create_builtin_fn(g, BuiltinFnIdFloor, "floor", 1);
8213 create_builtin_fn(g, BuiltinFnIdCeil, "ceil", 1);
8214 create_builtin_fn(g, BuiltinFnIdTrunc, "trunc", 1);
8215 create_builtin_fn(g, BuiltinFnIdNearbyInt, "nearbyInt", 1);
8216 create_builtin_fn(g, BuiltinFnIdRound, "round", 1);
82188217 create_builtin_fn(g, BuiltinFnIdMulAdd, "mulAdd", 4);
82198218 create_builtin_fn(g, BuiltinFnIdNewStackCall, "newStackCall", SIZE_MAX);
82208219 create_builtin_fn(g, BuiltinFnIdAsyncCall, "asyncCall", SIZE_MAX);
src/ir.cpp+99-85
......@@ -3125,9 +3125,7 @@ static IrInstruction *ir_build_overflow_op(IrBuilder *irb, Scope *scope, AstNode
31253125//TODO Powi, Pow, minnum, maxnum, maximum, minimum, copysign,
31263126// lround, llround, lrint, llrint
31273127// So far this is only non-complicated type functions.
3128const char *float_op_to_name(BuiltinFnId op, bool llvm_name) {
3129 const bool b = llvm_name;
3130
3128const char *float_op_to_name(BuiltinFnId op) {
31313129 switch (op) {
31323130 case BuiltinFnIdSqrt:
31333131 return "sqrt";
......@@ -3139,8 +3137,8 @@ const char *float_op_to_name(BuiltinFnId op, bool llvm_name) {
31393137 return "exp";
31403138 case BuiltinFnIdExp2:
31413139 return "exp2";
3142 case BuiltinFnIdLn:
3143 return b ? "log" : "ln";
3140 case BuiltinFnIdLog:
3141 return "log";
31443142 case BuiltinFnIdLog10:
31453143 return "log10";
31463144 case BuiltinFnIdLog2:
......@@ -3154,7 +3152,7 @@ const char *float_op_to_name(BuiltinFnId op, bool llvm_name) {
31543152 case BuiltinFnIdTrunc:
31553153 return "trunc";
31563154 case BuiltinFnIdNearbyInt:
3157 return b ? "nearbyint" : "nearbyInt";
3155 return "nearbyint";
31583156 case BuiltinFnIdRound:
31593157 return "round";
31603158 default:
......@@ -3162,14 +3160,14 @@ const char *float_op_to_name(BuiltinFnId op, bool llvm_name) {
31623160 }
31633161}
31643162
3165static IrInstruction *ir_build_float_op(IrBuilder *irb, Scope *scope, AstNode *source_node, IrInstruction *type, IrInstruction *op1, BuiltinFnId op) {
3163static IrInstruction *ir_build_float_op(IrBuilder *irb, Scope *scope, AstNode *source_node, IrInstruction *operand,
3164 BuiltinFnId fn_id)
3165{
31663166 IrInstructionFloatOp *instruction = ir_build_instruction<IrInstructionFloatOp>(irb, scope, source_node);
3167 instruction->type = type;
3168 instruction->op1 = op1;
3169 instruction->op = op;
3167 instruction->operand = operand;
3168 instruction->fn_id = fn_id;
31703169
3171 if (type != nullptr) ir_ref_instruction(type, irb->current_basic_block);
3172 ir_ref_instruction(op1, irb->current_basic_block);
3170 ir_ref_instruction(operand, irb->current_basic_block);
31733171
31743172 return &instruction->base;
31753173}
......@@ -5497,7 +5495,7 @@ static IrInstruction *ir_gen_builtin_fn_call(IrBuilder *irb, Scope *scope, AstNo
54975495 case BuiltinFnIdCos:
54985496 case BuiltinFnIdExp:
54995497 case BuiltinFnIdExp2:
5500 case BuiltinFnIdLn:
5498 case BuiltinFnIdLog:
55015499 case BuiltinFnIdLog2:
55025500 case BuiltinFnIdLog10:
55035501 case BuiltinFnIdFabs:
......@@ -5512,13 +5510,8 @@ static IrInstruction *ir_gen_builtin_fn_call(IrBuilder *irb, Scope *scope, AstNo
55125510 if (arg0_value == irb->codegen->invalid_instruction)
55135511 return arg0_value;
55145512
5515 AstNode *arg1_node = node->data.fn_call_expr.params.at(1);
5516 IrInstruction *arg1_value = ir_gen_node(irb, arg1_node, scope);
5517 if (arg1_value == irb->codegen->invalid_instruction)
5518 return arg1_value;
5519
5520 IrInstruction *ir_sqrt = ir_build_float_op(irb, scope, node, arg0_value, arg1_value, builtin_fn->id);
5521 return ir_lval_wrap(irb, scope, ir_sqrt, lval, result_loc);
5513 IrInstruction *inst = ir_build_float_op(irb, scope, node, arg0_value, builtin_fn->id);
5514 return ir_lval_wrap(irb, scope, inst, lval, result_loc);
55225515 }
55235516 case BuiltinFnIdTruncate:
55245517 {
......@@ -27643,7 +27636,7 @@ static IrInstruction *ir_analyze_instruction_save_err_ret_addr(IrAnalyze *ira, I
2764327636 return result;
2764427637}
2764527638
27646static void ir_eval_float_op(IrAnalyze *ira, IrInstruction *source_instr, BuiltinFnId fop, ZigType *float_type,
27639static ErrorMsg *ir_eval_float_op(IrAnalyze *ira, IrInstruction *source_instr, BuiltinFnId fop, ZigType *float_type,
2764727640 ZigValue *op, ZigValue *out_val)
2764827641{
2764927642 assert(ira && source_instr && float_type && out_val && op);
......@@ -27670,24 +27663,49 @@ static void ir_eval_float_op(IrAnalyze *ira, IrInstruction *source_instr, Builti
2767027663 out_val->data.x_f16 = f16_sqrt(op->data.x_f16);
2767127664 break;
2767227665 case BuiltinFnIdSin:
27666 out_val->data.x_f16 = zig_double_to_f16(sin(zig_f16_to_double(op->data.x_f16)));
27667 break;
2767327668 case BuiltinFnIdCos:
27669 out_val->data.x_f16 = zig_double_to_f16(cos(zig_f16_to_double(op->data.x_f16)));
27670 break;
2767427671 case BuiltinFnIdExp:
27672 out_val->data.x_f16 = zig_double_to_f16(exp(zig_f16_to_double(op->data.x_f16)));
27673 break;
2767527674 case BuiltinFnIdExp2:
27676 case BuiltinFnIdLn:
27675 out_val->data.x_f16 = zig_double_to_f16(exp2(zig_f16_to_double(op->data.x_f16)));
27676 break;
27677 case BuiltinFnIdLog:
27678 out_val->data.x_f16 = zig_double_to_f16(log(zig_f16_to_double(op->data.x_f16)));
27679 break;
2767727680 case BuiltinFnIdLog10:
27681 out_val->data.x_f16 = zig_double_to_f16(log10(zig_f16_to_double(op->data.x_f16)));
27682 break;
2767827683 case BuiltinFnIdLog2:
27684 out_val->data.x_f16 = zig_double_to_f16(log2(zig_f16_to_double(op->data.x_f16)));
27685 break;
2767927686 case BuiltinFnIdFabs:
27687 out_val->data.x_f16 = zig_double_to_f16(fabs(zig_f16_to_double(op->data.x_f16)));
27688 break;
2768027689 case BuiltinFnIdFloor:
27690 out_val->data.x_f16 = zig_double_to_f16(floor(zig_f16_to_double(op->data.x_f16)));
27691 break;
2768127692 case BuiltinFnIdCeil:
27693 out_val->data.x_f16 = zig_double_to_f16(ceil(zig_f16_to_double(op->data.x_f16)));
27694 break;
2768227695 case BuiltinFnIdTrunc:
27696 out_val->data.x_f16 = zig_double_to_f16(trunc(zig_f16_to_double(op->data.x_f16)));
27697 break;
2768327698 case BuiltinFnIdNearbyInt:
27699 out_val->data.x_f16 = zig_double_to_f16(nearbyint(zig_f16_to_double(op->data.x_f16)));
27700 break;
2768427701 case BuiltinFnIdRound:
27685 zig_panic("unimplemented f16 builtin");
27702 out_val->data.x_f16 = zig_double_to_f16(round(zig_f16_to_double(op->data.x_f16)));
27703 break;
2768627704 default:
2768727705 zig_unreachable();
2768827706 };
2768927707 break;
27690 };
27708 }
2769127709 case 32: {
2769227710 switch (fop) {
2769327711 case BuiltinFnIdSqrt:
......@@ -27705,7 +27723,7 @@ static void ir_eval_float_op(IrAnalyze *ira, IrInstruction *source_instr, Builti
2770527723 case BuiltinFnIdExp2:
2770627724 out_val->data.x_f32 = exp2f(op->data.x_f32);
2770727725 break;
27708 case BuiltinFnIdLn:
27726 case BuiltinFnIdLog:
2770927727 out_val->data.x_f32 = logf(op->data.x_f32);
2771027728 break;
2771127729 case BuiltinFnIdLog10:
......@@ -27736,7 +27754,7 @@ static void ir_eval_float_op(IrAnalyze *ira, IrInstruction *source_instr, Builti
2773627754 zig_unreachable();
2773727755 };
2773827756 break;
27739 };
27757 }
2774027758 case 64: {
2774127759 switch (fop) {
2774227760 case BuiltinFnIdSqrt:
......@@ -27754,7 +27772,7 @@ static void ir_eval_float_op(IrAnalyze *ira, IrInstruction *source_instr, Builti
2775427772 case BuiltinFnIdExp2:
2775527773 out_val->data.x_f64 = exp2(op->data.x_f64);
2775627774 break;
27757 case BuiltinFnIdLn:
27775 case BuiltinFnIdLog:
2775827776 out_val->data.x_f64 = log(op->data.x_f64);
2775927777 break;
2776027778 case BuiltinFnIdLog10:
......@@ -27785,7 +27803,11 @@ static void ir_eval_float_op(IrAnalyze *ira, IrInstruction *source_instr, Builti
2778527803 zig_unreachable();
2778627804 }
2778727805 break;
27788 };
27806 }
27807 case 80:
27808 return ir_add_error(ira, source_instr,
27809 buf_sprintf("compiler bug: TODO: implement '%s' for type '%s'. See https://github.com/ziglang/zig/issues/4026",
27810 float_op_to_name(fop), buf_ptr(&float_type->name)));
2778927811 case 128: {
2779027812 float128_t *out, *in;
2779127813 if (float_type->id == ZigTypeIdComptimeFloat) {
......@@ -27804,7 +27826,7 @@ static void ir_eval_float_op(IrAnalyze *ira, IrInstruction *source_instr, Builti
2780427826 case BuiltinFnIdCos:
2780527827 case BuiltinFnIdExp:
2780627828 case BuiltinFnIdExp2:
27807 case BuiltinFnIdLn:
27829 case BuiltinFnIdLog:
2780827830 case BuiltinFnIdLog10:
2780927831 case BuiltinFnIdLog2:
2781027832 case BuiltinFnIdFabs:
......@@ -27812,94 +27834,86 @@ static void ir_eval_float_op(IrAnalyze *ira, IrInstruction *source_instr, Builti
2781227834 case BuiltinFnIdCeil:
2781327835 case BuiltinFnIdTrunc:
2781427836 case BuiltinFnIdRound:
27815 zig_panic("unimplemented f128 builtin");
27837 return ir_add_error(ira, source_instr,
27838 buf_sprintf("compiler bug: TODO: implement '%s' for type '%s'. See https://github.com/ziglang/zig/issues/4026",
27839 float_op_to_name(fop), buf_ptr(&float_type->name)));
2781627840 default:
2781727841 zig_unreachable();
2781827842 }
2781927843 break;
27820 };
27844 }
2782127845 default:
2782227846 zig_unreachable();
2782327847 }
27848 out_val->special = ConstValSpecialStatic;
27849 return nullptr;
2782427850}
2782527851
27826static IrInstruction *ir_analyze_float_op(IrAnalyze *ira, IrInstruction *source_instr,
27827 ZigType *expr_type, AstNode *expr_type_src_node, IrInstruction *operand, BuiltinFnId op)
27828{
27829 // Only allow float types, and vectors of floats.
27830 ZigType *float_type = (expr_type->id == ZigTypeIdVector) ? expr_type->data.vector.elem_type : expr_type;
27831 if (float_type->id != ZigTypeIdFloat && float_type->id != ZigTypeIdComptimeFloat) {
27832 ir_add_error_node(ira, expr_type_src_node,
27833 buf_sprintf("@%s does not support type '%s'",
27834 float_op_to_name(op, false), buf_ptr(&float_type->name)));
27852static IrInstruction *ir_analyze_instruction_float_op(IrAnalyze *ira, IrInstructionFloatOp *instruction) {
27853 IrInstruction *operand = instruction->operand->child;
27854 ZigType *operand_type = operand->value->type;
27855 if (type_is_invalid(operand_type))
2783527856 return ira->codegen->invalid_instruction;
27836 }
2783727857
27838 IrInstruction *casted_op = ir_implicit_cast(ira, operand, float_type);
27839 if (type_is_invalid(casted_op->value->type))
27840 return ira->codegen->invalid_instruction;
27858 // This instruction accepts floats and vectors of floats.
27859 ZigType *scalar_type = (operand_type->id == ZigTypeIdVector) ?
27860 operand_type->data.vector.elem_type : operand_type;
2784127861
27842 if (instr_is_comptime(casted_op)) {
27843 if ((float_type->id == ZigTypeIdComptimeFloat ||
27844 float_type->data.floating.bit_count == 16 ||
27845 float_type->data.floating.bit_count == 128) &&
27846 op != BuiltinFnIdSqrt)
27847 {
27848 ir_add_error(ira, source_instr,
27849 buf_sprintf("compiler bug: TODO make @%s support type '%s'",
27850 float_op_to_name(op, false), buf_ptr(&float_type->name)));
27851 return ira->codegen->invalid_instruction;
27852 }
27862 if (scalar_type->id != ZigTypeIdFloat && scalar_type->id != ZigTypeIdComptimeFloat) {
27863 ir_add_error(ira, operand,
27864 buf_sprintf("expected float type, found '%s'", buf_ptr(&scalar_type->name)));
27865 return ira->codegen->invalid_instruction;
27866 }
2785327867
27854 ZigValue *op1_const = ir_resolve_const(ira, casted_op, UndefBad);
27855 if (!op1_const)
27868 if (instr_is_comptime(operand)) {
27869 ZigValue *operand_val = ir_resolve_const(ira, operand, UndefOk);
27870 if (operand_val == nullptr)
2785627871 return ira->codegen->invalid_instruction;
27872 if (operand_val->special == ConstValSpecialUndef)
27873 return ir_const_undef(ira, &instruction->base, operand_type);
2785727874
27858 IrInstruction *result = ir_const(ira, source_instr, expr_type);
27875 IrInstruction *result = ir_const(ira, &instruction->base, operand_type);
2785927876 ZigValue *out_val = result->value;
2786027877
27861 if (expr_type->id == ZigTypeIdVector) {
27862 expand_undef_array(ira->codegen, op1_const);
27878 if (operand_type->id == ZigTypeIdVector) {
27879 expand_undef_array(ira->codegen, operand_val);
2786327880 out_val->special = ConstValSpecialUndef;
2786427881 expand_undef_array(ira->codegen, out_val);
27865 size_t len = expr_type->data.vector.len;
27882 size_t len = operand_type->data.vector.len;
2786627883 for (size_t i = 0; i < len; i += 1) {
27867 ZigValue *float_operand_op1 = &op1_const->data.x_array.data.s_none.elements[i];
27884 ZigValue *elem_operand = &operand_val->data.x_array.data.s_none.elements[i];
2786827885 ZigValue *float_out_val = &out_val->data.x_array.data.s_none.elements[i];
27869 assert(float_operand_op1->type == float_type);
27870 assert(float_out_val->type == float_type);
27871 ir_eval_float_op(ira, source_instr, op, float_type, op1_const, float_out_val);
27872 float_out_val->type = float_type;
27886 ir_assert(elem_operand->type == scalar_type, &instruction->base);
27887 ir_assert(float_out_val->type == scalar_type, &instruction->base);
27888 ErrorMsg *msg = ir_eval_float_op(ira, &instruction->base, instruction->fn_id, scalar_type,
27889 elem_operand, float_out_val);
27890 if (msg != nullptr) {
27891 add_error_note(ira->codegen, msg, instruction->base.source_node,
27892 buf_sprintf("when computing vector element at index %" ZIG_PRI_usize, i));
27893 return ira->codegen->invalid_instruction;
27894 }
27895 float_out_val->type = scalar_type;
2787327896 }
27874 out_val->type = expr_type;
27897 out_val->type = operand_type;
2787527898 out_val->special = ConstValSpecialStatic;
2787627899 } else {
27877 ir_eval_float_op(ira, source_instr, op, float_type, op1_const, out_val);
27900 if (ir_eval_float_op(ira, &instruction->base, instruction->fn_id, scalar_type,
27901 operand_val, out_val) != nullptr)
27902 {
27903 return ira->codegen->invalid_instruction;
27904 }
2787827905 }
2787927906 return result;
2788027907 }
2788127908
27882 ir_assert(float_type->id == ZigTypeIdFloat, source_instr);
27909 ir_assert(scalar_type->id == ZigTypeIdFloat, &instruction->base);
2788327910
27884 IrInstruction *result = ir_build_float_op(&ira->new_irb, source_instr->scope,
27885 source_instr->source_node, nullptr, casted_op, op);
27886 result->value->type = expr_type;
27911 IrInstruction *result = ir_build_float_op(&ira->new_irb, instruction->base.scope,
27912 instruction->base.source_node, operand, instruction->fn_id);
27913 result->value->type = operand_type;
2788727914 return result;
2788827915}
2788927916
27890static IrInstruction *ir_analyze_instruction_float_op(IrAnalyze *ira, IrInstructionFloatOp *instruction) {
27891 ZigType *expr_type = ir_resolve_type(ira, instruction->type->child);
27892 if (type_is_invalid(expr_type))
27893 return ira->codegen->invalid_instruction;
27894
27895 IrInstruction *operand = instruction->op1->child;
27896 if (type_is_invalid(operand->value->type))
27897 return ira->codegen->invalid_instruction;
27898
27899 return ir_analyze_float_op(ira, &instruction->base, expr_type, instruction->type->source_node,
27900 operand, instruction->op);
27901}
27902
2790327917static IrInstruction *ir_analyze_instruction_bswap(IrAnalyze *ira, IrInstructionBswap *instruction) {
2790427918 Error err;
2790527919
src/ir.hpp+1-1
......@@ -33,7 +33,7 @@ bool ir_has_side_effects(IrInstruction *instruction);
3333struct IrAnalyze;
3434ZigValue *const_ptr_pointee(IrAnalyze *ira, CodeGen *codegen, ZigValue *const_val,
3535 AstNode *source_node);
36const char *float_op_to_name(BuiltinFnId op, bool llvm_name);
36const char *float_op_to_name(BuiltinFnId op);
3737
3838// for debugging purposes
3939void dbg_ir_break(const char *src_file, uint32_t line);
src/ir_print.cpp+2-9
......@@ -2005,15 +2005,8 @@ static void ir_print_add_implicit_return_type(IrPrint *irp, IrInstructionAddImpl
20052005}
20062006
20072007static void ir_print_float_op(IrPrint *irp, IrInstructionFloatOp *instruction) {
2008
2009 fprintf(irp->f, "@%s(", float_op_to_name(instruction->op, false));
2010 if (instruction->type != nullptr) {
2011 ir_print_other_instruction(irp, instruction->type);
2012 } else {
2013 fprintf(irp->f, "null");
2014 }
2015 fprintf(irp->f, ",");
2016 ir_print_other_instruction(irp, instruction->op1);
2008 fprintf(irp->f, "@%s(", float_op_to_name(instruction->fn_id));
2009 ir_print_other_instruction(irp, instruction->operand);
20172010 fprintf(irp->f, ")");
20182011}
20192012
test/stage1/behavior/floatop.zig+233-53
......@@ -1,6 +1,10 @@
1const expect = @import("std").testing.expect;
2const pi = @import("std").math.pi;
3const e = @import("std").math.e;
1const std = @import("std");
2const expect = std.testing.expect;
3const math = std.math;
4const pi = std.math.pi;
5const e = std.math.e;
6
7const epsilon = 0.000001;
48
59test "@sqrt" {
610 comptime testSqrt();
......@@ -10,25 +14,55 @@ test "@sqrt" {
1014fn testSqrt() void {
1115 {
1216 var a: f16 = 4;
13 expect(@sqrt(f16, a) == 2);
17 expect(@sqrt(a) == 2);
1418 }
1519 {
1620 var a: f32 = 9;
17 expect(@sqrt(f32, a) == 3);
21 expect(@sqrt(a) == 3);
22 var b: f32 = 1.1;
23 expect(math.approxEq(f32, @sqrt(b), 1.0488088481701516, epsilon));
1824 }
1925 {
2026 var a: f64 = 25;
21 expect(@sqrt(f64, a) == 5);
27 expect(@sqrt(a) == 5);
2228 }
2329 {
2430 const a: comptime_float = 25.0;
25 expect(@sqrt(comptime_float, a) == 5.0);
31 expect(@sqrt(a) == 5.0);
2632 }
27 // Waiting on a c.zig implementation
33 // TODO https://github.com/ziglang/zig/issues/4026
2834 //{
2935 // var a: f128 = 49;
30 // expect(@sqrt(f128, a) == 7);
36 // expect(@sqrt(a) == 7);
3137 //}
38 {
39 var v: @Vector(4, f32) = [_]f32{1.1, 2.2, 3.3, 4.4};
40 var result = @sqrt(v);
41 expect(math.approxEq(f32, @sqrt(@as(f32, 1.1)), result[0], epsilon));
42 expect(math.approxEq(f32, @sqrt(@as(f32, 2.2)), result[1], epsilon));
43 expect(math.approxEq(f32, @sqrt(@as(f32, 3.3)), result[2], epsilon));
44 expect(math.approxEq(f32, @sqrt(@as(f32, 4.4)), result[3], epsilon));
45 }
46}
47
48test "more @sqrt f16 tests" {
49 // TODO these are not all passing at comptime
50 expect(@sqrt(@as(f16, 0.0)) == 0.0);
51 expect(math.approxEq(f16, @sqrt(@as(f16, 2.0)), 1.414214, epsilon));
52 expect(math.approxEq(f16, @sqrt(@as(f16, 3.6)), 1.897367, epsilon));
53 expect(@sqrt(@as(f16, 4.0)) == 2.0);
54 expect(math.approxEq(f16, @sqrt(@as(f16, 7.539840)), 2.745877, epsilon));
55 expect(math.approxEq(f16, @sqrt(@as(f16, 19.230934)), 4.385309, epsilon));
56 expect(@sqrt(@as(f16, 64.0)) == 8.0);
57 expect(math.approxEq(f16, @sqrt(@as(f16, 64.1)), 8.006248, epsilon));
58 expect(math.approxEq(f16, @sqrt(@as(f16, 8942.230469)), 94.563370, epsilon));
59
60 // special cases
61 expect(math.isPositiveInf(@sqrt(@as(f16, math.inf(f16)))));
62 expect(@sqrt(@as(f16, 0.0)) == 0.0);
63 expect(@sqrt(@as(f16, -0.0)) == -0.0);
64 expect(math.isNan(@sqrt(@as(f16, -1.0))));
65 expect(math.isNan(@sqrt(@as(f16, math.nan(f16)))));
3266}
3367
3468test "@sin" {
......@@ -37,26 +71,28 @@ test "@sin" {
3771}
3872
3973fn testSin() void {
40 // TODO - this is actually useful and should be implemented
41 // (all the trig functions for f16)
42 // but will probably wait till self-hosted
43 //{
44 // var a: f16 = pi;
45 // expect(@sin(f16, a/2) == 1);
46 //}
74 // TODO test f128, and c_longdouble
75 // https://github.com/ziglang/zig/issues/4026
76 {
77 var a: f16 = 0;
78 expect(@sin(a) == 0);
79 }
4780 {
4881 var a: f32 = 0;
49 expect(@sin(f32, a) == 0);
82 expect(@sin(a) == 0);
5083 }
5184 {
5285 var a: f64 = 0;
53 expect(@sin(f64, a) == 0);
86 expect(@sin(a) == 0);
87 }
88 {
89 var v: @Vector(4, f32) = [_]f32{1.1, 2.2, 3.3, 4.4};
90 var result = @sin(v);
91 expect(math.approxEq(f32, @sin(@as(f32, 1.1)), result[0], epsilon));
92 expect(math.approxEq(f32, @sin(@as(f32, 2.2)), result[1], epsilon));
93 expect(math.approxEq(f32, @sin(@as(f32, 3.3)), result[2], epsilon));
94 expect(math.approxEq(f32, @sin(@as(f32, 4.4)), result[3], epsilon));
5495 }
55 // TODO
56 //{
57 // var a: f16 = pi;
58 // expect(@sqrt(f128, a/2) == 1);
59 //}
6096}
6197
6298test "@cos" {
......@@ -65,13 +101,27 @@ test "@cos" {
65101}
66102
67103fn testCos() void {
104 // TODO test f128, and c_longdouble
105 // https://github.com/ziglang/zig/issues/4026
106 {
107 var a: f16 = 0;
108 expect(@cos(a) == 1);
109 }
68110 {
69111 var a: f32 = 0;
70 expect(@cos(f32, a) == 1);
112 expect(@cos(a) == 1);
71113 }
72114 {
73115 var a: f64 = 0;
74 expect(@cos(f64, a) == 1);
116 expect(@cos(a) == 1);
117 }
118 {
119 var v: @Vector(4, f32) = [_]f32{1.1, 2.2, 3.3, 4.4};
120 var result = @cos(v);
121 expect(math.approxEq(f32, @cos(@as(f32, 1.1)), result[0], epsilon));
122 expect(math.approxEq(f32, @cos(@as(f32, 2.2)), result[1], epsilon));
123 expect(math.approxEq(f32, @cos(@as(f32, 3.3)), result[2], epsilon));
124 expect(math.approxEq(f32, @cos(@as(f32, 4.4)), result[3], epsilon));
75125 }
76126}
77127
......@@ -81,13 +131,27 @@ test "@exp" {
81131}
82132
83133fn testExp() void {
134 // TODO test f128, and c_longdouble
135 // https://github.com/ziglang/zig/issues/4026
136 {
137 var a: f16 = 0;
138 expect(@exp(a) == 1);
139 }
84140 {
85141 var a: f32 = 0;
86 expect(@exp(f32, a) == 1);
142 expect(@exp(a) == 1);
87143 }
88144 {
89145 var a: f64 = 0;
90 expect(@exp(f64, a) == 1);
146 expect(@exp(a) == 1);
147 }
148 {
149 var v: @Vector(4, f32) = [_]f32{1.1, 2.2, 0.3, 0.4};
150 var result = @exp(v);
151 expect(math.approxEq(f32, @exp(@as(f32, 1.1)), result[0], epsilon));
152 expect(math.approxEq(f32, @exp(@as(f32, 2.2)), result[1], epsilon));
153 expect(math.approxEq(f32, @exp(@as(f32, 0.3)), result[2], epsilon));
154 expect(math.approxEq(f32, @exp(@as(f32, 0.4)), result[3], epsilon));
91155 }
92156}
93157
......@@ -97,31 +161,59 @@ test "@exp2" {
97161}
98162
99163fn testExp2() void {
164 // TODO test f128, and c_longdouble
165 // https://github.com/ziglang/zig/issues/4026
166 {
167 var a: f16 = 2;
168 expect(@exp2(a) == 4);
169 }
100170 {
101171 var a: f32 = 2;
102 expect(@exp2(f32, a) == 4);
172 expect(@exp2(a) == 4);
103173 }
104174 {
105175 var a: f64 = 2;
106 expect(@exp2(f64, a) == 4);
176 expect(@exp2(a) == 4);
177 }
178 {
179 var v: @Vector(4, f32) = [_]f32{1.1, 2.2, 0.3, 0.4};
180 var result = @exp2(v);
181 expect(math.approxEq(f32, @exp2(@as(f32, 1.1)), result[0], epsilon));
182 expect(math.approxEq(f32, @exp2(@as(f32, 2.2)), result[1], epsilon));
183 expect(math.approxEq(f32, @exp2(@as(f32, 0.3)), result[2], epsilon));
184 expect(math.approxEq(f32, @exp2(@as(f32, 0.4)), result[3], epsilon));
107185 }
108186}
109187
110test "@ln" {
188test "@log" {
111189 // Old musl (and glibc?), and our current math.ln implementation do not return 1
112190 // so also accept those values.
113 comptime testLn();
114 testLn();
191 comptime testLog();
192 testLog();
115193}
116194
117fn testLn() void {
195fn testLog() void {
196 // TODO test f128, and c_longdouble
197 // https://github.com/ziglang/zig/issues/4026
198 {
199 var a: f16 = e;
200 expect(math.approxEq(f16, @log(a), 1, epsilon));
201 }
118202 {
119203 var a: f32 = e;
120 expect(@ln(f32, a) == 1 or @ln(f32, a) == @bitCast(f32, @as(u32, 0x3f7fffff)));
204 expect(@log(a) == 1 or @log(a) == @bitCast(f32, @as(u32, 0x3f7fffff)));
121205 }
122206 {
123207 var a: f64 = e;
124 expect(@ln(f64, a) == 1 or @ln(f64, a) == @bitCast(f64, @as(u64, 0x3ff0000000000000)));
208 expect(@log(a) == 1 or @log(a) == @bitCast(f64, @as(u64, 0x3ff0000000000000)));
209 }
210 {
211 var v: @Vector(4, f32) = [_]f32{1.1, 2.2, 0.3, 0.4};
212 var result = @log(v);
213 expect(math.approxEq(f32, @log(@as(f32, 1.1)), result[0], epsilon));
214 expect(math.approxEq(f32, @log(@as(f32, 2.2)), result[1], epsilon));
215 expect(math.approxEq(f32, @log(@as(f32, 0.3)), result[2], epsilon));
216 expect(math.approxEq(f32, @log(@as(f32, 0.4)), result[3], epsilon));
125217 }
126218}
127219
......@@ -131,13 +223,27 @@ test "@log2" {
131223}
132224
133225fn testLog2() void {
226 // TODO test f128, and c_longdouble
227 // https://github.com/ziglang/zig/issues/4026
228 {
229 var a: f16 = 4;
230 expect(@log2(a) == 2);
231 }
134232 {
135233 var a: f32 = 4;
136 expect(@log2(f32, a) == 2);
234 expect(@log2(a) == 2);
137235 }
138236 {
139237 var a: f64 = 4;
140 expect(@log2(f64, a) == 2);
238 expect(@log2(a) == 2);
239 }
240 {
241 var v: @Vector(4, f32) = [_]f32{1.1, 2.2, 0.3, 0.4};
242 var result = @log2(v);
243 expect(math.approxEq(f32, @log2(@as(f32, 1.1)), result[0], epsilon));
244 expect(math.approxEq(f32, @log2(@as(f32, 2.2)), result[1], epsilon));
245 expect(math.approxEq(f32, @log2(@as(f32, 0.3)), result[2], epsilon));
246 expect(math.approxEq(f32, @log2(@as(f32, 0.4)), result[3], epsilon));
141247 }
142248}
143249
......@@ -147,13 +253,27 @@ test "@log10" {
147253}
148254
149255fn testLog10() void {
256 // TODO test f128, and c_longdouble
257 // https://github.com/ziglang/zig/issues/4026
258 {
259 var a: f16 = 100;
260 expect(@log10(a) == 2);
261 }
150262 {
151263 var a: f32 = 100;
152 expect(@log10(f32, a) == 2);
264 expect(@log10(a) == 2);
153265 }
154266 {
155267 var a: f64 = 1000;
156 expect(@log10(f64, a) == 3);
268 expect(@log10(a) == 3);
269 }
270 {
271 var v: @Vector(4, f32) = [_]f32{1.1, 2.2, 0.3, 0.4};
272 var result = @log10(v);
273 expect(math.approxEq(f32, @log10(@as(f32, 1.1)), result[0], epsilon));
274 expect(math.approxEq(f32, @log10(@as(f32, 2.2)), result[1], epsilon));
275 expect(math.approxEq(f32, @log10(@as(f32, 0.3)), result[2], epsilon));
276 expect(math.approxEq(f32, @log10(@as(f32, 0.4)), result[3], epsilon));
157277 }
158278}
159279
......@@ -163,17 +283,33 @@ test "@fabs" {
163283}
164284
165285fn testFabs() void {
286 // TODO test f128, and c_longdouble
287 // https://github.com/ziglang/zig/issues/4026
288 {
289 var a: f16 = -2.5;
290 var b: f16 = 2.5;
291 expect(@fabs(a) == 2.5);
292 expect(@fabs(b) == 2.5);
293 }
166294 {
167295 var a: f32 = -2.5;
168296 var b: f32 = 2.5;
169 expect(@fabs(f32, a) == 2.5);
170 expect(@fabs(f32, b) == 2.5);
297 expect(@fabs(a) == 2.5);
298 expect(@fabs(b) == 2.5);
171299 }
172300 {
173301 var a: f64 = -2.5;
174302 var b: f64 = 2.5;
175 expect(@fabs(f64, a) == 2.5);
176 expect(@fabs(f64, b) == 2.5);
303 expect(@fabs(a) == 2.5);
304 expect(@fabs(b) == 2.5);
305 }
306 {
307 var v: @Vector(4, f32) = [_]f32{1.1, -2.2, 0.3, -0.4};
308 var result = @fabs(v);
309 expect(math.approxEq(f32, @fabs(@as(f32, 1.1)), result[0], epsilon));
310 expect(math.approxEq(f32, @fabs(@as(f32, -2.2)), result[1], epsilon));
311 expect(math.approxEq(f32, @fabs(@as(f32, 0.3)), result[2], epsilon));
312 expect(math.approxEq(f32, @fabs(@as(f32, -0.4)), result[3], epsilon));
177313 }
178314}
179315
......@@ -183,13 +319,27 @@ test "@floor" {
183319}
184320
185321fn testFloor() void {
322 // TODO test f128, and c_longdouble
323 // https://github.com/ziglang/zig/issues/4026
324 {
325 var a: f16 = 2.1;
326 expect(@floor(a) == 2);
327 }
186328 {
187329 var a: f32 = 2.1;
188 expect(@floor(f32, a) == 2);
330 expect(@floor(a) == 2);
189331 }
190332 {
191333 var a: f64 = 3.5;
192 expect(@floor(f64, a) == 3);
334 expect(@floor(a) == 3);
335 }
336 {
337 var v: @Vector(4, f32) = [_]f32{1.1, -2.2, 0.3, -0.4};
338 var result = @floor(v);
339 expect(math.approxEq(f32, @floor(@as(f32, 1.1)), result[0], epsilon));
340 expect(math.approxEq(f32, @floor(@as(f32, -2.2)), result[1], epsilon));
341 expect(math.approxEq(f32, @floor(@as(f32, 0.3)), result[2], epsilon));
342 expect(math.approxEq(f32, @floor(@as(f32, -0.4)), result[3], epsilon));
193343 }
194344}
195345
......@@ -199,13 +349,27 @@ test "@ceil" {
199349}
200350
201351fn testCeil() void {
352 // TODO test f128, and c_longdouble
353 // https://github.com/ziglang/zig/issues/4026
354 {
355 var a: f16 = 2.1;
356 expect(@ceil(a) == 3);
357 }
202358 {
203359 var a: f32 = 2.1;
204 expect(@ceil(f32, a) == 3);
360 expect(@ceil(a) == 3);
205361 }
206362 {
207363 var a: f64 = 3.5;
208 expect(@ceil(f64, a) == 4);
364 expect(@ceil(a) == 4);
365 }
366 {
367 var v: @Vector(4, f32) = [_]f32{1.1, -2.2, 0.3, -0.4};
368 var result = @ceil(v);
369 expect(math.approxEq(f32, @ceil(@as(f32, 1.1)), result[0], epsilon));
370 expect(math.approxEq(f32, @ceil(@as(f32, -2.2)), result[1], epsilon));
371 expect(math.approxEq(f32, @ceil(@as(f32, 0.3)), result[2], epsilon));
372 expect(math.approxEq(f32, @ceil(@as(f32, -0.4)), result[3], epsilon));
209373 }
210374}
211375
......@@ -215,29 +379,45 @@ test "@trunc" {
215379}
216380
217381fn testTrunc() void {
382 // TODO test f128, and c_longdouble
383 // https://github.com/ziglang/zig/issues/4026
384 {
385 var a: f16 = 2.1;
386 expect(@trunc(a) == 2);
387 }
218388 {
219389 var a: f32 = 2.1;
220 expect(@trunc(f32, a) == 2);
390 expect(@trunc(a) == 2);
221391 }
222392 {
223393 var a: f64 = -3.5;
224 expect(@trunc(f64, a) == -3);
394 expect(@trunc(a) == -3);
395 }
396 {
397 var v: @Vector(4, f32) = [_]f32{1.1, -2.2, 0.3, -0.4};
398 var result = @trunc(v);
399 expect(math.approxEq(f32, @trunc(@as(f32, 1.1)), result[0], epsilon));
400 expect(math.approxEq(f32, @trunc(@as(f32, -2.2)), result[1], epsilon));
401 expect(math.approxEq(f32, @trunc(@as(f32, 0.3)), result[2], epsilon));
402 expect(math.approxEq(f32, @trunc(@as(f32, -0.4)), result[3], epsilon));
225403 }
226404}
227405
228// This is waiting on library support for the Windows build (not sure why the other's don't need it)
229//test "@nearbyInt" {
406// TODO This is waiting on library support for the Windows build (not sure why the other's don't need it)
407//test "@nearbyint" {
230408// comptime testNearbyInt();
231409// testNearbyInt();
232410//}
233411
234412//fn testNearbyInt() void {
413// // TODO test f16, f128, and c_longdouble
414// // https://github.com/ziglang/zig/issues/4026
235415// {
236416// var a: f32 = 2.1;
237// expect(@nearbyInt(f32, a) == 2);
417// expect(@nearbyint(a) == 2);
238418// }
239419// {
240420// var a: f64 = -3.75;
241// expect(@nearbyInt(f64, a) == -4);
421// expect(@nearbyint(a) == -4);
242422// }
243423//}
test/stage1/behavior/math.zig+2-2
......@@ -587,12 +587,12 @@ test "@sqrt" {
587587
588588 const x = 14.0;
589589 const y = x * x;
590 const z = @sqrt(@TypeOf(y), y);
590 const z = @sqrt(y);
591591 comptime expect(z == x);
592592}
593593
594594fn testSqrt(comptime T: type, x: T) void {
595 expect(@sqrt(T, x * x) == x);
595 expect(@sqrt(x * x) == x);
596596}
597597
598598test "comptime_int param and return" {