Node:Numeric comparison, Next:, Previous:Bitwise operations, Up:Arithmetic


Numeric comparison

Note that the words that compare for equality (= <> 0= 0<> d= d<> d0= d0<>) work for for both signed and unsigned numbers. 

<       n1 n2 -- f        core       ``less-than''


<=       n1 n2 -- f        gforth       ``less-or-equal''


<>       n1 n2 -- f        core-ext       ``not-equals''


=       n1 n2 -- f        core       ``equals''


>       n1 n2 -- f        core       ``greater-than''


>=       n1 n2 -- f        gforth       ``greater-or-equal''


0<       n -- f        core       ``zero-less-than''


0<=       n -- f        gforth       ``zero-less-or-equal''


0<>       n -- f        core-ext       ``zero-not-equals''


0=       n -- f        core       ``zero-equals''


0>       n -- f        core-ext       ``zero-greater-than''


0>=       n -- f        gforth       ``zero-greater-or-equal''


u<       u1 u2 -- f        core       ``u-less-than''


u<=       u1 u2 -- f        gforth       ``u-less-or-equal''


u>       u1 u2 -- f        core-ext       ``u-greater-than''


u>=       u1 u2 -- f        gforth       ``u-greater-or-equal''


within       u1 u2 u3 -- f        core-ext       ``within''
u2=<u1<u3 or: u3=<u2 and u1 is not in [u3,u2). This works for unsigned and signed numbers (but not a mixture). Another way to think about this word is to consider the numbers as a circle (wrapping around from max-u to 0 for unsigned, and from max-n to min-n for signed numbers); now consider the range from u2 towards increasing numbers up to and excluding u3 (giving an empty range if u2=u3); if u1 is in this range, within returns true. 
d<       d1 d2 -- f        double       ``d-less-than''


d<=       d1 d2 -- f        gforth       ``d-less-or-equal''


d<>       d1 d2 -- f        gforth       ``d-not-equals''


d=       d1 d2 -- f        double       ``d-equals''


d>       d1 d2 -- f        gforth       ``d-greater-than''


d>=       d1 d2 -- f        gforth       ``d-greater-or-equal''


d0<       d -- f        double       ``d-zero-less-than''


d0<=       d -- f        gforth       ``d-zero-less-or-equal''


d0<>       d -- f        gforth       ``d-zero-not-equals''


d0=       d -- f        double       ``d-zero-equals''


d0>       d -- f        gforth       ``d-zero-greater-than''


d0>=       d -- f        gforth       ``d-zero-greater-or-equal''


du<       ud1 ud2 -- f        double-ext       ``d-u-less-than''


du<=       ud1 ud2 -- f        gforth       ``d-u-less-or-equal''


du>       ud1 ud2 -- f        gforth       ``d-u-greater-than''


du>=       ud1 ud2 -- f        gforth       ``d-u-greater-or-equal''