w-trade-solve 1.0.1

package/docs/styles/prettify.css

@@ -0,0 +1,80 @@
+.pln {
+  color: #ddd;
+}
+
+/* string content */
+.str {
+  color: #61ce3c;
+}
+
+/* a keyword */
+.kwd {
+  color: #fbde2d;
+}
+
+/* a comment */
+.com {
+  color: #aeaeae;
+}
+
+/* a type name */
+.typ {
+  color: #8da6ce;
+}
+
+/* a literal value */
+.lit {
+  color: #fbde2d;
+}
+
+/* punctuation */
+.pun {
+  color: #ddd;
+}
+
+/* lisp open bracket */
+.opn {
+  color: #000000;
+}
+
+/* lisp close bracket */
+.clo {
+  color: #000000;
+}
+
+/* a markup tag name */
+.tag {
+  color: #8da6ce;
+}
+
+/* a markup attribute name */
+.atn {
+  color: #fbde2d;
+}
+
+/* a markup attribute value */
+.atv {
+  color: #ddd;
+}
+
+/* a declaration */
+.dec {
+  color: #EF5050;
+}
+
+/* a variable name */
+.var {
+  color: #c82829;
+}
+
+/* a function name */
+.fun {
+  color: #4271ae;
+}
+
+/* Specify class=linenums on a pre to get line numbering */
+ol.linenums {
+  margin-top: 0;
+  margin-bottom: 0;
+  padding-bottom: 2px;
+}

package/g.mjs

