simple example for gonum matrix operation.

mat64.eigen.example.go

package main

import "github.com/gonum/matrix/mat64"

func main() {
        a := mat64.NewDense(2, 2, []float64{7.0, 0.5, 0.5, 1.0})
        println("S=")
        printm(a)
        println("Trace S=", a.Trace())
        printm(a)
        a1 := mat64.NewDense(2, 2, nil)
        a1.Clone(a)
        eigen := mat64.Eigen(a, 1e-07)
        println("after eigen")
        printm(a)
        printm(a1)
        println("EigenFactors=")
        printm(eigen.V)
        println("EigenValues=")
        printm(eigen.D())
        println("Trace EigenValues=", eigen.D().Trace())
        println("S multi EigenFactors")
        b := mat64.NewDense(2, 2, nil)
        //b.MulTrans(a, false, eigen.V, true)
        b.Mul(a1, eigen.V)
        printm(b)
        println("EigenValues multi EigenFactors=")
        b.Mul(eigen.D(), eigen.V)
        printm(b)
}
func printm(m *mat64.Dense) {
        r, c := m.Dims()
        for i := 0; i < r; i++ {
                for j := 0; j < c; j++ {
                        print(m.At(i, j), "\t")
                }
                println("")
        }
}
~

matrix.example.go

package main

import "github.com/skelterjohn/go.matrix"

func main() {
        a := matrix.MakeDenseMatrix([]float64{7.0, 0.5, 0.5, 1.0}, 2, 2)
        println("S=")
        printm(a)
        println("Trace S=", a.Trace())
        V, D, _ := a.Eigen()
        printm(a)
        printm(V)
        printm(D)
        println("Trace D=", D.Trace())
        C, _ := V.Times(D)
        C2, _ := a.Times(V)
        println(C, C2)
        printm(C.DenseMatrix())
        printm(C2.DenseMatrix())

}
func printm(m *matrix.DenseMatrix) {
        r := m.Rows()
        c := m.Cols()
        println(r)
        for i := 0; i < r; i++ {
                for j := 0; j < c; j++ {
                        a := m.Get(i, j)
                        print(a, " ")
                }
                println()
        }
}

pcc.go

package main

import "github.com/gonum/matrix/mat64"
import "errors"
import "github.com/gonum/floats"

func cov(data ...[]float64) (*mat64.Dense, error) {
	nSets := len(data)
	if nSets == 0 {
		return mat64.NewDense(0, 0, nil), nil
	}
	nData := len(data[0])
	for i := range data {
		if len(data[i]) != nData {
			return nil, errors.New("cov: datasets have unequal size")
		}
	}
	covmat := mat64.NewDense(nSets, nSets, nil)
	means := make([]float64, nSets)
	for i := range means {
		means[i] = floats.Sum(data[i]) / float64(nData)
	}
	for i := 0; i < nSets; i++ {
		for j := i; j < nSets; j++ {
			var cv float64
			meanI := means[i]
			meanJ := means[j]
			invData := 1 / float64(nData-1)
			for k, val := range data[i] {
				cv += invData * (val - meanI) * (data[j][k] - meanJ)
			}
			covmat.Set(i, j, cv)
			covmat.Set(j, i, cv)
		}
	}
	return covmat, nil
}

func main() {
	m1 := []float64{1.0, 2.0, 3.0, 4.0}
	m2 := []float64{2.0, 3.0, 1.0, 0.0}
	a, _ := cov(m1, m2)
	println("S=")
	printm(a)
	println("Trace S =", a.Trace())
	a1 := mat64.NewDense(2, 2, nil)
	a1.Clone(a)
	eigen := mat64.Eigen(a, 1e-07) // a value change to eigen.V
	println("EigenFactors =")
	printm(eigen.V)
	println("\nS variable changed to EigenFactors")
	printm(a)
	println("EigenValues =")
	printm(eigen.D())
	println("Trace EigenValues =", eigen.D().Trace())
	println("Original S multi EigenFactors =")
	b := mat64.NewDense(2, 2, nil)
	//b.MulTrans(a, false, eigen.V, true)
	b.Mul(a1, eigen.V)
	printm(b)
	println("EigenValues multi EigenFactors =")
	b.Mul(eigen.D(), eigen.V)
	printm(b)

}
func printm(m *mat64.Dense) {
	r, c := m.Dims()
	for i := 0; i < r; i++ {
		for j := 0; j < c; j++ {
			print(m.At(i, j), "\t")
		}
		println("")
	}
	println("")
}

REAME.md

pcc function from https://github.com/chenhao392/go/blob/master/pcc.go

test some operation in github.com/gonum/matrix/mat64