---

Hejsa

Jeg er på udkig efter en algoritme der kan finde
minimum i et array uden brug af for meget hukommelse.

Problemet er at arrayet fylder for meget og jeg får
et "out of memory" problem (hukommelsen på det
system jeg implementerer algoritmen på er ret
begrænset).

Jeg har et array A[m][n] som har størrelsen 300 * 512

Den n'te søjlevektor i A betegner jeg som A(:,n)

Den m'te rækkevektor i A betegner jeg som A(m,:)

A er til at starte med fyldt med 0'er.

Min pseudo-kode ser sådan her ud:

1) m=1
2) Indlæs ny rækkevektor i A(m,:)
3) For alle n udregn A_min[n]=min(A(:,n))
4) m=m+1
5) hvis m>300 så sæt m=1
6) gå til 2

Håber at der er nogen derude der kender en smart algoritme
med samme funktionalitet som ovennævnte??

Tak på forhånd.

---

Jack skrev:

> Jeg har et array A[m][n] som har størrelsen 300 * 512

> Min pseudo-kode ser sådan her ud:

> 1) m=1
> 2) Indlæs ny rækkevektor i A(m,:)

Indlæse hvor? Hvorfor ikke bare gennemløbe alle værdierne?

minimum=A[0][0]; // Garanterer at tallet er med i arrayet.
for (m=0; m<300; ++m) for (n=0; n<512; ++n)
   if (A[m][n]<minimum) minimum=A[m][n];

Krydspostet til: <news:dk.edb.programmering.c>,<news:dk.videnskab>
Fut til: <news:dk.edb.programmering.c>
Svar herpå sendes dertil hvis man ikke ændrer det.

--
Bertel
http://bertel.lundhansen.dk/      http://fiduso.dk/

---

>
> Indlæse hvor? Hvorfor ikke bare gennemløbe alle værdierne?

Der indlæses nye rækkevektorer hele tiden.

> minimum=A[0][0]; // Garanterer at tallet er med i arrayet.
> for (m=0; m<300; ++m) for (n=0; n<512; ++n)
> if (A[m][n]<minimum) minimum=A[m][n];

Det er sådan jeg har lavet det p.t. men det sparer jo ikke hukommelse.
Jeg prøver at finde en metode hvor jeg løbende indlæser rækkevektorer
men ikke behøver et array på 300*512 celler.

---

[ jack@nospammers.please ]

[ ... ]

> Der indlæses nye rækkevektorer hele tiden.


Men da er det bare å gjennomløpe disse vektorene fortløpende.

[ ... ]


> Det er sådan jeg har lavet det p.t. men det sparer jo ikke
> hukommelse.


Fokuset ditt ligger helt feil sted. Med unntaket av noen *meget*
spesielle problemstillinger, er 512*300 uinteressant lite plass.


> Jeg prøver at finde en metode hvor jeg løbende indlæser
> rækkeveektorer men ikke behøver et array på 300*512 celler.


Da kan du fremdeles bruke Bertels forslag. Sammenligningen med
"hittil" minimumsverdien kan skjer samtidig med innlesingen.





ivr
--
"...but it's HDTV -- it's got a better resolution than the real world."
       -- Fry, "When aliens attack"

---

> Fokuset ditt ligger helt feil sted. Med unntaket av noen *meget*
> spesielle problemstillinger, er 512*300 uinteressant lite plass.

Så må min problemstilling være meget speciel. Jeg har jo skrevet
at jeg får et "out of memory"-problem på det system jeg programmerer
netop fordi hukommelsen er ret lille.

> Da kan du fremdeles bruke Bertels forslag. Sammenligningen med
> "hittil" minimumsverdien kan skjer samtidig med innlesingen.

Bertels forslag er baseret på en misforståelse af det jeg skrev, så
forslaget er ikke brugbart.

---

