def load_from_matlab_files( self, index_fname=None, generators_fname=None, matname=None): """ index_fname : path to matrix of map on generators (may have to provide internal name of the matlab matrix to extract it from meta data. See example below. ) generators_fname : path to the region --> geneators map. Example: -------- hom_matrix = utils.load_matlab_matrix( 'henon_index.mat', 'hom_matrix' ) region2gen = utils.convert_matlab_gens( 'henon_gens.mat' ) map_on_regions = utils.index_map_to_region_map( hom_matrix, region2gen, shift=-1) """ self.index_fname = index_fname self.generators_fname = generators_fname self.index_map = utils.load_matlab_matrix( self.index_fname, matname ) self.region2gen = utils.convert_matlab_gens( self.generators_fname )
#!/usr/bin/python import sys import numpy as np import scipy.io from rads.misc import utils from rads.symbolics.sofic_processor import SoficProcessor for f in "ap1r2.mat ap2r6.mat ap3r2.mat ap3r4.mat ap4r2.mat ap5r2.mat ap5r3.mat ap6r5.mat ap7r3.mat ap8r2.mat ap8r3.mat ap9r2.mat ap9r3.mat ap11r8.mat ap12r8.mat ap13r8.mat ap14r8.mat ap15r8.mat".split(" "): dat = utils.load_matlab_matrix( '/home/raf/Dropbox/projects/plateaus/focm-data/'+f, matname='d') print f # the [0,0][0,1] is to get the second entry of the cell, i.e. dat.M_inv{2} M = dat['M_inv'][0,0][0,1] G = utils.cell2dict(dat['G_inv'][0,0][0,1][0]) sof = SoficProcessor(M,G) sof.process() print sof print 'entropy:', sof.entropy() # ap1r2.mat # SoficProcessor on 886 symbols, with 1096 states and 2065 transitions # entropy: 0.637936814478 # ap2r6.mat # SoficProcessor on 553 symbols, with 689 states and 1294 transitions # entropy: 0.637347707344 # ap3r2.mat # SoficProcessor on 834 symbols, with 999 states and 1870 transitions # entropy: 0.639166621114 # ap3r4.mat # SoficProcessor on 649 symbols, with 728 states and 1359 transitions
#!/usr/bin/python import sys import numpy as np import scipy.io from rads.misc import utils from rads.symbolics.sofic_processor import SoficProcessor datcell = utils.load_matlab_matrix('/home/raf/Dropbox/projects/plateaus/focm-data/results-9-2-2007/results_apboxprm_b2_d22.mat', matname='D') ents = np.zeros(datcell.shape) for i in range(datcell.shape[0]): for j in range(datcell.shape[1]): M = datcell[i,j][0,2] G = utils.cell2dict(datcell[i,j][0,1][0]) sof = SoficProcessor(M,G) sof.process() print sof ents[i,j] = sof.entropy() print 'entropy:', ents[i,j] np.savetxt('plateaus_ap_b2_22.txt',ents) # SoficProcessor on 2 symbols, with 6 states and 10 transitions # entropy: 0.528048909513 # SoficProcessor on 2 symbols, with 6 states and 10 transitions # entropy: 0.528048909513 # SoficProcessor on 2 symbols, with 6 states and 10 transitions # entropy: 0.528048909513
#print "Drawing all verified semi-conjugate subshifts..." #re1.draw() print "" ## EXPECTED OUTPUT for Leslie map files # >>> Testing with Numpy matices... # >>> Maximum entropy found: 0.150632111601 ############################## # test matlab functionality ############################## # load from matrix and dict print "Testing ability to start off with Matlab matrices..." hom_matrix = utils.load_matlab_matrix( fname_mat, matname ) region2gen = utils.convert_matlab_gens( reg_mat ) re2 = RigorousEntropy( index_map=hom_matrix, reg2gen=region2gen ) re2.prepare_regions() # drawing the map on regions print "Drawing the maps on strongly connected components (disjoint regions in the MVM)...\n" fig = re2.map_on_regions.draw() re2.compute_entropy() re2.get_max_entropy()
import numpy as np from rads.misc import utils from rads.symbolics.sofic_processor import SoficProcessor if len(sys.argv) < 3: print "usage: python test_sofic.py <data file> [<index_map> <generators>]" print "where <index_map> and <generators> default to M and G" genn = 'G' mapn = 'M' else: genn = sys.argv[2] mapn = sys.argv[3] filename = sys.argv[1] gens = utils.convert_matlab_gens( filename, genname=genn ) index_map = utils.load_matlab_matrix( filename, matname=mapn ).astype(int) sof = SoficProcessor( index_map, gens, debug=False ) sof.process() print sof print sof.entropy() # for i in range(ca.shape[0]): # gens = utils.cell2dict(ca[i,0]) # sof = SoficProcessor(ca[i,1],gens) # sof.process() # print sof # print sof.entropy() # ca = utils.load_matlab_matrix( '/home/raf/Dropbox/henon-tipping-14-run-goodruns.mat', matname='e' ) # ents = []
#!/usr/bin/python import sys import numpy as np import scipy.io from rads.misc import utils from rads.symbolics.sofic_processor import SoficProcessor dat = utils.load_matlab_matrix( '/home/raf/projects/std/std-eps2-p2-runs/std-eps2-p2-plus34-run-dat.mat', matname='dat') # the [0,0][0,1] is to get the second entry of the cell, i.e. dat.M_inv{2} M = dat['M_inv'][0,0][0,1] G = utils.cell2dict(dat['G_inv'][0,0][0,1][0]) sof = SoficProcessor(M,G) sof.process() print sof print 'entropy:', sof.entropy() # SoficProcessor on 41 symbols, with 68 states and 127 transitions # entropy: 0.571595590383 # up from STD: Theorem 4.4. The topological entropy for the standard map for eps = 2 is bounded below by 0.54518888942276. # 5/7/2017 TODO: minimize? (point being: we get a better number with a smaller description...)
# A <--> 0, B <--> 1, etc. region2gen = { 0 : [0,1], 1 : [2], 2 : [3,4] } symbols = numpy.matrix( [[0,1,1], [1,0,0], [0,1,1]] ) map_on_regions = DiGraph() map_on_regions.from_numpy_matrix( symbols ) if 1: hom_matrix = utils.load_matlab_matrix( 'henon_index.mat', 'hom_matrix' ) region2gen = utils.convert_matlab_gens( 'henon_gens.mat' ) map_on_regions = utils.index_map_to_region_map( hom_matrix, region2gen, shift=-1) if 0: hom_matrix = utils.load_matlab_matrix( 'leslie_index.mat', 'hom_matrix' ) region2gen = utils.convert_matlab_gens( 'leslie_gens.mat' ) map_on_regions = utils.index_map_to_region_map( hom_matrix, region2gen, shift=-1) ######################## # # APPEARS THAT BAD EDGE SETS ARE BEING THROWN INTO ONE (1) SET. CHECK THIS!! # ########################