pfe-double-ext
Prev? | pfe Forth Wordset List | ?Next

## Name

pfe-double-ext ? Double number + extensions

## Synopsis

`2LITERAL ( x1 x2 -- ) ?=>? (` | `)`; | ?

`"[ANS] FORTH"`;
?

`D+ ( d1.ud1 d2.ud2 -- d3.ud3 ) ?=>? (` | `)`; | ?

`"[ANS] FORTH"`;
?

`D- ?=>? (` | `)`; | ?

`"[ANS] FORTH"`;
?

`D. ( d1.d1 -- ) ?=>? (` | `)`; | ?

`"[ANS] FORTH"`;
?

`D.R ( d1.d1 n -- ) ?=>? (` | `)`; | ?

`"[ANS] FORTH"`;
?

`D0< ( d1.d1 -- flag ) ?=>? (` | `)`; | ?

`"[ANS] FORTH"`;
?

`D0= ( d1.d1 -- flag ) ?=>? (` | `)`; | ?

`"[ANS] FORTH"`;
?

`D2* ( d1.d1 -- d1.d1' ) ?=>? (` | `)`; | ?

`"[ANS] FORTH"`;
?

`D2/ ( d1.d1 -- d1.d1' ) ?=>? (` | `)`; | ?

`"[ANS] FORTH"`;
?

`D< ( d1.d1 d2.d2 -- flag ) ?=>? (` | `)`; | ?

`"[ANS] FORTH"`;
?

`D= ( d1.d1 d2.d2 -- flag ) ?=>? (` | `)`; | ?

`"[ANS] FORTH"`;
?

`D>S ( d.d -- n ) ?=>? (` | `)`; | ?

`"[ANS] FORTH"`;
?

`DABS ( d1.d1 -- d1.d1' ) ?=>? (` | `)`; | ?

`"[ANS] FORTH"`;
?

`DMAX ( d1.d1 d2.d2 -- d1.d1|d2.d2 ) ?=>? (` | `)`; | ?

`"[ANS] FORTH"`;
?

`DMIN ( d1.d1 d2.d2 -- d1.d1|d2.d2 ) ?=>? (` | `)`; | ?

`"[ANS] FORTH"`;
?

`DNEGATE ( d1.d1 -- d1.d1' ) ?=>? (` | `)`; | ?

`"[ANS] FORTH"`;
?

`M*/ ( d1.d1 n1 +n2 -- d2.d2 ) ?=>? (` | `)`; | ?

`"[ANS] FORTH"`;
?

`M+ ( d1.d1 n1 -- d2.d2 ) ?=>? (` | `)`; | ?

`"[ANS] FORTH"`;
?

## Description

2LITERAL ( x1 x2 -- ) immediate => "[ANS] FORTH"

compile a double-cell number to the current definition. When run, the doubele-cell is left on the stack for execution.

        ( -- x1 x2 )

(in most configurations this word is statesmart and it will do nothing in interpret-mode. See `2LITERAL,` for a non-immediate variant)

D+ ( d1.ud1 d2.ud2 -- d3.ud3 ) => "[ANS] FORTH"

the double-cell sum operation ( `+` )

D- - no description, sorry

D. ( d1.d1 -- ) => "[ANS] FORTH"

freefield output for a double-cell number ( => . )

D.R ( d1.d1 n -- ) => "[ANS] FORTH"

aligned output for a double-cell number ( => .R )

D0< ( d1.d1 -- flag ) => "[ANS] FORTH"

the double-cell less-than-zero operation ( `0<` )

D0= ( d1.d1 -- flag ) => "[ANS] FORTH"

the double-cell equal-to-zero operation ( `0=` )

D2* ( d1.d1 -- d1.d1' ) => "[ANS] FORTH"

the double-cell arithmetic shiftleft-by-1 operation ( `2*` )

D2/ ( d1.d1 -- d1.d1' ) => "[ANS] FORTH"

the double-cell arithmetic shiftright-by-1 operation ( `2/` )

D< ( d1.d1 d2.d2 -- flag ) => "[ANS] FORTH"

the double-cell is-less operation ( `<` )

D= ( d1.d1 d2.d2 -- flag ) => "[ANS] FORTH"

the double-cell is-equal operation ( `=` )

D>S ( d.d -- n ) => "[ANS] FORTH"

result is the numeric equivalent of d. If the double number was greater than what could fit into a single cell number, the modulo cellsize will be left since the higher-significant bits are just `DROP`ed

DABS ( d1.d1 -- d1.d1' ) => "[ANS] FORTH"

the double-cell abs operation ( `ABS` )

DMAX ( d1.d1 d2.d2 -- d1.d1|d2.d2 ) => "[ANS] FORTH"

the double-cell max operation ( `MAX` )

DMIN ( d1.d1 d2.d2 -- d1.d1|d2.d2 ) => "[ANS] FORTH"

the double-cell max operation ( `MIN` )

DNEGATE ( d1.d1 -- d1.d1' ) => "[ANS] FORTH"

the double-cell arithmetic negate operation ( `NEGATE` )

M*/ ( d1.d1 n1 +n2 -- d2.d2 ) => "[ANS] FORTH"

the double-cell multiply-divide operation using a triple-cell intermediate result for `*` ( `*\/` )

M+ ( d1.d1 n1 -- d2.d2 ) => "[ANS] FORTH"

the double-cell mixed-operand sum operation ( `+` / `D+` )

Prev? | Up | ?Next
pfe-dlfcn-ext? | Home | ?pfe-double-misc-ext