Go语言 随机向量与向量运算

随机U（0，1）均匀分布数组

func uniforms(dim int) []float64 {
    var vector []float64
    for i := 0; i < dim; i++ {
        vector = append(vector, rand.Float64())
    }
    return vector
}

 

随机整数数组

func randInt(dim, n int) []int {
    var vector []int
    for i := 0; i < dim; i++ {
        vector = append(vector, rand.Intn(n))
    }
    return vector
}

实例：

func printSliseInt(array []int) {
    for i := 0; i < len(array); i++ {
        fmt.Print(array[i], " ")
    }
    fmt.Println()
}
func main() {
    var arr0 = uniforms(6)
    var arr1 = randInt(8, 2)
    var arr2 = randInt(8, 10)
    var arr3 = randInt(8, 2)
    var arr4 = randInt(8, 2)
    var arr5 = randInt(8, 2)
    printSlise(arr0)
    printSliseInt(arr1)
    printSliseInt(arr2)
    printSliseInt(arr3)
    printSliseInt(arr4)
    printSliseInt(arr5)
    fmt.Println("---end---")
}

结果如下：

结果：

0.6046602879796196 0.9405090880450124 0.6645600532184904 0.4377141871869802 0.4246374970712657 0.6868230728671094

1 0 0 0 0 1 0 1

8 4 1 5 7 6 5 6

0 0 1 1 1 0 0 1

1 0 1 1 1 0 1 1

1 0 1 0 0 1 1 1

---end---

　　需要注意的是，无论重复运行多少次，结果都一模一样，因为随机种子恒定，但是多次调用是不一样的，因此大可放心地在算法中用，虽然多次运行结果复现，但是多次迭代中不复现。　

　　根据这个操作，创建很常用的zeros和ones就轻而易举了

func zeros(dim int) []float64 {
    var vector []float64
    for i := 0; i < dim; i++ {
        vector = append(vector, float64(0))
    }
    return vector
}

func ones(dim int) []float64 {
    var vector []float64
    for i := 0; i < dim; i++ {
        vector = append(vector, float64(1))
    }
    return vector
}
func main() {
    printSlise(zeros(5))
    printSlise(ones(6))
    fmt.Println("---end---")
}

结果：

0 0 0 0 0

1 1 1 1 1 1

---end---

 

　　向量的运算有常数和向量逐元素相加减乘，向量和向量逐元素相加减乘，向量和向量内积

常数和向量运算：

func scalaAdd(v []float64, a float64) []float64 {
    var res []float64
    var n int = len(v)
    for i := 0; i < n; i++ {
        res = append(res, a+v[i])
    }
    return res
}

func scalaSubtract(v []float64, a float64) []float64 {
    var res []float64
    var n int = len(v)
    for i := 0; i < n; i++ {
        res = append(res, v[i]-a)
    }
    return res
}

func scalaMulti(v []float64, a float64) []float64 {
    var res []float64
    var n int = len(v)
    for i := 0; i < n; i++ {
        res = append(res, a*v[i])
    }
    return res
}
func main() {
    var arr = []float64{4, 5, 7, 8, 2, 1}
    var arr1 = scalaAdd(arr, 10)
    arr2 := scalaSubtract(arr, 2)
    arr3 := scalaMulti(arr, 10)
    printSlise(arr)
    printSlise(arr1)
    printSlise(arr2)
    printSlise(arr3)
    fmt.Println("---end---")
}

结果如下：

4 5 7 8 2 1

14 15 17 18 12 11

2 3 5 6 0 -1

40 50 70 80 20 10

 

向量和向量逐元素运算：

func add(v1 []float64, v2 []float64) []float64 {
    var res []float64
    var n int = len(v2)
    for i := 0; i < n; i++ {
        res = append(res, v1[i]+v2[i])
    }
    return res
}

func subtract(v1 []float64, v2 []float64) []float64 {
    var res []float64
    var n int = len(v2)
    for i := 0; i < n; i++ {
        res = append(res, v1[i]-v2[i])
    }
    // fmt.Println(res)
    return res
}

func multiply(v1 []float64, v2 []float64) []float64 {
    var res []float64
    var n int = len(v2)
    for i := 0; i < n; i++ {
        res = append(res, v1[i]*v2[i])
    }
    return res
}
func main() {
    var arr0 = []float64{4, 5, 7, 8, 2, 1}
    var arr1 = scalaAdd(arr0, 10)
    var arr2 = add(arr1, arr0)
    var arr3 = subtract(arr1, arr0)
    arr4 := multiply(arr1, arr0)
    printSlise(arr0)
    printSlise(arr1)
    fmt.Println()
    printSlise(arr2)
    printSlise(arr3)
    printSlise(arr4)
    fmt.Println("---end---")
}

结果：

4 5 7 8 2 1

14 15 17 18 12 11

 

18 20 24 26 14 12

10 10 10 10 10 10

56 75 119 144 24 11

 

向量内积：

func innerMulti(v1 []float64, v2 []float64) float64 {
    var res float64
    var n int = len(v1)
    for i := 0; i < n; i++ {
        res += v1[i] * v2[i]
    }
    return res
}
func main() {
    var arr0 = []float64{1, 2, 3, 4, 5}
    var arr1 = scalaAdd(arr0, 0)
    var arr2 = innerMulti(arr0, arr1)
    fmt.Println(arr2)
    fmt.Println("---end---")
}

结果：

55