Wiskundige voorbeelden leren lezen

[pixebility]

Hallo allemaal,

Hoe kan ik wiskundige voorbeelden leren lezen?
Ik heb hier een voorbeeld


Wat betekenen de subscript variabelen bijvoorbeeld? En wat betekenen alpha en beta?

Bedankt Pixebility

[David]

Is er geen omschrijving gegeven wat er wordt berekend met de formule, wat de variabelen voorstellen?
Wellicht staat dist voor distance ofwel afstand. Maar afstand waartussen? x en y? Dan zou waarschijnlijk y ook als subscript staan.

[pixebility]

Nou het gaat mij niet zozeer om de formule hierboven maar over hoe je alle griekse letters, die subscript variabelen en dergelijke leest. Wat ze betekenen ik had inmiddels gevonden dat de variabelen in subscript indices zijn maar waar ze voor gebruikt worden snap ik nog steeds niet.

In het geval van de formule hierboven gaat het om alpha blending in afbeeldingen. Ik kom nogal eens wiskundige formules tegen in de uitleg maar als ik de formule niet snap dan begrijp ik de uitleg ook niet vandaar dat ik dat wil leren lezen.

[David]

Indices worden vooral gebruikt als je veel variabelen hebt; er zijn niet zoveel letters als je soms variabelen wilt gebruiken. Is dit voldoende? Zo niet, heb ik meer informatie nodig over je voorkennis/opleiding.

Het lezen van formules kan door voorkennis en/of uitleg in tekst; de formule moet de tekst niet uitleggen maar andersom.

[pixebility]

Ok hier is de uitleg die bij de formule hoort.

cvAdd() is a simple addition function: it adds all of the elements in src1 to the corresponding
elements in src2 and puts the results in dst. If mask is not set to NULL, then any
element of dst that corresponds to a zero element of mask remains unaltered by this operation.
Th e closely related function cvAddS() does the same thing except that the constant
scalar value is added to every element of src.
Th e function cvAddWeighted() is similar to cvAdd() except that the result written to dst is
computed according to the following formula:

[arie]

Dit is meer informatica dan wiskunde.

"cvAdd() is a simple addition function: it adds all of the elements in src1 to the corresponding elements in src2 and puts the results in dst."

Hier lees je:
src1 en src2 zijn verzamelingen met elementen (wsch staat dit voor source1 en source2 wat betekent bron1 en bron2: de verzamelingen waar je wat mee gaat doen. Je functies hebben geen invoerparameters, dus src1 en src2 zullen globaal gedefinieerd zijn).
In de formule zie je dat er 2 indices zijn: x en y. Deze duiden voor elk tweetal x en y een element van src aan. src1 en src2 zijn dan wsch gedefinieerd als matrices of arrays, src1[x][y] en src2[x][y], waarbij x en y gehele getallen zijn.

Deze tekst beschrijft dus de formule




"If mask is not set to NULL, then any element of dst that corresponds to a zero element of mask remains unaltered by this operation."

mask is dan ook een array mask[x][y], die afhankelijk van x en y de waarde nul of niet_nul heeft (doorgaans is niet_nul = 1):
- als mask[x][y]==0 dan verandert de waarde van dst[x][y] niet,
- indien mask[x][y] ongelijk nul dan gebruik je de formule om de nieuwe waarde van dst[x][y] te berekenen.
Merk op dat ze mask[x][y] hier niet in de formule verwerkt hebben.

"The closely related function cvAddS() does the same thing except that the constant scalar value is added to every element of src."

Een scalar is een vaste waarde = constante. In dit geval wordt deze bij bovenstaande opgeteld.
Dit betekent dat in bovenstaande formule een constante (bv gamma) opgeteld wordt.



Merk op dat jij hier y schrijft, maar ik denk dat in je boek gamma staat, klopt dat?


"The function cvAddWeighted() is similar to cvAdd() except that the result written to dst is computed according to the following formula:"

Weighted betekent gewogen, dwz elk van de inputwaarden krijgt een bepaald gewicht = wordt vermenigvuldigd met een bepaalde factor.
Hier zijn 2 factoren: alfa en beta, die het gewicht van alle elementen van src1 resp. alle elementen van src2 bepalen:

