Divide funs::common up into separate modules

This commit is contained in:
Brendan Zabarauskas 2012-11-22 11:09:04 +10:00
parent c6a7018aec
commit 167ca9a84d
8 changed files with 216 additions and 221 deletions

44
src/funs/approx.rs Normal file
View file

@ -0,0 +1,44 @@
use num::cast::cast;
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 {}
}
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 {}
}
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 {}
}

View file

@ -1,215 +0,0 @@
use core::cmp::{Eq, Ord};
use num::cast::*;
use vec::{Vec2, Vec3, Vec4};
/**
* Common Functions for all numeric types
*/
pub trait Extent {
pure fn min(y: &self) -> self;
pure fn max(y: &self) -> self;
pure fn clamp(minv: &self, maxv: &self) -> self;
}
#[inline(always)] pub pure fn min<T:Extent>(x: &T, y: &T) -> T { x.min(y) }
#[inline(always)] pub pure fn max<T:Extent>(x: &T, y: &T) -> T { x.max(y) }
#[inline(always)] pub pure fn clamp<T:Extent>(x: &T, minv: &T, maxv: &T) -> T { x.clamp(minv, maxv) }
pub impl u8: Extent {
#[inline(always)] pure fn min(y: &u8) -> u8 { if self < *y { self } else { *y } }
#[inline(always)] pure fn max(y: &u8) -> u8 { if self > *y { self } else { *y } }
#[inline(always)] pure fn clamp(minv: &u8, maxv: &u8) -> u8 { min(&max(&self, minv), maxv) }
}
pub impl u16: Extent {
#[inline(always)] pure fn min(y: &u16) -> u16 { if self < *y { self } else { *y } }
#[inline(always)] pure fn max(y: &u16) -> u16 { if self > *y { self } else { *y } }
#[inline(always)] pure fn clamp(minv: &u16, maxv: &u16) -> u16 { min(&max(&self, minv), maxv) }
}
pub impl u32: Extent {
#[inline(always)] pure fn min(y: &u32) -> u32 { if self < *y { self } else { *y } }
#[inline(always)] pure fn max(y: &u32) -> u32 { if self > *y { self } else { *y } }
#[inline(always)] pure fn clamp(minv: &u32, maxv: &u32) -> u32 { min(&max(&self, minv), maxv) }
}
pub impl u64: Extent {
#[inline(always)] pure fn min(y: &u64) -> u64 { if self < *y { self } else { *y } }
#[inline(always)] pure fn max(y: &u64) -> u64 { if self > *y { self } else { *y } }
#[inline(always)] pure fn clamp(minv: &u64, maxv: &u64) -> u64 { min(&max(&self, minv), maxv) }
}
pub impl uint: Extent {
#[inline(always)] pure fn min(y: &uint) -> uint { if self < *y { self } else { *y } }
#[inline(always)] pure fn max(y: &uint) -> uint { if self > *y { self } else { *y } }
#[inline(always)] pure fn clamp(minv: &uint, maxv: &uint) -> uint { min(&max(&self, minv), maxv) }
}
pub impl i8: Extent {
#[inline(always)] pure fn min(y: &i8) -> i8 { if self < *y { self } else { *y } }
#[inline(always)] pure fn max(y: &i8) -> i8 { if self > *y { self } else { *y } }
#[inline(always)] pure fn clamp(minv: &i8, maxv: &i8) -> i8 { min(&max(&self, minv), maxv) }
}
pub impl i16: Extent {
#[inline(always)] pure fn min(y: &i16) -> i16 { if self < *y { self } else { *y } }
#[inline(always)] pure fn max(y: &i16) -> i16 { if self > *y { self } else { *y } }
#[inline(always)] pure fn clamp(minv: &i16, maxv: &i16) -> i16 { min(&max(&self, minv), maxv) }
}
pub impl i32: Extent {
#[inline(always)] pure fn min(y: &i32) -> i32 { if self < *y { self } else { *y } }
#[inline(always)] pure fn max(y: &i32) -> i32 { if self > *y { self } else { *y } }
#[inline(always)] pure fn clamp(minv: &i32, maxv: &i32) -> i32 { min(&max(&self, minv), maxv) }
}
pub impl i64: Extent {
#[inline(always)] pure fn min(y: &i64) -> i64 { if self < *y { self } else { *y } }
#[inline(always)] pure fn max(y: &i64) -> i64 { if self > *y { self } else { *y } }
#[inline(always)] pure fn clamp(minv: &i64, maxv: &i64) -> i64 { min(&max(&self, minv), maxv) }
}
pub impl int: Extent {
#[inline(always)] pure fn min(y: &int) -> int { if self < *y { self } else { *y } }
#[inline(always)] pure fn max(y: &int) -> int { if self > *y { self } else { *y } }
#[inline(always)] pure fn clamp(minv: &int, maxv: &int) -> int { min(&max(&self, minv), maxv) }
}
pub impl f32: Extent {
#[inline(always)] pure fn min(y: &f32) -> f32 { if self < *y { self } else { *y } }
#[inline(always)] pure fn max(y: &f32) -> f32 { if self > *y { self } else { *y } }
#[inline(always)] pure fn clamp(minv: &f32, maxv: &f32) -> f32 { min(&max(&self, minv), maxv) }
}
pub impl f64: Extent {
#[inline(always)] pure fn min(y: &f64) -> f64 { if self < *y { self } else { *y } }
#[inline(always)] pure fn max(y: &f64) -> f64 { if self > *y { self } else { *y } }
#[inline(always)] pure fn clamp(minv: &f64, maxv: &f64) -> f64 { min(&max(&self, minv), maxv) }
}
pub impl float: Extent {
#[inline(always)] pure fn min(y: &float) -> float { if self < *y { self } else { *y } }
#[inline(always)] pure fn max(y: &float) -> float { if self > *y { self } else { *y } }
#[inline(always)] pure fn clamp(minv: &float, maxv: &float) -> float { min(&max(&self, minv), maxv) }
}
/**
* Common Functions for signed numeric types
*/
pub trait Signed {
pure fn abs() -> self;
pure fn sgn() -> self;
}
#[inline(always)] pub pure fn abs<T:Signed>(x: &T) -> T { x.abs() }
#[inline(always)] pub pure fn sgn<T:Signed>(x: &T) -> T { x.sgn() }
pub impl i8: Signed {
#[inline(always)] pure fn abs() -> i8 { if self >= 0 { self } else {-self } }
#[inline(always)] pure fn sgn() -> i8 { if self > 0 { 1 } else if self == 0 { 0 } else { -1 } }
}
pub impl i16: Signed {
#[inline(always)] pure fn abs() -> i16 { if self >= 0 { self } else {-self } }
#[inline(always)] pure fn sgn() -> i16 { if self > 0 { 1 } else if self == 0 { 0 } else { -1 } }
}
pub impl i32: Signed {
#[inline(always)] pure fn abs() -> i32 { if self >= 0 { self } else {-self } }
#[inline(always)] pure fn sgn() -> i32 { if self > 0 { 1 } else if self == 0 { 0 } else { -1 } }
}
pub impl i64: Signed {
#[inline(always)] pure fn abs() -> i64 { if self >= 0 { self } else {-self } }
#[inline(always)] pure fn sgn() -> i64 { if self > 0 { 1 } else if self == 0 { 0 } else { -1 } }
}
pub impl int: Signed {
#[inline(always)] pure fn abs() -> int { if self >= 0 { self } else {-self } }
#[inline(always)] pure fn sgn() -> int { if self > 0 { 1 } else if self == 0 { 0 } else { -1 } }
}
pub impl f32: Signed {
#[inline(always)] pure fn abs() -> f32 { if self >= 0f32 { self } else {-self } }
#[inline(always)] pure fn sgn() -> f32 { if self > 0f32 { 1f32 } else if self == 0f32 { 0f32 } else { -1f32 } }
}
pub impl f64: Signed {
#[inline(always)] pure fn abs() -> f64 { if self >= 0f64 { self } else {-self } }
#[inline(always)] pure fn sgn() -> f64 { if self > 0f64 { 1f64 } else if self == 0f64 { 0f64 } else { -1f64 } }
}
pub impl float: Signed {
#[inline(always)] pure fn abs() -> float { if self >= 0f { self } else {-self } }
#[inline(always)] pure fn sgn() -> float { if self > 0f { 1f } else if self == 0f { 0f } else { -1f } }
}
/**
* Common Functions for floating point types
*/
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 {}
}
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 {}
}
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 {}
}
pub trait Mix<B> {
pure fn mix(y: &self, a: &self) -> self;
pure fn mixb(y: &self, a: &B) -> self;
}
#[inline(always)] pub pure fn mix<T:Mix<B>, B>(x: &T, y: &T, a: &T) -> T { x.mix(y, a) }
#[inline(always)] pub pure fn mixb<T:Mix<B>, B>(x: &T, y: &T, a: &B) -> T { x.mixb(y, a) }
pub impl f32: Mix<bool> {
#[inline(always)] pure fn mix(y: &f32, a: &f32) -> f32 { self * (1f32 - (*a)) + (*y) * (*a) }
#[inline(always)] pure fn mixb(y: &f32, a: &bool) -> f32 { if *a { *y } else { self } }
}
pub impl f64: Mix<bool> {
#[inline(always)] pure fn mix(y: &f64, a: &f64) -> f64 { self * (1f64 - (*a)) + (*y) * (*a) }
#[inline(always)] pure fn mixb(y: &f64, a: &bool) -> f64 { if *a { *y } else { self } }
}
pub impl float: Mix<bool> {
#[inline(always)] pure fn mix(y: &float, a: &float) -> float { self * (1f - (*a)) + (*y) * (*a) }
#[inline(always)] pure fn mixb(y: &float, a: &bool) -> float { if *a { *y } else { self } }
}