Den Tue, 21 Feb 2006 22:21:26 +0100 skrev Jack:
>
>> Fokuset ditt ligger helt feil sted. Med unntaket av noen *meget*
>> spesielle problemstillinger, er 512*300 uinteressant lite plass.
>
> Så må min problemstilling være meget speciel. Jeg har jo skrevet
> at jeg får et "out of memory"-problem på det system jeg programmerer
> netop fordi hukommelsen er ret lille.
>
>> Da kan du fremdeles bruke Bertels forslag. Sammenligningen med
>> "hittil" minimumsverdien kan skjer samtidig med innlesingen.
>
> Bertels forslag er baseret på en misforståelse af det jeg skrev, så
> forslaget er ikke brugbart.

Så prøv at forklare det lidt bedre, for så tror jeg ikke der er
*nogen* der har forstået hvilken del det er du ikke kan finde ud af.

Mvh
Kent
--
Hard work may pay off in the long run, but laziness pays off right now.

---

[ jack@nospammers.please ]

[ ... ]

> Så må min problemstilling være meget speciel. Jeg har jo skrevet at
> jeg får et "out of memory"-problem på det system jeg programmerer
> netop fordi hukommelsen er ret lille.


.... og du har allerede minneprofilert koden din og har fastslått at
512*300 matrisen er minnesluken?


> Bertels forslag er baseret på en misforståelse af det jeg skrev, så
> forslaget er ikke brugbart.


Bertels forslag kan generaliseres *trivielt* til å finne det maksimale
elementet i en vilkårlig inputstrøm. Om data i den strømmen er
organisert i en matrise eller ikke er helt uvesentlig.





ivr
--
"...but it's HDTV -- it's got a better resolution than the real world."
       -- Fry, "When aliens attack"

---

Hvis jeg har forstået korrekt, behøver du kun at have
512 pladser i dit array:
Dit index på 300 bruger du ikke til noget, - eller?

mvh Thor

---

Ok, jeg undskylder min dårlige evne til at forklare mig...

Jeg har som sagt et array bestående af 300 rækker hvor hver
række indeholder 512 tal.

Min algoritme starter med at indlæse 512 tal som placeres på
1. række i arrayet.

** Dernæst checker jeg for hver kolonne i arrayet hvilket tal i
kolonnen der er minimum. Minimum for kolonne j placeres
på j'te plads i min "minimums-vektor". Min "minimums-vektor"
er som følge heraf en vektor med 512 minima.

Nu indlæser jeg så igen 512 tal som denne gang placeres på
2. række i arrayet.

Jeg kører igen ovenstående procedure (**) og indlæser igen
512 tal som placeres på 3. række i arrayet, kører proceduren (**)
og så fremdeles.

Når jeg har indlæst 512 tal og placeret dem på den 300. række
og udregnet minimums-vektoren, starter det hele forfra igen forstået
på den måde at den næste indlæsning sker til række 1 i arrayet...

Håber jeg har forklaret mig bedre denne gang?

I Matlab ville det se sådan her ud:

clc
close all
clear
minimums_vektor=zeros(1,512)
tal_array=zeros(300,512);
N_indlaesninger=1000;
tmp_cnt=1;

for k=1:N_indlaesninger
tal_array(tmp_cnt,:)=randn(1,512);
minimums_vektor=min(tal_array);
tmp_cnt=tmp_cnt+1;
if tmp_cnt>300
tmp_cnt=1;
end
end

Jeg prøver som sagt at finde ud af om jeg kan lave en algoritme
der har samme funktionalitet som ovennævnte matlab-program
uden at der skal bruges et 300*512 array. Det må kunne lade
sig gøre at lave en algoritme som kun bruger en 2 vektorer. En
vektor til at indlæse værdier i og en anden vektor hvor minima
placeres i.

---

Jack skrev:

> ** Dernæst checker jeg for hver kolonne i arrayet hvilket tal i
> kolonnen der er minimum. Minimum for kolonne j placeres
> på j'te plads i min "minimums-vektor".

Hvorfor dog det? Du behøver kun huske på ét eneste minimum.

> Når jeg har indlæst 512 tal og placeret dem på den 300. række
> og udregnet minimums-vektoren, starter det hele forfra igen forstået
> på den måde at den næste indlæsning sker til række 1 i arrayet...

Du siger at 150 kB hukommelse er et problem. Hvilket system
snakker vi om?

