mirror of
https://github.com/c9s/bbgo.git
synced 2024-11-24 15:55:14 +00:00
126 lines
2.8 KiB
Go
126 lines
2.8 KiB
Go
package indicator
|
|
|
|
import (
|
|
"github.com/sirupsen/logrus"
|
|
"time"
|
|
|
|
"github.com/c9s/bbgo/pkg/datatype/floats"
|
|
"github.com/c9s/bbgo/pkg/types"
|
|
)
|
|
|
|
var logLinReg = logrus.WithField("indicator", "LinReg")
|
|
|
|
// LinReg is Linear Regression baseline
|
|
//go:generate callbackgen -type LinReg
|
|
type LinReg struct {
|
|
types.SeriesBase
|
|
types.IntervalWindow
|
|
|
|
// Values are the slopes of linear regression baseline
|
|
Values floats.Slice
|
|
// ValueRatios are the ratio of slope to the price
|
|
ValueRatios floats.Slice
|
|
|
|
klines types.KLineWindow
|
|
|
|
EndTime time.Time
|
|
UpdateCallbacks []func(value float64)
|
|
}
|
|
|
|
// Last slope of linear regression baseline
|
|
func (lr *LinReg) Last() float64 {
|
|
if lr.Values.Length() == 0 {
|
|
return 0.0
|
|
}
|
|
return lr.Values.Last()
|
|
}
|
|
|
|
// LastRatio of slope to price
|
|
func (lr *LinReg) LastRatio() float64 {
|
|
if lr.ValueRatios.Length() == 0 {
|
|
return 0.0
|
|
}
|
|
return lr.ValueRatios.Last()
|
|
}
|
|
|
|
// Index returns the slope of specified index
|
|
func (lr *LinReg) Index(i int) float64 {
|
|
if i >= lr.Values.Length() {
|
|
return 0.0
|
|
}
|
|
|
|
return lr.Values.Index(i)
|
|
}
|
|
|
|
// IndexRatio returns the slope ratio
|
|
func (lr *LinReg) IndexRatio(i int) float64 {
|
|
if i >= lr.ValueRatios.Length() {
|
|
return 0.0
|
|
}
|
|
|
|
return lr.ValueRatios.Index(i)
|
|
}
|
|
|
|
// Length of the slope values
|
|
func (lr *LinReg) Length() int {
|
|
return lr.Values.Length()
|
|
}
|
|
|
|
// LengthRatio of the slope ratio values
|
|
func (lr *LinReg) LengthRatio() int {
|
|
return lr.ValueRatios.Length()
|
|
}
|
|
|
|
var _ types.SeriesExtend = &LinReg{}
|
|
|
|
// Update Linear Regression baseline slope
|
|
func (lr *LinReg) Update(kline types.KLine) {
|
|
lr.klines.Add(kline)
|
|
lr.klines.Truncate(lr.Window)
|
|
if len(lr.klines) < lr.Window {
|
|
lr.Values.Push(0)
|
|
lr.ValueRatios.Push(0)
|
|
return
|
|
}
|
|
|
|
var sumX, sumY, sumXSqr, sumXY float64 = 0, 0, 0, 0
|
|
end := len(lr.klines) - 1 // The last kline
|
|
for i := end; i >= end-lr.Window+1; i-- {
|
|
val := lr.klines[i].GetClose().Float64()
|
|
per := float64(end - i + 1)
|
|
sumX += per
|
|
sumY += val
|
|
sumXSqr += per * per
|
|
sumXY += val * per
|
|
}
|
|
length := float64(lr.Window)
|
|
slope := (length*sumXY - sumX*sumY) / (length*sumXSqr - sumX*sumX)
|
|
average := sumY / length
|
|
endPrice := average - slope*sumX/length + slope
|
|
startPrice := endPrice + slope*(length-1)
|
|
lr.Values.Push((endPrice - startPrice) / (length - 1))
|
|
lr.ValueRatios.Push(lr.Values.Last() / kline.GetClose().Float64())
|
|
|
|
logLinReg.Debugf("linear regression baseline slope: %f", lr.Last())
|
|
}
|
|
|
|
func (lr *LinReg) BindK(target KLineClosedEmitter, symbol string, interval types.Interval) {
|
|
target.OnKLineClosed(types.KLineWith(symbol, interval, lr.PushK))
|
|
}
|
|
|
|
func (lr *LinReg) PushK(k types.KLine) {
|
|
var zeroTime = time.Time{}
|
|
if lr.EndTime != zeroTime && k.EndTime.Before(lr.EndTime) {
|
|
return
|
|
}
|
|
|
|
lr.Update(k)
|
|
lr.EndTime = k.EndTime.Time()
|
|
}
|
|
|
|
func (lr *LinReg) LoadK(allKLines []types.KLine) {
|
|
for _, k := range allKLines {
|
|
lr.PushK(k)
|
|
}
|
|
}
|