[pixebility]

cvAdd heeft parameters namelijk:

Code: Selecteer alles

void cvAdd(
const CvArr* src1,
const CvArr* src2,
CvArr* dst,
const CvArr* mask = NULL
)

Je hebt gelijk er staat gamma.

[arie]

In dit geval zal je ergens ook nog een type-definitie hebben van CvArr, bijvoorbeeld een 2 dimensionale array van doubles.

src1, src2 en mask wijzen naar dergelijke arrays, die je niet mag veranderen (const),
dst is een pointer naar ook zo'n array, maar daarvan mag je de waarden wel veranderen (logisch, want die waarden wil je met je functie berekenen).

De arrays zelf zullen ook al eerder gedefinieerd moeten zijn (dus voordat deze functie aangeroepen word). De invoerparameters *src1, *src2, *dst en *mask zijn immers slechts pointers naar dergelijke arrays.

[pixebility]

Moet ik dan lezen als en neem ik aan?
Hoe moet ik gamma daar dan bij optellen? Ook bij de x en y waarde van src1 en src2?

[arie]

Nee.

src1[][] kan je zien als een 2 dimensionaal rooster met op elk roosterpunt een waarde.
De afmetingen van dit rooster zijn hier gedefineerd via CvArr.
Als dit bv een array van 3 bij 5 zou zijn met double waardes, dan heeft src1[][] ook deze vorm.
In code is dat vergelijkbaar met
double src1[3][5];
Hier bevat src1 3x5 = 15 plaatsen, elk voor een double value.
Afhankelijk van je programmeertaal lopen de indices dan van 1 t/m 3 resp 1 t/m 5 of van
0 t/m 2 resp 0 t/m 4.
In het laatste geval zijn je 15 variabelen dan:

src1[0][0], src1[0][1], src1[0][2], src1[0][3], src1[0][4],
src1[1][0], src1[1][1], src1[1][2], src1[1][3], src1[1][4],
src1[2][0], src1[2][1], src1[2][2], src1[2][3], src1[2][4].

Elk van deze 15 variabelen kan je een waarde naar keuze geven.
bijvoorbeeld:
src1[0][0]=2.34;
src1[2][3]=6.48;
src1[1][4]=5.33;
etc

als je integers x en y hebt:
int x, y;
en je geeft deze elk een waarde binnen de grenzen van de array,
bv x=1 en y=4,
dan roep je met src1[x][y] de waarde van src1[1][4] aan.
In ons voorbeeld is dat 5.33.
(deze waarde vermenigvuldigen we straks met alfa)

Ditzelfde geldt voor src2[][] en dst[][].

Als nog steeds src1[1][4]=5.33 is,
en
src2[1][4]=2.22
alfa=2.0
beta=3.0
gamma=4.0

dan bereken je dst[1][4] als:

dst[1][4] = alfa * src1[1][4] + beta * src2[1][4] + gamma
en in dit voorbeeld:
dst[1][4] = 2.0 * 5.33 + 3.0 * 2.22 + 4.0 = 21.32
In dit geval heeft dst[1][4] de waarde 21.32.

Omdat alle 15 elementen van src1 en alle 15 elementen van src2 een vooraf gegeven waarde hebben,
kan je ook de waarden van alle 15 elementen van dst op die manier berekenen.

In je programma zal je hiervoor de indices x en y gebruiken, waarbij x in ons voorbeeld loopt van 0 t/m 2 en y van 0 t/m 4.
Je programmacode zal dan lijken op dit voorbeeld:

Code: Selecteer alles

alpha = 2.0;
beta = 3.0;
gamma = 4.0;

for(x=0;x<3;x++)
  for(y=0;y<5;y++)
    dst[x][y] = alpha * src1[x][y] + beta * src2[x][y] + gamma;

Kom je zo verder?

[pixebility]

Arie je bent weer geweldig ik snap hem helemaal nu!
Bedankt allemaal voor jullie hulp!