User:Carsten Milkau/NOT Gate - Revision history

93.209.203.39: /* Implementation */

2023-07-15T04:00:59Z

Implementation

← Older revision		Revision as of 04:00, 15 July 2023
Line 26:		Line 26:
	NOT gates can often be avoided by modifying the circuit. For instance, an [[User:Carsten Milkau/OR Gate\|OR Gate]] with two NOT gates connected to its inputs and outputs can always be replaced by an AND gate with just one NOT gate connected.		NOT gates can often be avoided by modifying the circuit. For instance, an [[User:Carsten Milkau/OR Gate\|OR Gate]] with two NOT gates connected to its inputs and outputs can always be replaced by an AND gate with just one NOT gate connected.

	~~Unfortunately, there is no single-component implementation of a NOT gate~~. ~~However~~, ~~if you happen~~ to ~~have a data signal with a known value (like a memory containing a constant), often you can feed this signal into a single component in order~~ to ~~turn it into a NOT gate~~.		=== Single Block ===

			[[File:CompareUnit.png\|thumb]]

			Use the Gate Unit, set it to Nor and both inputs to the same Logic Reader.

	=== Using A Less-Than Comparator ===		=== Using A Less-Than Comparator ===

89.16.148.86: /* Definition */ names x and y for inputs/outputs in truth table

2018-07-22T12:13:11Z

Definition: names x and y for inputs/outputs in truth table

← Older revision		Revision as of 12:13, 22 July 2018
Line 8:		Line 8:
	\|+ value table		\|+ value table
	\|-		\|-
	!~~input~~ \|\| ~~output~~		!'''inputs''' \|\| '''outputs'''
			\|-
			!x \|\| y
	\|-		\|-
	\|0\|\|1		\|0\|\|1

89.16.148.86: /* Connectors */ y again

2018-07-22T12:11:58Z

Connectors: y again

← Older revision		Revision as of 12:11, 22 July 2018
Line 17:		Line 17:
	=== Connectors ===		=== Connectors ===

	* Input: one of two values (0 or 1)		* Input x: one of two values (0 or 1)
	* Output: the other of the two values		* Output y: the other of the two values

	== Implementation ==		== Implementation ==

89.16.148.86 at 12:10, 22 July 2018

2018-07-22T12:10:58Z

