use radix literals

[factor.git] / core / math / math.factor

diff --git a/core/math/math.factor b/core/math/math.factor
old mode 100755 (executable)
new mode 100644 (file)
index 1213e13..81e488c
--- a/core/math/math.factor
+++ b/core/math/math.factor
@@ -1,6 +1,6 @@
-! Copyright (C) 2003, 2009 Slava Pestov.
+! Copyright (C) 2003, 2009 Slava Pestov, Joe Groff.
 ! See http://factorcode.org/license.txt for BSD license.
-USING: kernel math.private ;
+USING: kernel ;
 IN: math
 
 GENERIC: >fixnum ( x -- n ) foldable
@@ -23,6 +23,14 @@ MATH: <= ( x y -- ? ) foldable
 MATH: >  ( x y -- ? ) foldable
 MATH: >= ( x y -- ? ) foldable
 
+MATH: unordered? ( x y -- ? ) foldable
+MATH: u<  ( x y -- ? ) foldable
+MATH: u<= ( x y -- ? ) foldable
+MATH: u>  ( x y -- ? ) foldable
+MATH: u>= ( x y -- ? ) foldable
+
+M: object unordered? 2drop f ;
+
 MATH: +   ( x y -- z ) foldable
 MATH: -   ( x y -- z ) foldable
 MATH: *   ( x y -- z ) foldable
@@ -51,11 +59,7 @@ PRIVATE>
 ERROR: log2-expects-positive x ;
 
 : log2 ( x -- n )
-    dup 0 <= [
-        log2-expects-positive
-    ] [
-        (log2)
-    ] if ; inline
+    dup 0 <= [ log2-expects-positive ] [ (log2) ] if ; inline
 
 : zero? ( x -- ? ) 0 number= ; inline
 : 2/ ( x -- y ) -1 shift ; inline
@@ -66,15 +70,15 @@ ERROR: log2-expects-positive x ;
 : ?1+ ( x -- y ) [ 1 + ] [ 0 ] if* ; inline
 : rem ( x y -- z ) abs [ mod ] [ + ] [ mod ] tri ; foldable
 : 2^ ( n -- 2^n ) 1 swap shift ; inline
-: even? ( n -- ? ) 1 bitand zero? ;
-: odd? ( n -- ? ) 1 bitand 1 number= ;
+: even? ( n -- ? ) 1 bitand zero? ; inline
+: odd? ( n -- ? ) 1 bitand 1 number= ; inline
 
-: if-zero ( n quot1 quot2 -- )
+: if-zero ( ..a n quot1: ( ..a -- ..b ) quot2: ( ..a n -- ..b ) -- ..b )
     [ dup zero? ] [ [ drop ] prepose ] [ ] tri* if ; inline
 
-: when-zero ( n quot -- ) [ ] if-zero ; inline
+: when-zero ( ..a n quot: ( ..a -- ..b ) -- ..b ) [ ] if-zero ; inline
 
-: unless-zero ( n quot -- ) [ ] swap if-zero ; inline
+: unless-zero ( ..a n quot: ( ..a -- ..b ) -- ..b ) [ ] swap if-zero ; inline
 
 UNION: integer fixnum bignum ;
 
@@ -96,56 +100,19 @@ GENERIC: fp-qnan? ( x -- ? )
 GENERIC: fp-snan? ( x -- ? )
 GENERIC: fp-infinity? ( x -- ? )
 GENERIC: fp-nan-payload ( x -- bits )
+GENERIC: fp-sign ( x -- ? )
 
