data_analysis/十面埋伏分析.js

const logger = require("./utils/logger");
const NumKit = require('./utils/num-kit')
const TimeKit = require('./utils/time-kit')
const ChartKit = require('./utils/chart-kit');
const fs = require('fs').promises;

async function readData() {
  let data = await fs.readFile('./data/k_lines.json', 'utf8')

  return JSON.parse(data)
}

/* 概率学说 */
// 统计过去N根累计涨幅，【有一定关系】
function statisticA(kLines, index) {
  let startK = kLines[index - 12]
  let endK = kLines[index - 1]

  if (!startK || !endK) {
    return 0
  }

  return parseInt(100 * (endK.Close - startK.Open) / startK.Open) + 100
}

// 返回过去一共NK涨幅超过M%【这个有关的】
function statisticB(kLines, index) {
  let count = 0
  for (let i = index - 1; i >= index - 2; i--) {
    let kLine = kLines[i]

    if (!kLines[i - 1]) break

    if (100 * (kLine.Close - kLine.Open) / kLine.Open < 3) continue

    count += 1
  }

  return count
}

/* 形态学说 */

// 如果前一根k线是阴线，并且收了影线，影线涨幅>=实体跌幅*0.732【有用，能过滤60%的交易，但是过滤的交易很多都是能盈利的，所以这个因子只能说保留一下】
function statisticD(_kLines, _index) {
  // let k = kLines[index - 1]
  //
  // if (!k) return 0
  //
  // // 计算实体的跌幅
  // const bodyDecline = k.Open - k.Close;
  //
  // // 如果跌幅小于5%，不适用这个过滤
  // if (100 * (k.Low - k.Open) / k.Open > -10) return 1
  //
  // // 计算下影线的涨幅
  // const lowerShadowGain = Math.min(k.Open, k.Close) - k.Low;
  //
  // // 判断下影线的涨幅是否大于或等于实体的跌幅
  // const hasLongLowerShadow = (lowerShadowGain / k.Low) >= (bodyDecline / k.Open) * 1;
  //
  // // 阴线并且下影线涨幅大于或等于实体跌幅
  // return hasLongLowerShadow ? 1 : 0;

  return 0
}

// 现在应该想一个形态，能过滤一下熊市时的亏损，牛市时的回撤无所谓
// function statisticC(kLines, index) {
//
// }

// 指标过滤
function filter(kLines, index) {
  // 过去N根K的累计涨幅
  let upRateN = statisticA(kLines, index)
  if (upRateN <= 75 || upRateN >= 90) {
    return false
  }

  // 一共NK涨幅超过M%
  if (statisticB(kLines, index) > 0) {
    return false
  }

  return true
}

let realCountMap = {}
function getRealDragonMap(kLinesMap, dayCount, BUY_LIMIT_RATE) {
  let realDragonMap = {}
  for (let symbol in kLinesMap) {
    let kLines = kLinesMap[symbol]

    let index = kLines.length - (dayCount + 1)
    let kLine = kLines[index]
    let prevKline = kLines[index - 1]

    // 开盘第一K不计算
    if (!kLine || !prevKline) continue

    // 指标过滤
    if (!filter(kLines, index)) continue

    let rate = 100 * (kLine.Close - kLine.Open) / kLine.Open
    // let upRate = 100 * (kLine.High - kLine.Open) / kLine.Open

    if (rate > BUY_LIMIT_RATE) {
      kLine.Rate = rate
      kLine.Profit = NumKit.getSubFloat(rate - BUY_LIMIT_RATE, 2)

      // if (upRate > 150) kLine.Profit = 140

      realDragonMap[symbol] = kLine

      if (!realCountMap[symbol]) {
        realCountMap[symbol] = kLine.Profit
      } else {
        realCountMap[symbol] += kLine.Profit
      }
      realCountMap[symbol] = NumKit.getSubFloat(realCountMap[symbol], 2)
    }
  }

  return realDragonMap
}

