Compare commits
No commits in common. "main" and "0.0.1" have entirely different histories.
43
.eslintrc.json
Normal file
43
.eslintrc.json
Normal file
@ -0,0 +1,43 @@
|
||||
{
|
||||
"env": {
|
||||
"es2021": true,
|
||||
"node": true
|
||||
},
|
||||
"extends": "standard",
|
||||
"parserOptions": {
|
||||
"ecmaVersion": "latest",
|
||||
"sourceType": "module"
|
||||
},
|
||||
"rules": {
|
||||
"no-tabs": [
|
||||
"error",
|
||||
{
|
||||
"allowIndentationTabs": true
|
||||
}
|
||||
],
|
||||
"indent": [
|
||||
"error",
|
||||
"tab"
|
||||
],
|
||||
"linebreak-style": [
|
||||
"error",
|
||||
"unix"
|
||||
],
|
||||
"quotes": [
|
||||
"error",
|
||||
"double"
|
||||
],
|
||||
"semi": [
|
||||
"error",
|
||||
"always"
|
||||
],
|
||||
"brace-style": [
|
||||
"error",
|
||||
"stroustrup",
|
||||
{
|
||||
"allowSingleLine": false
|
||||
}
|
||||
],
|
||||
"camelcase": 0
|
||||
}
|
||||
}
|
||||
4
.gitignore
vendored
4
.gitignore
vendored
@ -1,2 +1,2 @@
|
||||
go.sum
|
||||
dist/*
|
||||
**/package-lock.json
|
||||
**/node_modules
|
||||
|
||||
26
Makefile
26
Makefile
@ -1,26 +0,0 @@
|
||||
.PHONY: build clean test
|
||||
|
||||
build: clean
|
||||
@echo "======================== Building Binary ======================="
|
||||
minify wfa.js > dist/wfa.js
|
||||
GOOS=js GOARCH=wasm CGO_ENABLED=0 tinygo build -panic=trap -no-debug -opt=2 -target=wasm -o dist/wfa.wasm .
|
||||
|
||||
clean:
|
||||
@echo "======================== Cleaning Project ======================"
|
||||
go clean
|
||||
rm -f dist/wfa.wasm dist/wfa.js cover.prof cpu.prof mem.prof test.test
|
||||
|
||||
test:
|
||||
@echo "======================== Running Tests ========================="
|
||||
go test -v -cover -coverpkg=./pkg/ -coverprofile cover.prof -cpuprofile cpu.prof -memprofile mem.prof ./test/
|
||||
@echo "======================= Coverage Report ========================"
|
||||
go tool cover -func=cover.prof
|
||||
@rm -f cover.prof
|
||||
@echo "==================== CPU Performance Report ===================="
|
||||
go tool pprof -top cpu.prof
|
||||
@rm -f cpu.prof
|
||||
@echo "=================== Memory Performance Report =================="
|
||||
go tool pprof -top mem.prof
|
||||
@rm -f mem.prof
|
||||
|
||||
@rm -f test.test
|
||||
13
README.md
13
README.md
@ -1,13 +0,0 @@
|
||||
# Using WFA-JS
|
||||
|
||||
Download `wfa.js` and `wfa.wasm`from [releases](https://git.tronnet.net/tronnet/WFA-JS/releases) to your project. Add to your script:
|
||||
|
||||
```
|
||||
import wfa from "./wfa.js"
|
||||
await wfa("<path to wasm>")
|
||||
let result = wfAlign(...)
|
||||
operations = DecodeCIGAR(result.CIGAR)
|
||||
// ...
|
||||
```
|
||||
|
||||
Where `<path to wasm>` is the path from the site root ie. `./scripts/wfa.wasm`. This will depend on your project structure.
|
||||
15
go.mod
15
go.mod
@ -1,15 +0,0 @@
|
||||
module wfa
|
||||
|
||||
go 1.23.2
|
||||
|
||||
require (
|
||||
github.com/schollz/progressbar/v3 v3.17.0
|
||||
golang.org/x/exp v0.0.0-20241009180824-f66d83c29e7c
|
||||
)
|
||||
|
||||
require (
|
||||
github.com/mitchellh/colorstring v0.0.0-20190213212951-d06e56a500db // indirect
|
||||
github.com/rivo/uniseg v0.4.7 // indirect
|
||||
golang.org/x/sys v0.26.0 // indirect
|
||||
golang.org/x/term v0.25.0 // indirect
|
||||
)
|
||||
91
main.go
91
main.go
@ -1,91 +0,0 @@
|
||||
package main
|
||||
|
||||
import (
|
||||
"fmt"
|
||||
"syscall/js"
|
||||
wfa "wfa/pkg"
|
||||
)
|
||||
|
||||
func main() {
|
||||
c := make(chan bool)
|
||||
js.Global().Set("wfAlign", js.FuncOf(wfAlign))
|
||||
js.Global().Set("DecodeCIGAR", js.FuncOf(DecodeCIGAR))
|
||||
<-c
|
||||
}
|
||||
|
||||
func wfAlign(this js.Value, args []js.Value) interface{} {
|
||||
if len(args) != 4 {
|
||||
fmt.Println("invalid number of args, requires 4: s1, s2, penalties, doCIGAR")
|
||||
return nil
|
||||
}
|
||||
|
||||
if args[0].Type() != js.TypeString {
|
||||
fmt.Println("s1 should be a string")
|
||||
return nil
|
||||
}
|
||||
|
||||
s1 := args[0].String()
|
||||
|
||||
if args[1].Type() != js.TypeString {
|
||||
fmt.Println("s2 should be a string")
|
||||
return nil
|
||||
}
|
||||
|
||||
s2 := args[1].String()
|
||||
|
||||
if args[2].Type() != js.TypeObject {
|
||||
fmt.Println("penalties should be a map with key values m, x, o, e")
|
||||
return nil
|
||||
}
|
||||
|
||||
if args[2].Get("m").IsUndefined() || args[2].Get("x").IsUndefined() || args[2].Get("o").IsUndefined() || args[2].Get("e").IsUndefined() {
|
||||
fmt.Println("penalties should be a map with key values m, x, o, e")
|
||||
return nil
|
||||
}
|
||||
|
||||
m := args[2].Get("m").Int()
|
||||
x := args[2].Get("x").Int()
|
||||
o := args[2].Get("o").Int()
|
||||
e := args[2].Get("e").Int()
|
||||
|
||||
penalties := wfa.Penalty{
|
||||
M: m,
|
||||
X: x,
|
||||
O: o,
|
||||
E: e,
|
||||
}
|
||||
|
||||
if args[3].Type() != js.TypeBoolean {
|
||||
fmt.Println("doCIGAR should be a boolean")
|
||||
return nil
|
||||
}
|
||||
|
||||
doCIGAR := args[3].Bool()
|
||||
|
||||
// Call the actual func.
|
||||
result := wfa.WFAlign(s1, s2, penalties, doCIGAR)
|
||||
resultMap := map[string]interface{}{
|
||||
"score": result.Score,
|
||||
"CIGAR": result.CIGAR,
|
||||
}
|
||||
|
||||
return js.ValueOf(resultMap)
|
||||
}
|
||||
|
||||
func DecodeCIGAR(this js.Value, args []js.Value) interface{} {
|
||||
if len(args) != 1 {
|
||||
fmt.Println("invalid number of args, requires 1: CIGAR")
|
||||
return nil
|
||||
}
|
||||
|
||||
if args[0].Type() != js.TypeString {
|
||||
fmt.Println("CIGAR should be a string")
|
||||
return nil
|
||||
}
|
||||
|
||||
CIGAR := args[0].String()
|
||||
|
||||
decoded := wfa.RunLengthDecode(CIGAR)
|
||||
|
||||
return js.ValueOf(decoded)
|
||||
}
|
||||
18
package.json
Normal file
18
package.json
Normal file
@ -0,0 +1,18 @@
|
||||
{
|
||||
"name": "wfa-js",
|
||||
"version": "0.0.1",
|
||||
"description": "Wavefront alignment algorithm in JS",
|
||||
"main": "src/main.js",
|
||||
"type": "module",
|
||||
"devDependencies": {
|
||||
"eslint": "^8.43.0",
|
||||
"eslint-config-standard": "^17.1.0",
|
||||
"eslint-plugin-import": "^2.27.5",
|
||||
"eslint-plugin-n": "^16.0.1",
|
||||
"eslint-plugin-promise": "^6.1.1",
|
||||
"progress": "^2.0.3"
|
||||
},
|
||||
"scripts": {
|
||||
"lint": "DEBUG=eslint:cli-engine eslint --fix ."
|
||||
}
|
||||
}
|
||||
@ -1,55 +0,0 @@
|
||||
package wfa
|
||||
|
||||
type PositiveSlice[T any] struct {
|
||||
data []T
|
||||
valid []bool
|
||||
defaultValue T
|
||||
}
|
||||
|
||||
func (a *PositiveSlice[T]) TranslateIndex(idx int) int {
|
||||
return idx
|
||||
}
|
||||
|
||||
func (a *PositiveSlice[T]) Valid(idx int) bool {
|
||||
actualIdx := a.TranslateIndex(idx)
|
||||
return 0 <= actualIdx && actualIdx < len(a.valid) && a.valid[actualIdx]
|
||||
}
|
||||
|
||||
func (a *PositiveSlice[T]) Get(idx int) T {
|
||||
actualIdx := a.TranslateIndex(idx)
|
||||
if 0 <= actualIdx && actualIdx < len(a.valid) && a.valid[actualIdx] { // idx is in the slice
|
||||
return a.data[actualIdx]
|
||||
} else { // idx is out of the slice
|
||||
return a.defaultValue
|
||||
}
|
||||
}
|
||||
|
||||
func (a *PositiveSlice[T]) Set(idx int, value T) {
|
||||
actualIdx := a.TranslateIndex(idx)
|
||||
if actualIdx < 0 || actualIdx >= len(a.valid) { // idx is outside the slice
|
||||
// expand data array to actualIdx
|
||||
newData := make([]T, 2*actualIdx+1)
|
||||
copy(newData, a.data)
|
||||
a.data = newData
|
||||
|
||||
// expand valid array to actualIdx
|
||||
newValid := make([]bool, 2*actualIdx+1)
|
||||
copy(newValid, a.valid)
|
||||
a.valid = newValid
|
||||
}
|
||||
|
||||
a.data[actualIdx] = value
|
||||
a.valid[actualIdx] = true
|
||||
}
|
||||
|
||||
func (a *PositiveSlice[T]) Preallocate(hi int) {
|
||||
size := hi
|
||||
|
||||
// expand data array to actualIdx
|
||||
newData := make([]T, size+1)
|
||||
a.data = newData
|
||||
|
||||
// expand valid array to actualIdx
|
||||
newValid := make([]bool, size+1)
|
||||
a.valid = newValid
|
||||
}
|
||||
79
pkg/debug.go
79
pkg/debug.go
@ -1,79 +0,0 @@
|
||||
package wfa
|
||||
|
||||
import (
|
||||
"fmt"
|
||||
"math"
|
||||
)
|
||||
|
||||
func (w *WavefrontComponent) String(score int) string {
|
||||
traceback_str := []string{"OI", "EI", "OD", "ED", "SB", "IN", "DL", "EN"}
|
||||
s := "<"
|
||||
min_lo := math.MaxInt
|
||||
max_hi := math.MinInt
|
||||
|
||||
for i := 0; i <= score; i++ {
|
||||
if w.lo.Valid(i) && w.lo.Get(i) < min_lo {
|
||||
min_lo = w.lo.Get(i)
|
||||
}
|
||||
if w.hi.Valid(i) && w.hi.Get(i) > max_hi {
|
||||
max_hi = w.hi.Get(i)
|
||||
}
|
||||
}
|
||||
|
||||
for k := min_lo; k <= max_hi; k++ {
|
||||
s = s + fmt.Sprintf("%02d", k)
|
||||
if k < max_hi {
|
||||
s = s + "|"
|
||||
}
|
||||
}
|
||||
|
||||
s = s + ">\t<"
|
||||
|
||||
for k := min_lo; k <= max_hi; k++ {
|
||||
s = s + fmt.Sprintf("%02d", k)
|
||||
if k < max_hi {
|
||||
s = s + "|"
|
||||
}
|
||||
}
|
||||
|
||||
s = s + ">\n"
|
||||
|
||||
for i := 0; i <= score; i++ {
|
||||
s = s + "["
|
||||
lo := w.lo.Get(i)
|
||||
hi := w.hi.Get(i)
|
||||
// print out wavefront matrix
|
||||
for k := min_lo; k <= max_hi; k++ {
|
||||
valid, val, _ := UnpackWavefrontValue(w.W.Get(i).Get(k))
|
||||
if valid {
|
||||
s = s + fmt.Sprintf("%02d", val)
|
||||
} else if k < lo || k > hi {
|
||||
s = s + "--"
|
||||
} else {
|
||||
s = s + " "
|
||||
}
|
||||
|
||||
if k < max_hi {
|
||||
s = s + "|"
|
||||
}
|
||||
}
|
||||
s = s + "]\t["
|
||||
// print out traceback matrix
|
||||
for k := min_lo; k <= max_hi; k++ {
|
||||
valid, _, tb := UnpackWavefrontValue(w.W.Get(i).Get(k))
|
||||
if valid {
|
||||
s = s + traceback_str[tb]
|
||||
} else if k < lo || k > hi {
|
||||
s = s + "--"
|
||||
} else {
|
||||
s = s + " "
|
||||
}
|
||||
|
||||
if k < max_hi {
|
||||
s = s + "|"
|
||||
}
|
||||
}
|
||||
s = s + "]\n"
|
||||
}
|
||||
return s
|
||||
}
|
||||
164
pkg/types.go
164
pkg/types.go
@ -1,164 +0,0 @@
|
||||
package wfa
|
||||
|
||||
type Result struct {
|
||||
Score int
|
||||
CIGAR string
|
||||
}
|
||||
|
||||
type Penalty struct {
|
||||
M int
|
||||
X int
|
||||
O int
|
||||
E int
|
||||
}
|
||||
|
||||
type Traceback byte
|
||||
|
||||
const (
|
||||
OpenIns Traceback = iota
|
||||
ExtdIns
|
||||
OpenDel
|
||||
ExtdDel
|
||||
Sub
|
||||
Ins
|
||||
Del
|
||||
End
|
||||
)
|
||||
|
||||
// bitpacked wavefront values with 1 valid bit, 3 traceback bits, and 28 bits for the diag distance
|
||||
// technically this restricts to solutions within 268 million score but that should be sufficient for most cases
|
||||
type WavefrontValue uint32
|
||||
|
||||
// TODO: add 64 bit packed value in case more than 268 million score is needed
|
||||
|
||||
// PackWavefrontValue: packs a diag value and traceback into a WavefrontValue
|
||||
func PackWavefrontValue(value uint32, traceback Traceback) WavefrontValue {
|
||||
valueBM := value & 0x0FFF_FFFF
|
||||
tracebackBM := uint32(traceback&0x0000_0007) << 28
|
||||
return WavefrontValue(0x8000_0000 | valueBM | tracebackBM)
|
||||
}
|
||||
|
||||
// UnpackWavefrontValue: opens a WavefrontValue into a valid bool, diag value and traceback
|
||||
func UnpackWavefrontValue(wfv WavefrontValue) (bool, uint32, Traceback) {
|
||||
valueBM := uint32(wfv & 0x0FFF_FFFF)
|
||||
tracebackBM := uint8(wfv & 0x7000_0000 >> 28)
|
||||
validBM := wfv&0x8000_0000 != 0
|
||||
return validBM, valueBM, Traceback(tracebackBM)
|
||||
}
|
||||
|
||||
// Wavefront: stores a single wavefront, stores wavefront's lo value and hi is naturally lo + len(data)
|
||||
type Wavefront struct { // since wavefronts store diag distance, they should never be negative, and traceback data can be stored as uint8
|
||||
data []WavefrontValue
|
||||
lo int
|
||||
}
|
||||
|
||||
// NewWavefront: returns a new wavefront with size accomodating lo and hi (inclusive)
|
||||
func NewWavefront(lo int, hi int) *Wavefront {
|
||||
a := &Wavefront{}
|
||||
|
||||
a.lo = lo
|
||||
size := a.TranslateIndex(hi)
|
||||
|
||||
newData := make([]WavefrontValue, size+1)
|
||||
a.data = newData
|
||||
|
||||
return a
|
||||
}
|
||||
|
||||
// TranslateIndex: utility function for getting the data index given a diagonal
|
||||
func (a *Wavefront) TranslateIndex(diagonal int) int {
|
||||
return diagonal - a.lo
|
||||
}
|
||||
|
||||
// Get: returns WavefrontValue for given diagonal
|
||||
func (a *Wavefront) Get(diagonal int) WavefrontValue {
|
||||
actualIdx := a.TranslateIndex(diagonal)
|
||||
if 0 <= actualIdx && actualIdx < len(a.data) { // idx is in the slice
|
||||
return a.data[actualIdx]
|
||||
} else { // idx is out of the slice
|
||||
return 0
|
||||
}
|
||||
}
|
||||
|
||||
// Set: the diagonal to a WavefrontValue
|
||||
func (a *Wavefront) Set(diagonal int, value WavefrontValue) {
|
||||
actualIdx := a.TranslateIndex(diagonal)
|
||||
|
||||
/* in theory idx is always in bounds because the wavefront is preallocated
|
||||
if actualIdx < 0 || actualIdx >= len(a.data) {
|
||||
return
|
||||
}
|
||||
*/
|
||||
|
||||
a.data[actualIdx] = value
|
||||
}
|
||||
|
||||
// WavefrontComponent: each M/I/D wavefront matrix including the wavefront data, lo and hi
|
||||
type WavefrontComponent struct {
|
||||
lo *PositiveSlice[int] // lo for each wavefront
|
||||
hi *PositiveSlice[int] // hi for each wavefront
|
||||
W *PositiveSlice[*Wavefront] // wavefront diag distance and traceback for each wavefront
|
||||
}
|
||||
|
||||
// NewWavefrontComponent: returns initialized WavefrontComponent
|
||||
func NewWavefrontComponent(preallocateSize int) *WavefrontComponent {
|
||||
// new wavefront component = {
|
||||
// lo = [0]
|
||||
// hi = [0]
|
||||
// W = []
|
||||
// }
|
||||
w := &WavefrontComponent{
|
||||
lo: &PositiveSlice[int]{
|
||||
data: []int{0},
|
||||
valid: []bool{true},
|
||||
},
|
||||
hi: &PositiveSlice[int]{
|
||||
data: []int{0},
|
||||
valid: []bool{true},
|
||||
},
|
||||
W: &PositiveSlice[*Wavefront]{
|
||||
defaultValue: &Wavefront{
|
||||
data: []WavefrontValue{0},
|
||||
},
|
||||
},
|
||||
}
|
||||
|
||||
w.lo.Preallocate(preallocateSize)
|
||||
w.hi.Preallocate(preallocateSize)
|
||||
w.W.Preallocate(preallocateSize)
|
||||
|
||||
return w
|
||||
}
|
||||
|
||||
// GetVal: get value for wavefront=score, diag=k => returns ok, value, traceback
|
||||
func (w *WavefrontComponent) GetVal(score int, k int) (bool, uint32, Traceback) {
|
||||
return UnpackWavefrontValue(w.W.Get(score).Get(k))
|
||||
}
|
||||
|
||||
// SetVal: set value, traceback for wavefront=score, diag=k
|
||||
func (w *WavefrontComponent) SetVal(score int, k int, val uint32, tb Traceback) {
|
||||
w.W.Get(score).Set(k, PackWavefrontValue(val, tb))
|
||||
}
|
||||
|
||||
// GetLoHi: get lo and hi for wavefront=score
|
||||
func (w *WavefrontComponent) GetLoHi(score int) (bool, int, int) {
|
||||
// if lo[score] and hi[score] are valid
|
||||
if w.lo.Valid(score) && w.hi.Valid(score) {
|
||||
// return lo[score] hi[score]
|
||||
return true, w.lo.Get(score), w.hi.Get(score)
|
||||
} else {
|
||||
return false, 0, 0
|
||||
}
|
||||
}
|
||||
|
||||
// SetLoHi: set lo and hi for wavefront=score
|
||||
func (w *WavefrontComponent) SetLoHi(score int, lo int, hi int) {
|
||||
// lo[score] = lo
|
||||
w.lo.Set(score, lo)
|
||||
// hi[score] = hi
|
||||
w.hi.Set(score, hi)
|
||||
|
||||
// preemptively setup w.W
|
||||
b := NewWavefront(lo, hi)
|
||||
w.W.Set(score, b)
|
||||
}
|
||||
169
pkg/utils.go
169
pkg/utils.go
@ -1,169 +0,0 @@
|
||||
package wfa
|
||||
|
||||
import (
|
||||
"math"
|
||||
"strings"
|
||||
|
||||
"golang.org/x/exp/constraints"
|
||||
)
|
||||
|
||||
func UIntToString(num uint) string { // num assumed to be positive
|
||||
var builder strings.Builder
|
||||
|
||||
for num > 0 {
|
||||
digit := num % 10
|
||||
builder.WriteRune(rune('0' + digit))
|
||||
num /= 10
|
||||
}
|
||||
|
||||
// Reverse the string as we built it in reverse order
|
||||
str := []rune(builder.String())
|
||||
for i, j := 0, len(str)-1; i < j; i, j = i+1, j-1 {
|
||||
str[i], str[j] = str[j], str[i]
|
||||
}
|
||||
|
||||
return string(str)
|
||||
}
|
||||
|
||||
func RunLengthDecode(encoded string) string {
|
||||
decoded := strings.Builder{}
|
||||
length := len(encoded)
|
||||
i := 0
|
||||
|
||||
for i < length {
|
||||
// If the current character is a digit, we need to extract the run length
|
||||
runLength := 0
|
||||
for i < length && encoded[i] >= '0' && encoded[i] <= '9' {
|
||||
runLength = runLength*10 + int(encoded[i]-'0')
|
||||
i++
|
||||
}
|
||||
|
||||
// The next character will be the character to repeat
|
||||
if i < length {
|
||||
char := encoded[i]
|
||||
for j := 0; j < runLength; j++ {
|
||||
decoded.WriteByte(char)
|
||||
}
|
||||
i++ // Move past the character
|
||||
}
|
||||
}
|
||||
|
||||
return decoded.String()
|
||||
}
|
||||
|
||||
func SafeMin[T constraints.Integer](values []T, idx int) T {
|
||||
return values[idx]
|
||||
}
|
||||
|
||||
func SafeMax[T constraints.Integer](values []T, idx int) T {
|
||||
return values[idx]
|
||||
}
|
||||
|
||||
func SafeArgMax[T constraints.Integer](valids []bool, values []T) (bool, int) {
|
||||
hasValid := false
|
||||
maxIndex := 0
|
||||
maxValue := math.MinInt
|
||||
for i := 0; i < len(valids); i++ {
|
||||
if valids[i] && int(values[i]) > maxValue {
|
||||
hasValid = true
|
||||
maxIndex = i
|
||||
maxValue = int(values[i])
|
||||
}
|
||||
}
|
||||
if hasValid {
|
||||
return true, maxIndex
|
||||
} else {
|
||||
return false, 0
|
||||
}
|
||||
}
|
||||
|
||||
func SafeArgMin[T constraints.Integer](valids []bool, values []T) (bool, int) {
|
||||
hasValid := false
|
||||
minIndex := 0
|
||||
minValue := math.MaxInt
|
||||
for i := 0; i < len(valids); i++ {
|
||||
if valids[i] && int(values[i]) < minValue {
|
||||
hasValid = true
|
||||
minIndex = i
|
||||
minValue = int(values[i])
|
||||
}
|
||||
}
|
||||
if hasValid {
|
||||
return true, minIndex
|
||||
} else {
|
||||
return false, 0
|
||||
}
|
||||
}
|
||||
|
||||
func NextLoHi(M *WavefrontComponent, I *WavefrontComponent, D *WavefrontComponent, score int, penalties Penalty) (int, int) {
|
||||
x := penalties.X
|
||||
o := penalties.O
|
||||
e := penalties.E
|
||||
|
||||
a_ok, a_lo, a_hi := M.GetLoHi(score - x)
|
||||
b_ok, b_lo, b_hi := M.GetLoHi(score - o - e)
|
||||
c_ok, c_lo, c_hi := I.GetLoHi(score - e)
|
||||
d_ok, d_lo, d_hi := D.GetLoHi(score - e)
|
||||
|
||||
ok_lo, idx := SafeArgMin(
|
||||
[]bool{a_ok, b_ok, c_ok, d_ok},
|
||||
[]int{a_lo, b_lo, c_lo, d_lo},
|
||||
)
|
||||
lo := SafeMin([]int{a_lo, b_lo, c_lo, d_lo}, idx) - 1
|
||||
|
||||
ok_hi, idx := SafeArgMax(
|
||||
[]bool{a_ok, b_ok, c_ok, d_ok},
|
||||
[]int{a_hi, b_hi, c_hi, d_hi},
|
||||
)
|
||||
hi := SafeMax([]int{a_hi, b_hi, c_hi, d_hi}, idx) + 1
|
||||
|
||||
if ok_lo && ok_hi {
|
||||
M.SetLoHi(score, lo, hi)
|
||||
I.SetLoHi(score, lo, hi)
|
||||
D.SetLoHi(score, lo, hi)
|
||||
}
|
||||
return lo, hi
|
||||
}
|
||||
|
||||
func NextI(M *WavefrontComponent, I *WavefrontComponent, score int, k int, penalties Penalty) {
|
||||
o := penalties.O
|
||||
e := penalties.E
|
||||
|
||||
a_ok, a, _ := M.GetVal(score-o-e, k-1)
|
||||
b_ok, b, _ := I.GetVal(score-e, k-1)
|
||||
|
||||
ok, nextITraceback := SafeArgMax([]bool{a_ok, b_ok}, []uint32{a, b})
|
||||
nextIVal := SafeMax([]uint32{a, b}, nextITraceback) + 1 // important that the +1 is here
|
||||
if ok {
|
||||
I.SetVal(score, k, nextIVal, []Traceback{OpenIns, ExtdIns}[nextITraceback])
|
||||
}
|
||||
}
|
||||
|
||||
func NextD(M *WavefrontComponent, D *WavefrontComponent, score int, k int, penalties Penalty) {
|
||||
o := penalties.O
|
||||
e := penalties.E
|
||||
|
||||
a_ok, a, _ := M.GetVal(score-o-e, k+1)
|
||||
b_ok, b, _ := D.GetVal(score-e, k+1)
|
||||
|
||||
ok, nextDTraceback := SafeArgMax([]bool{a_ok, b_ok}, []uint32{a, b})
|
||||
nextDVal := SafeMax([]uint32{a, b}, nextDTraceback)
|
||||
if ok {
|
||||
D.SetVal(score, k, nextDVal, []Traceback{OpenDel, ExtdDel}[nextDTraceback])
|
||||
}
|
||||
}
|
||||
|
||||
func NextM(M *WavefrontComponent, I *WavefrontComponent, D *WavefrontComponent, score int, k int, penalties Penalty) {
|
||||
x := penalties.X
|
||||
|
||||
a_ok, a, _ := M.GetVal(score-x, k)
|
||||
a++ // important to have +1 here
|
||||
b_ok, b, _ := I.GetVal(score, k)
|
||||
c_ok, c, _ := D.GetVal(score, k)
|
||||
|
||||
ok, nextMTraceback := SafeArgMax([]bool{a_ok, b_ok, c_ok}, []uint32{a, b, c})
|
||||
nextMVal := SafeMax([]uint32{a, b, c}, nextMTraceback)
|
||||
if ok {
|
||||
M.SetVal(score, k, nextMVal, []Traceback{Sub, Ins, Del}[nextMTraceback])
|
||||
}
|
||||
}
|
||||
198
pkg/wfa.go
198
pkg/wfa.go
@ -1,198 +0,0 @@
|
||||
package wfa
|
||||
|
||||
import (
|
||||
"strings"
|
||||
)
|
||||
|
||||
func WFAlign(s1 string, s2 string, penalties Penalty, doCIGAR bool) Result {
|
||||
n := len(s1)
|
||||
m := len(s2)
|
||||
A_k := m - n
|
||||
A_offset := uint32(m)
|
||||
score := 0
|
||||
estimatedScore := (max(n, m) * max(penalties.M, penalties.X, penalties.O, penalties.E)) / 4
|
||||
M := NewWavefrontComponent(estimatedScore)
|
||||
M.SetLoHi(0, 0, 0)
|
||||
M.SetVal(0, 0, 0, End)
|
||||
I := NewWavefrontComponent(estimatedScore)
|
||||
D := NewWavefrontComponent(estimatedScore)
|
||||
|
||||
for {
|
||||
WFExtend(M, s1, n, s2, m, score)
|
||||
ok, val, _ := M.GetVal(score, A_k)
|
||||
if ok && val >= A_offset {
|
||||
break
|
||||
}
|
||||
score = score + 1
|
||||
WFNext(M, I, D, score, penalties)
|
||||
}
|
||||
|
||||
CIGAR := ""
|
||||
if doCIGAR {
|
||||
CIGAR = WFBacktrace(M, I, D, score, penalties, A_k, A_offset, s1, s2)
|
||||
}
|
||||
|
||||
return Result{
|
||||
Score: score,
|
||||
CIGAR: CIGAR,
|
||||
}
|
||||
}
|
||||
|
||||
func WFExtend(M *WavefrontComponent, s1 string, n int, s2 string, m int, score int) {
|
||||
_, lo, hi := M.GetLoHi(score)
|
||||
for k := lo; k <= hi; k++ {
|
||||
// v = M[score][k] - k
|
||||
// h = M[score][k]
|
||||
ok, hu, _ := M.GetVal(score, k)
|
||||
h := int(hu)
|
||||
v := h - k
|
||||
|
||||
// exit early if v or h are invalid
|
||||
if !ok {
|
||||
continue
|
||||
}
|
||||
for v < n && h < m && s1[v] == s2[h] {
|
||||
_, val, tb := M.GetVal(score, k)
|
||||
M.SetVal(score, k, val+1, tb)
|
||||
v++
|
||||
h++
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func WFNext(M *WavefrontComponent, I *WavefrontComponent, D *WavefrontComponent, score int, penalties Penalty) {
|
||||
// get this score's lo, hi
|
||||
lo, hi := NextLoHi(M, I, D, score, penalties)
|
||||
|
||||
for k := lo; k <= hi; k++ {
|
||||
NextI(M, I, score, k, penalties)
|
||||
NextD(M, D, score, k, penalties)
|
||||
NextM(M, I, D, score, k, penalties)
|
||||
}
|
||||
}
|
||||
|
||||
func WFBacktrace(M *WavefrontComponent, I *WavefrontComponent, D *WavefrontComponent, score int, penalties Penalty, A_k int, A_offset uint32, s1 string, s2 string) string {
|
||||
x := penalties.X
|
||||
o := penalties.O
|
||||
e := penalties.E
|
||||
|
||||
tb_s := score
|
||||
tb_k := A_k
|
||||
done := false
|
||||
|
||||
_, current_dist, current_traceback := M.GetVal(tb_s, tb_k)
|
||||
|
||||
Ops := []rune{'~'}
|
||||
Counts := []uint{0}
|
||||
idx := 0
|
||||
|
||||
for !done {
|
||||
switch current_traceback {
|
||||
case OpenIns:
|
||||
if Ops[idx] == 'I' {
|
||||
Counts[idx]++
|
||||
} else {
|
||||
Ops = append(Ops, 'I')
|
||||
Counts = append(Counts, 1)
|
||||
idx++
|
||||
}
|
||||
|
||||
tb_s = tb_s - o - e
|
||||
tb_k = tb_k - 1
|
||||
_, current_dist, current_traceback = M.GetVal(tb_s, tb_k)
|
||||
case ExtdIns:
|
||||
if Ops[idx] == 'I' {
|
||||
Counts[idx]++
|
||||
} else {
|
||||
Ops = append(Ops, 'I')
|
||||
Counts = append(Counts, 1)
|
||||
idx++
|
||||
}
|
||||
|
||||
tb_s = tb_s - e
|
||||
tb_k = tb_k - 1
|
||||
_, current_dist, current_traceback = I.GetVal(tb_s, tb_k)
|
||||
case OpenDel:
|
||||
if Ops[idx] == 'D' {
|
||||
Counts[idx]++
|
||||
} else {
|
||||
Ops = append(Ops, 'D')
|
||||
Counts = append(Counts, 1)
|
||||
idx++
|
||||
}
|
||||
|
||||
tb_s = tb_s - o - e
|
||||
tb_k = tb_k + 1
|
||||
_, current_dist, current_traceback = M.GetVal(tb_s, tb_k)
|
||||
case ExtdDel:
|
||||
if Ops[idx] == 'D' {
|
||||
Counts[idx]++
|
||||
} else {
|
||||
Ops = append(Ops, 'D')
|
||||
Counts = append(Counts, 1)
|
||||
idx++
|
||||
}
|
||||
|
||||
tb_s = tb_s - e
|
||||
tb_k = tb_k + 1
|
||||
_, current_dist, current_traceback = D.GetVal(tb_s, tb_k)
|
||||
case Sub:
|
||||
tb_s = tb_s - x
|
||||
// tb_k = tb_k;
|
||||
_, next_dist, next_traceback := M.GetVal(tb_s, tb_k)
|
||||
|
||||
if int(current_dist-next_dist)-1 > 0 {
|
||||
Ops = append(Ops, 'M')
|
||||
Counts = append(Counts, uint(current_dist-next_dist)-1)
|
||||
idx++
|
||||
}
|
||||
|
||||
if Ops[idx] == 'X' {
|
||||
Counts[idx]++
|
||||
} else {
|
||||
Ops = append(Ops, 'X')
|
||||
Counts = append(Counts, 1)
|
||||
idx++
|
||||
}
|
||||
|
||||
current_dist = next_dist
|
||||
current_traceback = next_traceback
|
||||
case Ins:
|
||||
// tb_s = tb_s;
|
||||
// tb_k = tb_k;
|
||||
_, next_dist, next_traceback := I.GetVal(tb_s, tb_k)
|
||||
|
||||
Ops = append(Ops, 'M')
|
||||
Counts = append(Counts, uint(current_dist-next_dist))
|
||||
idx++
|
||||
|
||||
current_dist = next_dist
|
||||
current_traceback = next_traceback
|
||||
case Del:
|
||||
// tb_s = tb_s;
|
||||
// tb_k = tb_k;
|
||||
_, next_dist, next_traceback := D.GetVal(tb_s, tb_k)
|
||||
|
||||
Ops = append(Ops, 'M')
|
||||
Counts = append(Counts, uint(current_dist-next_dist))
|
||||
idx++
|
||||
|
||||
current_dist = next_dist
|
||||
current_traceback = next_traceback
|
||||
case End:
|
||||
Ops = append(Ops, 'M')
|
||||
Counts = append(Counts, uint(current_dist))
|
||||
idx++
|
||||
|
||||
done = true
|
||||
}
|
||||
}
|
||||
|
||||
CIGAR := strings.Builder{}
|
||||
for i := len(Ops) - 1; i > 0; i-- {
|
||||
CIGAR.WriteString(UIntToString(Counts[i]))
|
||||
CIGAR.WriteRune(Ops[i])
|
||||
}
|
||||
|
||||
return CIGAR.String()
|
||||
}
|
||||
31
src/main.js
Normal file
31
src/main.js
Normal file
@ -0,0 +1,31 @@
|
||||
import wf_align from "./wfa.js";
|
||||
import fs from "fs";
|
||||
import ProgressBar from "progress";
|
||||
|
||||
let data = fs.readFileSync("./tests/tests.json");
|
||||
data = JSON.parse(data);
|
||||
const sequences = fs.readFileSync("./tests/sequences").toString().split("\n");
|
||||
// const total = sequences.length;
|
||||
const total = 500; // skip the later tests because of memory usage
|
||||
|
||||
for (const test_name of Object.keys(data)) {
|
||||
const test = data[test_name];
|
||||
const penalties = test.penalties;
|
||||
const solutions = fs.readFileSync(test.solutions).toString().split("\n");
|
||||
const bar = new ProgressBar(":bar :current/:total", { total: total / 2 });
|
||||
console.log(`test: ${test_name}`);
|
||||
let correct = 0;
|
||||
let j = 0;
|
||||
for (let i = 0; i < total; i += 2) {
|
||||
const s1 = sequences[i].replace(">");
|
||||
const s2 = sequences[i + 1].replace("<");
|
||||
const { CIGAR, score } = wf_align(s1, s2, penalties);
|
||||
const solution_score = Number(solutions[j].split("\t")[0]);
|
||||
if (solution_score === -score) {
|
||||
correct += 1;
|
||||
}
|
||||
j += 1;
|
||||
bar.tick();
|
||||
}
|
||||
console.log(`correct: ${correct}\ntotal: ${total / 2}\n`);
|
||||
}
|
||||
328
src/wfa.js
Normal file
328
src/wfa.js
Normal file
@ -0,0 +1,328 @@
|
||||
class WavefrontComponent {
|
||||
constructor () {
|
||||
this.lo = [0]; // lo for each wavefront
|
||||
this.hi = [0]; // hi for each wavefront
|
||||
this.W = []; // wavefront diag distance for each wavefront
|
||||
this.A = []; // compact CIGAR for backtrace
|
||||
}
|
||||
|
||||
// get value for wavefront=score, diag=k
|
||||
get_val (score, k) {
|
||||
if (this.W[score] !== undefined && this.W[score][k] !== undefined) {
|
||||
return this.W[score][k];
|
||||
}
|
||||
else {
|
||||
return NaN;
|
||||
}
|
||||
}
|
||||
|
||||
// set value for wavefront=score, diag=k
|
||||
set_val (score, k, val) {
|
||||
if (this.W[score]) {
|
||||
this.W[score][k] = val;
|
||||
}
|
||||
else {
|
||||
this.W[score] = [];
|
||||
this.W[score][k] = val;
|
||||
}
|
||||
}
|
||||
|
||||
// get alignment traceback
|
||||
get_traceback (score, k) {
|
||||
if (this.A[score] !== undefined && this.A[score][k] !== undefined) {
|
||||
return this.A[score][k];
|
||||
}
|
||||
else {
|
||||
return undefined;
|
||||
}
|
||||
}
|
||||
|
||||
// set alignment traceback
|
||||
set_traceback (score, k, traceback) {
|
||||
if (this.A[score]) {
|
||||
this.A[score][k] = traceback;
|
||||
}
|
||||
else {
|
||||
this.A[score] = [];
|
||||
this.A[score][k] = traceback;
|
||||
}
|
||||
}
|
||||
|
||||
// get hi for wavefront=score
|
||||
get_hi (score) {
|
||||
const hi = this.hi[score];
|
||||
return isNaN(hi) ? 0 : hi;
|
||||
}
|
||||
|
||||
// set hi for wavefront=score
|
||||
set_hi (score, hi) {
|
||||
this.hi[score] = hi;
|
||||
}
|
||||
|
||||
// get lo for wavefront=score
|
||||
get_lo (score) {
|
||||
const lo = this.lo[score];
|
||||
return isNaN(lo) ? 0 : lo;
|
||||
}
|
||||
|
||||
// set lo for wavefront=score
|
||||
set_lo (score, lo) {
|
||||
this.lo[score] = lo;
|
||||
}
|
||||
|
||||
// string representation of all wavefronts
|
||||
toString () {
|
||||
const traceback_str = ["OI", "EI", "OD", "ED", "SB", "IN", "DL", "EN"];
|
||||
let s = "<";
|
||||
let min_lo = Infinity;
|
||||
let max_hi = -Infinity;
|
||||
// get the min lo and max hi values across all wavefronts
|
||||
for (let i = 0; i < this.W.length; i++) {
|
||||
const lo = this.lo[i];
|
||||
const hi = this.hi[i];
|
||||
if (lo < min_lo) {
|
||||
min_lo = lo;
|
||||
}
|
||||
if (hi > max_hi) {
|
||||
max_hi = hi;
|
||||
}
|
||||
}
|
||||
// print out two headers, one for wavefront and one for traceback
|
||||
for (let k = min_lo; k <= max_hi; k++) {
|
||||
s += FormatNumberLength(k, 2);
|
||||
if (k < max_hi) {
|
||||
s += "|";
|
||||
}
|
||||
}
|
||||
s += ">\t<";
|
||||
for (let k = min_lo; k <= max_hi; k++) {
|
||||
s += FormatNumberLength(k, 2);
|
||||
if (k < max_hi) {
|
||||
s += "|";
|
||||
}
|
||||
}
|
||||
s += ">\n";
|
||||
// for each wavefront
|
||||
for (let i = 0; i < this.W.length; i++) {
|
||||
s += "[";
|
||||
const lo = this.lo[i];
|
||||
const hi = this.hi[i];
|
||||
// print out the wavefront matrix
|
||||
for (let k = min_lo; k <= max_hi; k++) {
|
||||
if (this.W[i] !== undefined && this.W[i][k] !== undefined && !isNaN(this.W[i][k])) {
|
||||
s += FormatNumberLength(this.W[i][k], 2);
|
||||
}
|
||||
else if (k < lo || k > hi) {
|
||||
s += "--";
|
||||
}
|
||||
else {
|
||||
s += " ";
|
||||
}
|
||||
if (k < max_hi) {
|
||||
s += "|";
|
||||
}
|
||||
}
|
||||
s += "]\t[";
|
||||
// print out the traceback matrix
|
||||
for (let k = min_lo; k <= max_hi; k++) {
|
||||
if (this.A[i] !== undefined && this.A[i][k] !== undefined) {
|
||||
s += traceback_str[this.A[i][k].toString()];
|
||||
}
|
||||
else if (k < lo || k > hi) {
|
||||
s += "--";
|
||||
}
|
||||
else {
|
||||
s += " ";
|
||||
}
|
||||
if (k < max_hi) {
|
||||
s += "|";
|
||||
}
|
||||
}
|
||||
s += "]\n";
|
||||
}
|
||||
return s;
|
||||
}
|
||||
}
|
||||
|
||||
const traceback = {
|
||||
OpenIns: 0,
|
||||
ExtdIns: 1,
|
||||
OpenDel: 2,
|
||||
ExtdDel: 3,
|
||||
Sub: 4,
|
||||
Ins: 5,
|
||||
Del: 6,
|
||||
End: 7
|
||||
};
|
||||
|
||||
function FormatNumberLength (num, length) {
|
||||
let r = "" + num;
|
||||
while (r.length < length) {
|
||||
r = " " + r;
|
||||
}
|
||||
return r;
|
||||
}
|
||||
|
||||
function min (args) {
|
||||
args.forEach((el, idx, arr) => {
|
||||
arr[idx] = isNaN(el) ? Infinity : el;
|
||||
});
|
||||
const min = Math.min.apply(Math, args);
|
||||
return min === Infinity ? NaN : min;
|
||||
}
|
||||
|
||||
function max (args) {
|
||||
args.forEach((el, idx, arr) => {
|
||||
arr[idx] = isNaN(el) ? -Infinity : el;
|
||||
});
|
||||
const max = Math.max.apply(Math, args);
|
||||
return max === -Infinity ? NaN : max;
|
||||
}
|
||||
|
||||
function argmax (args) {
|
||||
const val = max(args);
|
||||
return args.indexOf(val);
|
||||
}
|
||||
|
||||
export default function wf_align (s1, s2, penalties) {
|
||||
const n = s1.length;
|
||||
const m = s2.length;
|
||||
const A_k = m - n;
|
||||
const A_offset = m;
|
||||
let score = 0;
|
||||
const M = new WavefrontComponent();
|
||||
M.set_val(0, 0, 0);
|
||||
M.set_hi(0, 0);
|
||||
M.set_lo(0, 0);
|
||||
M.set_traceback(0, 0, traceback.End);
|
||||
const I = new WavefrontComponent();
|
||||
const D = new WavefrontComponent();
|
||||
while (true) {
|
||||
wf_extend(M, s1, n, s2, m, score);
|
||||
if (M.get_val(score, A_k) >= A_offset) {
|
||||
break;
|
||||
}
|
||||
score++;
|
||||
wf_next(M, I, D, score, penalties);
|
||||
}
|
||||
return wf_backtrace(M, I, D, score, penalties, A_k, A_offset);
|
||||
}
|
||||
|
||||
function wf_extend (M, s1, n, s2, m, score) {
|
||||
const lo = M.get_lo(score);
|
||||
const hi = M.get_hi(score);
|
||||
for (let k = lo; k <= hi; k++) {
|
||||
let v = M.get_val(score, k) - k;
|
||||
let h = M.get_val(score, k);
|
||||
if (isNaN(v) || isNaN(h)) {
|
||||
continue;
|
||||
}
|
||||
while (s1[v] === s2[h]) {
|
||||
M.set_val(score, k, M.get_val(score, k) + 1);
|
||||
v++;
|
||||
h++;
|
||||
if (v > n || h > m) {
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
function wf_next (M, I, D, score, penalties) {
|
||||
const x = penalties.x;
|
||||
const o = penalties.o;
|
||||
const e = penalties.e;
|
||||
const lo = min([M.get_lo(score - x), M.get_lo(score - o - e), I.get_lo(score - e), D.get_lo(score - e)]) - 1;
|
||||
const hi = max([M.get_hi(score - x), M.get_hi(score - o - e), I.get_hi(score - e), D.get_hi(score - e)]) + 1;
|
||||
M.set_hi(score, hi);
|
||||
I.set_hi(score, hi);
|
||||
D.set_hi(score, hi);
|
||||
M.set_lo(score, lo);
|
||||
I.set_lo(score, lo);
|
||||
D.set_lo(score, lo);
|
||||
for (let k = lo; k <= hi; k++) {
|
||||
I.set_val(score, k, max([
|
||||
M.get_val(score - o - e, k - 1),
|
||||
I.get_val(score - e, k - 1)
|
||||
]) + 1);
|
||||
I.set_traceback(score, k, [traceback.OpenIns, traceback.ExtdIns][argmax([
|
||||
M.get_val(score - o - e, k - 1),
|
||||
I.get_val(score - e, k - 1)
|
||||
])]);
|
||||
D.set_val(score, k, max([
|
||||
M.get_val(score - o - e, k + 1),
|
||||
D.get_val(score - e, k + 1)
|
||||
]));
|
||||
D.set_traceback(score, k, [traceback.OpenDel, traceback.ExtdDel][argmax([
|
||||
M.get_val(score - o - e, k + 1),
|
||||
D.get_val(score - e, k + 1)
|
||||
])]);
|
||||
M.set_val(score, k, max([
|
||||
M.get_val(score - x, k) + 1,
|
||||
I.get_val(score, k),
|
||||
D.get_val(score, k)
|
||||
]));
|
||||
M.set_traceback(score, k, [traceback.Sub, traceback.Ins, traceback.Del][argmax([
|
||||
M.get_val(score - x, k) + 1,
|
||||
I.get_val(score, k),
|
||||
D.get_val(score, k)
|
||||
])]);
|
||||
}
|
||||
}
|
||||
|
||||
function wf_backtrace (M, I, D, score, penalties, A_k) {
|
||||
const traceback_CIGAR = ["I", "I", "D", "D", "X", "", "", ""];
|
||||
const x = penalties.x;
|
||||
const o = penalties.o;
|
||||
const e = penalties.e;
|
||||
let CIGAR_rev = ""; // reversed CIGAR
|
||||
let tb_s = score; // traceback score
|
||||
let tb_k = A_k; // traceback diag k
|
||||
let current_traceback = M.get_traceback(tb_s, tb_k);
|
||||
let done = false;
|
||||
while (!done) {
|
||||
CIGAR_rev += traceback_CIGAR[current_traceback];
|
||||
switch (current_traceback) {
|
||||
case traceback.OpenIns:
|
||||
tb_s = tb_s - o - e;
|
||||
tb_k = tb_k - 1;
|
||||
current_traceback = M.get_traceback(tb_s, tb_k);
|
||||
break;
|
||||
case traceback.ExtdIns:
|
||||
tb_s = tb_s - e;
|
||||
tb_k = tb_k - 1;
|
||||
current_traceback = I.get_traceback(tb_s, tb_k);
|
||||
break;
|
||||
case traceback.OpenDel:
|
||||
tb_s = tb_s - o - e;
|
||||
tb_k = tb_k + 1;
|
||||
current_traceback = M.get_traceback(tb_s, tb_k);
|
||||
break;
|
||||
case traceback.ExtdDel:
|
||||
tb_s = tb_s - e;
|
||||
tb_k = tb_k + 1;
|
||||
current_traceback = D.get_traceback(tb_s, tb_k);
|
||||
break;
|
||||
case traceback.Sub:
|
||||
tb_s = tb_s - x;
|
||||
// tb_k = tb_k;
|
||||
current_traceback = M.get_traceback(tb_s, tb_k);
|
||||
break;
|
||||
case traceback.Ins:
|
||||
// tb_s = tb_s;
|
||||
// tb_k = tb_k;
|
||||
current_traceback = I.get_traceback(tb_s, tb_k);
|
||||
break;
|
||||
case traceback.Del:
|
||||
// tb_s = tb_s;
|
||||
// tb_k = tb_k;
|
||||
current_traceback = D.get_traceback(tb_s, tb_k);
|
||||
break;
|
||||
case traceback.End:
|
||||
done = true;
|
||||
break;
|
||||
}
|
||||
}
|
||||
const CIGAR = Array.from(CIGAR_rev).reverse().join("");
|
||||
return { CIGAR, score };
|
||||
}
|
||||
181
test/wfa_test.go
181
test/wfa_test.go
@ -1,181 +0,0 @@
|
||||
package tests
|
||||
|
||||
import (
|
||||
"bufio"
|
||||
"encoding/json"
|
||||
"log"
|
||||
"math/rand/v2"
|
||||
"os"
|
||||
"strconv"
|
||||
"strings"
|
||||
"testing"
|
||||
wfa "wfa/pkg"
|
||||
|
||||
"github.com/schollz/progressbar/v3"
|
||||
)
|
||||
|
||||
const testJsonPath = "tests.json"
|
||||
const testSequences = "sequences"
|
||||
|
||||
type TestPenalty struct {
|
||||
M int `json:"m"`
|
||||
X int `json:"x"`
|
||||
O int `json:"o"`
|
||||
E int `json:"e"`
|
||||
}
|
||||
|
||||
type TestCase struct {
|
||||
Penalties TestPenalty `json:"penalties"`
|
||||
Solutions string `json:"solutions"`
|
||||
}
|
||||
|
||||
func randRange(min, max int) uint32 {
|
||||
return uint32(rand.IntN(max-min) + min)
|
||||
}
|
||||
|
||||
func TestWavefrontPacking(t *testing.T) {
|
||||
for range 1000 {
|
||||
val := randRange(0, 1000)
|
||||
tb := wfa.Traceback(randRange(0, 7))
|
||||
v := wfa.PackWavefrontValue(val, tb)
|
||||
|
||||
valid, gotVal, gotTB := wfa.UnpackWavefrontValue(v)
|
||||
|
||||
if !valid || gotVal != val || gotTB != tb {
|
||||
t.Errorf(`test WavefrontPack/Unpack, val: %d, tb: %d, packedval: %x, gotok: %t, gotval: %d, gottb: %d\n`, val, tb, v, valid, gotVal, gotTB)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func GetScoreFromCIGAR(CIGAR string, penalties wfa.Penalty) int {
|
||||
unpackedCIGAR := wfa.RunLengthDecode(CIGAR)
|
||||
previousOp := '~'
|
||||
score := 0
|
||||
for _, Op := range unpackedCIGAR {
|
||||
if Op == 'M' {
|
||||
score = score + penalties.M
|
||||
} else if Op == 'X' {
|
||||
score = score + penalties.X
|
||||
} else if (Op == 'I' && previousOp != 'I') || (Op == 'D' && previousOp != 'D') {
|
||||
score = score + penalties.O + penalties.E
|
||||
} else if (Op == 'I' && previousOp == 'I') || (Op == 'D' && previousOp == 'D') {
|
||||
score = score + penalties.E
|
||||
}
|
||||
previousOp = Op
|
||||
}
|
||||
return score
|
||||
}
|
||||
|
||||
func CheckCIGARCorrectness(s1 string, s2 string, CIGAR string) bool {
|
||||
unpackedCIGAR := wfa.RunLengthDecode(CIGAR)
|
||||
i := 0
|
||||
j := 0
|
||||
|
||||
s1Aligned := strings.Builder{}
|
||||
alignment := strings.Builder{}
|
||||
s2Aligned := strings.Builder{}
|
||||
|
||||
for c := 0; c < len(unpackedCIGAR); c++ {
|
||||
Op := unpackedCIGAR[c]
|
||||
if Op == 'M' {
|
||||
s1Aligned.WriteByte(s1[i])
|
||||
alignment.WriteRune('|')
|
||||
s2Aligned.WriteByte(s2[j])
|
||||
i++
|
||||
j++
|
||||
} else if Op == 'X' {
|
||||
s1Aligned.WriteByte(s1[i])
|
||||
alignment.WriteRune(' ')
|
||||
s2Aligned.WriteByte(s2[j])
|
||||
i++
|
||||
j++
|
||||
} else if Op == 'I' {
|
||||
|
||||
s1Aligned.WriteRune('-')
|
||||
alignment.WriteRune(' ')
|
||||
s2Aligned.WriteByte(s2[j])
|
||||
|
||||
j++
|
||||
} else if Op == 'D' {
|
||||
s1Aligned.WriteByte(s1[i])
|
||||
alignment.WriteRune('|')
|
||||
s2Aligned.WriteRune('-')
|
||||
i++
|
||||
}
|
||||
}
|
||||
|
||||
if i == len(s1) && j == len(s2) {
|
||||
return true
|
||||
} else {
|
||||
log.Printf("\n%s\n%s\n%s\n i=%d, j=%d, |s1|=%d, |s2|=%d\n", s1Aligned.String(), alignment.String(), s2Aligned.String(), i, j, len(s1), len(s2))
|
||||
return false
|
||||
}
|
||||
}
|
||||
|
||||
func TestWFA(t *testing.T) {
|
||||
content, _ := os.ReadFile(testJsonPath)
|
||||
|
||||
var testMap map[string]TestCase
|
||||
json.Unmarshal(content, &testMap)
|
||||
|
||||
for k, v := range testMap {
|
||||
testName := k
|
||||
|
||||
testPenalties := wfa.Penalty{
|
||||
M: v.Penalties.M,
|
||||
X: v.Penalties.X,
|
||||
O: v.Penalties.O,
|
||||
E: v.Penalties.E,
|
||||
}
|
||||
|
||||
sequencesFile, _ := os.Open(testSequences)
|
||||
sequences := bufio.NewScanner(sequencesFile)
|
||||
solutionsFile, _ := os.Open(v.Solutions)
|
||||
solutions := bufio.NewScanner(solutionsFile)
|
||||
|
||||
bar := progressbar.Default(305, k)
|
||||
|
||||
idx := 0
|
||||
|
||||
for solutions.Scan() {
|
||||
solution := solutions.Text()
|
||||
|
||||
expectedScore, _ := strconv.Atoi(strings.Split(solution, "\t")[0])
|
||||
expectedCIGAR := strings.Split(solution, "\t")[1]
|
||||
|
||||
sequences.Scan()
|
||||
s1 := sequences.Text()
|
||||
s1 = s1[1:]
|
||||
|
||||
sequences.Scan()
|
||||
s2 := sequences.Text()
|
||||
s2 = s2[1:]
|
||||
|
||||
x := wfa.WFAlign(s1, s2, testPenalties, true)
|
||||
gotScore := x.Score
|
||||
gotCIGAR := x.CIGAR
|
||||
|
||||
if gotScore != -1*expectedScore {
|
||||
t.Errorf(`test: %s#%d, s1: %s, s2: %s, got: %d, expected: %d`, testName, idx, s1, s2, gotScore, expectedScore)
|
||||
os.Exit(1)
|
||||
}
|
||||
|
||||
if gotCIGAR != expectedCIGAR {
|
||||
checkScore := GetScoreFromCIGAR(gotCIGAR, testPenalties)
|
||||
CIGARCorrectness := CheckCIGARCorrectness(s1, s2, gotCIGAR)
|
||||
if checkScore != gotScore && checkScore != -1*expectedScore { // nonequivalent alignment
|
||||
t.Errorf(`test: %s#%d, s1: %s, s2: %s, got: [%s], expected: [%s]`, testName, idx, s1, s2, gotCIGAR, expectedCIGAR)
|
||||
t.Errorf(`test: %s#%d, recalculated score: %d`, testName, idx, checkScore)
|
||||
os.Exit(1)
|
||||
}
|
||||
if !CIGARCorrectness {
|
||||
t.Errorf(`test: %s#%d, s1: %s, s2: %s, got: [%s], expected: [%s]`, testName, idx, s1, s2, gotCIGAR, expectedCIGAR)
|
||||
os.Exit(1)
|
||||
}
|
||||
}
|
||||
|
||||
idx++
|
||||
bar.Add(1)
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -6,7 +6,7 @@
|
||||
"o": 2,
|
||||
"e": 1
|
||||
},
|
||||
"solutions": "test_affine_p0_sol"
|
||||
"solutions": "./tests/test_affine_p0_sol"
|
||||
},
|
||||
"p1": {
|
||||
"penalties": {
|
||||
@ -15,7 +15,7 @@
|
||||
"o": 1,
|
||||
"e": 4
|
||||
},
|
||||
"solutions": "test_affine_p1_sol"
|
||||
"solutions": "./tests/test_affine_p1_sol"
|
||||
},
|
||||
"p2": {
|
||||
"penalties": {
|
||||
@ -24,6 +24,6 @@
|
||||
"o": 3,
|
||||
"e": 2
|
||||
},
|
||||
"solutions": "test_affine_p2_sol"
|
||||
"solutions": "./tests/test_affine_p2_sol"
|
||||
}
|
||||
}
|
||||
560
wfa.js
560
wfa.js
@ -1,560 +0,0 @@
|
||||
// wasm_exec.js from tinygo
|
||||
|
||||
// Copyright 2018 The Go Authors. All rights reserved.
|
||||
// Use of this source code is governed by a BSD-style
|
||||
// license that can be found in the LICENSE file.
|
||||
//
|
||||
// This file has been modified for use by the TinyGo compiler.
|
||||
|
||||
(() => {
|
||||
// Map multiple JavaScript environments to a single common API,
|
||||
// preferring web standards over Node.js API.
|
||||
//
|
||||
// Environments considered:
|
||||
// - Browsers
|
||||
// - Node.js
|
||||
// - Electron
|
||||
// - Parcel
|
||||
|
||||
if (typeof global !== "undefined") {
|
||||
// global already exists
|
||||
} else if (typeof window !== "undefined") {
|
||||
window.global = window;
|
||||
} else if (typeof self !== "undefined") {
|
||||
self.global = self;
|
||||
} else {
|
||||
throw new Error("cannot export Go (neither global, window nor self is defined)");
|
||||
}
|
||||
|
||||
if (!global.require && typeof require !== "undefined") {
|
||||
global.require = require;
|
||||
}
|
||||
|
||||
if (!global.fs && global.require) {
|
||||
global.fs = require("node:fs");
|
||||
}
|
||||
|
||||
const enosys = () => {
|
||||
const err = new Error("not implemented");
|
||||
err.code = "ENOSYS";
|
||||
return err;
|
||||
};
|
||||
|
||||
if (!global.fs) {
|
||||
let outputBuf = "";
|
||||
global.fs = {
|
||||
constants: { O_WRONLY: -1, O_RDWR: -1, O_CREAT: -1, O_TRUNC: -1, O_APPEND: -1, O_EXCL: -1 }, // unused
|
||||
writeSync(fd, buf) {
|
||||
outputBuf += decoder.decode(buf);
|
||||
const nl = outputBuf.lastIndexOf("\n");
|
||||
if (nl != -1) {
|
||||
console.log(outputBuf.substr(0, nl));
|
||||
outputBuf = outputBuf.substr(nl + 1);
|
||||
}
|
||||
return buf.length;
|
||||
},
|
||||
write(fd, buf, offset, length, position, callback) {
|
||||
if (offset !== 0 || length !== buf.length || position !== null) {
|
||||
callback(enosys());
|
||||
return;
|
||||
}
|
||||
const n = this.writeSync(fd, buf);
|
||||
callback(null, n);
|
||||
},
|
||||
chmod(path, mode, callback) { callback(enosys()); },
|
||||
chown(path, uid, gid, callback) { callback(enosys()); },
|
||||
close(fd, callback) { callback(enosys()); },
|
||||
fchmod(fd, mode, callback) { callback(enosys()); },
|
||||
fchown(fd, uid, gid, callback) { callback(enosys()); },
|
||||
fstat(fd, callback) { callback(enosys()); },
|
||||
fsync(fd, callback) { callback(null); },
|
||||
ftruncate(fd, length, callback) { callback(enosys()); },
|
||||
lchown(path, uid, gid, callback) { callback(enosys()); },
|
||||
link(path, link, callback) { callback(enosys()); },
|
||||
lstat(path, callback) { callback(enosys()); },
|
||||
mkdir(path, perm, callback) { callback(enosys()); },
|
||||
open(path, flags, mode, callback) { callback(enosys()); },
|
||||
read(fd, buffer, offset, length, position, callback) { callback(enosys()); },
|
||||
readdir(path, callback) { callback(enosys()); },
|
||||
readlink(path, callback) { callback(enosys()); },
|
||||
rename(from, to, callback) { callback(enosys()); },
|
||||
rmdir(path, callback) { callback(enosys()); },
|
||||
stat(path, callback) { callback(enosys()); },
|
||||
symlink(path, link, callback) { callback(enosys()); },
|
||||
truncate(path, length, callback) { callback(enosys()); },
|
||||
unlink(path, callback) { callback(enosys()); },
|
||||
utimes(path, atime, mtime, callback) { callback(enosys()); },
|
||||
};
|
||||
}
|
||||
|
||||
if (!global.process) {
|
||||
global.process = {
|
||||
getuid() { return -1; },
|
||||
getgid() { return -1; },
|
||||
geteuid() { return -1; },
|
||||
getegid() { return -1; },
|
||||
getgroups() { throw enosys(); },
|
||||
pid: -1,
|
||||
ppid: -1,
|
||||
umask() { throw enosys(); },
|
||||
cwd() { throw enosys(); },
|
||||
chdir() { throw enosys(); },
|
||||
}
|
||||
}
|
||||
|
||||
if (!global.crypto) {
|
||||
const nodeCrypto = require("node:crypto");
|
||||
global.crypto = {
|
||||
getRandomValues(b) {
|
||||
nodeCrypto.randomFillSync(b);
|
||||
},
|
||||
};
|
||||
}
|
||||
|
||||
if (!global.performance) {
|
||||
global.performance = {
|
||||
now() {
|
||||
const [sec, nsec] = process.hrtime();
|
||||
return sec * 1000 + nsec / 1000000;
|
||||
},
|
||||
};
|
||||
}
|
||||
|
||||
if (!global.TextEncoder) {
|
||||
global.TextEncoder = require("node:util").TextEncoder;
|
||||
}
|
||||
|
||||
if (!global.TextDecoder) {
|
||||
global.TextDecoder = require("node:util").TextDecoder;
|
||||
}
|
||||
|
||||
// End of polyfills for common API.
|
||||
|
||||
const encoder = new TextEncoder("utf-8");
|
||||
const decoder = new TextDecoder("utf-8");
|
||||
let reinterpretBuf = new DataView(new ArrayBuffer(8));
|
||||
var logLine = [];
|
||||
|
||||
global.Go = class {
|
||||
constructor() {
|
||||
this._callbackTimeouts = new Map();
|
||||
this._nextCallbackTimeoutID = 1;
|
||||
|
||||
const mem = () => {
|
||||
// The buffer may change when requesting more memory.
|
||||
return new DataView(this._inst.exports.memory.buffer);
|
||||
}
|
||||
|
||||
const unboxValue = (v_ref) => {
|
||||
reinterpretBuf.setBigInt64(0, v_ref, true);
|
||||
const f = reinterpretBuf.getFloat64(0, true);
|
||||
if (f === 0) {
|
||||
return undefined;
|
||||
}
|
||||
if (!isNaN(f)) {
|
||||
return f;
|
||||
}
|
||||
|
||||
const id = v_ref & 0xffffffffn;
|
||||
return this._values[id];
|
||||
}
|
||||
|
||||
|
||||
const loadValue = (addr) => {
|
||||
let v_ref = mem().getBigUint64(addr, true);
|
||||
return unboxValue(v_ref);
|
||||
}
|
||||
|
||||
const boxValue = (v) => {
|
||||
const nanHead = 0x7FF80000n;
|
||||
|
||||
if (typeof v === "number") {
|
||||
if (isNaN(v)) {
|
||||
return nanHead << 32n;
|
||||
}
|
||||
if (v === 0) {
|
||||
return (nanHead << 32n) | 1n;
|
||||
}
|
||||
reinterpretBuf.setFloat64(0, v, true);
|
||||
return reinterpretBuf.getBigInt64(0, true);
|
||||
}
|
||||
|
||||
switch (v) {
|
||||
case undefined:
|
||||
return 0n;
|
||||
case null:
|
||||
return (nanHead << 32n) | 2n;
|
||||
case true:
|
||||
return (nanHead << 32n) | 3n;
|
||||
case false:
|
||||
return (nanHead << 32n) | 4n;
|
||||
}
|
||||
|
||||
let id = this._ids.get(v);
|
||||
if (id === undefined) {
|
||||
id = this._idPool.pop();
|
||||
if (id === undefined) {
|
||||
id = BigInt(this._values.length);
|
||||
}
|
||||
this._values[id] = v;
|
||||
this._goRefCounts[id] = 0;
|
||||
this._ids.set(v, id);
|
||||
}
|
||||
this._goRefCounts[id]++;
|
||||
let typeFlag = 1n;
|
||||
switch (typeof v) {
|
||||
case "string":
|
||||
typeFlag = 2n;
|
||||
break;
|
||||
case "symbol":
|
||||
typeFlag = 3n;
|
||||
break;
|
||||
case "function":
|
||||
typeFlag = 4n;
|
||||
break;
|
||||
}
|
||||
return id | ((nanHead | typeFlag) << 32n);
|
||||
}
|
||||
|
||||
const storeValue = (addr, v) => {
|
||||
let v_ref = boxValue(v);
|
||||
mem().setBigUint64(addr, v_ref, true);
|
||||
}
|
||||
|
||||
const loadSlice = (array, len, cap) => {
|
||||
return new Uint8Array(this._inst.exports.memory.buffer, array, len);
|
||||
}
|
||||
|
||||
const loadSliceOfValues = (array, len, cap) => {
|
||||
const a = new Array(len);
|
||||
for (let i = 0; i < len; i++) {
|
||||
a[i] = loadValue(array + i * 8);
|
||||
}
|
||||
return a;
|
||||
}
|
||||
|
||||
const loadString = (ptr, len) => {
|
||||
return decoder.decode(new DataView(this._inst.exports.memory.buffer, ptr, len));
|
||||
}
|
||||
|
||||
const timeOrigin = Date.now() - performance.now();
|
||||
this.importObject = {
|
||||
wasi_snapshot_preview1: {
|
||||
// https://github.com/WebAssembly/WASI/blob/main/phases/snapshot/docs.md#fd_write
|
||||
fd_write: function(fd, iovs_ptr, iovs_len, nwritten_ptr) {
|
||||
let nwritten = 0;
|
||||
if (fd == 1) {
|
||||
for (let iovs_i=0; iovs_i<iovs_len;iovs_i++) {
|
||||
let iov_ptr = iovs_ptr+iovs_i*8; // assuming wasm32
|
||||
let ptr = mem().getUint32(iov_ptr + 0, true);
|
||||
let len = mem().getUint32(iov_ptr + 4, true);
|
||||
nwritten += len;
|
||||
for (let i=0; i<len; i++) {
|
||||
let c = mem().getUint8(ptr+i);
|
||||
if (c == 13) { // CR
|
||||
// ignore
|
||||
} else if (c == 10) { // LF
|
||||
// write line
|
||||
let line = decoder.decode(new Uint8Array(logLine));
|
||||
logLine = [];
|
||||
console.log(line);
|
||||
} else {
|
||||
logLine.push(c);
|
||||
}
|
||||
}
|
||||
}
|
||||
} else {
|
||||
console.error('invalid file descriptor:', fd);
|
||||
}
|
||||
mem().setUint32(nwritten_ptr, nwritten, true);
|
||||
return 0;
|
||||
},
|
||||
fd_close: () => 0, // dummy
|
||||
fd_fdstat_get: () => 0, // dummy
|
||||
fd_seek: () => 0, // dummy
|
||||
"proc_exit": (code) => {
|
||||
if (global.process) {
|
||||
// Node.js
|
||||
process.exit(code);
|
||||
} else {
|
||||
// Can't exit in a browser.
|
||||
throw 'trying to exit with code ' + code;
|
||||
}
|
||||
},
|
||||
random_get: (bufPtr, bufLen) => {
|
||||
crypto.getRandomValues(loadSlice(bufPtr, bufLen));
|
||||
return 0;
|
||||
},
|
||||
},
|
||||
gojs: {
|
||||
// func ticks() float64
|
||||
"runtime.ticks": () => {
|
||||
return timeOrigin + performance.now();
|
||||
},
|
||||
|
||||
// func sleepTicks(timeout float64)
|
||||
"runtime.sleepTicks": (timeout) => {
|
||||
// Do not sleep, only reactivate scheduler after the given timeout.
|
||||
setTimeout(this._inst.exports.go_scheduler, timeout);
|
||||
},
|
||||
|
||||
// func finalizeRef(v ref)
|
||||
"syscall/js.finalizeRef": (v_ref) => {
|
||||
const id = mem().getUint32(unboxValue(v_ref), true);
|
||||
this._goRefCounts[id]--;
|
||||
if (this._goRefCounts[id] === 0) {
|
||||
const v = this._values[id];
|
||||
this._values[id] = null;
|
||||
this._ids.delete(v);
|
||||
this._idPool.push(id);
|
||||
}
|
||||
},
|
||||
|
||||
// func stringVal(value string) ref
|
||||
"syscall/js.stringVal": (value_ptr, value_len) => {
|
||||
const s = loadString(value_ptr, value_len);
|
||||
return boxValue(s);
|
||||
},
|
||||
|
||||
// func valueGet(v ref, p string) ref
|
||||
"syscall/js.valueGet": (v_ref, p_ptr, p_len) => {
|
||||
let prop = loadString(p_ptr, p_len);
|
||||
let v = unboxValue(v_ref);
|
||||
let result = Reflect.get(v, prop);
|
||||
return boxValue(result);
|
||||
},
|
||||
|
||||
// func valueSet(v ref, p string, x ref)
|
||||
"syscall/js.valueSet": (v_ref, p_ptr, p_len, x_ref) => {
|
||||
const v = unboxValue(v_ref);
|
||||
const p = loadString(p_ptr, p_len);
|
||||
const x = unboxValue(x_ref);
|
||||
Reflect.set(v, p, x);
|
||||
},
|
||||
|
||||
// func valueDelete(v ref, p string)
|
||||
"syscall/js.valueDelete": (v_ref, p_ptr, p_len) => {
|
||||
const v = unboxValue(v_ref);
|
||||
const p = loadString(p_ptr, p_len);
|
||||
Reflect.deleteProperty(v, p);
|
||||
},
|
||||
|
||||
// func valueIndex(v ref, i int) ref
|
||||
"syscall/js.valueIndex": (v_ref, i) => {
|
||||
return boxValue(Reflect.get(unboxValue(v_ref), i));
|
||||
},
|
||||
|
||||
// valueSetIndex(v ref, i int, x ref)
|
||||
"syscall/js.valueSetIndex": (v_ref, i, x_ref) => {
|
||||
Reflect.set(unboxValue(v_ref), i, unboxValue(x_ref));
|
||||
},
|
||||
|
||||
// func valueCall(v ref, m string, args []ref) (ref, bool)
|
||||
"syscall/js.valueCall": (ret_addr, v_ref, m_ptr, m_len, args_ptr, args_len, args_cap) => {
|
||||
const v = unboxValue(v_ref);
|
||||
const name = loadString(m_ptr, m_len);
|
||||
const args = loadSliceOfValues(args_ptr, args_len, args_cap);
|
||||
try {
|
||||
const m = Reflect.get(v, name);
|
||||
storeValue(ret_addr, Reflect.apply(m, v, args));
|
||||
mem().setUint8(ret_addr + 8, 1);
|
||||
} catch (err) {
|
||||
storeValue(ret_addr, err);
|
||||
mem().setUint8(ret_addr + 8, 0);
|
||||
}
|
||||
},
|
||||
|
||||
// func valueInvoke(v ref, args []ref) (ref, bool)
|
||||
"syscall/js.valueInvoke": (ret_addr, v_ref, args_ptr, args_len, args_cap) => {
|
||||
try {
|
||||
const v = unboxValue(v_ref);
|
||||
const args = loadSliceOfValues(args_ptr, args_len, args_cap);
|
||||
storeValue(ret_addr, Reflect.apply(v, undefined, args));
|
||||
mem().setUint8(ret_addr + 8, 1);
|
||||
} catch (err) {
|
||||
storeValue(ret_addr, err);
|
||||
mem().setUint8(ret_addr + 8, 0);
|
||||
}
|
||||
},
|
||||
|
||||
// func valueNew(v ref, args []ref) (ref, bool)
|
||||
"syscall/js.valueNew": (ret_addr, v_ref, args_ptr, args_len, args_cap) => {
|
||||
const v = unboxValue(v_ref);
|
||||
const args = loadSliceOfValues(args_ptr, args_len, args_cap);
|
||||
try {
|
||||
storeValue(ret_addr, Reflect.construct(v, args));
|
||||
mem().setUint8(ret_addr + 8, 1);
|
||||
} catch (err) {
|
||||
storeValue(ret_addr, err);
|
||||
mem().setUint8(ret_addr+ 8, 0);
|
||||
}
|
||||
},
|
||||
|
||||
// func valueLength(v ref) int
|
||||
"syscall/js.valueLength": (v_ref) => {
|
||||
return unboxValue(v_ref).length;
|
||||
},
|
||||
|
||||
// valuePrepareString(v ref) (ref, int)
|
||||
"syscall/js.valuePrepareString": (ret_addr, v_ref) => {
|
||||
const s = String(unboxValue(v_ref));
|
||||
const str = encoder.encode(s);
|
||||
storeValue(ret_addr, str);
|
||||
mem().setInt32(ret_addr + 8, str.length, true);
|
||||
},
|
||||
|
||||
// valueLoadString(v ref, b []byte)
|
||||
"syscall/js.valueLoadString": (v_ref, slice_ptr, slice_len, slice_cap) => {
|
||||
const str = unboxValue(v_ref);
|
||||
loadSlice(slice_ptr, slice_len, slice_cap).set(str);
|
||||
},
|
||||
|
||||
// func valueInstanceOf(v ref, t ref) bool
|
||||
"syscall/js.valueInstanceOf": (v_ref, t_ref) => {
|
||||
return unboxValue(v_ref) instanceof unboxValue(t_ref);
|
||||
},
|
||||
|
||||
// func copyBytesToGo(dst []byte, src ref) (int, bool)
|
||||
"syscall/js.copyBytesToGo": (ret_addr, dest_addr, dest_len, dest_cap, src_ref) => {
|
||||
let num_bytes_copied_addr = ret_addr;
|
||||
let returned_status_addr = ret_addr + 4; // Address of returned boolean status variable
|
||||
|
||||
const dst = loadSlice(dest_addr, dest_len);
|
||||
const src = unboxValue(src_ref);
|
||||
if (!(src instanceof Uint8Array || src instanceof Uint8ClampedArray)) {
|
||||
mem().setUint8(returned_status_addr, 0); // Return "not ok" status
|
||||
return;
|
||||
}
|
||||
const toCopy = src.subarray(0, dst.length);
|
||||
dst.set(toCopy);
|
||||
mem().setUint32(num_bytes_copied_addr, toCopy.length, true);
|
||||
mem().setUint8(returned_status_addr, 1); // Return "ok" status
|
||||
},
|
||||
|
||||
// copyBytesToJS(dst ref, src []byte) (int, bool)
|
||||
// Originally copied from upstream Go project, then modified:
|
||||
// https://github.com/golang/go/blob/3f995c3f3b43033013013e6c7ccc93a9b1411ca9/misc/wasm/wasm_exec.js#L404-L416
|
||||
"syscall/js.copyBytesToJS": (ret_addr, dst_ref, src_addr, src_len, src_cap) => {
|
||||
let num_bytes_copied_addr = ret_addr;
|
||||
let returned_status_addr = ret_addr + 4; // Address of returned boolean status variable
|
||||
|
||||
const dst = unboxValue(dst_ref);
|
||||
const src = loadSlice(src_addr, src_len);
|
||||
if (!(dst instanceof Uint8Array || dst instanceof Uint8ClampedArray)) {
|
||||
mem().setUint8(returned_status_addr, 0); // Return "not ok" status
|
||||
return;
|
||||
}
|
||||
const toCopy = src.subarray(0, dst.length);
|
||||
dst.set(toCopy);
|
||||
mem().setUint32(num_bytes_copied_addr, toCopy.length, true);
|
||||
mem().setUint8(returned_status_addr, 1); // Return "ok" status
|
||||
},
|
||||
}
|
||||
};
|
||||
|
||||
// Go 1.20 uses 'env'. Go 1.21 uses 'gojs'.
|
||||
// For compatibility, we use both as long as Go 1.20 is supported.
|
||||
this.importObject.env = this.importObject.gojs;
|
||||
}
|
||||
|
||||
async run(instance) {
|
||||
this._inst = instance;
|
||||
this._values = [ // JS values that Go currently has references to, indexed by reference id
|
||||
NaN,
|
||||
0,
|
||||
null,
|
||||
true,
|
||||
false,
|
||||
global,
|
||||
this,
|
||||
];
|
||||
this._goRefCounts = []; // number of references that Go has to a JS value, indexed by reference id
|
||||
this._ids = new Map(); // mapping from JS values to reference ids
|
||||
this._idPool = []; // unused ids that have been garbage collected
|
||||
this.exited = false; // whether the Go program has exited
|
||||
|
||||
while (true) {
|
||||
const callbackPromise = new Promise((resolve) => {
|
||||
this._resolveCallbackPromise = () => {
|
||||
if (this.exited) {
|
||||
throw new Error("bad callback: Go program has already exited");
|
||||
}
|
||||
setTimeout(resolve, 0); // make sure it is asynchronous
|
||||
};
|
||||
});
|
||||
this._inst.exports._start();
|
||||
if (this.exited) {
|
||||
break;
|
||||
}
|
||||
await callbackPromise;
|
||||
}
|
||||
}
|
||||
|
||||
_resume() {
|
||||
if (this.exited) {
|
||||
throw new Error("Go program has already exited");
|
||||
}
|
||||
this._inst.exports.resume();
|
||||
if (this.exited) {
|
||||
this._resolveExitPromise();
|
||||
}
|
||||
}
|
||||
|
||||
_makeFuncWrapper(id) {
|
||||
const go = this;
|
||||
return function () {
|
||||
const event = { id: id, this: this, args: arguments };
|
||||
go._pendingEvent = event;
|
||||
go._resume();
|
||||
return event.result;
|
||||
};
|
||||
}
|
||||
}
|
||||
|
||||
if (
|
||||
global.require &&
|
||||
global.require.main === module &&
|
||||
global.process &&
|
||||
global.process.versions &&
|
||||
!global.process.versions.electron
|
||||
) {
|
||||
if (process.argv.length != 3) {
|
||||
console.error("usage: go_js_wasm_exec [wasm binary] [arguments]");
|
||||
process.exit(1);
|
||||
}
|
||||
|
||||
const go = new Go();
|
||||
WebAssembly.instantiate(fs.readFileSync(process.argv[2]), go.importObject).then((result) => {
|
||||
return go.run(result.instance);
|
||||
}).catch((err) => {
|
||||
console.error(err);
|
||||
process.exit(1);
|
||||
});
|
||||
}
|
||||
})();
|
||||
|
||||
// wasm setup code
|
||||
export default function init (path) {
|
||||
return new Promise ((res) => {
|
||||
const go = new Go();
|
||||
var wasm;
|
||||
|
||||
if ('instantiateStreaming' in WebAssembly) {
|
||||
WebAssembly.instantiateStreaming(fetch(path), go.importObject).then(function (obj) {
|
||||
wasm = obj.instance;
|
||||
go.run(wasm);
|
||||
res()
|
||||
})
|
||||
} else {
|
||||
fetch(path).then(resp =>
|
||||
resp.arrayBuffer()
|
||||
).then(bytes =>
|
||||
WebAssembly.instantiate(bytes, go.importObject).then(function (obj) {
|
||||
wasm = obj.instance;
|
||||
go.run(wasm);
|
||||
res()
|
||||
})
|
||||
)
|
||||
}
|
||||
})
|
||||
}
|
||||
Loading…
Reference in New Issue
Block a user