const std = @import("std");
const math = std.math;
/// The type of a vector.
pub fn Vector(comptime N: usize) type {
return packed struct {
const Self = @This();
/// The scalar type manager by this vector.
pub const Scalar = f32;
values: [N]Scalar,
/// Initializes a vector from its scalar values.
pub fn init(values: [N]Scalar) Self {
return .{ .values = values };
}
/// Creates a vector filled with the given scalar value.
pub fn filled(n: Scalar) Self {
var values: [N]Scalar = undefined;
comptime var i = 0;
inline while (i < N) : (i += 1) {
values[i] = n;
}
return .{ .values = values };
}
pub fn format(
self: Self,
comptime fmt: []const u8,
options: std.fmt.FormatOptions,
writer: anytype,
) !void {
try writer.print("Vec{}[{}", .{N, self.values[0]});
comptime var i = 1;
inline while (i < N) : (i += 1) {
try writer.print(", {}", .{self.values[i]});
}
try writer.writeAll("]");
}
/// Creates a vector filled with zeroes.
pub fn zeroes() Self {
return comptime Self.filled(0);
}
/// Sums all scalars in this vector.
pub fn sum(self: Self) Scalar {
var total: Scalar = 0;
comptime var i = 0;
inline while (i < N) : (i += 1) {
total += self.values[i];
}
return total;
}
/// Adds 2 vector together.
pub fn add(self: Self, other: Self) Self {
const left: @Vector(N, Scalar) = self.values;
const right: @Vector(N, Scalar) = other.values;
return .{ .values = left + right };
}
/// Adds another vector to this vector.
pub fn addAssign(self: *Self, other: Self) void {
const left: @Vector(N, Scalar) = self.values;
const right: @Vector(N, Scalar) = other.values;
self.values = left + right;
}
/// Subtracts 2 vector together.
pub fn sub(self: Self, other: Self) Self {
const left: @Vector(N, Scalar) = self.values;
const right: @Vector(N, Scalar) = other.values;
return .{ .values = left - right };
}
/// Adds another vector to this vector.
pub fn subAssign(self: *Self, other: Self) void {
const left: @Vector(N, Scalar) = self.values;
const right: @Vector(N, Scalar) = other.values;
self.values = left - right;
}
/// Multiplies 2 vectors together.
pub fn mul(self: Self, other: Self) Self {
const left: @Vector(N, Scalar) = self.values;
const right: @Vector(N, Scalar) = other.values;
return .{ .values = left * right };
}
/// Multiplies a vector and a scalar together.
pub fn mulScalar(self: Self, n: Scalar) Self {
const left: @Vector(N, Scalar) = self.values;
const right: @Vector(N, Scalar) = Self.filled(n).values;
return .{ .values = left * right };
}
/// Multiplies this vector with another vector.
pub fn mulAssign(self: *Self, other: Self) void {
const left: @Vector(N, Scalar) = self.values;
const right: @Vector(N, Scalar) = other.values;
self.values = left * right;
}
/// Multiplies this vector with a scalar.
pub fn mulAssignScalar(self: *Self, n: Scalar) void {
const left: @Vector(N, Scalar) = self.values;
const right: @Vector(N, Scalar) = Self.filled(n).values;
self.values = left * right;
}
/// Multiplies 2 vectors together.
pub fn div(self: Self, other: Self) Self {
const left: @Vector(N, Scalar) = self.values;
const right: @Vector(N, Scalar) = other.values;
return .{ .values = left / right };
}
/// Multiplies a vector and a scalar together.
pub fn divScalar(self: Self, n: Scalar) Self {
const left: @Vector(N, Scalar) = self.values;
const right: @Vector(N, Scalar) = Self.filled(n).values;
return .{ .values = left / right };
}
/// Multiplies this vector with another vector.
pub fn divAssign(self: *Self, other: Self) void {
const left: @Vector(N, Scalar) = self.values;
const right: @Vector(N, Scalar) = other.values;
self.values = left / right;
}
/// Multiplies this vector with a scalar.
pub fn divAssignScalar(self: *Self, n: Scalar) void {
const left: @Vector(N, Scalar) = self.values;
const right: @Vector(N, Scalar) = Self.filled(n).values;
self.values = left / right;
}
/// Calculates the dot product of 2 vectors.
pub fn dot(self: Self, other: Self) Scalar {
return self.mul(other).sum();
}
/// Calculates the norm squared of this vector.
pub fn normSquared(self: Self) Scalar {
return self.dot(self);
}
/// Calculates the norm of this vector.
pub fn norm(self: Self) Scalar {
return math.sqrt(self.normSquared());
}
/// Returns a normalized version of this vector.
pub fn normalize(self: Self) Self {
const values: @Vector(N, Scalar) = self.values;
const norms: @Vector(N, Scalar) = Self.filled(self.norm()).values;
return .{ .values = values / norms };
}
/// Make this vector normalized.
pub fn normalizeAssign(self: *Self) void {
const values: @Vector(N, Scalar) = self.values;
const norms: @Vector(N, Scalar) = Self.filled(self.norm()).values;
self.values = values / norms;
}
/// Calculates the cross product of 2 vectors.
pub fn cross(self: Self, other: Self) Self {
if (N != 3) {
@compileError("A cross product can only be calculated for a 3D vector.");
}
const values = [3]Scalar{
self.values[1] * other.values[2] - self.values[2] * other.values[1],
self.values[2] * other.values[0] - self.values[0] * other.values[2],
self.values[0] * other.values[1] - self.values[1] * other.values[0],
};
return Self{ .values = values };
}
pub fn shrink(self: Self, comptime L: usize) Vector(L) {
if (L > N) unreachable;
var result: Vector(L) = undefined;
comptime var i = 0;
inline while (i < L) : (i += 1) {
result.values[i] = self.values[i];
}
return result;
}
};
}
fn expectVectorEqual(comptime N: usize, expected: Vector(N), actual: Vector(N)) void {
comptime var i = 0;
inline while (i < N) : (i += 1) {
std.testing.expectEqual(expected.values[i], actual.values[i]);
}
}
test "vector initialization" {
const actual = Vector(2).init(.{ 1, 2 });
std.testing.expectEqual(@floatCast(f32, 1), actual.values[0]);
std.testing.expectEqual(@floatCast(f32, 2), actual.values[1]);
}
test "vector scalar initialization" {
const v = Vector(3).filled(3);
expectVectorEqual(3, Vector(3).init(.{ 3, 3, 3 }), v);
}
test "vector zero initialization" {
const v = Vector(3).zeroes();
expectVectorEqual(3, Vector(3).init(.{ 0, 0, 0 }), v);
}
test "vector summation" {
const v = Vector(3).init(.{ 1, 2, 3 });
std.testing.expectEqual(@floatCast(f32, 6), v.sum());
}
test "vectors addition" {
const v1 = Vector(3).init(.{ 3, 4, 5 });
const v2 = Vector(3).init(.{ 6, 7, 8 });
expectVectorEqual(3, Vector(3).init(.{ 9, 11, 13 }), v1.add(v2));
var v3 = Vector(3).init(.{ 1, 2, 3 });
v3.addAssign(Vector(3).init(.{ 3, 2, 1 }));
expectVectorEqual(3, Vector(3).init(.{ 4, 4, 4 }), v3);
}
test "vectors subtraction" {
const v1 = Vector(3).init(.{ 3, 4, 5 });
const v2 = Vector(3).init(.{ 6, 7, 8 });
expectVectorEqual(3, Vector(3).init(.{ -3, -3, -3 }), v1.sub(v2));
var v3 = Vector(3).init(.{ 1, 2, 3 });
v3.subAssign(Vector(3).init(.{ 3, 2, 1 }));
expectVectorEqual(3, Vector(3).init(.{ -2, 0, 2 }), v3);
}
test "vector multiplication" {
const v1 = Vector(3).init(.{ 3, 4, 5 });
const v2 = Vector(3).init(.{ 6, 7, 8 });
expectVectorEqual(3, Vector(3).init(.{ 18, 28, 40 }), v1.mul(v2));
var v3 = Vector(3).init(.{ 1, 2, 3 });
v3.mulAssign(Vector(3).init(.{ 3, 2, 1 }));
expectVectorEqual(3, Vector(3).init(.{ 3, 4, 3 }), v3);
}
test "vector scalar multiplication" {
const v1 = Vector(3).init(.{ 3, 4, 5 });
expectVectorEqual(3, Vector(3).init(.{ 6, 8, 10 }), v1.mulScalar(2));
var v3 = Vector(3).init(.{ 1, 2, 3 });
v3.mulAssignScalar(3);
expectVectorEqual(3, Vector(3).init(.{ 3, 6, 9 }), v3);
}
test "vector division" {
const v1 = Vector(3).init(.{ 10, 20, 30 });
const v2 = Vector(3).init(.{ 5, 2, 6 });
expectVectorEqual(3, Vector(3).init(.{ 2, 10, 5 }), v1.div(v2));
var v3 = Vector(3).init(.{ 3, 2, 6 });
v3.divAssign(Vector(3).init(.{ 1, 2, 3 }));
expectVectorEqual(3, Vector(3).init(.{ 3, 1, 2 }), v3);
}
test "vector scalar division" {
const v1 = Vector(3).init(.{ 12, 24, 36 });
expectVectorEqual(3, Vector(3).init(.{ 1, 2, 3 }), v1.divScalar(12));
var v3 = Vector(3).init(.{ 1, 2, 3 });
v3.divAssignScalar(1);
expectVectorEqual(3, Vector(3).init(.{ 1, 2, 3 }), v3);
}
test "vector dot product" {
const v1 = Vector(3).init(.{ 1, 2, 3 });
const v2 = Vector(3).init(.{ 4, 5, 6 });
std.testing.expectEqual(@floatCast(f32, 32), v1.dot(v2));
}
test "vector norm squared" {
const v1 = Vector(2).init(.{ 3, 4 });
std.testing.expectEqual(@floatCast(f32, 25), v1.normSquared());
}
test "vector norm" {
const v1 = Vector(2).init(.{ 3, 4 });
std.testing.expectEqual(@floatCast(f32, 5), v1.norm());
}
test "vector normalization" {
const v1 = Vector(3).init(.{ 30, 10, 20 });
expectVectorEqual(3, Vector(3).init(.{0.80178372573729, 0.26726124191243, 0.53452248382486}), v1.normalize());
var v2 = Vector(3).init(.{ 60, 20, 40 });
v2.normalizeAssign();
expectVectorEqual(3, Vector(3).init(.{0.80178372573729, 0.26726124191243, 0.53452248382486}), v2);
}
test "vector cross product" {
const v1 = Vector(3).init(.{ 4, 5, 6 });
const v2 = Vector(3).init(.{ 7, 8, 9 });
expectVectorEqual(3, Vector(3).init(.{ -3, 6, -3 }), v1.cross(v2));
}