let fakeCountMap = {}
function getFakeDragonMap(kLinesMap, dayCount, BUY_LIMIT_RATE) {
  let fakeDragonMap = {}
  for (let symbol in kLinesMap) {
    let kLines = kLinesMap[symbol]
    let index = kLines.length - (dayCount + 1)
    let kLine = kLines[index]
    let prevKline = kLines[index - 1]

    // 开盘第一K不计算
    if (!kLine || (!prevKline)) continue

    // 指标过滤
    if (!filter(kLines, index)) continue

    let rate = 100 * (kLine.Close - kLine.Open) / kLine.Open
    if (rate < BUY_LIMIT_RATE) {
      kLine.Rate = rate
      // kLine.Profit = NumKit.getSubFloat(rate > 0 ? rate - BUY_LIMIT_RATE : -BUY_LIMIT_RATE, 2)
      kLine.Profit = NumKit.getSubFloat(rate - BUY_LIMIT_RATE, 2)
      fakeDragonMap[symbol] = kLine

      if (!fakeCountMap[symbol]) {
        fakeCountMap[symbol] = kLine.Profit
      } else {
        fakeCountMap[symbol] += kLine.Profit
      }
      fakeCountMap[symbol] = NumKit.getSubFloat(fakeCountMap[symbol], 2)
    }
  }

  return fakeDragonMap
}

let dataLeft = []
let dataRight = []
let tempLeft = []
let tempRight = []
let dataY = [...Array(200).keys()]
function dragonAnalysis(btcKLines, kLinesMap, dragonMap, dayCount) {
  for (let symbol in dragonMap) {
    let kLines = kLinesMap[symbol]
    let index = kLines.length - (dayCount + 1)

    let x = statisticB(kLines, index)
    let y = dragonMap[symbol].Profit

    // 打印实际的量
    // if (y > 0) {
    //   if (dataRight[x]) {
    //     dataRight[x] += y
    //   } else {
    //     dataRight[x] = y
    //   }
    // } else {
    //   if (dataLeft[x]) {
    //     dataLeft[x] += y
    //   } else {
    //     dataLeft[x] = y
    //   }
    // }

    // 打印倍数
    if (y > 0) {
      if (tempRight[x]) {
        tempRight[x] += y
      } else {
        tempRight[x] = y
      }
    } else {
      if (tempLeft[x]) {
        tempLeft[x] += y
      } else {
        tempLeft[x] = y
      }
    }
    dataRight[x] = (tempLeft[x]?tempRight[x]/Math.abs(tempLeft[x]):0)
    if (dataRight[x] > 10) dataRight[x] = 10
    if (dataRight[x] < 0.5) dataRight[x] = 0.5
  }
}

