Gemiddelde van inkomende waardes berekenen

[Felixje]

ik heb een bord dat iedere miliseconde een waarde doorgeeft (tussen 750 en 780), maar hiervan moet het gemiddelde worden berekend. Hoe kan ik dit doen?
Het is een periodieke beweging, en het liefst moet er alleen een gemiddelde worden berekend als de beweging bezig is, hij staat namelijk ook wel eens stil.

Of is er nog een andere manier om het aantal periodes te registreren? Ik doe het nou door iedere keer als de waarde boven een bepaalde waarde uitkomt te laten registreren, maar omdat de evenwichtsstand niet altijd hetzelfde is moet er dus een gemiddelde worden berekend. Als dit korter/beter kan is het ook welkom.

[.oisyn]

Ik snap het niet helemaal. Je weet toch wel hoe je een gemiddelde uit moet rekenen? Alle waardes bij elkaar optellen en dan delen door het aantal.

[Felixje]

.oisyn schreef op woensdag 05 september 2007 @ 19:36:
Ik snap het niet helemaal. Je weet toch wel hoe je een gemiddelde uit moet rekenen? Alle waardes bij elkaar optellen en dan delen door het aantal.

Ja, maar als ik iedere miliseconde een waarde binnenkrijg? Ik wil dat hij bijvoorbeeld iedere 10 seconde het gemiddelde berekent van alle waardes. Om hier nou 10000 regels code voor te schrijven...

[Anoniem: 70162]

10000 regels? dit is toch nooit meer dan 10 regels code? als je signaal stilstaat maakt niet uit het gemiddelde van allemaal dezelfde waardes is...

[Felixje]

Anoniem: 70162 schreef op woensdag 05 september 2007 @ 19:44:
10000 regels? dit is toch nooit meer dan 10 regels code? als je signaal stilstaat maakt niet uit het gemiddelde van allemaal dezelfde waardes is...

Hij meet iedere miliseconde, 1000 waardes per seconde dus. Het signaal staat een deel van de tijd idd stil, maar lang niet altijd.

[roy-t]

een arraylist maken, daar alle waardes in stoppen en om de zoveeltijd even alle waardes bij elkaar optellen en delen door arraylist.count?

Of wil je bijvoornbeeld maar maximaal 1000 waarden onthouden? simpel dan maak je een array[1000] en loop je van 1 tot 1000 door en begint weer met nieuwe waardes invullen bij 1 (telkens dus de oudste waarde overschrijvend)

Gemiddelde uitreken blijft het zelfde: som delen door aantal metingen (bij voorbeeld 2 dus delen door 1000, bij voorbeeld 1 dus delen door araylist.count.)

