Rule integer - Revision history

Confocal: reword/relink, base64

2023-03-30T08:26:58Z

reword/relink, base64

Confocal: LifeWiki:Tiki bar/Archive/2020#"Non-Lifelike" CAs -- cleanup suggested

2022-08-10T02:23:25Z

LifeWiki:Tiki bar/Archive/2020#"Non-Lifelike" CAs -- cleanup suggested

← Older revision		Revision as of 02:23, 10 August 2022
Line 17:		Line 17:

	==Non-totalistic and non-isotropic rules==		==Non-totalistic and non-isotropic rules==
	There is not yet a generally accepted way of assigning rule integers or numbers to [[non-totalistic ~~Life-like~~ cellular automaton\|non-totalistic]] or [[non-isotropic ~~Life-like~~ cellular automaton\|non-isotropic ~~Life-like~~ cellular automata]].		There is not yet a generally accepted way of assigning rule integers or numbers to [[non-totalistic cellular automaton\|non-totalistic]] or [[non-isotropic cellular automaton\|non-isotropic]] cellular automata.

	However, a candidate assignment is used by [[Chris Rowett]]'s [[LifeViewer]] and [[Golly]] 3.0 as a native rule type for [[~~Moore_neighbourhood~~\|Moore]], Hex and [[~~Von_Neumann_neighborhood~~\|von Neumann]] neighborhoods.		However, a candidate assignment is used by [[Chris Rowett]]'s [[LifeViewer]] and [[Golly]] 3.0 as a native rule type for [[Moore neighbourhood\|Moore]], Hex and [[Von Neumann neighborhood\|von Neumann]] neighborhoods.

	For the Moore neighborhood the format is as follows: <tt>rule = MAP{base64-encoded 512-bit binary string}</tt>, where the ''n''-th bit in the string gives the output state for a specific set of neighborhood conditions.		For the Moore neighborhood the format is as follows: <tt>rule = MAP{base64-encoded 512-bit binary string}</tt>, where the ''n''-th bit in the string gives the output state for a specific set of neighborhood conditions.

Ian07: /* Megacell non-totalistic encoding */AutoWikiBrowser, replaced: P1 → p1

2021-12-14T22:22:24Z

Megacell non-totalistic encoding: AutoWikiBrowser, replaced: P1 → p1

