✨ add new functions in bits & math lib

std/bits.nas

@@ -29,27 +29,27 @@ var u32_not = func(a) {
 }
 
 # get bit data from a special string. for example:
-# bits.fld(s,0,3);
-# if s stores 10100010(162)
-# will get 101(5).
+#   bits.fld(s,0,3);
+#   if s stores 10100010(162)
+#   will get 101(5).
 var fld = func(str, startbit, len) {
     return __fld;
 }
 
 # get sign-extended data from a special string. for example:
-# bits.sfld(s,0,3);
-# if s stores 10100010(162)
-# will get 101(5) then this will be signed extended to
-# 11111101(-3).
+#   bits.sfld(s,0,3);
+#   if s stores 10100010(162)
+#   will get 101(5) then this will be signed extended to
+#   11111101(-3).
 var sfld = func(str, startbit, len) {
     return __sfld;
 }
 
 # set value into a special string to store it. little-endian, for example:
-# bits.setfld(s,0,8,69);
-# set 01000101(69) to string will get this:
-# 10100010(162)
-# so s[0]=162.
+#   bits.setfld(s,0,8,69);
+#   set 01000101(69) to string will get this:
+#   10100010(162)
+#   so s[0]=162.
 var setfld = func(str, startbit, len, val) {
     return __setfld;
 }
@@ -57,4 +57,65 @@ var setfld = func(str, startbit, len, val) {
 # get a special string filled by '\0' to use in setfld.
 var buf = func(len) {
     return __buf;
+}
+
+var bit = [var __ = 1];
+for(var i = 1; i<32; i += 1) {
+    func(vec, arg...){
+        return __append;
+    }(bit, __ += __);
+}
+
+var test = func(n, b) {
+    n /= bit[b];
+    return int(n) != int(n/2)*2;
+}
+
+# returns number <n> with bit <b> set
+var set = func(n, b) {
+    return n+!test(n, b)*bit[b];
+}
+
+
+# returns number <n> with bit <b> cleared
+var clear = func(n, b) {
+    return n-test(n, b)*bit[b];
+}
+
+
+# returns number <n> with bit <b> toggled
+var toggle = func(n, b) {
+    return test(n, b) ? (n-bit[b]):(n+bit[b]);
+}
+
+
+# returns number <n> with bit <b> set to value <v>
+var switch = func(n, b, v) {
+    return n-(test(n, b)-!!v)*bit[b];
+}
+
+
+# returns number <n> as bit string, zero-padded to <len> digits:
+#   bits.string(6)     ->       "110"
+#   bits.string(6, 8)  ->  "00000110"
+var string = func(n, len = 1) {
+	var s = "";
+	while (n) {
+		var v = int(n/2);
+		s = (v+v!=n)~s;
+		n = v;
+	}
+	for (var i = size(s); i<len; i += 1)
+		s = '0'~s;
+	return s;
+}
+
+
+# returns bit string <s> as number:  bits.value("110")  ->  6
+var value = func(s) {
+	var n = 0;
+	var len = size(s);
+	for (var i = 0; i<len; i += 1)
+		n += n+(s[i]!= `0`);
+	return n;
 }

std/math.nas

@@ -21,6 +21,10 @@ var abs = func(x) {
     return x>0? x:-x;
 }
 
+var sgn = func(x) {
+    return x<0? -1:(x>0);
+}
+
 # floor will get the integral number of input argument
 # which is less than or equal to this argument.
 # this is basic native function in old nasal, 
@@ -57,6 +61,9 @@ var ln = func(x) {
     return __ln(x);
 }
 
+var _iln10 = 1/ln(10);
+var log10 = lg;
+
 var sqrt = func(x) {
     return __sqrt(x);
 }
@@ -69,10 +76,39 @@ var isnan = func(x) {
     return __isnan(x);
 }
 
-var max = func(x, y) {
-    return x>y? x:y;
+var max = func(x, arg...) {
+    var res = x;
+    foreach(var i;arg) {
+        if (i>res) {
+            res = i;
+        }
+    }
+    return res;
 }
 
-var min = func(x, y) {
-    return x<y? x:y;
+var min = func(x, arg...) {
+    var res = x;
+    foreach(var i;arg) {
+        if (i<res) {
+            res = i;
+        }
+    }
+    return res;
 }
+
+var mod = func(n, m) {
+    var x = n-int(n/m)*m;
+    return x<0? x+abs(m):x;
+}
+
+var fmod = func(n, m) {
+    return n-int(n/m)*m;
+}
+
+var clamp = func(value, min, max) {
+    return (value<min)? min:((value>max)? max:value);
+}
+
+var approx_eq = func(a, b, d = 0.000001) {
+    return abs(a-b)<d;
+}

test/donuts.nas

@@ -1,8 +1,6 @@
 import.std.runtime;
 
-var mod=func(n,a){
-    return n-int(n/a)*a;
-}
+var mod = math.mod;
 
 var main=func(run_time){
     var ts=maketimestamp();