lambdaway :: 4bit

2 | list | login |load

| |

_h1 four bit adder | [[4bit_adder2]]

{center
 {img {@ src="http://rosettacode.org/mw/images/7/76/Xor.png" width="30%"}}
 {img {@ src="http://rosettacode.org/mw/images/2/20/Fulladder.png" width="30%"}}
 {img {@ src="http://rosettacode.org/mw/images/0/0e/4bitsadder.png" width="30%"}}
 {h3 XOR | fullAdder | 4bitsAdder}
}

_ul [[http://rosettacode.org/wiki/Four_bit_adder| http://rosettacode.org/wiki/Four_bit_adder]]
_ul [[XOR|http://www.howtocreate.co.uk/xor.html]]

_h2 1) adding booleans

{prewrap

1.1) NOT, AND & OR are builtin "gates", we have to define the "XOR" gate

'{def xor
 {lambda {:a :b} 
  {or {and :a {not :b}}
      {and :b {not :a}}}}}
-> {def xor
 {lambda {:a :b} 
  {or {and :a {not :b}} {and :b {not :a}}}}}

1.2) the halfAdder HA has two inputs [A,B] and two outputs [S,C], sum and carry

'{def halfAdder
 {lambda {:a :b}
  {cons {and :a :b} 
        {xor :a :b}}}}
-> {def halfAdder
 {lambda {:a :b}
  {cons {and :a :b} {xor :a :b}}}}

1.3) the fullAdder combines two HA with three inputs [A,B,C0] and two outputs [S,C1]

'{def fullAdder 
 {lambda {:a :b :c}
  {let { {:b :b}
         {:ha1 {halfAdder :c :a}} }
   {let { {:ha1 :ha1}
          {:ha2 {halfAdder {cdr :ha1} :b}} }
         {cons {or {car :ha1} {car :ha2}} 
               {cdr :ha2}} }}}}
-> {def fullAdder 
 {lambda {:a :b :c}
  {let { {:ha1 {halfAdder :c :a}} {:b :b} }
   {let { {:ha1 :ha1}
          {:ha2 {halfAdder {cdr :ha1} :b}} }
        {cons {or {car :ha1} {car :ha2}} {cdr :ha2}} }}}}

1.4) the 4bitsAdder combines four fullAdders FA with nine inputs the value 0, [a0,a1,a2,a3] and [b0,b1,b2,b3] and five outputs [s0,s1,s2,s3] and v, the carry

'{def 4bitsAdder
 {lambda {:a4 :a3 :a2 :a1 :b4 :b3 :b2 :b1}
  {let { {:a4 :a4} {:a3 :a3} {:a2 :a2}
         {:b4 :b4} {:b3 :b3} {:b2 :b2}
         {:fa1 {fullAdder :a1 :b1 false}} }  // false is v
   {let { {:a4 :a4} {:a3 :a3}
          {:b4 :b4} {:b3 :b3}
          {:fa1 :fa1} 
          {:fa2 {fullAdder :a2 :b2 {car :fa1}}} }
    {let { {:a4 :a4}
           {:b4 :b4}
           {:fa1 :fa1}
           {:fa2 :fa2} 
           {:fa3 {fullAdder :a3 :b3 {car :fa2}}} }
     {let { {:fa1 :fa1}
            {:fa2 :fa2}
            {:fa3 :fa3}
            {:fa4 {fullAdder :a4 :b4 {car :fa3}}} }
          {car :fa4}
          {cdr :fa4} {cdr :fa3} {cdr :fa2} {cdr :fa1}}}}}}}
-> {def 4bitsAdder
 {lambda {:a4 :a3 :a2 :a1 :b4 :b3 :b2 :b1}
  {let { {:a4 :a4} {:a3 :a3} {:a2 :a2} {:b4 :b4} {:b3 :b3} {:b2 :b2}
         {:fa1 {fullAdder :a1 :b1 false}} }
   {let { {:a4 :a4} {:a3 :a3} {:b4 :b4} {:b3 :b3}
          {:fa1 :fa1} 
          {:fa2 {fullAdder :a2 :b2 {car :fa1}}} }
    {let { {:a4 :a4} {:b4 :b4}
           {:fa1 :fa1} {:fa2 :fa2} 
           {:fa3 {fullAdder :a3 :b3 {car :fa2}}} }
     {let { {:fa1 :fa1} {:fa2 :fa2} {:fa3 :fa3}
            {:fa4 {fullAdder :a4 :b4 {car :fa3}}} }
      {car :fa4} {cdr :fa4} {cdr :fa3} {cdr :fa2} {cdr :fa1}}}}}}}
}

_p Don't forget that the {code '{let { {arg val} ... } expression}} is a syntactic sugar for {code '{{lambda {args} expression} vals}} making things more readable. Taking in account that booleans can be defined as lambda expressions - see [[fromroots2canopy]] - and that the {code '{def name expression}} special form is optional and could be forgotten, writing {code '{4bitsAdder bool ... bool}} could be reduced to a (huge and convoluted) expression containing nothing but words and lambdas. It's binary arithmetic at the lambda calculus level.

_h2 test

{pre
'{4bitsAdder false false false true       //    0001
            false false false true}      // +  0001
->    {4bitsAdder false false false true false false false true}       // = 00010

'{4bitsAdder true true true true          //    1111
            false false false true}      // +  0001