Alles even in pseudo code, gewoon arrays zitten in vrijwel elke taal, arraylists zitten, zover ik weet alleen in de .Net talen (C#.net, VB.Net C++.net etc.)

Ik hoop dat dit een beetje een 'oplossing' voor je is, maar ik denk dat je anders/zowieso beter moet beschrijven wat je nu eigenlijk wilt.

Edit: en ineens stond er meer

Als je wil dat elke 10seconden het gemiddelde wordt berekend dan moet dat dus elke 10000 metingen, ik ga er even van uit dat je niet alle metingen wilt bewaren dus ik geef je even een soort van pseudo C# code:

C#:

int teller = 0;
            int metingswaarde = 0;
            int[] metingen;
            int gemiddelde = 0;
            metingen = new int[10000];
        
            for (int i = 0; i <= 10000;)
            {
                metingen[i] = metingswaarde; //sla de waarde op
                teller++;
                if (teller > 10)
                {
                    //reken gemiddelde uit
                    //even op een luie manier, de eerste 10s zul je op deze manier geen betrouwbare  
                    //gemiddeldes krijgen om dat de andere waarden nog 0 zijn.
                    for (int y = 0; y <= 10000;)
                    {
                        gemiddelde += metingen[y];
                        gemiddelde = gemiddelde / 10000;
                    }
                }
                //stop hier een stopfunctie, anders heb je een inf loop

               if (i >= 10000)
               {
                   i = 0;
               }
             Thread.Sleep(1); 
             //zorgt ervoor dat er pas over 1ms weer gekeken wordt naar een nieuwe waarde
            }

Gooi dit in een soort multithreaded programmatje zodat je UI ook nog reageert en je je stopfunctie kunt gebruiken, en voila! Ook zal er nog iets in moeten dat er voor zorgt dat er pas gekeken wordt als er een nieuwe waarde is (er staat nu wel Thread.Sleep(1) maar dat is nogal onprecies, lelijk en verspilde energie)

[ Voor 53% gewijzigd door roy-t op 05-09-2007 20:04 ]

[Anoniem: 70162]

wil je nou gewoon dit?

pseudocode:
int t=0 en int s=0
while (1)
print [ input + (t-1)s ] / t => =s
INC t
//while


//edit: oeps:P

[ Voor 15% gewijzigd door Anoniem: 70162 op 05-09-2007 19:49 ]

[Dido]

tel je waardes en houd dat aantal bij.
bereken bij iedere nieuwe waarde:

nieuw gemiddelde = ( ( oud gemiddelde * aantal ) + nieuwe waarde ) / aantal + 1
aantal = aantal + 1

Of je dat duizend keer per seconde gaat lukken is weer wat anders

[jochemh]

elke meting gewoon bij een integer optellen, dit getal bijvoorbeeld om de 10 sec door 10.000 delen, en die integer terug op 0 zetten. Dan heb je toch om de 10 sec het gemiddelde?

[.oisyn]

Idd. Als echter op elk moment het gemiddelde van de laatste 10s uit wil kunnen rekenen, dan zul je idd 10s aan meetdata bij moeten houden, hoewel iedere ms weer een nieuw gemiddelde uitrekenen wellicht een beetje overkill is. Je zou ook om de 1s het gemiddelde kunnen tonen, dan hoef je maar 10s/1s = 10 waarden op te slaan om het gemiddelde over te berekenen.

[.oisyn]

Dido schreef op woensdag 05 september 2007 @ 19:50:
tel je waardes en houd dat aantal bij.
bereken bij iedere nieuwe waarde:

nieuw gemiddelde = ( ( oud gemiddelde * aantal ) + nieuwe waarde ) / aantal + 1
aantal = aantal + 1

Of je dat duizend keer per seconde gaat lukken is weer wat anders

Wat voor computer heb jij die niet 1000 berekeningen per seconde kan doen?

[Dido]

.oisyn schreef op woensdag 05 september 2007 @ 20:01:
Wat voor computer heb jij die niet 1000 berekeningen per seconde kan doen?

Ten eerste zijn dat er meer dan 1000 per seconde (of heb jij er een die dat in 1 berekening doet? )

Ten tweede heb ik helaas inderdaad ervaring met hardware die mijn metingen niet bij kon houden - ok, dat was in '92 op een toen al verouderde 286, maar toch

[.oisyn]

Dido schreef op woensdag 05 september 2007 @ 20:04:
[...]

Ten eerste zijn dat er meer dan 1000 per seconde (of heb jij er een die dat in 1 berekening doet? )

Het is 1 berekening, ik zei niet dat het 1 operatie was . Maar think about it, een 3 GHz CPU doet 3 miljard cycles per seconde, waarvan veel berekeningen (optellen, aftrekken) slechts 1 cycle kosten. Nou heb ik het al een tijdje niet meer bijgehouden, maar een multiply is geloof ik <10 en een deling <40 oid. You do the math (pun intended )

[Anoniem: 70162]

een beetje compiler pakt in dit soort gevallen (je kan gewoon ruiken dat er een afronding aankomt) alleen even delingen
bitjes opschuiven ftw \o/

[Felixje]

jochemh schreef op woensdag 05 september 2007 @ 19:54:
elke meting gewoon bij een integer optellen, dit getal bijvoorbeeld om de 10 sec door 10.000 delen, en die integer terug op 0 zetten. Dan heb je toch om de 10 sec het gemiddelde?

Zo simpel, dat ik daar niet op kwam.
Ik was vergeten te zeggen dat ik in visual basic 2005 programmeer.

Wat ik nou nog vreemd vind is dat als ik timer1.interval=1 doe dat hij dan per seconde maar 100 tikjes doet ipv 1000. Hoe kan dit?

[RobIII]

Felixje schreef op woensdag 05 september 2007 @ 20:14:
[...]

Zo simpel, dat ik daar niet op kwam.
Ik was vergeten te zeggen dat ik in visual basic 2005 programmeer.

Wat ik nou nog vreemd vind is dat als ik timer1.interval=1 doe dat hij dan per seconde maar 100 tikjes doet ipv 1000. Hoe kan dit?

Omdat de timerresolutie grofweg op 50ms ligt; een gewone timer kan geen 'preciezere' garanties geven. Je zult dan moeten gaan kijken (lees: googlen) naar hi-resolution timers (vaak multi-media timers), maar ook die geven 0,0 garantie.

[ Voor 6% gewijzigd door RobIII op 05-09-2007 20:41 ]

[.oisyn]

Anoniem: 70162 schreef op woensdag 05 september 2007 @ 20:12:
een beetje compiler pakt in dit soort gevallen (je kan gewoon ruiken dat er een afronding aankomt) alleen even delingen
bitjes opschuiven ftw \o/

'aantal' is een variabele, dus vergeet dat maar. Daarnaast kan het niet eens, hoe ga jij bv. een deling door 3 met shifts aanpakken (zodat het ook nog eens sneller is dan een deling)?

[ Voor 17% gewijzigd door .oisyn op 05-09-2007 20:58 ]

[TjardE]

Leuk probleem wat je daar aansnijdt.

1) Je hebt eerst het probleem dat je niet alle waardes kunt/wilt onthouden omdat je misschien een geheugenbeperking hebt. Tevens wil je niet telkens al je waardes middelen omdat dit veel berekeningen vergt.