@@ -0,0 +1,110 @@
+import fs from 'fs'
+import path from 'path'
+import ott from './src/ott.mjs'
+import wts from './src/WTradeSolve.mjs'
+
+
+async function test() {
+
+    //示範用資料夾, fdOhlc 放 K 線序列, fdParam 放指標參數序列, 各以 `${key}.json` 儲存
+    //  fdData 為求得策略之儲存資料夾, 不存在時由 estimKeys 自動建立
+    let fdOhlc = './tmp/data-ohlc'
+    let fdParam = './tmp/data-param'
+    let fdData = './tmp/data-strategy'
+    fs.rmSync(fdData, { recursive: true, force: true })
+    fs.mkdirSync(fdOhlc, { recursive: true })
+    fs.mkdirSync(fdParam, { recursive: true })
+
+    //st, 設定物件, 由 opt.keySettings 指定取用之鍵
+    //  name 與 interval 用於組出 K 線序列 key(`${name}_price_${interval}`)與縮寫 tid
+    let st = {
+        btc4hr: {
+            name: 'btc',
+            symbol: 'BTCUSDT',
+            interval: '4hr',
+        },
+    }
+
+    //arrOhlc 與 arrParam, 20 根 4hr K 線與對應之指標序列(以 sin/cos 合成之示範資料)
+    let arrOhlc = []
+    let arrParam = []
+    let c = 100
+    for (let i = 0; i < 20; i++) {
+        let time = new Date(Date.UTC(2020, 0, 1) + i * 4 * 3600 * 1000).toISOString().slice(0, 19)
+        let o = c
+        c = c + Math.sin(i * 0.31) * 2 + Math.cos(i * 0.11) * 1.5
+        arrOhlc.push({ time, Open: o, High: Math.max(o, c) + 1, Low: Math.min(o, c) - 1, Close: c })
+        arrParam.push({ time, param: Math.sin(i * 0.17) })
+    }
+    fs.writeFileSync(path.resolve(fdOhlc, 'btc_price_4hr.json'), JSON.stringify(arrOhlc), 'utf8')
+    fs.writeFileSync(path.resolve(fdParam, 'btc_4hr_ma_1day.json'), JSON.stringify(arrParam), 'utf8')
+
+    //keys, 待率定門檻之指標 key, 各 key 於 fdParam 內須有對應之 `${key}.json`
+    let keys = ['btc_4hr_ma_1day']
+
+    //estimKeys, 以 omlPSO 率定[止損, 止盈, 各 key 門檻], 逐次以 runStrategy 回測並取 fitness 最小者
+    //  滿足 thNumTrade / thRWin / thREquivalentCumuProfitOrLossFinalNormYear 三門檻之參數組會存入 fdData
+    let m = await wts.estimKeys(ott, st, fdOhlc, fdParam, arrOhlc[0].time, arrOhlc[19].time, 'long', keys, fdData, {
+        keySettings: 'btc4hr',
+        thsTp: [3], //止盈候選(%), 僅給 1 點使示範較快收斂
+        thsSl: [2], //止損候選(%)
+        thNumTrade: 5, //至少 5 筆交易才存檔
+        thRWin: 0.5, //勝率至少 50% 才存檔
+        thREquivalentCumuProfitOrLossFinalNormYear: 0, //等效年化盈虧至少 0 才存檔
+    })
+
+    //設計變數為[止損, 止盈, 各 key 門檻], 故個數為 2 + keys 個數
+    //  各 key 門檻之解值帶有平移量 10, 大於 0 代表'>'條件、小於 0 代表'<'條件, 還原時扣除平移量
+    //  estimKeys 為隨機求解, 故以下各數值每次執行皆不同, 僅結構固定
+    console.log(m.bestSolution.ps.length, m.bestSolution.ps)
+    // => 3 [
+    //   { ind: 0, value: 0.02 },
+    //   { ind: 0, value: 0.03 },
+    //   { ind: 63, value: -9.799999999999999 }
+    // ]
+
+    //readStrategies, 讀回 fdData 內之策略, tkid 為`${tid}:${交易次數級距}`, 同 tkid 僅保留等效年化盈虧最佳者
+    let ss = wts.readStrategies(fdData, { readContent: true })
+    console.log(ss.map((s) => {
+        return `${s.tkid} → ${s.rEquivalentCumuProfitOrLossFinalNormYear}`
+    }))
+    // => [
+    //   'long ║ ma_1day:1 → 194.67%',
+    //   'long ║ ma_1day:11 → 839.50%',
+    //   'long ║ ma_1day:2 → 644.83%'
+    // ]
+
+    //策略內容含還原後之 conds(門檻已扣除平移量)與回測所用之 settings
+    console.log(ss[0].data.conds, ss[0].data.settings)
+    // => [ { key: 'btc_4hr_ma_1day', sym: '<', th: 0.3 } ] {
+    //   uIni: 1000,
+    //   uTrade: 1,
+    //   rTakeProfit: 0.03,
+    //   rStopLoss: 0.02,
+    //   rFee: 0.0005
+    // }
+
+    //genTid, 策略種類識別碼, 僅由 mode 與 keys 決定, 並將 `${name}_`、`${interval}_` 等樣式縮寫
+    console.log(wts.genTid('btc', '4hr', 'long', keys))
+    // => 'long ║ ma_1day'
+
+    //calcLevelNumTrade, 交易次數之級距代碼, 使不同交易次數規模之策略各自保留最佳者
+    console.log(wts.calcLevelNumTrade(3), wts.calcLevelNumTrade(30), wts.calcLevelNumTrade(300))
+    // => 1 12 102
+
+    //genStrategyFileName, 策略儲存檔名, 為`${tid} ⊙ ${級距} ⊙ ${等效年化盈虧}.json`
+    console.log(wts.genStrategyFileName('btc', '4hr', 'long', keys, {}, { numTrade: 30, rEquivalentCumuProfitOrLossFinalNormYear: '31.25%' }))
+    // => 'long ║ ma_1day ⊙ 12 ⊙ 31.25%.json'
+
+    //calcFitness, 求解所用之目標函數值, 越小越佳, 由勝率(權重 2)與等效年化盈虧(權重 1)組成
+    console.log(wts.calcFitness({ uIni: 1000 }, { numTrade: 30, uEquityFinal: 1200, rWin: '60%', rEquivalentCumuProfitOrLossFinalNormYear: '25%' }))
+    // => 1.3
+
+}
+test()
+    .catch((err) => {
+        console.log('catch', err)
+    })
+
+
+//node g.mjs

package/package.json

@@ -0,0 +1,31 @@
+{
+  "name": "w-trade-solve",
+  "version": "1.0.1",
+  "main": "dist/w-trade-solve.umd.js",
+  "dependencies": {
+    "lodash-es": "^4.18.1",
+    "w-data-tdprovide": "^1.0.4",
+    "w-optimization": "^1.0.22",
+    "w-trade-backtest": "^1.0.6",
+    "wsemi": "^1.8.67"
+  },
+  "devDependencies": {
+    "w-package-tools": "^1.1.12"
+  },
+  "scripts": {
+    "test": "mocha \"test/unit-*.test.mjs\" --parallel --timeout 60000",
+    "deploy": "gh-pages -d docs"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/yuda-lyu/w-trade-solve.git"
+  },
+  "keywords": [
+    "package",
+    "tool",
+    "csv",
+    "nodejs"
+  ],
+  "author": "yuda-lyu(semisphere)",
+  "license": "MIT"
+}