← Older revision		Revision as of 12:10, 22 July 2018
Line 32:		Line 32:
	If you have a circuit available (e.g. a constant memory) that has a value ''b'' known to stay between 0 and 1 (but not 0), you can turn a [[Kit (Logic Processor)#Compare Unit\|Compare Unit]] into a logic NOT gate by comparing the input ''x'' to ''b'', i.e.		If you have a circuit available (e.g. a constant memory) that has a value ''b'' known to stay between 0 and 1 (but not 0), you can turn a [[Kit (Logic Processor)#Compare Unit\|Compare Unit]] into a logic NOT gate by comparing the input ''x'' to ''b'', i.e.

	<pre>~~not_x~~ = (x < b)</pre>		<pre>y = (x < b)</pre>

	{\| class="wikitable"		{\| class="wikitable"
Line 54:		Line 54:
	If you have a circuit output available that is known to be zero when the NOT gate is used (e.g. a constant memory), you can turn a [[Kit (Logic Processor)#Compare Unit\|Compare Unit]] into a logic NOT gate by comparing the input ''x'' to ''0'', i.e.		If you have a circuit output available that is known to be zero when the NOT gate is used (e.g. a constant memory), you can turn a [[Kit (Logic Processor)#Compare Unit\|Compare Unit]] into a logic NOT gate by comparing the input ''x'' to ''0'', i.e.

	<pre>~~not_x~~ = (x = 0)</pre>		<pre>y = (x = 0)</pre>

	{\| class="wikitable"		{\| class="wikitable"

89.16.148.86: /* Using Subtraction */

2018-07-22T12:10:09Z

Using Subtraction

← Older revision		Revision as of 12:10, 22 July 2018
Line 71:		Line 71:

	=== Using Subtraction ===		=== Using Subtraction ===

			[[File:MathUnit.png\|thumb]]

			If you do not use 0 and 1 as the two possible input values of the inverter, you can use subtraction for implementation. In this case, you need a constant that is exactly the mean of the two input values, i.e.

			<pre>y = (m - x)</pre>

			where m = (a + b)/2 is the mean of the two allowed input values, (called ''a'' and ''b'' here).

			{\| class="wikitable"
			\|+ Circuit setup
			\|-
			! unit \|\| unit type \|\| connector/setting \|\| source/value
			\|-
			\| math 1 \|\| [[Kit (Logic Processor)#Math Unit\|Math Unit]] \|\| Input 1 \|\| x '''(input)'''
			\|-
			\| \|\| \|\| Input 2 \|\| m (constant, see above)
			\|-
			\| \|\| \|\| Operation \|\| Subtract
			\|-
			\| \|\| \|\| Output \|\| y '''(output)'''
			\|}

89.16.148.86 at 11:53, 22 July 2018

2018-07-22T11:53:33Z

← Older revision		Revision as of 11:53, 22 July 2018
Line 41:		Line 41:
	\|compare 1 \|\| Compare Unit \|\| Input 1 \|\| x '''(input)'''		\|compare 1 \|\| Compare Unit \|\| Input 1 \|\| x '''(input)'''
	\|-		\|-
	\| \|\| \|\| Input 2 \|\| ''b'' (constant or ~~bound~~ value)		\| \|\| \|\| Input 2 \|\| ''b'' (constant or bounded value)
	\|-		\|-
	\| \|\| \|\| Operation Selector \|\| Lesser		\| \|\| \|\| Operation Selector \|\| Lesser

89.16.148.86 at 11:51, 22 July 2018

2018-07-22T11:51:25Z

← Older revision		Revision as of 11:51, 22 July 2018
Line 49:		Line 49:

	=== Using An Equality Comparator ===		=== Using An Equality Comparator ===

			[[File:CompareUnit.png\|thumb]]

			If you have a circuit output available that is known to be zero when the NOT gate is used (e.g. a constant memory), you can turn a [[Kit (Logic Processor)#Compare Unit\|Compare Unit]] into a logic NOT gate by comparing the input ''x'' to ''0'', i.e.

			<pre>not_x = (x = 0)</pre>

			{\| class="wikitable"
			\|+ circuit setup
			\|-
			! unit \|\| unit type \|\| connector/setting \|\| source / value
			\|-
			\|compare 1 \|\| Compare Unit \|\| Input 1 \|\| x '''(input)'''
			\|-
			\| \|\| \|\| Input 2 \|\| 0 (constant)
			\|-
			\| \|\| \|\| Operation Selector \|\| Equals
			\|-
			\| \|\| \|\| Output \|\| y '''(output)'''
			\|}

	=== Using Subtraction ===		=== Using Subtraction ===

89.16.148.86 at 11:48, 22 July 2018

2018-07-22T11:48:01Z

@@ Line 27: / Line 27: @@
 === Using A Less-Than Comparator ===
 === Using An Equality Comparator ===
 === Using Subtraction ===

89.16.148.86: /* Implementation */ Improved example of NOT gate elimination

2018-07-22T10:35:00Z

Implementation: Improved example of NOT gate elimination

← Older revision		Revision as of 10:35, 22 July 2018
Line 22:		Line 22:
	== Implementation ==		== Implementation ==

	NOT gates can often be avoided by modifying the circuit. For instance, ~~if you use the output of a NOT gate to control the selector input of a~~ [[~~Kit (Logic Processor)#Logic Select Unit~~\|~~Logic Select Unit~~]]~~, you can just switch the~~ two inputs with ~~each other instead and eleminate the~~ NOT gate.		NOT gates can often be avoided by modifying the circuit. For instance, an [[User:Carsten Milkau/OR Gate\|OR Gate]] with two NOT gates connected to its inputs and outputs can always be replaced by an AND gate with just one NOT gate connected.

	Unfortunately, there is no single-component implementation of a NOT gate. However, if you happen to have a data signal with a known value (like a memory containing a constant), often you can feed this signal into a single component in order to turn it into a NOT gate.		Unfortunately, there is no single-component implementation of a NOT gate. However, if you happen to have a data signal with a known value (like a memory containing a constant), often you can feed this signal into a single component in order to turn it into a NOT gate.

Carsten Milkau: Created page with "= NOT Gate = A NOT gate, sometimes also called ''inverter'', is a circuit that outputs the value that was not input. It has a single input and output, and each can only take..."

2018-07-19T17:49:17Z

Created page with "= NOT Gate = A NOT gate, sometimes also called ''inverter'', is a circuit that outputs the value that was not input. It has a single input and output, and each can only take..."

New page

= NOT Gate =

A NOT gate, sometimes also called ''inverter'', is a circuit that outputs the value that was not input. It has a single input and output, and each can only take one of two pre-defined values (typically 0 and 1). Whatever the input value is selected, the output value will be the other of the two.

== Definition ==

{| class="wikitable"
|+ value table
|-
!input || output
|-
|0||1
|-
|1||0
|}

=== Connectors ===

* Input: one of two values (0 or 1)
* Output: the other of the two values

== Implementation ==

NOT gates can often be avoided by modifying the circuit. For instance, if you use the output of a NOT gate to control the selector input of a [[Kit (Logic Processor)#Logic Select Unit|Logic Select Unit]], you can just switch the two inputs with each other instead and eleminate the NOT gate.

Unfortunately, there is no single-component implementation of a NOT gate. However, if you happen to have a data signal with a known value (like a memory containing a constant), often you can feed this signal into a single component in order to turn it into a NOT gate.

=== Using A Less-Than Comparator ===
=== Using An Equality Comparator ===
=== Using Subtraction ===