updates
This commit is contained in:
Will Charczuk
parent
e53554fb04
commit
88499d5576
4 changed files with 443 additions and 8 deletions
|
|
@ -9,7 +9,7 @@ type LinearRegressionSeries struct {
|
|||
Style Style
|
||||
YAxis YAxisType
|
||||
|
||||
Window int
|
||||
Limit int
|
||||
Offset int
|
||||
InnerSeries ValueProvider
|
||||
|
||||
|
|
@ -36,18 +36,18 @@ func (lrs LinearRegressionSeries) GetYAxis() YAxisType {
|
|||
|
||||
// Len returns the number of elements in the series.
|
||||
func (lrs LinearRegressionSeries) Len() int {
|
||||
return Math.MinInt(lrs.GetWindow(), lrs.InnerSeries.Len()-lrs.GetOffset())
|
||||
return Math.MinInt(lrs.GetLimit(), lrs.InnerSeries.Len()-lrs.GetOffset())
|
||||
}
|
||||
|
||||
// GetWindow returns the window size.
|
||||
func (lrs LinearRegressionSeries) GetWindow() int {
|
||||
if lrs.Window == 0 {
|
||||
// GetLimit returns the window size.
|
||||
func (lrs LinearRegressionSeries) GetLimit() int {
|
||||
if lrs.Limit == 0 {
|
||||
return lrs.InnerSeries.Len()
|
||||
}
|
||||
return lrs.Window
|
||||
return lrs.Limit
|
||||
}
|
||||
|
||||
// GetEndIndex returns the effective window end.
|
||||
// GetEndIndex returns the effective limit end.
|
||||
func (lrs LinearRegressionSeries) GetEndIndex() int {
|
||||
offset := lrs.GetOffset() + lrs.Len()
|
||||
innerSeriesLastIndex := lrs.InnerSeries.Len() - 1
|
||||
|
|
@ -105,7 +105,6 @@ func (lrs *LinearRegressionSeries) computeCoefficients() {
|
|||
|
||||
xvalues := NewRingBufferWithCapacity(lrs.Len())
|
||||
for index := startIndex; index < endIndex; index++ {
|
||||
|
||||
x, _ := lrs.InnerSeries.GetValue(index)
|
||||
xvalues.Enqueue(x)
|
||||
}
|
||||
|
|
|
|||
319
matrix/matrix.go
Normal file
319
matrix/matrix.go
Normal file
|
|
@ -0,0 +1,319 @@
|
|||
package matrix
|
||||
|
||||
import (
|
||||
"bytes"
|
||||
"errors"
|
||||
"fmt"
|
||||
"math"
|
||||
)
|
||||
|
||||
const (
|
||||
// DefaultEpsilon represents the minimum precision for matrix math operations.
|
||||
DefaultEpsilon = 0.000001
|
||||
)
|
||||
|
||||
var (
|
||||
// ErrDimensionMismatch is a typical error.
|
||||
ErrDimensionMismatch = errors.New("matrix is not square, cannot invert")
|
||||
)
|
||||
|
||||
// New returns a new matrix.
|
||||
func New(rows, cols int) *Matrix {
|
||||
return &Matrix{
|
||||
rows: rows,
|
||||
cols: cols,
|
||||
epsilon: DefaultEpsilon,
|
||||
elements: make([]float64, rows*cols),
|
||||
}
|
||||
}
|
||||
|
||||
// Identity returns the identity matrix of a given order.
|
||||
func Identity(order int) *Matrix {
|
||||
m := New(order, order)
|
||||
for i := 0; i < order; i++ {
|
||||
m.Set(i, i, 1)
|
||||
}
|
||||
return m
|
||||
}
|
||||
|
||||
// Zeros returns a matrix of a given size zeroed.
|
||||
func Zeros(rows, cols int) *Matrix {
|
||||
return New(rows, cols)
|
||||
}
|
||||
|
||||
// Ones returns an matrix of ones.
|
||||
func Ones(rows, cols int) *Matrix {
|
||||
ones := make([]float64, rows*cols)
|
||||
for i := 0; i < (rows * cols); i++ {
|
||||
ones[i] = 1
|
||||
}
|
||||
|
||||
return &Matrix{
|
||||
rows: rows,
|
||||
cols: cols,
|
||||
epsilon: DefaultEpsilon,
|
||||
elements: ones,
|
||||
}
|
||||
}
|
||||
|
||||
// NewFromArrays creates a matrix from a jagged array set.
|
||||
func NewFromArrays(a [][]float64) *Matrix {
|
||||
rows := len(a)
|
||||
if rows == 0 {
|
||||
return nil
|
||||
}
|
||||
cols := len(a[0])
|
||||
m := New(rows, cols)
|
||||
for row := 0; row < rows; row++ {
|
||||
for col := 0; col < cols; col++ {
|
||||
m.Set(row, col, a[row][col])
|
||||
}
|
||||
}
|
||||
return m
|
||||
}
|
||||
|
||||
// Vector is just an array of values.
|
||||
type Vector []float64
|
||||
|
||||
// Matrix represents a 2d dense array of floats.
|
||||
type Matrix struct {
|
||||
epsilon float64
|
||||
elements []float64
|
||||
rows, cols int
|
||||
}
|
||||
|
||||
// Arrays returns the matrix as a two dimensional jagged array.
|
||||
func (m *Matrix) Arrays() [][]float64 {
|
||||
a := make([][]float64, m.rows, m.cols)
|
||||
|
||||
for row := 0; row < m.rows; row++ {
|
||||
for col := 0; col < m.cols; col++ {
|
||||
a[row][col] = m.Get(row, col)
|
||||
}
|
||||
}
|
||||
return a
|
||||
}
|
||||
|
||||
// Size returns the dimensions of the matrix.
|
||||
func (m *Matrix) Size() (rows, cols int) {
|
||||
rows = m.rows
|
||||
cols = m.cols
|
||||
return
|
||||
}
|
||||
|
||||
// IsSquare returns if the row count is equal to the column count.
|
||||
func (m *Matrix) IsSquare() bool {
|
||||
return m.rows == m.cols
|
||||
}
|
||||
|
||||
// IsSymmetric returns if the matrix is symmetric about its diagonal.
|
||||
func (m *Matrix) IsSymmetric() bool {
|
||||
if m.rows != m.cols {
|
||||
return false
|
||||
}
|
||||
for i := 0; i < m.rows; i++ {
|
||||
for j := 0; j < i; j++ {
|
||||
if m.Get(i, j) != m.Get(j, i) {
|
||||
return false
|
||||
}
|
||||
}
|
||||
}
|
||||
return true
|
||||
}
|
||||
|
||||
// Get returns the element at the given row, col.
|
||||
func (m *Matrix) Get(row, col int) float64 {
|
||||
index := (m.cols * row) + col
|
||||
return m.elements[index]
|
||||
}
|
||||
|
||||
// Set sets a value.
|
||||
func (m *Matrix) Set(row, col int, val float64) {
|
||||
index := (m.cols * row) + col
|
||||
m.elements[index] = val
|
||||
}
|
||||
|
||||
// Col returns a column of the matrix as a vector.
|
||||
func (m *Matrix) Col(col int) Vector {
|
||||
values := make([]float64, m.rows)
|
||||
for row := 0; row < m.rows; row++ {
|
||||
values[col] = m.Get(row, col)
|
||||
}
|
||||
return Vector(values)
|
||||
}
|
||||
|
||||
// Row returns a row of the matrix as a vector.
|
||||
func (m *Matrix) Row(row int) Vector {
|
||||
values := make([]float64, m.cols)
|
||||
for col := 0; col < m.cols; col++ {
|
||||
values[col] = m.Get(row, col)
|
||||
}
|
||||
return Vector(values)
|
||||
}
|
||||
|
||||
// Copy returns a duplicate of a given matrix.
|
||||
func (m *Matrix) Copy() *Matrix {
|
||||
m2 := New(m.rows, m.cols)
|
||||
for row := 0; row < m.rows; row++ {
|
||||
for col := 0; col < m.cols; col++ {
|
||||
m2.Set(row, col, m.Get(row, col))
|
||||
}
|
||||
}
|
||||
return m2
|
||||
}
|
||||
|
||||
// DiagonalVector returns a vector from the diagonal of a matrix.
|
||||
func (m *Matrix) DiagonalVector() Vector {
|
||||
rank := minInt(m.rows, m.cols)
|
||||
values := make([]float64, rank)
|
||||
|
||||
for index := 0; index < rank; index++ {
|
||||
values[index] = m.Get(index, index)
|
||||
}
|
||||
return Vector(values)
|
||||
}
|
||||
|
||||
// Equals returns if a matrix equals another matrix.
|
||||
func (m *Matrix) Equals(other *Matrix) bool {
|
||||
if other == nil && m != nil {
|
||||
return false
|
||||
} else if other == nil {
|
||||
return true
|
||||
}
|
||||
|
||||
if otherRows, otherCols := other.Size(); otherRows != m.rows || otherCols != m.cols {
|
||||
return false
|
||||
}
|
||||
|
||||
for row := 0; row < m.rows; row++ {
|
||||
for col := 0; col < m.cols; col++ {
|
||||
if m.Get(row, col) != other.Get(row, col) {
|
||||
return false
|
||||
}
|
||||
|
||||
}
|
||||
}
|
||||
return true
|
||||
}
|
||||
|
||||
// L returns the matrix with zeros below the diagonal.
|
||||
func (m *Matrix) L() *Matrix {
|
||||
m2 := New(m.rows, m.cols)
|
||||
for row := 0; row < m.rows; row++ {
|
||||
for col := row; col < m.cols; col++ {
|
||||
m2.Set(row, col, m.Get(row, col))
|
||||
}
|
||||
}
|
||||
return m2
|
||||
}
|
||||
|
||||
// U returns the matrix with zeros above the diagonal.
|
||||
func (m *Matrix) U() *Matrix {
|
||||
m2 := New(m.rows, m.cols)
|
||||
for row := 0; row < m.rows; row++ {
|
||||
for col := 0; col < row && col < m.cols; col++ {
|
||||
m2.Set(row, col, m.Get(row, col))
|
||||
}
|
||||
}
|
||||
return m2
|
||||
}
|
||||
|
||||
// Diagonal returns a matrix from the diagonal of a matrix.
|
||||
func (m *Matrix) Diagonal() *Matrix {
|
||||
rank := minInt(m.rows, m.cols)
|
||||
m2 := New(rank, rank)
|
||||
|
||||
for index := 0; index < rank; index++ {
|
||||
m2.Set(index, index, m.Get(index, index))
|
||||
}
|
||||
return m2
|
||||
}
|
||||
|
||||
// String returns a string representation of the matrix.
|
||||
func (m *Matrix) String() string {
|
||||
buffer := bytes.NewBuffer(nil)
|
||||
for row := 0; row < m.rows; row++ {
|
||||
for col := 0; col < m.cols; col++ {
|
||||
buffer.WriteString(fmt.Sprintf("%f", m.Get(row, col)))
|
||||
buffer.WriteRune(' ')
|
||||
}
|
||||
buffer.WriteRune('\n')
|
||||
}
|
||||
return buffer.String()
|
||||
}
|
||||
|
||||
// Decompositions
|
||||
|
||||
// LU returns the LU decomposition of a matrix.
|
||||
func (m *Matrix) LU() (l, u, p *Matrix) {
|
||||
return
|
||||
}
|
||||
|
||||
// QR performs the qr decomposition.
|
||||
func (m *Matrix) QR() (q, r *Matrix) {
|
||||
rows, cols := m.Size()
|
||||
qr := m.Copy()
|
||||
q = New(rows, cols)
|
||||
r = New(rows, cols)
|
||||
|
||||
var i, j, k int
|
||||
var norm, s float64
|
||||
|
||||
for k = 0; k < cols; k++ {
|
||||
norm = 0
|
||||
for i = k; i < rows; i++ {
|
||||
norm = math.Hypot(norm, qr.Get(i, k))
|
||||
}
|
||||
|
||||
if norm != 0 {
|
||||
if qr.Get(k, k) < 0 {
|
||||
norm = -norm
|
||||
}
|
||||
|
||||
for i = k; i < rows; i++ {
|
||||
qr.Set(i, k, qr.Get(i, k)/norm)
|
||||
}
|
||||
qr.Set(k, k, qr.Get(k, k)+1.0)
|
||||
|
||||
for j = k + 1; j < cols; j++ {
|
||||
s = 0
|
||||
for i = k; i < rows; i++ {
|
||||
s += qr.Get(i, k) * qr.Get(i, j)
|
||||
}
|
||||
s = -s / qr.Get(k, k)
|
||||
for i = k; i < rows; i++ {
|
||||
qr.Set(i, j, qr.Get(i, j)+s*qr.Get(i, k))
|
||||
|
||||
if i < j {
|
||||
r.Set(i, j, qr.Get(i, j))
|
||||
}
|
||||
}
|
||||
|
||||
}
|
||||
}
|
||||
|
||||
r.Set(k, k, -norm)
|
||||
|
||||
}
|
||||
|
||||
//Q Matrix:
|
||||
i, j, k = 0, 0, 0
|
||||
|
||||
for k = cols - 1; k >= 0; k-- {
|
||||
q.Set(k, k, 1.0)
|
||||
for j = k; j < cols; j++ {
|
||||
if qr.Get(k, k) != 0 {
|
||||
s = 0
|
||||
for i = k; i < rows; i++ {
|
||||
s += qr.Get(i, k) * q.Get(i, j)
|
||||
}
|
||||
s = -s / qr.Get(k, k)
|
||||
for i = k; i < rows; i++ {
|
||||
q.Set(i, j, q.Get(i, j)+s*qr.Get(i, k))
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
return
|
||||
}
|
||||
27
matrix/util.go
Normal file
27
matrix/util.go
Normal file
|
|
@ -0,0 +1,27 @@
|
|||
package matrix
|
||||
|
||||
import (
|
||||
"math"
|
||||
)
|
||||
|
||||
func minInt(values ...int) int {
|
||||
min := math.MaxInt32
|
||||
|
||||
for x := 0; x < len(values); x++ {
|
||||
if values[x] < min {
|
||||
min = values[x]
|
||||
}
|
||||
}
|
||||
return min
|
||||
}
|
||||
|
||||
func maxInt(values ...int) int {
|
||||
max := math.MinInt32
|
||||
|
||||
for x := 0; x < len(values); x++ {
|
||||
if values[x] > max {
|
||||
max = values[x]
|
||||
}
|
||||
}
|
||||
return max
|
||||
}
|
||||
90
polynomial_regression_series.go
Normal file
90
polynomial_regression_series.go
Normal file
|
|
@ -0,0 +1,90 @@
|
|||
package chart
|
||||
|
||||
import "fmt"
|
||||
|
||||
// PolynomialRegressionSeries implements a polynomial regression over a given
|
||||
// inner series.
|
||||
type PolynomialRegressionSeries struct {
|
||||
Name string
|
||||
Style Style
|
||||
YAxis YAxisType
|
||||
|
||||
Limit int
|
||||
Offset int
|
||||
Order int
|
||||
InnerSeries ValueProvider
|
||||
|
||||
coeffs []float64
|
||||
}
|
||||
|
||||
// GetName returns the name of the time series.
|
||||
func (prs PolynomialRegressionSeries) GetName() string {
|
||||
return prs.Name
|
||||
}
|
||||
|
||||
// GetStyle returns the line style.
|
||||
func (prs PolynomialRegressionSeries) GetStyle() Style {
|
||||
return prs.Style
|
||||
}
|
||||
|
||||
// GetYAxis returns which YAxis the series draws on.
|
||||
func (prs PolynomialRegressionSeries) GetYAxis() YAxisType {
|
||||
return prs.YAxis
|
||||
}
|
||||
|
||||
// Len returns the number of elements in the series.
|
||||
func (prs PolynomialRegressionSeries) Len() int {
|
||||
return Math.MinInt(prs.GetLimit(), prs.InnerSeries.Len()-prs.GetOffset())
|
||||
}
|
||||
|
||||
// GetLimit returns the window size.
|
||||
func (prs PolynomialRegressionSeries) GetLimit() int {
|
||||
if prs.Limit == 0 {
|
||||
return prs.InnerSeries.Len()
|
||||
}
|
||||
return prs.Limit
|
||||
}
|
||||
|
||||
// GetEndIndex returns the effective limit end.
|
||||
func (prs PolynomialRegressionSeries) GetEndIndex() int {
|
||||
offset := prs.GetOffset() + prs.Len()
|
||||
innerSeriesLastIndex := prs.InnerSeries.Len() - 1
|
||||
return Math.MinInt(offset, innerSeriesLastIndex)
|
||||
}
|
||||
|
||||
// GetOffset returns the data offset.
|
||||
func (prs PolynomialRegressionSeries) GetOffset() int {
|
||||
if prs.Offset == 0 {
|
||||
return 0
|
||||
}
|
||||
return prs.Offset
|
||||
}
|
||||
|
||||
// Validate validates the series.
|
||||
func (prs *PolynomialRegressionSeries) Validate() error {
|
||||
if prs.InnerSeries == nil {
|
||||
return fmt.Errorf("linear regression series requires InnerSeries to be set")
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
// GetValue returns the series value for a given index.
|
||||
func (prs *PolynomialRegressionSeries) GetValue(index int) (x, y float64) {
|
||||
if prs.InnerSeries == nil || prs.InnerSeries.Len() == 0 {
|
||||
return
|
||||
}
|
||||
return
|
||||
}
|
||||
|
||||
func (prs *PolynomialRegressionSeries) computeCoefficients() {
|
||||
vandMatrix := make([][]float64, prs.Len(), prs.Order+1)
|
||||
var xvalue float64
|
||||
for i := 0; i < prs.Len(); i++ {
|
||||
_, xvalue = prs.InnerSeries.GetValue(i)
|
||||
var mult float64 = 1.0
|
||||
for j := 0; j < prs.Order+1; j++ {
|
||||
vandMatrix[i][j] = mult
|
||||
mult = mult * xvalue
|
||||
}
|
||||
}
|
||||
}
|
||||
Loading…
Reference in a new issue