LT4335 float instructions

LT4335 float instructions.
Version of 8 July 2011.
Home.

Fundamental is that a float consists of two full-fledged integers, one for the mantissa, and one for the exponent. A float is null if the mantissa or exponent or both are null. In this regard, the LT4335 differs from most other CPUs.
Register notation like "#0 exp, #1 man" or "#0.1" indicates a float whose exponent is in #0 and mantissa is in #1. To make the float operations work, if an exponent is in #n, the corresponding mantissa must be in #(n+1). A convenient consequence is that an integer in #0 may be converted to a float in #0.1 simply by pushing an integer zero.
There is no need to inform the CPU that two registers combine to make a float, as the CPU does not enforce data types in registers or genspace. At all times may integer or string operations be performed on the exponent's and mantissa's respective contents. Example: to multiply a float by 2, simply perform the integer operation of adding 1 to its exponent, leaving the mantissa untouched. The programmer is cautioned, however, that tinkering with the mantissa and exponent separately is error prone.
To normalize a float is to do this:

If the mantissa is null:

If the exponent is null, do nothing.
If the exponent has a value, change it to null.

If the mantissa has a value:

If the exponent is null, change the mantissa to null.
If the exponent has a value:

If the mantissa is zero, change the exponent to zero.
If the mantissa is nonzero, perform this step…

Divide the mantissa by two, and add 1 to the exponent
…until either the mantissa is an odd number, or the exponent attains the maximum integer value.

To trim a float is to perform integer trimming on each of its mantissa and exponent. When a float is an input to an instruction, there is no requirement that it be normalized or trimmed. If a programmer does desire to both normalize a float and trim its component integers, the normalization should normally be done first.
The first three tables contain instructions that will get or put the mantissa and exponent of a float. The address within genspace for a float is specifically the address of its mantissa, its exponent immediately following.
Because a float is built of two integers, the programmer could use two integer instructions to get or put a float. If this is preferred, the mantissa and exponent need not adjoin in genspace, but can be widely separated. However, with two separate instructions the operation will no longer be atomic and hence will risk fouling an environment where data is shared among tasks. If this is a concern, a branch uninterruptable operation can be invoked.
With the size-embedded versions of the get, put, and get-and-put instructions a tradeoff in the instruction design was necessary: the size of each of the mantissa and exponent cannot be freely chosen from 0…255, but rather must be a multiple of 17, which is the word size of the LT4335. In an opcode like that of FGAE, m⁴_e⁴_00_000_1111, there is first an unsigned four-bit integer (m⁴) giving the size of the mantissa, in words — not bits. That is followed by another unsigned four-bit integer (e⁴), this one giving the size of the exponent in words. Therefore, _B1000 means one word = 17 bits, _B0100 = 34 bits, _B1010 = 85 bits, et cetera. A likely popular choice is the sequence _B1100_1000 which gives a mantissa of 51 bits and an exponent of 17 bits. The reason for employing word-size, and not bit-size, granularity is that an opcode is only 17 bits long, and two 8-bit size specifiers would leave only one bit, which is hardly enough to distinguish several instructions.
When the size operands are in registers, the limitations of the previous paragraph do not apply; the mantissa and exponent can be of arbitrary sizes, and those sizes need not be calculated until run time. Similarly, there is no size restriction when separate integer instructions are used to get or put the mantissa and exponent.
In the descriptions below:

m⁸ is a signed 8-bit integer (−127…+127 or null) for the mantissa of a tiny float (FG_E instruction only)
e⁴ is either:

a signed 4-bit integer (−7…+7 or null) for the exponent of a tiny float (FG_E instruction only)
an unsigned 4-bit integer (0…15) for the size (in words) of the exponent of a float

m⁴ is an unsigned 4-bit integer (0…15) for the size (in words) of the mantissa of a float.
u⁸ is an unsigned 8-bit integer (0…255)
s⁹ is a signed 9-bit integer (−255…+255 or null).
Sometimes the size of a mantissa or exponent is represented by a signed integer; an exception will be thrown in response to a requested size greater than 255, less than 0, or null.
Many of the get, put, and get-and-put instructions involve an offset. This number, when added to the address of the next physical instruction (which equals the address of the current instruction plus 17), gives the address in genspace whence to read data, or whither to write it. If the offset is null, an exception is thrown.
Get. (see also integer and string) All the float get instructions normalize and trim the result as it is placed into registers. If an unnormalized or untrimmed float is preferred, the programmer should use string get instructions.
The first get instruction pushes a float embedded in the opcode, while the rest get the float from genspace.

FG_E float get, value embedded m⁸_e⁴_01_001
Pulled: none
Pushed:
• #0 exp, #1 man: data retrieved
Embedded is a tiny float, with 8 bits for the mantissa and 4 for the exponent.
FG_AE float get, absolute address, sizes embedded m⁴_e⁴_000_10_1111 FG_AR float get, absolute address, all operands in registers 0⁸_000_10_1111
Pulled:
• #0 signed integer: address to read in genspace
Pushed:
• #0 exp, #1 man: data retrieved
m⁴ and e⁴ are how many words to retrieve for the mantissa and exponent. If both zero, FG_AR is performed instead.
Pulled:
• #0 signed integer: address to read in genspace
• #1 signed integer in 0…255: how many bits to retrieve for exponent
• #2 signed integer in 0…255: how many bits to retrieve for mantissa
Pushed:
• #0 exp, #1 man: data retrieved
FG_AE_Y float get, absolute address, sizes embedded, synchronized m⁴_e⁴_100_10_1111 FG_AR_Y float get, absolute address, all operands in registers, synchronized 0⁸_100_10_1111
Same as FG_AE, plus synchronization. If m⁴ and e⁴ are both zero, FG_AR_Y is performed instead. Same as FG_AR, plus synchronization.
FG_RO float get, relative address, offset embedded s⁹_01_10_1111
Pulled:
• #0 signed integer in 0…255: how many bits to retrieve for exponent
• #1 signed integer in 0…255: how many bits to retrieve for mantissa
Pushed:
• #0 exp, #1 man: data retrieved
s⁹ is the offset.
FG_RS float get, relative address, sizes embedded m⁴_e⁴_010_10_1111 FG_RR float get, relative address, all operands in registers 0⁸_010_10_1111
Pulled:
• #0 signed integer: offset
Pushed:
• #0 exp, #1 man: data retrieved
m⁴ and e⁴ are how many words to retrieve for the mantissa and exponent. If both zero, FG_RR is performed instead.
Pulled:
• #0 signed integer: offset
• #1 signed integer in 0…255: how many bits to retrieve for exponent
• #2 signed integer in 0…255: how many bits to retrieve for mantissa
Pushed:
• #0 exp, #1 man: data retrieved
FG_RO_Y float get, relative address, offset embedded, synchronized s⁹_11_10_1111
Same as FG_RO, plus synchronization.
FG_RS_Y float get, relative address, sizes embedded, synchronized m⁴_e⁴_110_10_1111 FG_RR_Y float get, relative address, all operands in registers, synchronized 0⁸_110_10_1111
Same as FG_RS, plus synchronization. If m⁴ and e⁴ are both zero, FG_RR_Y is performed instead. Same as FG_RR, plus synchronization.

