Reorganise funs module to mirror chapter 8 of the GLSL spec

src/funs/approx.rs

@@ -1,180 +0,0 @@
-use num::cast::cast;
-use vec::{Vec2, Vec3, Vec4};
-
-pub trait Approx {
-    pure fn floor() -> self;
-    pure fn trunc() -> self;
-    pure fn round() -> self;
-    // pure fn roundEven() -> self;
-    pure fn ceil()  -> self;
-    pure fn fract() -> self;
-}
-
-#[inline(always)] pub pure fn floor<T:Approx>(x: &T) -> T { x.floor() }
-#[inline(always)] pub pure fn trunc<T:Approx>(x: &T) -> T { x.trunc() }
-#[inline(always)] pub pure fn round<T:Approx>(x: &T) -> T { x.round() }
-// #[inline(always)] pub pure fn roundEven<T:Approx>(x: &T) -> T { x.roundEven() }
-#[inline(always)] pub pure fn ceil<T:Approx>(x: &T)  -> T { x.ceil() }
-#[inline(always)] pub pure fn fract<T:Approx>(x: &T) -> T { x.fract() }
-
-pub impl f32: Approx {
-    #[inline(always)] pure fn floor() -> f32 { cast(cmath::c_float_utils::floor(self)) }
-    #[inline(always)] pure fn trunc() -> f32 { cast(cmath::c_float_utils::trunc(self)) }
-    #[inline(always)] pure fn round() -> f32 { cast(cmath::c_float_utils::round(self)) }
-    // #[inline(always)] pure fn roundEven() -> f32 {}
-    #[inline(always)] pure fn ceil()  -> f32 { cast(cmath::c_float_utils::ceil(self)) }
-    #[inline(always)] pure fn fract() -> f32 { self - floor(&self) }
-}
-
-pub impl f64: Approx {
-    #[inline(always)] pure fn floor() -> f64 { cast(cmath::c_double_utils::floor(self)) }
-    #[inline(always)] pure fn trunc() -> f64 { cast(cmath::c_double_utils::trunc(self)) }
-    #[inline(always)] pure fn round() -> f64 { cast(cmath::c_double_utils::round(self)) }
-    // #[inline(always)] pure fn roundEven() -> f64 {}
-    #[inline(always)] pure fn ceil()  -> f64 { cast(cmath::c_double_utils::ceil(self)) }
-    #[inline(always)] pure fn fract() -> f64 { self - floor(&self) }
-}
-
-pub impl float: Approx {
-    #[inline(always)] pure fn floor() -> float { cast(cmath::c_float_utils::floor(cast(self))) }
-    #[inline(always)] pure fn trunc() -> float { cast(cmath::c_float_utils::trunc(cast(self))) }
-    #[inline(always)] pure fn round() -> float { cast(cmath::c_float_utils::round(cast(self))) }
-    // #[inline(always)] pure fn roundEven() -> float {}
-    #[inline(always)] pure fn ceil()  -> float { cast(cmath::c_float_utils::ceil(cast(self))) }
-    #[inline(always)] pure fn fract() -> float { self - floor(&self) }
-}
-
-pub impl<T:Copy Approx> Vec2<T>: Approx {
-    #[inline(always)]
-    pure fn floor() -> Vec2<T> {
-        Vec2::new(floor(&self[0]),
-                  floor(&self[1]))
-    }
-    
-    #[inline(always)]
-    pure fn trunc() -> Vec2<T> {
-        Vec2::new(trunc(&self[0]),
-                  trunc(&self[1]))
-    }
-    
-    #[inline(always)]
-    pure fn round() -> Vec2<T> {
-        Vec2::new(round(&self[0]),
-                  round(&self[1]))
-    }
-    
-    // #[inline(always)]
-    // pure fn ceil()  -> Vec2<T> {
-    //     Vec2::new(roundEven(&self[0]),
-    //               roundEven(&self[1]))
-    // }
-    
-    #[inline(always)]
-    pure fn ceil()  -> Vec2<T> {
-        Vec2::new(ceil(&self[0]),
-                  ceil(&self[1]))
-    }
-    
-    #[inline(always)]
-    pure fn fract() -> Vec2<T> {
-        Vec2::new(fract(&self[0]),
-                  fract(&self[1]))
-    }
-    
-}
-
-pub impl<T:Copy Approx> Vec3<T>: Approx {
-    #[inline(always)]
-    pure fn floor() -> Vec3<T> {
-        Vec3::new(floor(&self[0]),
-                  floor(&self[1]),
-                  floor(&self[2]))
-    }
-    
-    #[inline(always)]
-    pure fn trunc() -> Vec3<T> {
-        Vec3::new(trunc(&self[0]),
-                  trunc(&self[1]),
-                  trunc(&self[2]))
-    }
-    
-    #[inline(always)]
-    pure fn round() -> Vec3<T> {
-        Vec3::new(round(&self[0]),
-                  round(&self[1]),
-                  round(&self[2]))
-    }
-    
-    // #[inline(always)]
-    // pure fn ceil()  -> Vec3<T> {
-    //     Vec3::new(roundEven(&self[0]),
-    //               roundEven(&self[1]),
-    //               roundEven(&self[2]))
-    // }
-    
-    #[inline(always)]
-    pure fn ceil()  -> Vec3<T> {
-        Vec3::new(ceil(&self[0]),
-                  ceil(&self[1]),
-                  ceil(&self[2]))
-    }
-    
-    #[inline(always)]
-    pure fn fract() -> Vec3<T> {
-        Vec3::new(fract(&self[0]),
-                  fract(&self[1]),
-                  fract(&self[2]))
-    }
-    
-}
-
-pub impl<T:Copy Approx> Vec4<T>: Approx {
-    #[inline(always)]
-    pure fn floor() -> Vec4<T> {
-        Vec4::new(floor(&self[0]),
-                  floor(&self[1]),
-                  floor(&self[2]),
-                  floor(&self[3]))
-    }
-    
-    #[inline(always)]
-    pure fn trunc() -> Vec4<T> {
-        Vec4::new(trunc(&self[0]),
-                  trunc(&self[1]),
-                  trunc(&self[2]),
-                  trunc(&self[3]))
-    }
-    
-    #[inline(always)]
-    pure fn round() -> Vec4<T> {
-        Vec4::new(round(&self[0]),
-                  round(&self[1]),
-                  round(&self[2]),
-                  round(&self[3]))
-    }
-    
-    // #[inline(always)]
-    // pure fn ceil()  -> Vec4<T> {
-    //     Vec4::new(roundEven(&self[0]),
-    //               roundEven(&self[1]),
-    //               roundEven(&self[2]),
-    //               roundEven(&self[3]))
-    // }
-    
-    #[inline(always)]
-    pure fn ceil()  -> Vec4<T> {
-        Vec4::new(ceil(&self[0]),
-                  ceil(&self[1]),
-                  ceil(&self[2]),
-                  ceil(&self[3]))
-    }
-    
-    #[inline(always)]
-    pure fn fract() -> Vec4<T> {
-        Vec4::new(fract(&self[0]),
-                  fract(&self[1]),
-                  fract(&self[2]),
-                  fract(&self[3]))
-    }
-    
-}

src/funs/boolv.rs