->     {4bitsAdder true true true true false false false true}      // = 10000
  
}

_h2 2) from booleans to 4-bits and decimals

_p We translate the sets of booleans into 4bits numbers, then into decimal numbers

{pre
'{def bin2bool 
 {lambda {:b}
  {if {W.empty? {W.rest :b}}
   then {= {W.first :b} 1}
   else {= {W.first :b} 1} {bin2bool {W.rest :b}}}}}
-> {def bin2bool 
 {lambda {:b}
  {if {W.empty? {W.rest :b}}
   then {= {W.first :b} 1}
   else {= {W.first :b} 1} {bin2bool {W.rest :b}}}}}

'{def bool2bin
 {lambda {:b}
  {if {S.empty? {S.rest :b}}
   then {if {S.first :b} then 1 else 0} 
   else {if {S.first :b} then 1 else 0}{bool2bin {S.rest :b}}}}}
-> {def bool2bin
 {lambda {:b}
  {if {S.empty? {S.rest :b}}
   then {if {S.first :b} then 1 else 0} 
   else {if {S.first :b} then 1 else 0}{bool2bin {S.rest :b}}}}}

'{def bin2dec
 {def bin2dec.r
  {lambda {:p :r}
   {if {A.empty? :p}
    then :r
    else {bin2dec.r {A.rest :p} {+ {A.first :p} {* 2 :r}}}}}}
 {lambda {:p} {bin2dec.r {A.split :p} 0}}}
-> {def bin2dec
 {def bin2dec.r
  {lambda {:p :r}
   {if {A.empty? :p}
    then :r
    else {bin2dec.r {A.rest :p} {+ {A.first :p} {* 2 :r}}}}}}
 {lambda {:p} {bin2dec.r {A.split :p} 0}}}

'{def add
 {def numbers 0000 0001 0010 0011 0100 0101 0110 0111
              1000 1001 1010 1011 1100 1101 1110 1111}
 {lambda {:a :b}
  {bin2dec
   {bool2bin
    {4bitsAdder {bin2bool {S.get :a {numbers}}}
                {bin2bool {S.get :b {numbers}}}}}}}}
-> {def add
 {def numbers 0000 0001 0010 0011 0100 0101 0110 0111
              1000 1001 1010 1011 1100 1101 1110 1111}
 {lambda {:a :b}
  {bin2dec
   {bool2bin
    {4bitsAdder {bin2bool {S.get :a {numbers}}}
                {bin2bool {S.get :b {numbers}}}}}}}}
}

_h2 addition table

_p We build the addition table to numbers from 0 to 15, ie hexadecimal numbers

{pre
'{table
 {S.map {lambda {:i} {tr
  {S.map {{lambda {:i :j} {td {add :i :j}}} :i}  
  {S.serie 0 15}}}} 
 {S.serie 0 15}}
}
->
 {center {table
 {S.map {lambda {:i} {tr
  {S.map {{lambda {:i :j} {td {add :i :j}}} :i}  
  {S.serie 0 15}}}} 
 {S.serie 0 15}} 
}}

}

_p We have built a masterpiece of the processing unit.

_h2 from python ([[Jean-Paul Roy|http://jean.paul.roy.free.fr/]])

_ul [[exo_resist.py|http://jean.paul.roy.free.fr/PAA/src/exo_resist.py]]

{pre
Un circuit parmi d'autres:

|---r2----r3---|
•---r1---|              |---•
         |------r4------|
}

_h3 python

{pre
def serie(r1,r2) :               # résistors en série
    return r1 + r2

def parallele(r1,r2) :           # résistors en parallèle
    return r1 * r2 / (r1 + r2)   # 1/(1/r1 + 1/r2)

def circuit(r1,r2,r3,r4) :       # le circuit dessiné
    return serie(r1,parallele(serie(r2,r3),r4))

# Résister à la tentation de tout coder dans une seule fonction.
# Faire apparaître la structure de la solution...

print('La résistance totale du circuit est',circuit(5,20,25,80),'ohms')
}

_h3 lambdatalk

{pre
'{def serie
 {lambda {:r1 :r2} {+ :r1 :r2}}}
-> {def serie
 {lambda {:r1 :r2} {+ :r1 :r2}}}

'{def parallele
 {lambda {:r1 :r2} {/ {* :r1 :r2}
                      {+ :r1 :r2}}}}
-> {def parallele {lambda {:r1 :r2} {/ {* :r1 :r2} {+ :r1 :r2}}}}

'{def circuit
 {lambda {:r1 :r2 :r3 :r4}
  {serie :r1 {parallele {serie :r2  :r3}
                                 :r4}}}}
-> {def circuit   {lambda {:r1 :r2 :r3 :r4} {serie :r1 {parallele {serie :r2 :r3} :r4}}}}

La résistance totale du circuit est '{circuit 5 20 25 80} ohms.
-> La résistance totale du circuit est {circuit 5 20 25 80} ohms.
}