832 lines
32 KiB
Zig
832 lines
32 KiB
Zig
const std = @import("std");
|
||
const hlp = @import("helper.zig");
|
||
|
||
const Scalar = @import("Quantity.zig").Scalar;
|
||
const Scales = @import("Scales.zig");
|
||
const UnitScale = Scales.UnitScale;
|
||
const Dimensions = @import("Dimensions.zig");
|
||
const Dimension = Dimensions.Dimension;
|
||
|
||
/// A fixed-size array of `len` elements sharing the same dimension and scale as scalar type `Q`.
|
||
pub fn Vector(comptime len: usize, comptime Q: type) type {
|
||
const T = Q.ValueType;
|
||
|
||
return struct {
|
||
data: [len]T,
|
||
|
||
const Self = @This();
|
||
pub const ScalarType = Q;
|
||
pub const ValueType = T;
|
||
pub const dims: Dimensions = Q.dims;
|
||
pub const scales = Q.scales;
|
||
|
||
pub const zero = initDefault(0);
|
||
pub const one = initDefault(1);
|
||
|
||
pub fn initDefault(v: T) Self {
|
||
var data: [len]T = undefined;
|
||
inline for (&data) |*item| item.* = v;
|
||
return .{ .data = data };
|
||
}
|
||
|
||
// -------------------------------------------------------------------
|
||
// Internal: scalar-rhs normalisation (mirrors Scalar.zig)
|
||
// -------------------------------------------------------------------
|
||
|
||
/// Resolved Scalar type for a scalar operand (bare number or Scalar).
|
||
/// Passing another Vector here is a compile error.
|
||
inline fn ScalarRhsT(comptime Rhs: type) type {
|
||
if (comptime switch (@typeInfo(Rhs)) {
|
||
.@"struct", .@"enum", .@"union", .@"opaque" => @hasDecl(Rhs, "ScalarType"),
|
||
else => false,
|
||
})
|
||
@compileError(
|
||
"Expected a Scalar or bare number; got a Vector. " ++
|
||
"Use mul / div for element-wise vector operations.",
|
||
);
|
||
return hlp.rhsScalarType(T, Rhs);
|
||
}
|
||
|
||
/// Normalise a scalar rhs (bare number → dimensionless Scalar).
|
||
inline fn scalarRhs(r: anytype) ScalarRhsT(@TypeOf(r)) {
|
||
return hlp.toRhsScalar(T, r);
|
||
}
|
||
|
||
// -------------------------------------------------------------------
|
||
// Vector–Vector operations (rhs must be a Vector of the same length)
|
||
// -------------------------------------------------------------------
|
||
|
||
/// Element-wise addition. Dimensions must match; scales resolve to the finer of the two.
|
||
pub inline fn add(self: Self, rhs: anytype) Vector(len, Scalar(
|
||
T,
|
||
dims.argsOpt(),
|
||
hlp.finerScales(Self, @TypeOf(rhs)).argsOpt(),
|
||
)) {
|
||
const Tr = @TypeOf(rhs);
|
||
var res: Vector(len, Scalar(
|
||
T,
|
||
dims.argsOpt(),
|
||
hlp.finerScales(Self, @TypeOf(rhs)).argsOpt(),
|
||
)) = undefined;
|
||
inline for (self.data, 0..) |v, i| {
|
||
const q = (Q{ .value = v }).add(Tr.ScalarType{ .value = rhs.data[i] });
|
||
res.data[i] = q.value;
|
||
}
|
||
return res;
|
||
}
|
||
|
||
/// Element-wise subtraction. Dimensions must match; scales resolve to the finer of the two.
|
||
pub inline fn sub(self: Self, rhs: anytype) Vector(len, Scalar(
|
||
T,
|
||
dims.argsOpt(),
|
||
hlp.finerScales(Self, @TypeOf(rhs)).argsOpt(),
|
||
)) {
|
||
const Tr = @TypeOf(rhs);
|
||
var res: Vector(len, Scalar(
|
||
T,
|
||
dims.argsOpt(),
|
||
hlp.finerScales(Self, @TypeOf(rhs)).argsOpt(),
|
||
)) = undefined;
|
||
inline for (self.data, 0..) |v, i| {
|
||
const q = (Q{ .value = v }).sub(Tr.ScalarType{ .value = rhs.data[i] });
|
||
res.data[i] = q.value;
|
||
}
|
||
return res;
|
||
}
|
||
|
||
/// Element-wise division. Dimension exponents are subtracted per component.
|
||
pub inline fn div(
|
||
self: Self,
|
||
rhs: anytype,
|
||
) Vector(len, Scalar(
|
||
T,
|
||
dims.sub(@TypeOf(rhs).dims).argsOpt(),
|
||
hlp.finerScales(Self, @TypeOf(rhs)).argsOpt(),
|
||
)) {
|
||
const Tr = @TypeOf(rhs);
|
||
var res: Vector(len, Scalar(
|
||
T,
|
||
dims.sub(Tr.dims).argsOpt(),
|
||
hlp.finerScales(Self, @TypeOf(rhs)).argsOpt(),
|
||
)) = undefined;
|
||
inline for (self.data, 0..) |v, 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 mul(
|
||
self: Self,
|
||
rhs: anytype,
|
||
) Vector(len, Scalar(
|
||
T,
|
||
dims.add(@TypeOf(rhs).dims).argsOpt(),
|
||
hlp.finerScales(Self, @TypeOf(rhs)).argsOpt(),
|
||
)) {
|
||
const Tr = @TypeOf(rhs);
|
||
var res: Vector(len, Scalar(
|
||
T,
|
||
dims.add(Tr.dims).argsOpt(),
|
||
hlp.finerScales(Self, @TypeOf(rhs)).argsOpt(),
|
||
)) = undefined;
|
||
inline for (self.data, 0..) |v, i| {
|
||
const q = (Q{ .value = v }).mul(Tr.ScalarType{ .value = rhs.data[i] });
|
||
res.data[i] = q.value;
|
||
}
|
||
return res;
|
||
}
|
||
|
||
// -------------------------------------------------------------------
|
||
// Vector–Scalar operations
|
||
// scalar may be: Scalar, T, comptime_int, comptime_float
|
||
// -------------------------------------------------------------------
|
||
|
||
/// Divide every component by a single scalar. Dimensions are subtracted.
|
||
/// `scalar` may be a Scalar, `T`, `comptime_int`, or `comptime_float`.
|
||
pub inline fn divScalar(
|
||
self: Self,
|
||
scalar: anytype,
|
||
) Vector(len, Scalar(
|
||
T,
|
||
dims.sub(ScalarRhsT(@TypeOf(scalar)).dims).argsOpt(),
|
||
hlp.finerScales(Self, ScalarRhsT(@TypeOf(scalar))).argsOpt(),
|
||
)) {
|
||
const s_norm = scalarRhs(scalar);
|
||
const SN = @TypeOf(s_norm);
|
||
var res: Vector(len, Scalar(
|
||
T,
|
||
dims.sub(SN.dims).argsOpt(),
|
||
hlp.finerScales(Self, SN).argsOpt(),
|
||
)) = undefined;
|
||
inline for (self.data, 0..) |v, i|
|
||
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 mulScalar(
|
||
self: Self,
|
||
scalar: anytype,
|
||
) Vector(len, Scalar(
|
||
T,
|
||
dims.add(ScalarRhsT(@TypeOf(scalar)).dims).argsOpt(),
|
||
hlp.finerScales(Self, ScalarRhsT(@TypeOf(scalar))).argsOpt(),
|
||
)) {
|
||
const s_norm = scalarRhs(scalar);
|
||
const SN = @TypeOf(s_norm);
|
||
var res: Vector(len, Scalar(
|
||
T,
|
||
dims.add(SN.dims).argsOpt(),
|
||
hlp.finerScales(Self, SN).argsOpt(),
|
||
)) = undefined;
|
||
inline for (self.data, 0..) |v, i|
|
||
res.data[i] = (Q{ .value = v }).mul(s_norm).value;
|
||
return res;
|
||
}
|
||
|
||
// -------------------------------------------------------------------
|
||
// Dot / Cross
|
||
// -------------------------------------------------------------------
|
||
|
||
/// Standard dot product. Dimensions are summed (e.g., Force * Distance = Energy).
|
||
/// Returns a Scalar type with the combined dimensions and finest scale.
|
||
pub inline fn dot(self: Self, rhs: anytype) Scalar(
|
||
T,
|
||
dims.add(@TypeOf(rhs).dims).argsOpt(),
|
||
hlp.finerScales(Self, @TypeOf(rhs)).argsOpt(),
|
||
) {
|
||
const Tr = @TypeOf(rhs);
|
||
|
||
var sum: T = 0;
|
||
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.mul(q_rhs).value;
|
||
}
|
||
return .{ .value = sum };
|
||
}
|
||
|
||
/// 3D Cross product. Dimensions are summed.
|
||
/// Only valid for vectors of length 3.
|
||
pub inline fn cross(self: Self, rhs: anytype) Vector(3, Scalar(
|
||
T,
|
||
dims.add(@TypeOf(rhs).dims).argsOpt(),
|
||
hlp.finerScales(Self, @TypeOf(rhs)).argsOpt(),
|
||
)) {
|
||
if (comptime len != 3)
|
||
@compileError("Cross product is only defined for Vector(3, ...)");
|
||
|
||
const Tr = @TypeOf(rhs);
|
||
const ResScalar = Scalar(T, dims.add(Tr.dims).argsOpt(), hlp.finerScales(Self, Tr).argsOpt());
|
||
const ResVec = Vector(3, ResScalar);
|
||
|
||
// Calculation: [y1*z2 - z1*y2, z1*x2 - x1*z2, x1*y2 - y1*x2]
|
||
const s1 = Q{ .value = self.data[0] };
|
||
const s2 = Q{ .value = self.data[1] };
|
||
const s3 = Q{ .value = self.data[2] };
|
||
|
||
const o1 = Tr.ScalarType{ .value = rhs.data[0] };
|
||
const o2 = Tr.ScalarType{ .value = rhs.data[1] };
|
||
const o3 = Tr.ScalarType{ .value = rhs.data[2] };
|
||
|
||
return ResVec{
|
||
.data = .{
|
||
s2.mul(o3).sub(s3.mul(o2)).value,
|
||
s3.mul(o1).sub(s1.mul(o3)).value,
|
||
s1.mul(o2).sub(s2.mul(o1)).value,
|
||
},
|
||
};
|
||
}
|
||
|
||
// -------------------------------------------------------------------
|
||
// Unary
|
||
// -------------------------------------------------------------------
|
||
|
||
/// Returns a vector where each component is the absolute value of the original.
|
||
pub inline fn abs(self: Self) Self {
|
||
var res: Self = undefined;
|
||
inline for (self.data, 0..) |v, i| {
|
||
const q = Q{ .value = v };
|
||
res.data[i] = q.abs().value;
|
||
}
|
||
return res;
|
||
}
|
||
|
||
/// Returns a vector where each component is the absolute value of the original.
|
||
pub inline fn sqrt(self: Self) Self {
|
||
var res: Self = undefined;
|
||
inline for (self.data, 0..) |v, i| {
|
||
const q = Q{ .value = v };
|
||
res.data[i] = q.sqrt().value;
|
||
}
|
||
return res;
|
||
}
|
||
|
||
/// Multiplies all components of the vector together.
|
||
/// Resulting dimensions are (Original Dims * len).
|
||
pub inline fn product(self: Self) Scalar(
|
||
T,
|
||
dims.scale(len).argsOpt(),
|
||
scales.argsOpt(),
|
||
) {
|
||
var res_val: T = 1;
|
||
if (comptime hlp.isInt(T)) {
|
||
inline for (self.data) |v|
|
||
res_val = res_val *| v;
|
||
} else inline for (self.data) |v|
|
||
res_val *= v;
|
||
return .{ .value = res_val };
|
||
}
|
||
|
||
/// Raises every component to a compile-time integer power.
|
||
/// Dimensions are scaled by the exponent.
|
||
pub inline fn pow(self: Self, comptime exp: comptime_int) Vector(
|
||
len,
|
||
Scalar(
|
||
T,
|
||
dims.scale(exp).argsOpt(),
|
||
scales.argsOpt(),
|
||
),
|
||
) {
|
||
const ResScalar = Scalar(T, dims.scale(exp).argsOpt(), scales.argsOpt());
|
||
var res: Vector(len, ResScalar) = undefined;
|
||
inline for (self.data, 0..) |v, i| {
|
||
const q = Q{ .value = v };
|
||
res.data[i] = q.pow(exp).value;
|
||
}
|
||
return res;
|
||
}
|
||
|
||
/// Negate all components. Dimensions are preserved.
|
||
pub fn negate(self: Self) Self {
|
||
var res: Self = undefined;
|
||
inline for (self.data, 0..) |v, i|
|
||
res.data[i] = -v;
|
||
return res;
|
||
}
|
||
|
||
// -------------------------------------------------------------------
|
||
// Conversion
|
||
// -------------------------------------------------------------------
|
||
|
||
/// Convert all components to a compatible scalar type. Compile error on dimension mismatch.
|
||
pub inline fn to(self: Self, comptime DestQ: type) Vector(len, DestQ) {
|
||
var res: Vector(len, DestQ) = undefined;
|
||
inline for (self.data, 0..) |v, i|
|
||
res.data[i] = (Q{ .value = v }).to(DestQ).value;
|
||
return res;
|
||
}
|
||
|
||
// -------------------------------------------------------------------
|
||
// Length
|
||
// -------------------------------------------------------------------
|
||
|
||
/// Sum of squared components. Cheaper than `length` — use for comparisons.
|
||
pub inline fn lengthSqr(self: Self) T {
|
||
var sum: T = 0;
|
||
inline for (self.data) |v|
|
||
sum += v * v;
|
||
return sum;
|
||
}
|
||
|
||
/// Euclidean length. Integer types use integer sqrt (truncated).
|
||
pub inline fn length(self: Self) T {
|
||
const len_sq = self.lengthSqr();
|
||
|
||
if (comptime @typeInfo(T) == .int) {
|
||
const UnsignedT = @Int(.unsigned, @typeInfo(T).int.bits);
|
||
const u_len_sq = @as(UnsignedT, @intCast(len_sq));
|
||
return @as(T, @intCast(std.math.sqrt(u_len_sq)));
|
||
} else {
|
||
return @sqrt(len_sq);
|
||
}
|
||
}
|
||
|
||
// -------------------------------------------------------------------
|
||
// Vector–Vector comparisons
|
||
// -------------------------------------------------------------------
|
||
|
||
/// Returns true only if all components are equal after scale resolution.
|
||
pub inline fn eqAll(self: Self, rhs: anytype) bool {
|
||
const Tr = @TypeOf(rhs);
|
||
if (comptime !dims.eql(Tr.dims))
|
||
@compileError("Dimension mismatch in eq: " ++ dims.str() ++ " vs " ++ Tr.dims.str());
|
||
|
||
inline for (self.data, 0..) |v, i| {
|
||
const lhs_q = Q{ .value = v };
|
||
const rhs_q = Tr.ScalarType{ .value = rhs.data[i] };
|
||
if (!lhs_q.eq(rhs_q)) return false;
|
||
}
|
||
return true;
|
||
}
|
||
|
||
/// Returns true if any component differs after scale resolution.
|
||
pub inline fn neAll(self: Self, rhs: anytype) bool {
|
||
return !self.eqAll(rhs);
|
||
}
|
||
|
||
/// Element-wise "Equal". Returns an array of booleans.
|
||
pub inline fn eq(self: Self, rhs: anytype) [len]bool {
|
||
const Tr = @TypeOf(rhs);
|
||
var res: [len]bool = undefined;
|
||
inline for (self.data, 0..) |v, i|
|
||
res[i] = (Q{ .value = v }).eq(Tr.ScalarType{ .value = rhs.data[i] });
|
||
return res;
|
||
}
|
||
|
||
/// Element-wise "Not Equal". Returns an array of booleans.
|
||
pub inline fn ne(self: Self, rhs: anytype) [len]bool {
|
||
const Tr = @TypeOf(rhs);
|
||
var res: [len]bool = undefined;
|
||
inline for (self.data, 0..) |v, i|
|
||
res[i] = (Q{ .value = v }).ne(Tr.ScalarType{ .value = rhs.data[i] });
|
||
return res;
|
||
}
|
||
|
||
/// Element-wise "Greater Than". Returns an array of booleans.
|
||
pub inline fn gt(self: Self, rhs: anytype) [len]bool {
|
||
const Tr = @TypeOf(rhs);
|
||
var res: [len]bool = undefined;
|
||
inline for (self.data, 0..) |v, i|
|
||
res[i] = (Q{ .value = v }).gt(Tr.ScalarType{ .value = rhs.data[i] });
|
||
return res;
|
||
}
|
||
|
||
/// Element-wise "Greater Than or Equal". Returns an array of booleans.
|
||
pub inline fn gte(self: Self, rhs: anytype) [len]bool {
|
||
const Tr = @TypeOf(rhs);
|
||
var res: [len]bool = undefined;
|
||
inline for (self.data, 0..) |v, i|
|
||
res[i] = (Q{ .value = v }).gte(Tr.ScalarType{ .value = rhs.data[i] });
|
||
return res;
|
||
}
|
||
|
||
/// Element-wise "Less Than". Returns an array of booleans.
|
||
pub inline fn lt(self: Self, rhs: anytype) [len]bool {
|
||
const Tr = @TypeOf(rhs);
|
||
var res: [len]bool = undefined;
|
||
inline for (self.data, 0..) |v, i|
|
||
res[i] = (Q{ .value = v }).lt(Tr.ScalarType{ .value = rhs.data[i] });
|
||
return res;
|
||
}
|
||
|
||
/// Element-wise "Less Than or Equal". Returns an array of booleans.
|
||
pub inline fn lte(self: Self, rhs: anytype) [len]bool {
|
||
const Tr = @TypeOf(rhs);
|
||
var res: [len]bool = undefined;
|
||
inline for (self.data, 0..) |v, i|
|
||
res[i] = (Q{ .value = v }).lte(Tr.ScalarType{ .value = rhs.data[i] });
|
||
return res;
|
||
}
|
||
|
||
// -------------------------------------------------------------------
|
||
// Vector–Scalar comparisons
|
||
// scalar may be: Scalar, T, comptime_int, comptime_float
|
||
// -------------------------------------------------------------------
|
||
|
||
/// Compares every element in the vector to a single scalar for equality.
|
||
/// Returns an array of booleans [len]bool. Dimensions must match; scales are auto-resolved.
|
||
pub inline fn eqScalar(self: Self, scalar: anytype) [len]bool {
|
||
var res: [len]bool = undefined;
|
||
inline for (self.data, 0..) |v, i|
|
||
res[i] = (Q{ .value = v }).eq(scalar);
|
||
return res;
|
||
}
|
||
|
||
/// Compares every element in the vector to a single scalar for inequality.
|
||
/// Returns an array of booleans [len]bool. Dimensions must match; scales are auto-resolved.
|
||
pub inline fn neScalar(self: Self, scalar: anytype) [len]bool {
|
||
var res: [len]bool = undefined;
|
||
inline for (self.data, 0..) |v, i|
|
||
res[i] = (Q{ .value = v }).ne(scalar);
|
||
return res;
|
||
}
|
||
|
||
/// Checks if each element in the vector is strictly greater than the given scalar.
|
||
/// Returns an array of booleans [len]bool.
|
||
pub inline fn gtScalar(self: Self, scalar: anytype) [len]bool {
|
||
var res: [len]bool = undefined;
|
||
inline for (self.data, 0..) |v, i|
|
||
res[i] = (Q{ .value = v }).gt(scalar);
|
||
return res;
|
||
}
|
||
|
||
/// Checks if each element in the vector is greater than or equal to the given scalar.
|
||
/// Returns an array of booleans [len]bool.
|
||
pub inline fn gteScalar(self: Self, scalar: anytype) [len]bool {
|
||
var res: [len]bool = undefined;
|
||
inline for (self.data, 0..) |v, i|
|
||
res[i] = (Q{ .value = v }).gte(scalar);
|
||
return res;
|
||
}
|
||
|
||
/// Checks if each element in the vector is strictly less than the given scalar.
|
||
/// Returns an array of booleans [len]bool.
|
||
pub inline fn ltScalar(self: Self, scalar: anytype) [len]bool {
|
||
var res: [len]bool = undefined;
|
||
inline for (self.data, 0..) |v, i|
|
||
res[i] = (Q{ .value = v }).lt(scalar);
|
||
return res;
|
||
}
|
||
|
||
/// Checks if each element in the vector is less than or equal to the given scalar.
|
||
/// Returns an array of booleans [len]bool.
|
||
pub inline fn lteScalar(self: Self, scalar: anytype) [len]bool {
|
||
var res: [len]bool = undefined;
|
||
inline for (self.data, 0..) |v, i|
|
||
res[i] = (Q{ .value = v }).lte(scalar);
|
||
return res;
|
||
}
|
||
|
||
// -------------------------------------------------------------------
|
||
// Formatting
|
||
// -------------------------------------------------------------------
|
||
|
||
pub fn formatNumber(
|
||
self: Self,
|
||
writer: *std.Io.Writer,
|
||
options: std.fmt.Number,
|
||
) !void {
|
||
try writer.writeAll("(");
|
||
for (self.data, 0..) |v, i| {
|
||
if (i > 0) try writer.writeAll(", ");
|
||
switch (@typeInfo(T)) {
|
||
.float, .comptime_float => try writer.printFloat(v, options),
|
||
.int, .comptime_int => try writer.printInt(v, 10, .lower, .{
|
||
.width = options.width,
|
||
.alignment = options.alignment,
|
||
.fill = options.fill,
|
||
.precision = options.precision,
|
||
}),
|
||
else => unreachable,
|
||
}
|
||
}
|
||
try writer.writeAll(")");
|
||
var first = true;
|
||
inline for (std.enums.values(Dimension)) |bu| {
|
||
const v = dims.get(bu);
|
||
if (comptime v == 0) continue;
|
||
if (!first)
|
||
try writer.writeAll(".");
|
||
|
||
first = false;
|
||
|
||
const uscale = scales.get(bu);
|
||
if (bu == .T and (uscale == .min or uscale == .hour or uscale == .year))
|
||
try writer.print("{s}", .{uscale.str()})
|
||
else
|
||
try writer.print("{s}{s}", .{ uscale.str(), bu.unit() });
|
||
|
||
if (v != 1)
|
||
try hlp.printSuperscript(writer, v);
|
||
}
|
||
}
|
||
};
|
||
}
|
||
|
||
test "Format VectorX" {
|
||
const MeterPerSecondSq = Scalar(f32, .{ .L = 1, .T = -2 }, .{ .T = .n });
|
||
const KgMeterPerSecond = Scalar(f32, .{ .M = 1, .L = 1, .T = -1 }, .{ .M = .k });
|
||
|
||
const accel = MeterPerSecondSq.Vec3.initDefault(9.81);
|
||
const momentum = KgMeterPerSecond.Vec3{ .data = .{ 43, 0, 11 } };
|
||
|
||
var buf: [64]u8 = undefined;
|
||
var res = try std.fmt.bufPrint(&buf, "{d}", .{accel});
|
||
try std.testing.expectEqualStrings("(9.81, 9.81, 9.81)m.ns⁻²", res);
|
||
|
||
res = try std.fmt.bufPrint(&buf, "{d:.2}", .{momentum});
|
||
try std.testing.expectEqualStrings("(43.00, 0.00, 11.00)m.kg.s⁻¹", res);
|
||
}
|
||
|
||
test "VecX Init and Basic Arithmetic" {
|
||
const Meter = Scalar(i32, .{ .L = 1 }, .{});
|
||
const Vec3M = Meter.Vec3;
|
||
|
||
// Test zero, one, initDefault
|
||
const v_zero = Vec3M.zero;
|
||
try std.testing.expectEqual(0, v_zero.data[0]);
|
||
try std.testing.expectEqual(0, v_zero.data[1]);
|
||
try std.testing.expectEqual(0, v_zero.data[2]);
|
||
|
||
const v_one = Vec3M.one;
|
||
try std.testing.expectEqual(1, v_one.data[0]);
|
||
try std.testing.expectEqual(1, v_one.data[1]);
|
||
try std.testing.expectEqual(1, v_one.data[2]);
|
||
|
||
const v_def = Vec3M.initDefault(5);
|
||
try std.testing.expectEqual(5, v_def.data[0]);
|
||
try std.testing.expectEqual(5, v_def.data[1]);
|
||
try std.testing.expectEqual(5, v_def.data[2]);
|
||
|
||
// Test add and sub
|
||
const v1 = Vec3M{ .data = .{ 10, 20, 30 } };
|
||
const v2 = Vec3M{ .data = .{ 2, 4, 6 } };
|
||
|
||
const added = v1.add(v2);
|
||
try std.testing.expectEqual(12, added.data[0]);
|
||
try std.testing.expectEqual(24, added.data[1]);
|
||
try std.testing.expectEqual(36, added.data[2]);
|
||
|
||
const subbed = v1.sub(v2);
|
||
try std.testing.expectEqual(8, subbed.data[0]);
|
||
try std.testing.expectEqual(16, subbed.data[1]);
|
||
try std.testing.expectEqual(24, subbed.data[2]);
|
||
|
||
// Test negate
|
||
const neg = v1.negate();
|
||
try std.testing.expectEqual(-10, neg.data[0]);
|
||
try std.testing.expectEqual(-20, neg.data[1]);
|
||
try std.testing.expectEqual(-30, neg.data[2]);
|
||
}
|
||
|
||
test "VecX Kinematics (Scalar Mul/Div)" {
|
||
const Meter = Scalar(i32, .{ .L = 1 }, .{});
|
||
const Second = Scalar(i32, .{ .T = 1 }, .{});
|
||
const Vec3M = Meter.Vec3;
|
||
|
||
const pos = Vec3M{ .data = .{ 100, 200, 300 } };
|
||
const time = Second{ .value = 10 };
|
||
|
||
// Vector divided by scalar (Velocity = Position / 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]);
|
||
try std.testing.expectEqual(1, @TypeOf(vel).dims.get(.L));
|
||
try std.testing.expectEqual(-1, @TypeOf(vel).dims.get(.T));
|
||
|
||
// Vector multiplied by scalar (Position = Velocity * 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]);
|
||
try std.testing.expectEqual(1, @TypeOf(new_pos).dims.get(.L));
|
||
try std.testing.expectEqual(0, @TypeOf(new_pos).dims.get(.T));
|
||
}
|
||
|
||
test "VecX Element-wise Math and Scaling" {
|
||
const Meter = Scalar(i32, .{ .L = 1 }, .{});
|
||
const Vec3M = Meter.Vec3;
|
||
|
||
const v1 = Vec3M{ .data = .{ 10, 20, 30 } };
|
||
const v2 = Vec3M{ .data = .{ 2, 5, 10 } };
|
||
|
||
// Element-wise division
|
||
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]);
|
||
try std.testing.expectEqual(0, @TypeOf(div).dims.get(.L)); // M / M = Dimensionless
|
||
}
|
||
|
||
test "VecX Conversions" {
|
||
const KiloMeter = Scalar(i32, .{ .L = 1 }, .{ .L = .k });
|
||
const Meter = Scalar(i32, .{ .L = 1 }, .{});
|
||
|
||
const v_km = KiloMeter.Vec3{ .data = .{ 1, 2, 3 } };
|
||
const v_m = v_km.to(Meter);
|
||
|
||
try std.testing.expectEqual(1000, v_m.data[0]);
|
||
try std.testing.expectEqual(2000, v_m.data[1]);
|
||
try std.testing.expectEqual(3000, v_m.data[2]);
|
||
|
||
// Type checking the result
|
||
try std.testing.expectEqual(1, @TypeOf(v_m).dims.get(.L));
|
||
try std.testing.expectEqual(UnitScale.none, @TypeOf(v_m).scales.get(.L));
|
||
}
|
||
|
||
test "VecX Length" {
|
||
const MeterInt = Scalar(i32, .{ .L = 1 }, .{});
|
||
const MeterFloat = Scalar(f32, .{ .L = 1 }, .{});
|
||
|
||
// Integer length
|
||
// 3-4-5 triangle on XY plane
|
||
const v_int = MeterInt.Vec3{ .data = .{ 3, 4, 0 } };
|
||
try std.testing.expectEqual(25, v_int.lengthSqr());
|
||
try std.testing.expectEqual(5, v_int.length());
|
||
|
||
// Float length
|
||
const v_float = MeterFloat.Vec3{ .data = .{ 3.0, 4.0, 0.0 } };
|
||
try std.testing.expectApproxEqAbs(@as(f32, 25.0), v_float.lengthSqr(), 1e-4);
|
||
try std.testing.expectApproxEqAbs(@as(f32, 5.0), v_float.length(), 1e-4);
|
||
}
|
||
|
||
test "Vector Comparisons" {
|
||
const Meter = Scalar(f32, .{ .L = 1 }, .{});
|
||
const KiloMeter = Scalar(f32, .{ .L = 1 }, .{ .L = .k });
|
||
|
||
const v1 = Meter.Vec3{ .data = .{ 1000.0, 500.0, 0.0 } };
|
||
const v2 = KiloMeter.Vec3{ .data = .{ 1.0, 0.5, 0.0 } };
|
||
const v3 = KiloMeter.Vec3{ .data = .{ 1.0, 0.6, 0.0 } };
|
||
|
||
// 1. Equality (Whole vector)
|
||
try std.testing.expect(v1.eqAll(v2));
|
||
try std.testing.expect(v1.neAll(v3));
|
||
|
||
// 2. Element-wise Ordered Comparison
|
||
const higher = v3.gt(v1); // compares 1km, 0.6km, 0km vs 1000m, 500m, 0m
|
||
try std.testing.expectEqual(false, higher[0]); // 1km == 1000m
|
||
try std.testing.expectEqual(true, higher[1]); // 0.6km > 500m
|
||
try std.testing.expectEqual(false, higher[2]); // 0 == 0
|
||
|
||
// 3. Element-wise Equal Comparison
|
||
const equal = v3.eq(v1); // compares 1km, 0.6km, 0km vs 1000m, 500m, 0m
|
||
try std.testing.expectEqual(true, equal[0]); // 1km == 1000m
|
||
try std.testing.expectEqual(false, equal[1]); // 0.6km > 500m
|
||
try std.testing.expectEqual(true, equal[2]); // 0 == 0
|
||
|
||
// 3. Less than or equal
|
||
const low_eq = v1.lte(v3);
|
||
try std.testing.expect(low_eq[0] and low_eq[1] and low_eq[2]);
|
||
}
|
||
|
||
test "Vector vs Scalar Comparisons" {
|
||
const Meter = Scalar(f32, .{ .L = 1 }, .{});
|
||
const KiloMeter = Scalar(f32, .{ .L = 1 }, .{ .L = .k });
|
||
|
||
const positions = Meter.Vec3{ .data = .{ 500.0, 1200.0, 3000.0 } };
|
||
const threshold = KiloMeter{ .value = 1.0 }; // 1km (1000m)
|
||
|
||
// Check which axes exceed the 1km threshold
|
||
const exceeded = positions.gtScalar(threshold);
|
||
|
||
try std.testing.expectEqual(false, exceeded[0]); // 500m > 1km is false
|
||
try std.testing.expectEqual(true, exceeded[1]); // 1200m > 1km is true
|
||
try std.testing.expectEqual(true, exceeded[2]); // 3000m > 1km is true
|
||
|
||
// Check for equality (broadcasted)
|
||
const exact_match = positions.eqScalar(Meter{ .value = 500.0 });
|
||
try std.testing.expect(exact_match[0] == true);
|
||
try std.testing.expect(exact_match[1] == false);
|
||
}
|
||
|
||
test "Vector Dot and Cross Products" {
|
||
const Meter = Scalar(f32, .{ .L = 1 }, .{});
|
||
const Newton = Scalar(f32, .{ .M = 1, .L = 1, .T = -2 }, .{});
|
||
|
||
const pos = Meter.Vec3{ .data = .{ 10.0, 0.0, 0.0 } };
|
||
const force = Newton.Vec3{ .data = .{ 5.0, 5.0, 0.0 } };
|
||
|
||
// 1. Dot Product (Work = F dot d)
|
||
const work = force.dot(pos);
|
||
try std.testing.expectEqual(50.0, work.value);
|
||
// Dimensions should be M¹L²T⁻² (Energy/Joules)
|
||
try std.testing.expectEqual(1, @TypeOf(work).dims.get(.M));
|
||
try std.testing.expectEqual(2, @TypeOf(work).dims.get(.L));
|
||
try std.testing.expectEqual(-2, @TypeOf(work).dims.get(.T));
|
||
|
||
// 2. Cross Product (Torque = r cross F)
|
||
const torque = pos.cross(force);
|
||
try std.testing.expectEqual(0.0, torque.data[0]);
|
||
try std.testing.expectEqual(0.0, torque.data[1]);
|
||
try std.testing.expectEqual(50.0, torque.data[2]);
|
||
// Torque dimensions are same as Energy but as a Vector
|
||
try std.testing.expectEqual(2, @TypeOf(torque).dims.get(.L));
|
||
}
|
||
|
||
test "Vector Abs, Pow, Sqrt and Product" {
|
||
const Meter = Scalar(f32, .{ .L = 1 }, .{});
|
||
|
||
const v1 = Meter.Vec3{ .data = .{ -2.0, 3.0, -4.0 } };
|
||
|
||
// 1. Abs
|
||
const v_abs = v1.abs();
|
||
try std.testing.expectEqual(2.0, v_abs.data[0]);
|
||
try std.testing.expectEqual(4.0, v_abs.data[2]);
|
||
|
||
// 2. Product (L1 * L1 * L1 = L3)
|
||
const vol = v_abs.product();
|
||
try std.testing.expectEqual(24.0, vol.value);
|
||
try std.testing.expectEqual(3, @TypeOf(vol).dims.get(.L));
|
||
|
||
// 3. Pow (Scalar exponent: (L1)^2 = L2)
|
||
const area_vec = v_abs.pow(2);
|
||
try std.testing.expectEqual(4.0, area_vec.data[0]);
|
||
try std.testing.expectEqual(16.0, area_vec.data[2]);
|
||
try std.testing.expectEqual(2, @TypeOf(area_vec).dims.get(.L));
|
||
|
||
// 4. Sqrt
|
||
const sqrted = area_vec.sqrt();
|
||
try std.testing.expectEqual(2, sqrted.data[0]);
|
||
try std.testing.expectEqual(4, sqrted.data[2]);
|
||
try std.testing.expectEqual(2, @TypeOf(sqrted).dims.get(.L));
|
||
}
|
||
|
||
test "mulScalar comptime_int" {
|
||
const Meter = Scalar(i32, .{ .L = 1 }, .{});
|
||
const v = Meter.Vec3{ .data = .{ 1, 2, 3 } };
|
||
|
||
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]);
|
||
// Dimensions unchanged: L¹ × dimensionless = L¹
|
||
try std.testing.expectEqual(1, @TypeOf(scaled).dims.get(.L));
|
||
try std.testing.expectEqual(0, @TypeOf(scaled).dims.get(.T));
|
||
}
|
||
|
||
test "mulScalar comptime_float" {
|
||
const MeterF = Scalar(f32, .{ .L = 1 }, .{});
|
||
const v = MeterF.Vec3{ .data = .{ 1.0, 2.0, 4.0 } };
|
||
|
||
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 "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.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 "divScalar comptime_int" {
|
||
const Meter = Scalar(i32, .{ .L = 1 }, .{});
|
||
const v = Meter.Vec3{ .data = .{ 10, 20, 30 } };
|
||
|
||
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 "divScalar comptime_float" {
|
||
const MeterF = Scalar(f64, .{ .L = 1 }, .{});
|
||
const v = MeterF.Vec3{ .data = .{ 9.0, 6.0, 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);
|
||
try std.testing.expectEqual(1, @TypeOf(r).dims.get(.L));
|
||
}
|
||
|
||
test "eqScalar / gtScalar with comptime_int on dimensionless vector" {
|
||
// Bare numbers are dimensionless, so comparisons only work when vector is dimensionless too.
|
||
const DimLess = Scalar(i32, .{}, .{});
|
||
const v = DimLess.Vec3{ .data = .{ 1, 2, 3 } };
|
||
|
||
const eq_res = v.eqScalar(2);
|
||
try std.testing.expectEqual(false, eq_res[0]);
|
||
try std.testing.expectEqual(true, eq_res[1]);
|
||
try std.testing.expectEqual(false, eq_res[2]);
|
||
|
||
const gt_res = v.gtScalar(1);
|
||
try std.testing.expectEqual(false, gt_res[0]);
|
||
try std.testing.expectEqual(true, gt_res[1]);
|
||
try std.testing.expectEqual(true, gt_res[2]);
|
||
}
|