Krydspostet til: <news:dk.edb.programmering.c>,<news:dk.videnskab>
Fut til: <news:dk.edb.programmering.c>
Svar herpå sendes dertil hvis man ikke ændrer det.

--
Bertel
http://bertel.lundhansen.dk/      http://fiduso.dk/

---

>
>> ** Dernæst checker jeg for hver kolonne i arrayet hvilket tal i
>> kolonnen der er minimum. Minimum for kolonne j placeres
>> på j'te plads i min "minimums-vektor".
>
> Hvorfor dog det? Du behøver kun huske på ét eneste minimum.

Nej, for du overser at arrayet løbende bliver opdateret. Minimum i en given
kolonne er derfor minimum indtil den række som indeholder minimum'et
bliver overskrevet....Hvis du implementerer det program du foreslog i
matlab vil du se at der er en stor forskel i funktionalitet.

>> Når jeg har indlæst 512 tal og placeret dem på den 300. række
>> og udregnet minimums-vektoren, starter det hele forfra igen forstået
>> på den måde at den næste indlæsning sker til række 1 i arrayet...
>
> Du siger at 150 kB hukommelse er et problem. Hvilket system
> snakker vi om?

Et DSP-board hvor den interne hukommelse ifølge compileren bliver
brugt op når jeg opretter et 512*300 float-array.

---

Jack skrev:

>> Hvorfor dog det? Du behøver kun huske på ét eneste minimum.

> Nej, for du overser at arrayet løbende bliver opdateret.

Du har slet ikke forklaret systemet. Vi kan gætte forkert fra nu
af og til dommedag.

Skal minimum opsamles én gang i døgnet? eller skal det huskes for
hver række, for hvert fyldt array - eller hvad?

--
Bertel
http://bertel.lundhansen.dk/      http://fiduso.dk/

---

> Du har slet ikke forklaret systemet. Vi kan gætte forkert fra nu
> af og til dommedag.

Det må du undskylde. Hvilke oplysninger omkring systemet mangler du?
Jeg vil gerne forklare det, men kan ikke rigtig se hvad jeg mangler at
forklare og hvilke mangler der afstedkommer gætteri?

Her er et forklarende eksempel med en 3*2 matrix

Første cycle:

Jeg indlæser en tilfældig vektor x=[1 2] som placeres
i første række i matricen. Matricen ser derfor sådan her
ud:

[1 2]
[0 0]

Minimumsvektoren er [0 0]

Jeg indlæser den næste tilfældige vektor x=[-1 4] som
placeres på 2. række i matricen.

Matricen ændres til:

[1 2]
[-1 4]

Minimumsvektoren er [-1 2]

Jeg indlæser den næste vektor [-5 3] som placeres
på 1. række i matricen.

[-5 3]
[-1 4]

Minimumsvektoren er [-5 3]

Jeg indlæser den næste vektor [1 -1] som placeres
på 2. række i matricen.

[-5 3]
[1 -1]

Minimumsvektoren er [-5 -1]

osv. osv. osv.

Håber at min forklaring denne gang er bedre...

---

Jack skrev:

> Det må du undskylde. Hvilke oplysninger omkring systemet mangler du?
> Jeg vil gerne forklare det, men kan ikke rigtig se hvad jeg mangler at
> forklare og hvilke mangler der afstedkommer gætteri?

Hvorfor skal tallene gemmes i et array?
Du siger at de ændres løbende. Skal der beregnes et minimum for
hver 300*512 værdier? Eller er det et minimum beregnet hver time
- eller i hele processens levetid?
Hvorfor vil du gemme mellemresultater fra beregningen af et
minimum?

Hvad går det hele ud på, hvad skal det bruges til, og hvor kommer
tallene fra?

> Her er et forklarende eksempel med en 3*2 matrix

Jeg kan sagtens finde ud af dine arrayberegninger.

PS. Det er lidt træls hver gang at sætte fut til
programmeringsgruppen. Jeg forstår ikke at du igen retter det så
der sende til dk.videnskab.

Krydspostet til: <news:dk.edb.programmering.c>,<news:dk.videnskab>
Fut til: <news:dk.edb.programmering.c>
Svar herpå sendes dertil hvis man ikke ændrer det.

