crypto/math cleanups

contrib/crypto/blum-blum-shub.factor

@@ -1,6 +1,7 @@
 USING: kernel math sequences namespaces crypto math-contrib ;
 IN: crypto-internals
 
+! TODO: take (log log M) bits instead of 1 bit
 ! Blum Blum Shub, M = pq
 TUPLE: bbs x n ;
 
@@ -27,8 +28,9 @@ SYMBOL: temp-bbs
 
 IN: crypto
 : random-bbs-bits* ( numbits bbs -- n ) (bbs-bits) ;
-: random-bbs-bits ( numbits -- n ) blum-blum-shub get (bbs-bits) ;
+: random-bits ( numbits -- n ) blum-blum-shub get (bbs-bits) ;
+: random-bytes ( numbits -- n ) 8 * random-bits ;
 : random-int ( n -- n )
-    #! Cryptographically secure random number using Blum-Blum-Shub 256
-    [ log2 1+ random-bbs-bits ] keep mod ;
+    ! #! Cryptographically secure random number using Blum-Blum-Shub 256
+    [ log2 1+ random-bits ] keep dupd >= [ -1 shift ] when ;
 

contrib/crypto/load.factor

@@ -1,6 +1,7 @@
 REQUIRES: math ;
 
 PROVIDE: crypto {
+
     "common.factor"
     "timing.factor"
     "base64.factor"

contrib/crypto/random.factor

@@ -4,9 +4,9 @@ IN: crypto
 : make-bits ( quot numbits -- n | quot: -- 0/1 )
     0 -rot [ drop dup call rot 1 shift bitor swap ] each drop ;
 
+DEFER: random-bits
 : add-bit ( bit integer -- integer ) 1 shift bitor ;
 : append-bits ( inta intb nbits -- int ) swapd shift bitor ;
-: random-bits ( n -- int ) random-int 2 swap ^ random-int ;
 : large-random-bits ( n -- int )
     #! random number with high bit and low bit enabled (odd)
     2 swap ^ [ random-int ] keep -1 shift 1 bitor bitor ;

contrib/math/load.factor

@@ -7,4 +7,6 @@ PROVIDE: math {
     "matrices.factor"
     "statistics.factor"
     "numerical-integration.factor"
+} {
+    "test.factor"
 } ;

contrib/math/numerical-integration.factor

@@ -1,5 +1,4 @@
 IN: math-contrib
-
 USING: kernel sequences errors namespaces math vectors errors prettyprint io inspector ;
 
 : setup-range ( from to -- frange )

contrib/math/statistics.factor

@@ -27,7 +27,7 @@ USING: kernel math sequences ;
     #! max - min
     minmax swap - ;
 
-: var ( seq -- )
+: var ( seq -- x )
     #! variance, normalize by N-1
     dup length 1- dup 0 = [
         0 2nip
@@ -35,6 +35,6 @@ USING: kernel math sequences ;
         swap [ mean ] keep 0 [ pick - sq + ] reduce nip swap /
     ] if ;
 
-: std
+: std ( seq -- x )
     #! standard deviation, sqrt of variance
     var sqrt ;

contrib/math/test.factor

@@ -229,5 +229,5 @@ unit-test
 [ 0 ] [ { 1 } var ] unit-test
 [ 0 ] [ { 1 } std ] unit-test
 
-[ 3 ] [ 5 7 mod-inv ] unit-test
-[ 78572682077 ] [ 234829342 342389423843 mod-inv ] unit-test
+[ -2 ] [ 5 7 mod-inv ] unit-test
+[ -53889431 ] [ 234829342 342389423843 mod-inv ] unit-test

contrib/math/utils.factor

@@ -58,14 +58,9 @@ USING: errors kernel sequences math sequences-internals namespaces arrays ;
     #! find the absolute values of the min and max of a seq in one pass
     minmax 2dup [ abs ] 2apply > [ swap ] when ;
 
-SYMBOL: almost=-precision .000001 almost=-precision set
+SYMBOL: almost=-precision .0001 almost=-precision set-global
 : almost= ( a b -- bool )
-    2dup - abs almost=-precision get < [
-            2drop t
-        ] [
-            2array absminmax dup almost=-precision get * >r - abs r>
-            dup 0 < [ >= ] [ <= ] if
-    ] if ;
+    - abs almost=-precision get < ;
 
 TUPLE: frange from step length ;