ন্যানড লজিক গেটগুলি ব্যবহার করে একটি মিনিফ্লোট অ্যাডিং মেশিন তৈরি করুন


15

একটি মিনিফ্লোট একটি ভাসমান-পয়েন্ট সংখ্যাটির বাইনারি উপস্থাপনা যা খুব কম বিট থাকে।

এই প্রশ্নের মিনিফ্লোটটি 6-বিট নম্বর হিসাবে সংজ্ঞায়িত করা হবে m, যার নিম্নলিখিত প্রতিনিধিত্ব রয়েছে:

  • সংখ্যার সাইনটি পুনরায় পেশ করতে 1 বিট। 0সংখ্যাটি ইতিবাচক 1হলে এবং এই সংখ্যাটি নেতিবাচক হলে এই বিটটি হবে ।

  • সংখ্যার সূচককে উপস্থাপনের জন্য 3 টি বিট, অফসেট দ্বারা 3(অর্থাত্ একটি ব্যয়কারী 110প্রকৃতপক্ষে 2 3 এর একটি উপাদানকে উপস্থাপন করে , 2 6 নয় )।

    • একটি এক্সপোনেন্ট 000একটি উপাভিলম্ব সংখ্যা বোঝায়। ম্যান্টিসা হ'ল সংখ্যার ভগ্নাংশের অংশটিকে সংখ্যার পূর্ণসংখ্যার অংশের সাথে 0সর্বনিম্ন সম্ভাব্য ব্যয়কারকের একটি ফ্যাক্টর দ্বারা গুণিত করে (এই ক্ষেত্রে, 2 -2 )।
  • সংখ্যার মান্টিসাকে উপস্থাপন করতে 2 বিট। যদি ব্যাক্তি 000বা ব্যতীত অন্য কিছু হয় 111তবে 2 বিটগুলি a এর পরে ভগ্নাংশের অংশকে উপস্থাপন করে 1

    • একটি এক্সপোনেন্ট 111প্রতিনিধিত্ব করে infinityযদি অংশক হল 0, এবং NaN(কোন সংখ্যা) অন্যথায়।

উইকিপিডিয়া নিবন্ধে, এটি একটি (1.3.2.3) মিনিফ্লোট হিসাবে উল্লেখ করা হবে।

এই মিনিফ্লোটের প্রতিনিধিত্বের কয়েকটি উদাহরণ:

000000 =  0.00 = 0
000110 =  1.10 × 2^(1-3) = 0.375
001100 =  1.00 × 2^(3-3) = 1
011001 =  1.01 × 2^(6-3) = 10
011100 = infinity
011101 = NaN
100000 = -0.00 = -0
100011 = -0.11 × 2^(1-3) = -0.1875 (subnormal)
101011 = -1.11 × 2^(2-3) = -0.875
110100 = -1.00 × 2^(5-3) = -4
111100 = -infinity
111111 = NaN

আপনার টাস্ক দুই ইনপুট NAND দরজা 6 ইনপুট একটি minifloat প্রতিনিধিত্বমূলক লাগে একটি নেটওয়ার্ক গড়ে তোলা aএবং 6 ইনপুট একটি minifloat প্রতিনিধিত্বমূলক b, এবং আয় 6 minifloat প্রতিনিধিত্বমূলক আউটপুট a + b

  • আপনার নেটওয়ার্ক অবশ্যই যথাযথভাবে subnormals যুক্ত করা উচিত। উদাহরণস্বরূপ, 000001+ 000010অবশ্যই সমান 000011, এবং 001001+ 000010= 001010

  • আপনার নেটওয়ার্কে অবশ্যই ইনফিনিটগুলি সঠিকভাবে যোগ এবং বিয়োগ করতে হবে। অসীমের সাথে সীমাবদ্ধ যে কোনও কিছুই হ'ল একই অনন্ত। ইতিবাচক অনন্ত প্লাস নেতিবাচক অসীমতা NaN

  • একটি NaNপ্লাস যে কোনও কিছুর সমান হওয়া উচিত NaN, যদিও NaNএটি সমান।

  • একে অপরের সাথে ধনাত্মক শূন্য এবং নেতিবাচক শূন্য যুক্ত করার বিষয়টি আপনি কীভাবে পরিচালনা করবেন তা শূন্যের সাথে শূন্যের সমান শূন্যের সমান হবে।

আপনার নেটওয়ার্কটি সুবিধার উপর নির্ভর করে নিম্নলিখিত বৃত্তাকার নিয়মের কোনও প্রয়োগ করতে পারে:

  • বৃত্তাকার ডাউন (নেতিবাচক অসীমের দিকে)
  • রাউন্ড আপ (ধনাত্মক অনন্তের দিকে)
  • গোল শূন্যের দিকে
  • শূন্য থেকে বৃত্তাকার
  • উপরের যে কোনও নিয়ম অনুসারে অর্ধেকটি গোল করে নিকটতম পর্যন্ত গোল to

