Pourquoi l'amplitude de mon vecteur est-elle plus précise lorsque j'utilise une variable?

Question

J'écris un programme en traitement où je normalise un vecteur dans un vecteur unitaire. Quand je fais cela, je me attends mon vecteur d'avoir une magnitude de 1. Cependant, l'ampleur de mon vecteur est ce (voir ci-dessous)

L'ampleur est proche de 1, mais ce n'est pas exactement 1 J'ai calculé que je pouvais obtenir la magnitude du vecteur à 1 si je déclarais une variable égale à la grandeur du vecteur et divisait les composantes de mon vecteur par la variable au lieu de directement de la magnitude du vecteur, comme ci-dessous.

Toute idée pourquoi est plus précise de l'ampleur de mon vecteur lorsque j'utilise une variable? mag est égal à mag(), mag est un flotteur tandis que mag() renvoie un flotteur, donc je ne comprends pas pourquoi je reçois une différence de grandeurs.

L'intégralité de mon code est ci-dessous.

PVector center, mouse; 

void setup() { 
    size(1000,300); 
    background(0); 
    stroke(255); 
    center = new PVector(width/2,height/2); 
} 

void draw() { 
    background(0); 
    mouse = new PVector(mouseX, mouseY); 
    mouse.sub(center); //Mouse is now the vector between mouse and center. 
    mouse.normalize(); 
    println("magnitude: " + mouse.mag() + 
      ", Vector coordinates: (" + mouse.xPos + "," + mouse.yPos + ")"); 
    /* These values are getting normalized already, so the magnitude of the 
    vectors should be equal to 1. 
    */ 
    translate(center.xPos, center.yPos); 
    line(0,0,mouse.xPos,mouse.yPos); 
} 

class PVector { 
    float xPos; // xPos and yPos are the vector's components. 
    float yPos; 

    PVector (float xTemp, float yTemp) { 
    xPos = xTemp; 
    yPos = yTemp; 
    } 

    void sub(PVector vectorTemp) { 
    xPos = xPos - vectorTemp.xPos; 
    yPos = yPos - vectorTemp.yPos; 
    } 

    float mag() { 
    float magnitude = sqrt(xPos * xPos + yPos * yPos); 
    return magnitude; 
    } 

    void normalize() { 
    float mag = mag(); // My vector's magnitude is 1 when I use a variable. 
    xPos = xPos/mag; 
    yPos = yPos/mag; 

    } 
} 

Answer 1

La première version (de imprécise) a un défaut:
Il met à jour xPos et ensuite calcule mag() avec le xPos mis à jour. Ce qui signifie que yPos est mis à l'échelle par rapport à un sommet entièrement différent.

E.g. un flux d'échantillon de cette méthode pour un vecteur (3, 4) ressemblerait à ceci:

xPos = 3 
yPos = 4 

mag() = sqrt(3^2 + 4^2) = 5 
xPos = 3/5 

mag() = sqrt(3^2/5^2 + 4^2) ~= 4.045 
yPos = 4/~4.045 

ce qui conduit à une magnitude globale de ~ 1,2605 dans l'exemple ci-dessus. D'autre part, l'autre version calcule correctement l'amplitude et met ensuite à jour les valeurs de position.