--
Bertel
http://bertel.lundhansen.dk/      http://fiduso.dk/

---

> Hvorfor skal tallene gemmes i et array?

Fordi jeg gerne vil have et løbende minimum forstået på den måde at
det seneste minimum forbliver det seneste minimum indtil det bliver
overskrevet. Hvor lang tid det tager før det bliver overskrevet afhænger
af antallet af rækker i matricen/arrayet.

> Du siger at de ændres løbende. Skal der beregnes et minimum for
> hver 300*512 værdier?

Der skal udregnes 512 minimumsværdier svarende til antallet af
søjlevektorer i matricen/arrayet. Jeg udtager altså den første søjlevektor
i matricen og finder den mindste værdi i denne søjlevektor. Denne værdi
er den første minimumsværdi. Så tager jeg den næste søjlevektor i arrayet
og udregner minimum blandt værdierne i søjlevektoren. Og sådan fortsætter
jeg op til den sidste søjlevektor.

<Eller er det et minimum beregnet hver time
> - eller i hele processens levetid?

Tiden er - så vidt jeg kan se - ikke relevant. Det er blot en funktion
v=f(A) af en variabel MxN matrix A
som returnerer en vektor 1x512 vektor v med 512 minimumsværdier. Hvor tit og
ofte jeg kalder
f(A) er ikke vigtigt.

> Hvorfor vil du gemme mellemresultater fra beregningen af et
> minimum?

Jeg _vil_ ikke gemme. Jeg har lavet et foreløbigt program hvor jeg har
_valgt_ at gøre
det på denne måde. Men det er ikke særligt hukommelsesbesparende, så jeg
leder
efter et alternativ hvor jeg ikke behøver et array på 300x512 celler.

> Hvad går det hele ud på, hvad skal det bruges til, og hvor kommer
> tallene fra?

Jeg modtager løbende et power spektrum estimat (512 værdier) og skal løbende
udregne minimums-spektret. For at minimums-spektret er baseret på
observationer
over længere tid, har jeg valgt at minimum skal være baseret på de seneste
300
observationer.

> PS. Det er lidt træls hver gang at sætte fut til
> programmeringsgruppen. Jeg forstår ikke at du igen retter det så
> der sende til dk.videnskab.

Undskyld. Det gør jeg så ikke mere....

---

Jack skrev:

> Jeg modtager løbende et power spektrum estimat (512 værdier) og
> skal løbende udregne minimums-spektret. For at
> minimums-spektret er baseret på observationer over længere
> tid, har jeg valgt at minimum skal være baseret på de seneste
> 300 observationer.

Nu begynder det at give mening.

1. En tæller sættes til 0.
2. Når du har modtaget 512 værdier, beregner du minimum efter
'min' metode. Dette gemmes i variablen MINIMUM.
3. Tælleren tælles op.
4. Når du har modtaget 512 nye værdier, beregner du minimum efter
'min' metode - idet dog MINIMUM ikke initialiseres, men bevarer
sin sidste værdi.
5. Tælleren tælles op.
6 Hvis tælleren er mindre end 300, gå til 4.

7. Udskriv MINIMUM.
8. Gå til 1.

Tallet 300 kan ændres til et vilkårligt andet tal uden problemer.

--
Bertel
http://bertel.lundhansen.dk/      http://fiduso.dk/

---

> Nu begynder det at give mening.
>
> 1. En tæller sættes til 0.
> 2. Når du har modtaget 512 værdier, beregner du minimum efter
> 'min' metode. Dette gemmes i variablen MINIMUM.
> 3. Tælleren tælles op.
> 4. Når du har modtaget 512 nye værdier, beregner du minimum efter
> 'min' metode - idet dog MINIMUM ikke initialiseres, men bevarer
> sin sidste værdi.
> 5. Tælleren tælles op.
> 6 Hvis tælleren er mindre end 300, gå til 4.
>
> 7. Udskriv MINIMUM.
> 8. Gå til 1.
>
> Tallet 300 kan ændres til et vilkårligt andet tal uden problemer.
>

** minimum=A[0][0]; // Garanterer at tallet er med i arrayet.
** for (m=0; m<300; ++m) for (n=0; n<512; ++n)
** if (A[m][n]<minimum) minimum=A[m][n];


