From 167ca9a84dae17ea3eaa1df30044ad1fe82cf791 Mon Sep 17 00:00:00 2001 From: Brendan Zabarauskas Date: Thu, 22 Nov 2012 11:09:04 +1000 Subject: [PATCH] Divide funs::common up into separate modules --- src/funs/approx.rs | 44 ++++++++++ src/funs/common.rs | 215 --------------------------------------------- src/funs/extent.rs | 89 +++++++++++++++++++ src/funs/mix.rs | 22 +++++ src/funs/sign.rs | 51 +++++++++++ src/lmath.rc | 5 +- src/mat.rs | 7 +- src/quat.rs | 4 +- 8 files changed, 216 insertions(+), 221 deletions(-) create mode 100644 src/funs/approx.rs delete mode 100644 src/funs/common.rs create mode 100644 src/funs/extent.rs create mode 100644 src/funs/mix.rs create mode 100644 src/funs/sign.rs diff --git a/src/funs/approx.rs b/src/funs/approx.rs new file mode 100644 index 0000000..3be1555 --- /dev/null +++ b/src/funs/approx.rs @@ -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(x: T) -> T { x.floor() } +#[inline(always)] pub pure fn trunc(x: T) -> T { x.trunc() } +#[inline(always)] pub pure fn round(x: T) -> T { x.round() } +// #[inline(always)] pub pure fn roundEven(x: T) -> T { x.roundEven() } +#[inline(always)] pub pure fn ceil(x: T) -> T { x.ceil() } +// #[inline(always)] pub pure fn fract(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 {} +} \ No newline at end of file diff --git a/src/funs/common.rs b/src/funs/common.rs deleted file mode 100644 index 2948522..0000000 --- a/src/funs/common.rs +++ /dev/null @@ -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(x: &T, y: &T) -> T { x.min(y) } -#[inline(always)] pub pure fn max(x: &T, y: &T) -> T { x.max(y) } -#[inline(always)] pub pure fn clamp(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(x: &T) -> T { x.abs() } -#[inline(always)] pub pure fn sgn(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(x: T) -> T { x.floor() } -#[inline(always)] pub pure fn trunc(x: T) -> T { x.trunc() } -#[inline(always)] pub pure fn round(x: T) -> T { x.round() } -// #[inline(always)] pub pure fn roundEven(x: T) -> T { x.roundEven() } -#[inline(always)] pub pure fn ceil(x: T) -> T { x.ceil() } -// #[inline(always)] pub pure fn fract(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 { - pure fn mix(y: &self, a: &self) -> self; - pure fn mixb(y: &self, a: &B) -> self; -} - -#[inline(always)] pub pure fn mix, B>(x: &T, y: &T, a: &T) -> T { x.mix(y, a) } -#[inline(always)] pub pure fn mixb, B>(x: &T, y: &T, a: &B) -> T { x.mixb(y, a) } - -pub impl f32: Mix { - #[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 { - #[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 { - #[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 } } -} \ No newline at end of file diff --git a/src/funs/extent.rs b/src/funs/extent.rs new file mode 100644 index 0000000..e8aab9f --- /dev/null +++ b/src/funs/extent.rs @@ -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(x: &T, y: &T) -> T { x.min(y) } +#[inline(always)] pub pure fn max(x: &T, y: &T) -> T { x.max(y) } +#[inline(always)] pub pure fn clamp(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) } +} \ No newline at end of file diff --git a/src/funs/mix.rs b/src/funs/mix.rs new file mode 100644 index 0000000..b17e41d --- /dev/null +++ b/src/funs/mix.rs @@ -0,0 +1,22 @@ +pub trait Mix { + pure fn mix(y: &self, a: &self) -> self; + pure fn mixb(y: &self, a: &B) -> self; +} + +#[inline(always)] pub pure fn mix, B>(x: &T, y: &T, a: &T) -> T { x.mix(y, a) } +#[inline(always)] pub pure fn mixb, B>(x: &T, y: &T, a: &B) -> T { x.mixb(y, a) } + +pub impl f32: Mix { + #[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 { + #[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 { + #[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 } } +} \ No newline at end of file diff --git a/src/funs/sign.rs b/src/funs/sign.rs new file mode 100644 index 0000000..eea7733 --- /dev/null +++ b/src/funs/sign.rs @@ -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(x: &T) -> T { x.abs() } +#[inline(always)] pub pure fn 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 } } +} \ No newline at end of file diff --git a/src/lmath.rc b/src/lmath.rc index 05110a2..321c794 100644 --- a/src/lmath.rc +++ b/src/lmath.rc @@ -32,11 +32,14 @@ pub mod num { } pub mod funs { + pub mod approx; pub mod boolv; - pub mod common; pub mod exp; + pub mod extent; + pub mod mix; pub mod projection; pub mod relv; + pub mod sign; pub mod transform; pub mod trig; diff --git a/src/mat.rs b/src/mat.rs index 9ddb369..d1f4739 100644 --- a/src/mat.rs +++ b/src/mat.rs @@ -1,13 +1,14 @@ use core::cast::transmute; -use core::cmp::Eq; +use core::cmp::{Eq, Ord}; use core::ptr::to_unsafe_ptr; use core::vec::raw::buf_as_slice; use std::cmp::FuzzyEq; use dim::Dimensional; -use funs::common::*; use funs::exp::*; +use funs::extent::*; +use funs::sign::*; use num::cast::*; use num::default_eq::DefaultEq; use quat::{Quat, ToQuat}; @@ -826,7 +827,7 @@ pub impl Mat4: NumericMatrix, Vec4> { } } -pub impl Mat4: NumericMatrixNxN> { +pub impl Mat4: NumericMatrixNxN> { #[inline(always)] static pure fn identity() -> Mat4 { Mat4::new(NumCast::one() , NumCast::zero(), NumCast::zero(), NumCast::zero(), diff --git a/src/quat.rs b/src/quat.rs index 5c23b6d..016a048 100644 --- a/src/quat.rs +++ b/src/quat.rs @@ -1,5 +1,5 @@ use core::cast::transmute; -use core::cmp::Eq; +use core::cmp::{Eq, Ord}; use core::ptr::to_unsafe_ptr; use core::vec::raw::buf_as_slice; @@ -7,8 +7,8 @@ use std::cmp::FuzzyEq; use dim::Dimensional; use funs::exp::*; +use funs::extent::*; use funs::trig::*; -use funs::common::*; use mat::{Mat3, Mat4}; use num::cast::*; use num::default_eq::DefaultEq;