InversionCounter um die ausgabe der inversionspaare erweitert

src/main/java/Presenter/Algorithms/InversionCounter.java

@@ -5,29 +5,74 @@ import java.util.HashMap;
 import java.util.List;
 
 /**
- * Created by armin on 18.06.17.
+ * Implementierung verschiedener Algorithmen zur Berechnung von Ausgleichsgeraden.
+ *
+ * @Author: Armin Wolf
+ * @Email: a_wolf28@uni-muenster.de
+ * @Date: 18.06.2017.
  */
 public class InversionCounter  {
 
-    public static int run(List<Integer> a, List<Integer> b){
+    private  HashMap<Integer, Integer> dictionaryTO;
+    private  HashMap<Integer, Integer> dictionaryBACK;
+    private  ArrayList<Integer> substituted;
+    private  ArrayList<Pair> inversions;
+
+    private class Pair{
+        private Integer p1;
+        private Integer p2;
+        public Pair(Integer p1, Integer p2) {
+            this.p1 = p1;
+            this.p2 = p2;
+        }
+
+        public Integer getP1() {
+            return p1;
+        }
+
+        public void setP1(Integer p1) {
+            this.p1 = p1;
+        }
+
+        public Integer getP2() {
+            return p2;
+        }
+
+        public void setP2(Integer p2) {
+            this.p2 = p2;
+        }
+    }
+
+    public int run(List<Integer> a, List<Integer> b){
+
+        dictionaryTO =  new HashMap<>();
+        dictionaryBACK = new HashMap<>();
+        substituted =  new ArrayList<>();
+        inversions = new ArrayList<>();
 
-        HashMap<Integer, Integer> indexesA =  new HashMap<>();
-        ArrayList<Integer> substituted =  new ArrayList<>();
         ArrayList<Integer> temp = new ArrayList<>();
 
         temp.addAll(a);
 
         for (int i=0;i<a.size();i++){
-            indexesA.put(a.get(i), (i+1));
+            dictionaryTO.put(a.get(i), i+1 );
+            dictionaryBACK.put(i+1 , a.get(i));
         }
 
         for (int j=0;j<b.size();j++){
-            substituted.add(indexesA.get(b.get(j)));
+            substituted.add(dictionaryTO.get(b.get(j)));
         }
 
+        int ret = countInversions(substituted, 0, substituted.size()-1, temp);
 
-        return countInversions(substituted, 0, substituted.size()-1, temp);
 
+        getInversionPairs();
+        dictionaryTO =  null;
+        substituted =  null;
+        inversions = null;
+
+
+        return ret;
     }
 
 
@@ -41,7 +86,7 @@ public class InversionCounter  {
      * @param aux   Groundtruth Ordnung um die Anzahl der Inversionen zu bestimmen.
      * @return  Anzahl der inversionen zwischen a und aux.
      */
-    public static int countInversions(List<Integer> a, int start, int end, List<Integer> aux) {
+    public  int countInversions(List<Integer> a, int start, int end, List<Integer> aux) {
         if (start >= end) {
             return 0;
         }
@@ -60,6 +105,11 @@ public class InversionCounter  {
             if (aux.get(left) < aux.get(right)) {
                 a.set(index++, aux.get(left++));
             } else {
+
+                for (int i=left; i<=mid;i++){
+                   // System.out.println(aux.get(i)+" -- "+ aux.get(right));
+                    inversions.add(new Pair(aux.get(i), aux.get(right)));
+                }
                 a.set(index++, aux.get(right++));
                 invCount += mid - left + 1; // number of inversions for aux[right]
             }
@@ -71,4 +121,18 @@ public class InversionCounter  {
         return invCount;
     }
 
+
+    public void getInversionPairs(){
+        ArrayList<Pair> result = new ArrayList<>();
+
+        for (int i=0;i<inversions.size();i++){
+            result.add(new Pair(dictionaryBACK.get(inversions.get(i).getP1()), dictionaryBACK.get(inversions.get(i).getP2())));
+        }
+
+        //for (Pair p : result){
+        //    System.out.println(p.getP1() + " <==> " + p.getP2());
+        //}
+
+    }
+
 }

src/main/java/Presenter/Algorithms/LeastMedianOfSquaresEstimator.java

@@ -22,6 +22,7 @@ public class LeastMedianOfSquaresEstimator extends Observable implements Algorit
 
     private LinkedList<Line> set = new LinkedList<>();
     private LinkedList<Point> intersections = new LinkedList<>();
+    private InversionCounter invCounter = new InversionCounter();
     private int n;
     private double quantileError;
     private int kPlus;
@@ -150,7 +151,7 @@ public class LeastMedianOfSquaresEstimator extends Observable implements Algorit
 
         ArrayList<Point> umin = new ArrayList<>();
         ArrayList<Point> umax = new ArrayList<>();
-        HashMap<Point, Integer> secondaryIndex = new HashMap<>();
+        HashMap<Integer, Integer> secondaryIndex = new HashMap<>();
         ArrayList<Integer> listA =  new ArrayList<>();
         ArrayList<Integer> listB =  new ArrayList<>();
 
@@ -158,20 +159,20 @@ public class LeastMedianOfSquaresEstimator extends Observable implements Algorit
 
         int counter = 0;
         for (Line p : set) {
-            umin.add(new Point(p.getM(), slab.getLower() * p.getM() + p.getB(),counter+""));
-            umax.add(new Point(p.getM(), slab.getUpper() * p.getM() + p.getB(),counter+""));
+            //vertauscht das Point standardmäßig die x lexikografische Ordnung betrachtet
+            umin.add(new Point(slab.getLower() * p.getM() + p.getB(),p.getM(), counter+""));
+            umax.add(new Point(slab.getUpper() * p.getM() + p.getB(),p.getM() ,counter+""));
             counter++;
         }
 
+        for (int i=0; i<umin.size();i++){
+            int id = Integer.parseInt(umin.get(i).getId());
+            secondaryIndex.put(id, i);
+        }
+
         Collections.sort(umin);
         Collections.sort(umax);
 
-        for (int i=0; i<umin.size();i++){
-            int id = Integer.parseInt(umin.get(i).getId());
-            secondaryIndex.put(umin.get(i), id);
-        }
-
-
         for (Point p : umax){
             int x = Integer.parseInt(p.getId());
             listB.add(secondaryIndex.get(x));
@@ -182,7 +183,13 @@ public class LeastMedianOfSquaresEstimator extends Observable implements Algorit
             listA.add(secondaryIndex.get(x));
         }
 
-        numberOfInversions = InversionCounter.run(listA, listB);
+
+        // debug
+        //for (int i=0;i<listA.size();i++){
+        //   System.out.println(listA.get(i)+",  "+listB.get(i));
+        //}
+
+        numberOfInversions = invCounter.run(listA, listB);
 
         return numberOfInversions;
     }

src/main/java/View/MainFrame.java

@@ -146,6 +146,7 @@ public class MainFrame extends JFrame{
         sidepanel.setMinimumSize(new Dimension(400,500));
         arrangementDialog.setSize(new Dimension(800, 800));
         plotDialog.setSize(new Dimension(700, 470));
+        plotDialog.setResizable(false);
         output.setMinimumSize(new Dimension(400,500));
     }
 

src/main/java/View/PlotDialog.java

@@ -41,7 +41,6 @@ public class PlotDialog extends JPanel {
         this.setPreferredSize(new Dimension(800, 500));
         this.setMinimumSize(new Dimension(800, 500));
         this.setLayout(new BorderLayout());
-
     }
 
     public void createPlot(LinkedList<Line> points) {

src/test/java/Presenter/Algorithms/LeastMedianOfSquaresEstimatorTest.java

@@ -49,10 +49,10 @@ public class LeastMedianOfSquaresEstimatorTest {
 
     @Test
     public void mergeSort() throws Exception {
-        double[] umin = {6,3,4,1,2,5};
-        double[] umax = {3,5,2,6,1,4};
-//        double[] umin = {3,1,4,2};
-//        double[] umax = {1,4,2,3};
+//        double[] umin = {6,3,4,1,2,5};
+//        double[] umax = {3,5,2,6,1,4};
+        double[] umin = {1,2,3,4};
+        double[] umax = {2,3,4,1};
         ArrayList<Integer> a = new ArrayList<>();
         ArrayList<Integer> b = new ArrayList<>();
 
@@ -63,9 +63,9 @@ public class LeastMedianOfSquaresEstimatorTest {
         for (double d :umax) {
             b.add((int) d);
         }
-
-        int ret = InversionCounter.run(a, b);
-        assertEquals(9d, ret, 0.001);
+        InversionCounter invCounter = new InversionCounter();
+        int ret = invCounter.run(a, b);
+        assertEquals(3d, ret, 0.001);
 
     }