F_2 = pylarc.create_fft_matrix_matrixID(2)
pylarc.print_naive_by_matID(F_2)
print("\nF_3 matrix is:")
F_3 = pylarc.create_fft_matrix_matrixID(3)
pylarc.print_naive_by_matID(F_3)
#################################
# create FFT matrices in python #
#################################
print("\nCreate a vector\n")
A_arr = list(map(str, [1, 0, 0, 0, 0, 1, 0, 0]))
rowLevel = 3
colLevel = 0
dimWhole = 1 << colLevel
A_mID = pylarc.row_major_list_to_store_matrixID(A_arr, rowLevel, colLevel,
dimWhole)
pylarc.print_naive_by_matID(A_mID)
print("Now multiply FFT matrix by the vector to get the result\n")
B_mID = pylarc.matrix_mult_matrixID(F_3, A_mID)
pylarc.print_naive_by_matID(B_mID)
#################################
# precision test #
#################################
k = 3
print("\nCalculating the principal 2^%d-th root of unity:" % k)
root_matID = pylarc.principal_pow2_root_unity(k)
print("\nPrinting 2^%d-th root of unity:" % k)
for i in range(dim_whole)
]
elif scalarTypeStr in ("Real", "MPReal", "MPRational"):
randVals = [random.random() for i in range(dim_whole)]
else:
raise Exception('Do not know how to build matrix for type %s.' %
scalarTypeStr)
# create circulant matrix from the dim_whole random numbers
a = []
b = randVals
for i in range(dim_whole):
a.append(list(b))
b.insert(0, b.pop(-1))
#print("a: ", a)
amat = np.matrix(a)
alist = amat.reshape(-1).tolist()[0]
#print(alist)
arr = pylarc.map_to_str(alist, scalarTypeStr)
#print('arr:', pylarc.str_scalarTypeArray(arr, len(alist)))
# creating or finding the matrix associated with the array
serial = pylarc.row_major_list_to_store_matrixID(arr, level, level,
dim_whole)
filename_json = "../dat/out/circulant.lev%d.%s.json" % (level,
scalarTypeStr)
# pylarc.print_naive_by_matID(serial)
# print("\n")
pylarc.write_larcMatrix_file_by_matID(
serial, os.path.join(os.path.dirname(__file__), filename_json))
x = 3.77 * (2**5)
more = [x, x * 2**10, x * 2**15, x * 2**20]
elif typeChar == 'c': # reformat to C style strings
# note that python represents complex #s as a+b*1j
# and we've set up our C code to expect them as a+I*b
# also note that we can have no spaces between characters!
x = "3.77+I*2.34"
more = [x, "27.1+I*0", "0+I*27.1", "3.77+I*-2.34"]
elif typeChar == 'q': # need a better way to do this
x = "32/3"
more = [x, "57/5", "22/7", "16/33"]
else: # in case we define another type
x = 2**25
more = [x, 2**100, 2**50, 2**75]
myFirstMatID = pylarc.row_major_list_to_store_matrixID(list(map(str, more)), 1,
1, 2)
print("my first matrix is")
pylarc.print_naive_by_matID(myFirstMatID)
print("\nentry squared and then multiplied by 10 is")
squareID = pylarc.matrix_entrySquared_matrixID(myFirstMatID, "10")
pylarc.print_naive_by_matID(squareID)
myfile = "../tests/dat/out/temp_" + typeChar + "_matrix.json"
print(myfile)
pylarc.write_larcMatrix_file_by_matID(squareID, myfile)
# lets look at the result of building an identity and zero matrix
# from scratch using the row major reader and print
vals = [0 for i in range(64)]
verbose = 1
pylarc.initialize_larc(mat_store_exp, op_store_exp, max_level,
rnd_sig_bits, trunc_to_zero_bits, verbose)
pylarc.create_report_thread(1800)
# Define string for using in formating filenames
scalarTypeStr = pylarc.cvar.scalarTypeStr
# MAKE a matrix to test Globbing
# two by two tests
level = 1
dim_whole = 2**level
arr_a = list(map(str, [.4, 0, 0, .3]))
a_mID = pylarc.row_major_list_to_store_matrixID(arr_a, level, level,
dim_whole)
arr_b = list(map(str, [.8, 0, 0, .6]))
b_mID = pylarc.row_major_list_to_store_matrixID(arr_b, level, level,
dim_whole)
arr_c = list(map(str, [-.4, 0, 0, -.3]))
c_mID = pylarc.row_major_list_to_store_matrixID(arr_c, level, level,
dim_whole)
print("The matrixIDs of a, b, and c are %d %d %d\n" %
(a_mID, b_mID, c_mID))
d_mID = pylarc.matrix_add_matrixID(a_mID, a_mID)
print("matrix a:")
pylarc.print_naive_by_matID(a_mID)
print("\nMatrix id of a + a: %d, should be that of b: %d \n" %
# turn the matrix into an array by reading off each row in turn (row major format)
alist = a.reshape(-1).tolist()[0]
alist_strs = pylarc.map_to_str(alist, scalarTypeStr)
# arr = pylarc.buildArray(alist)
# print 'arr:', pylarc.str_scalarTypeArray(arr, len(alist))
print("alist_str:", alist_strs)
# parameters for entering the python array into the store
level = 2
dim_whole = 2**level
# creating or finding the matrix associated with the array
serial = pylarc.row_major_list_to_store_matrixID(alist_strs, level, level, dim_whole)
pylarc.print_naive_by_matID(serial)
print("\n")
# Make a parent matrix from four copies of the serial matrix
print("Creating matrix from get_matID_from_four_subMatIDs on panel input and writing LARCMatrix file\n")
panel = [serial]*4 # alternatively panel=[serial,serial,serial,serial]
serial_parent = pylarc.get_matID_from_four_subMatIDs(serial,serial,serial,serial,3,3)
pylarc.print_naive_by_matID(serial_parent)
filename = "../dat/out/testfile.%s.json" %scalarTypeStr
pylarc.write_larcMatrix_file_by_matID(serial_parent,os.path.join(os.path.dirname(__file__), filename))
# PLAYING WITH PREWRITTEN REVERSIBLE NAND LARCMatrix FILE
print("About to test read LARCMatrix file\n")
filename = "../dat/in/nand.%s.json" %scalarTypeStr
nand_matrixID = pylarc.read_larcMatrix_file_return_matID(os.path.join(os.path.dirname(__file__),filename))
a = np.matrix([[1 + 2j, 3 + 4j, 5 + 6j, 7 + 8j],
[8 + 7j, 6 + 5j, 3 + 4j, 1 + 2j],
[9 + 10j, 11 + 12j, 13 + 14j, 15 + 16j],
[16 + 15j, 14 + 13j, 12 + 11j, 10 + 9j]])
elif scalarTypeStr in ("Real", "MPReal", "MPRational"):
a = np.matrix([[1, 3, .5, 6], [8, 6, 3, .1], [-9, 11, 13, 1.5],
[16, 13, 12, 10]])
else:
raise Exception('Do not know how to build matrix for type %s.' %
scalarTypeStr)
# test our new function matrix_is_zero_matrixID(z_matID))
z = np.matrix([[0, 0], [0, 0]])
zlist = z.reshape(-1).tolist()[0]
zlist_strs = pylarc.map_to_str(zlist, scalarTypeStr)
z_matID = pylarc.row_major_list_to_store_matrixID(zlist_strs, 1, 1, 2)
pylarc.print_naive_by_matID(z_matID)
print("\nThe fucntion matrix_is_zero_matrixID returns:")
print(pylarc.matrix_is_zero_matrixID(z_matID))
print("\n")
# turn the matrix into an array by reading off each row in turn (row major format)
alist = a.reshape(-1).tolist()[0]
alist_strs = pylarc.map_to_str(alist, scalarTypeStr)
# arr = pylarc.buildArray(alist)
# print 'arr:', pylarc.str_scalarTypeArray(arr, len(alist))
print("alist_str:", alist_strs)
# parameters for entering the python array into the store
level = 2
dim_whole = 2**level
# [8, 6, 3, .1],
# [-9, 11, 13, 1.5],
# [16, 13, 12, 10]])
else:
raise Exception('Do not know how to build matrix for type %s.' %
scalarTypeStr)
print("COLUMN_COLUMN CASE")
# turn the matrix into an array by reading off each row in turn (row major format)
alist = a.reshape(-1).tolist()[0]
aarr = pylarc.map_to_str(alist, scalarTypeStr)
# print('array A:', pylarc.str_scalarTypeArray(aarr, len(alist)))
print('array A:', aarr)
# creating or finding the matrix associated with the array
serial_a = pylarc.row_major_list_to_store_matrixID(aarr, 3, 0, 1)
pylarc.print_naive_by_matID(serial_a)
print("\n")
# turn the matrix into an array by reading off each row in turn (row major format)
blist = b.reshape(-1).tolist()[0]
barr = pylarc.map_to_str(blist, scalarTypeStr)
# print('array B:', pylarc.str_scalarTypeArray(barr, len(blist)))
print('array B:', barr)
# creating or finding the matrix associated with the array
serial_b = pylarc.row_major_list_to_store_matrixID(barr, 2, 0, 1)
pylarc.print_naive_by_matID(serial_b)
print("\n")
print("kronecker product A \otimes B:")