2) Je kunt met lopende gemiddeldes werken dus inderdaad het verhaal van (vorig gemiddelde*aantal+waarde)/(aantal +1) en dan aantal=aantal+1, maar daar zie ik op gegeven moment iets over zijn maximum gaan (gemiddelde * aantal kan wel eens een onnoemelijk groot getal worden)

Ik zat te denken aan het volgende :

Je sampled het signaal b.v. elke 100 msec. Dan heb je dus over een seconde 10 waardes. Daar bereken je een gemiddelde van die dan geldt voor 1 seconde.
Deze waarde sla je op. Dit doe je dan weer om de 60 seconden om die seconden gemiddelden uit te middelen over een minuut. Dan heb je een minuut-gemiddelde.
Deze sla je dan weer op.
Dan ga je over op uur-gemiddelden, dag gemiddelden, maand gemiddelden, jaar gemiddelden.

Het vergt wel een en ander aan uitzoekwerk, maar volgens mij is dit een methode die wel werkt voor zoveel getallen waarover je over een lange periode een gemiddelde wilt hebben.

seconde gemiddelde : 10 waardes -> 1 waarde
minuut gemiddelde : 60 waardes -> 1 waarde (dus als je 60 seconden waardes hebt kun je een minuut gemiddelde gaan berekenen hiervan)
uur gemiddelde : 60 waardes -> 1 waarde (dus als je 60 minuut waardes hebt kun je je uur gemiddelde gaan berekenen)

Lastig uitleggen eigenlijk, maar denk wel dat dit een mogelijke oplossing zou kunnen zijn.

[Anoniem: 14829]

Felixje schreef op woensdag 05 september 2007 @ 19:42:
Ja, maar als ik iedere miliseconde een waarde binnenkrijg? Ik wil dat hij bijvoorbeeld iedere 10 seconde het gemiddelde berekent van alle waardes. Om hier nou 10000 regels code voor te schrijven...

Neem een array van 10000 waarden, en een tellertje die van 0 tot 9999 loopt. Als die teller de 10000 bereikt zet je 'm weer op 0. Bij iedere meting verhoog je 't tellertje en zet je de meting in het bijbehorende item in de array.
Elke 10 seconden tel je die 10000 items op en deel je ze door 10000.

Mocht dat niet genoeg performen, dan kun je ook iedere keer als een nieuwe waarde wordt toegevoegd een totaal bijhouden, en dan de waarde die wordt overschreven van dat totaal aftrekken en de nieuwe waarde erbij optellen. Dan hoef je elke 10 seconden alleen maar dat totaal door 10000 te delen.