package/script.txt

@@ -0,0 +1,19 @@
+#node toolg/addVersion.mjs
+node toolg/modifyReadme.mjs
+
+node toolg/cleanFolder.mjs
+./node_modules/.bin/jsdoc -c .jsdoc
+
+node toolg/gDocsExams.mjs
+
+node toolg/gDistRollup.mjs
+
+git add .  -A
+git commit -m 'modify: '
+git push origin master:master
+
+npm run deploy
+
+#npm test
+
+#npm publish

package/src/WTradeSolve.mjs

@@ -0,0 +1,29 @@
+import estimFinder from './estimFinder.mjs'
+import estimComps from './estimComps.mjs'
+import estimPicks from './estimPicks.mjs'
+import estimKeys from './estimKeys.mjs'
+import readStrategies from './readStrategies.mjs'
+import genTid from './genTid.mjs'
+import genSid from './genSid.mjs'
+import genStrategyFileName from './genStrategyFileName.mjs'
+import calcLevelNumTrade from './calcLevelNumTrade.mjs'
+import calcFitness from './calcFitness.mjs'
+import cont from './cont.mjs'
+
+
+let r = {
+    estimFinder,
+    estimComps,
+    estimPicks,
+    estimKeys,
+    readStrategies,
+    genTid,
+    genSid,
+    genStrategyFileName,
+    calcLevelNumTrade,
+    calcFitness,
+    cont,
+}
+
+
+export default r

package/src/calcFitness.mjs