Hvis jeg har forstået din metode (**) korrekt, så genneløber den arrayet som
om den var en sekvens og finder
minimum i hele arrayet. Det er jo ikke meningen. Dernæst: Dit seneste
forslag matcher ikke funktionaliteten af
den funktion jeg har lavet. Se følgende eksempel:


k=1

Input=[1 3 2]

Array opdateres:

[1 3 2]
[0 0 0]
[0 0 0]
[0 0 0]

Minimum=[0 0 0]
---------------------------------
k=2

Input=[1 0 1]

Array opdateres:

[1 3 2]
[1 0 1]
[0 0 0]
[0 0 0]

Minimum=[0 0 0]
---------------------------------
k=3

Input=[0 1 4]

Array opdateres:

[1 3 2]
[1 0 1]
[0 1 4]
[0 0 0]

Minimum=[0 0 0]
---------------------------------
k=4

Input=[5 1 3]

Array opdateres:

[1 3 2]
[1 0 1]
[0 1 4]
[5 1 3]

Minimum=[0 0 1]
---------------------------------
k=1

Input=[7 7 7]

Array opdateres:

[7 7 7]
[1 0 1]
[0 1 4]
[5 1 3]

Minimum=[0 0 1]
---------------------------------
Og her opstår problemet så:

k=2

Input=[0 0 0]

Array opdateres:

[7 7 7]
[0 0 0]
[0 1 4]
[5 1 3]

Minimum=[0 0 0]

Din metode giver ikke dette minimum-output [0 0 0] før
alle 4 rækker er gennemløbet.

---

Jack skrev:

> ** minimum=A[0][0]; // Garanterer at tallet er med i arrayet.
> ** for (m=0; m<300; ++m) for (n=0; n<512; ++n)
> ** if (A[m][n]<minimum) minimum=A[m][n];

> Hvis jeg har forstået din metode (**) korrekt, så genneløber den arrayet som
> om den var en sekvens

Jeg regnede med at du selv kunne revidere det:

   minimum=A[0]; // Garanterer at tallet er med i arrayet.
   for (n=0; n<512; ++n) if (A[n]<minimum) minimum=A[n];

Den rutine pudser du på det indkommende array.

I dit eksempel gemmer du alle arrays (300 i virkeligheden). Det
kan du bare lade være med.

Jeg har ikke i sinde at skrive mere i denne her tråd.

--
Bertel
http://bertel.lundhansen.dk/      http://fiduso.dk/

---

> Jeg regnede med at du selv kunne revidere det:
>
> minimum=A[0]; // Garanterer at tallet er med i arrayet.
> for (n=0; n<512; ++n) if (A[n]<minimum) minimum=A[n];
>
> Den rutine pudser du på det indkommende array.
>
> I dit eksempel gemmer du alle arrays (300 i virkeligheden). Det
> kan du bare lade være med.
>
> Jeg har ikke i sinde at skrive mere i denne her tråd.


Tak for hjælpen Bertel, men det reviderede eksempel viser
enten at jeg ikke kan finde ud af at forklare mig godt nok eller
at du har misforstået det jeg har prøvet at forklare. Dit kode-eksempel
løber 512 værdier igennem, hvilket svarer til at finde den frekvens
i power spektret som har den mindste amplitude. Det minimum jeg
søger efter kigger "bagud" i tiden og finder - for hver frekvens - den
mindste amplitude blandt de seneste 300 gemte amplituder.

Jeg prøver at arbejde videre med sagen.

---

Den Wed, 22 Feb 2006 16:24:03 +0100 skrev Bertel Lund Hansen:
> Jack skrev:
>
>> ** minimum=A[0][0]; // Garanterer at tallet er med i arrayet.
>> ** for (m=0; m<300; ++m) for (n=0; n<512; ++n)
>> ** if (A[m][n]<minimum) minimum=A[m][n];
>
>> Hvis jeg har forstået din metode (**) korrekt, så genneløber den arrayet som
>> om den var en sekvens
>
> Jeg regnede med at du selv kunne revidere det:
>
>    minimum=A[0]; // Garanterer at tallet er med i arrayet.
>    for (n=0; n<512; ++n) if (A[n]<minimum) minimum=A[n];
>
> Den rutine pudser du på det indkommende array.
>
> I dit eksempel gemmer du alle arrays (300 i virkeligheden). Det
> kan du bare lade være med.

