[Matlab] Cambiare "forma" a una cella

[cumel]

Buongiorno a tutti,
sto sbattendo la testa su un problema credo molto semplice, ma non banale:

voglio cambiare il contenuto di una cella come nell0esempio seguente, senza ricorrere a cicli for espliciti:

Da
a = {'1 2 3' ; '4 5 6' ; '7 8 9' ....} stringhe successive

A
b = { '1 2 3; 4 5 6; 7 8 9'} matrice di numeri

Qualcuno mi sa aiutare o suggerire dove posso rivolgermi?

Grazie mille ebuona giornata

MK

[tæo]

non ho ben capito cosa intendi con "b = { '1 2 3; 4 5 6; 7 8 9'} matrice di numeri" dato che b in quel caso sarebbe una cella 1x1 contenente una sola stringa. ad ogni modo ti propongo questo metodo per ottenere una matrice di double:

a = { '1 2 3' ; '4 5 6' ; '7 8 9' }
a = 

    '1 2 3'
    '4 5 6'
    '7 8 9'

b = str2num(cell2mat(a))
b =

     1     2     3
     4     5     6
     7     8     9

whos
  Name      Size            Bytes  Class     Attributes

  a         3x1               210  cell                
  b         3x3                72  double

[cumel]

Carissimo,
ti ringrazio molto, il tuo suggerimento centra l'obiettivo!

Tuttavia il vantaggio, rispetto al ciclo for, è minore di quanto mi aspettassi

(nel mio esempio passo
da Elapsed time is 1.189569 seconds.
a Elapsed time is 0.817373 seconds.)

Ma su file tipici iil tempo impiegato è di qualche minuto

Sto provando con una formula del tipo

c = arrayfun(@str2num, b);

che però non riesco a far funzionare correttamente. (mentre mi funziona correttamente la seguente b = arrayfun(@without_G,DISPL_BLOCK); dove without_G è una funzione da me definita)

Ti chiedo se
1. mi sai suggerire una correzione alla mia proposta
2. credi che una volta corretta possa essere più veloce.

In ognio caso ti ringrazio del tuo suggerimento precedente e ti auguro buiona giornata.

MK

[tæo]

giustamente cerchi di vettorizzare il codice ma credo che uno dei problemi più grossi sia l'uso della funzione "str2num", che nel tuo caso non può essere eliminata. ti consiglio di usare il profiler per vedere dove perdi più tempo, io ho testato su un array di 100000 elementi le due opzioni:

arrayfun(@num2str,a, 'UniformOutput',false)

for i=1:length(a)
    b(i) = num2str(a(i));
end

ed hanno impiegato praticamente lo stesso tempo (ho usato num2str per comodità, ma suppongo che i risultati valgano anche per la funzione duale str2num)


se lo ritieni utile prova a scrivere qualche dettaglio ulteriore e vediamo cosa possiamo fare

[cumel]

errata corrige

[cumel]

errata corrige

[cumel]

Ciao, ho fatto numerose prove e non ho trovato meglio di come già discusso.
Ti ringrazio e ti propongo un secondo probma che sono riuscito a risolvere con grandissimo dispendio di tempo computazionale e per il quale ritengo sia meglio cambiare approccio.

Il testo di partenza è questo:

'1119 A 2001 0.0000 '
'2002 0.0000 '
'2009 0.0000 '
'2010 0.0001 '
'1126 C 2001 0.0000 '
'2002 0.0000 '
'2009 0.0000 '
'2010 0.0000 '
'1157 B 2001 0.0000 '
'2002 0.0000 '
'2010 0.0000 '

I dati finali (sempre in forma di matrice da inserire in una cella):

1119 2001 0,0
1119 2002 0,0
1119 2009 0,0
1119 2010 0,0001
1126 2001 0,0
1126 2002 0,0
1126 2009 0,0
1126 2010 0,0
1157 2002 0,0
1157 2010 0,0

Io ho usato un ciclo for che legge riga per riga, discrimina se è una riga con le lettere ed eventualmente la pulisce e poi legge le righe successive riportando il primo valore della riga con il numero nel primo campo della riga precedente con la lettera (ora ripulita).

