4 files changed, 110 insertions, 32 deletions
diff --git a/std/Number/Binary.bruijn b/std/Number/Binary.bruijn
index a056538..77ce09c 100644
--- a/std/Number/Binary.bruijn
+++ b/std/Number/Binary.bruijn
@@ -163,6 +163,9 @@ not-eq? not! ∘∘ eq? ⧗ Binary → Binary → Boolean
 :test ([[[1 (0 2)]]] ≠? [[[1 (0 2)]]]) (false)
 :test ([[[1 (0 2)]]] ≠? (+2b)) (true)
 
+# prefix for comparing functions
+?‣ &eq?
+
 # adds 1 to a binary number (can introduce leading 0s)
 inc [~(0 z a¹ a⁰)] ⧗ Binary → Binary
 	z (+0b) : (+1b)
@@ -196,7 +199,7 @@ complement [[[[3 2 0 1]]]] ⧗ Binary → Binary
 :test (-*(+42b)) ([[[1 (0 (1 (0 (1 (0 2)))))]]])
 
 # inverts a binary number by complementing and incrementing (2's complement)
-# don't forget to pad the number with zeroes if needed
+# don't forget to pad the number with 0s if needed
 invert ++‣ ∘ -*‣ ⧗ Binary → Binary
 
 -‣ invert
@@ -204,9 +207,9 @@ invert ++‣ ∘ -*‣ ⧗ Binary → Binary
 :test (-(+0b)) ((+1b))
 :test (-(+1b)) ((+1b))
 
-# pads a binary number with zeroes until its as long a another binary number
-# TODO: this could probably be done without list magic
-pad [[binary! (pad-right ∀(list! %1) b⁰ (list! 0))]] ⧗ Binary → Binary → Binary
+# pads a binary number with 0s until it's as long a another binary number
+# TODO: this could be done without list magic (see Ternary)
+pad [[binary! (pad-right ∀(list! %1) b⁰ (list! %0))]] ⧗ Binary → Binary → Binary
 
 :test (pad (+5b) [[[1 2]]]) ([[[1 (0 (0 2))]]])
 
@@ -248,7 +251,7 @@ sub* [[abs 1 →^0]] ⧗ Binary → Binary → Binary
 # subs two binary numbers
 # uses addition but with two's complement
 # TODO: isn't very performant ⇒ replace with sub*
-# TODO: gives wrong results if b>a in a-b
+# TODO: gives fun results if b>a in a-b
 sub [[(0 =? 1) (+0b) -((pad 1 0) + -(pad 0 1))]] ⧗ Binary → Binary → Binary
 
 …-… sub
@@ -279,6 +282,20 @@ div² [~(0 z a¹ a⁰)] ⧗ Binary → Binary
 :test (/²(+6b) =? (+3b)) (true)
 :test (/²(+5b) =? (+2b)) (true)
 
+# ceiled integer log2 by counting bits
+# also counts leading 0s
+log2* [0 (+0b) inc inc] ⧗ Binary → Binary
+
+# ceiled integer log2 by counting bits
+log2 log2* ∘ strip ⧗ Binary → Binary
+
+:test ((log2 (+1b)) =? (+1b)) (true)
+:test ((log2 (+2b)) =? (+2b)) (true)
+:test ((log2 (+3b)) =? (+2b)) (true)
+:test ((log2 (+4b)) =? (+3b)) (true)
+:test ((log2 (+32b)) =? (+6b)) (true)
+:test ((log2 (+48b)) =? (+6b)) (true)
+
 # returns true if the number is even (remainder mod 2 == 0)
 even? ¬‣ ∘ lsb ⧗ Binary → Boolean
 
diff --git a/std/Number/Conversion.bruijn b/std/Number/Conversion.bruijn
index 0057310..52f3c9e 100644
--- a/std/Number/Conversion.bruijn
+++ b/std/Number/Conversion.bruijn
@@ -9,14 +9,18 @@
 # converts unary numbers to ternary
 unary→ternary [0 T.inc (+0t)] ⧗ Unary → Ternary
 
-:test (unary→ternary (+0u)) ((+0t))
-:test (unary→ternary (+2u)) ((+2t))
+¹³‣ unary→ternary
+
+:test (¹³(+0u)) ((+0t))
+:test (¹³(+2u)) ((+2t))
 
 # converts ternary numbers to unary
 ternary→unary [T.apply 0 U.inc (+0u)] ⧗ Ternary → Unary
 
-:test (ternary→unary (+0t)) ((+0u))
-:test (ternary→unary (+2t)) ((+2u))
+³¹‣ ternary→unary
+
+:test (³¹(+0t)) ((+0u))
+:test (³¹(+2t)) ((+2u))
 
 # converts binary numbers to ternary
 # constructs reversed path of composed functions and applies to ternary
