Changeset 64

Timestamp:

Sep 13, 2010, 12:59:27 PM (10 years ago)

Author:

mulligan

Message:

More work on bits, bytes and nibbles.

Location:

Deliverables/D4.1

Files:

• Bit.ml (modified) (1 diff)
• Byte.ml (modified) (2 diffs)
• Nibble.ml (modified) (3 diffs)

Deliverables/D4.1/Bit.ml

@@ -22 +22 @@
   val (-^-): bit -> bit -> bit
   val not: bit -> bit
-
 end;;
 

Deliverables/D4.1/Byte.ml

@@ -30 +30 @@
   val get_bit_at: int -> byte -> bit
   val set_bit_at: int -> bit -> byte -> byte option
+*)
 
   val (-&-): byte -> byte -> byte
   val (-|-): byte -> byte -> byte
   val (-^-): byte -> byte -> byte
+(*
+  val rotate_right: byte -> byte
+  val rotate_left: byte -> byte
+  val shift_right: byte -> byte
+  val shift_left: byte -> byte
+*)
   val not: byte -> byte
 
+(*
   val map_nibble: (nibble -> nibble) -> byte -> byte
   val map_bit: (bit -> bit) -> byte -> byte
@@ -42 +50 @@
   val zip_nibble: (nibble -> nibble -> nibble) -> byte -> byte -> byte
   val zip_bit: (bit -> bit -> bit) -> byte -> byte -> byte
-  val pretty: byte -> string
+  val to_string: byte -> string
 *)
 end
 
-module Byte(Nibble: NIBBLE): BYTE
-  with type bit = Nibble.bit and type nibble = Nibble.nibble =
+module Byte(Bit: BIT) (Nibble: NIBBLE): BYTE
+  with type Nibble.bit = Bit.bit
+  and  type nibble = Nibble.nibble =
 struct
-  type bit = Nibble.bit
+  type bit = Bit.bit
   type nibble = Nibble.nibble
   type byte = nibble * nibble
 
-  let from_bits b1 b2 b3 b4 b5 b6 b7 b8 =
-    let nibble 
+  let (-&-) (l1, l2) (r1, r2) = (Nibble.(-&-) l1 r1, Nibble.(-&-) l2 r2)
+  let (-|-) (l1, l2) (r1, r2) = (Nibble.(-|-) l1 r1, Nibble.(-|-) l2 r2)
+  let (-^-) (l1, l2) (r1, r2) = (Nibble.(-^-) l1 r1, Nibble.(-^-) l2 r2)
+(*
+  let shift_right (n1, n2) =
+    let (b1, b2, b3, b4) = Nibble.to_bits n1 in
+    let (b5, b6, b7, b8) = Nibble.to_bits n2 in
+    let new_n1 = Nibble.from_bits (Bit.from_bool false) b1 b2 b3 in
+    let new_n2 = Nibble.from_bits b4 b5 b6 b7 in
+      (new_n1, new_n2)
+  let shift_left (n1, n2) =
+    let (b1, b2, b3, b4) = Nibble.to_bits n1 in
+    let (b5, b6, b7, b8) = Nibble.to_bits n2 in
+    let new_n1 = Nibble.from_bits b1 b2 b3 b4 in
+    let new_n2 = Nibble.from_bits b5 b6 b7 (Bit.from_bool false) in
+      (new_n1, new_n2)
+  let rotate_right (n1, n2) =
+    let (b1, b2, b3, b4) = Nibble.to_bits n1 in
+    let (b5, b6, b7, b8) = Nibble.to_bits n2 in
+    let new_n1 = Nibble.from_bits b8 b1 b2 b3 in
+    let new_n2 = Nibble.from_bits b4 b5 b6 b7 in
+      (new_n1, new_n2)
+  let rotate_left (n1, n2) =
+    let (b1, b2, b3, b4) = Nibble.to_bits n1 in
+    let (b5, b6, b7, b8) = Nibble.to_bits n2 in
+    let new_n1 = Nibble.from_bits b2 b3 b4 b5 in
+    let new_n2 = Nibble.from_bits b5 b6 b7 b1 in
+      (new_n1, new_n2)
+*)
+  let not (n1, n2) = (Nibble.not n1, Nibble.not n2)
 end

Deliverables/D4.1/Nibble.ml

@@ -17 +17 @@
   val from_bit: bit -> nibble
   val from_int: int -> nibble option
-  val from_string: string -> nibble option
+  (* val from_string: string -> nibble option *)
 
   val to_bits: nibble -> (bit * bit * bit * bit)
@@ -30 +30 @@
   val (-|-): nibble -> nibble -> nibble
   val (-^-): nibble -> nibble -> nibble
+  val rotate_right: nibble -> nibble
+  val rotate_left: nibble -> nibble
+  val shift_right: nibble -> nibble
+  val shift_left: nibble -> nibble
   val not: nibble -> nibble
