#![no_std]
#![feature(alloc)]
#![feature(euclidean_division)]
extern crate num;
#[cfg(feature = "serialize")]
#[macro_use]
extern crate serde_derive;
#[cfg(feature = "serialize")]
extern crate serde;
pub mod vec1;
pub mod vec2;
pub mod vec3;
pub mod vec4;
pub mod math;
#[macro_use]
pub mod macros;
use math::{VecNum, VecInt, VecUnsigned, VecSigned, VecFloat};
#[cfg(feature = "serialize")]
use serde::{Serialize, Deserialize};
pub trait VecItem: Copy + Clone + Default + PartialEq {}
pub trait Vector {
type Item: VecItem;
}
impl VecItem for bool {}
impl VecItem for u8 {}
impl VecItem for u16 {}
impl VecItem for u32 {}
impl VecItem for u64 {}
impl VecItem for u128 {}
impl VecItem for i8 {}
impl VecItem for i16 {}
impl VecItem for i32 {}
impl VecItem for i64 {}
impl VecItem for i128 {}
impl VecItem for f32 {}
impl VecItem for f64 {}
#[cfg(not(feature = "large_defaults"))]
pub mod defaults {
use super::*;
pub type Vec1b = vec1::Vec1<bool>;
pub type Vec2b = vec2::Vec2<bool>;
pub type Vec3b = vec3::Vec3<bool>;
pub type Vec4b = vec4::Vec4<bool>;
pub type Vec1u = vec1::Vec1<u32>;
pub type Vec2u = vec2::Vec2<u32>;
pub type Vec3u = vec3::Vec3<u32>;
pub type Vec4u = vec4::Vec4<u32>;
pub type Vec1i = vec1::Vec1<i32>;
pub type Vec2i = vec2::Vec2<i32>;
pub type Vec3i = vec3::Vec3<i32>;
pub type Vec4i = vec4::Vec4<i32>;
pub type Vec1f = vec1::Vec1<f32>;
pub type Vec2f = vec2::Vec2<f32>;
pub type Vec3f = vec3::Vec3<f32>;
pub type Vec4f = vec4::Vec4<f32>;
}
#[cfg(feature = "large_defaults")]
pub mod defaults {
use super::*;
pub type Vec1b = vec1::Vec1<bool>;
pub type Vec2b = vec2::Vec2<bool>;
pub type Vec3b = vec3::Vec3<bool>;
pub type Vec4b = vec4::Vec4<bool>;
pub type Vec1u = vec1::Vec1<u64>;
pub type Vec2u = vec2::Vec2<u64>;
pub type Vec3u = vec3::Vec3<u64>;
pub type Vec4u = vec4::Vec4<u64>;
pub type Vec1i = vec1::Vec1<i64>;
pub type Vec2i = vec2::Vec2<i64>;
pub type Vec3i = vec3::Vec3<i64>;
pub type Vec4i = vec4::Vec4<i64>;
pub type Vec1f = vec1::Vec1<f64>;
pub type Vec2f = vec2::Vec2<f64>;
pub type Vec3f = vec3::Vec3<f64>;
pub type Vec4f = vec4::Vec4<f64>;
}
pub mod prelude {
pub use super::math;
pub use super::Vector;
pub use super::vec1::Vec1;
pub use super::vec2::Vec2;
pub use super::vec3::Vec3;
pub use super::vec4::Vec4;
pub use math::VecNum;
pub use math::VecDot;
pub use math::VecInt;
pub use math::VecUnsigned;
pub use math::VecSigned;
pub use math::VecFloat;
pub use super::defaults::*;
}
#[cfg(test)]
mod tests {
use super::prelude::*;
#[test]
fn basic_construction() {
let _ = Vec1::new(1u32);
let _ = Vec2::new(1u32, 2u32);
let _ = Vec3::new(1u32, 2u32, 3u32);
let _ = Vec4::new(1u32, 2u32, 3u32, 4u32);
let _ = Vec2::from((1u32, 2u32));
let _ = Vec3::from((1u32, 2u32, 3u32));
let _ = Vec4::from((1u32, 2u32, 3u32, 4u32));
}
#[test]
fn basic_operations() {
let _ = Vec1u::new(0) + Vec1u::new(3);
let _ = Vec2u::new(0, 1) + Vec2u::new(3, 2);
let _ = Vec3u::new(0, 1, 2) + Vec3u::new(3, 2, 1);
let _ = Vec4u::new(0, 1, 2, 3) + Vec4u::new(3, 2, 1, 0);
let _ = Vec1u::new(3) - Vec1u::new(3);
let _ = Vec2u::new(3, 2) - Vec2u::new(3, 2);
let _ = Vec3u::new(3, 2, 1) - Vec3u::new(3, 2, 1);
let _ = Vec4u::new(3, 2, 1, 0) - Vec4u::new(3, 2, 1, 0);
let _ = Vec1u::new(1) * Vec1u::new(4);
let _ = Vec2u::new(1, 2) * Vec2u::new(4, 3);
let _ = Vec3u::new(1, 2, 3) * Vec3u::new(4, 3, 2);
let _ = Vec4u::new(1, 2, 3, 4) * Vec4u::new(4, 3, 2, 1);
let _ = Vec1u::new(4) / Vec1u::new(5);
let _ = Vec2u::new(4, 3) / Vec2u::new(5, 4);
let _ = Vec3u::new(4, 3, 2) / Vec3u::new(5, 4, 3);
let _ = Vec4u::new(4, 3, 2, 1) / Vec4u::new(5, 4, 3, 2);
}
#[test]
fn primitive_operations() {
let _ = Vec1u::new(0) + 1;
let _ = Vec2u::new(0, 1) + 2;
let _ = Vec3u::new(0, 1, 2) + 3;
let _ = Vec4u::new(0, 1, 2, 3) + 4;
let _ = Vec1u::new(6) - 1;
let _ = Vec2u::new(6, 7) - 2;
let _ = Vec3u::new(6, 7, 8) - 3;
let _ = Vec4u::new(6, 7, 8, 9) - 4;
let _ = Vec1u::new(0) * 1;
let _ = Vec2u::new(0, 1) * 2;
let _ = Vec3u::new(0, 1, 2) * 3;
let _ = Vec4u::new(0, 1, 2, 3) * 4;
let _ = Vec1u::new(0) / 1;
let _ = Vec2u::new(0, 1) / 2;
let _ = Vec3u::new(0, 1, 2) / 3;
let _ = Vec4u::new(0, 1, 2, 3) / 4;
}
#[test]
fn basic_assignment() {
let mut v1 = Vec1u::new(0);
let mut v2 = Vec2u::new(0, 1);
let mut v3 = Vec3u::new(0, 1, 2);
let mut v4 = Vec4u::new(0, 1, 2, 3);
v1 += Vec1u::new(0);
v1 -= Vec1u::new(0);
v1 *= Vec1u::new(1);
v1 /= Vec1u::new(1);
v2 += Vec2u::new(0, 1);
v2 -= Vec2u::new(0, 1);
v2 *= Vec2u::new(1, 2);
v2 /= Vec2u::new(1, 2);
v3 += Vec3u::new(0, 1, 2);
v3 -= Vec3u::new(0, 1, 2);
v3 *= Vec3u::new(1, 2, 3);
v3 /= Vec3u::new(1, 2, 3);
v4 += Vec4u::new(0, 1, 2, 3);
v4 -= Vec4u::new(0, 1, 2, 3);
v4 *= Vec4u::new(1, 2, 3, 4);
v4 /= Vec4u::new(1, 2, 3, 4);
}
#[test]
fn primitive_assignment() {
let mut v1 = Vec1u::new(0);
let mut v2 = Vec2u::new(0, 1);
let mut v3 = Vec3u::new(0, 1, 2);
let mut v4 = Vec4u::new(0, 1, 2, 3);
v1 += 0;
v1 -= 0;
v1 *= 1;
v1 /= 1;
v2 += 0;
v2 -= 0;
v2 *= 1;
v2 /= 1;
v3 += 0;
v3 -= 0;
v3 *= 1;
v3 /= 1;
v4 += 0;
v4 -= 0;
v4 *= 1;
v4 /= 1;
}
fn pass_vec1u(_: Vec1u) {}
fn pass_vec2u(_: Vec2u) {}
fn pass_vec3u(_: Vec3u) {}
fn pass_vec4u(_: Vec4u) {}
#[test]
fn pass_to_func() {
pass_vec1u(vec1!(1));
pass_vec2u(vec2!(1, 2));
pass_vec3u(vec3!(1, 2, 3));
pass_vec4u(vec4!(1, 2, 3, 4));
}
#[test]
fn dot_product_vec2i(){
let zero = vec2!(0, 0);
let one = vec2!(1, 1);
let right = vec2!(1, 0);
let left = vec2!(-1, 0);
let up = vec2!(0, 1);
assert_eq!(zero.dot(zero), 0);
assert_eq!(one.dot(one), 2);
assert_eq!(right.dot(up), 0);
assert_eq!(right.dot(right), 1);
assert_eq!(right.dot(left), -1);
}
#[test]
fn dot_product_vec3f(){
let zero = vec3!(0.0, 0.0, 0.0);
let one = vec3!(1.0, 1.0, 1.0);
let right = vec3!(1.0, 0.0, 0.0);
let left = vec3!(-1.0, 0.0, 0.0);
let up = vec3!(0.0, 1.0, 0.0);
fn f_eq(a: f64, b: f64) -> bool {
(b - a).abs() < 0.01
}
assert!(f_eq(zero.dot(zero), 0.0));
assert!(f_eq(one.dot(one), 3.0));
assert!(f_eq(right.dot(up), 0.0));
assert!(f_eq(right.dot(right), 1.0));
assert!(f_eq(right.dot(left), -1.0));
}
fn length_of<V: VecFloat>(vec: V) -> V::Item where V::Item: math::Float {
vec.length()
}
#[test]
fn pass_generic() {
let v3 = vec3!(1.5, 2.0, 6.5);
let _ = v3.length();
let _ = length_of(v3);
}
#[test]
fn macros() {
let _v1_0 = vec1!(7);
let _v1_1 = vec1!([7]);
let _v1_2 = vec1![7; 1];
let _v2_0 = vec2!(7, 5);
let _v2_1 = vec2!([7, 5]);
let _v2_2 = vec2![7; 2];
let _v3_0 = vec3!(7, 5, 3);
let _v3_1 = vec3!([7, 5, 3]);
let _v3_2 = vec3![7; 3];
let _v4_0 = vec4!(7, 5, 3 ,1);
let _v4_1 = vec4!([7, 5, 3, 1]);
let _v4_2 = vec4![7; 4];
}
#[cfg(feature = "serialize")]
#[test]
fn serialize() {
}
#[cfg(feature = "serialize")]
#[test]
fn deserialize() {
}
}