(ns chipper.examples
  (:use chipper.core
        chipper.gates
        chipper.utils))

;; The Chipper DSL describes a simple DSL to build logic gates from basic logic operators. Once a gate is defined it can be used in clojure.

;; we can use basic logic gates defined in chipper.gates
;; Remember that we cannot put DSL expressions like gates or primitives as arguments of already built gates. The DSL is for describing new gates and primitives and not for chaining them in pure clojure
;; since they return lists but take distinct arguments as inputs (It is not impossible though, we can access the list values...it just isn't designed for this purpose)

(and* 0 0) ;; [0]
(and* 1 1) ;; [1]
(and* 1 0) ;; [0]

;; now let us define our own logic gate with this DSL. As a simple example we can use a half adder. A half adder adds two bits without an incoming carry and returns the result and an oiutcoming carry value
;; A half adder is simple: we XOR a and b and get the output bit s. Then we AND a and b and get the carry bit c.

(defgate halfadd* [a b] => [c s]
  (xor* [a b] => [s])
  (and* [a b] => [c]))

;; we now can run our new gate
;; the expected table is
;; a   b   s   c
;; 0   0   0   0
;; 1   0   1   0
;; 0   1   1   0
;; 1   1   0   1

(halfadd* 0 0) ;; [0 0] first value is c second is s
(halfadd* 1 0) ;; [0 1]
(halfadd* 0 1) ;; [0 1]
(halfadd* 1 1) ;; [1 0]

;; lets build a full adder. It is basically like the half adder but it accepts an incoming carry value

(defgate fulladd* [a b cin] => [c s]
  (xor* [a b] => [ab1])
  (and* [ab1 cin] => [abcin])
  (and* [a b] => [ab2])
  (or* [ab2 abcin] => [c])
  (xor* [ab1 cin] => [s]))

;; we now can run our new gate
;; the expected table is
;; a   b   cin   s   c
;; 0   0   0     0   0
;; 0   0   1     0   1
;; 0   1   0     0   1
;; 0   1   1     1   0
;; 1   0   0     0   1
;; 1   0   1     1   0
;; 1   1   0     1   0
;; 1   1   1     1   1

(fulladd* 0 0 0) ;; [0 0] first value is s second is c
(fulladd* 0 0 1) ;; [0 1]
(fulladd* 0 1 0) ;; [0 1]
(fulladd* 0 1 1) ;; [1 0]
(fulladd* 1 0 0) ;; [0 1]
(fulladd* 1 0 1) ;; [1 0]
(fulladd* 1 1 0) ;; [1 0]
(fulladd* 1 1 1) ;; [1 1]

;; Chipper does not come with high/low primitives which represent a 1 and 0. This is not necessary but is useful for understanding the concept behind this DSL
;; high* maps from [] to [1]
;; low* maps from [] to [0]
;; Remember that these primitives extend the DSL and not our clojure context, therefore we cannot put high and low as arguments of built logic gate like and*

(defprimitive high* [] => [out]
  [1])

(defprimitive low* [] => [out]
  [0])

;; lets build a 4 bit adder, we use the low* primitive as the incoming carry (0) just for showcasing the usage. we could use a halfadder or just the correct nand value (nand is primitive
;; wich makes this DSL functionally complete, everything is made of nands)

(defgate fourbitadd* [x1 x2 x3 x4 y1 y2 y3 y4] => [c s1 s2 s3 s4]
  (low* [] => [c4])
  (fulladd* [x4 y4 c4] => [c3 s4])
  (fulladd* [x3 y3 c3] => [c2 s3])
  (fulladd* [x2 y2 c2] => [c1 s2])
  (fulladd* [x1 y1 c1] => [c s1]))

;; correct values can be looked up on the internet or just calculated
(fourbitadd* 0 0 0 0, 0 0 0 0) ;; the comma is interpreted as a space, therefore it can be used for a better visualization [c=0 res = 0 0 0 0]
(fourbitadd* 1 0 0 0, 1 0 0 0) ;; [c=1 res = 0 0 0 0]
(fourbitadd* 0 1 1 1, 0 0 0 1) ;; [c=0 res = 1 0 0 0]