89
src/funs/extent.rs Normal file
View file

@ -0,0 +1,89 @@
use num::cast::cast;
pub trait Extent {
pure fn min(y: &self) -> self;
pure fn max(y: &self) -> self;
pure fn clamp(minv: &self, maxv: &self) -> self;
}
#[inline(always)] pub pure fn min<T:Extent>(x: &T, y: &T) -> T { x.min(y) }
#[inline(always)] pub pure fn max<T:Extent>(x: &T, y: &T) -> T { x.max(y) }
#[inline(always)] pub pure fn clamp<T:Extent>(x: &T, minv: &T, maxv: &T) -> T { x.clamp(minv, maxv) }
pub impl u8: Extent {
#[inline(always)] pure fn min(y: &u8) -> u8 { if self < *y { self } else { *y } }
#[inline(always)] pure fn max(y: &u8) -> u8 { if self > *y { self } else { *y } }
#[inline(always)] pure fn clamp(minv: &u8, maxv: &u8) -> u8 { min(&max(&self, minv), maxv) }
}
pub impl u16: Extent {
#[inline(always)] pure fn min(y: &u16) -> u16 { if self < *y { self } else { *y } }
#[inline(always)] pure fn max(y: &u16) -> u16 { if self > *y { self } else { *y } }
#[inline(always)] pure fn clamp(minv: &u16, maxv: &u16) -> u16 { min(&max(&self, minv), maxv) }
}
pub impl u32: Extent {
#[inline(always)] pure fn min(y: &u32) -> u32 { if self < *y { self } else { *y } }
#[inline(always)] pure fn max(y: &u32) -> u32 { if self > *y { self } else { *y } }
#[inline(always)] pure fn clamp(minv: &u32, maxv: &u32) -> u32 { min(&max(&self, minv), maxv) }
}
pub impl u64: Extent {
#[inline(always)] pure fn min(y: &u64) -> u64 { if self < *y { self } else { *y } }
#[inline(always)] pure fn max(y: &u64) -> u64 { if self > *y { self } else { *y } }
#[inline(always)] pure fn clamp(minv: &u64, maxv: &u64) -> u64 { min(&max(&self, minv), maxv) }
}
pub impl uint: Extent {
#[inline(always)] pure fn min(y: &uint) -> uint { if self < *y { self } else { *y } }
#[inline(always)] pure fn max(y: &uint) -> uint { if self > *y { self } else { *y } }
#[inline(always)] pure fn clamp(minv: &uint, maxv: &uint) -> uint { min(&max(&self, minv), maxv) }
}
pub impl i8: Extent {
#[inline(always)] pure fn min(y: &i8) -> i8 { if self < *y { self } else { *y } }
#[inline(always)] pure fn max(y: &i8) -> i8 { if self > *y { self } else { *y } }
#[inline(always)] pure fn clamp(minv: &i8, maxv: &i8) -> i8 { min(&max(&self, minv), maxv) }
}
pub impl i16: Extent {
#[inline(always)] pure fn min(y: &i16) -> i16 { if self < *y { self } else { *y } }
#[inline(always)] pure fn max(y: &i16) -> i16 { if self > *y { self } else { *y } }
#[inline(always)] pure fn clamp(minv: &i16, maxv: &i16) -> i16 { min(&max(&self, minv), maxv) }
}
pub impl i32: Extent {
#[inline(always)] pure fn min(y: &i32) -> i32 { if self < *y { self } else { *y } }
#[inline(always)] pure fn max(y: &i32) -> i32 { if self > *y { self } else { *y } }
#[inline(always)] pure fn clamp(minv: &i32, maxv: &i32) -> i32 { min(&max(&self, minv), maxv) }
}
pub impl i64: Extent {
#[inline(always)] pure fn min(y: &i64) -> i64 { if self < *y { self } else { *y } }
#[inline(always)] pure fn max(y: &i64) -> i64 { if self > *y { self } else { *y } }
#[inline(always)] pure fn clamp(minv: &i64, maxv: &i64) -> i64 { min(&max(&self, minv), maxv) }
}
pub impl int: Extent {
#[inline(always)] pure fn min(y: &int) -> int { if self < *y { self } else { *y } }
#[inline(always)] pure fn max(y: &int) -> int { if self > *y { self } else { *y } }
#[inline(always)] pure fn clamp(minv: &int, maxv: &int) -> int { min(&max(&self, minv), maxv) }
}
pub impl f32: Extent {
#[inline(always)] pure fn min(y: &f32) -> f32 { if self < *y { self } else { *y } }
#[inline(always)] pure fn max(y: &f32) -> f32 { if self > *y { self } else { *y } }
#[inline(always)] pure fn clamp(minv: &f32, maxv: &f32) -> f32 { min(&max(&self, minv), maxv) }
}
pub impl f64: Extent {
#[inline(always)] pure fn min(y: &f64) -> f64 { if self < *y { self } else { *y } }
#[inline(always)] pure fn max(y: &f64) -> f64 { if self > *y { self } else { *y } }
#[inline(always)] pure fn clamp(minv: &f64, maxv: &f64) -> f64 { min(&max(&self, minv), maxv) }
}
pub impl float: Extent {
#[inline(always)] pure fn min(y: &float) -> float { if self < *y { self } else { *y } }
#[inline(always)] pure fn max(y: &float) -> float { if self > *y { self } else { *y } }
#[inline(always)] pure fn clamp(minv: &float, maxv: &float) -> float { min(&max(&self, minv), maxv) }
}

