matthew
/
vanrijn
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
vanrijn/src/lib.rs

786 lines
20 KiB
Rust
Raw Blame History

use std::ops::Add;
use std::ops::Mul;
use std::ops::Sub;
#[derive(Clone, Copy, Eq, PartialEq)]
struct Vector2D<T>(T, T);
impl<T: Add> Add for Vector2D<T> {
type Output = Vector2D<T::Output>;
fn add(self, other: Vector2D<T>) -> Vector2D<T::Output> {
Vector2D(self.0 + other.0, self.1 + other.1)
}
}
impl<T: Sub> Sub for Vector2D<T> {
type Output = Vector2D<T::Output>;
fn sub(self, other: Vector2D<T>) -> Vector2D<T::Output> {
Vector2D(self.0 - other.0, self.1 - other.1)
}
}
impl<T: Mul + Copy> Mul<T> for Vector2D<T> {
type Output = Vector2D<T::Output>;
fn mul(self, other: T) -> Vector2D<T::Output> {
Vector2D(self.0 * other, self.1 * other)
}
}
impl Mul<Vector2D<f64>> for f64 {
type Output = Vector2D<f64>;
fn mul(self, other: Vector2D<f64>) -> Vector2D<f64> {
Vector2D(self * other.0, self * other.1)
}
}
#[derive(Clone, Copy, Eq, PartialEq)]
struct Vector3D<T>(T, T, T);
impl<T: Add> Add for Vector3D<T> {
type Output = Vector3D<T::Output>;
fn add(self, other: Vector3D<T>) -> Vector3D<T::Output> {
Vector3D(self.0 + other.0, self.1 + other.1, self.2 + other.2)
}
}
impl<T: Sub> Sub for Vector3D<T> {
type Output = Vector3D<T::Output>;
fn sub(self, other: Vector3D<T>) -> Vector3D<T::Output> {
Vector3D(self.0 - other.0, self.1 - other.1, self.2 - other.2)
}
}
impl<T: Mul + Copy> Mul<T> for Vector3D<T> {
type Output = Vector3D<T::Output>;
fn mul(self, other: T) -> Vector3D<T::Output> {
Vector3D(self.0 * other, self.1 * other, self.2 * other)
}
}
impl Mul<Vector3D<f64>> for f64 {
type Output = Vector3D<f64>;
fn mul(self, other: Vector3D<f64>) -> Vector3D<f64> {
Vector3D(self * other.0, self * other.1, self * other.2)
}
}
#[derive(Clone, Copy, Eq, PartialEq)]
struct Point2D<T>(T, T);
impl<T: Add> Add<Vector2D<T>> for Point2D<T> {
type Output = Point2D<T::Output>;
fn add(self, other: Vector2D<T>) -> Point2D<T::Output> {
Point2D(self.0 + other.0, self.1 + other.1)
}
}
#[derive(Clone, Copy, Eq, PartialEq)]
struct Point3D<T>(T, T, T);
impl<T: Add> Add<Vector3D<T>> for Point3D<T> {
type Output = Point3D<T::Output>;
fn add(self, other: Vector3D<T>) -> Point3D<T::Output> {
Point3D(self.0 + other.0, self.1 + other.1, self.2 + other.2)
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn test_vector2_add_zeroes_yields_zeroes() {
let a = Vector2D(0.0, 0.0);
let b = Vector2D(0.0, 0.0);
let c = a + b;
assert!(c.0 == 0.0);
assert!(c.1 == 0.0);
}
#[test]
fn test_vector2d_addition_identity() {
let id = Vector2D(0.0, 0.0);
let a = Vector2D(1.0, 2.0);
{
let c = a + id;
assert!(c.0 == a.0);
assert!(c.1 == a.1);
}
{
let d = id + a;
assert!(d.0 == a.0);
assert!(d.1 == a.1);
}
}
#[test]
fn test_vector2d_addition_float() {
let a = Vector2D(1.0, 2.0);
let b = Vector2D(4.0, 3.0);
let c = Vector2D(-1.0, -5.5);
let d = Vector2D(1.0, -2.0);
{
let r = a + b;
assert!(r.0 == a.0 + b.0);
assert!(r.1 == a.1 + b.1);
}
{
let r = b + a;
assert!(r.0 == a.0 + b.0);
assert!(r.1 == a.1 + b.1);
}
{
let r = b + c;
assert!(r.0 == b.0 + c.0);
assert!(r.1 == b.1 + c.1);
}
{
let r = c + b;
assert!(r.0 == b.0 + c.0);
assert!(r.1 == b.1 + c.1);
}
{
let r = c + d;
assert!(r.0 == c.0 + d.0);
assert!(r.1 == c.1 + d.1);
}
{
let r = d + c;
assert!(r.0 == c.0 + d.0);
assert!(r.1 == c.1 + d.1);
}
}
#[test]
fn test_vector2d_addition_int() {
let a = Vector2D(1, 2);
let b = Vector2D(4, 3);
let c = Vector2D(-1, -5);
let d = Vector2D(1, -2);
{
let r = a + b;
assert!(r.0 == a.0 + b.0);
assert!(r.1 == a.1 + b.1);
}
{
let r = b + a;
assert!(r.0 == a.0 + b.0);
assert!(r.1 == a.1 + b.1);
}
{
let r = b + c;
assert!(r.0 == b.0 + c.0);
assert!(r.1 == b.1 + c.1);
}
{
let r = c + b;
assert!(r.0 == b.0 + c.0);
assert!(r.1 == b.1 + c.1);
}
{
let r = c + d;
assert!(r.0 == c.0 + d.0);
assert!(r.1 == c.1 + d.1);
}
{
let r = d + c;
assert!(r.0 == c.0 + d.0);
assert!(r.1 == c.1 + d.1);
}
}
#[test]
fn test_vector2_subtrace_zeroes_yields_zeroes() {
let a = Vector2D(0.0, 0.0);
let b = Vector2D(0.0, 0.0);
let c = a - b;
assert!(c.0 == 0.0);
assert!(c.1 == 0.0);
}
#[test]
fn test_vector2d_subtraction_identity() {
let id = Vector2D(0.0, 0.0);
let a = Vector2D(1.0, 2.0);
let c = a - id;
assert!(c.0 == a.0);
assert!(c.1 == a.1);
}
#[test]
fn test_vector2d_subtraction_float() {
let a = Vector2D(1.0, 2.0);
let b = Vector2D(4.0, 3.0);
let c = Vector2D(-1.0, -5.5);
let d = Vector2D(1.0, -2.0);
{
let r = a - b;
assert!(r.0 == a.0 - b.0);
assert!(r.1 == a.1 - b.1);
}
{
let r = b - a;
assert!(r.0 == b.0 - a.0);
assert!(r.1 == b.1 - a.1);
}
{
let r = b - c;
assert!(r.0 == b.0 - c.0);
assert!(r.1 == b.1 - c.1);
}
{
let r = c - b;
assert!(r.0 == c.0 - b.0);
assert!(r.1 == c.1 - b.1);
}
{
let r = c - d;
assert!(r.0 == c.0 - d.0);
assert!(r.1 == c.1 - d.1);
}
{
let r = d - c;
assert!(r.0 == d.0 - c.0);
assert!(r.1 == d.1 - c.1);
}
}
#[test]
fn test_vector2d_subrtaction_int() {
let a = Vector2D(1, 2);
let b = Vector2D(4, 3);
let c = Vector2D(-1, -5);
let d = Vector2D(1, -2);
{
let r = a - b;
assert!(r.0 == a.0 - b.0);
assert!(r.1 == a.1 - b.1);
}
{
let r = b - a;
assert!(r.0 == b.0 - a.0);
assert!(r.1 == b.1 - a.1);
}
{
let r = b - c;
assert!(r.0 == b.0 - c.0);
assert!(r.1 == b.1 - c.1);
}
{
let r = c - b;
assert!(r.0 == c.0 - b.0);
assert!(r.1 == c.1 - b.1);
}
{
let r = c - d;
assert!(r.0 == c.0 - d.0);
assert!(r.1 == c.1 - d.1);
}
{
let r = d - c;
assert!(r.0 == d.0 - c.0);
assert!(r.1 == d.1 - c.1);
}
}
#[test]
fn test_vector2_multiply_zeroes_yields_zeroes() {
let a = Vector2D(0.0, 0.0);
let b = 0.0;
let c = a * b;
assert!(c.0 == 0.0);
assert!(c.1 == 0.0);
}
#[test]
fn test_vector2_multiplication_by_zero_yields_zeroes() {
let a = Vector2D(1.0, 2.0);
let b = 0.0;
let c = a * b;
assert!(c.0 == 0.0);
assert!(c.1 == 0.0);
}
#[test]
fn test_vector2_multiplication_identity() {
let a = Vector2D(1.0, 2.0);
let b = 1.0;
let c = a * b;
assert!(c.0 == a.0);
assert!(c.1 == a.1);
}
#[test]
fn test_vector2_multiplication_by_positive_float() {
let a = Vector2D(1.0, 2.0);
let b = 2.0;
let c = a * b;
assert!(c.0 == a.0 * 2.0);
assert!(c.1 == a.1 * 2.0);
}
#[test]
fn test_vector2_multiplication_by_negative_float() {
let a = Vector2D(1.0, 2.0);
let b = -2.0;
let c = a * b;
assert!(c.0 == a.0 * -2.0);
assert!(c.1 == a.1 * -2.0);
}
#[test]
fn test_vector2_multiplication_by_positive_int() {
let a = Vector2D(1, 2);
let b = 2;
let c = a * b;
assert!(c.0 == a.0 * 2);
assert!(c.1 == a.1 * 2);
}
#[test]
fn test_vector2_multiplication_by_negative_int() {
let a = Vector2D(1, 2);
let b = -2;
let c = a * b;
assert!(c.0 == a.0 * -2);
assert!(c.1 == a.1 * -2);
}
#[test]
fn test_vector2_multiply_zeroes_yields_zeroes_scalar_first() {
let a = Vector2D(0.0, 0.0);
let b = 0.0;
let c = b * a;
assert!(c.0 == 0.0);
assert!(c.1 == 0.0);
}
#[test]
fn test_vector2_multiply_zero_byvector2d_yields_zeroes() {
let a = Vector2D(1.0, 2.0);
let b = 0.0;
let c = b * a;
assert!(c.0 == 0.0);
assert!(c.1 == 0.0);
}
#[test]
fn test_vector2_multiplication_identity_scalar_first() {
let a = Vector2D(1.0, 2.0);
let b = 1.0;
let c = b * a;
assert!(c.0 == a.0);
assert!(c.1 == a.1);
}
#[test]
fn test_vector2_multiply_positive_float_by_vector2d() {
let a = Vector2D(1.0, 2.0);
let b = 2.0;
let c = b * a;
assert!(c.0 == a.0 * 2.0);
assert!(c.1 == a.1 * 2.0);
}
#[test]
fn test_vector2_multiply_negative_float_by_vector2d() {
let a = Vector2D(1.0, 2.0);
let b = -2.0;
let c = b * a;
assert!(c.0 == a.0 * -2.0);
assert!(c.1 == a.1 * -2.0);
}
#[test]
fn test_vector3d_add_zeroes_yields_zeroes() {
let a = Vector3D(0.0, 0.0, 0.0);
let b = Vector3D(0.0, 0.0, 0.0);
let c = a + b;
assert!(c.0 == 0.0);
assert!(c.1 == 0.0);
assert!(c.2 == 0.0);
}
#[test]
fn test_vector3d_addition_identity() {
let id = Vector3D(0.0, 0.0, 0.0);
let a = Vector3D(1.0, 2.0, 3.0);
{
let c = a + id;
assert!(c.0 == a.0);
assert!(c.1 == a.1);
assert!(c.2 == a.2);
}
{
let d = id + a;
assert!(d.0 == a.0);
assert!(d.1 == a.1);
assert!(d.2 == a.2);
}
}
#[test]
fn test_vector3d_addition_float() {
let a = Vector3D(1.0, 2.0, 1.5);
let b = Vector3D(4.0, 3.0, 2.0);
let c = Vector3D(-1.0, -5.5, 3.0);
let d = Vector3D(1.0, -2.0, 1.0);
{
let r = a + b;
assert!(r.0 == a.0 + b.0);
assert!(r.1 == a.1 + b.1);
assert!(r.2 == a.2 + b.2);
}
{
let r = b + a;
assert!(r.0 == a.0 + b.0);
assert!(r.1 == a.1 + b.1);
assert!(r.2 == a.2 + b.2);
}
{
let r = b + c;
assert!(r.0 == b.0 + c.0);
assert!(r.1 == b.1 + c.1);
assert!(r.2 == b.2 + c.2);
}
{
let r = c + b;
assert!(r.0 == b.0 + c.0);
assert!(r.1 == b.1 + c.1);
assert!(r.2 == b.2 + c.2);
}
{
let r = c + d;
assert!(r.0 == c.0 + d.0);
assert!(r.1 == c.1 + d.1);
assert!(r.2 == c.2 + d.2);
}
{
let r = d + c;
assert!(r.0 == c.0 + d.0);
assert!(r.1 == c.1 + d.1);
assert!(r.2 == c.2 + d.2);
}
}
#[test]
fn test_vector3d_addition_int() {
let a = Vector3D(1, 2, 1);
let b = Vector3D(4, 3, 2);
let c = Vector3D(-1, -5, 3);
let d = Vector3D(1, -2, 1);
{
let r = a + b;
assert!(r.0 == a.0 + b.0);
assert!(r.1 == a.1 + b.1);
assert!(r.2 == a.2 + b.2);
}
{
let r = b + a;
assert!(r.0 == a.0 + b.0);
assert!(r.1 == a.1 + b.1);
assert!(r.2 == a.2 + b.2);
}
{
let r = b + c;
assert!(r.0 == b.0 + c.0);
assert!(r.1 == b.1 + c.1);
assert!(r.2 == b.2 + c.2);
}
{
let r = c + b;
assert!(r.0 == b.0 + c.0);
assert!(r.1 == b.1 + c.1);
assert!(r.2 == b.2 + c.2);
}
{
let r = c + d;
assert!(r.0 == c.0 + d.0);
assert!(r.1 == c.1 + d.1);
assert!(r.2 == c.2 + d.2);
}
{
let r = d + c;
assert!(r.0 == c.0 + d.0);
assert!(r.1 == c.1 + d.1);
assert!(r.2 == c.2 + d.2);
}
}
#[test]
fn test_vector3d_subtract_zeroes_yields_zeroes() {
let a = Vector3D(0.0, 0.0, 0.0);
let b = Vector3D(0.0, 0.0, 0.0);
let c = a - b;
assert!(c.0 == 0.0);
assert!(c.1 == 0.0);
assert!(c.2 == 0.0);
}
#[test]
fn test_vector3d_subtraction_identity() {
let id = Vector3D(0.0, 0.0, 0.0);
let a = Vector3D(1.0, 2.0, 3.0);
{
let c = a - id;
assert!(c.0 == a.0);
assert!(c.1 == a.1);
assert!(c.2 == a.2);
}
}
#[test]
fn test_vector3d_subtraction_float() {
let a = Vector3D(1.0, 2.0, 1.5);
let b = Vector3D(4.0, 3.0, 2.0);
let c = Vector3D(-1.0, -5.5, 3.0);
let d = Vector3D(1.0, -2.0, 1.0);
{
let r = a - b;
assert!(r.0 == a.0 - b.0);
assert!(r.1 == a.1 - b.1);
assert!(r.2 == a.2 - b.2);
}
{
let r = b - a;
assert!(r.0 == b.0 - a.0);
assert!(r.1 == b.1 - a.1);
assert!(r.2 == b.2 - a.2);
}
{
let r = b - c;
assert!(r.0 == b.0 - c.0);
assert!(r.1 == b.1 - c.1);
assert!(r.2 == b.2 - c.2);
}
{
let r = c - b;
assert!(r.0 == c.0 - b.0);
assert!(r.1 == c.1 - b.1);
assert!(r.2 == c.2 - b.2);
}
{
let r = c - d;
assert!(r.0 == c.0 - d.0);
assert!(r.1 == c.1 - d.1);
assert!(r.2 == c.2 - d.2);
}
{
let r = d - c;
assert!(r.0 == d.0 - c.0);
assert!(r.1 == d.1 - c.1);
assert!(r.2 == d.2 - c.2);
}
}
#[test]
fn test_vector3d_subtraction_int() {
let a = Vector3D(1, 2, 1);
let b = Vector3D(4, 3, 2);
let c = Vector3D(-1, -5, 3);
let d = Vector3D(1, -2, 1);
{
let r = a - b;
assert!(r.0 == a.0 - b.0);
assert!(r.1 == a.1 - b.1);
assert!(r.2 == a.2 - b.2);
}
{
let r = b - a;
assert!(r.0 == b.0 - a.0);
assert!(r.1 == b.1 - a.1);
assert!(r.2 == b.2 - a.2);
}
{
let r = b - c;
assert!(r.0 == b.0 - c.0);
assert!(r.1 == b.1 - c.1);
assert!(r.2 == b.2 - c.2);
}
{
let r = c - b;
assert!(r.0 == c.0 - b.0);
assert!(r.1 == c.1 - b.1);
assert!(r.2 == c.2 - b.2);
}
{
let r = c - d;
assert!(r.0 == c.0 - d.0);
assert!(r.1 == c.1 - d.1);
assert!(r.2 == c.2 - d.2);
}
{
let r = d - c;
assert!(r.0 == d.0 - c.0);
assert!(r.1 == d.1 - c.1);
assert!(r.2 == d.2 - c.2);
}
}
#[test]
fn test_vector3_multiply_zeroes_yields_zeroes() {
let a = Vector3D(0.0, 0.0, 0.0);
let b = 0.0;
let c = a * b;
assert!(c.0 == 0.0);
assert!(c.1 == 0.0);
assert!(c.2 == 0.0);
}
#[test]
fn test_vector3_multiplication_by_zero_yields_zeroes() {
let a = Vector3D(1.0, 2.0, 3.0);
let b = 0.0;
let c = a * b;
assert!(c.0 == 0.0);
assert!(c.1 == 0.0);
assert!(c.2 == 0.0);
}
#[test]
fn test_vector3_multiplication_identity() {
let a = Vector3D(1.0, 2.0, 3.0);
let b = 1.0;
let c = a * b;
assert!(c == a);
}
#[test]
fn test_vector3_multiplication_by_positive_float() {
let a = Vector3D(1.0, 2.0, 3.0);
let b = 2.0;
let c = a * b;
assert!(c.0 == a.0 * 2.0);
assert!(c.1 == a.1 * 2.0);
assert!(c.2 == a.2 * 2.0);
}
#[test]
fn test_vector3_multiplication_by_negative_float() {
let a = Vector3D(1.0, 2.0, 3.0);
let b = -2.0;
let c = a * b;
assert!(c.0 == a.0 * -2.0);
assert!(c.1 == a.1 * -2.0);
assert!(c.2 == a.2 * -2.0);
}
#[test]
fn test_vector3_multiplication_by_positive_int() {
let a = Vector3D(1, 2, 3);
let b = 2;
let c = a * b;
assert!(c.0 == a.0 * 2);
assert!(c.1 == a.1 * 2);
assert!(c.2 == a.2 * 2);
}
#[test]
fn test_vector3_multiplication_by_negative_int() {
let a = Vector3D(1, 2, 3);
let b = -2;
let c = a * b;
assert!(c.0 == a.0 * -2);
assert!(c.1 == a.1 * -2);
assert!(c.2 == a.2 * -2);
}
#[test]
fn test_vector3_multiply_zeroes_yields_zeroes_scalar_first() {
let a = Vector3D(0.0, 0.0, 0.0);
let b = 0.0;
let c = b * a;
assert!(c.0 == 0.0);
assert!(c.1 == 0.0);
assert!(c.2 == 0.0);
}
#[test]
fn test_vector3_multiply_zero_byvector2d_yields_zeroes() {
let a = Vector3D(1.0, 2.0, 3.0);
let b = 0.0;
let c = b * a;
assert!(c.0 == 0.0);
assert!(c.1 == 0.0);
assert!(c.2 == 0.0);
}
#[test]
fn test_vector3_multiplication_identity_scalar_first() {
let a = Vector3D(1.0, 2.0, 3.0);
let b = 1.0;
let c = b * a;
assert!(c.0 == a.0);
assert!(c.1 == a.1);
assert!(c.2 == a.2);
}
#[test]
fn test_vector3_multiply_positive_float_by_vector2d() {
let a = Vector3D(1.0, 2.0, 3.0);
let b = 2.0;
let c = b * a;
assert!(c.0 == a.0 * 2.0);
assert!(c.1 == a.1 * 2.0);
assert!(c.2 == a.2 * 2.0);
}
#[test]
fn test_vector3_multiply_negative_float_by_vector2d() {
let a = Vector3D(1.0, 2.0, 3.0);
let b = -2.0;
let c = b * a;
assert!(c.0 == a.0 * -2.0);
assert!(c.1 == a.1 * -2.0);
assert!(c.2 == a.2 * -2.0);
}
#[test]
fn test_point2d_add_zero_vector2d() {
let a = Point2D(1.0, 2.3);
let b = Vector2D(0.0, 0.0);
let c = a + b;
assert!(c.0 == 1.0);
assert!(c.1 == 2.3);
}
#[test]
fn test_point2d_add_vector2d() {
let a = Point2D(1.0, 2.3);
let b = Vector2D(1.1, -1.0);
let c = a + b;
assert!(c.0 == a.0 + b.0);
assert!(c.1 == a.1 + b.1);
}
#[test]
fn test_point3d_add_zero_vector3d() {
let a = Point3D(1.0, 2.3, 4.5);
let b = Vector3D(0.0, 0.0, 0.0);
let c = a + b;
assert!(c.0 == 1.0);
assert!(c.1 == 2.3);
assert!(c.2 == 4.5);
}
#[test]
fn test_point3d_add_vector3d() {
let a = Point3D(1.0, 2.3, 4.5);
let b = Vector3D(1.1, -1.0, 0.5);
let c = a + b;
assert!(c.0 == a.0 + b.0);
assert!(c.1 == a.1 + b.1);
assert!(c.2 == a.2 + b.2);
}
}
Reference in New Issue View Git Blame Copy Permalink