Vector Addition

[JoeB]

Hallo,

ich habe ein Programm geschrieben, dass das Thema Vector umfasst...jedoch bei der Vectoraddition kommt immer nicht das richtige raus. Es gibt ei Ergebnis raus, alleridungs nicht das richtige.
Könnt ihr mir vielleicht helfen? Ich weiß nicht mehr weiter...

public final class Vector {
	
	/**************************
 		Membervariablen
	 **************************/
	
	private double Direction;
	private double Length;
	
	
	/**************************
 		Konstruktoren
	 **************************/

	public Vector() {
		this.Length = 0.0;
	}
	
	public Vector(double Direction) {
		this.Length = 1.0;
		this.Direction = Direction;
	}
	
	public Vector(double Direction, double Length) {
		if(Length < 0){
            this.Length = -Length;
            this.Direction = Direction+Math.PI;
        } 
		else{
            this.Length = Length;
            this.Direction = Direction;
        }
 
        while(this.Direction >= 2*Math.PI){
            this.Direction -= 2*Math.PI;
		}
	}
	
	/**************************
 		Getter
	 **************************/
	private double getLength() {		
		return Math.abs(this.Length);
	}
	
	private double getDirection() {
		return this.Direction;
	}
	
	
	/**************************
	 	Öffentliche Methoden
	 **************************/
	
	public boolean isNull() {
		// Wenn this.Length dem Wert 0.0 entspricht gebe true zurück, wenn nicht dann false
		return this.getLength() == 0.0 ? true : false;
	}
	
	public boolean isParallel(Vector more) {
		if( (this.isNull()) || (more.isNull()) ) 
		{ return true; }
            if( (near(this.getDirection(), more.getDirection())) || (near(this.getDirection() + Math.PI, more.getDirection())) ||(near(this.getDirection(), more.getDirection() + Math.PI)) ) 
			{ return true; }
                return false;
	}
	
	public boolean isSameAs(Vector more){
	if( (near(this.getLength(), more.getLength())) && (near(this.getDirection(), more.getDirection())) ||((this.isNull()) || (more.isNull())) ) 
	
	{ return true; }
                return false;
	}
	
	public Vector scaledBy(double scale) {
	    return new Vector( scale * this.getLength(), this.getDirection() );
        
	}
	
	Vector add(Vector more) {
	    
		double newLength;
    	double newDirection;
    	double xLength = Math.cos(getDirection()) * getLength();
    	double yLength = Math.sin(getDirection()) * getLength();
    	double xDirection = Math.cos(more.getDirection()) * more.getLength();
    	double yDirection = Math.sin(more.getDirection()) * more.getLength();
    	xLength += xDirection;
    	yLength += yDirection;
    	newLength = to(Math.sqrt(xLength * xLength + yLength * yLength));
    	if(Math.atan2(yLength, xLength) < 0) {
			newDirection = to((Math.atan2(yLength, xLength)) + 2 * Math.PI);
    	}
    	else {
			newDirection = to(Math.atan2(yLength, xLength));
    	}
			return new Vector(newLength, newDirection);
    	
  
	}
	
	public void print(){
		System.out.println("Länge = " + to(this.getLength()) + " ,Direction = " + to(this.getDirection()) + " rad");
	}
	 
    public void print(String prefix) {
        System.out.print(prefix + ": ");
        this.print();
    }
	
	/**************************
 		Private Methoden
	 **************************/
	private boolean near(double val1, double val2) {
		// Differenz der beiden Werte berechnen
		double diference = Math.abs(val1 - val2);
		
		// Prüfung ob Differenz kleiner 1e-8 ist und Rückgabe von true oder false
		return diference < 1e-8 ? true : false;
	}
	private double to(double zahl) {
            if (zahl != Math.PI){
				zahl *= 100000;
				zahl = Math.rint(zahl);
				zahl /= 100000;
				return zahl;
    		}
    		else{
    		return zahl;
    		}
    }
}

public class VectorMain {

	public static void main(String[] args) {

		double Length1 = Double.parseDouble(args[0]);
		double Direction1 = Double.parseDouble(args[1]);
		double factor1 = Double.parseDouble(args[2]);
		double Length2 = Double.parseDouble(args[3]);
		double Direction2 = Double.parseDouble(args[4]);
		
		Vector v1 = new Vector();
		Vector v2 = new Vector(Length1, Direction1);
		Vector v3 = new Vector(Length2, Direction2);
		Vector v4 = v3.scaledBy(factor1);
        v4.print("V 4");
		Vector v5 = v1.add(v2);
        v5.print("V 5");
 
		
		System.out.println( v3.isNull() );
		
		if(v2.isParallel(v1)) {
            System.out.println("Vector 2 und Vector 1 sind parallel");} 
			else {
             System.out.println("Vector 2 und Vector 1 sind nicht parallel");
                }
	    if(v2.isParallel(v3)) {
            System.out.println("Vector 2 und Vector 3 sind parallel");
        } 
		else { 
			System.out.println("Vector 2 und Vector 3 sind nicht parallel");
        }
 
        if(v2.isSameAs(v1)) {
            System.out.println("Vector 2 und Vector 1 sind gleich");
        } 
		else {
			System.out.println("Vector 2 und Vector 1 sind nicht gleich");
        }
 
        if(v2.isSameAs(v3)) {
			System.out.println("Vector 2 und Vector 3 sind gleich");
        } 
		else {
			System.out.println("Vector 2 und Vector 3 sind nicht gleich");
        }
	
	}

}