@@ -25,8 +29,10 @@ binary→ternary [y [[[rec]]] [0] 0 (+0t)] ⧗ Binary → Ternary
 		case-rec B.odd? 0 (2 (1 ∘ T.inc) (B.dec 0)) (2 (1 ∘ (T.mul (+2t))) (B.div² 0))
 		case-end 1
 
-:test (T.eq? (binary→ternary (+0b)) (+0t)) ([[1]])
-:test (T.eq? (binary→ternary (+42b)) (+42t)) ([[1]])
+²³‣ binary→ternary
+
+:test (T.eq? ²³(+0b) (+0t)) ([[1]])
+:test (T.eq? ²³(+42b) (+42t)) ([[1]])
 
 # converts numbers to binary
 # constructs reversed path of composed functions and applies to ternary
@@ -35,5 +41,7 @@ ternary→binary [y [[[rec]]] [0] 0 (+0b)] ⧗ Ternary → Binary
 		case-rec T.odd? 0 (2 (1 ∘ B.inc) (T.dec 0)) (2 (1 ∘ (B.mul (+2b))) (T.div² 0))
 		case-end 1
 
-:test (B.eq? (ternary→binary (+0t)) (+0b)) ([[1]])
-:test (B.eq? (ternary→binary (+42t)) (+42b)) ([[1]])
+³²‣ ternary→binary
+
+:test (B.eq? ³²(+0t) (+0b)) ([[1]])
+:test (B.eq? ³²(+42t) (+42b)) ([[1]])
diff --git a/std/Number/Ternary.bruijn b/std/Number/Ternary.bruijn
index 20a89e8..86f4593 100644
--- a/std/Number/Ternary.bruijn
+++ b/std/Number/Ternary.bruijn
@@ -1,5 +1,5 @@
 # MIT License, Copyright (c) 2022 Marvin Borner
-# ternary implementation of T.Æ. Mogensen and Douglas W. Jones (see refs in README)
+# inspiration from T.Æ. Mogensen and Douglas W. Jones (see refs in README)
 # → refer to std/Math for more advanced functions
 
 :import std/Box B
@@ -65,6 +65,9 @@ t⁰? [0 false false true] ⧗ Trit → Boolean
 :test (t⁺ ↑ (+42)) (↑⁺(+42))
 :test (t⁰ ↑ (+42)) (↑⁰(+42))
 
+# lshifts a zero trit into a balanced ternary number
+←⁰‣ [[[[[4 (0 3) 2 1 0]]]]]
+
 # infinity
 # WARNING: using this mostly results in undefined behavior! (TODO?)
 infty z [[[[[1 (4 1)]]]]] ⧗ Number
@@ -129,6 +132,20 @@ lst [0 t⁰ [t⁻] [t⁺] [t⁰]] ⧗ Number → Trit
 :test (lst (+42)) (t⁰)
 
 # extracts most significant trit from a balanced ternary number
+mst* [B.get t⁰ (0 z a⁻ a⁺ a⁰)] ⧗ Number → Trit
+	z B.empty
+	a⁻ [B.store! 0 t⁻]
+	a⁺ [B.store! 0 t⁺]
+	a⁰ [B.store! 0 t⁰]
+
+:test (mst* (-1)) (t⁻)
+:test (mst* (+0)) (t⁰)
+:test (mst* (+1)) (t⁺)
+:test (mst* (+42)) (t⁺)
+:test (mst* [[[[(0 (1 (0 3)))]]]]) (t⁰)
+
+# extracts most significant trit from a balanced ternary number
+# ignores leading 0s
 mst [B.get t⁰ (0 z a⁻ a⁺ a⁰)] ⧗ Number → Trit
 	z B.empty
 	a⁻ [B.store! 0 t⁻]
@@ -215,6 +232,9 @@ not-eq? not! ∘∘ eq? ⧗ Number → Number → Boolean
 :test ((+1) ≠? (+0)) (true)
 :test ((-42) ≠? (+42)) (true)
 
+# prefix for comparing functions
+?‣ &eq?
+
 # adds (+1) to a balanced ternary number (can introduce leading 0s)
 inc [~(0 z a⁻ a⁺ a⁰)] ⧗ Number → Number
 	z (+0) : (+1)
@@ -339,6 +359,23 @@ abs [<?0 -0 0] ⧗ Number → Number
 :test (|(-1)) ((+1))
 :test (|(+42)) ((+42))
 
+# returns max number of two
+max [[(1 ≤? 0) 0 1]] ⧗ Number → Number → Number
+
+:test (max (+5) (+2)) ((+5))
+
+# returns min number of two
+min [[(1 ≤? 0) 1 0]] ⧗ Number → Number → Number
+
+:test (min (+5) (+2)) ((+2))
+
+# clamps a number between two numbers
+clamp [[[min 1 (max 0 2)]]] ⧗ Number → Number → Number
+
+:test (clamp (+0) (+5) (+3)) ((+3))
+:test (clamp (+0) (+5) (-2)) ((+0))
+:test (clamp (+0) (+5) (+7)) ((+5))
+
 # apply a function n times to a value
 # ~> substitute church numbers
 apply z [[[rec]]] ⧗ Number → (a → a) → a → a
