---

yaml
---
r: 41465
b: refs/heads/snap-stage3
c: bb9c3ed
h: refs/heads/master
i:
  41463: 24b32cb
v: v3

Author: Kimundi

[refs]

@@ -1,7 +1,7 @@
 ---
 refs/heads/master: 09bb07bed9166105ea961a42b5fff7739ae0d2e9
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
-refs/heads/snap-stage3: 05d83017ec249d5a338001acba30f7b717c7507e
+refs/heads/snap-stage3: bb9c3ed8764077455b6e726ba49c9845e03f4f0c
 refs/heads/try: 3d5418789064fdb463e872a4e651af1c628a3650
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b

branches/snap-stage3/src/libcore/num/num.rs

@@ -59,4 +59,93 @@ pub trait ToStrRadix {
 
 pub trait FromStrRadix {
     static pub pure fn from_str_radix(str: &str, radix: uint) -> Option<self>;
+}
+
+// Generic math functions:
+
+/// Dynamically calculates the value `inf` (`1/0`).
+/// Can fail on integer types.
+#[inline(always)]
+pub pure fn infinity<T: Num One Zero>() -> T {
+    let _0: T = Zero::zero();
+    let _1: T = One::one();
+    _1 / _0
+}
+
+/// Dynamically calculates the value `-inf` (`-1/0`).
+/// Can fail on integer types.
+#[inline(always)]
+pub pure fn neg_infinity<T: Num One Zero>() -> T {
+    let _0: T = Zero::zero();
+    let _1: T = One::one();
+    - _1 / _0
+}
+
+/// Dynamically calculates the value `NaN` (`0/0`).
+/// Can fail on integer types.
+#[inline(always)]
+pub pure fn NaN<T: Num Zero>() -> T {
+    let _0: T = Zero::zero();
+    _0 / _0
+}
+
+/// Returns `true` if `num` has the value `inf` (`1/0`).
+/// Can fail on integer types.
+#[inline(always)]
+pub pure fn is_infinity<T: Num One Zero Eq>(num: &T) -> bool {
+    (*num) == (infinity::<T>())
+}
+
+/// Returns `true` if `num` has the value `-inf` (`-1/0`).
+/// Can fail on integer types.
+#[inline(always)]
+pub pure fn is_neg_infinity<T: Num One Zero Eq>(num: &T) -> bool {
+    (*num) == (neg_infinity::<T>())
+}
+
+/// Returns `true` if `num` has the value `NaN` (is not equal to itself).
+#[inline(always)]
+pub pure fn is_NaN<T: Num Eq>(num: &T) -> bool {
+    (*num) != (*num)
+}
+
+/// Returns `true` if `num` has the value `-0` (`1/num == -1/0`).
+/// Can fail on integer types.
+#[inline(always)]
+pub pure fn is_neg_zero<T: Num One Zero Eq>(num: &T) -> bool {
+    let _1: T = One::one();
+    let _0: T = Zero::zero();
+    *num == _0 && is_neg_infinity(&(_1 / *num))
+}
+
+/**
+ * Calculates a power to a given radix, optimized for uint `pow` and `radix`.
+ *
+ * Returns `radix^pow` as `T`.
+ *
+ * Note:
+ * Also returns `1` for `0^0`, despite that technically being an
+ * undefined number. The Reason for this is twofold:
+ * - If code written to use this function cares about that special case, it's
+ *   probably going to catch it before making the call.
+ * - If code written to use this function doesn't care about it, it's
+ *   probably assuming that `x^0` always equals `1`.
+ */ 
+pub pure fn pow_with_uint<T: Num One Zero>(radix: uint, pow: uint) -> T {
+    let _0: T = Zero::zero();
+    let _1: T = One::one();
+
+    if pow   == 0u { return _1; }
+    if radix == 0u { return _0; }
+    let mut my_pow     = pow;
+    let mut total      = _1;
+    let mut multiplier = Num::from_int(radix as int);
+    while (my_pow > 0u) {
+        if my_pow % 2u == 1u {
+            total *= multiplier;
+        }
+        my_pow     /= 2u;
+        multiplier *= multiplier;
+    }
+    total
 }