Vielen Dank schon mal!

 

[muckelzwerg]

Warum machst Du das "so"? Du kannst Deinen Vektor ja bauen wie Du magst, aber eigentlich ist ein Vektor sowas wie ein Feld mit einer Anzahl von Koordinaten. Die Länge ergibt sich dann über die Seitenverhältnisse im (meist karthesischen) Koordinatensystem und die Richtung über den Bezug zum Ursprung.
Was würdest Du denn machen, wenn Du einen Vektor für 3D Koordinatensysteme bauen wolltest? Noch eine weitere Richtung einbauen? Polarkoordinaten verwenden?


Wenn Du sagst, es kommt nicht das richtige heraus, dann weißt Du doch, was richtig wäre.
Also schreib mal auf, was Du getestet hast, was dabei herauskommen sollte (Deiner Ansicht nach) und was dann tatsächlich herauskam.

 

[Dekker]

Boa ganz ehrlich, was sind das für Vektoren die du da baust oO.

Für mich ist nach Definition ein Vektor ein n-Elementiges Tuppel (x_1,...,x_n) mit x_n € R. Was du hast, hat einen Wert direction und ne Länge.

Wenn ich das jetzt richtig sehe müssten deine Vektoren also eindimensionale Skalare sein. Von daher verwirrt mich deine Rechnung bei Vektoraddition noch viel mehr.

Erkläre mal nach welchem Ansatz du hier vorgehst, ich denke ich bin nich der einzigste der da nur Bahnhof versteht.

Im übrigen sollten nach Konvention Variablen mit Kleinbuchstaben anfangen. Auch wenn sie private sind.

 

[Andi_CH]

    private double direction; // Variablennamen klein schreiben
    private double length;
    
    
    /**************************
        Konstruktoren
     **************************/
 
    public Vector() {
        length = 0.0;
        direction = 0.0; // sollte auch gesetzt werden
    }
...

Klassenname Vector ist ungeschickt - Vector gibt es schon.

und der Name "direction" in add ist mehr als verwirrend - er ist schlicht falsch.

 

[Andi_CH]

...aber ich will ja konstruktiv sein - für die Vektoraddition ist es besser den Vektor karthesisch zu speichern

package com.javaforum.test;

public class GeomVectorCart {

	private double mX;
	private double mY;

	public GeomVectorCart() {
		mX = 0.0;
		mY = 0.0;
	}
	public GeomVectorCart(double x, double y) {
		mX = x;
		mY = y;
	}
	public double direction() {
		return Math.atan2(mY, mX);
	}
	public double length() {
		return Math.sqrt(mX * mX + mY * mY);
	}
	public double x() {
		return mX;
	}
	public double y() {
		return mY;
	}
	public void setXY(double x, double y) {
		mX = x;
		mY = y;
	}
	public void setAngLen(double angle, double length) {
		mX = Math.sin(angle) * length;
		mY = Math.cos(angle) * length;
	}
	public GeomVectorCart add(GeomVectorCart vect) {
		double x = this.x() + vect.x();
		double y = this.y() + vect.y();
		setXY(x, y);
		return this;
	}
	@Override
	public String toString() {
		return "[angle = " + Math.toDegrees(direction()) + ", length = " + length() + "] - [x = " + x() + ", y = " + y() + "]";
	}

	public static void main(String[] args) {
		GeomVectorCart vector1 = new GeomVectorCart();
		GeomVectorCart vector2 = new GeomVectorCart();
		System.out.println(vector1);
		System.out.println(vector1.add(vector2));
		vector1.setXY(1, 0);
		vector2.setXY(1, 0);
		System.out.println(vector1.add(vector2));
		vector1.setXY(1, 0);
		vector2.setXY(0, 1);
		System.out.println(vector1.add(vector2));
		vector1.setXY(1, 0);
		vector2.setXY(-1, 0);
		System.out.println(vector1.add(vector2));
		vector1.setXY(1, 0);
		vector2.setXY(0, -1);
		System.out.println(vector1.add(vector2));
		vector1.setXY(1, 1);
		vector2.setXY(1, 1);
		System.out.println(vector1.add(vector2));
		vector1.setXY(-1, 1);
		vector2.setXY(-1, 1);
		System.out.println(vector1.add(vector2));
	}

}

----
Postings von wegen mX sind absolut unnötig und bewirken rein gar nichts!

Und für die die nicht wissen worum es geht - in meiner Software wird es niemals gleiche Namen für unterschiedliche Dinge wie z.B. Parameter und Membervariablen geben. Die Verwechlungsgefahr ist zu gross. Die Meisten hier sind allerdings so obrigkeitsgläubig, dass sie Codierrichtlinien über Fehlerresistenz stellen.

 

[Marco13]

Das ursprüngliche 'add' sah schon gefrickelt aus. Unabhängig von der Frage nach der Effizienz: Wenn du eine Methode schreiben würdest, die zwischen der kartesischen- und der Polarkoordinatendarstellung umwandelt, könntest du die isoliert testen, und die Addition könnte dann auf die "einfache" Addition wie im obigen Post zurückgeführt werden.