No more "n/"-prefixed functions.

1 files changed, 18 insertions, 18 deletions

diff --git a/stdlib/source/lux/data/number/frac.lux b/stdlib/source/lux/data/number/frac.lux
index 522f3c674..0cd8fe897 100644
--- a/stdlib/source/lux/data/number/frac.lux
+++ b/stdlib/source/lux/data/number/frac.lux
@@ -196,7 +196,7 @@
                           +1.0)
                    div-power (loop [muls-left ("lux text size" decimal-part)
                                     output +1.0]
-                               (if (n/= 0 muls-left)
+                               (if (//nat.= 0 muls-left)
                                  output
                                  (recur (dec muls-left)
                                         (..* <base> output))))
@@ -227,9 +227,9 @@
 
     _
     (let [num-digits ("lux text size" digits)]
-      (if (n/<= chunk-size num-digits)
+      (if (//nat.<= chunk-size num-digits)
         (list digits)
-        (let [boundary (n/- chunk-size num-digits)
+        (let [boundary (//nat.- chunk-size num-digits)
               chunk ("lux text clip" boundary num-digits digits)
               remaining ("lux text clip" 0 boundary digits)]
           (list& chunk (segment-digits chunk-size remaining)))))))
@@ -323,15 +323,15 @@
 (template [<from> <from-translator> <to> <to-translator> <base-bits>]
   [(def: (<from> on-left? input)
      (-> Bit Text Text)
-     (let [max-num-chars (n// <base-bits> 64)
+     (let [max-num-chars (//nat./ <base-bits> 64)
            input-size ("lux text size" input)
-           zero-padding (let [num-digits-that-need-padding (n/% <base-bits> input-size)]
-                          (if (n/= 0 num-digits-that-need-padding)
+           zero-padding (let [num-digits-that-need-padding (//nat.% <base-bits> input-size)]
+                          (if (//nat.= 0 num-digits-that-need-padding)
                             ""
-                            (loop [zeroes-left (n/- num-digits-that-need-padding
-                                                    <base-bits>)
+                            (loop [zeroes-left (//nat.- num-digits-that-need-padding
+                                                        <base-bits>)
                                    output ""]
-                              (if (n/= 0 zeroes-left)
+                              (if (//nat.= 0 zeroes-left)
                                 output
                                 (recur (dec zeroes-left)
                                        ("lux text concat" "0" output))))))
@@ -448,7 +448,7 @@
                    sign-bit (if (..= -1.0 (..signum input))
                               1
                               0)
-                   exponent-bits (|> exponent ..int .nat (n/+ double-bias) (//i64.and exponent-mask))
+                   exponent-bits (|> exponent ..int .nat (//nat.+ double-bias) (//i64.and exponent-mask))
                    mantissa-bits (|> mantissa ..int .nat)]
                ($_ //i64.or
                    (//i64.left-shift 63 sign-bit)
@@ -464,7 +464,7 @@
 
   [mantissa mantissa-mask mantissa-size 0]
   [exponent exponent-mask exponent-size mantissa-size]
-  [sign     sign-mask     1             (n/+ exponent-size mantissa-size)]
+  [sign     sign-mask     1             (//nat.+ exponent-size mantissa-size)]
   )
 
 (def: #export (from-bits input)
@@ -472,15 +472,15 @@
   (let [S (sign input)
         E (exponent input)
         M (mantissa input)]
-    (cond (n/= ..special-exponent-bits E)
-          (if (n/= 0 M)
-            (if (n/= 0 S)
+    (cond (//nat.= ..special-exponent-bits E)
+          (if (//nat.= 0 M)
+            (if (//nat.= 0 S)
               ..positive-infinity
               ..negative-infinity)
             ..not-a-number)
 
-          (and (n/= 0 E) (n/= 0 M))
-          (if (n/= 0 S)
+          (and (//nat.= 0 E) (//nat.= 0 M))
+          (if (//nat.= 0 S)
             +0.0
             (..* -1.0 +0.0))
 
@@ -488,12 +488,12 @@
           (let [normalized (|> M (//i64.set mantissa-size)
                                .int //int.frac
                                (../ (math.pow +52.0 +2.0)))
-                power (math.pow (|> E (n/- double-bias)
+                power (math.pow (|> E (//nat.- double-bias)
                                     .int //int.frac)
                                 +2.0)
                 shifted (..* power
                              normalized)]
-            (if (n/= 0 S)
+            (if (//nat.= 0 S)
               shifted
               (..* -1.0 shifted))))))