FG_E	float get, value embedded	m⁸_e⁴_01_001
Pulled: none Pushed: • #0 exp, #1 man: data retrieved Embedded is a tiny float, with 8 bits for the mantissa and 4 for the exponent.
FG_AE	float get, absolute address, sizes embedded	m⁴_e⁴_000_10_1111	FG_AR	float get, absolute address, all operands in registers	0⁸_000_10_1111
Pulled: • #0 signed integer: address to read in genspace Pushed: • #0 exp, #1 man: data retrieved m⁴ and e⁴ are how many words to retrieve for the mantissa and exponent. If both zero, FG_AR is performed instead.	Pulled: • #0 signed integer: address to read in genspace • #1 signed integer in 0…255: how many bits to retrieve for exponent • #2 signed integer in 0…255: how many bits to retrieve for mantissa Pushed: • #0 exp, #1 man: data retrieved
FG_AE_Y	float get, absolute address, sizes embedded, synchronized	m⁴_e⁴_100_10_1111	FG_AR_Y	float get, absolute address, all operands in registers, synchronized	0⁸_100_10_1111
Same as FG_AE, plus synchronization. If m⁴ and e⁴ are both zero, FG_AR_Y is performed instead.	Same as FG_AR, plus synchronization.
FG_RO	float get, relative address, offset embedded	s⁹_01_10_1111
Pulled: • #0 signed integer in 0…255: how many bits to retrieve for exponent • #1 signed integer in 0…255: how many bits to retrieve for mantissa Pushed: • #0 exp, #1 man: data retrieved s⁹ is the offset.
FG_RS	float get, relative address, sizes embedded	m⁴_e⁴_010_10_1111	FG_RR	float get, relative address, all operands in registers	0⁸_010_10_1111
Pulled: • #0 signed integer: offset Pushed: • #0 exp, #1 man: data retrieved m⁴ and e⁴ are how many words to retrieve for the mantissa and exponent. If both zero, FG_RR is performed instead.	Pulled: • #0 signed integer: offset • #1 signed integer in 0…255: how many bits to retrieve for exponent • #2 signed integer in 0…255: how many bits to retrieve for mantissa Pushed: • #0 exp, #1 man: data retrieved
FG_RO_Y	float get, relative address, offset embedded, synchronized	s⁹_11_10_1111
Same as FG_RO, plus synchronization.
FG_RS_Y	float get, relative address, sizes embedded, synchronized	m⁴_e⁴_110_10_1111	FG_RR_Y	float get, relative address, all operands in registers, synchronized	0⁸_110_10_1111
Same as FG_RS, plus synchronization. If m⁴ and e⁴ are both zero, FG_RR_Y is performed instead.	Same as FG_RR, plus synchronization.

Intentionally omitted is an option to embed an 8-bit mantissa size but place the exponent size in a register, and vice versa.

Put. (see also integer and string) The next instructions pull an float from the stack and write it into genspace. They attempt to convert each of the mantissa and exponent from the size it assumed in its register to the size requested for genspace, which is likely different from the trimmed size. Rounding-nearest-half-even may be necessary, and a reduction in digits may incur a null.

FP_AE float put, absolute address, sizes embedded m⁴_e⁴_000_01_1111 FP_AR float put, absolute address, all operands in registers 0⁸_000_01_1111
Pulled:
• #0 exp, #1 man: data to write
• #2 signed integer: the address to write in genspace
Pushed: none
m⁴ and e⁴ are how many words to write for the mantissa and exponent. If both zero, FP_AR is performed instead.
Pulled:
• #0 exp, #1 man: data to write
• #2 signed integer: address to write in genspace
• #3 signed integer in 0…255: how many bits to write for exponent
• #4 signed integer in 0…255: how many bits to write for mantissa
Pushed: none
FP_AE_Y float put, absolute address, sizes embedded, synchronized m⁴_e⁴_100_01_1111 FP_AR_Y float put, absolute address, all operands in registers, synchronized 0⁸_100_01_1111
Same as FP_AE, plus synchronization. If m⁴ and e⁴ are both zero, FP_AR_Y is performed instead. Same as FP_AR, plus synchronization.
FP_RO float put, relative address, offset embedded s⁹_01_01_1111
Pulled:
• #0 exp, #1 man: data to write
• #1 signed integer in 0…255: how many bits to write for exponent
• #2 signed integer in 0…255: how many bits to write for mantissa
Pushed: none
s⁹ is the offset.
FP_RS float put, relative address, sizes embedded m⁴_e⁴_010_01_1111 FP_RR float put, relative address, all operands in registers 0⁸_010_01_1111
Pulled:
• #0 exp, #1 man: data to write
• #2 signed integer: offset
Pushed: none
m⁴ and e⁴ are how many words to write for the mantissa and exponent. If both zero, FP_RR is performed instead.
Pulled:
• #0 exp, #1 man: data to write
• #2 signed integer: offset
• #3 signed integer in 0…255: how many bits to write for exponent
• #4 signed integer in 0…255: how many bits to write for mantissa
Pushed: none
FP_RO_Y float put, relative address, offset embedded, synchronized s⁹_11_01_1111
Same as FP_RO, plus synchronization.
FP_RS_Y float put, relative address, sizes embedded, synchronized m⁴_e⁴_110_01_1111 FP_RR_Y float put, relative address, all operands in registers, synchronized 0⁸_110_01_1111
Same as FP_RS, plus synchronization. If m⁴ and e⁴ are both zero, FP_RR_Y is performed instead. Same as FP_RR, plus synchronization.

FP_AE	float put, absolute address, sizes embedded	m⁴_e⁴_000_01_1111	FP_AR	float put, absolute address, all operands in registers	0⁸_000_01_1111
Pulled: • #0 exp, #1 man: data to write • #2 signed integer: the address to write in genspace Pushed: none m⁴ and e⁴ are how many words to write for the mantissa and exponent. If both zero, FP_AR is performed instead.	Pulled: • #0 exp, #1 man: data to write • #2 signed integer: address to write in genspace • #3 signed integer in 0…255: how many bits to write for exponent • #4 signed integer in 0…255: how many bits to write for mantissa Pushed: none
FP_AE_Y	float put, absolute address, sizes embedded, synchronized	m⁴_e⁴_100_01_1111	FP_AR_Y	float put, absolute address, all operands in registers, synchronized	0⁸_100_01_1111
Same as FP_AE, plus synchronization. If m⁴ and e⁴ are both zero, FP_AR_Y is performed instead.	Same as FP_AR, plus synchronization.
FP_RO	float put, relative address, offset embedded	s⁹_01_01_1111
Pulled: • #0 exp, #1 man: data to write • #1 signed integer in 0…255: how many bits to write for exponent • #2 signed integer in 0…255: how many bits to write for mantissa Pushed: none s⁹ is the offset.
FP_RS	float put, relative address, sizes embedded	m⁴_e⁴_010_01_1111	FP_RR	float put, relative address, all operands in registers	0⁸_010_01_1111
Pulled: • #0 exp, #1 man: data to write • #2 signed integer: offset Pushed: none m⁴ and e⁴ are how many words to write for the mantissa and exponent. If both zero, FP_RR is performed instead.	Pulled: • #0 exp, #1 man: data to write • #2 signed integer: offset • #3 signed integer in 0…255: how many bits to write for exponent • #4 signed integer in 0…255: how many bits to write for mantissa Pushed: none
FP_RO_Y	float put, relative address, offset embedded, synchronized	s⁹_11_01_1111
Same as FP_RO, plus synchronization.
FP_RS_Y	float put, relative address, sizes embedded, synchronized	m⁴_e⁴_110_01_1111	FP_RR_Y	float put, relative address, all operands in registers, synchronized	0⁸_110_01_1111
Same as FP_RS, plus synchronization. If m⁴ and e⁴ are both zero, FP_RR_Y is performed instead.	Same as FP_RR, plus synchronization.