জিনিসগুলিকে সরল করার জন্য, আপনি নীচের সাথে সম্পর্কিত স্কোর সহ আপনার ডায়াগ্রামে AND, OR, NOT, এবং XOR গেট ব্যবহার করতে পারেন:

  • NOT: 1
  • AND: 2
  • OR: 3
  • XOR: 4

এই স্কোরগুলির প্রতিটি ন্যাং গেটের সংখ্যার সাথে সম্পর্কিত যা এটি সম্পর্কিত গেটটি নির্মাণ করতে লাগে।

লজিক সার্কিট যা উপরের সমস্ত প্রয়োজনীয়তা জয়কে সঠিকভাবে প্রয়োগ করতে কয়েকটি ন্যান্ড গেট ব্যবহার করে।


2
চমৎকার চ্যালেঞ্জ - কোডে এটি বাস্তবায়নের জন্য আমাকে গুরুত্ব সহকারে চিন্তা করতে হবে, ন্যাং গেটগুলি ছেড়ে দিন।
ডিজিটাল ট্রমা

উত্তর:


10

830 ন্যানড

এটি 24 নোট, 145 ANDs, 128 ওআর, 33 এক্সওআর ব্যবহার করে। এটি সর্বদা শূন্যের দিকে ঘোরে, এটি শূন্য মানের জন্য -0 বা +0 ফিরে আসতে পারে এবং আমি বিশ্বাস করি যে এটি ইনফিনিটিগুলি এবং NaN এর সাথে সঠিকভাবে আচরণ করে:

  • ± INF ± INF = ± INF
  • ± INF + NaN = ± INF
  • ± INF ∓ INF = NaN
  • ± INF + সংখ্যা = ± INF
  • NaN + NaN = NaN
  • NaN + সংখ্যা = NaN

নীচে আমার কাছে সার্কিটের কোডেড উপস্থাপনা রয়েছে। এই ধরণের জিনিসগুলি বর্ণনা করার আমার কাছে খুব কম অভিজ্ঞতা আছে, সুতরাং এটি করার সাধারণ উপায়টি আসলেই আমি জানি না, তবে প্রতিটি পরিবর্তনশীল একটি বুলিয়ান তাই এটি একটি সার্কিটের বর্ণনা দেয় তা স্পষ্ট। আরেকটি বিষয়, আমার এটির চিত্রটি চেষ্টা করার চেষ্টা বা তাত্পর্যতা আমার নেই বা নেই, তবে সেখানে যদি কোনও সফ্টওয়্যার ব্যবহার করা সহজ হয় তবে যে কেউ উল্লেখ করতে চায় আমি একবার নজর দিতে আগ্রহী in

a0,a1,a2,a3,a4,a5 = mini0
b0,b1,b2,b3,b4,b5 = mini1

neg = XOR(a0,b0)
nneg = NOT(neg)

na1 = NOT(a1)
na2 = NOT(a2)
na3 = NOT(a3)

a2_a3 = AND(a2,a3)
a2_na3 = AND(a2,na3)
na2_a3 = AND(na2,a3)
na2_na3 = AND(na2,na3)

a123 = AND(a1,a2_a3)
l0 = AND(a1,a2_na3)
l1 = AND(a1,na2_a3)
l2 = AND(a1,na2_na3)
l3 = AND(na1,a2_a3)
l4 = AND(na1,a2_na3)
l5 = AND(na1,na2_a3)
l6 = AND(na1,na2_na3)

a45 = OR(a4,a5)
a_nan = AND(a123,a45)
a_inf = AND(a123,NOT(a45))

m0 = l0
m1 = OR(l1,AND(l0,a4))
m2 = OR(l2,OR(AND(l1,a4),AND(l0,a5)))
m3 = OR(l3,OR(AND(l2,a4),AND(l1,a5)))
m4 = OR(l4,OR(AND(l3,a4),AND(l2,a5)))
m5 = OR(l5,OR(AND(l4,a4),AND(l3,a5)))
l5_l6 = OR(l5,l6)
m6 = OR(AND(l4,a5),AND(l5_l6,a4))
m7 = AND(l5_l6,a5)

nb1 = NOT(b1)
nb2 = NOT(b2)
nb3 = NOT(b3)

b2_b3 = AND(b2,b3)
b2_nb3 = AND(b2,nb3)
nb2_b3 = AND(nb2,b3)
nb2_nb3 = AND(nb2,nb3)

b123 = AND(b1,b2_b3)
k0 = AND(b1,b2_nb3)
k1 = AND(b1,nb2_b3)
k2 = AND(b1,nb2_nb3)
k3 = AND(nb1,b2_b3)
k4 = AND(nb1,b2_nb3)
k5 = AND(nb1,nb2_b3)
k6 = AND(nb1,nb2_nb3)

