def kuramoto_sivashinsky(sequence_length=1000, n_sequence=1, spatial_points=100): ''' solution of the Kuramoto–Sivashinsky equation, u_t + u*u_x + α*u_xx + γ*u_xxxx = 0, computed by tanh-function method. ''' # Octave functions are download from https://github.com/qyxiao/machine-learning-2016-spring/blob/master from oct2py import octave N = spatial_points h = 0.25 # time step length nstp = sequence_length # a0 = np.zeros([N - 2, 1]) L = 22. input_data = np.zeros( (n_sequence, sequence_length + 1, spatial_points + 1)) tt = np.zeros((n_sequence, 1, sequence_length + 1)) xx = np.zeros((n_sequence, spatial_points + 1, 1)) for idx in range(n_sequence): a0 = np.random.rand(N - 2, 1) / 4 # just some initial condition [tt[idx], fdata] = octave.feval('ksfmstp', a0, L, h, nstp, 1, nout=2) [xx[idx], input_data[idx, :, :]] = octave.feval('ksfm2real', fdata, L, nout=2) # we remove first time and spatial indices because sometimes they get bad values input_data = input_data[:, 1:, 1:] tt = np.linspace(np.min(tt[:, :, :-1]), np.max(tt[:, :, :-1]), sequence_length) xx = xx[0, :-1, 0] return input_data, xx, tt
def get_kuramoto_sivashinsky_lyap_exp(sequence_length=1000, n_sequence=100, spatial_points=64): ''' Lyapunov exponent for the Kuramoto–Sivashinsky equation, u_t + u*u_x + α*u_xx + γ*u_xxxx = 0. The method is adapted and modified from "Physica D 65 (1993) 117-134" paper, also from https://blog.abhranil.net/2014/07/22/calculating-the-lyapunov-exponent-of-a-time-series-with-python-code/ ''' from oct2py import octave N = spatial_points h = 0.25 # time step length nstp = sequence_length L = 22. dlist = [[] for i in range(sequence_length)] for i0 in range(n_sequence): a0 = np.random.rand(N - 2, 1) / 2 # just some initial condition [_, fdata] = octave.feval('ksfmstp', a0, L, h, nstp, 1, nout=2) [_, input_data0] = octave.feval('ksfm2real', fdata, L, nout=2) a1 = a0 + 10**(-7) [_, fdata] = octave.feval('ksfmstp', a1, L, h, nstp, 1, nout=2) [_, input_data1] = octave.feval('ksfm2real', fdata, L, nout=2) for k in range(sequence_length): dlist[k].append( np.log(np.linalg.norm(input_data0[k, :] - input_data1[k, :]))) spectrum = np.zeros((sequence_length)) for i in range(sequence_length): spectrum[i] = sum(dlist[i]) / len(dlist[i]) lyap_exp = np.polyfit(range(len(spectrum)), spectrum, 1)[0] / h return lyap_exp
def test_apply_OBM(): """Test apply_OBM by comparing to Octave""" obm_m, _ = octave.feval('octave/thirdoct.m', float(FS), float(NFFT), float(NUMBAND), float(MINFREQ), nout=2) x = np.random.randn(2 * FS) x_tob_m = octave.feval('octave/applyOBM', x, obm_m, float(N_FRAME), float(NFFT), float(NUMBAND)) x_tob_m = np.array(x_tob_m) x_spec = stft(x, N_FRAME, NFFT, overlap=2).transpose() x_tob = np.zeros((NUMBAND, x_spec.shape[1])) for i in range(x_tob.shape[1]): x_tob[:, i] = np.sqrt(np.matmul(OBM, np.square(np.abs(x_spec[:, i])))) assert_allclose(x_tob, x_tob_m, atol=ATOL)
def set_data_matlab(self, bind : str = None) -> None : """ Get data from matlab file format """ try : oct.eval("cd .") self._raw_data = oct.feval(bind) except : print("Please install oct2py and its dependencies if you want to use set_data_matlab()") raise self._network = Network() buses = [] for i in range(0, self._raw_data["bus"].shape[0]): buses.append(Bus(data = self._raw_data["bus"][i])) ### merge "gen" and "gencost" matrix self._raw_data["all_gen"] = np.concatenate((self._raw_data["gen"],self._raw_data["gencost"]),axis=1) ### Adding generators for i in range(0, self._raw_data["gen"].shape[0]): buses[int(self._raw_data["gen"][i][0] - 1)].add_generator(data = self._raw_data["all_gen"][i]) ### Adding buses self._network.add_buses(buses) ### Adding branches for i in range(0,self._raw_data["branch"].shape[0]): self._network.add_branch(Branch(self._raw_data["branch"][i]))
def test_estoi_good_fs(): """ Test extended STOI at sampling frequency of 10kHz. """ x = np.random.randn(2 * FS) y = np.random.randn(2 * FS) estoi_out = stoi(x, y, FS, extended=True) estoi_out_m = octave.feval('octave/estoi.m', x, y, float(FS)) assert_allclose(estoi_out, estoi_out_m, atol=ATOL, rtol=RTOL)
def test_stoi_good_fs(): """ Test STOI at sampling frequency of 10kHz. """ x = np.random.randn(2 * FS) y = np.random.randn(2 * FS) stoi_out = stoi(x, y, FS) stoi_out_m = octave.feval('octave/stoi.m', x, y, float(FS)) assert_allclose(stoi_out, stoi_out_m, atol=ATOL, rtol=RTOL)
def run_octave_script2(pk): out = None obj = ScriptCode.objects.get(pk=pk) user_folder = obj.get_user_folder() from oct2py import octave as oc import oct2py oc.addpath(user_folder) lst = tuple([2, 3]) try: out = oc.feval(obj.get_file_name(), *lst, plot_dir=user_folder + '/images/', timeout=3) except oct2py.Oct2PyError: print('Octave Error happened') self.update_state(state='FAILED', meta={'message': 'Octave Error Happened'}) oc.exit() oct2py.kill_octave() return None except TypeError: self.update_state(state='FAILED', meta={'message': 'type Error Happened'}) oc.exit() oct2py.kill_octave() return None oc.exit() oct2py.kill_octave() result = {} result['somethings'] = 0 result['out'] = out return result
def test_stdft(): """Test stdft by comparing to Octave""" x = np.random.randn(2 * FS) spec_m = octave.feval('octave/stdft.m', x, float(N_FRAME), float(N_FRAME / 2), float(NFFT)) spec_m = spec_m[:, 0:(NFFT // 2 + 1)].transpose() spec = stft(x, N_FRAME, NFFT, overlap=2).transpose() assert_allclose(spec, spec_m, atol=ATOL)
def test_stoi_upsample(): """ Test STOI at sampling frequency above 10 kHz. """ for fs in [8000]: x = np.random.randn(2 * fs) y = np.random.randn(2 * fs) octave.eval('pkg load signal') stoi_out = stoi(x, y, fs) stoi_out_m = octave.feval('octave/stoi.m', x, y, float(fs)) assert_allclose(stoi_out, stoi_out_m, atol=ATOL, rtol=RTOL)
def test_stoi_downsample(): """ Test STOI at sampling frequency below 10 kHz. """ for fs in [11025, 16000, 22050, 32000, 44100, 48000]: x = np.random.randn(2 * fs) y = np.random.randn(2 * fs) octave.eval('pkg load signal') stoi_out = stoi(x, y, fs) stoi_out_m = octave.feval('octave/stoi.m', x, y, float(fs)) assert_allclose(stoi_out, stoi_out_m, atol=ATOL, rtol=RTOL)
def test_hanning(): """ Compare scipy and Matlab hanning window. Matlab returns a N+2 size window without first and last samples. A custom Octave function has been written to mimic this behavior.""" hanning = scipy.hanning(N_FRAME+2)[1:-1] hanning_m = np.squeeze(octave.feval('octave/ml_hanning.m', N_FRAME)) assert_allclose(hanning, hanning_m, atol=ATOL)
def test_thirdoct(): """Test thirdoct by comparing to Octave""" obm_m, cf_m = octave.feval('octave/thirdoct.m', float(FS), float(NFFT), float(NUMBAND), float(MINFREQ), nout=2) obm, cf = thirdoct(FS, NFFT, NUMBAND, MINFREQ) obm_m = np.array(obm_m) cf_m = np.array(cf_m).transpose().squeeze() assert_allclose(obm, obm_m, atol=ATOL) assert_allclose(cf, cf_m, atol=ATOL)
def test_removesf(): """Test remove_silent_frames by comparing to Octave""" # Initialize x = np.random.randn(2 * FS) y = np.random.randn(2 * FS) # Add silence segment silence = np.zeros(3 * NFFT, ) x = np.concatenate([x[:FS], silence, x[FS:]]) y = np.concatenate([y[:FS], silence, y[FS:]]) xs, ys = remove_silent_frames(x, y, DYN_RANGE, N_FRAME, N_FRAME // 2) xs_m, ys_m = octave.feval('octave/removeSilentFrames.m', x, y, float(DYN_RANGE), float(N_FRAME), float(N_FRAME / 2), nout=2) xs_m = np.squeeze(xs_m) ys_m = np.squeeze(ys_m) assert_allclose(xs, xs_m, atol=ATOL) assert_allclose(ys, ys_m, atol=ATOL)
def denoise(wave): from oct2py import octave output = octave.feval('logmmse', np.trim_zeros(wave), 16000) return np.float32(np.squeeze(output))
for i, f in enumerate(hull.simplices): for j in range(3): cube.vectors[i][j] = hull.points[f[j], :] # Write the mesh to file "cube.stl" cube.save( 'D:\matlab_useful_codes\Mesh_voxelisation\Mesh_voxelisation\cube2.stl') ############################running matlab scripts in python ################################# from oct2py import octave as oct # octave = oct.oct2py('D:\Octave\Octave-5.1.0.0\mingw64\\bin\octave-cli.exe') import os oct.eval("cd D:\matlab_useful_codes\Mesh_voxelisation\Mesh_voxelisation") cwd = os.getcwd() oct.addpath(cwd) oct.addpath('D:\matlab_useful_codes\Mesh_voxelisation\Mesh_voxelisation') oct.feval('VOXELISE_example_function', 'cube2.stl', rmax2 - rmin2, cmax2 - cmin2, zmax2 - zmin2) # oct.feval('VOXELISE_example_function','cube2.stl',100,100,100) oct.eval("cd D:\matlab_useful_codes\Mesh_voxelisation") # oct.eval("save -v7 myworkspace.mat") from scipy.io import loadmat D = loadmat( "D:\matlab_useful_codes\Mesh_voxelisation\Mesh_voxelisation\myworkspace.mat" ) print(D.keys()) ########reading the .mat matrix convert it to numpy array and save it as .nrrd image using SimpleITK # z=sio.loadmat('test_voxel.mat') zz = np.zeros((d1, h1, w1), dtype=int) z2 = D['OUTPUTgrid'] # os.remove('cube2.stl') rmin3, rmax3, cmin3, cmax3, zmin3, zmax3 = bbox2_3D(z2) # zz[rmin2:,cmin2:,zmin2:]=z2
'length(cm)': lengthset, 'time': timeset, columns[0]: wifi0, columns[1]: wifi1, columns[2]: wifi2, columns[3]: wifi3, columns[4]: wifi4, columns[5]: wifi5 } with open(filename, "w+") as f: json.dump(data, f) print "New file %s has been written.\n" % filename #plot graph octave.addpath('/home/pi') octave.addpath('/home/pi/jsonlab') octave.feval("plot_signal_strength", filename) #set all values to the initial state delta = 0 accumulated_delta = 0 length = 0 last_heading = 0 count = 0 break finally: print "Exiting program!\n" GPIO.cleanup() # resets all input/output configurations
def differential_evolution(fobj, bounds, use_octave=False, mut=0.9, crossp=0.7, popsize=100, its=100): fitness_list = [] generations = [] dimensions = len(bounds) pop = np.random.rand(popsize, dimensions) min_b, max_b = np.asarray(bounds).T diff = np.fabs(min_b - max_b) pop_denorm = min_b + pop * diff if (use_octave): fitness = np.asarray( [octave.feval('peaks', ind) for ind in pop_denorm]) else: fitness = np.asarray( [octave.feval('rastrigin', ind) for ind in pop_denorm]) best_idx = np.argmin(fitness) best = pop_denorm[best_idx] for i in range(its): for j in range(popsize): idxs = [idx for idx in range(popsize) if idx != j] a, b, c = pop[np.random.choice(idxs, 3, replace=False)] mutant = np.clip(a + mut * (b - c), 0, 1) cross_points = np.random.rand(dimensions) < crossp if not np.any(cross_points): cross_points[np.random.randint(0, dimensions)] = True trial = np.where(cross_points, mutant, pop[j]) trial_denorm = min_b + trial * diff if (use_octave): f = octave.feval('peaks', trial_denorm) else: f = fobj(trial_denorm) if f < fitness[j]: fitness[j] = f pop[j] = trial if f < fitness[best_idx]: best_idx = j best = trial_denorm yield best, fitness[best_idx] print("Best individual in generation %s : %f , %f" % (i + 1, best[0], best[1])) print("Best individual score in generation %s : %s" % (i + 1, fitness[best_idx])) fitness_list.append(fitness[best_idx]) generations.append(i + 1) plot_chart(fitness_list, generations)
def test_mc(self): # Test all common algorithmstest_bc for algorithm in self.common_algorithms_mc: print("Testing ", algorithm, " (mc)") # Test all files in directory for filename in self.mc_files: path = self.mc_test_dir + '/' + filename path_octave = '/test/mc/' + filename # Octave execution mean_err_oct, std_error_oct, mean_nSV_oct, std_nSV_oct, mean_time_oct, std_time_oct = octave.feval( './LIBOL-0.3/demo.m', 'mc', algorithm, path_octave, 'libsvm', nout=6) # Python execution result_python = run('mc', algorithm, path, 'libsvm', print_results=False, test_parameters=True) mean_err_py = result_python[0] mean_nSV_py = result_python[1] mean_time_py = result_python[2] # Test for similar performance error_diff = abs(mean_err_oct - mean_err_py) self.assertLessEqual(error_diff, 6 * std_error_oct) # Test for better execution time self.assertLessEqual(mean_time_py, mean_time_oct)
def track(camera): # EVENT LISTENER octave.addpath('/home/Shuyang/Downloads/update/Velocity_Control_Constrained_ABB_OpenRAVE') egm=rpi_abb_irc5.EGM() # Initialize Robot Parameters [ex,ey,ez,n,P,q_nouse,H,ttype,dq_bounds] = octave.feval('robotParams', nout=9) # Initialize Control Parameters # initial joint angles q = np.zeros((6, 1)) [R,pos] = octave.feval('fwdkin', q,ttype,H,P,n, nout=2) dq = np.zeros((int(n),1)) # velocities w_t = np.zeros((3, 1)) v_t = np.zeros((3, 1)) # create a handle of these parameters for interactive modifications obj = ControlParams(ex,ey,ez,n,P,H,ttype,dq_bounds,q,dq,pos,orien,pos_v,ang_v[None, :],w_t,v_t,epsilon,view_port,axes_lim,inc_pos_v,inc_ang_v,0,er,ep,0) dt = 0 counter = 0 req_exit = [] StateVector = [] listener = threading.Thread(target=input_thread, args=(req_exit,)) listener.start() tag_index = 0 Roc = np.array([[0.4860,-0.1868,-0.8537], [0.0583, -0.9678, 0.2450], [-0.8720, -0.1688, -0.4595]]) Poc = np.array([[3579.5], [-826.5], [1416.7]]) # Kalman Filter Parameters Phi = np.matrix('1 0 0 1 0 0; 0 1 0 0 1 0; 0 0 1 0 0 1; 0 0 0 1 0 0; 0 0 0 0 1 0; 0 0 0 0 0 1') R = np.eye(3,3)*1000 Q = np.eye(6)*1000 H = np.eye(3,6) Cov = np.eye(6,6)*1500 while not req_exit: if counter != 0: end = time.time() dt = end-start start = time.time() counter = counter + 1 if counter != 0: J_eef = octave.feval('getJacobian', obj.params['controls']['q'], obj.params['defi']['ttype'], obj.params['defi']['H'], obj.params['defi']['P'], obj.params['defi']['n']) data = [] # Search if the camera module fails to find the tag for 30 consecutive frames for x in range(0,30): data = camera.get_all_poses()[tag_index] if data != []: break; # SEARCH TERMINATED DUE TO BREAK SIGNAL if data == []: print "No data." return # Follow tag while it is in view else: Z = data[0] # Kalman Filter: Initialization if StateVector == []: StateVector = np.concatenate( (Z,np.array([[10],[10],[10]])),axis =0 ) # Kalman Filter: Prediction StateVector = np.matmul(Phi, StateVector) Cov = np.matmul(np.matmul(Phi, Cov),np.transpose(Phi)) + Q # Kalman Filter: Update K = np.matmul(np.matmul(Cov, np.transpose(H)),np.linalg.inv(np.matmul(H,np.matmul(Cov, np.transpose(H))) +R)) StateVector = StateVector + np.matmul(K,(Z-np.matmul(H,StateVector))) Cov = (np.eye(6,6)-K*H)*Cov Z_est = np.array(StateVector[:3]) Poa = np.matmul(Roc, Z_est) + Poc Poa = Coordinate_mapping(Poa) print "Poa:", np.transpose(Poa) obj.params['controls']['dq'] = np.linalg.inv(J_eef[3:6, :])*(Poa - obj.params['controls']['q']) # desired joint velocity obj.params['controls']['q'] = obj.params['controls']['q'] + obj.params['controls']['dq']*dt res, state = egm.receive_from_robot(0.01) if res: a = np.array(state.joint_angles) a = a * 180 / np.pi print "Joints: " + str(a) egm.send_to_robot([float(x)*180/np.pi for x in obj.params['controls']['q']]) print "Target Joints: " + str([float(x)*90/np.pi for x in obj.params['controls']['q']])
def CRP(filepath, file): octave.eval('pkg load signal') crp = octave.feval('extract_CRP', filepath, file) return crp