Get-and-(conditional)-put. (see also integer and string) The machine compares the float in genspace to the "old value" float:

If they both have values, and they are equal: the "new value" float is written to genspace in place of the old value, and the one-bit string 1 is pushed.
If either is null, or they are unequal: genspace is not changed, and the one-bit string 0 is pushed.

It is not necessary that the numbers have been normalized or trimmed. For example, here are two numbers that would test as equal:

mantissa 01110000 = 14 and exponent 0011111 = −4; this number is 14 ÷16 = 0.875
mantissa 11100 = 7 and exponent 101111 = −3; this number is 7÷8 = 0.875

The two floats must be of exactly the same value; there is no provision for a tolerance. (If an exact match of bit patterns is desired, the string version of get-and-put should be used.) If the "new value" float is of such large or small magnitude that its exponent will not fit into the indicated region of genspace, a null will be written instead.

FGP_AE float get-and-put, absolute address, sizes embedded m⁴_e⁴_000_11_1111 FGP_AR float get-and-put, absolute address, all operands in registers 0⁸_000_11_1111
Pulled:
• #0 signed integer: the address to examine in genspace
• #1 exp, #2 man: old value
• #3 exp, #4 man: new value
Pushed:
• #0 one-bit string: result
m⁴ and e⁴ are how many words in genspace to examine for the mantissa and exponent. If both zero, FGP_AR is performed instead.
Pulled:
• #0 signed integer: address to examine in genspace
• #1 signed integer in 0…255: how many bits in genspace to examine for exponent
• #2 signed integer in 0…255: how many bits in genspace to examine for mantissa
• #3 exp, #4 man: old value
• #5 exp, #6 man: new value
Pushed:
• #0 one-bit string: result
FGP_AE_Y float get-and-put, absolute address, sizes embedded, synchronized m⁴_e⁴_100_11_1111 FGP_AR_Y float get-and-put, absolute address, all operands in registers, synchronized 0⁸_100_11_1111
Same as FGP_AE, plus synchronization. If m⁴ and e⁴ are both zero, FGP_AR_Y is performed instead. Same as FGP_AR, plus synchronization.
FGP_RO float get-and-put, relative address, offset embedded s⁹_01_11_1111
Pulled:
• #0 signed integer in 0…255: how many bits in genspace to examine for exponent
• #1 signed integer in 0…255: how many bits in genspace to examine for mantissa
• #2 exp, #3 man: old value
• #4 exp, #5 man: new value
Pushed:
• #0 one-bit string: result
s⁹ is the offset.
FGP_RS float get-and-put, relative address, sizes embedded m⁴_e⁴_010_11_1111 FGP_RR float get-and-put, relative address, all operands in registers 0⁸_010_11_1111
Pulled:
• #0 signed integer: offset
• #1 exp, #2 man: old value
• #3 exp, #4 man: new value
Pushed:
• #0 one-bit string: result
m⁴ and e⁴ are how many words in genspace to examine for the mantissa and exponent. If both zero, FGP_RR is performed instead.
Pulled:
• #0 signed integer: offset
• #1 signed integer in 0…255: how many bits in genspace to examine
• #2 exp, #3 man: old value
• #4 exp, #5 man: new value
Pushed:
• #0 one-bit string: result
FGP_RO_Y float get-and-put, relative address, offset embedded, synchronized s⁹_11_11_1111
Same as FGP_RO, plus synchronization.
FGP_RS_Y float get-and-put, relative address, sizes embedded, synchronized m⁴_e⁴_110_11_1111 FGP_RR_Y float get-and-put, relative address, all operands in registers, synchronized 0⁸_110_11_1111
Same as FGP_RE, plus synchronization. If m⁴ and e⁴ are both zero, FGP_RR_Y is performed instead. Same as FGP_RR, plus synchronization.

FGP_AE	float get-and-put, absolute address, sizes embedded	m⁴_e⁴_000_11_1111	FGP_AR	float get-and-put, absolute address, all operands in registers	0⁸_000_11_1111
Pulled: • #0 signed integer: the address to examine in genspace • #1 exp, #2 man: old value • #3 exp, #4 man: new value Pushed: • #0 one-bit string: result m⁴ and e⁴ are how many words in genspace to examine for the mantissa and exponent. If both zero, FGP_AR is performed instead.	Pulled: • #0 signed integer: address to examine in genspace • #1 signed integer in 0…255: how many bits in genspace to examine for exponent • #2 signed integer in 0…255: how many bits in genspace to examine for mantissa • #3 exp, #4 man: old value • #5 exp, #6 man: new value Pushed: • #0 one-bit string: result
FGP_AE_Y	float get-and-put, absolute address, sizes embedded, synchronized	m⁴_e⁴_100_11_1111	FGP_AR_Y	float get-and-put, absolute address, all operands in registers, synchronized	0⁸_100_11_1111
Same as FGP_AE, plus synchronization. If m⁴ and e⁴ are both zero, FGP_AR_Y is performed instead.	Same as FGP_AR, plus synchronization.
FGP_RO	float get-and-put, relative address, offset embedded	s⁹_01_11_1111
Pulled: • #0 signed integer in 0…255: how many bits in genspace to examine for exponent • #1 signed integer in 0…255: how many bits in genspace to examine for mantissa • #2 exp, #3 man: old value • #4 exp, #5 man: new value Pushed: • #0 one-bit string: result s⁹ is the offset.
FGP_RS	float get-and-put, relative address, sizes embedded	m⁴_e⁴_010_11_1111	FGP_RR	float get-and-put, relative address, all operands in registers	0⁸_010_11_1111
Pulled: • #0 signed integer: offset • #1 exp, #2 man: old value • #3 exp, #4 man: new value Pushed: • #0 one-bit string: result m⁴ and e⁴ are how many words in genspace to examine for the mantissa and exponent. If both zero, FGP_RR is performed instead.	Pulled: • #0 signed integer: offset • #1 signed integer in 0…255: how many bits in genspace to examine • #2 exp, #3 man: old value • #4 exp, #5 man: new value Pushed: • #0 one-bit string: result
FGP_RO_Y	float get-and-put, relative address, offset embedded, synchronized	s⁹_11_11_1111
Same as FGP_RO, plus synchronization.
FGP_RS_Y	float get-and-put, relative address, sizes embedded, synchronized	m⁴_e⁴_110_11_1111	FGP_RR_Y	float get-and-put, relative address, all operands in registers, synchronized	0⁸_110_11_1111
Same as FGP_RE, plus synchronization. If m⁴ and e⁴ are both zero, FGP_RR_Y is performed instead.	Same as FGP_RR, plus synchronization.

