bbgo_origin/pkg/bbgo/scale.go

309 lines
6.4 KiB
Go
Raw Normal View History

2021-02-27 17:53:00 +00:00
package bbgo
import (
"fmt"
"math"
"github.com/pkg/errors"
2021-02-27 17:53:00 +00:00
)
type Scale interface {
Solve() error
Formula() string
FormulaOf(x float64) string
Call(x float64) (y float64)
}
func init() {
_ = Scale(&ExponentialScale{})
_ = Scale(&LogarithmicScale{})
_ = Scale(&LinearScale{})
_ = Scale(&QuadraticScale{})
}
2021-02-27 17:53:00 +00:00
// y := ab^x
// shift xs[0] to 0 (x - h)
// a = y1
//
// y := ab^(x-h)
// y2/a = b^(x2-h)
// y2/y1 = b^(x2-h)
//
// also posted at https://play.golang.org/p/JlWlwZjoebE
type ExponentialScale struct {
2021-02-27 17:53:00 +00:00
Domain [2]float64 `json:"domain"`
Range [2]float64 `json:"range"`
a float64
b float64
h float64
}
func (s *ExponentialScale) Solve() error {
2021-02-27 17:53:00 +00:00
s.h = s.Domain[0]
s.a = s.Range[0]
s.b = math.Pow(s.Range[1]/s.Range[0], 1/(s.Domain[1]-s.h))
return nil
}
func (s *ExponentialScale) String() string {
2021-02-27 17:53:00 +00:00
return s.Formula()
}
func (s *ExponentialScale) Formula() string {
2021-02-27 17:53:00 +00:00
return fmt.Sprintf("f(x) = %f * %f ^ (x - %f)", s.a, s.b, s.h)
}
func (s *ExponentialScale) FormulaOf(x float64) string {
2021-02-27 17:53:00 +00:00
return fmt.Sprintf("f(%f) = %f * %f ^ (%f - %f)", x, s.a, s.b, x, s.h)
}
func (s *ExponentialScale) Call(x float64) (y float64) {
2021-02-27 18:20:47 +00:00
if x < s.Domain[0] {
x = s.Domain[0]
} else if x > s.Domain[1] {
x = s.Domain[1]
}
2021-02-27 17:53:00 +00:00
y = s.a * math.Pow(s.b, x-s.h)
return y
}
type LogarithmicScale struct {
2021-02-27 17:53:00 +00:00
Domain [2]float64 `json:"domain"`
Range [2]float64 `json:"range"`
h float64
s float64
a float64
}
func (s *LogarithmicScale) Call(x float64) (y float64) {
2021-02-27 18:20:47 +00:00
if x < s.Domain[0] {
x = s.Domain[0]
} else if x > s.Domain[1] {
x = s.Domain[1]
}
2021-02-27 17:53:00 +00:00
// y = a * log(x - h) + s
2021-02-27 18:06:33 +00:00
y = s.a*math.Log(x-s.h) + s.s
2021-02-27 17:53:00 +00:00
return y
}
func (s *LogarithmicScale) String() string {
2021-02-27 17:53:00 +00:00
return s.Formula()
}
func (s *LogarithmicScale) Formula() string {
2021-02-27 17:53:00 +00:00
return fmt.Sprintf("f(x) = %f * log(x - %f) + %f", s.a, s.h, s.s)
}
func (s *LogarithmicScale) FormulaOf(x float64) string {
2021-02-27 17:53:00 +00:00
return fmt.Sprintf("f(%f) = %f * log(%f - %f) + %f", x, s.a, x, s.h, s.s)
}
func (s *LogarithmicScale) Solve() error {
2021-02-27 17:53:00 +00:00
// f(x) = a * log2(x - h) + s
//
// log2(1) = 0
//
// h = x1 - 1
// s = y1
//
// y2 = a * log(x2 - h) + s
// y2 = a * log(x2 - h) + y1
// y2 - y1 = a * log(x2 - h)
// a = (y2 - y1) / log(x2 - h)
s.h = s.Domain[0] - 1
s.s = s.Range[0]
2021-02-27 18:06:33 +00:00
s.a = (s.Range[1] - s.Range[0]) / math.Log(s.Domain[1]-s.h)
return nil
}
2021-02-27 18:20:47 +00:00
type LinearScale struct {
Domain [2]float64 `json:"domain"`
Range [2]float64 `json:"range"`
a, b float64
}
func (s *LinearScale) Solve() error {
xs := s.Domain
ys := s.Range
// y1 = a * x1 + b
// y2 = a * x2 + b
// y2 - y1 = (a * x2 + b) - (a * x1 + b)
// y2 - y1 = (a * x2) - (a * x1)
// y2 - y1 = a * (x2 - x1)
// a = (y2 - y1) / (x2 - x1)
// b = y1 - (a * x1)
s.a = (ys[1] - ys[0]) / (xs[1] - xs[0])
s.b = ys[0] - (s.a * xs[0])
return nil
}
func (s *LinearScale) Call(x float64) (y float64) {
if x < s.Domain[0] {
x = s.Domain[0]
} else if x > s.Domain[1] {
x = s.Domain[1]
}
y = s.a*x + s.b
2021-02-27 18:20:47 +00:00
return y
}
func (s *LinearScale) String() string {
return s.Formula()
}
func (s *LinearScale) Formula() string {
return fmt.Sprintf("f(x) = %f * x + %f", s.a, s.b)
}
func (s *LinearScale) FormulaOf(x float64) string {
return fmt.Sprintf("f(%f) = %f * %f + %f", x, s.a, x, s.b)
}
// see also: http://www.vb-helper.com/howto_find_quadratic_curve.html
2021-02-27 18:06:33 +00:00
type QuadraticScale struct {
Domain [3]float64 `json:"domain"`
Range [3]float64 `json:"range"`
a, b, c float64
}
func (s *QuadraticScale) Solve() error {
xs := s.Domain
ys := s.Range
s.a = ((ys[1]-ys[0])*(xs[0]-xs[2]) + (ys[2]-ys[0])*(xs[1]-xs[0])) /
((xs[0]-xs[2])*(math.Pow(xs[1], 2)-math.Pow(xs[0], 2)) + (xs[1]-xs[0])*(math.Pow(xs[2], 2)-math.Pow(xs[0], 2)))
s.b = ((ys[1] - ys[0]) - s.a*(math.Pow(xs[1], 2)-math.Pow(xs[0], 2))) / (xs[1] - xs[0])
s.c = ys[1] - s.a*math.Pow(xs[1], 2) - s.b*xs[1]
2021-02-27 17:53:00 +00:00
return nil
}
2021-02-27 18:06:33 +00:00
func (s *QuadraticScale) Call(x float64) (y float64) {
2021-02-27 18:20:47 +00:00
if x < s.Domain[0] {
x = s.Domain[0]
} else if x > s.Domain[2] {
x = s.Domain[2]
}
2021-02-27 18:06:33 +00:00
// y = a * log(x - h) + s
y = s.a*math.Pow(x, 2) + s.b*x + s.c
2021-02-27 18:06:33 +00:00
return y
}
func (s *QuadraticScale) String() string {
return s.Formula()
}
func (s *QuadraticScale) Formula() string {
return fmt.Sprintf("f(x) = %f * x ^ 2 + %f * x + %f", s.a, s.b, s.c)
}
func (s *QuadraticScale) FormulaOf(x float64) string {
return fmt.Sprintf("f(%f) = %f * %f ^ 2 + %f * %f + %f", x, s.a, x, s.b, x, s.c)
}
type SlideRule struct {
// Scale type could be one of "log", "exp", "linear", "quadratic"
// this is similar to the d3.scale
LinearScale *LinearScale `json:"linear"`
LogScale *LogarithmicScale `json:"log"`
ExpScale *ExponentialScale `json:"exp"`
QuadraticScale *QuadraticScale `json:"quadratic"`
}
func (rule *SlideRule) Scale() (Scale, error) {
if rule.LogScale != nil {
return rule.LogScale, nil
}
if rule.ExpScale != nil {
return rule.ExpScale, nil
}
if rule.LinearScale != nil {
return rule.LinearScale, nil
}
if rule.QuadraticScale != nil {
return rule.QuadraticScale, nil
}
return nil, errors.New("no any scale is defined")
}
// PriceVolumeScale defines the scale DSL for strategy, e.g.,
//
// scaleQuantity:
// byPrice:
// exp:
// domain: [10_000, 50_000]
// range: [0.01, 1.0]
//
// and
//
// scaleQuantity:
// byVolume:
// linear:
// domain: [10_000, 50_000]
// range: [0.01, 1.0]
type PriceVolumeScale struct {
ByPrice *SlideRule `json:"byPrice"`
ByVolume *SlideRule `json:"byVolume"`
}
func (q *PriceVolumeScale) Scale(price float64, volume float64) (quantity float64, err error) {
if q.ByPrice != nil {
quantity, err = q.ScaleByPrice(price)
return
} else if q.ByVolume != nil {
quantity, err = q.ScaleByVolume(volume)
} else {
err = errors.New("either price or volume scale is not defined")
}
return
}
// ScaleByPrice scale quantity by the given price
func (q *PriceVolumeScale) ScaleByPrice(price float64) (float64, error) {
if q.ByPrice == nil {
return 0, errors.New("byPrice scale is not defined")
}
scale, err := q.ByPrice.Scale()
if err != nil {
return 0, err
}
if err := scale.Solve() ; err != nil {
return 0, err
}
return scale.Call(price), nil
}
// ScaleByVolume scale quantity by the given volume
func (q *PriceVolumeScale) ScaleByVolume(volume float64) (float64, error) {
if q.ByVolume == nil {
return 0, errors.New("byVolume scale is not defined")
}
scale, err := q.ByVolume.Scale()
if err != nil {
return 0, err
}
if err := scale.Solve() ; err != nil {
return 0, err
}
return scale.Call(volume), nil
}