@@ -0,0 +1,133 @@
+import cint from 'wsemi/src/cint.mjs'
+import p2r from './p2r.mjs'
+
+
+/**
+ * 計算策略適應值fitness
+ *
+ * 供最佳化求解使用之目標函數值，數值越小代表策略越佳
+ * 由勝率與最終等效年化盈虧兩者組成: 勝率rWin限縮至[0,1]，等效年化盈虧rEquivalentCumuProfitOrLossFinalNormYear限縮至[0,0.5]再正規化至[0,1]，兩者皆轉為越小越好後，以權重2與1加權求和，故無懲罰時fitness落於[0,3]
+ * 交易次數為0時加上懲罰值1000000，最終累計盈虧金額(summary.uEquityFinal-settings.uIni)小於等於0時再加上懲罰值1000000，故兩者皆觸發時可達2000000以上
+ *
+ * Unit Test: {@link https://github.com/yuda-lyu/w-trade-solve/blob/master/test/unit-calcFitness.test.mjs Github}
+ * @function
+ * @param {Object} settings 輸入策略設定物件，需含uIni(初始資金)欄位
+ * @param {Object} summary 輸入回測統計摘要物件，需含numTrade(交易次數)、uEquityFinal(最終權益金額)、rWin(勝率百分比字串)、rEquivalentCumuProfitOrLossFinalNormYear(最終等效年化盈虧百分比字串)欄位
+ * @returns {Number} 回傳適應值數值，越小代表策略越佳
+ * @example
+ *
+ * let settings = { uIni: 1000 }
+ *
+ * //勝率60%, 等效年化盈虧25%(正規化後0.5), fitness = 2*(1-0.6) + 1*(1-0.5) = 1.3
+ * let summary = {
+ *     numTrade: 30,
+ *     uEquityFinal: 1200,
+ *     rWin: '60%',
+ *     rEquivalentCumuProfitOrLossFinalNormYear: '25%',
+ * }
+ * console.log(calcFitness(settings, summary))
+ * // => 1.3
+ *
+ * //無交易且無獲利時, 兩懲罰值皆觸發
+ * let summaryNone = {
+ *     numTrade: 0,
+ *     uEquityFinal: 1000,
+ *     rWin: '',
+ *     rEquivalentCumuProfitOrLossFinalNormYear: '',
+ * }
+ * console.log(calcFitness(settings, summaryNone))
+ * // => 2000003
+ *
+ */
+let calcFitness = (settings, summary) => {
+
+    //numTrade
+    let numTrade = cint(summary.numTrade)
+
+    //uIni
+    let uIni = settings.uIni
+
+    // //uTradeAllMax
+    // let uTradeAllMax = summary.uTradeAllMax
+    // // console.log('uTradeAllMax', uTradeAllMax)
+
+    // //uDrawdownMax
+    // let uDrawdownMax = summary.uDrawdownMax
+
+    //uEquityFinal
+    let uEquityFinal = summary.uEquityFinal
+
+    //uCumuProfitOrLossFinal
+    let uCumuProfitOrLossFinal = uEquityFinal - uIni
+    // console.log('uCumuProfitOrLossFinal', uCumuProfitOrLossFinal)
+
+    //rEquivalentCumuProfitOrLossFinalNormYear, 等效年化報酬率
+    let rEquivalentCumuProfitOrLossFinalNormYear = p2r(summary.rEquivalentCumuProfitOrLossFinalNormYear)
+    rEquivalentCumuProfitOrLossFinalNormYear = Math.min(Math.max(rEquivalentCumuProfitOrLossFinalNormYear, 0), 0.5) //最大限制為年化50% (依實際年化分布調整)
+    rEquivalentCumuProfitOrLossFinalNormYear /= 0.5 //正規化最大值1
+
+    //_rEquivalentCumuProfitOrLossFinalNormYear, 等效年化報酬率越高越好, 須轉換至越低越好
+    let _rEquivalentCumuProfitOrLossFinalNormYear = 1 - rEquivalentCumuProfitOrLossFinalNormYear
+    // console.log('_rEquivalentCumuProfitOrLossFinalNormYear', _rEquivalentCumuProfitOrLossFinalNormYear)
+
+    // //rCumuProfitOrLossFinal
+    // let rCumuProfitOrLossFinal = p2r(summary.rCumuProfitOrLossFinal)
+
+    // //_rCumuProfitOrLossFinal, 盈虧越高須轉越低越好
+    // let _rCumuProfitOrLossFinal = 3000 - Math.max(rCumuProfitOrLossFinal, 0)
+    // if (_rCumuProfitOrLossFinal < 0) {
+    //     throw new Error(`最終盈虧比例[${_rCumuProfitOrLossFinal}]非預期過高`)
+    // }
+    // if (rCumuProfitOrLossFinal <= 0) {
+    //     _rCumuProfitOrLossFinal += 300000 - rCumuProfitOrLossFinal //懲罰值
+    // }
+
+    // //rDrawdownMax
+    // let rDrawdownMax = p2r(summary.rDrawdownMax)
+    // rDrawdownMax = Math.min(Math.max(rDrawdownMax, 0), 1)
+
+    // //_rDrawdownMax, 最大回撤率不用轉換, 越低越好
+    // let _rDrawdownMax = rDrawdownMax
+
+    // //rSharpe
+    // let rSharpe = w.cdbl(summary.rSharpe)
+
+    // //_rSharpe, 夏普值越高須轉越低越好
+    // let _rSharpe = 5 - Math.min(Math.max(rSharpe, 0), 5) //夏普值理論上可無限大, 故須限制範圍
+    // if (_rSharpe < 0) {
+    //     throw new Error(`夏普值[${rSharpe}]非預期過高`)
+    // }
+    // if (rSharpe <= 0) {
+    //     _rSharpe += 100000 - rSharpe //懲罰值
+    // }
+
+    //ratioWin
+    let ratioWin = p2r(summary.rWin)
+    ratioWin = Math.min(Math.max(ratioWin, 0), 1)
+
+    //_ratioWin, 勝率越高越好, 須轉換至越低越好
+    let _ratioWin = 1 - ratioWin
+
+    // //ratioKeep
+    // let ratioKeep = p2r(summary.rTradeAllMax)
+
+    //fitness
+    let fitness = 0
+    // fitness += 3 * _rCumuProfitOrLossFinal
+    // fitness += 2 * _rDrawdownMax
+    // fitness += 2 * _rSharpe
+    fitness += 2 * _ratioWin
+    fitness += 1 * _rEquivalentCumuProfitOrLossFinalNormYear
+    if (numTrade === 0) {
+        fitness += 1000000 //懲罰值
+    }
+    if (uCumuProfitOrLossFinal <= 0) {
+        fitness += 1000000 //懲罰值
+    }
+    // console.log('fitness', fitness)
+
+    return fitness
+}
+
+
+export default calcFitness

package/src/calcLevelNumTrade.mjs

