lychiyu/bbgo_origin
1
0
Fork 0
mirror of https://github.com/c9s/bbgo.git synced 2024-09-20 08:11:08 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

Merge pull request #1198 from andycheng123/feature/profit-tracker

Browse Source 
FEATURE: add ProfitStatsTracker
This commit is contained in:
Andy Cheng 2023-07-18 11:40:26 +08:00 committed by GitHub
commit e37edb3056
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
7 changed files with 305 additions and 152 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

9
config/linregmaker.yaml
View File

@ -175,3 +175,12 @@ exchangeStrategies:
# roiStopLoss is the stop loss percentage of the position ROI (currently the price change)
- roiStopLoss:
percentage: 30%
profitStatsTracker:
interval: 1d
window: 30
accumulatedProfitReport:
profitMAWindow: 60
shortTermProfitWindow: 14
tsvReportPath: res.tsv
trackParameters: false

9
config/supertrend.yaml
View File

@ -112,3 +112,12 @@ exchangeStrategies:
# If true, looking for lower lows in long position and higher highs in short position. If false, looking for
# higher highs in long position and lower lows in short position
oppositeDirectionAsPosition: false
profitStatsTracker:
interval: 1d
window: 30
accumulatedProfitReport:
profitMAWindow: 60
shortTermProfitWindow: 14
tsvReportPath: res.tsv
trackParameters: false

235
pkg/report/profit_report.go
View File