Versus. (see also integer, string, and branch) Two floats may be compared with each other. The result is a string at #0, which contains 32 bits. Its contents are:

Address of bit within #0_new With FV_E and FV_R, this bit equals 1 when … Comments
0 #0.1_old and #2.3_old both have values, and #0.1_old > #2.3_old never both 1 exact comparison, analogous to integer and string
1 #0.1_old and #2.3_old both have values, and #0.1_old ≤ #2.3_old
2 #0.1_old and #2.3_old both have values, and #0.1_old ≠ #2.3_old never both 1
3 #0.1_old and #2.3_old both have values, and #0.1_old = #2.3_old
4 #0.1_old and #2.3_old both have values, and #0.1_old < #2.3_old never both 1
5 #0.1_old and #2.3_old both have values, and #0.1_old ≥ #2.3_old
6 #0.1_old is null never the same analogous to integer
7 #0.1_old has a value
8 #2.3_old is null never the same
9 #2.3_old has a value
10 #0.1_old and #2.3_old are similar never the same
11 #0.1_old and #2.3_old are dissimilar
12 #0.1_old has a value, and #2.3_old is null never the same
13 #0.1_old is null, or #2.3_old has a value
14 #0.1_old is null, and #2.3_old has a value never the same
15 #0.1_old has a value, or #2.3_old is null
16 #0.1_old has a value, and #2.3_old has a value never the same
17 #0.1_old is null, or #2.3_old is null
18 #0.1_old is null, and #2.3_old is null never the same
19 #0.1_old has a value, or #2.3_old has a value
20 #0.1_old and #2.3_old both have values, and #0.1_old > #2.3_old never both 1 absolute tolerance
21 #0.1_old and #2.3_old both have values, and #0.1_old ≤ #2.3_old
22 #0.1_old and #2.3_old both have values, and #0.1_old ≠ #2.3_old never both 1
23 #0.1_old and #2.3_old both have values, and #0.1_old = #2.3_old
24 #0.1_old and #2.3_old both have values, and #0.1_old < #2.3_old never both 1
25 #0.1_old and #2.3_old both have values, and #0.1_old ≥ #2.3_old
26 #0.1_old and #2.3_old both have values, and #0.1_old > #2.3_old never both 1 relative tolerance
27 #0.1_old and #2.3_old both have values, and #0.1_old ≤ #2.3_old
28 #0.1_old and #2.3_old both have values, and #0.1_old ≠ #2.3_old never both 1
29 #0.1_old and #2.3_old both have values, and #0.1_old = #2.3_old
30 #0.1_old and #2.3_old both have values, and #0.1_old < #2.3_old never both 1
31 #0.1_old and #2.3_old both have values, and #0.1_old ≥ #2.3_old

Address of bit within #0_new	With FV_E and FV_R, this bit equals 1 when …	Comments
0	#0.1_old and #2.3_old both have values, and #0.1_old > #2.3_old	never both 1	exact comparison, analogous to integer and string
1	#0.1_old and #2.3_old both have values, and #0.1_old ≤ #2.3_old
2	#0.1_old and #2.3_old both have values, and #0.1_old ≠ #2.3_old	never both 1
3	#0.1_old and #2.3_old both have values, and #0.1_old = #2.3_old
4	#0.1_old and #2.3_old both have values, and #0.1_old < #2.3_old	never both 1
5	#0.1_old and #2.3_old both have values, and #0.1_old ≥ #2.3_old
6	#0.1_old is null	never the same	analogous to integer
7	#0.1_old has a value
8	#2.3_old is null	never the same
9	#2.3_old has a value
10	#0.1_old and #2.3_old are similar	never the same
11	#0.1_old and #2.3_old are dissimilar
12	#0.1_old has a value, and #2.3_old is null	never the same
13	#0.1_old is null, or #2.3_old has a value
14	#0.1_old is null, and #2.3_old has a value	never the same
15	#0.1_old has a value, or #2.3_old is null
16	#0.1_old has a value, and #2.3_old has a value	never the same
17	#0.1_old is null, or #2.3_old is null
18	#0.1_old is null, and #2.3_old is null	never the same
19	#0.1_old has a value, or #2.3_old has a value
20	#0.1_old and #2.3_old both have values, and #0.1_old > #2.3_old	never both 1	absolute tolerance
21	#0.1_old and #2.3_old both have values, and #0.1_old ≤ #2.3_old
22	#0.1_old and #2.3_old both have values, and #0.1_old ≠ #2.3_old	never both 1
23	#0.1_old and #2.3_old both have values, and #0.1_old = #2.3_old
24	#0.1_old and #2.3_old both have values, and #0.1_old < #2.3_old	never both 1
25	#0.1_old and #2.3_old both have values, and #0.1_old ≥ #2.3_old
26	#0.1_old and #2.3_old both have values, and #0.1_old > #2.3_old	never both 1	relative tolerance
27	#0.1_old and #2.3_old both have values, and #0.1_old ≤ #2.3_old
28	#0.1_old and #2.3_old both have values, and #0.1_old ≠ #2.3_old	never both 1
29	#0.1_old and #2.3_old both have values, and #0.1_old = #2.3_old
30	#0.1_old and #2.3_old both have values, and #0.1_old < #2.3_old	never both 1
31	#0.1_old and #2.3_old both have values, and #0.1_old ≥ #2.3_old

A comparand is regarded as null if the mantissa, the exponent, or both are null. The programmer can investigate the component integers if greater detail is required.

FV_E float versus, tolerance embedded s⁹_1111_0111 FV_R float versus, tolerance in register 0⁸1_1111_0111
Pulled:
• #0 exp, #1 man: comparand
• #2 exp, #3 man: comparand
Pushed:
• #0 32-bit string: result
If s⁹ is null, FV_R is performed instead.
Pulled:
• #0 exp, #1 man: comparand
• #2 exp, #3 man: comparand
• #4 unsigned integer: tolerance
Pushed:
• #0 32-bit string: result

FV_E	float versus, tolerance embedded	s⁹_1111_0111	FV_R	float versus, tolerance in register	0⁸1_1111_0111
Pulled: • #0 exp, #1 man: comparand • #2 exp, #3 man: comparand Pushed: • #0 32-bit string: result If s⁹ is null, FV_R is performed instead.	Pulled: • #0 exp, #1 man: comparand • #2 exp, #3 man: comparand • #4 unsigned integer: tolerance Pushed: • #0 32-bit string: result

The absolute and relative tolerances are most easily described by reference to the number produced by the FIL instruction, namely the base-two logarithm of a float's absolute value, rounded to an integer, rounded toward negative infinity.

