Postfix Reference Guide - Revision history

Root: /* Comparison operators for real numbers */

2026-05-18T13:58:46Z

Comparison operators for real numbers

← Older revision		Revision as of 13:58, 18 May 2026
Line 698:		Line 698:
	\|}		\|}

	=== Comparison operators for real numbers ===		=== Comparison operators for double precision binary floating point real numbers ===

	The DCMP operator compares two double precision binary floating point numbers (64 bits). The result is a 32-bit binary integer value: less than 0, if the first operand is lower than the second; 0, if they are equal; greater than 0, otherwise. <!--P3CMP (for ternary posits) and T3CMP (for ternary takums) work in a similar way. Note that posits and takums are natively compared using Kleene logic (the operators below translate that into Boolean logic).-->		The DCMP operator compares two double precision binary floating point numbers (64 bits). The result is a 32-bit binary integer value: less than 0, if the first operand is lower than the second; 0, if they are equal; greater than 0, otherwise. <!--P3CMP (for ternary posits) and T3CMP (for ternary takums) work in a similar way. Note that posits and takums are natively compared using Kleene logic (the operators below translate that into Boolean logic).-->

Root: /* Simple Stack Operations */

2026-05-18T13:57:13Z

Simple Stack Operations

← Older revision		Revision as of 13:57, 18 May 2026
Line 336:		Line 336:
	! class="pfrow" \| $ value		! class="pfrow" \| $ value
	! class="pfdesc" \| Pushes an 8-byte float '''value''' (64 bits, double precision)		! class="pfdesc" \| Pushes an 8-byte float '''value''' (64 bits, double precision)
			\|-
			! class="pfrow" \| POSIT3 value
			! class="pfrow" \| $
			! class="pfrow" \| $ value
			! class="pfdesc" \| Pushes a ternary real '''value''' (128 bits, 80 trits)
	\|-		\|-
	! class="pfrow" \| TAKUM3 value		! class="pfrow" \| TAKUM3 value

Root: /* Store operations */

2026-05-18T13:56:47Z

Store operations

← Older revision		Revision as of 13:56, 18 May 2026
Line 287:		Line 287:
	! class="pfrow" \| $		! class="pfrow" \| $
	! class="pfdesc" \| Stores 8 bytes (double)		! class="pfdesc" \| Stores 8 bytes (double)
			\|-
			! class="pfrow" \| STPOSIT3
			! class="pfrow" \| $ val addr
			! class="pfrow" \| $
			! class="pfdesc" \| Stores 16 bytes (80-trit ternary real)
	\|-		\|-
	! class="pfrow" \| STTAKUM3		! class="pfrow" \| STTAKUM3

Root: /* Load operations */

2026-05-18T13:56:26Z

Load operations

← Older revision		Revision as of 13:56, 18 May 2026
Line 241:		Line 241:
	! class="pfrow" \| $ [addr]		! class="pfrow" \| $ [addr]
	! class="pfdesc" \| Loads 8 bytes (double)		! class="pfdesc" \| Loads 8 bytes (double)
			\|-
			! class="pfrow" \| LDPOSIT3
			! class="pfrow" \| $ addr
			! class="pfrow" \| $ [addr]
			! class="pfdesc" \| Loads 16 bytes (80-trit ternary real)
	\|-		\|-
	! class="pfrow" \| LDTAKUM3		! class="pfrow" \| LDTAKUM3

Root: /* Values (declaration in segments) */

2026-05-18T13:55:55Z

Values (declaration in segments)

← Older revision		Revision as of 13:55, 18 May 2026
Line 111:		Line 111:
	! class="pfrow" \|		! class="pfrow" \|
	! class="pfdesc" \| Declares a static double precision (64-bit) floating point '''value'''		! class="pfdesc" \| Declares a static double precision (64-bit) floating point '''value'''
			\|-
			! class="pfrow" \| SPOSIT3 value
			! class="pfrow" \|
			! class="pfrow" \|
			! class="pfdesc" \| Declares a static ternary posit real '''value''' (128 bits, 80 trits)
	\|-		\|-
	! class="pfrow" \| STAKUM3 value		! class="pfrow" \| STAKUM3 value

Root: /* Comparison operators for real numbers */

2026-04-18T18:48:54Z

Comparison operators for real numbers