async function main() {
  let kLinesMap = await readData()

  const BUY_LIMIT_RATE = 0               // 从什么比例入场
  const FIRST_FEW_DAYS = 1               // 第几K的数据，0表示今K，1表示昨K，2表示前K，以此类推
  const BAKE_TEST_DAYS = 800              // 一共回测多少K
  // const FIRST_FEW_DAYS = 710                   // 第几K的数据，0表示今K，1表示昨K，2表示前K，以此类推
  // const BAKE_TEST_DAYS = 1                     // 一共回测多少K


  let btcKLines = kLinesMap['BTC_USDT']
  let totalProfit = 0
  for (let day_count = FIRST_FEW_DAYS; day_count < FIRST_FEW_DAYS + BAKE_TEST_DAYS; day_count++) {
    let btcKline = btcKLines[btcKLines.length - (day_count + 1)]
    let btcKlineDownRate = 100 * (btcKline.Open - btcKline.Low) / btcKline.Open // 可能的回撤计算

    // 赚钱榜
    // logger.info("----------------赚钱榜数据分析----------------")
    let realDragonProfit = 0
    let realDragonMap = getRealDragonMap(kLinesMap, day_count, BUY_LIMIT_RATE)
    for (let symbol in realDragonMap) {
      realDragonProfit += realDragonMap[symbol].Profit
      // logger.info(`${realDragonMap[symbol].Symbol}, ${realDragonMap[symbol].Profit}%`)
    }
    dragonAnalysis(btcKLines, kLinesMap, realDragonMap, day_count)

    // logger.info("----------------亏钱榜数据分析----------------")
    // 亏钱榜
    let fakeDragonProfit = 0
    let fakeDragonMap = getFakeDragonMap(kLinesMap, day_count, BUY_LIMIT_RATE)
    for (let symbol in fakeDragonMap) {
      fakeDragonProfit += fakeDragonMap[symbol].Profit
      // logger.info(`${fakeDragonMap[symbol].Symbol}, ${fakeDragonMap[symbol].Profit}%`)
    }
    dragonAnalysis(btcKLines, kLinesMap, fakeDragonMap, day_count)

    realDragonProfit = NumKit.getSubFloat(realDragonProfit, 2)
    fakeDragonProfit = NumKit.getSubFloat(fakeDragonProfit, 2)
    let realLength = Object.keys(realDragonMap).length
    let fakeLength = Object.keys(fakeDragonMap).length
    let realRate = NumKit.getSubFloat(realLength / (realLength + fakeLength), 2)
    let fakeRate = NumKit.getSubFloat(1 - realRate, 2)
    let expRealProfit = NumKit.getSubFloat(realRate * realDragonProfit, 2)
    let expFakeProfit = NumKit.getSubFloat(fakeRate * fakeDragonProfit, 2)
    let synProfit = NumKit.getSubFloat(expFakeProfit + expRealProfit, 2)
    let avgProfit = NumKit.getSubFloat(synProfit / (realLength + fakeLength), 2)
    let isStopLoss = false
    if ((Object.keys(fakeDragonMap).length !== 0 || Object.keys(realDragonMap).length !== 0)) {
      if (avgProfit < -0.8 || btcKlineDownRate > 0.5) {
        avgProfit = -1
        isStopLoss = true
      }
    } else {
      avgProfit = 0
    }


    let index = kLinesMap['BTC_USDT'].length - (day_count + 1)
    let btcK = kLinesMap['BTC_USDT'][index]
    let dateStr = TimeKit.getTimeByMillisecond(btcK.Time)
    let btcUpRate = NumKit.getSubFloat(100 * (btcK.Close - btcK.Open) / btcK.Open, 2)

    logger.info(`${day_count}根(${dateStr}, ${realLength + fakeLength}只)，赚钱榜(${realLength}只)利润${realDragonProfit}%`
      + `，亏钱榜(${fakeLength}只)利润${fakeDragonProfit}%`
      + `，赚钱榜期望利润${expRealProfit}%，亏钱榜期望利润${expFakeProfit}%，综合利润${synProfit}%，平均每只利润${avgProfit}% ${isStopLoss ? '(止损)' : ''}`
      + `，BTC涨幅${btcUpRate}%`
    )

    totalProfit += avgProfit
    totalProfit = NumKit.getSubFloat(totalProfit, 2)
  }

  let dayProfit = NumKit.getSubFloat(totalProfit / BAKE_TEST_DAYS, 2)
  logger.info(`利润期望值总和：${totalProfit}%，平均根化${dayProfit}%。`)
  // let lastData = []
  // for (let x = 0; x < dataRight.length; x++) {
  //   lastData.push([x, dataRight[x]])
  // }

  let rst = 'option=' + JSON.stringify(ChartKit.printBar(dataY, dataLeft, dataRight), null, 2)
  // let rst = 'option=' + JSON.stringify(ChartKit.printPointChart(lastData), null, 2)
  require('fs').writeFile('./data/option.txt', rst, 'utf8', (err) => {
    if (err) {
      logger.error('写入文件时发生错误:', err);
    } else {
      logger.info('分析结果已写入到 ./data/option.txt');
    }
  });
}

main().catch((error) => {
  logger.error(error.stack);
  process.exitCode = 1;
})