For absolute tolerance, the instruction subtracts one comparand from the other. If the FIL of that difference is less than or equal to the tolerance, the numbers are deemed equal, not greater-than, and not less-than.
For relative tolerance, define the anchor to be the comparand of greater absolute value. The instruction subtracts the other comparand from the anchor to obtain the deviation. Next the FIL of the deviation is subtracted from the FIL of the anchor; and if that difference is greater than or equal to the tolerance, the numbers are deemed equal, not greater-than, and not less-than.
Whether tolerance is absolute or relative, in the case where both comparands happen to be exactly equal they are of course regarded as equal, not greater-than, and not less-than.

The absolute and relative tolerance comparisons are not intended to be a comprehensive error-management system. Rather, they are a quick and easy way to determine whether two floats are "very nearly" equal, and can be beneficial to iterative numerical routines that must frequently test for a termination condition.

Arithmetic. (see also integer) Float arithmetic offers the usual operations. The output will be null on overflow, null input, or division by zero. Null or not, the float will be normalized, and each component integer trimmed.

The precision is the number of bits that the mantissa will have before normalization or trimming, and all those bits are guaranteed accurate according to the round-nearest-half-even rule; this is a relative precision, not an absolute. If the requested precision is not in 0…255, an exception will be thrown. When the precision is embedded in the opcode, it is the first eight bits.

FA_E float add, precision embedded u⁸_00000_0111 FA_R float add, precision in register 0⁸_00000_0111
Pulled:
• #0 exp, #1 man: augend
• #2 exp, #3 man: addend
Pushed:
• #0 exp, #1 man = #0.1_old + #2.3_old
If u⁸ is zero, FA_R is performed instead.
Pulled:
• #0 exp, #1 man: augend
• #2 exp, #3 man: addend
• #4 signed integer in 0…255: precision
Pushed:
• #0 exp, #1 man = #0.1_old + #2.3_old
FS_E float subtract, precision embedded u⁸_10000_0111 FS_R float subtract, precision in register 0⁸_10000_0111
Pulled:
• #0 exp, #1 man: minuend
• #2 exp, #3 man: subtrahend
Pushed:
• #0 exp, #1 man = #0.1_old − #2.3_old
If u⁸ is zero, FS_R is performed instead.
Pulled:
• #0 exp, #1 man: minuend
• #2 exp, #3 man: subtrahend
• #4 signed integer in 0…255: precision
Pushed:
• #0 exp, #1 man = #0.1_old − #2.3_old
FS_0E float negate, precision embedded u⁸_01000_0111 FS_0R float negate, precision in register 0⁸_01000_0111
Pulled:
• #0 exp, #1 man: negand
Pushed:
• #0 exp, #1 man = 0 − #0.1_old
If u⁸ is zero, FS_0R is performed instead.
Pulled:
• #0 exp, #1 man: negand
• #3 signed integer in 0…255: precision
Pushed:
• #0 exp, #1 man = 0 − #0.1_old
FM_E float multiply, precision embedded u⁸_11000_0111 FM_R float multiply, precision in register 0⁸_11000_0111
Pulled:
• #0 exp, #1 man: multiplicand
• #2 exp, #3 man: multiplier
Pushed:
• #0 exp, #1 man = #0.1_old × #2.3_old
If u⁸ is zero, FM_R is performed instead.
Pulled:
• #0 exp, #1 man: multiplicand
• #2 exp, #3 man: multiplier
• #4 signed integer in 0…255: precision
Pushed:
• #0 exp, #1 man = #0.1_old × #2.3_old
FD_E float divide, precision embedded u⁸_00100_0111 FD_R float divide, precision in register 0⁸_00100_0111
Pulled:
• #0 exp, #1 man: dividend
• #2 exp, #3 man: divisor
Pushed:
• #0 exp, #1 man = #0.1_old ÷ #2.3_old
If u⁸ is zero, FD_R is performed instead.
Pulled:
• #0 exp, #1 man: dividend
• #2 exp, #3 man: divisor
• #4 signed integer in 0…255: precision
Pushed:
• #0 exp, #1 man = #0.1_old ÷ #2.3_old
FD_1E float reciprocal, precision embedded u⁸_10100_0111 FD_1R float reciprocal, precision in register 0⁸_10100_0111
Pulled:
• #0 exp, #1 man: operand
Pushed:
• #0 exp, #1 man = 1 ÷ #0.1_old
If u⁸ is zero, FD_1R is performed instead.
Pulled:
• #0 exp, #1 man: operand
• #3 signed integer in 0…255: precision
Pushed:
• #0 exp, #1 man = 1 ÷ #0.1_old
FMA_E float multiply and add, precision embedded u⁸_01100_0111 FMA_R float multiply and add, precision in register 0⁸_01100_0111
Pulled:
• #0 exp, #1 man: multiplicand
• #2 exp, #3 man: multiplier
• #4 exp, #5 man: addend
Pushed:
• #0 exp, #1 man = (#0.1_old × #2.3_old) + #4.5_old
If u⁸ is zero, FMA_R is performed instead.
Pulled:
• #0 exp, #1 man: multiplicand
• #2 exp, #3 man: multiplier
• #4 exp, #5 man: addend
• #6 signed integer in 0…255: precision
Pushed:
• #0 exp, #1 man = (#0.1_old × #2.3_old) + #4.5_old
FMS_E float multiply and subtract, precision embedded u⁸_11100_0111 FMS_R float multiply and subtract, precision in register 0⁸_11100_0111
Pulled:
• #0 exp, #1 man: multiplicand
• #2 exp, #3 man: multiplier
• #4 exp, #5 man: addend
Pushed:
• #0 exp, #1 man = (#0.1_old × #2.3_old) − #4.5_old
If u⁸ is zero, FMS_R is performed instead.
Pulled:
• #0 exp, #1 man: multiplicand
• #2 exp, #3 man: multiplier
• #4 exp, #5 man: addend
• #6 signed integer in 0…255: precision
Pushed:
• #0 exp, #1 man = (#0.1_old × #2.3_old) − #4.5_old