22
src/funs/mix.rs Normal file
View file

@ -0,0 +1,22 @@
pub trait Mix<B> {
pure fn mix(y: &self, a: &self) -> self;
pure fn mixb(y: &self, a: &B) -> self;
}
#[inline(always)] pub pure fn mix<T:Mix<B>, B>(x: &T, y: &T, a: &T) -> T { x.mix(y, a) }
#[inline(always)] pub pure fn mixb<T:Mix<B>, B>(x: &T, y: &T, a: &B) -> T { x.mixb(y, a) }
pub impl f32: Mix<bool> {
#[inline(always)] pure fn mix(y: &f32, a: &f32) -> f32 { self * (1f32 - (*a)) + (*y) * (*a) }
#[inline(always)] pure fn mixb(y: &f32, a: &bool) -> f32 { if *a { *y } else { self } }
}
pub impl f64: Mix<bool> {
#[inline(always)] pure fn mix(y: &f64, a: &f64) -> f64 { self * (1f64 - (*a)) + (*y) * (*a) }
#[inline(always)] pure fn mixb(y: &f64, a: &bool) -> f64 { if *a { *y } else { self } }
}
pub impl float: Mix<bool> {
#[inline(always)] pure fn mix(y: &float, a: &float) -> float { self * (1f - (*a)) + (*y) * (*a) }
#[inline(always)] pure fn mixb(y: &float, a: &bool) -> float { if *a { *y } else { self } }
}

