Scala aligner Smith-Waterman with row-column maximum (govnokod ^_^)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
import scala.io.Source
import Array._
/**
* Created by Const.
*/
class Aligner(fileWithData: String) {
val data = Source.fromFile(fileWithData).mkString.split("\n").toList
val alphabet = data(0).zipWithIndex.map{case (x: Char, i: Int) => (x, i)}.toMap
val (xx, xt) = (data.take(alphabet.size + 1).tail, data.drop(alphabet.size + 1))
val mtx = xx.map((x: String) => x.split(" ").map((num: String) => num.toInt)).toArray
for ((row, idx) <- mtx.zipWithIndex) {
for (j <- row) {
print("!" + j)
}
println()
}
val (gapScore, maxGaps, firstSeq, secondSeq) = xt match {
case (score: String) :: (maxg: String) :: (fst: String) :: (scd: String) :: Nil => (score.toInt, maxg.toInt, fst, scd)
case _ => throw new IllegalArgumentException("Please check your input file.")
}
def alignWithMiller() {
var scoreMatrix = ofDim[Int](firstSeq.length + 1, secondSeq.length + 1)
var initialString = Range(0, -secondSeq.length, -1).toArray
}
def alignWithNiddleman(maximumGaps: Int = maxGaps) {
var scoreMatrix = ofDim[Int](secondSeq.length + 1, firstSeq.length + 1)
for (i <- 0 to secondSeq.length)
scoreMatrix(i)(0) = 0
for (j <- 0 to firstSeq.length)
scoreMatrix(0)(j) = 0
for (i <- scoreMatrix.indices if i > 0) {
for (j <- scoreMatrix(i).indices if j > 0) {
val matcher = scoreMatrix(i - 1)(j - 1) + mtx(alphabet(secondSeq(i - 1)))(alphabet(firstSeq(j - 1)))
val delete = if (i > 1)
Range(1, i).toList.map((k: Int) => scoreMatrix(i - k)(j) + gapScore*k).max
else scoreMatrix(1)(j - 1) + gapScore
val insert = if (j > 1)
Range(1, j).toList.map((k: Int) => scoreMatrix(i)(j - k) + gapScore*k).max
else scoreMatrix(i - 1)(1) + gapScore
scoreMatrix(i)(j) = List[Int](matcher, delete, insert).max
}
}
for (row <- scoreMatrix) {
for (j <- row) {
printf("%-5d", j)
}
println()
}
var aligned = (List[Char](), List[Char]())
var i = secondSeq.length
var j = firstSeq.length
while (i != 0 && j != 0) {
val forward = scoreMatrix(i - 1)(j - 1)
val gapSecond = scoreMatrix(i - 1)(j)
val gapFirst = scoreMatrix(i)(j - 1)
(forward :: gapFirst :: gapSecond :: Nil) match {
case x:List[Int] if forward == x.max => {
aligned = (secondSeq(i - 1) +: aligned._1, firstSeq(j - 1) +: aligned._2)
i -= 1
j -= 1
}
case x:List[Int] if gapFirst == x.max => {
aligned = ('-' +: aligned._1, firstSeq(j - 1) +: aligned._2)
j -= 1
}
case x:List[Int] if gapSecond == x.max => {
aligned = (secondSeq(i - 1) +: aligned._1, '-' +: aligned._2)
i -= 1
}
}
}
if (i > 0) {
while (i > 0) {
aligned = (secondSeq(i - 1) +: aligned._1, '-' +: aligned._2)
i -= 1
}
}
if (j > 0) {
while (j > 0) {
aligned = ('-' +: aligned._1, firstSeq(j - 1) +: aligned._2)
j -= 1
}
}
println(aligned._1 mkString)
println(aligned._2 mkString)
}
}