@@ -396,6 +433,17 @@ div² [z [[[[rec]]]] (+0) 0 0] ⧗ Number → Number
 :test (/³*(-6) =? (-2)) (true)
 :test (/³*(+5) =? (+1)) (true)
 
+# ceiled integer log3 by counting number of trits
+# also counts leading 0s
+log3* [0 (+0) inc inc inc] ⧗ Number → Number
+
+# ceiled integer log3 by counting number of trits
+log3 log3* ∘ strip ⧗ Number → Number
+
+:test (log3 (+0)) ((+0))
+:test (log3 (+5)) ((+3))
+:test (log3 (+42)) ((+5))
+
 # returns the smallest number in a range such that a predicate is true
 binary-search z [[[[rec]]]] ⧗ (Number → Boolean) → Number → Number → Number
 	rec (0 =? 1) case-end case-search
@@ -417,10 +465,29 @@ ternary-search z [[[[rec]]]] ⧗ (Number → Number) → Number → Number → N
 
 # finds quotient and remainder using binary search
 # TODO: fix for numbers <=1 (case analysis, q,r<0)
-# TODO: faster algorithm
 quot-rem [[go --(binary-search [0 ⋅ 1 >? 2] (+0) 1)]] ⧗ Number → Number → (Pair Number Number)
 	go [0 : (2 - (1 ⋅ 0))]
 
+# pads a ternary number with 0s until it's as long a another ternary number
+pad y [[[(log3* 0) <? (log3* 1) (2 1 ←⁰0) 0]]] ⧗ Number → Number → Number
+
+# forces number to be exactly n trits long (either pad/trim)
+force [[[0 <? 2 pad trim] (log3* 0)]] ⧗ Number → Number
+	pad y [[[=?1 0 (2 --1 ←⁰0)]]] (2 - 0) 1
+	trim y [[[=?1 0 (2 --1 /³0)]]] (0 - 2) 1
+
+# technique by Douglas W. Jones
+# TODO: fix
+quot-rem* [[[[z [[[[rec]]]] 1 (+0) 3]] ((max (log3 1) (log3 0)) ⋅ (+2)) 0]]
+	rec =?2 (0 : 1) ([[compare-case eq lt gt 1 (+0)]] rem' quo')
+		rem' force 5 ((mst* (force 5 0)) ↑ (+0) + ↑⁰1)
+		quo' force 5 ↑⁰0
+		eq 5 --4 1 0
+		lt [(-0 >? 2) ⋁? ((-0 =? 2) ⋀? <?1) fix (6 --5 2 1)] (force 7 (1 + 6))
+			fix 6 --5 0 --1
+		gt [(-0 <? 2) ⋁? ((-0 =? 2) ⋀? >?1) fix (6 --5 2 1)] (force 7 (1 - 6))
+			fix 6 --5 0 ++1
+
 # divs two balanced ternary numbers
 div ^‣ ∘∘ quot-rem ⧗ Number → Number
 
@@ -461,20 +528,3 @@ odd? ¬‣ ∘ even? ⧗ Number → Boolean
 :test (≠²?(+1)) (true)
 :test (≠²?(+41)) (true)
 :test (≠²?(+42)) (false)
-
-# returns max number of two
-max [[(1 ≤? 0) 0 1]] ⧗ Number → Number → Number
-
-:test (max (+5) (+2)) ((+5))
-
-# returns min number of two
-min [[(1 ≤? 0) 1 0]] ⧗ Number → Number → Number
-
-:test (min (+5) (+2)) ((+2))
-
-# clamps a number between two numbers
-clamp [[[min 1 (max 0 2)]]] ⧗ Number → Number → Number
-
-:test (clamp (+0) (+5) (+3)) ((+3))
-:test (clamp (+0) (+5) (-2)) ((+0))
-:test (clamp (+0) (+5) (+7)) ((+5))
diff --git a/std/Number/Unary.bruijn b/std/Number/Unary.bruijn
index 0c65c41..81af007 100644
--- a/std/Number/Unary.bruijn
+++ b/std/Number/Unary.bruijn
@@ -119,6 +119,9 @@ not-eq? not! ∘∘ eq? ⧗ Unary → Unary → Boolean
 :test ((+1u) ≠? (+1u)) (false)
 :test ((+42u) ≠? (+42u)) (false)
 
+# prefix for comparing functions
+?‣ &eq?
+
 # returns eq, lt, gt depending on comparison of two numbers
 compare-case [[[[[go (1 - 0) (0 - 1)]]]]] ⧗ a → b → c → Unary → Unary → d
 	go [[=?0 (=?1 6 5) 4]]