FA_E	float add, precision embedded	u⁸_00000_0111	FA_R	float add, precision in register	0⁸_00000_0111
Pulled: • #0 exp, #1 man: augend • #2 exp, #3 man: addend Pushed: • #0 exp, #1 man = #0.1_old + #2.3_old If u⁸ is zero, FA_R is performed instead.	Pulled: • #0 exp, #1 man: augend • #2 exp, #3 man: addend • #4 signed integer in 0…255: precision Pushed: • #0 exp, #1 man = #0.1_old + #2.3_old
FS_E	float subtract, precision embedded	u⁸_10000_0111	FS_R	float subtract, precision in register	0⁸_10000_0111
Pulled: • #0 exp, #1 man: minuend • #2 exp, #3 man: subtrahend Pushed: • #0 exp, #1 man = #0.1_old − #2.3_old If u⁸ is zero, FS_R is performed instead.	Pulled: • #0 exp, #1 man: minuend • #2 exp, #3 man: subtrahend • #4 signed integer in 0…255: precision Pushed: • #0 exp, #1 man = #0.1_old − #2.3_old
FS_0E	float negate, precision embedded	u⁸_01000_0111	FS_0R	float negate, precision in register	0⁸_01000_0111
Pulled: • #0 exp, #1 man: negand Pushed: • #0 exp, #1 man = 0 − #0.1_old If u⁸ is zero, FS_0R is performed instead.	Pulled: • #0 exp, #1 man: negand • #3 signed integer in 0…255: precision Pushed: • #0 exp, #1 man = 0 − #0.1_old
FM_E	float multiply, precision embedded	u⁸_11000_0111	FM_R	float multiply, precision in register	0⁸_11000_0111
Pulled: • #0 exp, #1 man: multiplicand • #2 exp, #3 man: multiplier Pushed: • #0 exp, #1 man = #0.1_old × #2.3_old If u⁸ is zero, FM_R is performed instead.	Pulled: • #0 exp, #1 man: multiplicand • #2 exp, #3 man: multiplier • #4 signed integer in 0…255: precision Pushed: • #0 exp, #1 man = #0.1_old × #2.3_old
FD_E	float divide, precision embedded	u⁸_00100_0111	FD_R	float divide, precision in register	0⁸_00100_0111
Pulled: • #0 exp, #1 man: dividend • #2 exp, #3 man: divisor Pushed: • #0 exp, #1 man = #0.1_old ÷ #2.3_old If u⁸ is zero, FD_R is performed instead.	Pulled: • #0 exp, #1 man: dividend • #2 exp, #3 man: divisor • #4 signed integer in 0…255: precision Pushed: • #0 exp, #1 man = #0.1_old ÷ #2.3_old
FD_1E	float reciprocal, precision embedded	u⁸_10100_0111	FD_1R	float reciprocal, precision in register	0⁸_10100_0111
Pulled: • #0 exp, #1 man: operand Pushed: • #0 exp, #1 man = 1 ÷ #0.1_old If u⁸ is zero, FD_1R is performed instead.	Pulled: • #0 exp, #1 man: operand • #3 signed integer in 0…255: precision Pushed: • #0 exp, #1 man = 1 ÷ #0.1_old
FMA_E	float multiply and add, precision embedded	u⁸_01100_0111	FMA_R	float multiply and add, precision in register	0⁸_01100_0111
Pulled: • #0 exp, #1 man: multiplicand • #2 exp, #3 man: multiplier • #4 exp, #5 man: addend Pushed: • #0 exp, #1 man = (#0.1_old × #2.3_old) + #4.5_old If u⁸ is zero, FMA_R is performed instead.	Pulled: • #0 exp, #1 man: multiplicand • #2 exp, #3 man: multiplier • #4 exp, #5 man: addend • #6 signed integer in 0…255: precision Pushed: • #0 exp, #1 man = (#0.1_old × #2.3_old) + #4.5_old
FMS_E	float multiply and subtract, precision embedded	u⁸_11100_0111	FMS_R	float multiply and subtract, precision in register	0⁸_11100_0111
Pulled: • #0 exp, #1 man: multiplicand • #2 exp, #3 man: multiplier • #4 exp, #5 man: addend Pushed: • #0 exp, #1 man = (#0.1_old × #2.3_old) − #4.5_old If u⁸ is zero, FMS_R is performed instead.	Pulled: • #0 exp, #1 man: multiplicand • #2 exp, #3 man: multiplier • #4 exp, #5 man: addend • #6 signed integer in 0…255: precision Pushed: • #0 exp, #1 man = (#0.1_old × #2.3_old) − #4.5_old

Integer-style division of floats. The remaining division operations are similar to those for integers. They involves two inputs (numerator N and denominator D) and two outputs (quotient Q and remainder R).

Here are the specifications:

If D = 0, the operation will fail.
N − R will equal Q × D.
The magnitude of R will be less than the magnitude of D.
R will be of the same sign (positive, negative, zero) as D.
N, D and R are floats, but Q is an integer.

Whatever the signs of N and D, Q is rounded toward negative infinity; no attempt is made to round Q to the nearest integer. Not observed is the usual float rounding rule, round-nearest-half-even.

Q will be trimmed as any other integer. The requested precision affects only R.

Another way to look at the operation is this:

If the exponents of N and D are both nonnegative, then they are both mathematical integers, and the definition of Q are R is exactly as that of integers. Although R will be a mathematical integer, it will be stored as a float.
If N or D has a negative exponent, both of them are multiplied by such a power of two as to make the exponents nonnegative. Then Q are R are figured as for integers. While Q will need no adjustment, R must be divided by the power of two that was earlier used for multiplication.

A result is null if either input is null, or if there is division by zero.

FIL is a rough guide to the magnitude of a float. The result is signed integer n if the float's absolute value is at least 2**n, but less than 2**(n + 1). It is easy for the machine to calculate. Define the leader of a positive integer as the address (within the register) of its rightmost nonzero bit. The leader of a negative integer is the leader of its absolute value, and the leader of zero or null is undefined. Then, for a float that is neither null nor zero, the result is obtained by adding the exponent to the mantissa's leader.

FR_E float remainder, precision embedded u⁸_00010_0111 FR_R float remainder, precision in register 0⁸_00010_0111
Pulled:
• #0 exp, #1 man: numerator
• #2 exp, #3 man: denominator
Pushed:
• #0 exp, #1 man = remainder of #0.1_old ÷ #2.3_old
If u⁸ is zero, FR_R is performed instead.
Pulled:
• #0 exp, #1 man: numerator
• #2 exp, #3 man: denominator
• #4 signed integer: precision
Pushed:
• #0 exp, #1 man = remainder of #0.1_old ÷ #2.3_old
FQ_RE float quotient and remainder, precision embedded u⁸_10010_0111 FQ_RR float quotient and remainder, precision in register 0⁸_10010_0111
Pulled:
• #0 exp, #1 man: numerator
• #2 exp, #3 man: denominator
Pushed:
• #0 exp, #1 man = remainder of #0.1_old ÷ #2.3_old
• #2 signed integer = quotient of #0.1_old ÷ #2.3_old
If u⁸ is zero, FQ_RR is performed instead.
Pulled:
• #0 exp, #1 man: numerator
• #2 exp, #3 man: denominator
• #4 signed integer in 0…255: precision
Pushed:
• #0 exp, #1 man = remainder of #0.1_old ÷ #2.3_old
• #2 signed integer = quotient of #0.1_old ÷ #2.3_old
FQ float quotient ?_x_10111_0111 FIL float integer logarithm ?_x_10111_0111
Pulled:
• #0 exp, #1 man: numerator
• #2 exp, #3 man: denominator
Pushed:
• #0 signed integer = quotient of #0.1_old ÷ #2.3_old
Pulled:
• #0 exp, #1 man: operand
Pushed:
• #0 signed integer: base-2 logarithm of absolute value of #0.1_old, rounded toward negative infinity
#0_new is null if #0.1_old is null or zero.