@@ -0,0 +1,92 @@
+import isnum from 'wsemi/src/isnum.mjs'
+import cint from 'wsemi/src/cint.mjs'
+
+
+/**
+ * 計算交易次數所屬級距代碼levelNumTrade
+ *
+ * 交易次數過少之策略統計意義不足，過多則屬高頻，故以級距分群，使不同交易次數規模之策略各自保留最佳者
+ * 級距對應為: <=0為0，1-5為1，6-9為2，10-24為11，25-49為12，50-74為13，75-99為14，100-249為101，250-499為102，500-749為103，750-999為104，1000-1999為1001，2000-2999為1002，3000-3999為1003，4000-4999為1004，>=5000為100
+ * numTrade非數值時throw
+ *
+ * Unit Test: {@link https://github.com/yuda-lyu/w-trade-solve/blob/master/test/unit-calcLevelNumTrade.test.mjs Github}
+ * @function
+ * @param {Number} numTrade 輸入交易次數數值
+ * @returns {Number} 回傳級距代碼數值
+ * @example
+ *
+ * console.log(calcLevelNumTrade(0))
+ * // => 0
+ *
+ * console.log(calcLevelNumTrade(3))
+ * // => 1
+ *
+ * console.log(calcLevelNumTrade(30))
+ * // => 12
+ *
+ * console.log(calcLevelNumTrade(8000))
+ * // => 100
+ *
+ */
+let calcLevelNumTrade = (numTrade) => {
+
+    if (!isnum(numTrade)) {
+        throw new Error(`numTrade[${numTrade}] is not a number`)
+    }
+    numTrade = cint(numTrade)
+
+    let levelNumTrade = 0
+    if (numTrade <= 0) {
+        levelNumTrade = 0
+    }
+    else if (numTrade <= 5) {
+        levelNumTrade = 1
+    }
+    else if (numTrade <= 10 - 1) {
+        levelNumTrade = 2
+    }
+    else if (numTrade <= 25 - 1) {
+        levelNumTrade = 11
+    }
+    else if (numTrade <= 50 - 1) {
+        levelNumTrade = 12
+    }
+    else if (numTrade <= 75 - 1) {
+        levelNumTrade = 13
+    }
+    else if (numTrade <= 100 - 1) {
+        levelNumTrade = 14
+    }
+    else if (numTrade <= 250 - 1) {
+        levelNumTrade = 101
+    }
+    else if (numTrade <= 500 - 1) {
+        levelNumTrade = 102
+    }
+    else if (numTrade <= 750 - 1) {
+        levelNumTrade = 103
+    }
+    else if (numTrade <= 1000 - 1) {
+        levelNumTrade = 104
+    }
+    else if (numTrade <= 2000 - 1) {
+        levelNumTrade = 1001
+    }
+    else if (numTrade <= 3000 - 1) {
+        levelNumTrade = 1002
+    }
+    else if (numTrade <= 4000 - 1) {
+        levelNumTrade = 1003
+    }
+    else if (numTrade <= 5000 - 1) {
+        levelNumTrade = 1004
+    }
+    else {
+        levelNumTrade = 100
+    }
+
+    return levelNumTrade
+}
+
+
+export default calcLevelNumTrade

package/src/cont.mjs

@@ -0,0 +1,22 @@
+/**
+ * 共用常數
+ *
+ * dlmSeps為tid與sid內各段(mode與各key或各cond)之分隔字串
+ * dlmPkgs為策略檔名內各段(tid、levelNumTrade、rEquivalentCumuProfitOrLossFinalNormYear)之分隔字串
+ *
+ * @name cont
+ * @const
+ * @type {Object}
+ * @example
+ *
+ * console.log(cont)
+ * // => { dlmSeps: ' ║ ', dlmPkgs: ' ⊙ ' }
+ *
+ */
+let r = {
+    dlmSeps: ' ║ ',
+    dlmPkgs: ' ⊙ ',
+}
+
+
+export default r

package/src/estimComps.mjs

