InversionCounter um die ausgabe der inversionspaare erweitert
This commit is contained in:
parent
e0a99fd006
commit
202673272c
|
@ -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());
|
||||
//}
|
||||
|
||||
}
|
||||
|
||||
}
|
||||
|
|
|
@ -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;
|
||||
}
|
||||
|
|
|
@ -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));
|
||||
}
|
||||
|
||||
|
|
|
@ -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) {
|
||||
|
|
|
@ -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);
|
||||
|
||||
}
|
||||
|
||||
|
|
Loading…
Reference in New Issue