Postfix Reference Guide - Revision history

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)

Root: /* Ternary Kleene logic operations */

2026-04-17T11:05:13Z

Ternary Kleene logic operations

← Older revision		Revision as of 11:05, 17 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. ~~These~~ operators ~~use~~ short-circuit Kleene logic with KAND/KOR.		These operators assume balanced ternary (64-bit/40-trit) integer arguments. Note that these operators do not short-circuit Kleene logic with KAND/KOR.
	{\|		{\|
	! class="pfrow" \| KNOT		! class="pfrow" \| KNOT

Root: /* Ternary Kleene logic operations */

2026-04-17T10:58:04Z

Ternary Kleene logic operations

← Older revision		Revision as of 10:58, 17 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.		These operators assume balanced ternary (64-bit/40-trit) integer arguments. These operators use short-circuit Kleene logic with KAND/KOR.
	{\|		{\|
	! class="pfrow" \| KNOT		! class="pfrow" \| KNOT

Root: /* Ternary Kleene logic operations */

2026-04-17T10:55:38Z

Ternary Kleene logic operations

← Older revision		Revision as of 10:55, 17 April 2026
Line 731:		Line 731:
	! class="pfrow" \| $ a		! class="pfrow" \| $ a
	! class="pfrow" \| $ ~a		! class="pfrow" \| $ ~a
	! class="pfdesc" \| ~~Logical negation~~		! class="pfdesc" \| NOT operation
	\|-		\|-
	! class="pfrow" \| KAND		! class="pfrow" \| KAND

Root: /* Bitwise Operations */

2026-04-17T10:55:18Z

Bitwise Operations

@@ Line 722: / Line 722: @@
 ! class="pfrow" | $ a&oplus;b
 ! class="pfdesc" | Bitwise XOR (exclusive OR) operation
 |}

Root: /* Ternary posit (128-bit/80-trit) operations */

2026-04-17T10:39:22Z

Ternary posit (128-bit/80-trit) operations

@@ Line 492: / Line 492: @@
 |-
 ! class="pfrow" | PDIV
 ! class="pfrow" | $ a b
 ! class="pfrow" | $ a/b