@@ -0,0 +1,118 @@
+import get from 'lodash-es/get.js'
+import map from 'lodash-es/map.js'
+import size from 'lodash-es/size.js'
+import cint from 'wsemi/src/cint.mjs'
+import isestr from 'wsemi/src/isestr.mjs'
+import randomIntsNdpRange from 'wsemi/src/randomIntsNdpRange.mjs'
+import sep from 'wsemi/src/sep.mjs'
+import estimPicks from './estimPicks.mjs'
+
+
+/**
+ * 依指標組成comps隨機挑選keys，再率定各key之門檻與止盈止損，求解最佳策略
+ *
+ * comps為以逗號分隔之3個數字字串，依序代表由一般類(keysNorm)、指數類(keysIndex)與成交量類(keysVolumn)各隨機挑選之key個數，例如'2,1,0'代表挑2個一般類、1個指數類與0個成交量類
+ * 各類皆以randomIntsNdpRange不重複隨機取樣，故同一comps每次執行所挑之keys不同
+ * comps非3段時throw，其餘檢核與分類邏輯同estimPicks
+ *
+ * Unit Test: {@link https://github.com/yuda-lyu/w-trade-solve/blob/master/test/unit-estimComps.test.mjs Github}
+ * @function
+ * @param {Function} ott 輸入時區時間函數，傳入時間字串回傳dayjs時間物件，可用src/ott.mjs
+ * @param {Object} st 輸入設定物件，需可由opt.keySettings取得name、symbol與interval欄位
+ * @param {String} fdOhlc 輸入儲存K線(ohlc)序列資料夾字串
+ * @param {String} fdParam 輸入儲存指標參數序列資料夾字串
+ * @param {String} timeStart 輸入回測起始時間字串，格式'YYYY-MM-DDTHH:mm:ss'
+ * @param {String} timeEnd 輸入回測結束時間字串，格式'YYYY-MM-DDTHH:mm:ss'
+ * @param {String} mode 輸入交易方向字串，可選'long'或'short'
+ * @param {String} comps 輸入指標組成字串，為逗號分隔之3個數字，例如'2,1,0'
+ * @param {String} fdData 輸入儲存策略資料夾字串，不存在時自動建立
+ * @param {Object} [opt={}] 輸入設定物件，預設{}，全部欄位皆傳遞至estimPicks
+ * @returns {Promise} 回傳Promise，resolve為undefined
+ * @example
+ *
+ * import ott from './src/ott.mjs'
+ *
+ * let st = {
+ *     btc4hr: { name: 'btc', symbol: 'BTCUSDT', interval: '4hr' },
+ * }
+ *
+ * //comps='2,1,0', 挑2種一般類、1種指數類與0種成交量類
+ * await estimComps(ott, st, './data/ohlc', './data/param', '2022-07-01T00:00:00', '2025-04-08T00:00:00', 'long', '2,1,0', './data/strategy', {
+ *     keySettings: 'btc4hr',
+ * })
+ *
+ */
+let estimComps = async (ott, st, fdOhlc, fdParam, timeStart, timeEnd, mode, comps, fdData, opt = {}) => {
+
+    if (!isestr(fdOhlc)) {
+        throw new Error(`invalid fdOhlc[${fdOhlc}]`)
+    }
+    if (!isestr(fdParam)) {
+        throw new Error(`invalid fdParam[${fdParam}]`)
+    }
+    if (!isestr(timeStart)) {
+        throw new Error(`invalid timeStart[${timeStart}]`)
+    }
+    if (!isestr(timeEnd)) {
+        throw new Error(`invalid timeEnd[${timeEnd}]`)
+    }
+    if (mode !== 'long' && mode !== 'short') {
+        throw new Error(`invalid mode[${mode}]`)
+    }
+    if (!isestr(comps)) {
+        throw new Error(`invalid comps[${comps}]`)
+    }
+    if (!isestr(fdData)) {
+        throw new Error(`invalid fdData[${fdData}]`)
+    }
+
+    //cs, 例如comps='2,1,0', 此為挑2種norm, 1種index, 0種volumn
+    let cs = sep(comps, ',')
+    if (size(cs) !== 3) {
+        throw new Error(`comps[${comps}]非預期`)
+    }
+    cs = map(cs, cint)
+    // console.log('cs', cs)
+
+    //pkn
+    let pkn = (arr, n) => {
+        let up = size(arr) - 1
+        let ks = randomIntsNdpRange(0, up, n)
+        let rs = map(ks, (k) => {
+            return get(arr, k)
+        })
+        return rs
+    }
+
+    //funPickKeys
+    let funPickKeys = ({ keysNorm, keysIndex, keysVolumn }) => {
+        let keys = []
+        if (cs[0] >= 1) {
+            keys = [
+                ...keys,
+                ...pkn(keysNorm, cs[0]),
+            ]
+        }
+        if (cs[1] >= 1) {
+            keys = [
+                ...keys,
+                ...pkn(keysIndex, cs[1]),
+            ]
+        }
+        if (cs[2] >= 1) {
+            keys = [
+                ...keys,
+                ...pkn(keysVolumn, cs[2]),
+            ]
+        }
+        // console.log('keys', keys)
+        return keys
+    }
+
+    //estimPicks
+    await estimPicks(ott, st, fdOhlc, fdParam, timeStart, timeEnd, mode, funPickKeys, fdData, opt)
+
+}
+
+
+export default estimComps