Maar dan heb je wel steeds het gemiddelde over de laatste 10 seconden. Ik weet niet of dat ook je bedoeling is?

[Marcj]

Waarom niet wat simpeler? Bij elke iteratie op de volgende manier het gemiddelde berekenen:

code:

avg = X * avg + (1.0 - X) * value

waarbij X bijvoorbeeld gelijk staat aan 0.9 oid. Dit kan snel berekend worden en je hoeft niets te onthouden. Plus dat hoe ouder de waarde is des te minder weegt deze mee in de berekening. De nieuwste waarde heeft (in dit geval) een gewicht van 0.1, de een na laatst 0.09, die daarvoor 0.081 en daarvoor 0.0729 etc... Deze waarde zal je dan even moeten finetunen.

[BraveWorld]

Felixje schreef op woensdag 05 september 2007 @ 20:14:
[...]
Zo simpel, dat ik daar niet op kwam.

Dat is het meest simpele. Als het een nadeel is dat je elke 10 sec ineens een nieuw gemiddelde krijgt kan je ook een glijdend gemiddelde berekenen:

Je moet dan toch wel 10000 waarden onthouden. Maar je houdt dan ook een Totaalwaarde bij. Elke nieuwe sample tel je dan op bij de Totaalwaarde, en hiervan trek je af de waarde van de sample van 10 sec geleden. De nieuwe Totaalwaarde kan je dan door 10000 delen om je nieuwe glijdende gemiddelde te weten.

*** edit: in de tussentijd is dit ook al door anderen aangedragen ***

[ Voor 6% gewijzigd door BraveWorld op 05-09-2007 21:49 ]

[roy-t]

Anoniem: 14829 schreef op woensdag 05 september 2007 @ 21:32:
[...]

Neem een array van 10000 waarden, en een tellertje die van 0 tot 9999 loopt. Als die teller de 10000 bereikt zet je 'm weer op 0. Bij iedere meting verhoog je 't tellertje en zet je de meting in het bijbehorende item in de array.
Elke 10 seconden tel je die 10000 items op en deel je ze door 10000.

Nooouuu dat had ik allang gepost stelerd


maar ach al maak je 2 of 3 arrays van 10.000 dan heb je eerst elke 10s danaarna elke 100.000seconden (27uur) en als je ze nog langer wilt bewaren doe je dan nog een keer 10.000 (32jaar) en dat in een paar megabytjes geheugen

natuurlijk kun je ook nog dingen gaan outputten naar een bestand.