← Older revision		Revision as of 18:48, 18 April 2026
Line 680:		Line 680:
	=== Comparison operators for real numbers ===		=== Comparison operators for real numbers ===

	The DCMP operator compares two double precision floating point numbers. The result is an integer value: less than 0, if the first operand is ~~less~~ than the second; 0, if they are equal; greater than 0, otherwise. <!--P3CMP (for ternary posits) and T3CMP (for ternary takums) work in a similar way. Note that posits and takums are natively compared using Kleene logic (the operators below translate that into Boolean logic).-->		The DCMP operator compares two double precision binary floating point numbers (64 bits). The result is a 32-bit binary integer value: less than 0, if the first operand is lower than the second; 0, if they are equal; greater than 0, otherwise. <!--P3CMP (for ternary posits) and T3CMP (for ternary takums) work in a similar way. Note that posits and takums are natively compared using Kleene logic (the operators below translate that into Boolean logic).-->

	{\|		{\|
Line 691:		Line 691:
	! class="pfrow" \| $ a b		! class="pfrow" \| $ a b
	! class="pfrow" \| $ i		! class="pfrow" \| $ i
	! class="pfdesc" \| "compare" -- i<0, a<b; i&equiv;0, a&equiv;b; i>0, a>b ('''a''' and '''b''' are 128-bit/80-trit posits; '''i''' is a 32-bit integer)		! class="pfdesc" \| "compare" -- i<0, a<b; i&equiv;0, a&equiv;b; i>0, a>b ('''a''' and '''b''' are 128-bit/80-trit posits; '''i''' is a 32-bit binary integer)
	\|-		\|-
	! class="pfrow" \| T3CMP		! class="pfrow" \| T3CMP
	! class="pfrow" \| $ a b		! class="pfrow" \| $ a b
	! class="pfrow" \| $ i		! class="pfrow" \| $ i
	! class="pfdesc" \| "compare" -- i<0, a<b; i&equiv;0, a&equiv;b; i>0, a>b ('''a''' and '''b''' are 128-bit/80-trit takums; '''i''' is a 32-bit integer)-->		! class="pfdesc" \| "compare" -- i<0, a<b; i&equiv;0, a&equiv;b; i>0, a>b ('''a''' and '''b''' are 128-bit/80-trit takums; '''i''' is a 32-bit binary integer)-->
	\|}		\|}

Root: /* Bitwise Operations */

2026-04-18T18:46:25Z

Bitwise Operations

