adrien/zig-dimal
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Updated README + Renamed mulBy and divBy to mul div

Browse Source
This commit is contained in:
adrien
2026-04-22 23:33:58 +02:00
parent 2c94df7f4a
commit 719679aabc
6 changed files with 229 additions and 122 deletions
Download Patch File Download Diff File Expand all files Collapse all files
src/Base.zig
+5 -5
View File
@@ -153,12 +153,12 @@ test "BaseQuantities - Kinematics equations" {
const t = Second.Of(f32){ .value = 2.0 };
// Velocity = Distance / Time
const v = d.divBy(t);
const v = d.div(t);
try std.testing.expectEqual(25.0, v.value);
try std.testing.expect(Speed.dims.eql(@TypeOf(v).dims));
// Acceleration = Velocity / Time
const a = v.divBy(t);
const a = v.div(t);
try std.testing.expectEqual(12.5, a.value);
try std.testing.expect(Acceleration.dims.eql(@TypeOf(a).dims));
}
@@ -170,13 +170,13 @@ test "BaseQuantities - Dynamics (Force and Work)" {
const a = Acceleration.Of(f32){ .value = 9.8 };
// Force = mass * acceleration
const f = m.mulBy(a);
const f = m.mul(a);
try std.testing.expectEqual(98, f.value);
try std.testing.expect(Force.dims.eql(@TypeOf(f).dims));
// Energy (Work) = Force * distance
const distance = Meter.Of(f32){ .value = 5.0 };
const energy = f.mulBy(distance);
const energy = f.mul(distance);
try std.testing.expectEqual(490, energy.value);
try std.testing.expect(Energy.dims.eql(@TypeOf(energy).dims));
}
@@ -186,7 +186,7 @@ test "BaseQuantities - Electric combinations" {
const time = Second.Of(f32){ .value = 3.0 }; // 3 s
// Charge = Current * time
const charge = current.mulBy(time);
const charge = current.mul(time);
try std.testing.expectEqual(6.0, charge.value);
try std.testing.expect(ElectricCharge.dims.eql(@TypeOf(charge).dims));
}
src/Dimensions.zig
+2 -2
View File
@@ -75,7 +75,7 @@ pub fn argsOpt(self: Self) ArgOpts {
return args;
}
/// Add exponents component-wise. Used internally by `mulBy`.
/// Add exponents component-wise. Used internally by `mul`.
pub fn add(comptime a: Self, comptime b: Self) Self {
var result = Self.initFill(0);
inline for (std.enums.values(Dimension)) |d|
@@ -83,7 +83,7 @@ pub fn add(comptime a: Self, comptime b: Self) Self {
return result;
}
/// Subtract exponents component-wise. Used internally by `divBy`.
/// Subtract exponents component-wise. Used internally by `div`.
pub fn sub(comptime a: Self, comptime b: Self) Self {
var result = Self.initFill(0);
inline for (std.enums.values(Dimension)) |d|
src/Scalar.zig
+26 -26
View File
@@ -90,7 +90,7 @@ pub fn Scalar(comptime T: type, comptime d_opt: Dimensions.ArgOpts, comptime s_o
/// Multiply two quantities. Dimension exponents are summed: `L¹ * T⁻¹ → L¹T⁻¹`.
/// `rhs` may be a Scalar, `T`, `comptime_int`, or `comptime_float`
/// (bare numbers are treated as dimensionless — dimensions pass through unchanged).
pub inline fn mulBy(self: Self, r: anytype) Scalar(
pub inline fn mul(self: Self, r: anytype) Scalar(
T,
dims.add(RhsT(@TypeOf(r)).dims).argsOpt(),
hlp.finerScales(Self, RhsT(@TypeOf(r))).argsOpt(),
@@ -110,7 +110,7 @@ pub fn Scalar(comptime T: type, comptime d_opt: Dimensions.ArgOpts, comptime s_o
/// Divide two quantities. Dimension exponents are subtracted: `L¹ / T¹ → L¹T⁻¹`.
/// Integer types use truncating division.
/// `rhs` may be a Scalar, `T`, `comptime_int`, or `comptime_float`.
pub inline fn divBy(self: Self, r: anytype) Scalar(
pub inline fn div(self: Self, r: anytype) Scalar(
T,
dims.sub(RhsT(@TypeOf(r)).dims).argsOpt(),
hlp.finerScales(Self, RhsT(@TypeOf(r))).argsOpt(),
@@ -193,10 +193,10 @@ pub fn Scalar(comptime T: type, comptime d_opt: Dimensions.ArgOpts, comptime s_o
const mult: DestT = comptime @intFromFloat(ratio);
return .{ .value = @as(DestT, @intCast(self.value)) * mult };
} else if (comptime ratio < 1.0 and @round(1.0 / ratio) == 1.0 / ratio) {
const div: DestT = comptime @intFromFloat(1.0 / ratio);
const d: DestT = comptime @intFromFloat(1.0 / ratio);
const val = @as(DestT, @intCast(self.value));
const half = comptime div / 2;
const rounded = if (val >= 0) @divTrunc(val + half, div) else @divTrunc(val - half, div);
const half = comptime d / 2;
const rounded = if (val >= 0) @divTrunc(val + half, d) else @divTrunc(val - half, d);
return .{ .value = rounded };
}
}
@@ -473,13 +473,13 @@ test "MulBy" {
const d = Meter{ .value = 3.0 };
const t = Second{ .value = 4.0 };
const area_time = d.mulBy(t);
const area_time = d.mul(t);
try std.testing.expectEqual(12, area_time.value);
try std.testing.expectEqual(1, @TypeOf(area_time).dims.get(.L));
try std.testing.expectEqual(1, @TypeOf(area_time).dims.get(.T));
const d2 = Meter{ .value = 5.0 };
const area = d.mulBy(d2);
const area = d.mul(d2);
try std.testing.expectEqual(15, area.value);
try std.testing.expectEqual(2, @TypeOf(area).dims.get(.L));
try std.testing.expectEqual(0, @TypeOf(area).dims.get(.T));
@@ -491,7 +491,7 @@ test "MulBy with scale" {
const dist = KiloMeter{ .value = 2.0 };
const mass = KiloGram{ .value = 3.0 };
const prod = dist.mulBy(mass);
const prod = dist.mul(mass);
try std.testing.expectEqual(1, @TypeOf(prod).dims.get(.L));
try std.testing.expectEqual(1, @TypeOf(prod).dims.get(.M));
}
@@ -505,8 +505,8 @@ test "MulBy with type change" {
const d = Meter{ .value = 3.0 };
const t = Second{ .value = 4.0 };
const area_time = d.mulBy(t).to(KmSec);
const area_time_f = d.mulBy(t).to(KmSec_f);
const area_time = d.mul(t).to(KmSec);
const area_time_f = d.mul(t).to(KmSec_f);
try std.testing.expectEqual(12, area_time.value);
try std.testing.expectApproxEqAbs(12, area_time_f.value, 0.0001);
try std.testing.expectEqual(1, @TypeOf(area_time).dims.get(.L));
@@ -520,7 +520,7 @@ test "MulBy small" {
const d = Meter{ .value = 3.0 };
const t = Second{ .value = 4.0 };
const area_time = d.mulBy(t);
const area_time = d.mul(t);
try std.testing.expectEqual(12, area_time.value);
try std.testing.expectEqual(1, @TypeOf(area_time).dims.get(.L));
try std.testing.expectEqual(1, @TypeOf(area_time).dims.get(.T));
@@ -531,7 +531,7 @@ test "MulBy dimensionless" {
const Meter = Scalar(i128, .{ .L = 1 }, .{});
const d = Meter{ .value = 7 };
const scaled = d.mulBy(DimLess{ .value = 3 });
const scaled = d.mul(DimLess{ .value = 3 });
try std.testing.expectEqual(21, scaled.value);
try std.testing.expectEqual(1, @TypeOf(scaled).dims.get(.L));
}
@@ -562,13 +562,13 @@ test "Chained: velocity and acceleration" {
const dist = Meter{ .value = 100.0 };
const t1 = Second{ .value = 5.0 };
const velocity = dist.divBy(t1);
const velocity = dist.div(t1);
try std.testing.expectEqual(20, velocity.value);
try std.testing.expectEqual(1, @TypeOf(velocity).dims.get(.L));
try std.testing.expectEqual(-1, @TypeOf(velocity).dims.get(.T));
const t2 = Second{ .value = 4.0 };
const accel = velocity.divBy(t2);
const accel = velocity.div(t2);
try std.testing.expectEqual(5, accel.value);
try std.testing.expectEqual(1, @TypeOf(accel).dims.get(.L));
try std.testing.expectEqual(-2, @TypeOf(accel).dims.get(.T));
@@ -580,7 +580,7 @@ test "DivBy integer exact" {
const dist = Meter{ .value = 120 };
const time = Second{ .value = 4 };
const vel = dist.divBy(time);
const vel = dist.div(time);
try std.testing.expectEqual(30, vel.value);
try std.testing.expectEqual(1, @TypeOf(vel).dims.get(.L));
@@ -593,7 +593,7 @@ test "Finer scales skip dim 0" {
const r = Dimless{ .value = 30 };
const time = KiloMetre{ .value = 4 };
const vel = r.mulBy(time);
const vel = r.mul(time);
try std.testing.expectEqual(120, vel.value);
try std.testing.expectEqual(Scales.UnitScale.k, @TypeOf(vel).scales.get(.L));
@@ -690,49 +690,49 @@ test "Pow" {
try std.testing.expectEqual(3, @TypeOf(area_f).dims.get(.L));
}
test "mulBy comptime_int" {
test "mul comptime_int" {
const Meter = Scalar(i128, .{ .L = 1 }, .{});
const d = Meter{ .value = 7 };
const scaled = d.mulBy(3); // comptime_int → dimensionless
const scaled = d.mul(3); // comptime_int → dimensionless
try std.testing.expectEqual(21, scaled.value);
try std.testing.expectEqual(1, @TypeOf(scaled).dims.get(.L));
try std.testing.expectEqual(0, @TypeOf(scaled).dims.get(.T));
}
test "mulBy comptime_float" {
test "mul comptime_float" {
const MeterF = Scalar(f64, .{ .L = 1 }, .{});
const d = MeterF{ .value = 4.0 };
const scaled = d.mulBy(2.5); // comptime_float → dimensionless
const scaled = d.mul(2.5); // comptime_float → dimensionless
try std.testing.expectApproxEqAbs(10.0, scaled.value, 1e-9);
try std.testing.expectEqual(1, @TypeOf(scaled).dims.get(.L));
}
test "mulBy T (value type)" {
test "mul T (value type)" {
const MeterF = Scalar(f32, .{ .L = 1 }, .{});
const d = MeterF{ .value = 6.0 };
const factor: f32 = 0.5;
const scaled = d.mulBy(factor); // bare f32 → dimensionless
const scaled = d.mul(factor); // bare f32 → dimensionless
try std.testing.expectApproxEqAbs(3.0, scaled.value, 1e-6);
try std.testing.expectEqual(1, @TypeOf(scaled).dims.get(.L));
}
test "divBy comptime_int" {
test "div comptime_int" {
const Meter = Scalar(i128, .{ .L = 1 }, .{});
const d = Meter{ .value = 100 };
const half = d.divBy(4); // comptime_int → dimensionless divisor
const half = d.div(4); // comptime_int → dimensionless divisor
try std.testing.expectEqual(25, half.value);
try std.testing.expectEqual(1, @TypeOf(half).dims.get(.L));
}
test "divBy comptime_float" {
test "div comptime_float" {
const MeterF = Scalar(f64, .{ .L = 1 }, .{});
const d = MeterF{ .value = 9.0 };
const r = d.divBy(3.0);
const r = d.div(3.0);
try std.testing.expectApproxEqAbs(3.0, r.value, 1e-9);
try std.testing.expectEqual(1, @TypeOf(r).dims.get(.L));
}
src/Vector.zig
+26 -26
View File
@@ -42,7 +42,7 @@ pub fn Vector(comptime len: usize, comptime Q: type) type {
})
@compileError(
"Expected a Scalar or bare number; got a Vector. " ++
"Use mulBy / divBy for element-wise vector operations.",
"Use mul / div for element-wise vector operations.",
);
return hlp.rhsScalarType(T, Rhs);
}
@@ -94,7 +94,7 @@ pub fn Vector(comptime len: usize, comptime Q: type) type {
}
/// Element-wise division. Dimension exponents are subtracted per component.
pub inline fn divBy(
pub inline fn div(
self: Self,
rhs: anytype,
) Vector(len, Scalar(
@@ -109,14 +109,14 @@ pub fn Vector(comptime len: usize, comptime Q: type) type {
hlp.finerScales(Self, @TypeOf(rhs)).argsOpt(),
)) = undefined;
inline for (self.data, 0..) |v, i| {
const q = (Q{ .value = v }).divBy(Tr.ScalarType{ .value = rhs.data[i] });
const q = (Q{ .value = v }).div(Tr.ScalarType{ .value = rhs.data[i] });
res.data[i] = q.value;
}
return res;
}
/// Element-wise multiplication. Dimension exponents are summed per component.
pub inline fn mulBy(
pub inline fn mul(
self: Self,
rhs: anytype,
) Vector(len, Scalar(
@@ -131,7 +131,7 @@ pub fn Vector(comptime len: usize, comptime Q: type) type {
hlp.finerScales(Self, @TypeOf(rhs)).argsOpt(),
)) = undefined;
inline for (self.data, 0..) |v, i| {
const q = (Q{ .value = v }).mulBy(Tr.ScalarType{ .value = rhs.data[i] });
const q = (Q{ .value = v }).mul(Tr.ScalarType{ .value = rhs.data[i] });
res.data[i] = q.value;
}
return res;
@@ -144,7 +144,7 @@ pub fn Vector(comptime len: usize, comptime Q: type) type {
/// Divide every component by a single scalar. Dimensions are subtracted.
/// `scalar` may be a Scalar, `T`, `comptime_int`, or `comptime_float`.
pub inline fn divByScalar(
pub inline fn divScalar(
self: Self,
scalar: anytype,
) Vector(len, Scalar(
@@ -160,13 +160,13 @@ pub fn Vector(comptime len: usize, comptime Q: type) type {
hlp.finerScales(Self, SN).argsOpt(),
)) = undefined;
inline for (self.data, 0..) |v, i|
res.data[i] = (Q{ .value = v }).divBy(s_norm).value;
res.data[i] = (Q{ .value = v }).div(s_norm).value;
return res;
}
/// Multiply every component by a single scalar. Dimensions are summed.
/// `scalar` may be a Scalar, `T`, `comptime_int`, or `comptime_float`.
pub inline fn mulByScalar(
pub inline fn mulScalar(
self: Self,
scalar: anytype,
) Vector(len, Scalar(
@@ -182,7 +182,7 @@ pub fn Vector(comptime len: usize, comptime Q: type) type {
hlp.finerScales(Self, SN).argsOpt(),
)) = undefined;
inline for (self.data, 0..) |v, i|
res.data[i] = (Q{ .value = v }).mulBy(s_norm).value;
res.data[i] = (Q{ .value = v }).mul(s_norm).value;
return res;
}
@@ -203,7 +203,7 @@ pub fn Vector(comptime len: usize, comptime Q: type) type {
inline for (self.data, 0..) |v, i| {
const q_lhs = Q{ .value = v };
const q_rhs = Tr.ScalarType{ .value = rhs.data[i] };
sum += q_lhs.mulBy(q_rhs).value;
sum += q_lhs.mul(q_rhs).value;
}
return .{ .value = sum };
}
@@ -233,9 +233,9 @@ pub fn Vector(comptime len: usize, comptime Q: type) type {
return ResVec{
.data = .{
s2.mulBy(o3).sub(s3.mulBy(o2)).value,
s3.mulBy(o1).sub(s1.mulBy(o3)).value,
s1.mulBy(o2).sub(s2.mulBy(o1)).value,
s2.mul(o3).sub(s3.mul(o2)).value,
s3.mul(o1).sub(s1.mul(o3)).value,
s1.mul(o2).sub(s2.mul(o1)).value,
},
};
}
@@ -591,7 +591,7 @@ test "VecX Kinematics (Scalar Mul/Div)" {
const time = Second{ .value = 10 };
// Vector divided by scalar (Velocity = Position / Time)
const vel = pos.divByScalar(time);
const vel = pos.divScalar(time);
try std.testing.expectEqual(10, vel.data[0]);
try std.testing.expectEqual(20, vel.data[1]);
try std.testing.expectEqual(30, vel.data[2]);
@@ -599,7 +599,7 @@ test "VecX Kinematics (Scalar Mul/Div)" {
try std.testing.expectEqual(-1, @TypeOf(vel).dims.get(.T));
// Vector multiplied by scalar (Position = Velocity * Time)
const new_pos = vel.mulByScalar(time);
const new_pos = vel.mulScalar(time);
try std.testing.expectEqual(100, new_pos.data[0]);
try std.testing.expectEqual(200, new_pos.data[1]);
try std.testing.expectEqual(300, new_pos.data[2]);
@@ -615,7 +615,7 @@ test "VecX Element-wise Math and Scaling" {
const v2 = Vec3M{ .data = .{ 2, 5, 10 } };
// Element-wise division
const div = v1.divBy(v2);
const div = v1.div(v2);
try std.testing.expectEqual(5, div.data[0]);
try std.testing.expectEqual(4, div.data[1]);
try std.testing.expectEqual(3, div.data[2]);
@@ -755,11 +755,11 @@ test "Vector Abs, Pow, Sqrt and Product" {
try std.testing.expectEqual(2, @TypeOf(sqrted).dims.get(.L));
}
test "mulByScalar comptime_int" {
test "mulScalar comptime_int" {
const Meter = Scalar(i32, .{ .L = 1 }, .{});
const v = Meter.Vec3{ .data = .{ 1, 2, 3 } };
const scaled = v.mulByScalar(10); // comptime_int → dimensionless
const scaled = v.mulScalar(10); // comptime_int → dimensionless
try std.testing.expectEqual(10, scaled.data[0]);
try std.testing.expectEqual(20, scaled.data[1]);
try std.testing.expectEqual(30, scaled.data[2]);
@@ -768,45 +768,45 @@ test "mulByScalar comptime_int" {
try std.testing.expectEqual(0, @TypeOf(scaled).dims.get(.T));
}
test "mulByScalar comptime_float" {
test "mulScalar comptime_float" {
const MeterF = Scalar(f32, .{ .L = 1 }, .{});
const v = MeterF.Vec3{ .data = .{ 1.0, 2.0, 4.0 } };
const scaled = v.mulByScalar(0.5); // comptime_float → dimensionless
const scaled = v.mulScalar(0.5); // comptime_float → dimensionless
try std.testing.expectApproxEqAbs(0.5, scaled.data[0], 1e-6);
try std.testing.expectApproxEqAbs(1.0, scaled.data[1], 1e-6);
try std.testing.expectApproxEqAbs(2.0, scaled.data[2], 1e-6);
try std.testing.expectEqual(1, @TypeOf(scaled).dims.get(.L));
}
test "mulByScalar T (value type)" {
test "mulScalar T (value type)" {
const MeterF = Scalar(f32, .{ .L = 1 }, .{});
const v = MeterF.Vec3{ .data = .{ 3.0, 6.0, 9.0 } };
const factor: f32 = 2.0;
const scaled = v.mulByScalar(factor);
const scaled = v.mulScalar(factor);
try std.testing.expectApproxEqAbs(6.0, scaled.data[0], 1e-6);
try std.testing.expectApproxEqAbs(12.0, scaled.data[1], 1e-6);
try std.testing.expectApproxEqAbs(18.0, scaled.data[2], 1e-6);
try std.testing.expectEqual(1, @TypeOf(scaled).dims.get(.L));
}
test "divByScalar comptime_int" {
test "divScalar comptime_int" {
const Meter = Scalar(i32, .{ .L = 1 }, .{});
const v = Meter.Vec3{ .data = .{ 10, 20, 30 } };
const halved = v.divByScalar(2); // comptime_int → dimensionless divisor
const halved = v.divScalar(2); // comptime_int → dimensionless divisor
try std.testing.expectEqual(5, halved.data[0]);
try std.testing.expectEqual(10, halved.data[1]);
try std.testing.expectEqual(15, halved.data[2]);
try std.testing.expectEqual(1, @TypeOf(halved).dims.get(.L));
}
test "divByScalar comptime_float" {
test "divScalar comptime_float" {
const MeterF = Scalar(f64, .{ .L = 1 }, .{});
const v = MeterF.Vec3{ .data = .{ 9.0, 6.0, 3.0 } };
const r = v.divByScalar(3.0);
const r = v.divScalar(3.0);
try std.testing.expectApproxEqAbs(3.0, r.data[0], 1e-9);
try std.testing.expectApproxEqAbs(2.0, r.data[1], 1e-9);
try std.testing.expectApproxEqAbs(1.0, r.data[2], 1e-9);
src/benchmark.zig
+24 -24
View File
@@ -80,7 +80,7 @@ fn bench_Scalar(writer: *std.Io.Writer) !void {
const Types = .{ i16, i32, i64, i128, i256, f32, f64 };
const TNames = .{ "i16", "i32", "i64", "i128", "i256", "f32", "f64" };
const Ops = .{ "add", "sub", "mulBy", "divBy", "to", "abs", "pow", "eq", "gt", "mulBy(n)" };
const Ops = .{ "add", "sub", "mul", "div", "to", "abs", "pow", "eq", "gt", "mul(n)" };
var results_matrix: [Ops.len][Types.len]f64 = undefined;
@@ -103,10 +103,10 @@ fn bench_Scalar(writer: *std.Io.Writer) !void {
(M{ .value = getVal(T, i, 63) }).add(M{ .value = getVal(T, i +% 7, 63) })
else if (comptime std.mem.eql(u8, op_name, "sub"))
(M{ .value = getVal(T, i +% 10, 63) }).sub(M{ .value = getVal(T, i, 63) })
else if (comptime std.mem.eql(u8, op_name, "mulBy"))
(M{ .value = getVal(T, i, 63) }).mulBy(M{ .value = getVal(T, i +% 1, 63) })
else if (comptime std.mem.eql(u8, op_name, "divBy"))
(M{ .value = getVal(T, i +% 10, 63) }).divBy(S{ .value = getVal(T, i, 63) })
else if (comptime std.mem.eql(u8, op_name, "mul"))
(M{ .value = getVal(T, i, 63) }).mul(M{ .value = getVal(T, i +% 1, 63) })
else if (comptime std.mem.eql(u8, op_name, "div"))
(M{ .value = getVal(T, i +% 10, 63) }).div(S{ .value = getVal(T, i, 63) })
else if (comptime std.mem.eql(u8, op_name, "to"))
(KM{ .value = getVal(T, i, 15) }).to(M)
else if (comptime std.mem.eql(u8, op_name, "abs"))
@@ -115,8 +115,8 @@ fn bench_Scalar(writer: *std.Io.Writer) !void {
(M{ .value = getVal(T, i, 63) }).eq(M{ .value = getVal(T, i +% 3, 63) })
else if (comptime std.mem.eql(u8, op_name, "gt"))
(M{ .value = getVal(T, i, 63) }).gt(M{ .value = getVal(T, i +% 3, 63) })
else // "mulBy(n)" — bare comptime_int, dimensionless
(M{ .value = getVal(T, i, 63) }).mulBy(3);
else
(M{ .value = getVal(T, i, 63) }).mul(3);
},
);
}
@@ -171,7 +171,7 @@ fn bench_vsNative(writer: *std.Io.Writer) !void {
const Types = .{ i32, i64, i128, f32, f64 };
const TNames = .{ "i32", "i64", "i128", "f32", "f64" };
const Ops = .{ "add", "mulBy", "divBy" };
const Ops = .{ "add", "mul", "div" };
try writer.print(
\\
@@ -200,7 +200,7 @@ fn bench_vsNative(writer: *std.Io.Writer) !void {
const b = getValT(T, 2);
_ = if (comptime std.mem.eql(u8, op_name, "add"))
a + b
else if (comptime std.mem.eql(u8, op_name, "mulBy"))
else if (comptime std.mem.eql(u8, op_name, "mul"))
a * b
else if (comptime @typeInfo(T) == .int) @divTrunc(a, b) else a / b;
}
@@ -211,14 +211,14 @@ fn bench_vsNative(writer: *std.Io.Writer) !void {
const q_start = getTime();
for (0..ITERS) |i| {
const qa = M{ .value = getValT(T, i) };
const qb = if (comptime std.mem.eql(u8, op_name, "divBy")) S{ .value = getValT(T, 2) } else M{ .value = getValT(T, 2) };
const qb = if (comptime std.mem.eql(u8, op_name, "div")) S{ .value = getValT(T, 2) } else M{ .value = getValT(T, 2) };
_ = if (comptime std.mem.eql(u8, op_name, "add"))
qa.add(qb)
else if (comptime std.mem.eql(u8, op_name, "mulBy"))
qa.mulBy(qb)
else if (comptime std.mem.eql(u8, op_name, "mul"))
qa.mul(qb)
else
qa.divBy(qb);
qa.div(qb);
}
const q_end = getTime();
quantity_total_ns += @as(f64, @floatFromInt(q_start.durationTo(q_end).toNanoseconds()));
@@ -268,7 +268,7 @@ fn bench_crossTypeVsNative(writer: *std.Io.Writer) !void {
const Types = .{ i16, i64, i128, f32, f64 };
const TNames = .{ "i16", "i64", "i128", "f32", "f64" };
const Ops = .{ "add", "mulBy", "divBy" };
const Ops = .{ "add", "mul", "div" };
try writer.print(
\\
@@ -301,7 +301,7 @@ fn bench_crossTypeVsNative(writer: *std.Io.Writer) !void {
_ = if (comptime std.mem.eql(u8, op_name, "add"))
a + b
else if (comptime std.mem.eql(u8, op_name, "mulBy"))
else if (comptime std.mem.eql(u8, op_name, "mul"))
a * b
else if (comptime @typeInfo(T1) == .int)
@divTrunc(a, b)
@@ -315,17 +315,17 @@ fn bench_crossTypeVsNative(writer: *std.Io.Writer) !void {
const q_start = getTime();
for (0..ITERS) |i| {
const qa = M1{ .value = getValT(T1, i) };
const qb = if (comptime std.mem.eql(u8, op_name, "divBy"))
const qb = if (comptime std.mem.eql(u8, op_name, "div"))
S2{ .value = getValT(T2, 2) }
else
M2{ .value = getValT(T2, 2) };
_ = if (comptime std.mem.eql(u8, op_name, "add"))
qa.add(qb)
else if (comptime std.mem.eql(u8, op_name, "mulBy"))
qa.mulBy(qb)
else if (comptime std.mem.eql(u8, op_name, "mul"))
qa.mul(qb)
else
qa.divBy(qb);
qa.div(qb);
}
const q_end = getTime();
quantity_total_ns += @as(f64, @floatFromInt(q_start.durationTo(q_end).toNanoseconds()));
@@ -387,7 +387,7 @@ fn bench_Vector(writer: *std.Io.Writer) !void {
const TNames = .{ "i32", "i64", "i128", "f32", "f64" };
const Lengths = .{ 3, 4, 16 };
// "cross" is only valid for len=3; other cells will show " --- "
const Ops = .{ "add", "divBy", "mulByScalar", "dot", "cross", "product", "pow", "length" };
const Ops = .{ "add", "div", "mulScalar", "dot", "cross", "product", "pow", "length" };
inline for (Ops, 0..) |op_name, o_idx| {
inline for (Types, TNames) |T, tname| {
@@ -416,11 +416,11 @@ fn bench_Vector(writer: *std.Io.Writer) !void {
if (comptime std.mem.eql(u8, op_name, "add")) {
const v2 = V.initDefault(getVal(T, i +% 7, 63));
_ = v1.add(v2);
} else if (comptime std.mem.eql(u8, op_name, "divBy")) {
_ = v1.divBy(V.initDefault(getVal(T, i +% 2, 63)));
} else if (comptime std.mem.eql(u8, op_name, "mulByScalar")) {
} else if (comptime std.mem.eql(u8, op_name, "div")) {
_ = v1.div(V.initDefault(getVal(T, i +% 2, 63)));
} else if (comptime std.mem.eql(u8, op_name, "mulScalar")) {
const s_val = Q_time{ .value = getVal(T, i +% 2, 63) };
_ = v1.mulByScalar(s_val);
_ = v1.mulScalar(s_val);
} else if (comptime std.mem.eql(u8, op_name, "dot")) {
const v2 = V.initDefault(getVal(T, i +% 5, 63));
_ = v1.dot(v2);