Pasted

package vector
 
import (
    "sync"
)
 
type IVector interface {
    Len() int
    GetAt(int) float64
    SetAt(int, float64)
}
 
type Vector struct {
    sync.RWMutex
    vec []float64
}
 
func New(args ...float64) IVector {
    v := new(Vector)
    v.vec = make([]float64, len(args))
 
    for i, e := range args {
        v.SetAt(i, e)
 
    }
 
    return v
}
 
// The length of the vector
func (v *Vector) Len() int {
    return len(v.vec)
}
 
// Getter
func (v *Vector) GetAt(i int) float64 {
    if i < 0 || i >= v.Len() {
        panic("Index out of range")
    }
 
    return v.vec[i]
}
 
// Setter
func (v *Vector) SetAt(i int, data float64) {
    if i < 0 || i >= v.Len() {
        panic("Index out of range")
    }
 
    v.Lock()
    v.vec[i] = data
    v.Unlock()
}
 
/ Vector algebra delegating to function object.
// This method delegates vector algebra to function object set by users, making
// it faster then these methods relying on reflection.
func Apply(v1 IVector, v2 IVector, f func(float64, float64) float64) IVector {
    _len := v1.Len()
 
    if !(_len == v2.Len()) {
        panic("Unequal vector size")
    }
 
    out := WithSize(_len)
 
    var wg sync.WaitGroup
 
    for i := 0; i < _len; i++ {
        wg.Add(1)
 
        go func(v1 IVector, v2 IVector, out IVector, f func(float64, float64) float64, i int) {
            defer wg.Done()
 
            out.SetAt(i, f(v1.GetAt(i), v2.GetAt(i)))
        }(v1, v2, out, f, i)
    }
 
    wg.Wait()
 
    return out
}