@@ -1,53 +0,0 @@
-use vec::{Vector, Vec2, Vec3, Vec4};
-
-pub trait BooleanVector: Vector<bool> {
-    pure fn any() -> bool;
-    pure fn all() -> bool;
-    pure fn not() -> self;
-}
-
-#[inline(always)] pub pure fn any<T:BooleanVector>(x: &T) -> bool { x.any() }
-#[inline(always)] pub pure fn all<T:BooleanVector>(x: &T) -> bool { x.all() }
-#[inline(always)] pub pure fn not<T:BooleanVector>(x: &T) -> T    { x.not() }
-
-pub impl Vec2<bool>: BooleanVector {
-    pure fn any() -> bool {
-        self[0] || self[1]
-    }
-    
-    pure fn all() -> bool {
-        self[0] && self[1]
-    }
-    
-    pure fn not() -> Vec2<bool> { 
-        Vec2::new(!self[0], !self[1])
-    }
-}
-
-pub impl Vec3<bool>: BooleanVector {
-    pure fn any() -> bool {
-        self[0] || self[1] || self[2]
-    }
-    
-    pure fn all() -> bool {
-        self[0] && self[1] && self[2]
-    }
-    
-    pure fn not() -> Vec3<bool> { 
-        Vec3::new(!self[0], !self[1], !self[2])
-    }
-}
-
-pub impl Vec4<bool>: BooleanVector {
-    pure fn any() -> bool {
-        self[0] || self[1] || self[2] || self[3]
-    }
-    
-    pure fn all() -> bool {
-        self[0] && self[1] && self[2] && self[3]
-    }
-    
-    pure fn not() -> Vec4<bool> { 
-        Vec4::new(!self[0], !self[1], !self[2], !self[3])
-    }
-}

src/funs/common.rs