b45 = OR(b4,b5)
b_nan = AND(b123,b45)
b_inf = AND(b123,NOT(b45))  

n0 = k0
n1 = OR(k1,AND(k0,b4))
n2 = OR(k2,OR(AND(k1,b4),AND(k0,b5)))
n3 = OR(k3,OR(AND(k2,b4),AND(k1,b5)))
n4 = OR(k4,OR(AND(k3,b4),AND(k2,b5)))
n5 = OR(k5,OR(AND(k4,b4),AND(k3,b5)))
k5_k6 = OR(k5,k6)
n6 = OR(AND(k4,b5),AND(k5_k6,b4))
n7 = AND(k5_k6,b5)

first = n0,n1,n2,n3,n4,n5,n6,n7

i7 = n7
i6 = XOR(n6,n7)
carry_6 = OR(n6,n7)
i5 = XOR(n5,carry_6)
carry_5 = OR(n5,carry_6)
i4 = XOR(n4,carry_5)
carry_4 = OR(n4,carry_5)
i3 = XOR(n3,carry_4)
carry_3 = OR(n3,carry_4)
i2 = XOR(n2,carry_3)
carry_2 = OR(n2,carry_3)
i1 = XOR(n1,carry_2)
carry_1 = OR(n1,carry_2)
i0 = XOR(n0,carry_1)
i_sign = OR(n0,carry_1)

n7 = OR(AND(nneg,n7),AND(neg,i7))
n6 = OR(AND(nneg,n6),AND(neg,i6))
n5 = OR(AND(nneg,n5),AND(neg,i5))
n4 = OR(AND(nneg,n4),AND(neg,i4))
n3 = OR(AND(nneg,n3),AND(neg,i3))
n2 = OR(AND(nneg,n2),AND(neg,i2))
n1 = OR(AND(nneg,n1),AND(neg,i1))
n0 = OR(AND(nneg,n0),AND(neg,i0))
n_sign = AND(neg,i_sign)

r7 = XOR(m7,n7)
carry_7 = AND(m7,n7)
hr6 = XOR(m6,n6)
hcarry_6 = AND(m6,n6)
r6 = XOR(hr6,carry_7)
carry_6 = OR(hcarry_6,AND(hr6,carry_7))
hr5 = XOR(m5,n5)
hcarry_5 = AND(m5,n5)
r5 = XOR(hr5,carry_6)
carry_5 = OR(hcarry_5,AND(hr5,carry_6))
hr4 = XOR(m4,n4)
hcarry_4 = AND(m4,n4)
r4 = XOR(hr4,carry_5)
carry_4 = OR(hcarry_4,AND(hr4,carry_5))
hr3 = XOR(m3,n3)
hcarry_3 = AND(m3,n3)
r3 = XOR(hr3,carry_4)
carry_3 = OR(hcarry_3,AND(hr3,carry_4))
hr2 = XOR(m2,n2)
hcarry_2 = AND(m2,n2)
r2 = XOR(hr2,carry_3)
carry_2 = OR(hcarry_2,AND(hr2,carry_3))
hr1 = XOR(m1,n1)
hcarry_1 = AND(m1,n1)
r1 = XOR(hr1,carry_2)
carry_1 = OR(hcarry_1,AND(hr1,carry_2))
hr0 = XOR(m0,n0)
hcarry_0 = AND(m0,n0)
r0 = XOR(hr0,carry_1)
carry_0 = OR(hcarry_0,AND(hr0,carry_1))
r_sign = XOR(n_sign,carry_0)

s7 = r7
s6 = XOR(r6,r7)
carry_6 = OR(r6,r7)
s5 = XOR(r5,carry_6)
carry_5 = OR(r5,carry_6)
s4 = XOR(r4,carry_5)
carry_4 = OR(r4,carry_5)
s3 = XOR(r3,carry_4)
carry_3 = OR(r3,carry_4)
s2 = XOR(r2,carry_3)
carry_2 = OR(r2,carry_3)
s1 = XOR(r1,carry_2)
carry_1 = OR(r1,carry_2)
s0 = XOR(r0,carry_1)

n_r_sign = NOT(r_sign)
r0 = OR(AND(n_r_sign,r0),AND(r_sign,s0))
r1 = OR(AND(n_r_sign,r1),AND(r_sign,s1))
r2 = OR(AND(n_r_sign,r2),AND(r_sign,s2))
r3 = OR(AND(n_r_sign,r3),AND(r_sign,s3))
r4 = OR(AND(n_r_sign,r4),AND(r_sign,s4))
r5 = OR(AND(n_r_sign,r5),AND(r_sign,s5))
r6 = OR(AND(n_r_sign,r6),AND(r_sign,s6))
r7 = OR(AND(n_r_sign,r7),AND(r_sign,s7))