@ -2,196 +2,173 @@ package report
import (
"fmt"
"github.com/c9s/bbgo/pkg/bbgo"
"github.com/c9s/bbgo/pkg/data/tsv"
"github.com/c9s/bbgo/pkg/datatype/floats"
"github.com/c9s/bbgo/pkg/fixedpoint"
"github.com/c9s/bbgo/pkg/indicator"
indicatorv2 "github.com/c9s/bbgo/pkg/indicator/v2"
"github.com/c9s/bbgo/pkg/types"
"strconv"
)
// AccumulatedProfitReport For accumulated profit report output
type AccumulatedProfitReport struct {
// AccumulatedProfitMAWindow Accumulated profit SMA window, in number of trades
AccumulatedProfitMAWindow int `json:"accumulatedProfitMAWindow"`
// ProfitMAWindow Accumulated profit SMA window
ProfitMAWindow int `json:"profitMAWindow"`
// IntervalWindow interval window, in days
IntervalWindow int `json:"intervalWindow"`
// NumberOfInterval How many intervals to output to TSV
NumberOfInterval int `json:"NumberOfInterval"`
// ShortTermProfitWindow The window to sum up the short-term profit
ShortTermProfitWindow int `json:"shortTermProfitWindow"`
// TsvReportPath The path to output report to
TsvReportPath string `json:"tsvReportPath"`
// AccumulatedDailyProfitWindow The window to sum up the daily profit, in days
AccumulatedDailyProfitWindow int `json:"accumulatedDailyProfitWindow"`
symbol string
Symbol string
types.IntervalWindow
// Accumulated profit
accumulatedProfit fixedpoint.Value
accumulatedProfitPerDay floats.Slice
previousAccumulatedProfit fixedpoint.Value
accumulatedProfit fixedpoint.Value
accumulatedProfitPerInterval *types.Float64Series
// Accumulated profit MA
accumulatedProfitMA *indicator.SMA
accumulatedProfitMAPerDay floats.Slice
profitMA *indicatorv2.SMAStream
profitMAPerInterval floats.Slice
// Daily profit
dailyProfit floats.Slice
// Profit of each interval
ProfitPerInterval floats.Slice
// Accumulated fee
accumulatedFee fixedpoint.Value
accumulatedFeePerDay floats.Slice
accumulatedFee fixedpoint.Value
accumulatedFeePerInterval floats.Slice
// Win ratio
winRatioPerDay floats.Slice
winRatioPerInterval floats.Slice
// Profit factor
profitFactorPerDay floats.Slice
profitFactorPerInterval floats.Slice
// Trade number
dailyTrades floats.Slice
accumulatedTrades int
previousAccumulatedTrades int
accumulatedTrades int
accumulatedTradesPerInterval floats.Slice
// Extra values
extraValues [][2]string
strategyParameters [][2]string
}
func (r *AccumulatedProfitReport) Initialize(Symbol string, session *bbgo.ExchangeSession, orderExecutor *bbgo.GeneralOrderExecutor, TradeStats *types.TradeStats) {
r.Symbol = Symbol
func (r *AccumulatedProfitReport) Initialize(symbol string, interval types.Interval, window int) {
r.symbol = symbol
r.Interval = interval
r.Window = window
if r.AccumulatedProfitMAWindow <= 0 {
r.AccumulatedProfitMAWindow = 60
if r.ProfitMAWindow <= 0 {
r.ProfitMAWindow = 60
}
if r.IntervalWindow <= 0 {
r.IntervalWindow = 7
if r.Window <= 0 {
r.Window = 7
}
if r.AccumulatedDailyProfitWindow <= 0 {
r.AccumulatedDailyProfitWindow = 7
if r.ShortTermProfitWindow <= 0 {
r.ShortTermProfitWindow = 7
}
if r.NumberOfInterval <= 0 {
r.NumberOfInterval = 1
}
r.accumulatedProfitMA = &indicator.SMA{IntervalWindow: types.IntervalWindow{Interval: types.Interval1d, Window: r.AccumulatedProfitMAWindow}}
session.Subscribe(types.KLineChannel, r.Symbol, types.SubscribeOptions{Interval: types.Interval1d})
// Record profit
orderExecutor.TradeCollector().OnProfit(func(trade types.Trade, profit *types.Profit) {
if profit == nil {
return
}
r.RecordProfit(profit.Profit)
})
// Record trade
orderExecutor.TradeCollector().OnTrade(func(trade types.Trade, profit fixedpoint.Value, netProfit fixedpoint.Value) {
r.RecordTrade(trade.Fee)
})
// Record daily status
session.MarketDataStream.OnKLineClosed(types.KLineWith(r.Symbol, types.Interval1d, func(kline types.KLine) {
r.DailyUpdate(TradeStats)
}))
r.accumulatedProfitPerInterval = types.NewFloat64Series()
r.profitMA = indicatorv2.SMA(r.accumulatedProfitPerInterval, r.ProfitMAWindow)
}
func (r *AccumulatedProfitReport) AddExtraValue(valueAndTitle [2]string) {
r.extraValues = append(r.extraValues, valueAndTitle)
func (r *AccumulatedProfitReport) AddStrategyParameter(title string, value string) {
r.strategyParameters = append(r.strategyParameters, [2]string{title, value})
}
func (r *AccumulatedProfitReport) RecordProfit(profit fixedpoint.Value) {
r.accumulatedProfit = r.accumulatedProfit.Add(profit)
}
func (r *AccumulatedProfitReport) RecordTrade(fee fixedpoint.Value) {
r.accumulatedFee = r.accumulatedFee.Add(fee)
func (r *AccumulatedProfitReport) AddTrade(trade types.Trade) {
r.accumulatedFee = r.accumulatedFee.Add(trade.Fee)
r.accumulatedTrades += 1
}
func (r *AccumulatedProfitReport) DailyUpdate(tradeStats *types.TradeStats) {
// Daily profit
r.dailyProfit.Update(r.accumulatedProfit.Sub(r.previousAccumulatedProfit).Float64())
r.previousAccumulatedProfit = r.accumulatedProfit
func (r *AccumulatedProfitReport) Rotate(ps *types.ProfitStats, ts *types.TradeStats) {
// Accumulated profit
r.accumulatedProfitPerDay.Update(r.accumulatedProfit.Float64())
r.accumulatedProfit = r.accumulatedProfit.Add(ps.AccumulatedNetProfit)
r.accumulatedProfitPerInterval.PushAndEmit(r.accumulatedProfit.Float64())
// Accumulated profit MA
r.accumulatedProfitMA.Update(r.accumulatedProfit.Float64())
r.accumulatedProfitMAPerDay.Update(r.accumulatedProfitMA.Last(0))
// Profit of each interval
r.ProfitPerInterval.Update(ps.AccumulatedNetProfit.Float64())
// Profit MA
r.profitMAPerInterval.Update(r.profitMA.Last(0))
// Accumulated Fee
r.accumulatedFeePerDay.Update(r.accumulatedFee.Float64())
r.accumulatedFeePerInterval.Update(r.accumulatedFee.Float64())
// Trades
r.accumulatedTradesPerInterval.Update(float64(r.accumulatedTrades))
// Win ratio
r.winRatioPerDay.Update(tradeStats.WinningRatio.Float64())
r.winRatioPerInterval.Update(ts.WinningRatio.Float64())
// Profit factor
r.profitFactorPerDay.Update(tradeStats.ProfitFactor.Float64())
r.profitFactorPerInterval.Update(ts.ProfitFactor.Float64())
}
// Daily trades
r.dailyTrades.Update(float64(r.accumulatedTrades - r.previousAccumulatedTrades))
r.previousAccumulatedTrades = r.accumulatedTrades
// CsvHeader returns a header slice
func (r *AccumulatedProfitReport) CsvHeader() []string {
titles := []string{
"#",
"Symbol",
"Total Net Profit",
fmt.Sprintf("Total Net Profit %sMA%d", r.Interval, r.ProfitMAWindow),
fmt.Sprintf("%s%d Net Profit", r.Interval, r.ShortTermProfitWindow),
"accumulatedFee",
"winRatio",
"profitFactor",
fmt.Sprintf("%s%d Trades", r.Interval, r.Window),
}
for i := 0; i < len(r.strategyParameters); i++ {
titles = append(titles, r.strategyParameters[i][0])
}
return titles
}
// CsvRecords returns a data slice
func (r *AccumulatedProfitReport) CsvRecords() [][]string {
var data [][]string
for i := 0; i <= r.Window-1; i++ {
values := []string{
strconv.Itoa(i + 1),
r.symbol,
strconv.FormatFloat(r.accumulatedProfitPerInterval.Last(i), 'f', 4, 64),
strconv.FormatFloat(r.profitMAPerInterval.Last(i), 'f', 4, 64),
strconv.FormatFloat(r.accumulatedProfitPerInterval.Last(i)-r.accumulatedProfitPerInterval.Last(i+r.ShortTermProfitWindow), 'f', 4, 64),
strconv.FormatFloat(r.accumulatedFeePerInterval.Last(i), 'f', 4, 64),
strconv.FormatFloat(r.winRatioPerInterval.Last(i), 'f', 4, 64),
strconv.FormatFloat(r.profitFactorPerInterval.Last(i), 'f', 4, 64),
strconv.FormatFloat(r.accumulatedTradesPerInterval.Last(i), 'f', 4, 64),
}
for j := 0; j < len(r.strategyParameters); j++ {
values = append(values, r.strategyParameters[j][1])
}
data = append(data, values)
}
return data
}
// Output Accumulated profit report to a TSV file
func (r *AccumulatedProfitReport) Output(symbol string) {
func (r *AccumulatedProfitReport) Output() {
if r.TsvReportPath != "" {
// Open specified file for appending
tsvwiter, err := tsv.AppendWriterFile(r.TsvReportPath)
if err != nil {
panic(err)
}
defer tsvwiter.Close()
// Output title row
titles := []string{
"#",
"Symbol",
"accumulatedProfit",
"accumulatedProfitMA",
fmt.Sprintf("%dd profit", r.AccumulatedDailyProfitWindow),
"accumulatedFee",
"accumulatedNetProfit",
"winRatio",
"profitFactor",
"60D trades",
}
for i := 0; i < len(r.extraValues); i++ {
titles = append(titles, r.extraValues[i][0])
}
_ = tsvwiter.Write(titles)
// Output data row
for i := 0; i <= r.NumberOfInterval-1; i++ {
accumulatedProfit := r.accumulatedProfitPerDay.Index(r.IntervalWindow * i)
accumulatedProfitStr := fmt.Sprintf("%f", accumulatedProfit)
accumulatedProfitMA := r.accumulatedProfitMAPerDay.Index(r.IntervalWindow * i)
accumulatedProfitMAStr := fmt.Sprintf("%f", accumulatedProfitMA)
intervalAccumulatedProfit := r.dailyProfit.Tail(r.AccumulatedDailyProfitWindow+r.IntervalWindow*i).Sum() - r.dailyProfit.Tail(r.IntervalWindow*i).Sum()
intervalAccumulatedProfitStr := fmt.Sprintf("%f", intervalAccumulatedProfit)
accumulatedFee := fmt.Sprintf("%f", r.accumulatedFeePerDay.Index(r.IntervalWindow*i))
accumulatedNetProfit := fmt.Sprintf("%f", accumulatedProfit-r.accumulatedFeePerDay.Index(r.IntervalWindow*i))
winRatio := fmt.Sprintf("%f", r.winRatioPerDay.Index(r.IntervalWindow*i))
profitFactor := fmt.Sprintf("%f", r.profitFactorPerDay.Index(r.IntervalWindow*i))
trades := r.dailyTrades.Tail(60+r.IntervalWindow*i).Sum() - r.dailyTrades.Tail(r.IntervalWindow*i).Sum()
tradesStr := fmt.Sprintf("%f", trades)
values := []string{
fmt.Sprintf("%d", i+1),
symbol, accumulatedProfitStr,
accumulatedProfitMAStr,
intervalAccumulatedProfitStr,
accumulatedFee,
accumulatedNetProfit,
winRatio, profitFactor,
tradesStr,
}
for j := 0; j < len(r.extraValues); j++ {
values = append(values, r.extraValues[j][1])
}
_ = tsvwiter.Write(values)
}
// Column Title
_ = tsvwiter.Write(r.CsvHeader())
// Output data rows
_ = tsvwiter.WriteAll(r.CsvRecords())
}
}

96
pkg/report/profit_stats_tracker.go Normal file
View File

@ -0,0 +1,96 @@
package report
import (
"github.com/c9s/bbgo/pkg/bbgo"
"github.com/c9s/bbgo/pkg/core"
"github.com/c9s/bbgo/pkg/fixedpoint"
"github.com/c9s/bbgo/pkg/types"
)
type ProfitStatsTracker struct {
types.IntervalWindow
// Accumulated profit report
AccumulatedProfitReport *AccumulatedProfitReport `json:"accumulatedProfitReport"`
Market types.Market
ProfitStatsSlice []*types.ProfitStats
CurrentProfitStats **types.ProfitStats
tradeStats *types.TradeStats
}
func (p *ProfitStatsTracker) Subscribe(session *bbgo.ExchangeSession, symbol string) {
session.Subscribe(types.KLineChannel, symbol, types.SubscribeOptions{Interval: p.Interval})
}
// InitLegacy is for backward capability. ps is the ProfitStats of the strategy, Market is the strategy Market
func (p *ProfitStatsTracker) InitLegacy(market types.Market, ps **types.ProfitStats, ts *types.TradeStats) {
p.Market = market
if *ps == nil {
*ps = types.NewProfitStats(p.Market)
}
p.tradeStats = ts
p.CurrentProfitStats = ps
p.ProfitStatsSlice = append(p.ProfitStatsSlice, *ps)
if p.AccumulatedProfitReport != nil {
p.AccumulatedProfitReport.Initialize(p.Market.Symbol, p.Interval, p.Window)
}
}
// Init initialize the tracker with the given Market
func (p *ProfitStatsTracker) Init(market types.Market, ts *types.TradeStats) {
ps := types.NewProfitStats(p.Market)
p.InitLegacy(market, &ps, ts)
}
func (p *ProfitStatsTracker) Bind(session *bbgo.ExchangeSession, tradeCollector *core.TradeCollector) {
tradeCollector.OnProfit(func(trade types.Trade, profit *types.Profit) {
if profit == nil {
return
}
p.AddProfit(*profit)
})
tradeCollector.OnTrade(func(trade types.Trade, profit fixedpoint.Value, netProfit fixedpoint.Value) {
p.AddTrade(trade)
})
// Rotate profitStats slice
session.MarketDataStream.OnKLineClosed(types.KLineWith(p.Market.Symbol, p.Interval, func(kline types.KLine) {
p.Rotate()
}))
}
// Rotate the tracker to make a new ProfitStats to record the profits
func (p *ProfitStatsTracker) Rotate() {
// Update report
if p.AccumulatedProfitReport != nil {
p.AccumulatedProfitReport.Rotate(*p.CurrentProfitStats, p.tradeStats)
}
*p.CurrentProfitStats = types.NewProfitStats(p.Market)
p.ProfitStatsSlice = append(p.ProfitStatsSlice, *p.CurrentProfitStats)
// Truncate
if len(p.ProfitStatsSlice) > p.Window {
p.ProfitStatsSlice = p.ProfitStatsSlice[len(p.ProfitStatsSlice)-p.Window:]
}
}
func (p *ProfitStatsTracker) AddProfit(profit types.Profit) {
(*p.CurrentProfitStats).AddProfit(profit)
}
func (p *ProfitStatsTracker) AddTrade(trade types.Trade) {
(*p.CurrentProfitStats).AddTrade(trade)
if p.AccumulatedProfitReport != nil {
p.AccumulatedProfitReport.AddTrade(trade)
}
}

42
pkg/strategy/linregmaker/strategy.go
View File

@ -3,6 +3,9 @@ package linregmaker
import (
"context"
"fmt"
"github.com/c9s/bbgo/pkg/report"
"os"
"strconv"
"sync"
"github.com/c9s/bbgo/pkg/risk/dynamicrisk"
@ -135,6 +138,10 @@ type Strategy struct {
ProfitStats *types.ProfitStats `persistence:"profit_stats"`
TradeStats *types.TradeStats `persistence:"trade_stats"`
// ProfitStatsTracker tracks profit related status and generates report
ProfitStatsTracker *report.ProfitStatsTracker `json:"profitStatsTracker"`
TrackParameters bool `json:"trackParameters"`
Environment *bbgo.Environment
StandardIndicatorSet *bbgo.StandardIndicatorSet
Market types.Market
@ -242,6 +249,11 @@ func (s *Strategy) Subscribe(session *bbgo.ExchangeSession) {
if len(s.DynamicQuantityDecrease) > 0 {
s.DynamicQuantityDecrease.Initialize(s.Symbol, session)
}
// Profit tracker
if s.ProfitStatsTracker != nil {
s.ProfitStatsTracker.Subscribe(session, s.Symbol)
}
}
func (s *Strategy) CurrentPosition() *types.Position {
@ -664,6 +676,28 @@ func (s *Strategy) Run(ctx context.Context, orderExecutor bbgo.OrderExecutor, se
})
s.ExitMethods.Bind(session, s.orderExecutor)
// Setup profit tracker
if s.ProfitStatsTracker != nil {
if s.ProfitStatsTracker.CurrentProfitStats == nil {
s.ProfitStatsTracker.InitLegacy(s.Market, &s.ProfitStats, s.TradeStats)
}
// Add strategy parameters to report
if s.TrackParameters && s.ProfitStatsTracker.AccumulatedProfitReport != nil {
s.ProfitStatsTracker.AccumulatedProfitReport.AddStrategyParameter("ReverseEMAWindow", strconv.Itoa(s.ReverseEMA.Window))
s.ProfitStatsTracker.AccumulatedProfitReport.AddStrategyParameter("FastLinRegWindow", strconv.Itoa(s.FastLinReg.Window))
s.ProfitStatsTracker.AccumulatedProfitReport.AddStrategyParameter("FastLinRegInterval", s.FastLinReg.Interval.String())
s.ProfitStatsTracker.AccumulatedProfitReport.AddStrategyParameter("SlowLinRegWindow", strconv.Itoa(s.SlowLinReg.Window))
s.ProfitStatsTracker.AccumulatedProfitReport.AddStrategyParameter("SlowLinRegInterval", s.SlowLinReg.Interval.String())
s.ProfitStatsTracker.AccumulatedProfitReport.AddStrategyParameter("FasterDecreaseRatio", strconv.FormatFloat(s.FasterDecreaseRatio.Float64(), 'f', 4, 64))
s.ProfitStatsTracker.AccumulatedProfitReport.AddStrategyParameter("NeutralBollingerWindow", strconv.Itoa(s.NeutralBollinger.Window))
s.ProfitStatsTracker.AccumulatedProfitReport.AddStrategyParameter("NeutralBollingerBandWidth", strconv.FormatFloat(s.NeutralBollinger.BandWidth, 'f', 4, 64))
s.ProfitStatsTracker.AccumulatedProfitReport.AddStrategyParameter("Spread", strconv.FormatFloat(s.Spread.Float64(), 'f', 4, 64))
}
s.ProfitStatsTracker.Bind(s.session, s.orderExecutor.TradeCollector())
}
// Indicators initialized by StandardIndicatorSet must be initialized in Run()
// Initialize ReverseEMA
s.ReverseEMA = s.StandardIndicatorSet.EWMA(s.ReverseEMA.IntervalWindow)
@ -812,7 +846,15 @@ func (s *Strategy) Run(ctx context.Context, orderExecutor bbgo.OrderExecutor, se
bbgo.OnShutdown(ctx, func(ctx context.Context, wg *sync.WaitGroup) {
defer wg.Done()
// Output profit report
if s.ProfitStatsTracker != nil {
if s.ProfitStatsTracker.AccumulatedProfitReport != nil {
s.ProfitStatsTracker.AccumulatedProfitReport.Output()
}
}
_ = s.orderExecutor.GracefulCancel(ctx)
_, _ = fmt.Fprintln(os.Stderr, s.TradeStats.String())
})
return nil

59
pkg/strategy/supertrend/strategy.go
View File

@ -39,6 +39,10 @@ type Strategy struct {
ProfitStats *types.ProfitStats `persistence:"profit_stats"`
TradeStats *types.TradeStats `persistence:"trade_stats"`
// ProfitStatsTracker tracks profit related status and generates report
ProfitStatsTracker *report.ProfitStatsTracker `json:"profitStatsTracker"`
TrackParameters bool `json:"trackParameters"`
// Symbol is the market symbol you want to trade
Symbol string `json:"symbol"`
@ -101,9 +105,6 @@ type Strategy struct {
// StrategyController
bbgo.StrategyController
// Accumulated profit report
AccumulatedProfitReport *report.AccumulatedProfitReport `json:"accumulatedProfitReport"`
}
func (s *Strategy) ID() string {
@ -131,6 +132,11 @@ func (s *Strategy) Subscribe(session *bbgo.ExchangeSession) {
session.Subscribe(types.KLineChannel, s.Symbol, types.SubscribeOptions{Interval: s.LinearRegression.Interval})
s.ExitMethods.SetAndSubscribe(session, s)
// Profit tracker
if s.ProfitStatsTracker != nil {
s.ProfitStatsTracker.Subscribe(session, s.Symbol)
}
}
// Position control
@ -351,28 +357,31 @@ func (s *Strategy) Run(ctx context.Context, orderExecutor bbgo.OrderExecutor, se
s.orderExecutor.BindTradeStats(s.TradeStats)
s.orderExecutor.Bind()
// AccountValueCalculator
s.AccountValueCalculator = bbgo.NewAccountValueCalculator(s.session, s.Market.QuoteCurrency)
// Accumulated profit report
if bbgo.IsBackTesting {
if s.AccumulatedProfitReport == nil {
s.AccumulatedProfitReport = &report.AccumulatedProfitReport{}
// Setup profit tracker
if s.ProfitStatsTracker != nil {
if s.ProfitStatsTracker.CurrentProfitStats == nil {
s.ProfitStatsTracker.InitLegacy(s.Market, &s.ProfitStats, s.TradeStats)
}
s.AccumulatedProfitReport.Initialize(s.Symbol, session, s.orderExecutor, s.TradeStats)
// Add strategy parameters to report
s.AccumulatedProfitReport.AddExtraValue([2]string{"window", fmt.Sprintf("%d", s.Window)})
s.AccumulatedProfitReport.AddExtraValue([2]string{"multiplier", fmt.Sprintf("%f", s.SupertrendMultiplier)})
s.AccumulatedProfitReport.AddExtraValue([2]string{"fastDEMA", fmt.Sprintf("%d", s.FastDEMAWindow)})
s.AccumulatedProfitReport.AddExtraValue([2]string{"slowDEMA", fmt.Sprintf("%d", s.SlowDEMAWindow)})
s.AccumulatedProfitReport.AddExtraValue([2]string{"takeProfitAtrMultiplier", fmt.Sprintf("%f", s.TakeProfitAtrMultiplier)})
s.AccumulatedProfitReport.AddExtraValue([2]string{"stopLossByTriggeringK", fmt.Sprintf("%t", s.StopLossByTriggeringK)})
s.AccumulatedProfitReport.AddExtraValue([2]string{"stopByReversedSupertrend", fmt.Sprintf("%t", s.StopByReversedSupertrend)})
s.AccumulatedProfitReport.AddExtraValue([2]string{"stopByReversedDema", fmt.Sprintf("%t", s.StopByReversedDema)})
s.AccumulatedProfitReport.AddExtraValue([2]string{"stopByReversedLinGre", fmt.Sprintf("%t", s.StopByReversedLinGre)})
if s.TrackParameters && s.ProfitStatsTracker.AccumulatedProfitReport != nil {
s.ProfitStatsTracker.AccumulatedProfitReport.AddStrategyParameter("window", fmt.Sprintf("%d", s.Window))
s.ProfitStatsTracker.AccumulatedProfitReport.AddStrategyParameter("multiplier", fmt.Sprintf("%f", s.SupertrendMultiplier))
s.ProfitStatsTracker.AccumulatedProfitReport.AddStrategyParameter("fastDEMA", fmt.Sprintf("%d", s.FastDEMAWindow))
s.ProfitStatsTracker.AccumulatedProfitReport.AddStrategyParameter("slowDEMA", fmt.Sprintf("%d", s.SlowDEMAWindow))
s.ProfitStatsTracker.AccumulatedProfitReport.AddStrategyParameter("takeProfitAtrMultiplier", fmt.Sprintf("%f", s.TakeProfitAtrMultiplier))
s.ProfitStatsTracker.AccumulatedProfitReport.AddStrategyParameter("stopLossByTriggeringK", fmt.Sprintf("%t", s.StopLossByTriggeringK))
s.ProfitStatsTracker.AccumulatedProfitReport.AddStrategyParameter("stopByReversedSupertrend", fmt.Sprintf("%t", s.StopByReversedSupertrend))
s.ProfitStatsTracker.AccumulatedProfitReport.AddStrategyParameter("stopByReversedDema", fmt.Sprintf("%t", s.StopByReversedDema))
s.ProfitStatsTracker.AccumulatedProfitReport.AddStrategyParameter("stopByReversedLinGre", fmt.Sprintf("%t", s.StopByReversedLinGre))
}
s.ProfitStatsTracker.Bind(s.session, s.orderExecutor.TradeCollector())
}
// AccountValueCalculator
s.AccountValueCalculator = bbgo.NewAccountValueCalculator(s.session, s.Market.QuoteCurrency)
// For drawing
profitSlice := floats.Slice{1., 1.}
price, _ := session.LastPrice(s.Symbol)
@ -520,10 +529,14 @@ func (s *Strategy) Run(ctx context.Context, orderExecutor bbgo.OrderExecutor, se
bbgo.OnShutdown(ctx, func(ctx context.Context, wg *sync.WaitGroup) {
defer wg.Done()
if bbgo.IsBackTesting {
// Output accumulated profit report
defer s.AccumulatedProfitReport.Output(s.Symbol)
// Output profit report
if s.ProfitStatsTracker != nil {
if s.ProfitStatsTracker.AccumulatedProfitReport != nil {
s.ProfitStatsTracker.AccumulatedProfitReport.Output()
}
}
if bbgo.IsBackTesting {
// Draw graph
if s.DrawGraph {
if err := s.Draw(&profitSlice, &cumProfitSlice); err != nil {

7
pkg/types/profit.go
View File

@ -164,6 +164,9 @@ type ProfitStats struct {
TodayGrossProfit fixedpoint.Value `json:"todayGrossProfit,omitempty"`
TodayGrossLoss fixedpoint.Value `json:"todayGrossLoss,omitempty"`
TodaySince int64 `json:"todaySince,omitempty"`
//StartTime time.Time
//EndTime time.Time
}
func NewProfitStats(market Market) *ProfitStats {
@ -182,6 +185,8 @@ func NewProfitStats(market Market) *ProfitStats {
TodayGrossProfit: fixedpoint.Zero,
TodayGrossLoss: fixedpoint.Zero,
TodaySince: 0,
//StartTime: time.Now().UTC(),
//EndTime: time.Now().UTC(),
}
}
@ -223,6 +228,8 @@ func (s *ProfitStats) AddProfit(profit Profit) {
s.AccumulatedGrossLoss = s.AccumulatedGrossLoss.Add(profit.Profit)
s.TodayGrossLoss = s.TodayGrossLoss.Add(profit.Profit)
}
//s.EndTime = profit.TradedAt.UTC()
}
func (s *ProfitStats) AddTrade(trade Trade) {