go语言float64相加

可以直接使用"+"运算符进行相加，例如：

var x float64 = 2.5
var y float64 = 3.7
sum := x + y
fmt.Println(sum) // 输出：6.2

请注意，float类型相加时可能会出现精度误差，建议使用math包中的函数进行精确计算。

相关问题

用go语言写一个词向量

词向量是一种将单词映射到向量空间中的技术，它可以用于自然语言处理中的诸多任务，例如文本分类、机器翻译等。在Go语言中，我们可以使用Gonum库来实现词向量。

首先，我们需要定义一个词向量类型：

type WordVector struct {
    Words []string
    Vectors [][]float64
}

其中，`Words`表示词汇表，`Vectors`表示单词对应的向量。

接下来，我们可以使用Gonum的矩阵运算函数来实现训练词向量模型。下面是一个简单的例子：

import (
    "fmt"
    "github.com/gonum/matrix/mat64"
)

func TrainWordVector(corpus [][]string, dim int) *WordVector {
    // 构建词汇表
    words := make([]string, 0)
    for _, doc := range corpus {
        for _, word := range doc {
            if !contains(words, word) {
                words = append(words, word)
            }
        }
    }

    // 初始化词向量矩阵
    V := mat64.NewDense(len(words), dim, nil)
    for i := 0; i < V.RawMatrix().Rows; i++ {
        for j := 0; j < V.RawMatrix().Cols; j++ {
            V.Set(i, j, rand.Float64())
        }
    }

    // 训练词向量模型
    for _, doc := range corpus {
        for i, word := range doc {
            // 获取当前单词的词向量
            x := V.RowVec(wordIndex(words, word))

            // 计算上下文单词的加权平均向量
            var context mat64.Vector
            for j := i-2; j <= i+2; j++ {
                if j >= 0 && j < len(doc) && j != i {
                    context.AddVec(context, V.RowVec(wordIndex(words, doc[j])))
                }
            }
            context.ScaleVec(1.0/3.0, &context)

            // 更新当前单词的词向量
            x.AddScaledVec(x, 0.01, &context)
            V.SetRow(wordIndex(words, word), x.RawVector().Data)
        }
    }

    return &WordVector{Words: words, Vectors: V.RawMatrix().Data}
}

// 判断一个字符串是否在一个字符串切片中
func contains(arr []string, str string) bool {
    for _, a := range arr {
        if a == str {
            return true
        }
    }
    return false
}

// 获取一个单词在词汇表中的索引
func wordIndex(words []string, word string) int {
    for i, w := range words {
        if w == word {
            return i
        }
    }
    return -1
}

在上面的代码中，我们首先构建了词汇表 `words`，然后初始化了词向量矩阵 `V`。接着，我们遍历语料库 `corpus`，对每个单词进行更新。具体地，我们先获取当前单词的词向量 `x`，然后计算上下文单词的加权平均向量 `context`，并将其与当前单词的词向量相加，最后更新当前单词的词向量。这个过程可以反复迭代多次，以得到更好的词向量模型。

最后，我们可以使用训练好的模型来获取单词的词向量：

func (wv *WordVector) GetVector(word string) []float64 {
    index := wordIndex(wv.Words, word)
    if index == -1 {
        return nil
    }
    return wv.Vectors[index]
}

这个函数可以返回一个单词的词向量，如果该单词不在词汇表中，则返回 `nil`。

当然，上面的实现仅是一个简单的例子，实际应用中可能需要更复杂的模型和更大规模的语料库。但是，通过这个例子，我们可以看到如何使用Gonum库来实现词向量。