ajusted or() behaviour when Z is input

[Mograsim.git] / era.mi / src / era / mi / logic / Bit.java

diff --git a/era.mi/src/era/mi/logic/Bit.java b/era.mi/src/era/mi/logic/Bit.java
index e7c9396..3f25d77 100644 (file)
--- a/era.mi/src/era/mi/logic/Bit.java
+++ b/era.mi/src/era/mi/logic/Bit.java
@@ -1,95 +1,109 @@
-package era.mi.logic;
-
-public enum Bit
-{
-       ONE, ZERO, Z, X;
-
-       public static Bit and(Bit a, Bit b)
-       {
-               return a.and(b);
-       }
-
-       public Bit and(Bit other)
-       {
-               if (equals(Bit.ZERO) || other.equals(Bit.ZERO))
-                       return Bit.ZERO;
-               else if (equals(other) && equals(Bit.ONE))
-                       return Bit.ONE;
-               else
-                       return Bit.X;
-       }
-
-       public static Bit or(Bit a, Bit b)
-       {
-               return a.or(b);
-       }
-
-       public Bit or(Bit other)
-       {
-               if (equals(Bit.ONE) || other.equals(Bit.ONE))
-                       return Bit.ONE;
-               else if (equals(other) && equals(Bit.ZERO))
-                       return Bit.ZERO;
-               else
-                       return Bit.X;
-       }
-
-       public static Bit xor(Bit a, Bit b)
-       {
-               return a.xor(b);
-       }
-
-       public Bit xor(Bit other)
-       {
-               // I'm uncertain how this should behave for cases where one value is neither 1 nor 0.
-               // TODO: Implement xor
-               return Bit.X;
-       }
-
-       public Bit not()
-       {
-               switch (this)
-                       {
-                       case ONE:
-                               return Bit.ZERO;
-                       case ZERO:
-                               return Bit.ONE;
-                       default:
-                               return Bit.X;
-                       }
-       }
-
-       /**
-        * Rules for two bits that get directly connected<br>
-        * <code><table>
-        * <tbody>
-        * <tr><td><td>X<td>0<td>1<td>Z</tr>
-        * <tr><td>X<td>X<td>X<td>X<td>X</tr>
-        * <tr><td>0<td>X<td>0<td>X<td>0</tr>
-        * <tr><td>1<td>X<td>X<td>1<td>1</tr>
-        * <tr><td>Z<td>X<td>0<td>1<td>Z</tr>
-        * </tbody>
-        * </table><code>
-        * 
-        * @return the result according to the table
-        * 
-        * @author Christian Femers
-        */
-       public Bit combineWith(Bit other)
-       {
-               if (this == other)
-                       return this;
-               if (this == X || other == X)
-                       return X;
-               if (other == Z)
-                       return this;
-               if (this == Z)
-                       return other;
-               return X;
-       }
-
-       public static Bit combine(Bit a, Bit b)
-       {
-               return a.combineWith(b);
-       }
-}
+package era.mi.logic;\r
+\r
+import java.util.Arrays;\r
+\r
+public enum Bit\r
+{\r
+       ONE, ZERO, Z, X;\r
+\r
+       public static Bit and(Bit a, Bit b)\r
+       {\r
+               return a.and(b);\r
+       }\r
+\r
+       public Bit and(Bit other)\r
+       {\r
+               if (this == ZERO || other == ZERO)\r
+                       return ZERO;\r
+               else if (this == other && this == ONE)\r
+                       return ONE;\r
+               else if (this == X || other == X)\r
+                       return X;\r
+               else\r
+                       return ZERO;\r
+       }\r
+\r
+       public static Bit or(Bit a, Bit b)\r
+       {\r
+               return a.or(b);\r
+       }\r
+\r
+       public Bit or(Bit other)\r
+       {\r
+               if (this == ONE || other == ONE)\r
+                       return ONE;\r
+               else if (this == other && this == ZERO)\r
+                       return ZERO;\r
+               else if (this == X || other == X)\r
+                       return X;\r
+               else\r
+                       return ZERO;\r
+       }\r
+\r
+       public static Bit xor(Bit a, Bit b)\r
+       {\r
+               return a.xor(b);\r
+       }\r
+\r
+       public Bit xor(Bit other)\r
+       {\r
+               if(this == X || this == Z || other == X || other == Z)\r
+                       return Bit.X;\r
+               else\r
+                       return this == other ? ZERO : ONE;\r
+       }\r
+\r
+       public Bit not()\r
+       {\r
+               switch (this)\r
+                       {\r
+                       case ONE:\r
+                               return Bit.ZERO;\r
+                       case ZERO:\r
+                               return Bit.ONE;\r
+                       default:\r
+                               return Bit.X;\r
+                       }\r
+       }\r
+       \r
+       public Bit[] makeArray(int length)\r
+       {\r
+               Bit[] bits = new Bit[length];\r
+               Arrays.fill(bits, this);\r
+               return bits;\r
+       }\r
+\r
+       /**\r
+        * Rules for two bits that get directly connected<br>\r
+        * <code><table>\r
+        * <tbody>\r
+        * <tr><td><td>X<td>0<td>1<td>Z</tr>\r
+        * <tr><td>X<td>X<td>X<td>X<td>X</tr>\r
+        * <tr><td>0<td>X<td>0<td>X<td>0</tr>\r
+        * <tr><td>1<td>X<td>X<td>1<td>1</tr>\r
+        * <tr><td>Z<td>X<td>0<td>1<td>Z</tr>\r
+        * </tbody>\r
+        * </table><code>\r
+        * \r
+        * @return the result according to the table\r
+        * \r
+        * @author Christian Femers\r
+        */\r
+       public Bit combineWith(Bit other)\r
+       {\r
+               if (this == other)\r
+                       return this;\r
+               if (this == X || other == X)\r
+                       return X;\r
+               if (other == Z)\r
+                       return this;\r
+               if (this == Z)\r
+                       return other;\r
+               return X;\r
+       }\r
+\r
+       public static Bit combine(Bit a, Bit b)\r
+       {\r
+               return a.combineWith(b);\r
+       }\r
+}\r