maargoed ik denk dat de TS nu meer dan genoeg dingen heeft, zelfs ene crappy code voorbeeld van mijn kant (is dan wel C#.net maar met VB2005 is dit bijna hetzelfde, je hebt alle zelfde tools ter beschikking met net een andere taal)

[ Voor 36% gewijzigd door roy-t op 05-09-2007 22:09 ]

[voodooless]

Marcj schreef op woensdag 05 september 2007 @ 21:46:
waarbij X bijvoorbeeld gelijk staat aan 0.9 oid. Dit kan snel berekend worden en je hoeft niets te onthouden. Plus dat hoe ouder de waarde is des te minder weegt deze mee in de berekening. De nieuwste waarde heeft (in dit geval) een gewicht van 0.1, de een na laatst 0.09, die daarvoor 0.081 en daarvoor 0.0729 etc... Deze waarde zal je dan even moeten finetunen.

Dat heet lopend gemiddelde. Is inderdaad lekker snel.

Met een array (ringbuffer idee) kan dat natuurlijk ook snel. Zodra deze vol is kun je namelijk de waarde die je weggooit weghalen uit het totaal, en de toegevoegde waarde optellen, en delen door het totaal. Zo hoef je niet alle losse waardes door te lopen. De gein is dat je stiekem helemaal geen array nodig hebt Alleen maar een totaale count, de oudste waarde, de nieuwste, het aantal, en de som Ueber simpel om zo van de x laatse waarden super snel het gemiddelde te berekenen, ook al zijn dat er 1 miljoen

Ik ben trouwens wel benieuwd waarom je 1000 keer per seconde het gemiddelde inkomen wil berekenen

[ Voor 4% gewijzigd door voodooless op 05-09-2007 23:30 ]

[MNeMoNiCS]

voodooless schreef op woensdag 05 september 2007 @ 22:25:
[...]


Dat heet lopend gemiddelde. Is inderdaad lekker snel.

Met een array (ringbuffer idee) kan dat natuurlijk ook snel. Zodra deze vol is kun je namelijk de waarde die je weggooit weghalen uit het totaal, en de toegevoegde waarde optellen, en delen door het totaal. Zo hoef je niet alle losse waardes door te lopen. De gein is dat je stiekem helemaal geen array nodig hebt Alleen maar een totaale count, de oudste waarde, de nieuwste, het aantal, en de som Ueber simpel om zo van de x laatse waarden super snel het gemiddelde te berekenen, ook al zijn dat er 1 miljoen

Ik ben trouwens wel benieuwd waarom je 1000 keer per seconde het gemiddelde inkomen wil berekenen

Als je geen array nodig hebt, waar haal je dan steeds de oudste waarde vandaan?

[voodooless]

MNeMoNiCS schreef op woensdag 05 september 2007 @ 23:15:
Als je geen array nodig hebt, waar haal je dan steeds de oudste waarde vandaan?

Zeer goede vraag Array is dus wel nodig helaas, maar de rest van het verhaal blijft natuurlijk.

[ Voor 15% gewijzigd door voodooless op 05-09-2007 23:31 ]

[Felixje]

Waarom ik dat wil?

Ik ben een windkrachtmeter aan het bouwen. De as waar hij op draait is een motortje van een cdrom-speler. Ik dacht misschien heb ik wat aan de inductiestroom die ik opwek, maar die is verschrikkelijk klein. Toen kwam ik erachter dat de weerstand tijdens het draaien periodiek verandert, dwz hij schommelt zo rond de 460 ohm met een uitwijking van ongeveer 10 ohm.

Ik heb dus een 2e weerstand aangesloten, waardoor de spanning verdeelt wordt over de weerstanden. ik meet dan de spanning over een weerstand die ook periodiek is. Dit is op een vellemanbordje aangesloten die dan de waardes krijgt. Ik heb het zo geprogrammeerd dat hij registreert als je boven een bepaalde waarde komt, maar het probleem is dat de uitwijking hier ook nogal klein is, en de evenwichtsstand ook nog wel eens wat wil veranderen. Daarom wil ik om de paar seconde een nieuwe evenwichtsstand om te kunnen vergelijken. Hij kijkt ook iedere 1 ms of hij boven de waarde uitkomt, dus ik heb hem ook om de 1ms een meting laten doen. Hiervoor moet ik dus het gemiddelde hebben.

Ik ben er inmiddels uit, en het werkt. Discussier lekker verder zou ik zeggen, maar mijn vraag is beantwoord.

[MNeMoNiCS]

voodooless schreef op woensdag 05 september 2007 @ 23:30:
[...]


Zeer goede vraag Array is dus wel nodig helaas, maar de rest van het verhaal blijft natuurlijk.

Je zou natuurlijk het gemiddelde als benadering voor de oudste waarde kunnen gebruiken

[curry684]

Felixje schreef op woensdag 05 september 2007 @ 19:42:
[...]

Ja, maar als ik iedere miliseconde een waarde binnenkrijg? Ik wil dat hij bijvoorbeeld iedere 10 seconde het gemiddelde berekent van alle waardes. Om hier nou 10000 regels code voor te schrijven...

Kun je ons verblijden met een uitsnede van de 10000 benodigde regels, stuk of 5 a 10 of zo? Ik ben erg benieuwd en kan me er minder dan niets bij voorstellen hoe je het dan wil doen eigenlijk. Never too old to learn

[voodooless]

MNeMoNiCS schreef op woensdag 05 september 2007 @ 23:54:
Je zou natuurlijk het gemiddelde als benadering voor de oudste waarde kunnen gebruiken

Dan kun je net zo goed het al eerder voorgestelde lopende gemiddelde nemen.