-
-  val swap_bits: nibble -> nibble
 
   val map_bit: (bit -> bit) -> nibble -> nibble
@@ -65 +67 @@
     | 15 -> Some (Bit.from_int 1, Bit.from_int 1, Bit.from_int 1, Bit.from_int 1)
     | _ -> None
-  let from_string
 
-  let to_bit (l, h) =
-    let (bl, bh) = Bit.to_bool l, Bit.to_bool h in
-    match (bl, bh) with
-      (false, b) -> Some (Bit.from_bool b)
-    | (true, b) -> None
-  let to_int (l, h) = (2 * Bit.to_int l) + Bit.to_int h
+  let to_bit (b1, b2, b3, b4) =
+    let (d1, d2, d3, d4) = Bit.to_bool b1, Bit.to_bool b2, Bit.to_bool b3, Bit.to_bool b4 in
+    match (d1, d2, d3, d4) with
+      (false, false, false, b) -> Some (Bit.from_bool b)
+   |  _ -> None
+  let to_bits (b1, b2, b3, b4) = (b1, b2, b3, b4)
+  let to_int (b1, b2, b3, b4) = (8 * Bit.to_int b1) + (4 * Bit.to_int b2) + 
+                                (2 * Bit.to_int b3) + Bit.to_int b4
+
+  let get_bit_at index (b1, b2, b3, b4) =
+    match index with
+      0 -> Some b4
+    | 1 -> Some b3
+    | 2 -> Some b2
+    | 3 -> Some b1
+    | _ -> None
+
+  let set_bit_at index new_bit (b1, b2, b3, b4) =
+    match index with
+      0 -> Some (b1, b2, b3, new_bit)
+    | 1 -> Some (b1, b2, new_bit, b4)
+    | 2 -> Some (b1, new_bit, b3, b4)
+    | 3 -> Some (new_bit, b2, b3, b4)
+    | _ -> None
+
+  let (-&-) (l1, l2, l3, l4) (r1, r2, r3, r4) =
+     (Bit.(-&-) l1 r1, Bit.(-&-) l2 r2, Bit.(-&-) l3 r3, Bit.(-&-) l4 r4)
+  let (-|-) (l1, l2, l3, l4) (r1, r2, r3, r4) =
+     (Bit.(-|-) l1 r1, Bit.(-|-) l2 r2, Bit.(-|-) l3 r3, Bit.(-|-) l4 r4)
+  let (-^-) (l1, l2, l3, l4) (r1, r2, r3, r4) =
+     (Bit.(-^-) l1 r1, Bit.(-^-) l2 r2, Bit.(-^-) l3 r3, Bit.(-^-) l4 r4)
+  let rotate_right (b1, b2, b3, b4) = (b4, b1, b2, b3)
+  let rotate_left (b1, b2, b3, b4) = (b2, b3, b4, b1)
+  let shift_right (b1, b2, b3, b4) = (Bit.from_bool false, b1, b2, b3)
+  let shift_left (b1, b2, b3, b4) = (b2, b3, b4, Bit.from_bool false)
+  let not (b1, b2, b3, b4) = (Bit.not b1, Bit.not b2, Bit.not b3, Bit.not b4)
+
+  let map_bit f (b1, b2, b3, b4) = (f b1, f b2, f b3, f b4)
+  let iter_bit f (b1, b2, b3, b4) =
+    let str_b1 = f b1 in
+    let str_b2 = f b2 in
+    let str_b3 = f b3 in
+    let str_b4 = f b4 in
+      str_b1 ^ str_b2 ^ str_b3 ^ str_b4
+  let zip_bit f (l1, l2, l3, l4) (r1, r2, r3, r4) = (f l1 r1, f l2 r2, f l3 r3, f l4 r4)
+
   let to_string = iter_bit Bit.to_string
-
-  let get_bit_at index (l, h) =
-    if index = 0 then
-      Some l
-    else if index = 1 then
-      Some h
-    else
-      None
-
-  let set_bit_at index new_bit (l, h) =
-    if index = 0 then
-      Some (new_bit, h)
-    else if index = 1 then
-      Some (l, new_bit)
-    else
-      None
-
-  let (-&-) (l1,h1) (l2, h2) =
-     (Bit.(-&-) l1 l2, Bit.(-&-) h1 h2)
-  let (-|-) (l1,h1) (l2, h2) =
-     (Bit.(-|-) l1 l2, Bit.(-|-) h1 h2)
-  let (-^-) (l1,h1) (l2, h2) =
-     (Bit.(-^-) l1 l2, Bit.(-^-) h1 h2)
-
-  let not (l, h) = (Bit.not l, Bit.not h)
-
-  let swap_bits (l, h) = (h, l)
-
-  let map_bit f (l, h) = (f l, f h)
-  let iter_bit f (l, h) =
-    let str_l = f l in
-    let str_h = f h in
-      str_l ^ str_h
-  let zip_bit f (l1, h1) (l2, h2) = (f l1 l2, f l2 h2)
 end