← Older revision		Revision as of 22:22, 14 December 2021
Line 41:		Line 41:

	== Megacell non-totalistic encoding ==		== Megacell non-totalistic encoding ==
	Adam P. Goucher's [[P1 megacell]] is a Life [[unit cell]] capable of simulating arbitrary non-totalistic rules. Its configuration includes a 512-bit rule integer encoded as a line of eaters in the west side of the south corner. This uses a different bit order, with the center cell as the most significant bit:		Adam P. Goucher's [[p1 megacell]] is a Life [[unit cell]] capable of simulating arbitrary non-totalistic rules. Its configuration includes a 512-bit rule integer encoded as a line of eaters in the west side of the south corner. This uses a different bit order, with the center cell as the most significant bit:

	{\| border="1" style="border-collapse: collapse; text-align: center;"		{\| border="1" style="border-collapse: collapse; text-align: center;"

Ian07 at 00:08, 13 February 2021

2021-02-13T00:08:04Z

← Older revision		Revision as of 00:08, 13 February 2021
Line 19:		Line 19:
	There is not yet a generally accepted way of assigning rule integers or numbers to [[non-totalistic Life-like cellular automaton\|non-totalistic]] or [[non-isotropic Life-like cellular automaton\|non-isotropic Life-like cellular automata]].		There is not yet a generally accepted way of assigning rule integers or numbers to [[non-totalistic Life-like cellular automaton\|non-totalistic]] or [[non-isotropic Life-like cellular automaton\|non-isotropic Life-like cellular automata]].

	However, a candidate assignment is used by [[Chris Rowett~~\|Chris Rowett~~'s]] [[LifeViewer]] and [[Golly]] 3.0 as a native rule type for [[Moore_neighbourhood\|Moore]], Hex and [[Von_Neumann_neighborhood\|von Neumann]] neighborhoods.		However, a candidate assignment is used by [[Chris Rowett]]'s [[LifeViewer]] and [[Golly]] 3.0 as a native rule type for [[Moore_neighbourhood\|Moore]], Hex and [[Von_Neumann_neighborhood\|von Neumann]] neighborhoods.

	For the Moore neighborhood the format is as follows: <tt>rule = MAP{base64-encoded 512-bit binary string}</tt>, where the ''n''-th bit in the string gives the output state for a specific set of neighborhood conditions.		For the Moore neighborhood the format is as follows: <tt>rule = MAP{base64-encoded 512-bit binary string}</tt>, where the ''n''-th bit in the string gives the output state for a specific set of neighborhood conditions.

Rowett at 07:50, 12 February 2021

2021-02-12T07:50:37Z

← Older revision		Revision as of 07:50, 12 February 2021
Line 19:		Line 19:
	There is not yet a generally accepted way of assigning rule integers or numbers to [[non-totalistic Life-like cellular automaton\|non-totalistic]] or [[non-isotropic Life-like cellular automaton\|non-isotropic Life-like cellular automata]].		There is not yet a generally accepted way of assigning rule integers or numbers to [[non-totalistic Life-like cellular automaton\|non-totalistic]] or [[non-isotropic Life-like cellular automaton\|non-isotropic Life-like cellular automata]].

	However, a candidate assignment is used by [[~~User:rowett~~\|Chris Rowett's]] [[LifeViewer]] and [[Golly]] 3.0 as a native rule type for [[Moore_neighbourhood\|Moore]], Hex and [[Von_Neumann_neighborhood\|von Neumann]] neighborhoods.		However, a candidate assignment is used by [[Chris Rowett\|Chris Rowett's]] [[LifeViewer]] and [[Golly]] 3.0 as a native rule type for [[Moore_neighbourhood\|Moore]], Hex and [[Von_Neumann_neighborhood\|von Neumann]] neighborhoods.

	For the Moore neighborhood the format is as follows: <tt>rule = MAP{base64-encoded 512-bit binary string}</tt>, where the ''n''-th bit in the string gives the output state for a specific set of neighborhood conditions.		For the Moore neighborhood the format is as follows: <tt>rule = MAP{base64-encoded 512-bit binary string}</tt>, where the ''n''-th bit in the string gives the output state for a specific set of neighborhood conditions.

GUYTU6J: Reformatting the B3/S23 example

2021-02-10T09:37:15Z

Reformatting the B3/S23 example

← Older revision		Revision as of 09:37, 10 February 2021
Line 2:		Line 2:
	The '''rule integer''' of a given outer-totalistic [[Life-like cellular automata\|Life-like cellular automaton]] is a single integer expressing its [[birth]] and [[survival]] conditions.		The '''rule integer''' of a given outer-totalistic [[Life-like cellular automata\|Life-like cellular automaton]] is a single integer expressing its [[birth]] and [[survival]] conditions.

	The rule integer is computed by iterating over all B and S conditions, in order, writing down a one if a condition is present and a zero otherwise, and finally reversing the resulting string and interpreting it as a binary number. For instance, for [[Conway's Game of Life]] (B3/S23):		The rule integer is computed by iterating over all B and S conditions, in order, writing down a one if a condition is present and a zero otherwise, and finally reversing the resulting string and interpreting it as a binary number. For instance, for [[Conway's Game of Life]] (B3/S23), its rule integer is 6152 because:

	:<tt>B0 B1 B2 B3 B4 B5 B6 B7 B8 S0 S1 S2 S3 S4 S5 S6 S7 S8~~</tt>~~		<tt>
	~~:<tt> ~~0 ~~ ~~0 ~~ ~~0 ~~ ~~1 ~~ ~~0 ~~ ~~0 ~~ ~~0 ~~ ~~0 ~~ ~~0 ~~ ~~0 ~~ ~~0 ~~ ~~1 ~~ ~~1 ~~ ~~0 ~~ ~~0 ~~ ~~0 ~~ ~~0 ~~ ~~0 = ~~000100000001100000</tt>~~		{\|
			\|-
	~~:<tt~~>000100000001100000 => 000001100000001000b = 6152d</tt>		\| B0 \|\| B1 \|\| B2 \|\| B3 \|\| B4 \|\| B5 \|\| B6 \|\| B7 \|\| B8 \|\| S0 \|\| S1 \|\| S2 \|\| S3 \|\| S4 \|\| S5 \|\| S6 \|\| S7 \|\| S8
			\|-
			\| 0 \|\| 0 \|\| 0 \|\| 1 \|\| 0 \|\| 0 \|\| 0 \|\| 0 \|\| 0 \|\| 0 \|\| 0 \|\| 1 \|\| 1 \|\| 0 \|\| 0 \|\| 0 \|\| 0 \|\| 0 => 000100000001100000 => 000001100000001000b = 6152d
			\|}</tt>

	Rule integers can also be constructed for hexagonal-neighbourhood rules using similar methods.		Rule integers can also be constructed for hexagonal-neighbourhood rules using similar methods.
Line 18:		Line 21:
	However, a candidate assignment is used by [[User:rowett\|Chris Rowett's]] [[LifeViewer]] and [[Golly]] 3.0 as a native rule type for [[Moore_neighbourhood\|Moore]], Hex and [[Von_Neumann_neighborhood\|von Neumann]] neighborhoods.		However, a candidate assignment is used by [[User:rowett\|Chris Rowett's]] [[LifeViewer]] and [[Golly]] 3.0 as a native rule type for [[Moore_neighbourhood\|Moore]], Hex and [[Von_Neumann_neighborhood\|von Neumann]] neighborhoods.

	For the ~~[[Moore_neighborhood\|~~Moore]] neighborhood the format is as follows: <tt>rule = MAP{base64-encoded 512-bit binary string}</tt>, where the ''n''-th bit in the string gives the output state for a specific set of neighborhood conditions.		For the Moore neighborhood the format is as follows: <tt>rule = MAP{base64-encoded 512-bit binary string}</tt>, where the ''n''-th bit in the string gives the output state for a specific set of neighborhood conditions.

	Numbering the bits starting with 0, bit #0 (&B000000000) is the output state if all neighbors (and the center cell) are OFF, and bit #511 (&B111111111) is the output state if all neighbors (and the center cell) are ON. In between, look up the value of the various ON cells in a neighborhood in the following table:		Numbering the bits starting with 0, bit #0 (&B000000000) is the output state if all neighbors (and the center cell) are OFF, and bit #511 (&B111111111) is the output state if all neighbors (and the center cell) are ON. In between, look up the value of the various ON cells in a neighborhood in the following table:
Line 33:		Line 36:
	The output state is read directly from the 512-bit string, The position in the string is determined by the sum of the values of the ON cells. For example, zero-based bit#85 (=1+4+16+64) specifies what happens to an ON cell (16) if it has ON neighbors to the SE (1), SW (4), and NE (64).		The output state is read directly from the 512-bit string, The position in the string is determined by the sum of the values of the ON cells. For example, zero-based bit#85 (=1+4+16+64) specifies what happens to an ON cell (16) if it has ON neighbors to the SE (1), SW (4), and NE (64).

	For the Hex neighborhood the format is: <tt>rule = MAP{base64-encoded 128-bit binary string}</tt> and for the ~~[[Von_Neumann_neighborhood\|~~von Neumann]] neighborhood the format is: <tt>rule = MAP{base64-encoded 32-bit binary string}</tt>.		For the Hex neighborhood the format is: <tt>rule = MAP{base64-encoded 128-bit binary string}</tt> and for the von Neumann neighborhood the format is: <tt>rule = MAP{base64-encoded 32-bit binary string}</tt>.

	Note the canonical form of MAP rule strings zeroes unused bits in the final base64 character.		Note the canonical form of MAP rule strings zeroes unused bits in the final base64 character.

Muzik at 09:09, 11 December 2018

2018-12-11T09:09:07Z

← Older revision		Revision as of 09:09, 11 December 2018
Line 8:		Line 8:

	:<tt>000100000001100000 => 000001100000001000b = 6152d</tt>		:<tt>000100000001100000 => 000001100000001000b = 6152d</tt>

			Rule integers can also be constructed for hexagonal-neighbourhood rules using similar methods.

	[[apgsearch]] 3.x (apgmera) uses a variant of rule integers to determine the circuitry needed to compute a given rule.		[[apgsearch]] 3.x (apgmera) uses a variant of rule integers to determine the circuitry needed to compute a given rule.

Rowett: /* Non-totalistic and non-isotropic rules */

2017-09-03T09:32:14Z

Non-totalistic and non-isotropic rules

← Older revision		Revision as of 09:32, 3 September 2017
Line 31:		Line 31:
	The output state is read directly from the 512-bit string, The position in the string is determined by the sum of the values of the ON cells. For example, zero-based bit#85 (=1+4+16+64) specifies what happens to an ON cell (16) if it has ON neighbors to the SE (1), SW (4), and NE (64).		The output state is read directly from the 512-bit string, The position in the string is determined by the sum of the values of the ON cells. For example, zero-based bit#85 (=1+4+16+64) specifies what happens to an ON cell (16) if it has ON neighbors to the SE (1), SW (4), and NE (64).

	For the Hex neighborhood the format is: <tt>rule = MAP{base64-encoded 128-bit binary string}</tt> and for the [[Von_Neumann_neighborhood\|von Neumann ~~neighborhood~~]] the format is: <tt>rule = MAP{base64-encoded 32-bit binary string}</tt>.		For the Hex neighborhood the format is: <tt>rule = MAP{base64-encoded 128-bit binary string}</tt> and for the [[Von_Neumann_neighborhood\|von Neumann]] neighborhood the format is: <tt>rule = MAP{base64-encoded 32-bit binary string}</tt>.

	Note the canonical form of MAP rule strings zeroes unused bits in the final base64 character.		Note the canonical form of MAP rule strings zeroes unused bits in the final base64 character.

Rowett: /* Updated MAP for hex and von Neumann neighborhoods */

2017-09-03T09:31:26Z

Updated MAP for hex and von Neumann neighborhoods

← Older revision		Revision as of 09:31, 3 September 2017
Line 14:		Line 14:
	There is not yet a generally accepted way of assigning rule integers or numbers to [[non-totalistic Life-like cellular automaton\|non-totalistic]] or [[non-isotropic Life-like cellular automaton\|non-isotropic Life-like cellular automata]].		There is not yet a generally accepted way of assigning rule integers or numbers to [[non-totalistic Life-like cellular automaton\|non-totalistic]] or [[non-isotropic Life-like cellular automaton\|non-isotropic Life-like cellular automata]].

	However, a candidate assignment is used by [[User:rowett\|Chris Rowett's]] [[LifeViewer]] and ~~will be added to~~ Golly 3.0 as a native rule type: <tt>rule = MAP {base64-encoded 512-bit binary string}</tt>, where the ''n''-th bit in the string gives the output state for a specific set of neighborhood conditions.		However, a candidate assignment is used by [[User:rowett\|Chris Rowett's]] [[LifeViewer]] and [[Golly]] 3.0 as a native rule type for [[Moore_neighbourhood\|Moore]], Hex and [[Von_Neumann_neighborhood\|von Neumann]] neighborhoods.

			For the [[Moore_neighborhood\|Moore]] neighborhood the format is as follows: <tt>rule = MAP{base64-encoded 512-bit binary string}</tt>, where the ''n''-th bit in the string gives the output state for a specific set of neighborhood conditions.

	Numbering the bits starting with 0, bit #0 (&B000000000) is the output state if all neighbors (and the center cell) are OFF, and bit #511 (&B111111111) is the output state if all neighbors (and the center cell) are ON. In between, look up the value of the various ON cells in a neighborhood in the following table:		Numbering the bits starting with 0, bit #0 (&B000000000) is the output state if all neighbors (and the center cell) are OFF, and bit #511 (&B111111111) is the output state if all neighbors (and the center cell) are ON. In between, look up the value of the various ON cells in a neighborhood in the following table:
Line 28:		Line 30:

	The output state is read directly from the 512-bit string, The position in the string is determined by the sum of the values of the ON cells. For example, zero-based bit#85 (=1+4+16+64) specifies what happens to an ON cell (16) if it has ON neighbors to the SE (1), SW (4), and NE (64).		The output state is read directly from the 512-bit string, The position in the string is determined by the sum of the values of the ON cells. For example, zero-based bit#85 (=1+4+16+64) specifies what happens to an ON cell (16) if it has ON neighbors to the SE (1), SW (4), and NE (64).

			For the Hex neighborhood the format is: <tt>rule = MAP{base64-encoded 128-bit binary string}</tt> and for the [[Von_Neumann_neighborhood\|von Neumann neighborhood]] the format is: <tt>rule = MAP{base64-encoded 32-bit binary string}</tt>.

			Note the canonical form of MAP rule strings zeroes unused bits in the final base64 character.

	== Megacell non-totalistic encoding ==		== Megacell non-totalistic encoding ==

Apple Bottom: Also see

2017-07-22T21:17:07Z

Also see

← Older revision		Revision as of 21:17, 22 July 2017
Line 40:		Line 40:
	\| 16 \|\| 32 \|\| 64		\| 16 \|\| 32 \|\| 64
	\|}		\|}

			== Also see ==
			* [[Rulestring]]

← Older revision		Revision as of 08:26, 30 March 2023
Line 1:		Line 1:
	{{Glossary}}		{{Glossary}}
	The '''rule integer''' of a given ~~outer-totalistic~~ [[Life-like ~~cellular automata\|Life-like cellular automaton~~]] is a single integer expressing its [[birth]] and [[survival]] conditions.		The '''rule integer''' of a given [[Life-like rule]] is a single integer expressing its [[birth]] and [[survival]] conditions.

	The rule integer is computed by iterating over all B and S conditions, in order, writing down a one if a condition is present and a zero otherwise, and finally reversing the resulting string and interpreting it as a binary number. For instance, for [[Conway's Game of Life]] (B3/S23), its rule integer is 6152 because:		The rule integer is computed by iterating over all B and S conditions, in order, writing down a one if a condition is present and a zero otherwise, and finally reversing the resulting string and interpreting it as a binary number. For instance, for [[Conway's Game of Life]] (B3/S23), its rule integer is 6152 because:
Line 12:		Line 12:
	\|}</tt>		\|}</tt>

	Rule integers can also be constructed for hexagonal-neighbourhood rules using similar methods.		Rule integers can also be constructed for [[hexagonal neighbourhood]] rules using similar methods.

	[[apgsearch]] 3.x (apgmera) uses a variant of rule integers to determine the circuitry needed to compute a given rule.		[[apgsearch]] 3.x (apgmera) uses a variant of rule integers to determine the circuitry needed to compute a given rule.

	==Non-totalistic and non-isotropic rules==		==Non-totalistic and non-isotropic rules==
	There is not yet a generally accepted way of assigning rule integers or numbers to [[~~non~~-totalistic ~~cellular automaton~~\|non-totalistic]] or [[~~non~~-isotropic ~~cellular automaton~~\|non-isotropic]] ~~cellular automata~~.		There is not yet a generally accepted way of assigning rule integers or numbers to [[Non-totalistic rule\|non-totalistic]] or [[Non-isotropic rule\|non-isotropic]] rules.

	However, a candidate assignment is used by [[Chris Rowett]]'s [[LifeViewer]] and [[Golly]] 3.0 as a native rule type for [[Moore neighbourhood\|Moore]], Hex and [[Von Neumann neighborhood\|von Neumann]] neighborhoods.		However, a candidate assignment is used by [[Chris Rowett]]'s [[LifeViewer]] and [[Golly]] 3.0 as a native rule type for [[Moore neighbourhood\|Moore]], Hex and [[Von Neumann neighborhood\|von Neumann]] neighborhoods.
Line 38:		Line 38:
	For the Hex neighborhood the format is: <tt>rule = MAP{base64-encoded 128-bit binary string}</tt> and for the von Neumann neighborhood the format is: <tt>rule = MAP{base64-encoded 32-bit binary string}</tt>.		For the Hex neighborhood the format is: <tt>rule = MAP{base64-encoded 128-bit binary string}</tt> and for the von Neumann neighborhood the format is: <tt>rule = MAP{base64-encoded 32-bit binary string}</tt>.

	Note the canonical form of MAP rule strings zeroes unused bits in the final base64 character.		Note the canonical form of MAP rule strings zeroes unused bits in the final [[base64]] character.

	== Megacell non-totalistic encoding ==		== Megacell non-totalistic encoding ==