Du finder minimum vandret, hvor han ønsker at finde den lodret.

Han vil ikke have minimum af de 512 elementer, men 512 minimumsværdier,
et fra hvert element i array'et. Og det skal hele tiden være minimum
af de sidste 300 læsninger, hver gang der indlæses et nyt array med
512 elementer.

Det er ikke en simpel problem-stilling, og jeg kan efterhånden godt
forstå at han havde svært ved at forklare den. Jeg har måske en ide, men
den er endnu sværere at forklare...

For hver af de 512 værdier, skal der gemmes et antal (tid,minimumsværdi).
Hver gang der kommer en værdi der er højere end den seneste registrerede
minimumsværdi, skal den gemmes med position, og hver gang der kommer en
lavere værdi, skal alle de tidligere gemte værdier der er højere end
(eller lig med) denne slettes, og den lavere værdi gemmes i stedet for
med position.

Fx:

1,5,6,4,3,7

1: (0,1)
5: (0,1) (1,5)
6: (0,1) (1,5) (2,6)
4: (0,1) (3,4)
3: (0,1) (4,3)
7: (0,1) (4,3) (5,7)

Den nuværende minimumsværdi vil så altid være den første i rækken. Når
så programmet har de 300 samples, kan vi begynde at slette de gamle
værdier. Ved 300 slettes (0,1), og nu er minimumsværdien (stadig den
første i rækken) 3. Ved 304 slettes (4,3), hvorved minimumsværdien
bliver 7, osv.

Ulemper:

Meget mere kompleks kode.

Worst case bruger den endnu mere RAM end det oprindelige forslag (at
gemme alle værdierne), da den worst case vil gemme alle tallene, plus
tiden. Det kommer dog an på data-størrelsen, snakker vi fx om en byte
(0-255), kan der max blive gemt 255 værdier (+ tid), da der kun gemmes
værdier der er større end den foregående. Er det fire bits, gemmes der
max 16 værdier.

Mvh
Kent
--
Hard work may pay off in the long run, but laziness pays off right now.

---

> Du finder minimum vandret, hvor han ønsker at finde den lodret.
> Han vil ikke have minimum af de 512 elementer, men 512 minimumsværdier,
> et fra hvert element i array'et. Og det skal hele tiden være minimum
> af de sidste 300 læsninger, hver gang der indlæses et nyt array med
> 512 elementer.

Det er nemlig rigtigt!

> Det er ikke en simpel problem-stilling,

Enig

> For hver af de 512 værdier, skal der gemmes et antal (tid,minimumsværdi).
> Hver gang der kommer en værdi der er højere end den seneste registrerede
> minimumsværdi, skal den gemmes med position, og hver gang der kommer en
> lavere værdi, skal alle de tidligere gemte værdier der er højere end
> (eller lig med) denne slettes, og den lavere værdi gemmes i stedet for
> med position.
>

Jeg skal lige tygge på dit forslag og prøve at se om jeg kan forstå
det....Men jeg er
p.t. også kommet frem til at det kommer til at handle om noget med at gemme
minimums-værdiernes position og så ellers en række betingelser til at styre
hvordan minimums-værdien skal outputtes....Min intuition siger mig dog at
løsningen ikke bliver særlig kompleks hvis jeg ellers får lavet en
nogenlunde
fornuftig styring.

---

"Jack" <jack@nospammers.please> writes:

> Jeg skal lige tygge på dit forslag og prøve at se om jeg kan forstå
> det....Men jeg er
> p.t. også kommet frem til at det kommer til at handle om noget med at gemme
> minimums-værdiernes position og så ellers en række betingelser til at styre
> hvordan minimums-værdien skal outputtes....Min intuition siger mig dog at
> løsningen ikke bliver særlig kompleks hvis jeg ellers får lavet en
> nogenlunde
> fornuftig styring.

Hvis problemet er dette:

Der ankommer loebende vektorer med 512 tal i, og vi oensker at
vedligeholde en 512-vektor hvor hver indgang indeholder minimum
over de tilsvarende indgange i de seneste 300 vektorer,

saa kan man formulere det meget simplere ved at taenke paa det som 512
gange dette problem:

Der ankommer loebende tal; vedligehold minimum over de seneste
n. (Hvor n er 300 i dette tilfaelde).

Jeg kan ikke umiddelbart se nogen loesning, som ikke involverer at
huske paa alle n tal.

En muligvis brugbar observation: Naar et nyt tal ankommer, saa kan
alle tidligere tal som er stoerre end det nye tal, slettes, for de kan
aldrig nogensinde blive minimum over de seneste 300 tal.

---

[ jack@nospammers.please ]

[ ... ]

> ** Dernæst checker jeg for hver kolonne i arrayet hvilket tal i
> kolonnen der er minimum. Minimum for kolonne j placeres
> på j'te plads i min "minimums-vektor". Min "minimums-vektor"
> er som følge heraf en vektor med 512 minima.


Det ser ut som at algoritmen din forsøker å finne minimum for hver
kolonne. Er dette riktig?

Forutsatt det, her er et forslag:

for (int reads = 0; reads < limit; ++reads ) {
T min_vector[512] = { T(0) };
for (size_t row = 0; row < 300; ++row )
for (size_t column = 0; column < 512; ++column ) {
    T next_element = <consume next element from input>;
if ( next_element <compares as less-than> min_vector[column] )
    min_vector[column] = next_element;
}

/* [1] */
}

.... hvilket er generalisering av det Bertel foreslo. Jeg regner med at
du skal gjøre noe spennende med minima rundt [1] (ellers er
beregningen litt meningsløs, med mindre det å skrive til den
minneadressen som min_vector opptar har noen interessante
sideeffekter).


> Jeg prøver som sagt at finde ud af om jeg kan lave en algoritme der
> har samme funktionalitet som ovennævnte matlab-program uden at der
> skal bruges et 300*512 array. Det må kunne lade sig gøre at lave en
> algoritme som kun bruger en 2 vektorer. En vektor til at indlæse
> værdier i og en anden vektor hvor minima placeres i.


Eh, ja? Så vidt jeg kan forstå skal du lese elementene i en
sekvensiell rekkefølge (heller enn en eller annen tilfeldig
rekkefølge). Hver <consume next element from input> tilsvarer en
indeksjustering (enten rad eller kolonne).





ivr
--
"...but it's HDTV -- it's got a better resolution than the real world."
       -- Fry, "When aliens attack"

---

>
> Det ser ut som at algoritmen din forsøker å finne minimum for hver
> kolonne. Er dette riktig?

Ja. Det er korrekt.


> for (int reads = 0; reads < limit; ++reads )
>{
> T min_vector[512] = { T(0) };
> for (size_t row = 0; row < 300; ++row )
> for (size_t column = 0; column < 512; ++column )
> {
> T next_element = <consume next element
> from input>;
> if ( next_element <compares as less-than>
> min_vector[column] )
> min_vector[column] =
> next_element;
> }
>
> /* [1] */
> }

Hvad gør sætningen T min_vector[512] = { T(0) } ??

Kan du skrive programmet med MATLAB-notation? eller i pseudo-kode ?

---

> Håber at der er nogen derude der kender en smart algoritme
> med samme funktionalitet som ovennævnte??
>
> Tak på forhånd.

Hej Jack
Så vidt jeg forstår dit problem, er det når du laver referencen til dit
array: tal_array = zeroes(300,512) du allokerer hukommelse, og på samme måde
når du laver din minimums vektor.
To forslag:
1. Når du indlæser dine værdier i arrayet gem minimums værdien hvis den er
mindre end foregående minimumsværdi.
2. Alt efter hvor dit array er gemt skal du finde adressen på det første
element, så lægger du længden af dit tal siceoff(array(0,0)) til denne
adresse, og sammenligner tallet der står der med din minimumsværdi, videre
til næste tal. Om du har muligheden for at lave det i matlab ved jeg ikke.
MVH
Søren