Changeset 1586

Timestamp:

06/30/14 08:51:09 (10 years ago)

Author:

rkrimmel

Message:

Adding simple smith waterman and changing alignment algorithm creation to factory pattern

Location:

branches/ralph/src/main/java/de/ugoe/cs/autoquest/tasktrees

Files:

• alignment/algorithms/AlignmentAlgorithm.java (added)
• alignment/algorithms/AlignmentAlgorithmFactory.java (added)
• alignment/algorithms/SmithWaterman.java (added)
• alignment/algorithms/SmithWatermanRepeated.java (modified) (3 diffs)
• alignment/matrix/BinaryAlignmentStorage.java (modified) (1 diff)
• alignment/pal/tree/FengDoolittleNode.java (modified) (2 diffs)
• alignment/pal/tree/UPGMAAligningTree.java (modified) (8 diffs)
• temporalrelation/SequenceForTaskDetectionRuleAlignment.java (modified) (2 diffs)

branches/ralph/src/main/java/de/ugoe/cs/autoquest/tasktrees/alignment/algorithms/SmithWatermanRepeated.java

@@ -8 +8 @@
 import de.ugoe.cs.util.console.Console;
 
-public class SmithWatermanRepeated {
+public class SmithWatermanRepeated implements AlignmentAlgorithm {
 
         /**
@@ -208 +208 @@
         }
 
-        /**
-         * Get the alignment score between the two input strings.
-         */
+        /* (non-Javadoc)
+         * @see de.ugoe.cs.autoquest.tasktrees.alignment.algorithms.AlignmentAlgorithm#getAlignmentScore()
+         */
+        @Override
         public double getAlignmentScore() {
                 return matrix[length1+1][0].getScore();
@@ -328 +329 @@
 
 
+        /* (non-Javadoc)
+         * @see de.ugoe.cs.autoquest.tasktrees.alignment.algorithms.AlignmentAlgorithm#getAlignment()
+         */
+        @Override
         public ArrayList<NumberSequence> getAlignment() {
                 return alignment;

branches/ralph/src/main/java/de/ugoe/cs/autoquest/tasktrees/alignment/matrix/BinaryAlignmentStorage.java

@@ -2 +2 @@
 
 
-import de.ugoe.cs.autoquest.tasktrees.alignment.algorithms.SmithWatermanRepeated;
+import de.ugoe.cs.autoquest.tasktrees.alignment.algorithms.AlignmentAlgorithm;
 
 public class BinaryAlignmentStorage {
 
-    private SmithWatermanRepeated[][] alignments;
+    private AlignmentAlgorithm[][] alignments;
     UPGMAMatrix sequenceDistances;
    
     public BinaryAlignmentStorage(int sizex, int sizey) {
-        alignments = new SmithWatermanRepeated[sizex+1][sizey+1];
+        alignments = new AlignmentAlgorithm[sizex+1][sizey+1];
         sequenceDistances = new UPGMAMatrix(Math.max(sizex,sizey));
         sequenceDistances.initialize(Double.POSITIVE_INFINITY);
     }
     
-    public void set(int i,int j,SmithWatermanRepeated sw) {
+    public void set(int i,int j,AlignmentAlgorithm sw) {
         alignments[i][j] = sw;
     }
     
-    public SmithWatermanRepeated get(int i,int j) {
+    public AlignmentAlgorithm get(int i,int j) {
         return alignments[i][j];
     }

branches/ralph/src/main/java/de/ugoe/cs/autoquest/tasktrees/alignment/pal/tree/FengDoolittleNode.java

@@ -11 +11 @@
 
 import java.util.ArrayList;
-import java.util.logging.Level;
-
 import de.ugoe.cs.autoquest.tasktrees.alignment.algorithms.NumberSequence;
 import de.ugoe.cs.autoquest.tasktrees.alignment.pal.misc.Identifier;
-import de.ugoe.cs.util.console.Console;
+
 
 
@@ -374 +372 @@
                 newNode.addChild(child2);
                 newNode.setIdentifier(new Identifier(child1.getIdentifier().getName() + " " + child2.getIdentifier().getName()));
-                //System.out.println("Merging " + child1.getIdentifier() + " with " + child2.getIdentifier());
                 
                 return newNode;

branches/ralph/src/main/java/de/ugoe/cs/autoquest/tasktrees/alignment/pal/tree/UPGMAAligningTree.java

@@ -15 +15 @@
 
 import java.util.ArrayList;
-import java.util.Iterator;
 import java.util.logging.Level;
 
+import de.ugoe.cs.autoquest.tasktrees.alignment.algorithms.AlignmentAlgorithm;
+import de.ugoe.cs.autoquest.tasktrees.alignment.algorithms.AlignmentAlgorithmFactory;
 import de.ugoe.cs.autoquest.tasktrees.alignment.algorithms.NumberSequence;
 import de.ugoe.cs.autoquest.tasktrees.alignment.algorithms.SmithWatermanRepeated;
@@ -228 +229 @@
                                 int maxIndex = 0;
                                 for(int i=0;i<seqCount1;i++) {
-                                        tempStorage.set(i, 1, new SmithWatermanRepeated(node1.getSequence(i).getSequence(), node2.getSequence(0).getSequence() , submat, 5));
+                                        tempStorage.set(i, 1, AlignmentAlgorithmFactory.create(node1.getSequence(i).getSequence(), node2.getSequence(0).getSequence() , submat, 5));
                                         if(maxScore < tempStorage.get(i, 1).getAlignmentScore()) {
                                                 maxScore = tempStorage.get(i, 1).getAlignmentScore();
@@ -234 +235 @@
                                         }
                                 }
+                                //if(maxScore > 0)
                                 alignment.add(tempStorage.get(maxIndex, 1).getAlignment().get(1));
                         }
@@ -243 +245 @@
                                 int maxIndex = 0;
                                 for(int i=0;i<seqCount2;i++) {
-                                        tempStorage.set(1, i, new SmithWatermanRepeated(node2.getSequence(i).getSequence(), node1.getSequence(0).getSequence() , submat, 5));
+                                        tempStorage.set(1, i, AlignmentAlgorithmFactory.create(node2.getSequence(i).getSequence(), node1.getSequence(0).getSequence() , submat, 5));
                                         if(maxScore < tempStorage.get(1, i).getAlignmentScore()) {
                                                 maxScore = tempStorage.get(1, i).getAlignmentScore();
@@ -249 +251 @@
                                         }
                                 }
+                                //if(maxScore > 0)
                                 alignment.add(tempStorage.get(1,maxIndex).getAlignment().get(1));
                         }
@@ -261 +264 @@
                                         for(int i=0;i<seqCount1;i++) {
                                                 for(int j=0;j<seqCount2;j++) {
-                                                        tempStorage1.set(j, 0, new SmithWatermanRepeated(node1.getSequence(i).getSequence(), node2.getSequence(j).getSequence() , submat, 5));
+                                                        tempStorage1.set(j, 0, AlignmentAlgorithmFactory.create(node1.getSequence(i).getSequence(), node2.getSequence(j).getSequence() , submat, 5));
                                                         if(maxScore1 < tempStorage1.get(j, 0).getAlignmentScore()) {
                                                                 maxScore1 = tempStorage1.get(j, 0).getAlignmentScore();
@@ -267 +270 @@
                                                         }
                                                 }
+                                                //if(maxScore1 > 0)
                                                 alignment.add(tempStorage1.get(maxIndex1,0).getAlignment().get(0));
                                         }
                                         for(int i=0; i<seqCount2;i++) {
                                                 for (int j=0;j<seqCount1;j++) {
-                                                        tempStorage2.set(j, 0, new SmithWatermanRepeated(node2.getSequence(i).getSequence(),node1.getSequence(j).getSequence(),submat,5));
+                                                        tempStorage2.set(j, 0, AlignmentAlgorithmFactory.create(node2.getSequence(i).getSequence(),node1.getSequence(j).getSequence(),submat,5));
                                                         if(maxScore2 < tempStorage2.get(j, 0).getAlignmentScore()) {
                                                                 maxScore2 = tempStorage2.get(j, 0).getAlignmentScore();
@@ -277 +281 @@
                                                         }
                                                 }
+                                                //if(maxScore2 > 0)
                                                 alignment.add(tempStorage2.get(maxIndex2,0).getAlignment().get(0));
                                         }

branches/ralph/src/main/java/de/ugoe/cs/autoquest/tasktrees/temporalrelation/SequenceForTaskDetectionRuleAlignment.java

@@ -26 +26 @@
 import java.util.logging.Level;
 
+import de.ugoe.cs.autoquest.tasktrees.alignment.algorithms.AlignmentAlgorithm;
+import de.ugoe.cs.autoquest.tasktrees.alignment.algorithms.AlignmentAlgorithmFactory;
 import de.ugoe.cs.autoquest.tasktrees.alignment.algorithms.NumberSequence;
 import de.ugoe.cs.autoquest.tasktrees.alignment.algorithms.SmithWatermanRepeated;
@@ -170 +172 @@
                                         int smithWatermanThreshold = 10;
 
-                                        alignments.set(i, j,new SmithWatermanRepeated(
+                                        alignments.set(i, j,AlignmentAlgorithmFactory.create(
                                                         ns1.getSequence(), ns2.getSequence(), submat,
                                                         smithWatermanThreshold));
-                                        SmithWatermanRepeated sameSequence1 = new SmithWatermanRepeated(
+                                        AlignmentAlgorithm sameSequence1 = AlignmentAlgorithmFactory.create(
                                                         ns1.getSequence(), ns1.getSequence(), submat,
                                                         smithWatermanThreshold);
-                                        SmithWatermanRepeated sameSequence2 = new SmithWatermanRepeated(
+                                        AlignmentAlgorithm sameSequence2 = AlignmentAlgorithmFactory.create(
                                                         ns2.getSequence(), ns2.getSequence(), submat,
                                                         smithWatermanThreshold);
-                                        SmithWatermanRepeated randomSequence = new SmithWatermanRepeated(
+                                        AlignmentAlgorithm randomSequence = AlignmentAlgorithmFactory.create(
                                                         ns1.shuffle().getSequence(),ns2.shuffle().getSequence(),submat,smithWatermanThreshold);