FR_E	float remainder, precision embedded	u⁸_00010_0111	FR_R	float remainder, precision in register	0⁸_00010_0111
Pulled: • #0 exp, #1 man: numerator • #2 exp, #3 man: denominator Pushed: • #0 exp, #1 man = remainder of #0.1_old ÷ #2.3_old If u⁸ is zero, FR_R is performed instead.	Pulled: • #0 exp, #1 man: numerator • #2 exp, #3 man: denominator • #4 signed integer: precision Pushed: • #0 exp, #1 man = remainder of #0.1_old ÷ #2.3_old
FQ_RE	float quotient and remainder, precision embedded	u⁸_10010_0111	FQ_RR	float quotient and remainder, precision in register	0⁸_10010_0111
Pulled: • #0 exp, #1 man: numerator • #2 exp, #3 man: denominator Pushed: • #0 exp, #1 man = remainder of #0.1_old ÷ #2.3_old • #2 signed integer = quotient of #0.1_old ÷ #2.3_old If u⁸ is zero, FQ_RR is performed instead.	Pulled: • #0 exp, #1 man: numerator • #2 exp, #3 man: denominator • #4 signed integer in 0…255: precision Pushed: • #0 exp, #1 man = remainder of #0.1_old ÷ #2.3_old • #2 signed integer = quotient of #0.1_old ÷ #2.3_old
FQ	float quotient	?_x_10111_0111	FIL	float integer logarithm	?_x_10111_0111
Pulled: • #0 exp, #1 man: numerator • #2 exp, #3 man: denominator Pushed: • #0 signed integer = quotient of #0.1_old ÷ #2.3_old	Pulled: • #0 exp, #1 man: operand Pushed: • #0 signed integer: base-2 logarithm of absolute value of #0.1_old, rounded toward negative infinity #0_new is null if #0.1_old is null or zero.

Format. (see also integer) The first instructions round-nearest-half-even the operand to a requested precision. The result is normalized and trimmed.

The last two instructions change the formatting of a float, but not its value. A programmer who desires the mantissa or exponent to be trimmed to a non-minimal size will need to invoke the integer instructions directly.

FF_RE float format round, precision embedded u⁸_01010_0111 FF_RR float format round, precision in register 0⁸_01010_0111
Pulled:
• #0 exp, #1 man: operand
Pushed:
• #0 exp, #1 man = #0.1_old rounded
If u⁸ is zero, FF_RR is performed instead.
Pulled:
• #0 exp, #1 man: operand
• #3 signed integer in 0…255: precision
Pushed:
• #0 exp, #1 man: = #0.1_old rounded
FF_N float format normalize ?_x_10111_0111 FF_T float format trim ?_x_10111_0111
Pulled:
• #0 exp, #1 man: operand
Pushed:
• #0 exp, #1 man: #0.1_old normalized
Pulled:
• #0 exp, #1 man: operand
Pushed:
• #0 exp, #1 man: each of #0_old and #1_old trimmed to its minimum size

FF_RE	float format round, precision embedded	u⁸_01010_0111	FF_RR	float format round, precision in register	0⁸_01010_0111
Pulled: • #0 exp, #1 man: operand Pushed: • #0 exp, #1 man = #0.1_old rounded If u⁸ is zero, FF_RR is performed instead.	Pulled: • #0 exp, #1 man: operand • #3 signed integer in 0…255: precision Pushed: • #0 exp, #1 man: = #0.1_old rounded
FF_N	float format normalize	?_x_10111_0111	FF_T	float format trim	?_x_10111_0111
Pulled: • #0 exp, #1 man: operand Pushed: • #0 exp, #1 man: #0.1_old normalized	Pulled: • #0 exp, #1 man: operand Pushed: • #0 exp, #1 man: each of #0_old and #1_old trimmed to its minimum size

Transcendental. The standard mathematical functions in the table below can be included on LT4335 implementations intended for scientific purposes. As compared to the other instruction tables, a condensed format has been used, because most of the operations are very similar to one another; the top row explains.

As usual, any null input ensures a null output.

FT…E float transcendental <function>, precision embedded u⁸_b⁵_0111 FT…R float transcendental <function>, precision in register 0⁸_b⁵_0111 Comments
Pulled:
• #0 exp, #1 man: operand
Pushed:
• <function> of #0.1_old
If u⁸ is zero, FT…R is performed instead.
Pulled:
• #0 exp, #1 man: operand
• #3 signed integer in 0…255: precision
Pushed:
• <function> of #0.1_old
FT_R2E flo tra square root, prec emb u⁸_00110_0111 FT_R2R flo tra square root, prec reg 0⁸_00110_0111 If operand is less than zero, result will be null.
FT_R3E flo tra cube root, prec emb u⁸_10110_0111 FT_R3R flo tra cube root, prec reg 0⁸_10110_0111
FT_EE flo tra exponential, prec emb u⁸_01110_0111 FT_ER flo tra exponential, prec reg 0⁸_01110_0111
FT_LE flo tra logarithm, prec emb u⁸_11110_0111 FT_LR flo tra logarithm, prec reg 0⁸_11110_0111 If operand is not greater than zero, result will be null.
FT_CSE flo tra circular sine, prec emb u⁸_00001_0111 FT_CSR flo tra circular sine, prec reg 0⁸_00001_0111
FT_HSE flo tra hyperbolic sine, prec emb u⁸_10001_0111 FT_HSR flo tra hyperbolic sine, prec reg 0⁸_10001_0111
FT_ICSE flo tra inverse circular sine, prec emb u⁸_01001_0111 FT_ICSR flo tra inverse circular sine, prec reg 0⁸_01001_0111 If absolute value of operand is greater than one, result will be null. Otherwise, −π ÷ 2 ≤ result ≤ +π ÷ 2.
FT_IHSE flo tra inverse hyperbolic sine, prec emb u⁸_11001_0111 FT_IHSR flo tra inverse hyperbolic sine, prec reg 0⁸_11001_0111
FT_CCE flo tra circular cosine, prec emb u⁸_00101_0111 FT_CCR flo tra circular cosine, prec reg 0⁸_00101_0111
FT_HCE flo tra hyperbolic cosine, prec emb u⁸_10101_0111 FT_HCR flo tra hyperbolic cosine, prec reg 0⁸_10101_0111
FT_ICCE flo tra inverse circular cosine, prec emb u⁸_01101_0111 FT_ICCR flo tra inverse circular cosine, prec reg 0⁸_01101_0111 If absolute value of operand is greater than one, result will be null. Otherwise, 0 ≤ result ≤ π.
FT_IHCE flo tra inverse hyperbolic cosine, prec emb u⁸_11101_0111 FT_IHCR flo tra inverse hyperbolic cosine, prec reg 0⁸_11101_0111 If operand is less than one, result will be null.
FT_CTE flo tra circular tangent, prec emb u⁸_00011_0111 FT_CTR flo tra circular tangent, prec reg 0⁸_00011_0111 If operand approximates an odd multiple of π ÷ 2, result will be null because of overflow.
FT_HTE flo tra hyperbolic tangent, prec emb u⁸_10011_0111 FT_HTR flo tra hyperbolic tangent, prec reg 0⁸_10011_0111
FT_ICT_1E flo tra inverse circular tangent, one argument, prec emb u⁸_01011_0111 FT_ICT_1R flo tra inverse circular tangent, one argument, prec reg 0⁸_01011_0111 −π ÷ 2 < result < +π ÷ 2.
FT_IHTE flo tra inverse hyperbolic tangent, prec emb u⁸_11011_0111 FT_IHTR flo tra inverse hyperbolic tangent, prec reg 0⁸_11011_0111 If absolute value of operand is not less than one, result will be null.
FT_ICT_2E flo tra inverse circular tangent, two arguments, prec emb u⁸_00111_0111 FT_ICT_2R flo tra inverse circular tangent, two arguments, prec reg 0⁸_00111_0111 see note below
Pulled:
• #0 exp, #1 man: abscissa
• #2 exp, #3 man: ordinate
Pushed:
• #0 exp, #1 man: result
If u⁸ is zero, FA_ICT_2R is performed instead.
Pulled:
• #0 exp, #1 man: abscissa
• #2 exp, #3 man: ordinate
• #4 signed integer in 0…255: precision
Pushed:
• #0 exp, #1 man: result

