def main(): try: coeff_file = sys.argv[1] dims = tuple([int(d) for d in sys.argv[2].split(',')]) except: raise Exception( 'USAGE: python relative_quantities.py coeff_file m,k,n') full_stab_mat = 0 if len(sys.argv) > 3: full_stab_mat = sys.argv[3] coeffs = read_coeffs(coeff_file) # Using the notation from our paper a_vec = np.array( [sum(np.abs([float(x) for x in row])) for row in transpose(coeffs[0])]) b_vec = np.array( [sum(np.abs([float(x) for x in row])) for row in transpose(coeffs[1])]) e_vec = [ np.dot(np.abs([float(x) for x in row]), a_vec * b_vec) for row in coeffs[2] ] R = len(coeffs[0][0]) print R, dims[0], dims[1], dims[2], int(max(e_vec))
def main(): try: coeff_file = sys.argv[1] dims = tuple([int(d) for d in sys.argv[2].split(',')]) except: raise Exception('USAGE: python stability_parameters.py coeff_file m,k,n') coeffs = read_coeffs(coeff_file) phi = compute_phi(coeffs) print 'phi =', phi sigma = compute_sigma(coeffs, dims) print 'sigma =', sigma omega = 1.0 + float(phi) / sigma print 'omega =', omega # One recursive step print 'optimal lambda (1 recursive step) = ', 2.0 ** -(53 / (float(phi + sigma))) print 'error (1 recursive step) = ', 2.0 ** -(53 / omega) # Two recursive steps phi *= 2 omega = 1.0 + float(phi) / sigma print 'optimal lambda (2 recursive steps) = ', 2.0 ** -(53 / (float(phi + sigma))) print 'error (2 recursive steps) = ', 2.0 ** -(53 / omega)
def main(): try: coeff_file = sys.argv[1] dims = tuple([int(d) for d in sys.argv[2].split(',')]) except: raise Exception( 'USAGE: python stability_parameters.py coeff_file m,k,n') coeffs = read_coeffs(coeff_file) phi = compute_phi(coeffs) print 'phi =', phi sigma = compute_sigma(coeffs, dims) print 'sigma =', sigma omega = 1.0 + float(phi) / sigma print 'omega =', omega # One recursive step print 'optimal lambda (1 recursive step) = ', 2.0**-(53 / (float(phi + sigma))) print 'error (1 recursive step) = ', 2.0**-(53 / omega) # Two recursive steps phi *= 2 omega = 1.0 + float(phi) / sigma print 'optimal lambda (2 recursive steps) = ', 2.0**-(53 / (float(phi + sigma))) print 'error (2 recursive steps) = ', 2.0**-(53 / omega)
def main(): try: coeff_file = sys.argv[1] dims = tuple([int(d) for d in sys.argv[2].split(',')]) except: raise Exception('USAGE: python stability_vector.py coeff_file m,k,n') coeffs = read_coeffs(coeff_file) # Using the notation from our paper a_vec = np.array([ sum(np.abs([zero_one(x) for x in row])) for row in transpose(coeffs[0]) ]) b_vec = np.array([ sum(np.abs([zero_one(x) for x in row])) for row in transpose(coeffs[1]) ]) e_vec = [ np.dot(np.abs([float(x) for x in row]), a_vec * b_vec) for row in coeffs[2] ] mn = max_norm(coeffs[0]) * max_norm(coeffs[1]) * max_norm(coeffs[2]) emax = int(np.max(e_vec)) print emax, mn, emax * mn
def main(): try: coeff_file = sys.argv[1] dims = tuple([int(d) for d in sys.argv[2].split(",")]) except: raise Exception("USAGE: python counts.py coeff_file m,k,n") coeffs = convert.read_coeffs(coeff_file) coeffs[2] = subexpr_elim.transpose(coeffs[2]) counts = [base_counts(coeffs[i]) for i in range(3)] counts_X = [(0, 0, 0) for i in range(3, 6)] if len(coeffs) > 3: counts_X = [elim_counts(coeffs[i]) for i in range(3, 6)] xtotal = tuple([sum(cnts) for cnts in zip(*(counts_X))]) total = tuple([sum(cnts) for cnts in zip(*(counts + counts_X))]) print " + r w" print "A %3d %3d %3d" % counts[0] print "B %3d %3d %3d" % counts[1] print "C %3d %3d %3d" % counts[2] print "AX %3d %3d %3d" % counts_X[0] print "BX %3d %3d %3d" % counts_X[1] print "CX %3d %3d %3d" % counts_X[2] print "xtot %3d %3d %3d" % xtotal print "tot %3d %3d %3d" % total
def main(): try: coeff_file = sys.argv[1] dims = tuple([int(d) for d in sys.argv[2].split(',')]) print 'Reading coefficients for %d x %d x %d matrix' % dims except: raise Exception('USAGE: python subexpr_elim.py coeff_file m,k,n') coeffs = convert.read_coeffs(coeff_file) print 'nnz = ', num_nonzero(coeffs) A_elim = eliminate(coeffs[0]) B_elim = eliminate(coeffs[1]) # Transpose the C coefficients C_coeffs = transpose(coeffs[2]) C_elim = eliminate(C_coeffs) A_subs, num_subs_A = update_coeffs(coeffs[0], A_elim) B_subs, num_subs_B = update_coeffs(coeffs[1], B_elim) C_subs, num_subs_C = update_coeffs(C_coeffs, C_elim) C_coeffs = transpose(C_coeffs) total_elim = num_subs_A + num_subs_B + num_subs_C print 'Eliminating %d non-zeros' % total_elim new_nonzeros = int(coeff_file.split('-')[-1]) - total_elim new_name = '-'.join(coeff_file.split('-')[:-1]) + '-%d' % (new_nonzeros) print 'Writing information to ' + new_name with open(new_name, 'w') as out_file: out_file.write('# Eliminated version of %s\n' % coeff_file) def write_coeff_set(coeff_set): ''' Write the coefficient set for a single matrix (A, B, or C). ''' def pretty_print(value): if float(int(float(value))) == float(value): return str(int(float(value))) else: return str(value) for entry in coeff_set: # Single (i, j) entry of a single matrix. out_file.write(' '.join([pretty_print(val) for val in entry]) + '\n') if len(coeff_set) == 0: out_file.write('\n') write_coeff_set(coeffs[0]) out_file.write('#\n') write_coeff_set(coeffs[1]) out_file.write('#\n') write_coeff_set(C_coeffs) out_file.write('# Substitution information\n') write_coeff_set(A_subs) out_file.write('#\n') write_coeff_set(B_subs) out_file.write('#\n') write_coeff_set(C_subs)
def main(): try: coeff_file = sys.argv[1] dims = tuple([int(d) for d in sys.argv[2].split(',')]) except: raise Exception('USAGE: python stability_vector.py coeff_file m,k,n') full_stab_mat = 0 if len(sys.argv) > 3: full_stab_mat = sys.argv[3] coeffs = read_coeffs(coeff_file) # Using the notation from our paper a_vec = np.array( [sum(np.abs([float(x) for x in row])) for row in transpose(coeffs[0])]) b_vec = np.array( [sum(np.abs([float(x) for x in row])) for row in transpose(coeffs[1])]) e_vec = [ np.dot(np.abs([float(x) for x in row]), a_vec * b_vec) for row in coeffs[2] ] alpha_vec = np.array([num_nonzero(row) for row in transpose(coeffs[0])]) beta_vec = np.array([num_nonzero(row) for row in transpose(coeffs[1])]) ab_vec = alpha_vec + beta_vec gamma_vec = [num_nonzero(row) for row in coeffs[2]] W_ind = np.array([[float(val) for val in row] for row in coeffs[2]]) W_ind[np.nonzero(W_ind)] = 1 q_vec = [gamma_vec[k] + np.max(ab_vec * W_ind[k,:]) \ for k in range(W_ind.shape[0])] # Number of additions nnz = sum([val for val in ab_vec]) + sum([val for val in gamma_vec]) # print as q_vec emax rank = len(coeffs[0][0]) mkn = dims[0] * dims[1] * dims[2] print mkn, rank, nnz, int(np.max(q_vec)), int(np.max(e_vec)) if full_stab_mat: # Print in the same style as D'Alberto presents in his 2014 paper. print 'e vector:' for i in range(dims[0]): out_format = '\t' + ' '.join(['%4d' for _ in range(dims[2])]) vals = e_vec[(i * dims[2]):(i * dims[2] + dims[2])] print out_format % tuple(vals) print 'q vector:' for i in range(dims[0]): out_format = '\t' + ' '.join(['%4d' for _ in range(dims[2])]) vals = q_vec[(i * dims[2]):(i * dims[2] + dims[2])] print out_format % tuple(vals)
def main(): try: coeff_file = sys.argv[1] dims = tuple([int(d) for d in sys.argv[2].split(',')]) except: raise Exception('USAGE: python stability_vector.py coeff_file m,k,n') full_stab_mat = 0 if len(sys.argv) > 3: full_stab_mat = sys.argv[3] coeffs = read_coeffs(coeff_file) # Using the notation from our paper a_vec = np.array([sum(np.abs([float(x) for x in row])) for row in transpose(coeffs[0])]) b_vec = np.array([sum(np.abs([float(x) for x in row])) for row in transpose(coeffs[1])]) e_vec = [np.dot(np.abs([float(x) for x in row]), a_vec * b_vec) for row in coeffs[2]] alpha_vec = np.array([num_nonzero(row) for row in transpose(coeffs[0])]) beta_vec = np.array([num_nonzero(row) for row in transpose(coeffs[1])]) ab_vec = alpha_vec + beta_vec gamma_vec = [num_nonzero(row) for row in coeffs[2]] W_ind = np.array([[float(val) for val in row] for row in coeffs[2]]) W_ind[np.nonzero(W_ind)] = 1 q_vec = [gamma_vec[k] + np.max(ab_vec * W_ind[k,:]) \ for k in range(W_ind.shape[0])] # Number of additions nnz = sum([val for val in ab_vec]) + sum([val for val in gamma_vec]) # print as q_vec emax rank = len(coeffs[0][0]) mkn = dims[0] * dims[1] * dims[2] print mkn, rank, nnz, int(np.max(q_vec)), int(np.max(e_vec)) if full_stab_mat: # Print in the same style as D'Alberto presents in his 2014 paper. print 'e vector:' for i in range(dims[0]): out_format = '\t' + ' '.join(['%4d' for _ in range(dims[2])]) vals = e_vec[(i * dims[2]):(i * dims[2] + dims[2])] print out_format % tuple(vals) print 'q vector:' for i in range(dims[0]): out_format = '\t' + ' '.join(['%4d' for _ in range(dims[2])]) vals = q_vec[(i * dims[2]):(i * dims[2] + dims[2])] print out_format % tuple(vals)
def main(): try: coeff_file = sys.argv[1] dims = tuple([int(d) for d in sys.argv[2].split(',')]) except: raise Exception('USAGE: python stability_vector.py coeff_file m,k,n') coeffs = read_coeffs(coeff_file) # Using the notation from our paper a_vec = np.array([sum(np.abs([zero_one(x) for x in row])) for row in transpose(coeffs[0])]) b_vec = np.array([sum(np.abs([zero_one(x) for x in row])) for row in transpose(coeffs[1])]) e_vec = [np.dot(np.abs([float(x) for x in row]), a_vec * b_vec) for row in coeffs[2]] mn = max_norm(coeffs[0]) * max_norm(coeffs[1]) * max_norm(coeffs[2]) emax = int(np.max(e_vec)) print emax, mn, emax * mn
def main(): try: coeff_file = sys.argv[1] dims = tuple([int(d) for d in sys.argv[2].split(',')]) except: raise Exception('USAGE: python relative_quantities.py coeff_file m,k,n') full_stab_mat = 0 if len(sys.argv) > 3: full_stab_mat = sys.argv[3] coeffs = read_coeffs(coeff_file) # Using the notation from our paper a_vec = np.array([sum(np.abs([float(x) for x in row])) for row in transpose(coeffs[0])]) b_vec = np.array([sum(np.abs([float(x) for x in row])) for row in transpose(coeffs[1])]) e_vec = [np.dot(np.abs([float(x) for x in row]), a_vec * b_vec) for row in coeffs[2]] R = len(coeffs[0][0]) print R, dims[0], dims[1], dims[2], int(max(e_vec))
def main(): try: coeff_file = sys.argv[1] dims = tuple([int(d) for d in sys.argv[2].split(',')]) except: raise Exception('USAGE: python stability_parameters.py coeff_file m,k,n') coeffs = read_coeffs(coeff_file) phi = compute_phi(coeffs) print('phi =', phi) sigma = compute_sigma(coeffs, dims) print('sigma =', sigma) omega = 1.0 + float(phi) / sigma print('omega =', omega) # set bits of precision d = 24 # float prec = 'single' #d = 53 # double #prec = 'double' # One recursive step print('optimal lambda (1 recursive step) = ', 2.0 ** -(d / (float(phi + sigma)))) print('error (1 recursive step) = ', 2.0 ** -(d / omega)) # Two recursive steps phi *= 2 omega = 1.0 + float(phi) / sigma print('optimal lambda (2 recursive steps) = ', 2.0 ** -(d / (float(phi + sigma)))) print('error (2 recursive steps) = ', 2.0 ** -(d / omega)) # Note precision print('\t\t....................... assuming ', prec, ' precision')