Mock.Polars:

Fixed a bug where duplicate estimates could be added to the Polar table (this happened when the angle was 0, so the "negative" angle became 360, which is equivalent).
Now has a list of angle values for each wind speed, rather than checking if Pair<WindSpeed, WindAngle> exists in the map.
calculateVMG now uses linear interpolation between two adjacent angles (e.g., if data file contains angles 0, 30, 45, etc.. it can interpolate and find an optimal VMG angle between those, for example, 17 degrees).
Added a third test for when we provide a wind speed which is lower than any wind speed values in the Polars table. Still need to actually calculate correct VMG values by hand.

#story[873]

mock/src/main/java/seng302/Model/Polars.java

@@ -18,7 +18,11 @@ public class Polars {
     private HashMap<Pair<Double, Double>, Double> polarValues = new HashMap<>();
 
     ///Stores a list of angles from the polar table - this is used during the calculateVMG function.
-    private ArrayList<Double> polarAngles = new ArrayList<>();
+    ///Maps between windSpeed and a list of angles for that wind speed.
+    private HashMap<Double, ArrayList<Double>> polarAngles = new HashMap<>();
+
+
+
 
     /**
      * Ctor.
@@ -38,33 +42,42 @@ public class Polars {
 
         //We also add the same values with a negative angle, as the data file contains data for 0-180 degrees, but we also need 180-360 degrees. This is because it may turn out that going 5 degrees into the wind gives us, say, 9knots, but -5 into the wind may give us 10knots, towards our destination.
 
+        //Create the array to store angles for this wind speed if it doesn't exist.
+        if (!this.polarAngles.containsKey(trueWindSpeed)) {
+            this.polarAngles.put(trueWindSpeed, new ArrayList<>());
+        }
+
         //Add estimate to map.
         Pair newKeyPositive = new Pair(trueWindSpeed, relativeWindAngle);
         polarValues.put(newKeyPositive, boatSpeed);
 
-        double negativeAngle = -relativeWindAngle;
+        double negativeAngle = 360d - relativeWindAngle;
+        //This essentially does angle modulo 360, to get something in the interval [0, 360).
+        while (negativeAngle >= 360d) {
+            negativeAngle -= 360d;
+        }
+        //Ensure that the positive and negative angles aren't the same (e.g., pos = 0, neg = 360 - 0 = 0.
+        if (negativeAngle != relativeWindAngle) {
             Pair newKeyNegative = new Pair(trueWindSpeed, negativeAngle);
             polarValues.put(newKeyNegative, boatSpeed);
+        }
 
 
         //Add angle to angle list.
-        if (!this.polarAngles.contains(relativeWindAngle)) {
+        if (!this.polarAngles.get(trueWindSpeed).contains(relativeWindAngle)) {
-            this.polarAngles.add(relativeWindAngle);
+            this.polarAngles.get(trueWindSpeed).add(relativeWindAngle);
         }
 
-        if (!this.polarAngles.contains(negativeAngle)) {
+        if (!this.polarAngles.get(trueWindSpeed).contains(negativeAngle)) {
-            this.polarAngles.add(negativeAngle);
+            this.polarAngles.get(trueWindSpeed).add(negativeAngle);
         }
 
 
-        //System.out.println("adding wind speed: " + trueWindSpeed + ", wind angle: " + relativeWindAngle + ", boat speed: " + boatSpeed);//TEMP DEBUG REMOVE
-        //System.out.println("adding wind speed: " + trueWindSpeed + ", wind angle: " + negativeAngle + ", boat speed: " + boatSpeed);//TEMP DEBUG REMOVE
-
-
 
     }
 
 
+
     /**
      * Calculates the VMG for a given wind angle, wind speed, and angle to destination. Will only return VMGs that have a true bearing (angle) within a given bound - this is to ensure that you can calculate VMGs without going out of bounds. If you don't care about bearing bounds, simple pass in lower = 0, upper = 360.
      * @param trueWindAngle The current true wind angle.
@@ -80,7 +93,13 @@ public class Polars {
         //TODO we need to add interpolation between angles for a given wind speed (e.g., we have 0 deg, 30 deg, but the optimal bearing may be 17.3 degrees).
         //TODO we should also interpolate between wind speeds (e.g., we have 12kn and 16kn, but if the wind speed is actually 15.999kn, then we should interpolate to get a more accurate final value).
 
-        double polarWindSpeed = 0;
+        //Sorts polar angles.
+        for (ArrayList<Double> angles : this.polarAngles.values()) {
+            angles.sort(null);
+        }
+
+        //-1 indicates that we haven't found any smaller wind speeds in our map.
+        double polarWindSpeed = -1;
 
         //Find the lower bound wind speed from the polar table.
         for (Pair<Double, Double> key : this.polarValues.keySet()) {
@@ -93,70 +112,109 @@ public class Polars {
             }
         }
 
+        //If we never found a smaller speed value (e.g., smallest speed in table is 4kn, user provided 2kn), then for now we give a vector with 0 speed towards destination. Later, this should interpolate between adjacent wind speeds.
+        if (polarWindSpeed == -1) {
+            return new VMG(0, destinationAngle);
+        }
 
-        //Find the angle with the best VMG.
-        double bestVMGAngle = 0;
-        double bestVMGVelocity = 0;
-        for (double polarAngle : this.polarAngles) {
-
-            Pair<Double,Double> key = new Pair<>(polarWindSpeed, polarAngle);
-
-            //System.out.println("selecting " + polarAngle + " degrees from wind dir, and " + polarWindSpeed + "knots wind speed.");//TEMP DEBUG REMOVE
 
-            //We need to check that the map contains this (speed, angle) pair because some of the datafile entries have different angles in the same column (e.g., (16kn, 45 deg) and (20kn, 43 deg), but there is no (20kn, 45 deg).
-            if (this.polarValues.containsKey(key)) {
 
-                //This is the velocity from the polar table at this wind speed/angle.
+        //Find the angle with the best VMG.
-                double estVelocity = this.polarValues.get(key);
 
+        double bestVMGAngle = 0;
+        double bestVMGVelocity = 0;
+        //The list of polar angles for this wind speed.
+        ArrayList<Double> polarAngles = this.polarAngles.get(polarWindSpeed);
 
-                //System.out.println("speed is est. " + estVelocity + "knots.");//TEMP DEBUG REMOVE
+        //For all angles in the accepted interval (in 1 degree increments).
+        for (double angle = 0; angle < 360; angle += 1) {
 
             //This is the true bearing of the boat, if it went at the angle against the wind.
-                //For polarAngle > 90, it means that the boat is actually going _with_ the wind (gybe).
+            //For angle > 90 and angle < 270, it means that the boat is actually going _with_ the wind (gybe).
-                double trueBoatBearing = trueWindAngle + polarAngle + 180d;
+            double trueBoatBearing = trueWindAngle + angle + 180d;
             while (trueBoatBearing >= 360) {
                 trueBoatBearing -= 360;
             }
 
-                //System.out.println("true boat bearing is " + trueBoatBearing + " degrees.");//TEMP DEBUG REMOVE
+            //Check that the boat's bearing would actually be acceptable.
-
+            if ((trueBoatBearing <= bearingLowerBound) || (trueBoatBearing > bearingUpperBound)) {
-                //Check that the trueBoatBearing is actually within the accepted interval.
-                if ((trueBoatBearing <= bearingLowerBound) || (trueBoatBearing >= bearingUpperBound)) {
                 //If the angle is too small or too great, don't use it - skip to the next iteration.
                 continue;
             }
-                else {
-                    //If it is acceptable...
 
-                    //System.out.println("this is in the acceptable range");//TEMP DEBUG REMOVE
+
+            //Basic linear interpolation. Find the nearest two angles from the table, and interpolate between them.
+
+            //Check which pair of adjacent points the angle is between.
+            boolean foundInterval = false;
+            double lowerBound = 0;
+            double upperBound = 0;
+            for (int i = 0; i < polarAngles.size() - 1; i++) {
+                if ((angle >= polarAngles.get(i)) && (angle < polarAngles.get(i + 1))) {
+                    foundInterval = true;
+                    lowerBound = polarAngles.get(i);
+                    upperBound = polarAngles.get(i + 1);
+                    break;
+                }
+            }
+
+            //Calculate how far between those points the angle is.
+            if (!foundInterval) {
+                //If we never found the interval, then it must be the "last" interval, between the i'th and 0'th values.
+                lowerBound = polarAngles.get(polarAngles.size() - 1);
+                upperBound = polarAngles.get(0);
+            }
+
+            //This is the "distance" between the angle and its lower bound.
+            //I.e., L----A-----------U
+            //      <----> is lowerDelta.
+            double lowerDelta = angle - lowerBound;
+
+            //This is the "distance" between the upper and lower bound.
+            //I.e., L----A-----------U
+            //      <----------------> is intervalDelta.
+            //This can potentially be negative if we have, e.g., lower = 340deg, upper = 0deg, delta = -340deg.
+            double intervalDelta = upperBound - lowerBound;
+            //If it _is_ negative, modulo it to make it positive.
+            //E.g., -340deg = +20deg.
+            if (intervalDelta < 0) {
+                intervalDelta += 360d;
+            }
+
+            //This is how far between the lower and upper bounds the angle is, as a proportion (e.g., 0.5 = half-way, 0.9 = close to upper).
+            double interpolationScalar = lowerDelta / intervalDelta;
+
+            //Get the estimated boat speeds for the lower and upper angles.
+            Pair<Double,Double> lowerKey = new Pair<>(polarWindSpeed, lowerBound);
+            Pair<Double,Double> upperKey = new Pair<>(polarWindSpeed, upperBound);
+            double lowerSpeed = this.polarValues.get(lowerKey);
+            double upperSpeed = this.polarValues.get(upperKey);
+            //Get the delta between upper and lower speeds.
+            double speedDelta = upperSpeed - lowerSpeed;
+
+            //Calculate the speed at the interpolated angle.
+            double interpolatedSpeed = lowerSpeed + (speedDelta * interpolationScalar);
+
+
 
             //This is the delta angle between the boat's true bearing and the destination.
             double angleBetweenDestAndTack = trueBoatBearing - destinationAngle;
             //This is the estimated velocity towards the target (e.g., angling away from the target reduces velocity).
-                    double vmgTemp = Math.cos(Math.toRadians(angleBetweenDestAndTack)) * estVelocity;
+            double vmgTemp = Math.cos(Math.toRadians(angleBetweenDestAndTack)) * interpolatedSpeed;
 
-                    //System.out.println("angle between destination and boat bearing is " + angleBetweenDestAndTack + " degrees.");//TEMP DEBUG REMOVE
-                    //System.out.println("this has an overall velocity of " + vmgTemp + "knots.");//TEMP DEBUG REMOVE
 
             //Check that the velocity is better.
             if (vmgTemp > bestVMGVelocity) {
-                        //System.out.println("This is the new best velocity. Previous was " + bestVMGVelocity + "knots at " + bestVMGAngle + " degrees.");//TEMP DEBUG REMOVE
                 bestVMGVelocity = vmgTemp;
                 bestVMGAngle = trueBoatBearing;
             }
 
         }
-            }
-
-        }
 
-        //System.out.println("VMG speed = " + bestVMGVelocity + " , VMG angle = " + bestVMGAngle);//TEMP DEBUG REMOVE
 
         //Create the VMG object and return it.
         return new VMG(bestVMGVelocity, bestVMGAngle);
 
-
     }
 
 

mock/src/test/java/seng302/Model/PolarsTest.java

@@ -34,10 +34,11 @@ public class PolarsTest {
         double speedEpsilon = 2;//Are these epsilons a bit too big?
 
         //Test 1.
+        //This test has a wind speed that is between two values from the table (12kn, 16kn, this is 15.9kn).
         double windAngle1 = 31.5;
         double destAngle1 = 65.32;
-        double windSpeed1 = 15;//knots
+        double windSpeed1 = 15.9;//knots
-        double vmgAngle1 = 88;
+        double vmgAngle1 = 88; //TODO the expected results need to be calculated and placed here.
         double vmgSpeed1 = 12;
 
         VMG calcVMG1 = polars.calculateVMG(windAngle1, windSpeed1, destAngle1, 0, 360);
@@ -52,9 +53,10 @@ public class PolarsTest {
 
 
         //Test 2.
+        //This test has a wind speed much larger than any in the table (max from table is 30kn, this is 40kn).
         double windAngle2 = 200;
         double destAngle2 = 35;
-        double windSpeed2 = 20;//knots
+        double windSpeed2 = 40;//knots
         double vmgAngle2 = 88;
         double vmgSpeed2 = 12;
 
@@ -68,6 +70,25 @@ public class PolarsTest {
         //assertEquals(calcVMGAngle2, vmgAngle2, angleEpsilon);
         //assertEquals(calcVMGSpeed2, vmgSpeed2, speedEpsilon);
 
+
+        //Test 3.
+        //This test has a wind speed lower than any non-zero values from the table (table has 0kn, 4kn, this is 2kn).
+        double windAngle3 = 345;
+        double destAngle3 = 199;
+        double windSpeed3 = 2;//knots
+        double vmgAngle3 = 88;
+        double vmgSpeed3 = 12;
+
+        VMG calcVMG3 = polars.calculateVMG(windAngle3, windSpeed3, destAngle3, 0, 360);
+        double calcVMGAngle3 = calcVMG3.getBearing();
+        double calcVMGSpeed3 = calcVMG3.getSpeed();
+
+        System.out.println("VMG speed = " + calcVMGSpeed3 + " , VMG angle = " + calcVMGAngle3);//TEMP DEBUG REMOVE
+
+
+        //assertEquals(calcVMGAngle3, vmgAngle3, angleEpsilon);
+        //assertEquals(calcVMGSpeed3, vmgSpeed3, speedEpsilon);
+
     }
 
 }