← Older revision		Revision as of 18:46, 18 April 2026
Line 701:		Line 701:
	== Bitwise Operations ==		== Bitwise Operations ==

	These operators ~~assume~~ 32-bit ~~arguments~~.		These operators take and 32-bit binary integer operands. The result is also a 32-bit binary integer.
	{\|		{\|
	! class="pfrow" \| NOT		! class="pfrow" \| NOT

Root: /* Ternary Kleene logic operations */

2026-04-18T18:42:24Z

Ternary Kleene logic operations

← Older revision		Revision as of 18:42, 18 April 2026
Line 726:		Line 726:
	== Ternary Kleene logic operations ==		== Ternary Kleene logic operations ==

	These operators ~~assume~~ balanced ternary (64-bit/40-trit) integer ~~arguments~~. Note that these operators do not short-circuit Kleene logic with KAND/KOR.		These operators take balanced ternary (64-bit/40-trit) integer operands. Note that these operators do not short-circuit Kleene logic with KAND/KOR. The result is also a balanced ternary (64-bit/40-trit) integer.
	{\|		{\|
	! class="pfrow" \| KNOT		! class="pfrow" \| KNOT

Root: /* Integer comparison instructions */

2026-04-18T18:40:57Z

Integer comparison instructions

← Older revision		Revision as of 18:40, 18 April 2026
Line 616:		Line 616:
	== Comparison Operations ==		== Comparison Operations ==

	=== ~~Integer~~ comparison instructions ===		=== Binary integer comparison instructions ===

	The comparison instructions are binary operations that leave at the top of the stack 0 (zero) or 1 (one), depending on the result of the comparison: respectively, '''false''' or '''true'''. The value may be directly used to perform conditional jumps (e.g., JZ, JNZ), that use the value of the top of the stack instead of relying on special processor registers ("flags").		The comparison instructions are binary operations (each operand is a 32-bit binary integer) that leave at the top of the stack 0 (zero) or 1 (one), depending on the result of the comparison: respectively, '''false''' or '''true''' (32-bit binary integer). The value may be directly used to perform conditional jumps (e.g., JZ, JNZ), that use the value of the top of the stack instead of relying on special processor registers ("flags").

	{\|		{\|
Line 654:		Line 654:
	\|}		\|}

	The following consider unsigned operands:		The following consider unsigned 32-bit binary integer operands (the result is also a 32-bit binary integer):

	{\|		{\|

Root: /* Type Conversion Operations */

2026-04-18T18:36:40Z

Type Conversion Operations

← Older revision		Revision as of 18:36, 18 April 2026
Line 553:		Line 553:
	\|}		\|}

	'''SRC''' and '''DST''' in the instuction above are as follows (not all combinations are available -- see table ~~below~~):		'''SRC''' and '''DST''' in the instuction above are as follows (not all combinations are available -- see the following table):
	* '''B''': Balanced ternary integer (64-bit/40-trit)		* '''B''': Balanced ternary integer (64-bit/40-trit)
	* '''D''': Double precision floating point (64-bit)		* '''D''': Double precision floating point (64-bit)

← Older revision		Revision as of 13:57, 18 May 2026
Line 336:		Line 336:
	! class="pfrow" \| $ value		! class="pfrow" \| $ value
	! class="pfdesc" \| Pushes an 8-byte float '''value''' (64 bits, double precision)		! class="pfdesc" \| Pushes an 8-byte float '''value''' (64 bits, double precision)
			\|-
			! class="pfrow" \| POSIT3 value
			! class="pfrow" \| $
			! class="pfrow" \| $ value
			! class="pfdesc" \| Pushes a ternary real '''value''' (128 bits, 80 trits)
	\|-		\|-
	! class="pfrow" \| TAKUM3 value		! class="pfrow" \| TAKUM3 value

← Older revision		Revision as of 13:56, 18 May 2026
Line 287:		Line 287:
	! class="pfrow" \| $		! class="pfrow" \| $
	! class="pfdesc" \| Stores 8 bytes (double)		! class="pfdesc" \| Stores 8 bytes (double)
			\|-
			! class="pfrow" \| STPOSIT3
			! class="pfrow" \| $ val addr
			! class="pfrow" \| $
			! class="pfdesc" \| Stores 16 bytes (80-trit ternary real)
	\|-		\|-
	! class="pfrow" \| STTAKUM3		! class="pfrow" \| STTAKUM3

← Older revision		Revision as of 13:56, 18 May 2026
Line 241:		Line 241:
	! class="pfrow" \| $ [addr]		! class="pfrow" \| $ [addr]
	! class="pfdesc" \| Loads 8 bytes (double)		! class="pfdesc" \| Loads 8 bytes (double)
			\|-
			! class="pfrow" \| LDPOSIT3
			! class="pfrow" \| $ addr
			! class="pfrow" \| $ [addr]
			! class="pfdesc" \| Loads 16 bytes (80-trit ternary real)
	\|-		\|-
	! class="pfrow" \| LDTAKUM3		! class="pfrow" \| LDTAKUM3

← Older revision		Revision as of 13:55, 18 May 2026
Line 111:		Line 111:
	! class="pfrow" \|		! class="pfrow" \|
	! class="pfdesc" \| Declares a static double precision (64-bit) floating point '''value'''		! class="pfdesc" \| Declares a static double precision (64-bit) floating point '''value'''
			\|-
			! class="pfrow" \| SPOSIT3 value
			! class="pfrow" \|
			! class="pfrow" \|
			! class="pfdesc" \| Declares a static ternary posit real '''value''' (128 bits, 80 trits)
	\|-		\|-
	! class="pfrow" \| STAKUM3 value		! class="pfrow" \| STAKUM3 value

← Older revision		Revision as of 18:48, 18 April 2026
Line 680:		Line 680:
	=== Comparison operators for real numbers ===		=== Comparison operators for real numbers ===

	The DCMP operator compares two double precision floating point numbers. The result is an integer value: less than 0, if the first operand is ~~less~~ than the second; 0, if they are equal; greater than 0, otherwise. <!--P3CMP (for ternary posits) and T3CMP (for ternary takums) work in a similar way. Note that posits and takums are natively compared using Kleene logic (the operators below translate that into Boolean logic).-->		The DCMP operator compares two double precision binary floating point numbers (64 bits). The result is a 32-bit binary integer value: less than 0, if the first operand is lower than the second; 0, if they are equal; greater than 0, otherwise. <!--P3CMP (for ternary posits) and T3CMP (for ternary takums) work in a similar way. Note that posits and takums are natively compared using Kleene logic (the operators below translate that into Boolean logic).-->

	{\|		{\|
Line 691:		Line 691:
	! class="pfrow" \| $ a b		! class="pfrow" \| $ a b
	! class="pfrow" \| $ i		! class="pfrow" \| $ i
	! class="pfdesc" \| "compare" -- i<0, a<b; i&equiv;0, a&equiv;b; i>0, a>b ('''a''' and '''b''' are 128-bit/80-trit posits; '''i''' is a 32-bit integer)		! class="pfdesc" \| "compare" -- i<0, a<b; i&equiv;0, a&equiv;b; i>0, a>b ('''a''' and '''b''' are 128-bit/80-trit posits; '''i''' is a 32-bit binary integer)
	\|-		\|-
	! class="pfrow" \| T3CMP		! class="pfrow" \| T3CMP
	! class="pfrow" \| $ a b		! class="pfrow" \| $ a b
	! class="pfrow" \| $ i		! class="pfrow" \| $ i
	! class="pfdesc" \| "compare" -- i<0, a<b; i&equiv;0, a&equiv;b; i>0, a>b ('''a''' and '''b''' are 128-bit/80-trit takums; '''i''' is a 32-bit integer)-->		! class="pfdesc" \| "compare" -- i<0, a<b; i&equiv;0, a&equiv;b; i>0, a>b ('''a''' and '''b''' are 128-bit/80-trit takums; '''i''' is a 32-bit binary integer)-->
	\|}		\|}