Credo che sia assolutamente necessario vettorializzare, ma non riesco a farlo data la diversa struttura delle varie righe (peraltro non a blocchi fissi).

Se hai qualche suggeriemnto ti sono grato.

MK

[tæo]

in questo caso non vedo come potresti vettorizzare il codice, ho provato a scrivere due righe di codice e questo è il risultato:

a = textread('data.txt','%s','delimiter','\n');
b = zeros(size(a,1),3);

for i=1:length(a)
    spaces = regexp(a{i},'\s+');
    
    if length(spaces)==4
        head   = a{i}(1:spaces(1));
    else
        spaces(1:4) = [1 1 spaces];
    end
    
    b(i,1) = str2double(head);
    b(i,2) = str2double(a{i}(spaces(2):spaces(3)));
    b(i,3) = str2double(a{i}(spaces(3):end));
    
end

dove data.txt è un file del tipo:

1119 A 2001 0.0000 
2002 0.0000 
2009 0.0000 
2010 0.0001 
1126 C 2001 0.0000 
2002 0.0000 
2009 0.0000 
2010 0.0000 
1157 B 2001 0.0000 
2002 0.0000 
2010 0.0000

i tempi di esecuzione non sono drammatici, per processare un file di ~15000 righe ci ha messo 3.5 secondi, tra l'altro, secondo il profiler ~75% del tempo è speso da str2double.

[cumel]

Grazie,
la tua idea è valida, ma solo in parte, perchèuno dei problemi che ho trovato è che la lunghezza di b è variabile (nel senso che le righe di b possono andare da zero a una ventina) e il tuo estratto non risolve questo problema...

Avevo approcciato in questo modo ma è super dispendioso:

