save

.gitignore

@@ -2,6 +2,7 @@
 *.dll
 *.exe
 *.db
+*.html
 bin/
 spot/
 html/

config.yml

@@ -2,8 +2,8 @@
 
 
 
-assetName: "SOLUSDT"
+assetName: "TIAUSDT"
 
-duration: "30m"
+duration: "1h"
 
 limit: 17000

main.go

@@ -22,14 +22,34 @@ func main() {
 	// 	fmt.Println(e)
 	// strategey.RunBacktestEma()
 	// strategey.RunBacktestEmaChoppy()
-
+	// strategey.RunBacktestMacd()
 	// strategey.RunBacktestDonchain()
 	// strategey.RunBacktestDonchainChoppy()
 
 	// c, _ := strategey.GetCsvDataFrame("BTCUSDT", "4h", "2022-05", "2023-12")
 
 	// fmt.Println(c)
 	strategey.RunBacktestST()
+	// strategey.RunBacktestSuperTrend()
+
+	// var err error
+
+	// // account := trader.NewAccount(1000)
+	// btcfg, err := config.Yaml()
+	// if err != nil {
+	// 	log.Fatalf("error: %v", err)
+	// }
+
+	// fmt.Println("--------------------------------------------")
+
+	// // strategyName := getStrageyNameDonchain()
+	// assetName := btcfg.AssetName
+	// duration := btcfg.Dration
+
+	// df, _ := strategey.GetCandleData(assetName, duration)
+	// account := trader.NewAccount(1000)
+
+	// df.Signal = df.SuperTrendChoppyStrategy(17, 2.0, 13, account)
 
 	// hSeries := df.Candles.Col("High")
 	// lSeries := df.Candles.Col("Low")
@@ -44,8 +64,8 @@ func main() {
 	end := time.Now()
 
 	// 処理時間を計算
-	duration := end.Sub(start)
+	duration1 := end.Sub(start)
 
 	// 処理時間を表示
-	fmt.Printf("処理時間: %v\n", duration)
+	fmt.Printf("処理時間: %v\n", duration1)
 }

pkg/analytics/expected_value.go

@@ -0,0 +1,24 @@
+package analytics
+
+import "v1/pkg/execute"
+
+func ExpectedValue(s *execute.SignalEvents) float64 {
+
+	if s == nil {
+		return 0.0
+	}
+
+	var ev float64
+
+	wr := WinRate(s)
+
+	aw := AveregeProfit(s)
+
+	lr := 1.0 - wr
+
+	al := AveregeLoss(s)
+
+	ev = (wr * aw) - (lr * al)
+
+	return ev
+}

pkg/analytics/pay_off_ratio.go

@@ -17,6 +17,18 @@ func AveregeProfit(s *execute.SignalEvents) float64 {
 
 }
 
+func AveregeProfitRatio(s *execute.SignalEvents) float64 {
+	if s == nil {
+		return 0.0
+	}
+	totalProfit := Profit(s)
+
+	// USDの金額ベースから%表記に変換
+	averageProfitPercentage := (totalProfit / s.Signals[0].AccountBalance)
+
+	return averageProfitPercentage
+}
+
 func AveregeLoss(s *execute.SignalEvents) float64 {
 
 	if s == nil {

pkg/analytics/return_dorawdown_ratio.go

@@ -0,0 +1,17 @@
+package analytics
+
+import "v1/pkg/execute"
+
+func ReturnDDRattio(s *execute.SignalEvents) float64 {
+
+	if s == nil {
+		return 0.0
+	}
+
+	np := NetProfit(s)
+	dd := MaxDrawdownUSD(s)
+
+	rdr := np / dd
+
+	return rdr
+}

pkg/analytics/sqn.go

@@ -0,0 +1,63 @@
+package analytics
+
+import (
+	"math"
+	"v1/pkg/execute"
+)
+
+func calculateStandardDeviation(s *execute.SignalEvents) float64 {
+	if s == nil || s.Signals == nil || len(s.Signals) == 0 {
+		return 0.0
+	}
+
+	var profits []float64
+	var buyPrice float64
+
+	for _, signal := range s.Signals {
+		if signal.Side != "BUY" && signal.Side != "SELL" {
+			continue
+		}
+		if signal.Side == "BUY" {
+			buyPrice = signal.Price
+		} else if signal.Side == "SELL" && buyPrice != 0 {
+			profit := (signal.Price - buyPrice) * signal.Size
+			profits = append(profits, profit)
+			buyPrice = 0 // Reset buy price after a sell
+		}
+	}
+
+	// Calculate mean of profits
+	mean := 0.0
+	for _, profit := range profits {
+		mean += profit
+	}
+	mean /= float64(len(profits))
+
+	// Calculate standard deviation of profits
+	variance := 0.0
+	for _, profit := range profits {
+		difference := profit - mean
+		squaredDifference := difference * difference
+		variance += squaredDifference
+	}
+	variance /= float64(len(profits) - 1)
+
+	standardDeviation := math.Sqrt(variance)
+
+	return standardDeviation
+}
+
+func SQN(s *execute.SignalEvents) float64 {
+	if s == nil {
+		return 0.0
+	}
+
+	e := ExpectedValue(s)
+	tt := TotalTrades(s)
+
+	sdv := calculateStandardDeviation(s)
+
+	sqn := math.Sqrt(float64(tt)) * e / sdv
+
+	return sqn
+}

pkg/charts/candle_chart.go

@@ -6,6 +6,7 @@ import (
 	"time"
 	"v1/pkg/data"
 	dbquery "v1/pkg/data/query"
+	"v1/pkg/indicator/indicators"
 	"v1/pkg/management/risk"
 
 	"github.com/go-echarts/go-echarts/v2/charts"
@@ -222,6 +223,171 @@ func klineWithMA() *charts.Kline {
 	return kline
 }
 
+func klineWithDonchain() *charts.Kline {
+	kline := charts.NewKLine()
+
+	x := make([]string, 0)
+	y := make([]opts.KlineData, 0)
+	for i := 0; i < len(kd); i++ {
+		x = append(x, kd[i].date)
+		y = append(y, opts.KlineData{Value: kd[i].data})
+	}
+
+	// Calculate MA20 using talib
+	highdata := make([]float64, len(kd))
+	lowdata := make([]float64, len(kd))
+	for i, k := range kd {
+		highdata[i] = k.data[3]
+		lowdata[i] = k.data[2]
+	}
+
+	donchain := indicators.Donchain(highdata, lowdata, 40)
+
+	// Convert ma20 to []opts.LineData
+	donchainLineHighData := make([]opts.LineData, len(donchain.High))
+	for i, v := range donchain.High {
+		donchainLineHighData[i] = opts.LineData{Value: v}
+	}
+
+	// Add MA20 to the chart
+	donchainLineHigh := charts.NewLine()
+	donchainLineHigh.SetXAxis(x).AddSeries("High", donchainLineHighData)
+
+	kline.Overlap(donchainLineHigh)
+
+	// Convert ma20 to []opts.LineData
+	donchainLineLowData := make([]opts.LineData, len(donchain.Low))
+	for i, v := range donchain.Low {
+		donchainLineLowData[i] = opts.LineData{Value: v}
+	}
+
+	// Add MA20 to the chart
+	donchainLineLow := charts.NewLine()
+	donchainLineLow.SetXAxis(x).AddSeries("Low", donchainLineLowData)
+
+	kline.Overlap(donchainLineLow)
+
+	// Convert ma20 to []opts.LineData
+	donchainLineMidData := make([]opts.LineData, len(donchain.Mid))
+	for i, v := range donchain.Mid {
+		donchainLineMidData[i] = opts.LineData{Value: v}
+	}
+
+	// Add MA20 to the chart
+	donchainLineMid := charts.NewLine()
+	donchainLineMid.SetXAxis(x).AddSeries("Mid", donchainLineMidData)
+
+	kline.Overlap(donchainLineMid)
+
+	kline.SetGlobalOptions(
+		charts.WithTitleOpts(opts.Title{
+			Title: assetName + " " + duration + " " + "Chart",
+		}),
+		charts.WithXAxisOpts(opts.XAxis{
+			SplitNumber: 20,
+		}),
+		charts.WithYAxisOpts(opts.YAxis{
+			Scale: true,
+		}),
+		charts.WithDataZoomOpts(opts.DataZoom{
+			Type:       "inside",
+			Start:      50,
+			End:        100,
+			XAxisIndex: []int{0},
+		}),
+		charts.WithDataZoomOpts(opts.DataZoom{
+			Type:       "slider",
+			Start:      50,
+			End:        100,
+			XAxisIndex: []int{0},
+		}),
+	)
+
+	kline.SetXAxis(x).AddSeries("kline", y)
+	return kline
+}
+
+func klineWithSuperTrend() *charts.Kline {
+	kline := charts.NewKLine()
+
+	x := make([]string, 0)
+	y := make([]opts.KlineData, 0)
+	for i := 0; i < len(kd); i++ {
+		x = append(x, kd[i].date)
+		y = append(y, opts.KlineData{Value: kd[i].data})
+	}
+
+	// Calculate MA20 using talib
+	h := make([]float64, len(kd))
+	l := make([]float64, len(kd))
+	c := make([]float64, len(kd))
+	for i, k := range kd {
+		h[i] = k.data[3]
+		l[i] = k.data[2]
+		c[i] = k.data[1]
+
+	}
+
+	st, _ := indicators.SuperTrend(21, 3.0, h, l, c)
+
+	stLineData := make([]opts.LineData, len(st.SuperTrend))
+	for i, v := range st.SuperTrend {
+		stLineData[i] = opts.LineData{Value: v}
+	}
+
+	stLine := charts.NewLine()
+	stLine.SetXAxis(x).AddSeries("st", stLineData)
+
+	kline.Overlap(stLine)
+
+	// stupLineData := make([]opts.LineData, len(st.UpperBand))
+	// for i, v := range st.SuperTrend {
+	// 	stupLineData[i] = opts.LineData{Value: v}
+	// }
+
+	// stLineHigh := charts.NewLine()
+	// stLineHigh.SetXAxis(x).AddSeries("st", stupLineData)
+
+	// kline.Overlap(stLineHigh)
+
+	// stlowLineData := make([]opts.LineData, len(st.LowerBand))
+	// for i, v := range st.SuperTrend {
+	// 	stlowLineData[i] = opts.LineData{Value: v}
+	// }
+
+	// stLineLow := charts.NewLine()
+	// stLineLow.SetXAxis(x).AddSeries("st", stlowLineData)
+
+	// kline.Overlap(stLineLow)
+
+	kline.SetGlobalOptions(
+		charts.WithTitleOpts(opts.Title{
+			Title: assetName + " " + duration + " " + "Chart",
+		}),
+		charts.WithXAxisOpts(opts.XAxis{
+			SplitNumber: 20,
+		}),
+		charts.WithYAxisOpts(opts.YAxis{
+			Scale: true,
+		}),
+		charts.WithDataZoomOpts(opts.DataZoom{
+			Type:       "inside",
+			Start:      50,
+			End:        100,
+			XAxisIndex: []int{0},
+		}),
+		charts.WithDataZoomOpts(opts.DataZoom{
+			Type:       "slider",
+			Start:      50,
+			End:        100,
+			XAxisIndex: []int{0},
+		}),
+	)
+
+	kline.SetXAxis(x).AddSeries("kline", y)
+	return kline
+}
+
 func klineWithChoppy() *charts.Kline {
 	kline := charts.NewKLine()
 
@@ -299,6 +465,7 @@ func (CandleStickChart) CandleStickChart() {
 		// klineDataZoomInside(),
 		klineDataZoomBoth(),
 		klineWithMA(),
+		klineWithSuperTrend(),
 		klineWithChoppy(),
 	)