51
src/funs/sign.rs Normal file
View file

@ -0,0 +1,51 @@
/// 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 } }
}

View file

@ -32,11 +32,14 @@ pub mod num {
} }
pub mod funs { pub mod funs {
pub mod approx;
pub mod boolv; pub mod boolv;
pub mod common;
pub mod exp; pub mod exp;
pub mod extent;
pub mod mix;
pub mod projection; pub mod projection;
pub mod relv; pub mod relv;
pub mod sign;
pub mod transform; pub mod transform;
pub mod trig; pub mod trig;

View file

@ -1,13 +1,14 @@
use core::cast::transmute; use core::cast::transmute;
use core::cmp::Eq; use core::cmp::{Eq, Ord};
use core::ptr::to_unsafe_ptr; use core::ptr::to_unsafe_ptr;
use core::vec::raw::buf_as_slice; use core::vec::raw::buf_as_slice;
use std::cmp::FuzzyEq; use std::cmp::FuzzyEq;
use dim::Dimensional; use dim::Dimensional;
use funs::common::*;
use funs::exp::*; use funs::exp::*;
use funs::extent::*;
use funs::sign::*;
use num::cast::*; use num::cast::*;
use num::default_eq::DefaultEq; use num::default_eq::DefaultEq;
use quat::{Quat, ToQuat}; use quat::{Quat, ToQuat};
@ -826,7 +827,7 @@ pub impl<T:Copy Num NumCast> Mat4<T>: NumericMatrix<T, Vec4<T>, Vec4<T>> {
} }
} }
pub impl<T:Copy Num NumCast DefaultEq Signed Ord> Mat4<T>: NumericMatrixNxN<T, Vec4<T>> { pub impl<T:Copy Num NumCast DefaultEq Sign Ord> Mat4<T>: NumericMatrixNxN<T, Vec4<T>> {
#[inline(always)] #[inline(always)]
static pure fn identity() -> Mat4<T> { static pure fn identity() -> Mat4<T> {
Mat4::new(NumCast::one() , NumCast::zero(), NumCast::zero(), NumCast::zero(), Mat4::new(NumCast::one() , NumCast::zero(), NumCast::zero(), NumCast::zero(),

View file

@ -1,5 +1,5 @@
use core::cast::transmute; use core::cast::transmute;
use core::cmp::Eq; use core::cmp::{Eq, Ord};
use core::ptr::to_unsafe_ptr; use core::ptr::to_unsafe_ptr;
use core::vec::raw::buf_as_slice; use core::vec::raw::buf_as_slice;
@ -7,8 +7,8 @@ use std::cmp::FuzzyEq;
use dim::Dimensional; use dim::Dimensional;
use funs::exp::*; use funs::exp::*;
use funs::extent::*;
use funs::trig::*; use funs::trig::*;
use funs::common::*;
use mat::{Mat3, Mat4}; use mat::{Mat3, Mat4};
use num::cast::*; use num::cast::*;
use num::default_eq::DefaultEq; use num::default_eq::DefaultEq;