FT…E	float transcendental <function>, precision embedded	u⁸_b⁵_0111	FT…R	float transcendental <function>, precision in register	0⁸_b⁵_0111	Comments
Pulled: • #0 exp, #1 man: operand Pushed: • <function> of #0.1_old If u⁸ is zero, FT…R is performed instead.	Pulled: • #0 exp, #1 man: operand • #3 signed integer in 0…255: precision Pushed: • <function> of #0.1_old
FT_R2E	flo tra square root, prec emb	u⁸_00110_0111	FT_R2R	flo tra square root, prec reg	0⁸_00110_0111	If operand is less than zero, result will be null.
FT_R3E	flo tra cube root, prec emb	u⁸_10110_0111	FT_R3R	flo tra cube root, prec reg	0⁸_10110_0111
FT_EE	flo tra exponential, prec emb	u⁸_01110_0111	FT_ER	flo tra exponential, prec reg	0⁸_01110_0111
FT_LE	flo tra logarithm, prec emb	u⁸_11110_0111	FT_LR	flo tra logarithm, prec reg	0⁸_11110_0111	If operand is not greater than zero, result will be null.
FT_CSE	flo tra circular sine, prec emb	u⁸_00001_0111	FT_CSR	flo tra circular sine, prec reg	0⁸_00001_0111
FT_HSE	flo tra hyperbolic sine, prec emb	u⁸_10001_0111	FT_HSR	flo tra hyperbolic sine, prec reg	0⁸_10001_0111
FT_ICSE	flo tra inverse circular sine, prec emb	u⁸_01001_0111	FT_ICSR	flo tra inverse circular sine, prec reg	0⁸_01001_0111	If absolute value of operand is greater than one, result will be null. Otherwise, −π ÷ 2 ≤ result ≤ +π ÷ 2.
FT_IHSE	flo tra inverse hyperbolic sine, prec emb	u⁸_11001_0111	FT_IHSR	flo tra inverse hyperbolic sine, prec reg	0⁸_11001_0111
FT_CCE	flo tra circular cosine, prec emb	u⁸_00101_0111	FT_CCR	flo tra circular cosine, prec reg	0⁸_00101_0111
FT_HCE	flo tra hyperbolic cosine, prec emb	u⁸_10101_0111	FT_HCR	flo tra hyperbolic cosine, prec reg	0⁸_10101_0111
FT_ICCE	flo tra inverse circular cosine, prec emb	u⁸_01101_0111	FT_ICCR	flo tra inverse circular cosine, prec reg	0⁸_01101_0111	If absolute value of operand is greater than one, result will be null. Otherwise, 0 ≤ result ≤ π.
FT_IHCE	flo tra inverse hyperbolic cosine, prec emb	u⁸_11101_0111	FT_IHCR	flo tra inverse hyperbolic cosine, prec reg	0⁸_11101_0111	If operand is less than one, result will be null.
FT_CTE	flo tra circular tangent, prec emb	u⁸_00011_0111	FT_CTR	flo tra circular tangent, prec reg	0⁸_00011_0111	If operand approximates an odd multiple of π ÷ 2, result will be null because of overflow.
FT_HTE	flo tra hyperbolic tangent, prec emb	u⁸_10011_0111	FT_HTR	flo tra hyperbolic tangent, prec reg	0⁸_10011_0111
FT_ICT_1E	flo tra inverse circular tangent, one argument, prec emb	u⁸_01011_0111	FT_ICT_1R	flo tra inverse circular tangent, one argument, prec reg	0⁸_01011_0111	−π ÷ 2 < result < +π ÷ 2.
FT_IHTE	flo tra inverse hyperbolic tangent, prec emb	u⁸_11011_0111	FT_IHTR	flo tra inverse hyperbolic tangent, prec reg	0⁸_11011_0111	If absolute value of operand is not less than one, result will be null.
FT_ICT_2E	flo tra inverse circular tangent, two arguments, prec emb	u⁸_00111_0111	FT_ICT_2R	flo tra inverse circular tangent, two arguments, prec reg	0⁸_00111_0111	see note below
Pulled: • #0 exp, #1 man: abscissa • #2 exp, #3 man: ordinate Pushed: • #0 exp, #1 man: result If u⁸ is zero, FA_ICT_2R is performed instead.	Pulled: • #0 exp, #1 man: abscissa • #2 exp, #3 man: ordinate • #4 signed integer in 0…255: precision Pushed: • #0 exp, #1 man: result

Generally, FT_ICT_2E and FT_ICT_2R return the inverse circular tangent of ordinate ÷ abscissa. According to the signs of ordinate and abscissa, however, the result may be increased or decreased by 2 × π. Also, a nonnull result is obtained when the abscissa is zero if the ordinate is not zero. The effect is that of the widely used atan2 function found in many computer languages, with an overall range of −π < result ≤ +π. Here are the details:

if… then…
ordinate < 0 and abscissa < 0 −π < result < −π ÷ 2
ordinate < 0 and abscissa = 0 result = −π ÷ 2
ordinate < 0 and abscissa > 0 −π ÷ 2 < result < 0
ordinate = 0 and abscissa > 0 result = 0
ordinate > 0 and abscissa > 0 0 < result < +π ÷ 2
ordinate > 0 and abscissa = 0 result = +π ÷ 2
ordinate > 0 and abscissa < 0 +π ÷ 2 < result < +π
ordinate = 0 and abscissa < 0 result = +π
ordinate = 0 and abscissa = 0 result is null

if…	then…
ordinate < 0 and abscissa < 0	−π < result < −π ÷ 2
ordinate < 0 and abscissa = 0	result = −π ÷ 2
ordinate < 0 and abscissa > 0	−π ÷ 2 < result < 0
ordinate = 0 and abscissa > 0	result = 0
ordinate > 0 and abscissa > 0	0 < result < +π ÷ 2
ordinate > 0 and abscissa = 0	result = +π ÷ 2
ordinate > 0 and abscissa < 0	+π ÷ 2 < result < +π
ordinate = 0 and abscissa < 0	result = +π
ordinate = 0 and abscissa = 0	result is null