2015-06-01 25 views
7

Esiste un sistema dinamico non lineare x_n = f(x_n,eta) la cui forma funzionale è x[n+1] = 2*x[n] mod 1. Questo è un sistema dinamico caotico chiamato mappa di Sawtooth o Mappa di Bernoulli. Sto affrontando difficoltà nell'implementazione delle due rappresentazioni della mappatura inversa fornite da Eq (4) ed Eq (5). Di seguito è riportata una breve descrizione del problema.Matlab: impossibile ottenere razionali univoci quando si implementa una formula per la conversione da binario a numero reale Parte

description

cui la sequenza (s[n+k])_k=1 to N-1 è la descrizione simbolica dello x[n]. Questa descrizione deriva dal partizionamento dell'intervallo apparecchiatura descritta di seguito.

Let, il numero di partizioni M = 2 e lo spazio simbolo = {0,1} e la regola per l'assegnazione dei simboli è

s[n+1] = 1 if x[n] >= 0.5, otherwise s[n+1] = 0 

autori di questo documento:

Linear, Random Representations of Chaos 

Per Eq (5) Non ottengo le stesse serie temporali dopo l'inverso, alcuni valori differiscono dopo aver eseguito la conversione da binario a reale. Qualcuno può darmi la procedura corretta?

Ho provato a implementare la mappa Bijective per Eqs (4) e (5), ma non funziona.

Codice per Eq (5) - I binarizing in 2 modi. x contiene i numeri reali; s è l'equivalente binario 0/1 di ogni reale; y è la risposta dopo la conversione di s in real. s1 è l'equivalente binario + 1/-1 di x; b è la risposta dopo la conversione in real. In questo caso di + 1/-1, quando sto convertendo da rappresentazione simbolica a reale, cambio -1 con 0 e poi applico la formula in Eq (5). Dalle risposte, si può vedere che e b non corrispondono a x dopo aver eseguito la conversione. Ottengo anche i veri negativi per b quando i real originali sono tutti razionali senza segno !! Come posso implementare correttamente in modo che siano entrambi uguali?

N =10; 
x(1) = 0.1; 
for i =1 : N 
     x(i+1) = mod(x(i)*2, 1); 
end 
    y = x; 
s = (y>=0.5); %generate 0/1 logicals 


for n = 1: N   
y(n) = 0.5*s(n+1) + 0.5*y(n+1); 
end 

b=x; 

s1 = 2*(b>=0.5)-1; %Generate +1/-1 



    for k =1: N 
    if s1(k)== -1 
     s1(k) = 0; 
    end 
b(k) = 0.5*s1(k+1) + 0.5*b(k+1); 
end 

Let, x =

0.100000000000000 0.200000000000000 0.400000000000000 0.800000000000000 0.600000000000000 0.200000000000000 0.400000000000000 0.800000000000001 0.600000000000001 0.200000000000003 0.400000000000006 

y =

0.100000000000000 0.200000000000000 0.900000000000000 0.800000000000000 0.100000000000000 0.200000000000000 0.900000000000000 0.800000000000001 0.100000000000001 0.200000000000003 0.400000000000006 

b =

-0.400000000000000 0.700000000000000 0.900000000000000 -0.200000000000000 -0.400000000000000 0.700000000000000 0.900000000000000 -0.199999999999999 -0.399999999999999 -0.299999999999997 0.400000000000006 
+0

Secondo l'equazione 4, 'k' aumenta da' n' a 'n + N-1'. Quindi '\ beta_inverse (s_n)' usa 's_n'? Come? Inoltre non penso che usi 's (9), ..., s (1)'. Un'altra cosa, dobbiamo leggere l'intera domanda per rispondere? –

+0

S_n è un vettore di n simboli e hai ragione, S_10 usa s_10, s_11 e così via. Ad esempio, S = beta (binary_of_x) = beta (0,101) = 0,01 – SKM

+0

Ci sono troppe modifiche importanti nelle domande OP, spesso dopo che sono state fornite le risposte. Questo è il numero sei, se la memoria funziona correttamente. Cercherò di segnalarli a un moderatore quando avrò tempo - nel frattempo, per favore, desista da tali importanti modifiche. Ci piace conservare le domande nella forma in cui sono state poste, a meno che non ci siano circostanze attenuanti. – halfer

risposta

2

questo pezzo del vostro codice è completamente sbagliato, si cambia s (k) ma tu usi s (k + 1), significa che cambiare s (k) non ha alcun effetto!

for k =1: N 
    if s1(k)== -1 
     s1(k) = 0; 
    end 
b(k) = 0.5*s1(k+1) + 0.5*b(k+1); 
end 

vera è:

for k =1: N+1 
    if s1(k)== -1 
     s1(k) = 0; 
    end 
    end 
    for k =1: N 
     b(k) = 0.5*s1(k+1) + 0.5*b(k+1); 
    end 

y =

colonne da 1 a 10

0.1000 0.2000 0.9000 0.8000 0.1000 0.2000 0.9000 0.8000 0.1000 0.2000 

Colonna 11

0.4000 
.210

b =

colonne da 1 a 10

0.1000 0.2000 0.9000 0.8000 0.1000 0.2000 0.9000 0.8000 0.1000 0.2000 

Colonna 11

0.4000 

x = 0,1 0,2 0,4 0,8

1) b = x => b = 0,1 0,2 0,4 0,8

2) s1 = 2 (b> = 0,5) -1 => s1 = -1 -1 -1 1

3) anello su s1 => s1 = 0 0 0 1

4) b (3) = 0.5 * s (4) 0,5 (b4) = 0,5 + 0,4 = 0,9

quindi il codice è corretto, ma la tua formula è corretta! e un'altra cosa,> i punti 3 e 4 si cancellano a vicenda, voglio dire che il risultato dei passaggi 3 e 4 insieme è (b> 0.5), e come conclusione! è ovvio dalla tua formula che se x (i)> 0.5 e x (i-1) < 0.5 allora b (i-1) non può essere uguale a x (i-1)

perché b (i-1) = 0.5 * x (i) 0,5 * ((x (i)> 0.5))

e se assumiamo x (i)> 0.5 possiamo scrivere:

b (i-1) = 0,5 * X (i) + 0.5 * 1

e sappiamo x (i) = mod (2x (i-1), 1) = 2 * x (i-1) {perché x (i-1) < 0,5 so 2 * x (i-1) < 1}

quindi abbiamo

b (i-1) = 0,5 * 2 * X (i-1) + 0,5 * 1 = X (i-1) +0,5 => b (i-1)> 0,5, ma x (i- 1) < 0,5 !!!!!

quindi la tua formula è sbagliata.

+0

Grazie per la risposta.Tuttavia, il problema principale che converte il binario in reale come fatto dall'implementazione corretta non è uguale ai numeri reali originali, x. Perché i valori in b non sono uguali ai valori in x? – SKM

+0

Inoltre, c'è un nuovo errore che sto tentando di accedere a s1 (129); indice fuori limite perché size (s1) = [128] (dove N = 128 anziché N = 10 – SKM

+0

controlla la dimensione di x (o b, ecc.) se è 128, N deve essere 127! –