p = 10#2*rand.randint(2,(N-1)/2-N/5)
myMAGIC = MAGIC_CMPLX()
myMAGIC.F_simulation_init(N,p)
in1_arr_Re = np.array([])
in1_arr_Im = np.array([])
in2_arr_Re = np.array([])
in2_arr_Im = np.array([])
out_arr_Re = np.array([])
out_arr_Im = np.array([])
exp_arr_Re = np.array([])
exp_arr_Im = np.array([])
lines = 100
# writing some numbers to MAGIC. msb in 0 column
for i in range (0,lines):
Real = randrange_float(start=-(2 ** ((N / 2 - p / 2 - 1) / 2)) + 1, stop=(2 ** ((N / 2 - p / 2 - 1) / 2)) - 1, step=(2 ** (-p / 4)))
Imaginary = randrange_float(start=-(2 ** ((N / 2 - p / 2 - 1) / 2)) + 1, stop=(2 ** ((N / 2 - p / 2 - 1) / 2)) - 1, step=(2 ** (-p / 4)))
in1_arr_Re = np.r_[in1_arr_Re, Real]
in1_arr_Im = np.r_[in1_arr_Im, Imaginary]
row_add = i
msb_add = 0
myMAGIC.F_write_CMPLX_num(row_add, msb_add, [Real,Imaginary])
# writing second set of numbers to MAGIC. msb in N column
for i in range (0,len(myMAGIC)):
Real = randrange_float(start=-(2 ** ((N / 2 - p / 2 - 1) / 2)) + 1, stop=(2 ** ((N / 2 - p / 2 - 1) / 2)) - 1, step=(2 ** (-p / 4)))
Imaginary = randrange_float(start=-(2 ** ((N / 2 - p / 2 - 1) / 2)) + 1, stop=(2 ** ((N / 2 - p / 2 - 1) / 2)) - 1, step=(2 ** (-p / 4)))
while (abs(Real) + abs(Imaginary) == 0):
Real = randrange_float(start=-(2 ** ((N / 2 - p / 2 - 1) / 2)) + 1, stop=(2 ** ((N / 2 - p / 2 - 1) / 2)) - 1, step=(2 ** (-p / 4)))
Imaginary = randrange_float(start=-(2 ** ((N / 2 - p / 2 - 1) / 2)) + 1, stop=(2 ** ((N / 2 - p / 2 - 1) / 2)) - 1, step=(2 ** (-p / 4)))
in2_arr_Re = np.r_[in2_arr_Re, Real]
N_start = 8
N = 32
p = 0
N_Array = np.arange(N_start,N+1)
end_mem_arr = np.array([])
max_mem_arr = np.array([])
cycles_arr = np.array([])
for n in range(N_start, N+1):
myMAGIC = MAGIC()
myMAGIC.F_simulation_init(n,p,print_=0)
for i in range(2):
val = randrange_float(start=-(2 ** (n - p - 1)) + 1, stop=(2 ** (n - p - 1)) - (2 ** (-p)), step=2 ** (-p))
myMAGIC.F_write_num(0, i*n, val)
rows = np.arange(0,len(myMAGIC))
#################################################################
# choose a function by deleting the '#' from the wanted function
# *** change the graph names accordingly
#################################################################
#myMAGIC.F_2num_DIV_remain(rows, 0, n, 2*n, 3*n)
myMAGIC.F_2num_DIV_approx(rows, 0, n, 2 * n, N=n, p=p)
#myMAGIC.F_2num_FA(rows, in1_msb=0, in2_msb=n, out_add=2 * n)
#################################################################
# initiating simulation
N = rand.randint(10, 20)
p = rand.randint(0, N - 1)
lines = 100
myMAGIC = MAGIC()
myMAGIC.F_simulation_init(N, p)
in1_arr = np.array([])
in2_arr = np.array([])
out_arr = np.array([])
exp_arr = np.array([])
# writing some numbers to MAGIC. msb in 0 column
for i in range(0, lines):
val = randrange_float(start=-(2**((N - p - 1) / 2)) + 1,
stop=(2**((N - p - 1) / 2)) - 1,
step=(2**(-p / 2)))
in1_arr = np.r_[in1_arr, val]
row_add = i
msb_add = 0
myMAGIC.F_write_num(row_add, msb_add, val)
# writing second set of numbers to MAGIC. msb in N column
for i in range(0, len(myMAGIC)):
val = randrange_float(start=-(2**((N - p - 1) / 2)) + 1,
stop=(2**((N - p - 1) / 2)) - 1,
step=(2**(-p / 2)))
in2_arr = np.r_[in2_arr, val]
row_add = i
msb_add = N
myMAGIC.F_write_num(row_add, msb_add, val)
# initiating simulation
N = 18 #rand.randint(10,20)
p = 9 #rand.randint(0,N-1)
myMAGIC = MAGIC()
myMAGIC.F_simulation_init(N, p)
in1_arr = np.array([])
out_arr = np.array([])
exp_arr = np.array([])
lines = 1000
# writing some numbers to MAGIC. msb in 0 column
for i in range(0, lines):
val = randrange_float(start=-(2**(N - p - 2)),
stop=(2**(N - p - 2)) - (2**(-p)),
step=2**(-p))
in1_arr = np.r_[in1_arr, val]
row_add = i
msb_add = 0
myMAGIC.F_write_num(row_add, msb_add, val, N)
#myMAGIC.F_write_num(row_add, N, 1)
# checking full adder on 2 bits with & without carry in
rows = np.arange(0, len(myMAGIC))
myMAGIC.F_invert_according2sign(rows, 0, 0, N, N)
for row in rows:
exp_arr = np.r_[exp_arr, abs(in1_arr[row])]
out_arr = np.r_[out_arr, myMAGIC.F_read_num(row, N)]
# ending simulation with prints and graphs
myMAGIC.F_simulation_end()
p = rand.randint(0,N-1)
myMAGIC = MAGIC_CMPLX()
myMAGIC.F_simulation_init(N,p)
in1_arr_Re = np.array([])
in1_arr_Im = np.array([])
in2_arr_Re = np.array([])
in2_arr_Im = np.array([])
out_arr_Re = np.array([])
out_arr_Im = np.array([])
exp_arr_Re = np.array([])
exp_arr_Im = np.array([])
lines = 1000
# writing some numbers to MAGIC. msb in 0 column
for i in range (0,lines):
Real = randrange_float(start=-(2 ** (N - p - 2)), stop=(2 ** (N - p - 2)) - (2 ** (-p)), step=2 ** (-p))
Imaginary = randrange_float(start=-(2 ** (N - p - 2)), stop=(2 ** (N - p - 2)) - (2 ** (-p)), step=2 ** (-p))
in1_arr_Re = np.r_[in1_arr_Re, Real]
in1_arr_Im = np.r_[in1_arr_Im, Imaginary]
row_add = i
msb_add = 0
myMAGIC.F_write_CMPLX_num(row_add, msb_add, [Real,Imaginary])
# writing second set of numbers to MAGIC. msb in N column
for i in range (0,len(myMAGIC)):
Real = randrange_float(start=-(2 ** (N - p - 2)), stop=(2 ** (N - p - 2)) - (2 ** (-p)), step=2 ** (-p))
Imaginary = randrange_float(start=-(2 ** (N - p - 2)), stop=(2 ** (N - p - 2)) - (2 ** (-p)), step=2 ** (-p))
in2_arr_Re = np.r_[in2_arr_Re, Real]
in2_arr_Im = np.r_[in2_arr_Im, Imaginary]
row_add = i
msb_add = 2*N