h0 = r0
rest = h0
h1 = AND(r1,NOT(rest))
rest = OR(rest,h1)
h2 = AND(r2,NOT(rest))
rest = OR(rest,h2)
h3 = AND(r3,NOT(rest))
rest = OR(rest,h3)
h4 = AND(r4,NOT(rest))
rest = OR(rest,h4)
h5 = AND(r5,NOT(rest))
rest = OR(rest,h5)
h6 = AND(r6,NOT(rest))
rest = OR(rest,h6)
h7 = AND(r7,NOT(rest))

e0 = OR(h0,OR(h1,h2))
e1 = OR(h0,OR(h3,h4))
e2 = OR(h1,OR(h3,h5))

ne0 = NOT(e0)
ne1 = NOT(e1)
ne2 = NOT(e2)

e0e1 = AND(e0,e1)
e0ne1 = AND(e0,ne1)
ne0e1 = AND(ne0,e1)
ne0ne1 = AND(ne0,ne1)

x0 = AND(e0e1,  ne2)
x1 = AND(e0ne1, e2 )
x2 = AND(e0ne1, ne2)
x3 = AND(ne0e1, e2 )
x4 = AND(ne0e1, ne2)
x5 = AND(ne0ne1,e2 )
x6 = AND(ne0ne1,ne2)

u0 = AND(x0,r1)
u1 = AND(x1,r2)
u2 = AND(x2,r3)
u3 = AND(x3,r4)
u4 = AND(x4,r5)
u5 = AND(x5,r6)
u6 = AND(x6,r6)

v0 = AND(x0,r2)
v1 = AND(x1,r3)
v2 = AND(x2,r4)
v3 = AND(x3,r5)
v4 = AND(x4,r6)
v5 = AND(x5,r7)
v6 = AND(x6,r7)

f0 = OR(u0,OR(u1,OR(u2,OR(u3,OR(u4,OR(u5,u6))))))
f1 = OR(v0,OR(v1,OR(v2,OR(v3,OR(v4,OR(v5,v6))))))
sign = XOR(a0,r_sign)

either_nan = OR(a_nan,b_nan)
either_inf = OR(a_inf,b_inf)
ans_nan = OR(AND(AND(a_inf,b_inf),XOR(a0,b0)),AND(NOT(either_inf),either_nan))
nans_nan = NOT(ans_nan)
ans_inf = AND(nans_nan,OR(either_nan,either_inf))
ans_none = AND(nans_nan,NOT(ans_inf))
nans_none = NOT(ans_none)

result0 = OR(OR(AND(a_inf,a0),AND(b_inf,b0)),AND(ans_none,sign))
result1 = OR( nans_none, AND(ans_none,e0) )
result2 = OR( nans_none, AND(ans_none,e1) )
result3 = OR( nans_none, AND(ans_none,e2) )
result4 = OR( ans_nan, AND(ans_none,f0) )
result5 = OR( ans_nan, AND(ans_none,f1) )

এটি শেষ হয়ে গেলে, এটি শূন্যের দিকে বা নেতিবাচক অনন্তের দিকে "ডাউন" হয়ে যাবে? উৎসুক.
জো জেড।

@JoeZ। আমি অবশ্যই এটি শূন্যের দিকে গোল করার চেষ্টা করব এবং আমি মনে করি যে এটি করা কোনও সমস্যা হওয়া উচিত নয়, যদিও আমি এটি না লিখেই নিশ্চিত হতে পারি না। এটি দুটি নেতিবাচক সংখ্যা যুক্ত করা স্পষ্টতই তুচ্ছ (তাদের শূন্যের দিকে গোল করা) সুতরাং আমি মনে করি এটির সাথে থাকা আরও সম্ভবত সহজ হবে।
কেস্যাব

1
সম্পূর্ণ সমাধান নিয়ে আসার জন্য ভাল কাজ করেছি। কিছু সহজ অপ্টিমাইজেশন আছে।OR(AND(w,x),AND(y,z))হয় NAND(NAND(w,x),NAND(y,z))4 সংরক্ষণ, এবং কয়েক বার আপনাকে প্রথমে নির্মাণ ব্যবহার করেছি; এবং আপনার NaN চিকিত্সা কিছুটা ভুল কারণ এটি Inf + NaNহওয়া উচিত NaN
পিটার টেলর
আমাদের সাইট ব্যবহার করে, আপনি স্বীকার করেছেন যে আপনি আমাদের কুকি নীতি এবং গোপনীয়তা নীতিটি পড়েছেন এবং বুঝতে পেরেছেন ।
Licensed under cc by-sa 3.0 with attribution required.