EvoApprox8B

% This code is a part of EvoApproxLib library (ehw.fit.vutbr.cz/approxlib) distributed under The MIT License.
% When used, please cite the following article(s): V. Mrazek, R. Hrbacek, Z. Vasicek and L. Sekanina, "EvoApprox8b: Library of approximate adders and multipliers for circuit design and benchmarking of approximation methods". Design, Automation & Test in Europe Conference & Exhibition (DATE), 2017, Lausanne, 2017, pp. 258-261. doi: 10.23919/DATE.2017.7926993 
% This file contains a circuit from evoapprox8b dataset. Note that a new version of library was already published.

function [ c ] = mul8_RippleCarryArrayMultiplier( a, b )
% Approximate function mul8_RippleCarryArrayMultiplier
%  Library = EvoApprox8b
%  Circuit = mul8_RCAM
%  Area   (180) = 8448
%  Delay  (180) = 5.090
%  Power  (180) = 4503.00
%  Area   (45) = 616
%  Delay  (45) = 1.890
%  Power  (45) = 392.40
%  Nodes = 120
%  HD = 0
%  MAE = 0.00000
%  MSE = 0.00000
%  MRE = 0.00 %
%  WCE = 0
%  WCRE = 0 %
%  EP = 0.0 %
  a = uint16(a);
  b = uint16(b);
  c = 0;
  n0 = bitand(bitshift(a, -0), 1, 'uint16');
  n2 = bitand(bitshift(a, -1), 1, 'uint16');
  n4 = bitand(bitshift(a, -2), 1, 'uint16');
  n6 = bitand(bitshift(a, -3), 1, 'uint16');
  n8 = bitand(bitshift(a, -4), 1, 'uint16');
  n10 = bitand(bitshift(a, -5), 1, 'uint16');
  n12 = bitand(bitshift(a, -6), 1, 'uint16');
  n14 = bitand(bitshift(a, -7), 1, 'uint16');
  n16 = bitand(bitshift(b, -0), 1, 'uint16');
  n18 = bitand(bitshift(b, -1), 1, 'uint16');
  n20 = bitand(bitshift(b, -2), 1, 'uint16');
  n22 = bitand(bitshift(b, -3), 1, 'uint16');
  n24 = bitand(bitshift(b, -4), 1, 'uint16');
  n26 = bitand(bitshift(b, -5), 1, 'uint16');
  n28 = bitand(bitshift(b, -6), 1, 'uint16');
  n30 = bitand(bitshift(b, -7), 1, 'uint16');
  n32 = bitand(n0, n16);
  n34 = bitand(n2, n16);
  n36 = bitand(n4, n16);
  n38 = bitand(n6, n16);
  n40 = bitand(n8, n16);
  n42 = bitand(n10, n16);
  n44 = bitand(n12, n16);
  n46 = bitand(n14, n16);
  n48 = bitand(n0, n18);
  n50 = bitand(n2, n18);
  n52 = bitand(n4, n18);
  n54 = bitand(n6, n18);
  n56 = bitand(n8, n18);
  n58 = bitand(n10, n18);
  n60 = bitand(n12, n18);
  n62 = bitand(n14, n18);
  n64 = bitxor(n34, n48);
  n65 = bitand(n34, n48);
  n66 = bitxor(bitxor(n36, n50), n65);
  n67 = bitor(bitor(bitand(n36, n50), bitand(n50, n65)), bitand(n36, n65));
  n68 = bitxor(bitxor(n38, n52), n67);
  n69 = bitor(bitor(bitand(n38, n52), bitand(n52, n67)), bitand(n38, n67));
  n70 = bitxor(bitxor(n40, n54), n69);
  n71 = bitor(bitor(bitand(n40, n54), bitand(n54, n69)), bitand(n40, n69));
  n72 = bitxor(bitxor(n42, n56), n71);
  n73 = bitor(bitor(bitand(n42, n56), bitand(n56, n71)), bitand(n42, n71));
  n74 = bitxor(bitxor(n44, n58), n73);
  n75 = bitor(bitor(bitand(n44, n58), bitand(n58, n73)), bitand(n44, n73));
  n76 = bitxor(bitxor(n46, n60), n75);
  n77 = bitor(bitor(bitand(n46, n60), bitand(n60, n75)), bitand(n46, n75));
  n78 = bitxor(n77, n62);
  n79 = bitand(n77, n62);
  n80 = bitand(n0, n20);
  n82 = bitand(n2, n20);
  n84 = bitand(n4, n20);
  n86 = bitand(n6, n20);
  n88 = bitand(n8, n20);
  n90 = bitand(n10, n20);
  n92 = bitand(n12, n20);
  n94 = bitand(n14, n20);
  n96 = bitxor(n66, n80);
  n97 = bitand(n66, n80);
  n98 = bitxor(bitxor(n68, n82), n97);
  n99 = bitor(bitor(bitand(n68, n82), bitand(n82, n97)), bitand(n68, n97));
  n100 = bitxor(bitxor(n70, n84), n99);
  n101 = bitor(bitor(bitand(n70, n84), bitand(n84, n99)), bitand(n70, n99));
  n102 = bitxor(bitxor(n72, n86), n101);
  n103 = bitor(bitor(bitand(n72, n86), bitand(n86, n101)), bitand(n72, n101));
  n104 = bitxor(bitxor(n74, n88), n103);
  n105 = bitor(bitor(bitand(n74, n88), bitand(n88, n103)), bitand(n74, n103));
  n106 = bitxor(bitxor(n76, n90), n105);
  n107 = bitor(bitor(bitand(n76, n90), bitand(n90, n105)), bitand(n76, n105));
  n108 = bitxor(bitxor(n78, n92), n107);
  n109 = bitor(bitor(bitand(n78, n92), bitand(n92, n107)), bitand(n78, n107));
  n110 = bitxor(bitxor(n79, n94), n109);
  n111 = bitor(bitor(bitand(n79, n94), bitand(n94, n109)), bitand(n79, n109));
  n112 = bitand(n0, n22);
  n114 = bitand(n2, n22);
  n116 = bitand(n4, n22);
  n118 = bitand(n6, n22);
  n120 = bitand(n8, n22);
  n122 = bitand(n10, n22);
  n124 = bitand(n12, n22);
  n126 = bitand(n14, n22);
  n128 = bitxor(n98, n112);
  n129 = bitand(n98, n112);
  n130 = bitxor(bitxor(n100, n114), n129);
  n131 = bitor(bitor(bitand(n100, n114), bitand(n114, n129)), bitand(n100, n129));
  n132 = bitxor(bitxor(n102, n116), n131);
  n133 = bitor(bitor(bitand(n102, n116), bitand(n116, n131)), bitand(n102, n131));
  n134 = bitxor(bitxor(n104, n118), n133);
  n135 = bitor(bitor(bitand(n104, n118), bitand(n118, n133)), bitand(n104, n133));
  n136 = bitxor(bitxor(n106, n120), n135);
  n137 = bitor(bitor(bitand(n106, n120), bitand(n120, n135)), bitand(n106, n135));
  n138 = bitxor(bitxor(n108, n122), n137);
  n139 = bitor(bitor(bitand(n108, n122), bitand(n122, n137)), bitand(n108, n137));
  n140 = bitxor(bitxor(n110, n124), n139);
  n141 = bitor(bitor(bitand(n110, n124), bitand(n124, n139)), bitand(n110, n139));
  n142 = bitxor(bitxor(n111, n126), n141);
  n143 = bitor(bitor(bitand(n111, n126), bitand(n126, n141)), bitand(n111, n141));
  n144 = bitand(n0, n24);
  n146 = bitand(n2, n24);
  n148 = bitand(n4, n24);
  n150 = bitand(n6, n24);
  n152 = bitand(n8, n24);
  n154 = bitand(n10, n24);
  n156 = bitand(n12, n24);
  n158 = bitand(n14, n24);
  n160 = bitxor(n130, n144);
  n161 = bitand(n130, n144);
  n162 = bitxor(bitxor(n132, n146), n161);
  n163 = bitor(bitor(bitand(n132, n146), bitand(n146, n161)), bitand(n132, n161));
  n164 = bitxor(bitxor(n134, n148), n163);
  n165 = bitor(bitor(bitand(n134, n148), bitand(n148, n163)), bitand(n134, n163));
  n166 = bitxor(bitxor(n136, n150), n165);
  n167 = bitor(bitor(bitand(n136, n150), bitand(n150, n165)), bitand(n136, n165));
  n168 = bitxor(bitxor(n138, n152), n167);
  n169 = bitor(bitor(bitand(n138, n152), bitand(n152, n167)), bitand(n138, n167));
  n170 = bitxor(bitxor(n140, n154), n169);
  n171 = bitor(bitor(bitand(n140, n154), bitand(n154, n169)), bitand(n140, n169));
  n172 = bitxor(bitxor(n142, n156), n171);
  n173 = bitor(bitor(bitand(n142, n156), bitand(n156, n171)), bitand(n142, n171));
  n174 = bitxor(bitxor(n143, n158), n173);
  n175 = bitor(bitor(bitand(n143, n158), bitand(n158, n173)), bitand(n143, n173));
  n176 = bitand(n0, n26);
  n178 = bitand(n2, n26);
  n180 = bitand(n4, n26);
  n182 = bitand(n6, n26);
  n184 = bitand(n8, n26);
  n186 = bitand(n10, n26);
  n188 = bitand(n12, n26);
  n190 = bitand(n14, n26);
  n192 = bitxor(n162, n176);
  n193 = bitand(n162, n176);
  n194 = bitxor(bitxor(n164, n178), n193);
  n195 = bitor(bitor(bitand(n164, n178), bitand(n178, n193)), bitand(n164, n193));
  n196 = bitxor(bitxor(n166, n180), n195);
  n197 = bitor(bitor(bitand(n166, n180), bitand(n180, n195)), bitand(n166, n195));
  n198 = bitxor(bitxor(n168, n182), n197);
  n199 = bitor(bitor(bitand(n168, n182), bitand(n182, n197)), bitand(n168, n197));
  n200 = bitxor(bitxor(n170, n184), n199);
  n201 = bitor(bitor(bitand(n170, n184), bitand(n184, n199)), bitand(n170, n199));
  n202 = bitxor(bitxor(n172, n186), n201);
  n203 = bitor(bitor(bitand(n172, n186), bitand(n186, n201)), bitand(n172, n201));
  n204 = bitxor(bitxor(n174, n188), n203);
  n205 = bitor(bitor(bitand(n174, n188), bitand(n188, n203)), bitand(n174, n203));
  n206 = bitxor(bitxor(n175, n190), n205);
  n207 = bitor(bitor(bitand(n175, n190), bitand(n190, n205)), bitand(n175, n205));
  n208 = bitand(n0, n28);
  n210 = bitand(n2, n28);
  n212 = bitand(n4, n28);
  n214 = bitand(n6, n28);
  n216 = bitand(n8, n28);
  n218 = bitand(n10, n28);
  n220 = bitand(n12, n28);
  n222 = bitand(n14, n28);
  n224 = bitxor(n194, n208);
  n225 = bitand(n194, n208);
  n226 = bitxor(bitxor(n196, n210), n225);
  n227 = bitor(bitor(bitand(n196, n210), bitand(n210, n225)), bitand(n196, n225));
  n228 = bitxor(bitxor(n198, n212), n227);
  n229 = bitor(bitor(bitand(n198, n212), bitand(n212, n227)), bitand(n198, n227));
  n230 = bitxor(bitxor(n200, n214), n229);
  n231 = bitor(bitor(bitand(n200, n214), bitand(n214, n229)), bitand(n200, n229));
  n232 = bitxor(bitxor(n202, n216), n231);
  n233 = bitor(bitor(bitand(n202, n216), bitand(n216, n231)), bitand(n202, n231));
  n234 = bitxor(bitxor(n204, n218), n233);
  n235 = bitor(bitor(bitand(n204, n218), bitand(n218, n233)), bitand(n204, n233));
  n236 = bitxor(bitxor(n206, n220), n235);
  n237 = bitor(bitor(bitand(n206, n220), bitand(n220, n235)), bitand(n206, n235));
  n238 = bitxor(bitxor(n207, n222), n237);
  n239 = bitor(bitor(bitand(n207, n222), bitand(n222, n237)), bitand(n207, n237));
  n240 = bitand(n0, n30);
  n242 = bitand(n2, n30);
  n244 = bitand(n4, n30);
  n246 = bitand(n6, n30);
  n248 = bitand(n8, n30);
  n250 = bitand(n10, n30);
  n252 = bitand(n12, n30);
  n254 = bitand(n14, n30);
  n256 = bitxor(n226, n240);
  n257 = bitand(n226, n240);
  n258 = bitxor(bitxor(n228, n242), n257);
  n259 = bitor(bitor(bitand(n228, n242), bitand(n242, n257)), bitand(n228, n257));
  n260 = bitxor(bitxor(n230, n244), n259);
  n261 = bitor(bitor(bitand(n230, n244), bitand(n244, n259)), bitand(n230, n259));
  n262 = bitxor(bitxor(n232, n246), n261);
  n263 = bitor(bitor(bitand(n232, n246), bitand(n246, n261)), bitand(n232, n261));
  n264 = bitxor(bitxor(n234, n248), n263);
  n265 = bitor(bitor(bitand(n234, n248), bitand(n248, n263)), bitand(n234, n263));
  n266 = bitxor(bitxor(n236, n250), n265);
  n267 = bitor(bitor(bitand(n236, n250), bitand(n250, n265)), bitand(n236, n265));
  n268 = bitxor(bitxor(n238, n252), n267);
  n269 = bitor(bitor(bitand(n238, n252), bitand(n252, n267)), bitand(n238, n267));
  n270 = bitxor(bitxor(n239, n254), n269);
  n271 = bitor(bitor(bitand(n239, n254), bitand(n254, n269)), bitand(n239, n269));
  c = bitor(c, bitshift(bitand(n32, 1), 0));
  c = bitor(c, bitshift(bitand(n64, 1), 1));
  c = bitor(c, bitshift(bitand(n96, 1), 2));
  c = bitor(c, bitshift(bitand(n128, 1), 3));
  c = bitor(c, bitshift(bitand(n160, 1), 4));
  c = bitor(c, bitshift(bitand(n192, 1), 5));
  c = bitor(c, bitshift(bitand(n224, 1), 6));
  c = bitor(c, bitshift(bitand(n256, 1), 7));
  c = bitor(c, bitshift(bitand(n258, 1), 8));
  c = bitor(c, bitshift(bitand(n260, 1), 9));
  c = bitor(c, bitshift(bitand(n262, 1), 10));
  c = bitor(c, bitshift(bitand(n264, 1), 11));
  c = bitor(c, bitshift(bitand(n266, 1), 12));
  c = bitor(c, bitshift(bitand(n268, 1), 13));
  c = bitor(c, bitshift(bitand(n270, 1), 14));
  c = bitor(c, bitshift(bitand(n271, 1), 15));
end