Updated to latest rust, added take_only Vec method, add factorisation module

Author: mitchmindtree

src/factorisation.rs

@@ -0,0 +1,78 @@
+//!
+//! factorisation.rs
+//!
+//! Created by Mitchell Nordine at 05:03AM on May 29, 2014.
+//!
+//!
+
+use std::num::Int;
+use super::modulo;
+
+/// Check if the queried value is a factor of num.
+#[inline]
+pub fn is_factor<I>(num: I, query: I) -> bool
+where I: Int {
+    modulo(num, query) == Int::zero()
+}
+
+/// Check if any of the queried values are a factor of num.
+#[inline]
+pub fn are_any_factors<I>(num: I, queries: &[I]) -> bool
+where I: Int + Copy {
+    queries.iter().any(|query| is_factor(num, *query))
+}
+
+/// Check if all of the queried values are a factor of num.
+#[inline]
+pub fn are_all_factors<I>(num: I, queries: &[I]) -> bool
+where I: Int + Copy {
+    queries.iter().all(|query| is_factor(num, *query))
+}
+
+/// Is the number prime?
+#[inline]
+pub fn is_prime<I>(num: I) -> bool
+where I: Int + Copy {
+    match get_all_factors(num).len() {
+        1 | 2 => true,
+        _ => false
+    }
+}
+
+/// Return the lowest non-one factor.
+#[inline]
+pub fn lowest_non_one<I>(n: I) -> Option<I>
+where I: Int + Copy {
+    let one: I = Int::one();
+    let mut i: I = one + one;
+    while i * i <= n {
+        if n % i == Int::zero() {
+            if i > one { return Some(i) }
+            else if i * i != n {
+                let n_div_i = n / i;
+                if n_div_i > one { return Some(n_div_i) }
+            }
+        }
+        i = i + one;
+    }
+    None
+}
+
+/// Get all factors for 'n'.
+#[inline]
+pub fn get_all_factors<I>(n: I) -> Vec<I> where I: Int {
+    let one: I = Int::one();
+    let mut factors: Vec<I> = vec![one];
+    let mut i: I = one + one;
+    while i * i <= n {
+        if n % i == Int::zero() {
+            factors.push(i);
+            if i * i != n { factors.push(n / i); }
+        }
+        i = i + one;
+    }
+    factors.push(n);
+    factors.sort_by(|a, b| a.cmp(b));
+    return factors; 
+}
+

src/lib.rs

@@ -7,6 +7,14 @@
 
 #![feature(if_let)]
 
+pub use factorisation::{
+    is_factor,
+    are_any_factors,
+    are_all_factors,
+    is_prime,
+    lowest_non_one,
+    get_all_factors,
+};
 pub use iter::{
     ZipPrev,
 };
@@ -22,7 +30,12 @@ pub use math::{
     remainder,
     wrap,
 };
+pub use vec::{
+    TakeOnly,
+};
 
+pub mod factorisation;
 pub mod iter;
 pub mod math;
+pub mod vec;
 

src/math.rs

@@ -6,44 +6,46 @@
 ///
 
 use std::mem;
-use std::num::One;
-use std::num::zero;
+use std::num::{
+    Float,
+    Int,
+};
 
 /// Clamp a value to a range.
 #[inline]
-pub fn clamp<T: Num + Primitive>(val: T, min: T, max: T) -> T {
+pub fn clamp<T: PartialOrd>(val: T, min: T, max: T) -> T {
     if val < min { min } else { if val > max { max } else { val } }
 }
 
 /// Floors value.
 #[inline]
-pub fn fast_floor<F: Float + FromPrimitive + ToPrimitive>(f: F) -> int {
+pub fn fast_floor<F: Float + FromPrimitive + ToPrimitive>(f: F) -> i64 {
     return if f > FromPrimitive::from_int(0).unwrap() {
-        f.to_int().unwrap()
+        f.to_i64().unwrap()
     } else {
-        f.to_int().unwrap() - One::one()
+        f.to_i64().unwrap() - Int::one()
     }
 }
 
 /// Models the CPP fmod function.
 #[inline]
-pub fn fmod<F: Float + FromPrimitive + ToPrimitive>(numer: F, denom: F) -> F {
+pub fn fmod<F: Float>(numer: F, denom: F) -> F {
     let rquot: F = (numer / denom).floor();
     numer - rquot * denom
 }
 
 /// Implementation of grad1 for the ported _slang_library_noise1 method
 #[inline]
-pub fn grad1(hash: int, x: f32) -> f32 {
-    let h: int = hash & 15;
+pub fn grad1(hash: i64, x: f32) -> f32 {
+    let h: i64 = hash & 15;
     let mut grad: f32 = 1.0f32 + ((h & 7) as f32);
     if h & 8 > 0 { grad = (-1.0f32) * grad; }
     grad * x
 }
 
 /// Check if value is in range.
 #[inline]
-pub fn in_range<T: Num + Primitive>(val: T, min: T, max: T) -> bool {
+pub fn in_range<T: Ord>(val: T, min: T, max: T) -> bool {
     val >= min && val <= max
 }
 
@@ -55,8 +57,8 @@ pub fn lerp(start: f32, stop: f32, amt: f32) -> f32 {
 
 /// Map a value from a given range to a new given range.
 #[inline]
-pub fn map_range<X: Num + Copy + FromPrimitive + ToPrimitive,
-                 Y: Num + Copy + FromPrimitive + ToPrimitive>
+pub fn map_range<X: Copy + FromPrimitive + ToPrimitive,
+                 Y: Copy + FromPrimitive + ToPrimitive>
     (val: X, in_min: X, in_max: X, out_min: Y, out_max: Y) -> Y {
     let (val_f, in_min_f, in_max_f, out_min_f, out_max_f) = (
         val.to_f64().unwrap(),
@@ -86,9 +88,9 @@ pub fn remainder<F: Float + FromPrimitive + ToPrimitive>(numer: F, denom: F) ->
 #[inline]
 pub fn modulo<I: Int>(a: I, b: I) -> I {
     match a % b {
-        r if (r > zero() && b < zero())
-          || (r < zero() && b > zero()) => (r + b),
-        r                               => r,
+        r if (r > Int::zero() && b < Int::zero())
+          || (r < Int::zero() && b > Int::zero()) => (r + b),
+        r                                         => r,
     }
 }
 

src/vec.rs

@@ -0,0 +1,30 @@
+//!
+//!  vec.rs
+//!
+//!  Created by Mitchell Nordine at 01:25AM on November 18, 2014.
+//!
+//!
+
+
+/// Take only the elements that return `true` from the given condition.
+pub trait TakeOnly<T> {
+    /// Take only the elements that return `true` from the given condition.
+    fn take_only(&mut self, |&T| -> bool) -> Vec<T>;
+}
+
+impl<T> TakeOnly<T> for Vec<T> {
+    fn take_only(&mut self, cond: |&T| -> bool) -> Vec<T> {
+        let mut vec = Vec::with_capacity(self.len());
+        let mut i = 0;
+        while i < self.len() {
+            let cond_result = cond(&self[i]);
+            if cond_result {
+                vec.push(self.remove(i).expect("Tried to take T at `i` - no elem there."));
+            } else {
+                i += 1;
+            }
+        }
+        vec
+    }
+}
+