for j=1:numel(BLOCK_RED)
if ( (findstr('A BLOCK_RED{j}) > 0 ) ...
| (findstr('B, BLOCK_RED{j}) > 0) ...
| (findstr('C, BLOCK_RED{j}) > 0) ...
| (findstr('D, BLOCK_RED{j}) > 0) ) %verifica se prima riga
PRIMA = sscanf(BLOCK_RED{j}, '%d %*s %d %f')'; % legge la prima
pippo = PRIMA(1);
pappo = PRIMA(1);
ROW = PRIMA;
else
SUCC = sscanf(BLOCK_RED{j}, '%d %f')'; % righe successive
ROW = [pippo, SUCC]; %recupera le info dalla prima riga
end%if
TEMP = [TEMP; ROW];

TEMP = [TEMP; ROW];

DATI_FINALI{i} = TEMP;

Adwesso provo a smanettarci un po', ma il mio obiettivo è di satre sotto i 30 secondi per 2 milioni di righe.

La vedo dura...

Ti iringrazio ancora per gli spunti preziosi.
Programmare non è il mio mestiere e si vede...

Se non ti scoccia e hai altyre idee sono super ben accette.

MK

[tæo]

non credo che matlab sia lo strumento migliore per fare quello di cui hai bisogno. tu lavori con forloop, stringhe, I/O di sistema, codice non vettorizzabile e conversione di tipi, tutte cose che scalano male in matlab.

ti consiglio di codificare questa procedura in C, eventualmente in un MEX file se lo vuoi chiamare da codice matlab.


comunque non ho capito cosa contiene la variabile b, e a cosa ti riferisci con "lunghezza di b variabile"

[cumel]

Purtroppo non conosco nessun linguaggio vero e proprio...
quindi mi dovrò arrangiare con matlab.

Scusa, non sono stato chiaro nella spiegazione:
chiamo "a" le righe con la lettera, e "b" le righe successive (senza lettera).
Queste ultime non sono sempre lo stesso numero e quindi devo inserire un controllo che discrimina se la riga appartiene al tipo "a" va trattata in un modo, se appratiene al tipo "b" in un altro.

Pensavo che un modo furbo fosse aggiungere a TUTTE le righe in maniera "vettoriale" due colonne di zeri per esempio.
E poi prendere gli ultimi elementi come nell'esempio sotto.

ORIGINALE

1119 A 2001 0.0000
2002 0.0000
2009 0.0000
2010 0.0001
1126 C 2001 0.0000
2002 0.0000
2009 0.0000
2010 0.0000
1157 B 2001 0.0000
2002 0.0000
2010 0.0000

PRIMO PASSO: VIA LE LETTERE

1119 2001 0.0000
2002 0.0000
2009 0.0000
2010 0.0001
1126 2001 0.0000
2002 0.0000
2009 0.0000
2010 0.0000
1157 2001 0.0000
2002 0.0000
2010 0.0000

SECONDO PASSO AGGIUNTA COLONNE

0 0 1119 2001 0.0000
0 0 2002 0.0000
0 0 2009 0.0000
0 0 2010 0.0001
0 0 1126 2001 0.0000
0 0 2002 0.0000
0 0 2009 0.0000
0 0 2010 0.0000
0 0 1157 2001 0.0000
0 0 2002 0.0000
0 0 2010 0.0000


CAT FINALE (TENGO SOLO GLGLI ULTIMI 3 ELEMENTI)

1119 2001 0.0000
0 2002 0.0000
0 2009 0.0000
0 2010 0.0001
1126 2001 0.0000
0 2002 0.0000
0 2009 0.0000
0 2010 0.0000
1157 2001 0.0000
0 2002 0.0000
0 2010 0.0000

E INFINE SOSTITUISCO GLI ZERI CON IL NUMERO DIVERSO DA ZERO PESCATO DALLA RIGA PRECEDENTE TRADUCO IN NUMERI

DI QUI A MATLAB IL PASSO E' DURO...

Spero di essere stato chiaro in modo da non renderti improba la comprensione.
MK

[tæo]

la mia soluzione funziona per qualunque numero di righe "b":

a = textread('data.txt','%s','delimiter','\n');
b = zeros(size(a,1),3);

for i=1:length(a)
    spaces = regexp(a{i},'\s[A-Z0-9]');
    
    if length(spaces)==3
        head = a{i}(1:spaces(1));
    else
        spaces(1:3) = [1 1 spaces];
    end
    
    b(i,1) = str2double(head);
    b(i,2) = str2double(a{i}(spaces(2):spaces(3)));
    b(i,3) = str2double(a{i}(spaces(3):end));
    
end

questa è una versione leggermente modificata (la regexp ignora eventuali spazi al termine di ogni riga)

con questo data.txt:

1119 A 2001 0.0000 
2002 0.0000 
2009 0.0000 
2010 0.0001 
2002 0.0000 
2009 0.0000 
2010 0.0001 
2002 0.0000 
2009 0.0000 
2010 0.0001 
1126 C 2001 0.0000 
2002 0.0000 
2009 0.0000 
2010 0.0000 
2002 0.0000 
2009 0.0000 
1157 B 2001 0.0000 
2002 0.0000 
2010 0.0000

ottengo:

   1.0e+03 *

    1.1190    2.0010         0
    1.1190    2.0020         0
    1.1190    2.0090         0
    1.1190    2.0100    0.0000
    1.1190    2.0020         0
    1.1190    2.0090         0
    1.1190    2.0100    0.0000
    1.1190    2.0020         0
    1.1190    2.0090         0
    1.1190    2.0100    0.0000
    1.1260    2.0010         0
    1.1260    2.0020         0
    1.1260    2.0090         0
    1.1260    2.0100         0
    1.1260    2.0020         0
    1.1260    2.0090         0
    1.1570    2.0010         0
    1.1570    2.0020         0
    1.1570    2.0100         0

la soluzione ha quindi un costo lineare nel numero di righe, e la maggior parte del tempo è impiegata dalla conversione stringa->double.

[cumel]

ho adattato al mio caso specifico il tuo file: funziona bene.
Mi sembra che meglio di così usando matlab non si possa fare.

Tra l'altro già questo è meglio della lettura sequenziale con while (approccio che avevo utilizzato in una prima fase).

Grazie e spero che questa discussione e i tuoi consigli possano essere utili non solo a me!

MK