@@ -0,0 +1,583 @@
+use num::cast::cast;
+use vec::{Vec2, Vec3, Vec4};
+
+/// Should only be implemented on signed types.
+pub trait Sign {
+    pure fn abs() -> self;
+    
+    /// returns `-1` if the number is negative, `0` if the number is equal to 0,
+    /// and `1` if the number is positive
+    pure fn sign() -> self;
+}
+
+#[inline(always)] pub pure fn abs<T:Sign>(x: &T)  -> T { x.abs()  }
+#[inline(always)] pub pure fn sign<T:Sign>(x: &T) -> T { x.sign() }
+
+pub impl i8: Sign {
+    #[inline(always)] pure fn abs()  -> i8 { if self >= 0 { self } else {-self } }
+    #[inline(always)] pure fn sign() -> i8 { if self > 0 { 1 } else if self == 0 { 0 } else { -1 } }
+}
+
+pub impl i16: Sign {
+    #[inline(always)] pure fn abs()  -> i16 { if self >= 0 { self } else {-self } }
+    #[inline(always)] pure fn sign() -> i16 { if self > 0 { 1 } else if self == 0 { 0 } else { -1 } }
+}
+
+pub impl i32: Sign {
+    #[inline(always)] pure fn abs()  -> i32 { if self >= 0 { self } else {-self } }
+    #[inline(always)] pure fn sign() -> i32 { if self > 0 { 1 } else if self == 0 { 0 } else { -1 } }
+}
+
+pub impl i64: Sign {
+    #[inline(always)] pure fn abs()  -> i64 { if self >= 0 { self } else {-self } }
+    #[inline(always)] pure fn sign() -> i64 { if self > 0 { 1 } else if self == 0 { 0 } else { -1 } }
+}
+
+pub impl int: Sign {
+    #[inline(always)] pure fn abs()  -> int { if self >= 0 { self } else {-self } }
+    #[inline(always)] pure fn sign() -> int { if self > 0 { 1 } else if self == 0 { 0 } else { -1 } }
+}
+
+pub impl f32: Sign {
+    #[inline(always)] pure fn abs()  -> f32 { if self >= 0f32 { self } else {-self } }
+    #[inline(always)] pure fn sign() -> f32 { if self > 0f32 { 1f32 } else if self == 0f32 { 0f32 } else { -1f32 } }
+}
+
+pub impl f64: Sign {
+    #[inline(always)] pure fn abs()  -> f64 { if self >= 0f64 { self } else {-self } }
+    #[inline(always)] pure fn sign() -> f64 { if self > 0f64 { 1f64 } else if self == 0f64 { 0f64 } else { -1f64 } }
+}
+
+pub impl float: Sign {
+    #[inline(always)] pure fn abs()  -> float { if self >= 0f { self } else {-self } }
+    #[inline(always)] pure fn sign() -> float { if self > 0f { 1f } else if self == 0f { 0f } else { -1f } }
+}
+
+
+
+pub impl<T:Copy Sign> Vec2<T>: Sign {
+    #[inline(always)]
+    pure fn abs() -> Vec2<T> {
+        Vec2::new(abs(&self[0]),
+                  abs(&self[1]))
+    }
+    
+    #[inline(always)]
+    pure fn sign() -> Vec2<T> {
+        Vec2::new(sign(&self[0]),
+                  sign(&self[1]))
+    }
+}
+
+pub impl<T:Copy Sign> Vec3<T>: Sign {
+    #[inline(always)]
+    pure fn abs() -> Vec3<T> {
+        Vec3::new(abs(&self[0]),
+                  abs(&self[1]),
+                  abs(&self[2]))
+    }
+    
+    #[inline(always)]
+    pure fn sign() -> Vec3<T> {
+        Vec3::new(sign(&self[0]),
+                  sign(&self[1]),
+                  sign(&self[2]))
+    }
+}
+
+pub impl<T:Copy Sign> Vec4<T>: Sign {
+    #[inline(always)]
+    pure fn abs() -> Vec4<T> {
+        Vec4::new(abs(&self[0]),
+                  abs(&self[1]),
+                  abs(&self[2]),
+                  abs(&self[3]))
+    }
+    
+    #[inline(always)]
+    pure fn sign() -> Vec4<T> {
+        Vec4::new(sign(&self[0]),
+                  sign(&self[1]),
+                  sign(&self[2]),
+                  sign(&self[3]))
+    }
+}
+
+pub trait Approx {
+    pure fn floor() -> self;
+    pure fn trunc() -> self;
+    pure fn round() -> self;
+    // pure fn roundEven() -> self;
+    pure fn ceil()  -> self;
+    pure fn fract() -> self;
+}
+
+#[inline(always)] pub pure fn floor<T:Approx>(x: &T) -> T { x.floor() }
+#[inline(always)] pub pure fn trunc<T:Approx>(x: &T) -> T { x.trunc() }
+#[inline(always)] pub pure fn round<T:Approx>(x: &T) -> T { x.round() }
+// #[inline(always)] pub pure fn roundEven<T:Approx>(x: &T) -> T { x.roundEven() }
+#[inline(always)] pub pure fn ceil<T:Approx>(x: &T)  -> T { x.ceil() }
+#[inline(always)] pub pure fn fract<T:Approx>(x: &T) -> T { x.fract() }
+
+pub impl f32: Approx {
+    #[inline(always)] pure fn floor() -> f32 { cast(cmath::c_float_utils::floor(self)) }
+    #[inline(always)] pure fn trunc() -> f32 { cast(cmath::c_float_utils::trunc(self)) }
+    #[inline(always)] pure fn round() -> f32 { cast(cmath::c_float_utils::round(self)) }
+    // #[inline(always)] pure fn roundEven() -> f32 {}
+    #[inline(always)] pure fn ceil()  -> f32 { cast(cmath::c_float_utils::ceil(self)) }
+    #[inline(always)] pure fn fract() -> f32 { self - floor(&self) }
+}
+
+pub impl f64: Approx {
+    #[inline(always)] pure fn floor() -> f64 { cast(cmath::c_double_utils::floor(self)) }
+    #[inline(always)] pure fn trunc() -> f64 { cast(cmath::c_double_utils::trunc(self)) }
+    #[inline(always)] pure fn round() -> f64 { cast(cmath::c_double_utils::round(self)) }
+    // #[inline(always)] pure fn roundEven() -> f64 {}
+    #[inline(always)] pure fn ceil()  -> f64 { cast(cmath::c_double_utils::ceil(self)) }
+    #[inline(always)] pure fn fract() -> f64 { self - floor(&self) }
+}
+
+pub impl float: Approx {
+    #[inline(always)] pure fn floor() -> float { cast(cmath::c_float_utils::floor(cast(self))) }
+    #[inline(always)] pure fn trunc() -> float { cast(cmath::c_float_utils::trunc(cast(self))) }
+    #[inline(always)] pure fn round() -> float { cast(cmath::c_float_utils::round(cast(self))) }
+    // #[inline(always)] pure fn roundEven() -> float {}
+    #[inline(always)] pure fn ceil()  -> float { cast(cmath::c_float_utils::ceil(cast(self))) }
+    #[inline(always)] pure fn fract() -> float { self - floor(&self) }
+}
+
+pub impl<T:Copy Approx> Vec2<T>: Approx {
+    #[inline(always)]
+    pure fn floor() -> Vec2<T> {
+        Vec2::new(floor(&self[0]),
+                  floor(&self[1]))
+    }
+    
+    #[inline(always)]
+    pure fn trunc() -> Vec2<T> {
+        Vec2::new(trunc(&self[0]),
+                  trunc(&self[1]))
+    }
+    
+    #[inline(always)]
+    pure fn round() -> Vec2<T> {
+        Vec2::new(round(&self[0]),
+                  round(&self[1]))
+    }
+    
+    // #[inline(always)]
+    // pure fn ceil()  -> Vec2<T> {
+    //     Vec2::new(roundEven(&self[0]),
+    //               roundEven(&self[1]))
+    // }
+    
+    #[inline(always)]
+    pure fn ceil()  -> Vec2<T> {
+        Vec2::new(ceil(&self[0]),
+                  ceil(&self[1]))
+    }
+    
+    #[inline(always)]
+    pure fn fract() -> Vec2<T> {
+        Vec2::new(fract(&self[0]),
+                  fract(&self[1]))
+    }
+    
+}
+
+pub impl<T:Copy Approx> Vec3<T>: Approx {
+    #[inline(always)]
+    pure fn floor() -> Vec3<T> {
+        Vec3::new(floor(&self[0]),
+                  floor(&self[1]),
+                  floor(&self[2]))
+    }
+    
+    #[inline(always)]
+    pure fn trunc() -> Vec3<T> {
+        Vec3::new(trunc(&self[0]),
+                  trunc(&self[1]),
+                  trunc(&self[2]))
+    }
+    
+    #[inline(always)]
+    pure fn round() -> Vec3<T> {
+        Vec3::new(round(&self[0]),
+                  round(&self[1]),
+                  round(&self[2]))
+    }
+    
+    // #[inline(always)]
+    // pure fn ceil()  -> Vec3<T> {
+    //     Vec3::new(roundEven(&self[0]),
+    //               roundEven(&self[1]),
+    //               roundEven(&self[2]))
+    // }
+    
+    #[inline(always)]
+    pure fn ceil()  -> Vec3<T> {
+        Vec3::new(ceil(&self[0]),
+                  ceil(&self[1]),
+                  ceil(&self[2]))
+    }
+    
+    #[inline(always)]
+    pure fn fract() -> Vec3<T> {
+        Vec3::new(fract(&self[0]),
+                  fract(&self[1]),
+                  fract(&self[2]))
+    }
+    
+}
+
+pub impl<T:Copy Approx> Vec4<T>: Approx {
+    #[inline(always)]
+    pure fn floor() -> Vec4<T> {
+        Vec4::new(floor(&self[0]),
+                  floor(&self[1]),
+                  floor(&self[2]),
+                  floor(&self[3]))
+    }
+    
+    #[inline(always)]
+    pure fn trunc() -> Vec4<T> {
+        Vec4::new(trunc(&self[0]),
+                  trunc(&self[1]),
+                  trunc(&self[2]),
+                  trunc(&self[3]))
+    }
+    
+    #[inline(always)]
+    pure fn round() -> Vec4<T> {
+        Vec4::new(round(&self[0]),
+                  round(&self[1]),
+                  round(&self[2]),
+                  round(&self[3]))
+    }
+    
+    // #[inline(always)]
+    // pure fn ceil()  -> Vec4<T> {
+    //     Vec4::new(roundEven(&self[0]),
+    //               roundEven(&self[1]),
+    //               roundEven(&self[2]),
+    //               roundEven(&self[3]))
+    // }
+    
+    #[inline(always)]
+    pure fn ceil()  -> Vec4<T> {
+        Vec4::new(ceil(&self[0]),
+                  ceil(&self[1]),
+                  ceil(&self[2]),
+                  ceil(&self[3]))
+    }
+    
+    #[inline(always)]
+    pure fn fract() -> Vec4<T> {
+        Vec4::new(fract(&self[0]),
+                  fract(&self[1]),
+                  fract(&self[2]),
+                  fract(&self[3]))
+    }
+    
+}
+
+pub trait MinMax {
+    pure fn min(other: &self) -> self;
+    pure fn max(other: &self) -> self;
+}
+
+#[inline(always)] pub pure fn min<T:MinMax>(a: &T, b: &T) -> T { a.min(b) }
+#[inline(always)] pub pure fn max<T:MinMax>(a: &T, b: &T) -> T { a.max(b) }
+
+pub impl u8: MinMax {
+    #[inline(always)] pure fn min(other: &u8) -> u8 { if self < *other { self } else { *other } }
+    #[inline(always)] pure fn max(other: &u8) -> u8 { if self > *other { self } else { *other } }
+}
+
+pub impl u16: MinMax {
+    #[inline(always)] pure fn min(other: &u16) -> u16 { if self < *other { self } else { *other } }
+    #[inline(always)] pure fn max(other: &u16) -> u16 { if self > *other { self } else { *other } }
+}
+
+pub impl u32: MinMax {
+    #[inline(always)] pure fn min(other: &u32) -> u32 { if self < *other { self } else { *other } }
+    #[inline(always)] pure fn max(other: &u32) -> u32 { if self > *other { self } else { *other } }
+}
+
+pub impl u64: MinMax {
+    #[inline(always)] pure fn min(other: &u64) -> u64 { if self < *other { self } else { *other } }
+    #[inline(always)] pure fn max(other: &u64) -> u64 { if self > *other { self } else { *other } }
+}
+
+pub impl uint: MinMax {
+    #[inline(always)] pure fn min(other: &uint) -> uint { if self < *other { self } else { *other } }
+    #[inline(always)] pure fn max(other: &uint) -> uint { if self > *other { self } else { *other } }
+}
+
+pub impl i8: MinMax {
+    #[inline(always)] pure fn min(other: &i8) -> i8 { if self < *other { self } else { *other } }
+    #[inline(always)] pure fn max(other: &i8) -> i8 { if self > *other { self } else { *other } }
+}
+
+pub impl i16: MinMax {
+    #[inline(always)] pure fn min(other: &i16) -> i16 { if self < *other { self } else { *other } }
+    #[inline(always)] pure fn max(other: &i16) -> i16 { if self > *other { self } else { *other } }
+}
+
+pub impl i32: MinMax {
+    #[inline(always)] pure fn min(other: &i32) -> i32 { if self < *other { self } else { *other } }
+    #[inline(always)] pure fn max(other: &i32) -> i32 { if self > *other { self } else { *other } }
+}
+
+pub impl i64: MinMax {
+    #[inline(always)] pure fn min(other: &i64) -> i64 { if self < *other { self } else { *other } }
+    #[inline(always)] pure fn max(other: &i64) -> i64 { if self > *other { self } else { *other } }
+}
+
+pub impl int: MinMax {
+    #[inline(always)] pure fn min(other: &int) -> int { if self < *other { self } else { *other } }
+    #[inline(always)] pure fn max(other: &int) -> int { if self > *other { self } else { *other } }
+}
+
+pub impl f32: MinMax {
+    #[inline(always)] pure fn min(other: &f32) -> f32 { if self < *other { self } else { *other } }
+    #[inline(always)] pure fn max(other: &f32) -> f32 { if self > *other { self } else { *other } }
+}
+
+pub impl f64: MinMax {
+    #[inline(always)] pure fn min(other: &f64) -> f64 { if self < *other { self } else { *other } }
+    #[inline(always)] pure fn max(other: &f64) -> f64 { if self > *other { self } else { *other } }
+}
+
+pub impl float: MinMax {
+    #[inline(always)] pure fn min(other: &float) -> float { if self < *other { self } else { *other } }
+    #[inline(always)] pure fn max(other: &float) -> float { if self > *other { self } else { *other } }
+}
+
+pub impl<T:Copy MinMax> Vec2<T>: MinMax {
+    #[inline(always)]
+    pure fn min(other: &Vec2<T>) -> Vec2<T> {
+        Vec2::new(min(&self[0], &other[0]),
+                  min(&self[1], &other[1]))
+    }
+    
+    #[inline(always)]
+    pure fn max(other: &Vec2<T>) -> Vec2<T> {
+        Vec2::new(max(&self[0], &other[0]),
+                  max(&self[1], &other[1]))
+    }
+}
+
+pub impl<T:Copy MinMax> Vec3<T>: MinMax {
+    #[inline(always)]
+    pure fn min(other: &Vec3<T>) -> Vec3<T> {
+        Vec3::new(min(&self[0], &other[0]),
+                  min(&self[1], &other[1]),
+                  min(&self[2], &other[2]))
+    }
+    
+    #[inline(always)]
+    pure fn max(other: &Vec3<T>) -> Vec3<T> {
+        Vec3::new(max(&self[0], &other[0]),
+                  max(&self[1], &other[1]),
+                  max(&self[2], &other[2]))
+    }
+}
+
+pub impl<T:Copy MinMax> Vec4<T>: MinMax {
+    #[inline(always)]
+    pure fn min(other: &Vec4<T>) -> Vec4<T> {
+        Vec4::new(min(&self[0], &other[0]),
+                  min(&self[1], &other[1]),
+                  min(&self[2], &other[2]),
+                  min(&self[3], &other[3]))
+    }
+    
+    #[inline(always)]
+    pure fn max(other: &Vec4<T>) -> Vec4<T> {
+        Vec4::new(max(&self[0], &other[0]),
+                  max(&self[1], &other[1]),
+                  max(&self[2], &other[2]),
+                  max(&self[3], &other[3]))
+    }
+}
+
+pub trait Clamp {
+    pure fn clamp(mn: &self, mx: &self) -> self;
+}
+
+#[inline(always)] pub pure fn clamp<T:Clamp>(x: &T, mn: &T, mx: &T) -> T { x.clamp(mn, mx) }
+
+pub impl u8:    Clamp { #[inline(always)] pure fn clamp(mn: &u8,    mx: &u8)    -> u8    { min(&max(&self, mn), mx) } }
+pub impl u16:   Clamp { #[inline(always)] pure fn clamp(mn: &u16,   mx: &u16)   -> u16   { min(&max(&self, mn), mx) } }
+pub impl u32:   Clamp { #[inline(always)] pure fn clamp(mn: &u32,   mx: &u32)   -> u32   { min(&max(&self, mn), mx) } }
+pub impl u64:   Clamp { #[inline(always)] pure fn clamp(mn: &u64,   mx: &u64)   -> u64   { min(&max(&self, mn), mx) } }
+pub impl uint:  Clamp { #[inline(always)] pure fn clamp(mn: &uint,  mx: &uint)  -> uint  { min(&max(&self, mn), mx) } }
+pub impl i8:    Clamp { #[inline(always)] pure fn clamp(mn: &i8,    mx: &i8)    -> i8    { min(&max(&self, mn), mx) } }
+pub impl i16:   Clamp { #[inline(always)] pure fn clamp(mn: &i16,   mx: &i16)   -> i16   { min(&max(&self, mn), mx) } }
+pub impl i32:   Clamp { #[inline(always)] pure fn clamp(mn: &i32,   mx: &i32)   -> i32   { min(&max(&self, mn), mx) } }
+pub impl i64:   Clamp { #[inline(always)] pure fn clamp(mn: &i64,   mx: &i64)   -> i64   { min(&max(&self, mn), mx) } }
+pub impl int:   Clamp { #[inline(always)] pure fn clamp(mn: &int,   mx: &int)   -> int   { min(&max(&self, mn), mx) } }
+pub impl f32:   Clamp { #[inline(always)] pure fn clamp(mn: &f32,   mx: &f32)   -> f32   { min(&max(&self, mn), mx) } }
+pub impl f64:   Clamp { #[inline(always)] pure fn clamp(mn: &f64,   mx: &f64)   -> f64   { min(&max(&self, mn), mx) } }
+pub impl float: Clamp { #[inline(always)] pure fn clamp(mn: &float, mx: &float) -> float { min(&max(&self, mn), mx) } }
+
+pub impl<T:Copy Clamp> Vec2<T>: Clamp {
+    #[inline(always)]
+    pure fn clamp(mn: &Vec2<T>, mx: &Vec2<T>) -> Vec2<T> {
+        Vec2::new(self[0].clamp(&mn[0], &mx[0]),
+                  self[1].clamp(&mn[1], &mx[1]))
+    }
+}
+
+pub impl<T:Copy Clamp> Vec3<T>: Clamp {
+    #[inline(always)]
+    pure fn clamp(mn: &Vec3<T>, mx: &Vec3<T>) -> Vec3<T> {
+        Vec3::new(self[0].clamp(&mn[0], &mx[0]),
+                  self[1].clamp(&mn[1], &mx[1]),
+                  self[2].clamp(&mn[2], &mx[2]))
+    }
+}
+
+pub impl<T:Copy Clamp> Vec4<T>: Clamp {
+    #[inline(always)]
+    pure fn clamp(mn: &Vec4<T>, mx: &Vec4<T>) -> Vec4<T> {
+        Vec4::new(self[0].clamp(&mn[0], &mx[0]),
+                  self[1].clamp(&mn[1], &mx[1]),
+                  self[2].clamp(&mn[2], &mx[2]),
+                  self[3].clamp(&mn[3], &mx[3]))
+    }
+}
+
+pub trait Mix {
+    pure fn mix(other: &self, value: &self) -> self;
+    pure fn smooth_step(edge0: &self, edge1: &self) -> self;
+    pure fn step(edge: &self) -> self;
+}
+
+#[inline(always)] pub pure fn mix<T:Mix>(a: &T, b: &T, value: &T) -> T { a.mix(b, value) }
+#[inline(always)] pub pure fn smooth_step<T:Mix>(x: &T, edge0: &T, edge1: &T) -> T { x.smooth_step(edge0, edge1) }
+#[inline(always)] pub pure fn step<T:Mix>(x: &T, edge: &T) -> T { x.step(edge) }
+
+pub impl f32: Mix {
+    #[inline(always)]
+    pure fn mix(other: &f32, value: &f32) -> f32 {
+        self * (1.0 - (*value)) + (*other) * (*value)
+    }
+    
+    #[inline(always)]
+    pure fn smooth_step(edge0: &f32, edge1: &f32) -> f32 {
+        let t = clamp(&((self - *edge0) / (*edge1 - *edge0)), &0.0, &1.0);
+        return t * t * (3.0 - 2.0 * t);
+    }
+    
+    #[inline(always)]
+    pure fn step(edge: &f32) -> f32 {
+        if self < *edge { 0.0 } else { 1.0 }
+    }
+}
+
+pub impl f64: Mix {
+    #[inline(always)]
+    pure fn mix(other: &f64, value: &f64) -> f64 {
+        self * (1.0 - (*value)) + (*other) * (*value)
+    }
+    
+    #[inline(always)]
+    pure fn smooth_step(edge0: &f64, edge1: &f64) -> f64 {
+        let t = clamp(&((self - *edge0) / (*edge1 - *edge0)), &0.0, &1.0);
+        return t * t * (3.0 - 2.0 * t);
+    }
+    
+    #[inline(always)]
+    pure fn step(edge: &f64) -> f64 {
+        if self < *edge { 0.0 } else { 1.0 }
+    }
+}
+
+pub impl float: Mix {
+    #[inline(always)]
+    pure fn mix(other: &float, value: &float) -> float {
+        self * (1.0 - (*value)) + (*other) * (*value)
+    }
+    
+    #[inline(always)]
+    pure fn smooth_step(edge0: &float, edge1: &float) -> float {
+        let t = clamp(&((self - *edge0) / (*edge1 - *edge0)), &0.0, &1.0);
+        return t * t * (3.0 - 2.0 * t);
+    }
+    
+    #[inline(always)]
+    pure fn step(edge: &float) -> float {
+        if self < *edge { 0.0 } else { 1.0 }
+    }
+}
+
+pub impl<T:Copy Mix> Vec2<T>: Mix {
+    #[inline(always)]
+    pure fn mix(other: &Vec2<T>, value: &Vec2<T>) -> Vec2<T> {
+        Vec2::new(self[0].mix(&other[0], &value[0]),
+                  self[1].mix(&other[1], &value[1]))
+    }
+    
+    #[inline(always)]
+    pure fn smooth_step(edge0: &Vec2<T>, edge1: &Vec2<T>) -> Vec2<T> {
+        Vec2::new(self[0].smooth_step(&edge0[0], &edge1[0]),
+                  self[1].smooth_step(&edge0[1], &edge1[1]))
+    }
+    
+    #[inline(always)]
+    pure fn step(edge: &Vec2<T>) -> Vec2<T> {
+        Vec2::new(self[0].step(&edge[0]),
+                  self[1].step(&edge[1]))
+    }
+}
+
+pub impl<T:Copy Mix> Vec3<T>: Mix {
+    #[inline(always)]
+    pure fn mix(other: &Vec3<T>, value: &Vec3<T>) -> Vec3<T> {
+        Vec3::new(self[0].mix(&other[0], &value[0]),
+                  self[1].mix(&other[1], &value[1]),
+                  self[2].mix(&other[2], &value[2]))
+    }
+    
+    #[inline(always)]
+    pure fn smooth_step(edge0: &Vec3<T>, edge1: &Vec3<T>) -> Vec3<T> {
+        Vec3::new(self[0].smooth_step(&edge0[0], &edge1[0]),
+                  self[1].smooth_step(&edge0[1], &edge1[1]),
+                  self[2].smooth_step(&edge0[2], &edge1[2]))
+    }
+    
+    #[inline(always)]
+    pure fn step(edge: &Vec3<T>) -> Vec3<T> {
+        Vec3::new(self[0].step(&edge[0]),
+                  self[1].step(&edge[1]),
+                  self[2].step(&edge[2]))
+    }
+}
+
+pub impl<T:Copy Mix> Vec4<T>: Mix {
+    #[inline(always)]
+    pure fn mix(other: &Vec4<T>, value: &Vec4<T>) -> Vec4<T> {
+        Vec4::new(self[0].mix(&other[0], &value[0]),
+                  self[1].mix(&other[1], &value[1]),
+                  self[2].mix(&other[2], &value[2]),
+                  self[3].mix(&other[3], &value[3]))
+    }
+    
+    #[inline(always)]
+    pure fn smooth_step(edge0: &Vec4<T>, edge1: &Vec4<T>) -> Vec4<T> {
+        Vec4::new(self[0].smooth_step(&edge0[0], &edge1[0]),
+                  self[1].smooth_step(&edge0[1], &edge1[1]),
+                  self[2].smooth_step(&edge0[2], &edge1[2]),
+                  self[3].smooth_step(&edge0[3], &edge1[3]))
+    }
+    
+    #[inline(always)]
+    pure fn step(edge: &Vec4<T>) -> Vec4<T> {
+        Vec4::new(self[0].step(&edge[0]),
+                  self[1].step(&edge[1]),
+                  self[2].step(&edge[2]),
+                  self[3].step(&edge[3]))
+    }
+}

src/funs/exponential.rs

@@ -1,7 +1,7 @@
 /**
  * Exponential Functions
  */
-use num::cast::*;
+use num::cast::{NumCast, cast};
 use vec::{Vec2, Vec3, Vec4};
 
 pub trait Exp {

src/funs/extent.rs

@@ -1,170 +0,0 @@
-use num::cast::cast;
-use vec::{Vec2, Vec3, Vec4};
-
-pub trait MinMax {
-    pure fn min(other: &self) -> self;
-    pure fn max(other: &self) -> self;
-}
-
-#[inline(always)] pub pure fn min<T:MinMax>(a: &T, b: &T) -> T { a.min(b) }
-#[inline(always)] pub pure fn max<T:MinMax>(a: &T, b: &T) -> T { a.max(b) }
-
-pub impl u8: MinMax {
-    #[inline(always)] pure fn min(other: &u8) -> u8 { if self < *other { self } else { *other } }
-    #[inline(always)] pure fn max(other: &u8) -> u8 { if self > *other { self } else { *other } }
-}
-
-pub impl u16: MinMax {
-    #[inline(always)] pure fn min(other: &u16) -> u16 { if self < *other { self } else { *other } }
-    #[inline(always)] pure fn max(other: &u16) -> u16 { if self > *other { self } else { *other } }
-}
-
-pub impl u32: MinMax {
-    #[inline(always)] pure fn min(other: &u32) -> u32 { if self < *other { self } else { *other } }
-    #[inline(always)] pure fn max(other: &u32) -> u32 { if self > *other { self } else { *other } }
-}
-
-pub impl u64: MinMax {
-    #[inline(always)] pure fn min(other: &u64) -> u64 { if self < *other { self } else { *other } }
-    #[inline(always)] pure fn max(other: &u64) -> u64 { if self > *other { self } else { *other } }
-}
-
-pub impl uint: MinMax {
-    #[inline(always)] pure fn min(other: &uint) -> uint { if self < *other { self } else { *other } }
-    #[inline(always)] pure fn max(other: &uint) -> uint { if self > *other { self } else { *other } }
-}
-
-pub impl i8: MinMax {
-    #[inline(always)] pure fn min(other: &i8) -> i8 { if self < *other { self } else { *other } }
-    #[inline(always)] pure fn max(other: &i8) -> i8 { if self > *other { self } else { *other } }
-}
-
-pub impl i16: MinMax {
-    #[inline(always)] pure fn min(other: &i16) -> i16 { if self < *other { self } else { *other } }
-    #[inline(always)] pure fn max(other: &i16) -> i16 { if self > *other { self } else { *other } }
-}
-
-pub impl i32: MinMax {
-    #[inline(always)] pure fn min(other: &i32) -> i32 { if self < *other { self } else { *other } }
-    #[inline(always)] pure fn max(other: &i32) -> i32 { if self > *other { self } else { *other } }
-}
-
-pub impl i64: MinMax {
-    #[inline(always)] pure fn min(other: &i64) -> i64 { if self < *other { self } else { *other } }
-    #[inline(always)] pure fn max(other: &i64) -> i64 { if self > *other { self } else { *other } }
-}
-
-pub impl int: MinMax {
-    #[inline(always)] pure fn min(other: &int) -> int { if self < *other { self } else { *other } }
-    #[inline(always)] pure fn max(other: &int) -> int { if self > *other { self } else { *other } }
-}
-
-pub impl f32: MinMax {
-    #[inline(always)] pure fn min(other: &f32) -> f32 { if self < *other { self } else { *other } }
-    #[inline(always)] pure fn max(other: &f32) -> f32 { if self > *other { self } else { *other } }
-}
-
-pub impl f64: MinMax {
-    #[inline(always)] pure fn min(other: &f64) -> f64 { if self < *other { self } else { *other } }
-    #[inline(always)] pure fn max(other: &f64) -> f64 { if self > *other { self } else { *other } }
-}
-
-pub impl float: MinMax {
-    #[inline(always)] pure fn min(other: &float) -> float { if self < *other { self } else { *other } }
-    #[inline(always)] pure fn max(other: &float) -> float { if self > *other { self } else { *other } }
-}
-
-pub impl<T:Copy MinMax> Vec2<T>: MinMax {
-    #[inline(always)]
-    pure fn min(other: &Vec2<T>) -> Vec2<T> {
-        Vec2::new(min(&self[0], &other[0]),
-                  min(&self[1], &other[1]))
-    }
-    
-    #[inline(always)]
-    pure fn max(other: &Vec2<T>) -> Vec2<T> {
-        Vec2::new(max(&self[0], &other[0]),
-                  max(&self[1], &other[1]))
-    }
-}
-
-pub impl<T:Copy MinMax> Vec3<T>: MinMax {
-    #[inline(always)]
-    pure fn min(other: &Vec3<T>) -> Vec3<T> {
-        Vec3::new(min(&self[0], &other[0]),
-                  min(&self[1], &other[1]),
-                  min(&self[2], &other[2]))
-    }
-    
-    #[inline(always)]
-    pure fn max(other: &Vec3<T>) -> Vec3<T> {
-        Vec3::new(max(&self[0], &other[0]),
-                  max(&self[1], &other[1]),
-                  max(&self[2], &other[2]))
-    }
-}
-
-pub impl<T:Copy MinMax> Vec4<T>: MinMax {
-    #[inline(always)]
-    pure fn min(other: &Vec4<T>) -> Vec4<T> {
-        Vec4::new(min(&self[0], &other[0]),
-                  min(&self[1], &other[1]),
-                  min(&self[2], &other[2]),
-                  min(&self[3], &other[3]))
-    }
-    
-    #[inline(always)]
-    pure fn max(other: &Vec4<T>) -> Vec4<T> {
-        Vec4::new(max(&self[0], &other[0]),
-                  max(&self[1], &other[1]),
-                  max(&self[2], &other[2]),
-                  max(&self[3], &other[3]))
-    }
-}
-
-pub trait Clamp {
-    pure fn clamp(mn: &self, mx: &self) -> self;
-}
-
-#[inline(always)] pub pure fn clamp<T:Clamp>(x: &T, mn: &T, mx: &T) -> T { x.clamp(mn, mx) }
-
-pub impl u8:    Clamp { #[inline(always)] pure fn clamp(mn: &u8,    mx: &u8)    -> u8    { min(&max(&self, mn), mx) } }
-pub impl u16:   Clamp { #[inline(always)] pure fn clamp(mn: &u16,   mx: &u16)   -> u16   { min(&max(&self, mn), mx) } }
-pub impl u32:   Clamp { #[inline(always)] pure fn clamp(mn: &u32,   mx: &u32)   -> u32   { min(&max(&self, mn), mx) } }
-pub impl u64:   Clamp { #[inline(always)] pure fn clamp(mn: &u64,   mx: &u64)   -> u64   { min(&max(&self, mn), mx) } }
-pub impl uint:  Clamp { #[inline(always)] pure fn clamp(mn: &uint,  mx: &uint)  -> uint  { min(&max(&self, mn), mx) } }
-pub impl i8:    Clamp { #[inline(always)] pure fn clamp(mn: &i8,    mx: &i8)    -> i8    { min(&max(&self, mn), mx) } }
-pub impl i16:   Clamp { #[inline(always)] pure fn clamp(mn: &i16,   mx: &i16)   -> i16   { min(&max(&self, mn), mx) } }
-pub impl i32:   Clamp { #[inline(always)] pure fn clamp(mn: &i32,   mx: &i32)   -> i32   { min(&max(&self, mn), mx) } }
-pub impl i64:   Clamp { #[inline(always)] pure fn clamp(mn: &i64,   mx: &i64)   -> i64   { min(&max(&self, mn), mx) } }
-pub impl int:   Clamp { #[inline(always)] pure fn clamp(mn: &int,   mx: &int)   -> int   { min(&max(&self, mn), mx) } }
-pub impl f32:   Clamp { #[inline(always)] pure fn clamp(mn: &f32,   mx: &f32)   -> f32   { min(&max(&self, mn), mx) } }
-pub impl f64:   Clamp { #[inline(always)] pure fn clamp(mn: &f64,   mx: &f64)   -> f64   { min(&max(&self, mn), mx) } }
-pub impl float: Clamp { #[inline(always)] pure fn clamp(mn: &float, mx: &float) -> float { min(&max(&self, mn), mx) } }
-
-pub impl<T:Copy Clamp> Vec2<T>: Clamp {
-    #[inline(always)]
-    pure fn clamp(mn: &Vec2<T>, mx: &Vec2<T>) -> Vec2<T> {
-        Vec2::new(self[0].clamp(&mn[0], &mx[0]),
-                  self[1].clamp(&mn[1], &mx[1]))
-    }
-}
-
-pub impl<T:Copy Clamp> Vec3<T>: Clamp {
-    #[inline(always)]
-    pure fn clamp(mn: &Vec3<T>, mx: &Vec3<T>) -> Vec3<T> {
-        Vec3::new(self[0].clamp(&mn[0], &mx[0]),
-                  self[1].clamp(&mn[1], &mx[1]),
-                  self[2].clamp(&mn[2], &mx[2]))
-    }
-}
-
-pub impl<T:Copy Clamp> Vec4<T>: Clamp {
-    #[inline(always)]
-    pure fn clamp(mn: &Vec4<T>, mx: &Vec4<T>) -> Vec4<T> {
-        Vec4::new(self[0].clamp(&mn[0], &mx[0]),
-                  self[1].clamp(&mn[1], &mx[1]),
-                  self[2].clamp(&mn[2], &mx[2]),
-                  self[3].clamp(&mn[3], &mx[3]))
-    }
-}

src/funs/mix.rs

@@ -1,137 +0,0 @@
-use num::cast::*;
-use vec::{Vec2, Vec3, Vec4};
-
-use extent::{Clamp, clamp};
-
-pub trait Mix {
-    pure fn mix(other: &self, value: &self) -> self;
-    pure fn smooth_step(edge0: &self, edge1: &self) -> self;
-    pure fn step(edge: &self) -> self;
-}
-
-#[inline(always)] pub pure fn mix<T:Mix>(a: &T, b: &T, value: &T) -> T { a.mix(b, value) }
-#[inline(always)] pub pure fn smooth_step<T:Mix>(x: &T, edge0: &T, edge1: &T) -> T { x.smooth_step(edge0, edge1) }
-#[inline(always)] pub pure fn step<T:Mix>(x: &T, edge: &T) -> T { x.step(edge) }
-
-pub impl f32: Mix {
-    #[inline(always)]
-    pure fn mix(other: &f32, value: &f32) -> f32 {
-        self * (1.0 - (*value)) + (*other) * (*value)
-    }
-    
-    #[inline(always)]
-    pure fn smooth_step(edge0: &f32, edge1: &f32) -> f32 {
-        let t = clamp(&((self - *edge0) / (*edge1 - *edge0)), &0.0, &1.0);
-        return t * t * (3.0 - 2.0 * t);
-    }
-    
-    #[inline(always)]
-    pure fn step(edge: &f32) -> f32 {
-        if self < *edge { 0.0 } else { 1.0 }
-    }
-}
-
-pub impl f64: Mix {
-    #[inline(always)]
-    pure fn mix(other: &f64, value: &f64) -> f64 {
-        self * (1.0 - (*value)) + (*other) * (*value)
-    }
-    
-    #[inline(always)]
-    pure fn smooth_step(edge0: &f64, edge1: &f64) -> f64 {
-        let t = clamp(&((self - *edge0) / (*edge1 - *edge0)), &0.0, &1.0);
-        return t * t * (3.0 - 2.0 * t);
-    }
-    
-    #[inline(always)]
-    pure fn step(edge: &f64) -> f64 {
-        if self < *edge { 0.0 } else { 1.0 }
-    }
-}
-
-pub impl float: Mix {
-    #[inline(always)]
-    pure fn mix(other: &float, value: &float) -> float {
-        self * (1.0 - (*value)) + (*other) * (*value)
-    }
-    
-    #[inline(always)]
-    pure fn smooth_step(edge0: &float, edge1: &float) -> float {
-        let t = clamp(&((self - *edge0) / (*edge1 - *edge0)), &0.0, &1.0);
-        return t * t * (3.0 - 2.0 * t);
-    }
-    
-    #[inline(always)]
-    pure fn step(edge: &float) -> float {
-        if self < *edge { 0.0 } else { 1.0 }
-    }
-}
-
-pub impl<T:Copy Mix> Vec2<T>: Mix {
-    #[inline(always)]
-    pure fn mix(other: &Vec2<T>, value: &Vec2<T>) -> Vec2<T> {
-        Vec2::new(self[0].mix(&other[0], &value[0]),
-                  self[1].mix(&other[1], &value[1]))
-    }
-    
-    #[inline(always)]
-    pure fn smooth_step(edge0: &Vec2<T>, edge1: &Vec2<T>) -> Vec2<T> {
-        Vec2::new(self[0].smooth_step(&edge0[0], &edge1[0]),
-                  self[1].smooth_step(&edge0[1], &edge1[1]))
-    }
-    
-    #[inline(always)]
-    pure fn step(edge: &Vec2<T>) -> Vec2<T> {
-        Vec2::new(self[0].step(&edge[0]),
-                  self[1].step(&edge[1]))
-    }
-}
-
-pub impl<T:Copy Mix> Vec3<T>: Mix {
-    #[inline(always)]
-    pure fn mix(other: &Vec3<T>, value: &Vec3<T>) -> Vec3<T> {
-        Vec3::new(self[0].mix(&other[0], &value[0]),
-                  self[1].mix(&other[1], &value[1]),
-                  self[2].mix(&other[2], &value[2]))
-    }
-    
-    #[inline(always)]
-    pure fn smooth_step(edge0: &Vec3<T>, edge1: &Vec3<T>) -> Vec3<T> {
-        Vec3::new(self[0].smooth_step(&edge0[0], &edge1[0]),
-                  self[1].smooth_step(&edge0[1], &edge1[1]),
-                  self[2].smooth_step(&edge0[2], &edge1[2]))
-    }
-    
-    #[inline(always)]
-    pure fn step(edge: &Vec3<T>) -> Vec3<T> {
-        Vec3::new(self[0].step(&edge[0]),
-                  self[1].step(&edge[1]),
-                  self[2].step(&edge[2]))
-    }
-}
-
-pub impl<T:Copy Mix> Vec4<T>: Mix {
-    #[inline(always)]
-    pure fn mix(other: &Vec4<T>, value: &Vec4<T>) -> Vec4<T> {
-        Vec4::new(self[0].mix(&other[0], &value[0]),
-                  self[1].mix(&other[1], &value[1]),
-                  self[2].mix(&other[2], &value[2]),
-                  self[3].mix(&other[3], &value[3]))
-    }
-    
-    #[inline(always)]
-    pure fn smooth_step(edge0: &Vec4<T>, edge1: &Vec4<T>) -> Vec4<T> {
-        Vec4::new(self[0].smooth_step(&edge0[0], &edge1[0]),
-                  self[1].smooth_step(&edge0[1], &edge1[1]),
-                  self[2].smooth_step(&edge0[2], &edge1[2]),
-                  self[3].smooth_step(&edge0[3], &edge1[3]))
-    }
-    
-    #[inline(always)]
-    pure fn step(edge: &Vec4<T>) -> Vec4<T> {
-        Vec4::new(self[0].step(&edge[0]),
-                  self[1].step(&edge[1]),
-                  self[2].step(&edge[2]),
-                  self[3].step(&edge[3]))
-    }
-}

src/funs/projection.rs

@@ -1,5 +1,5 @@
-use funs::trig::*;
+use funs::triganomic::tan;
-use angle::Angle;
+use angle::Radians;
 use mat::Mat4;
 use num::cast::cast;
 use num::consts::pi;

src/funs/relational.rs

@@ -4,7 +4,7 @@
 
 use core::cmp::{Eq, Ord};
 
-use vec::{Vec2, Vec3, Vec4};
+use vec::{Vector, Vec2, Vec3, Vec4};
 
 pub trait RelVector<BVec> {
     pure fn less_than(y: &self) -> BVec;
@@ -152,4 +152,56 @@ pub impl<T:Copy Ord Eq> Vec4<T>: RelVector<Vec4<bool>> {
                   self[2] != y[2],
                   self[3] != y[3])
     }
+}
+
+pub trait BooleanVector: Vector<bool> {
+    pure fn any() -> bool;
+    pure fn all() -> bool;
+    pure fn not() -> self;
+}
+
+#[inline(always)] pub pure fn any<T:BooleanVector>(x: &T) -> bool { x.any() }
+#[inline(always)] pub pure fn all<T:BooleanVector>(x: &T) -> bool { x.all() }
+#[inline(always)] pub pure fn not<T:BooleanVector>(x: &T) -> T    { x.not() }
+
+pub impl Vec2<bool>: BooleanVector {
+    pure fn any() -> bool {
+        self[0] || self[1]
+    }
+    
+    pure fn all() -> bool {
+        self[0] && self[1]
+    }
+    
+    pure fn not() -> Vec2<bool> { 
+        Vec2::new(!self[0], !self[1])
+    }
+}
+
+pub impl Vec3<bool>: BooleanVector {
+    pure fn any() -> bool {
+        self[0] || self[1] || self[2]
+    }
+    
+    pure fn all() -> bool {
+        self[0] && self[1] && self[2]
+    }
+    
+    pure fn not() -> Vec3<bool> { 
+        Vec3::new(!self[0], !self[1], !self[2])
+    }
+}
+
+pub impl Vec4<bool>: BooleanVector {
+    pure fn any() -> bool {
+        self[0] || self[1] || self[2] || self[3]
+    }
+    
+    pure fn all() -> bool {
+        self[0] && self[1] && self[2] && self[3]
+    }
+    
+    pure fn not() -> Vec4<bool> { 
+        Vec4::new(!self[0], !self[1], !self[2], !self[3])
+    }
 }

src/funs/sign.rs

@@ -1,103 +0,0 @@
-use vec::{Vec2, Vec3, Vec4};
-
-/// Should only be implemented on signed types.
-pub trait Sign {
-    pure fn abs() -> self;
-    
-    /// returns `-1` if the number is negative, `0` if the number is equal to 0,
-    /// and `1` if the number is positive
-    pure fn sign() -> self;
-}
-
-#[inline(always)] pub pure fn abs<T:Sign>(x: &T)  -> T { x.abs()  }
-#[inline(always)] pub pure fn sign<T:Sign>(x: &T) -> T { x.sign() }
-
-pub impl i8: Sign {
-    #[inline(always)] pure fn abs()  -> i8 { if self >= 0 { self } else {-self } }
-    #[inline(always)] pure fn sign() -> i8 { if self > 0 { 1 } else if self == 0 { 0 } else { -1 } }
-}
-
-pub impl i16: Sign {
-    #[inline(always)] pure fn abs()  -> i16 { if self >= 0 { self } else {-self } }
-    #[inline(always)] pure fn sign() -> i16 { if self > 0 { 1 } else if self == 0 { 0 } else { -1 } }
-}
-
-pub impl i32: Sign {
-    #[inline(always)] pure fn abs()  -> i32 { if self >= 0 { self } else {-self } }
-    #[inline(always)] pure fn sign() -> i32 { if self > 0 { 1 } else if self == 0 { 0 } else { -1 } }
-}
-
-pub impl i64: Sign {
-    #[inline(always)] pure fn abs()  -> i64 { if self >= 0 { self } else {-self } }
-    #[inline(always)] pure fn sign() -> i64 { if self > 0 { 1 } else if self == 0 { 0 } else { -1 } }
-}
-
-pub impl int: Sign {
-    #[inline(always)] pure fn abs()  -> int { if self >= 0 { self } else {-self } }
-    #[inline(always)] pure fn sign() -> int { if self > 0 { 1 } else if self == 0 { 0 } else { -1 } }
-}
-
-pub impl f32: Sign {
-    #[inline(always)] pure fn abs()  -> f32 { if self >= 0f32 { self } else {-self } }
-    #[inline(always)] pure fn sign() -> f32 { if self > 0f32 { 1f32 } else if self == 0f32 { 0f32 } else { -1f32 } }
-}
-
-pub impl f64: Sign {
-    #[inline(always)] pure fn abs()  -> f64 { if self >= 0f64 { self } else {-self } }
-    #[inline(always)] pure fn sign() -> f64 { if self > 0f64 { 1f64 } else if self == 0f64 { 0f64 } else { -1f64 } }
-}
-
-pub impl float: Sign {
-    #[inline(always)] pure fn abs()  -> float { if self >= 0f { self } else {-self } }
-    #[inline(always)] pure fn sign() -> float { if self > 0f { 1f } else if self == 0f { 0f } else { -1f } }
-}
-
-
-
-pub impl<T:Copy Sign> Vec2<T>: Sign {
-    #[inline(always)]
-    pure fn abs() -> Vec2<T> {
-        Vec2::new(abs(&self[0]),
-                  abs(&self[1]))
-    }
-    
-    #[inline(always)]
-    pure fn sign() -> Vec2<T> {
-        Vec2::new(sign(&self[0]),
-                  sign(&self[1]))
-    }
-}
-
-pub impl<T:Copy Sign> Vec3<T>: Sign {
-    #[inline(always)]
-    pure fn abs() -> Vec3<T> {
-        Vec3::new(abs(&self[0]),
-                  abs(&self[1]),
-                  abs(&self[2]))
-    }
-    
-    #[inline(always)]
-    pure fn sign() -> Vec3<T> {
-        Vec3::new(sign(&self[0]),
-                  sign(&self[1]),
-                  sign(&self[2]))
-    }
-}
-
-pub impl<T:Copy Sign> Vec4<T>: Sign {
-    #[inline(always)]
-    pure fn abs() -> Vec4<T> {
-        Vec4::new(abs(&self[0]),
-                  abs(&self[1]),
-                  abs(&self[2]),
-                  abs(&self[3]))
-    }
-    
-    #[inline(always)]
-    pure fn sign() -> Vec4<T> {
-        Vec4::new(sign(&self[0]),
-                  sign(&self[1]),
-                  sign(&self[2]),
-                  sign(&self[3]))
-    }
-}

src/funs/test/test_common.rs

@@ -1,6 +1,40 @@
-use extent::*;
+use common::*;
 use vec::{Vec2, Vec3, Vec4};
 
+#[test]
+fn test_abs() {
+    assert 0.abs()      == 0;
+    assert 2.abs()      == 2;
+    assert (-2).abs()   == 2;
+    assert abs(&0)      == 0;
+    assert abs(&2)      == 2;
+    assert abs(&-2)     == 2;
+    
+    assert 0.0.abs()    == 0.0;
+    assert 2.5.abs()    == 2.5;
+    assert (-2.5).abs() == 2.5;
+    assert abs(&0.0)    == 0.0;
+    assert abs(&2.5)    == 2.5;
+    assert abs(&-2.5)   == 2.5;
+}
+
+#[test]
+fn test_sign() {
+    assert 0.sign()     == 0;
+    assert 2.sign()     == 1;
+    assert (-2).sign()  == -1;
+    assert sign(&0)     == 0;
+    assert sign(&2)     == 1;
+    assert sign(&-2)    == -1;
+    
+    assert 0.0.sign()   == 0.0;
+    assert 2.5.sign()   == 1.0;
+    assert (-2.5).sign()== -1.0;
+    assert sign(&0.0)   == 0.0;
+    assert sign(&2.5)   == 1.0;
+    assert sign(&-2.5)  == -1.0;
+}
+
 #[test]
 fn test_min() {
     assert 1u.min(&2u)      == 1u;

src/funs/test/test_relational.rs

@@ -1,5 +1,5 @@
 use vec::*;
-use boolv::*;
+use relational::*;
 
 #[test]
 fn test_boolv2() {

src/funs/test/test_sign.rs

@@ -1,35 +0,0 @@
-use sign::*;
-
-#[test]
-fn test_abs() {
-    assert 0.abs()      == 0;
-    assert 2.abs()      == 2;
-    assert (-2).abs()   == 2;
-    assert abs(&0)      == 0;
-    assert abs(&2)      == 2;
-    assert abs(&-2)     == 2;
-    
-    assert 0.0.abs()    == 0.0;
-    assert 2.5.abs()    == 2.5;
-    assert (-2.5).abs() == 2.5;
-    assert abs(&0.0)    == 0.0;
-    assert abs(&2.5)    == 2.5;
-    assert abs(&-2.5)   == 2.5;
-}
-
-#[test]
-fn test_sign() {
-    assert 0.sign()     == 0;
-    assert 2.sign()     == 1;
-    assert (-2).sign()  == -1;
-    assert sign(&0)     == 0;
-    assert sign(&2)     == 1;
-    assert sign(&-2)    == -1;
-    
-    assert 0.0.sign()   == 0.0;
-    assert 2.5.sign()   == 1.0;
-    assert (-2.5).sign()== -1.0;
-    assert sign(&0.0)   == 0.0;
-    assert sign(&2.5)   == 1.0;
-    assert sign(&-2.5)  == -1.0;
-}

src/funs/transform.rs

@@ -1,7 +1,8 @@
-use funs::trig::*;
+use funs::triganomic::{cos, sin};
-use angle::Angle;
+use angle::Radians;
 use mat::{Mat3, Mat4};
-use num::cast::*;
+use num::cast::{NumCast, cast};
+use vec::Vec3;
 
 pub pure fn mat3_from_rotation<T:Copy Num NumCast>(theta: Radians<T>, axis: Vec3<T>) -> Mat3<T> {
     let c:  T = cos(&theta);

src/funs/triganomic.rs

@@ -1,5 +1,5 @@
-use num::cast::*;
+use num::cast::{NumCast, cast};
-use angle::*;
+use angle::Radians;
 use vec::{Vec3, Vec2, Vec4};
 
 ///

src/lmath.rc

@@ -35,22 +35,17 @@ pub mod num {
 }
 
 pub mod funs {
-  pub mod approx;
+  pub mod common;
-  pub mod boolv;
+  pub mod exponential;
-  pub mod exp;
-  pub mod extent;
-  pub mod mix;
   pub mod projection;
-  pub mod relv;
+  pub mod relational;
-  pub mod sign;
   pub mod transform;
-  pub mod trig;
+  pub mod triganomic;
   
   #[test]
   mod test {
-    mod test_boolv;
+    mod test_common;
-    mod test_extent;
+    mod test_relational;
-    mod test_sign;
     mod test_transform;
   }
 }

src/mat.rs

@@ -7,9 +7,8 @@ use core::vec::raw::buf_as_slice;
 use std::cmp::FuzzyEq;
 
 use dim::Dimensional;
-use funs::exp::*;
+use funs::common::*;
-use funs::extent::*;
+use funs::exponential::*;
-use funs::sign::*;
 use num::cast::*;
 use num::default_eq::DefaultEq;
 use quat::{Quat, ToQuat};

src/quat.rs

@@ -7,9 +7,9 @@ use core::vec::raw::buf_as_slice;
 use std::cmp::FuzzyEq;
 
 use dim::Dimensional;
-use funs::exp::*;
+use funs::common::*;
-use funs::extent::*;
+use funs::exponential::*;
-use funs::trig::*;
+use funs::triganomic::*;
 use mat::{Mat3, Mat4};
 use num::cast::*;
 use num::default_eq::DefaultEq;

src/vec.rs

@@ -7,7 +7,7 @@ use core::vec::raw::buf_as_slice;
 use std::cmp::FuzzyEq;
 
 use dim::Dimensional;
-use funs::exp::Exp;
+use funs::exponential::Exp;
 use num::cast::*;
 use num::default_eq::DefaultEq;