-M: object fp-special?
-    drop f ; inline
-M: object fp-nan?
-    drop f ; inline
-M: object fp-qnan?
-    drop f ; inline
-M: object fp-snan?
-    drop f ; inline
-M: object fp-infinity?
-    drop f ; inline
-M: object fp-nan-payload
-    drop f ; inline
-
-M: float fp-special?
-    double>bits -52 shift HEX: 7ff [ bitand ] keep = ; inline
-
-M: float fp-nan-payload
-    double>bits HEX: fffffffffffff bitand ; inline
-
-M: float fp-nan?
-    dup fp-special? [ fp-nan-payload zero? not ] [ drop f ] if ; inline
-
-M: float fp-qnan?
-    dup fp-nan? [ fp-nan-payload HEX: 8000000000000 bitand zero? not ] [ drop f ] if ; inline
-
-M: float fp-snan?
-    dup fp-nan? [ fp-nan-payload HEX: 8000000000000 bitand zero? ] [ drop f ] if ; inline
-
-M: float fp-infinity?
-    dup fp-special? [ fp-nan-payload zero? ] [ drop f ] if ; inline
+M: object fp-special? drop f ; inline
+M: object fp-nan? drop f ; inline
+M: object fp-qnan? drop f ; inline
+M: object fp-snan? drop f ; inline
+M: object fp-infinity? drop f ; inline
 
 : <fp-nan> ( payload -- nan )
-    HEX: 7ff0000000000000 bitor bits>double ; inline
+    0x7ff0000000000000 bitor bits>double ; inline
 
-: next-float ( m -- n )
-    double>bits
-    dup -0.0 double>bits > [ 1 - bits>double ] [ ! negative non-zero
-        dup -0.0 double>bits = [ drop 0.0 ] [ ! negative zero
-            1 + bits>double ! positive
-        ] if
-    ] if ; inline
-
-: prev-float ( m -- n )
-    double>bits
-    dup -0.0 double>bits >= [ 1 + bits>double ] [ ! negative
-        dup 0.0 double>bits = [ drop -0.0 ] [ ! positive zero
-            1 - bits>double ! positive non-zero
-        ] if
-    ] if ; inline
+GENERIC: next-float ( m -- n )
+GENERIC: prev-float ( m -- n )
 
 : next-power-of-2 ( m -- n )
     dup 2 <= [ drop 2 ] [ 1 - log2 1 + 2^ ] if ; inline
@@ -170,35 +137,37 @@ M: float fp-infinity?
 
 PRIVATE>
 
-: (each-integer) ( i n quot: ( i -- ) -- )
+: (each-integer) ( ... i n quot: ( ... i -- ... ) -- ... )
     [ iterate-step iterate-next (each-integer) ]
     [ 3drop ] if-iterate? ; inline recursive
 
-: (find-integer) ( i n quot: ( i -- ? ) -- i )
+: (find-integer) ( ... i n quot: ( ... i -- ... ? ) -- ... i )
     [
-        iterate-step roll
-        [ 2drop ] [ iterate-next (find-integer) ] if
+        iterate-step
+        [ [ ] ] 2dip
+        [ iterate-next (find-integer) ] 2curry bi-curry if
     ] [ 3drop f ] if-iterate? ; inline recursive
 
-: (all-integers?) ( i n quot: ( i -- ? ) -- ? )
+: (all-integers?) ( ... i n quot: ( ... i -- ... ? ) -- ... ? )
     [
-        iterate-step roll
-        [ iterate-next (all-integers?) ] [ 3drop f ] if
+        iterate-step
+        [ iterate-next (all-integers?) ] 3curry
+        [ f ] if
     ] [ 3drop t ] if-iterate? ; inline recursive
 
-: each-integer ( n quot -- )
+: each-integer ( ... n quot: ( ... i -- ... ) -- ... )
     iterate-prep (each-integer) ; inline
 
-: times ( n quot -- )
+: times ( ... n quot: ( ... -- ... ) -- ... )
     [ drop ] prepose each-integer ; inline
 
-: find-integer ( n quot -- i )
+: find-integer ( ... n quot: ( ... i -- ... ? ) -- ... i )
     iterate-prep (find-integer) ; inline
 
-: all-integers? ( n quot -- ? )
+: all-integers? ( ... n quot: ( ... i -- ... ? ) -- ... ? )
     iterate-prep (all-integers?) ; inline
 
-: find-last-integer ( n quot: ( i -- ? ) -- i )
+: find-last-integer ( ... n quot: ( ... i -- ... ? ) -- ... i )
     over 0 < [
         2drop f
     ] [