conversion d’un indicateur tradingview Bjorgum Double Tap

Forums › ProRealTime forum Français › Support ProBuilder › conversion d’un indicateur tradingview Bjorgum Double Tap

Viewing 2 posts - 1 through 2 (of 2 total)
  • 02/07/2023 at 8:15 AM #209270
    dridri

    This source code is subject to the terms of the Mozilla Public License 2.0 at https://mozilla.org/MPL/2.0/
    // © Bjorgum

    // ________________________________________________________________
    // |\______________________________________________________________/|
    // || ________________ ||
    // || ___ __ )_____(_)___________________ ____ ________ ___ ||
    // || __ __ |____ /_ __ \_ ___/_ __ / / / /_ ____ \ ||
    // || _ /_/ /____ / / /_/ / / _ /_/ // /_/ /_ / / / / / ||
    // || /_____/ ___ / \____//_/ _\__, / \__,_/ /_/ /_/ /_/ ||
    // || /___/ /____/ ||
    // ||______________________________________________________________||
    // |/______________________________________________________________\|

    //@version=5
    // @strategy_alert_message {{strategy.order.alert_message}}

    strategy(
    title = “Bjorgum Double Tap”,
    shorttitle = “Bj Double Tap”,
    overlay = true,
    max_lines_count = 500,
    max_labels_count = 500,
    precision = 3,
    default_qty_type = strategy.cash,
    commission_value = 0.04,
    commission_type = strategy.commission.percent,
    slippage = 1,
    currency = currency.USD,
    default_qty_value = 1000,
    initial_capital = 1000)

    // ══════════════════════════════════ //
    // —————> Immutable Constants <—————— // // ══════════════════════════════════ // string useStratTip = “Enables or disables the strategy tester allowing a change between either an indicator or a strategy.” string dLongTip = “Detect long setups.” string dShortTip = “Detect short setups.” string FLIPTip = “Allow entry in the opposite bias while already in a position.” string startTip = “Start date & time to begin backtest period. Useful for beginning new bot. eg. Set time to now to make broker emulator in a flat position with the proper starting captial before setting alerts” string endTip = “End date & time to stop searching for setups for back testing.” string tolTip = “The difference in height allowable for the signifcant points of the pattern expressed as a percent of the pattern height. Example: The points can vary in height by 15% of the pattern height from one another.” string lenTip = “The length used to calcuate significant points to form pivots for pattern detection. Example: The highest or lowest point in 50 bars.” string fibTip = “The fib target extension projected from the neckline of the pattern in the direction of the pattern bias expressed as a percent. Example: 100% is a 1:1 measurment of the height from the pattern neckline.” string stopPerTip = “The fib extension of the pattern height measured from the point of invalidation. Example: 0% would be the high point of a double top. 50% would be halfway between the top and the neckline.” string offsetTip = “The number of bars lines are extended into the future during an ongoing pattern.” string atrStopTip = “Enables an ATR trailing stop once the target extension is breached. NOTE: This disables a take profit order in the strategy format.” string atrLenTip = “The number of bars used in the ATR calculation.” string atrMultTip = “The multiplier of the ATR value to subtract from the swing low or swing high point. Example: 1 is 100% of the ATR, 2 is 2x the ATR value.” string lookbackTip = “The number of bars to look back to find a swing high or swing low to be used in the trailing stop calculation. Example: 1 ATR subtracted from the lowest point in 5 bars. 1 would use the lowest point within the last bar.” string tableTip = “Show the data table for trade limit levels during an active trade. (table will only show when a pattern is present on the chart, or in bar replay).” string labelTip = “Updates the double top/bottom label with ‘Success’ or ‘Failure’ and updates color based on the outcome of the pattern.” string thirdTip = “Where would you like to send your alerts?” string pPhraseTip = “A custom passphrase to authenticate your json message with a touch more security.” string aTronKeyTip = “The name of your Alertatron API keys. (Add the ticker in brackets). Example: MyKeys(XBTUSD).” string tickerTip = “The ticker to be traded when using Trading Connector” string LongTip = “3Commas start long deal bot keys.” string LongEndTip = “3Commas end long deal bot keys.” string ShortTip = “3Commas start short deal bot keys.” string ShortEndTip = “3Commas end short deal bot keys.” string dt = “Double Top” string db = “Double Bottom” string suc = ” – Success” string fail = ” – Failure” string winStr = “Target reached! 💰” string loseStr = “Stopped out… 🤷‍♂” string tabPerc = “{0, number, #.##}\n({1, number, #.##}%)” string tcStop = “slmod slprice={0} tradeid={1}” string dExit = “‘{‘\”content\”: \”Bjorgum {0}\\n\\n\\t'{{ticker}}' '{{interval}}'\\n\\n\\t{1}\”‘}'” string S1 = “tiny” , string P1 = “top” string S2 = “small” , string P2 = “middle” string S3 = “normal” , string P3 = “bottom” string S4 = “large” , string P4 = “left” string S5 = “huge” , string P5 = “center” string S6 = “auto” , string P6 = “right” var string tnB = “” , string A1 = “Custom Json” string altStr = “” , string A2 = “Trading Connector” string tUp = “” , string A3 = “Alertatron” string dCordWin = “” , string A4 = “3Commas” string dCordLose = “” , string A5 = “Discord” float pos = strategy.position_size int sync = bar_index bool confirm = barstate.isconfirmed var int dir = na var float lmt = na var float stp = na string altExit = na bool FLAT = pos == 0 bool LONG = pos > 0
    bool SHORT = pos < 0
    var int tradeId = 0

    color col1 = color.new(#b2b5be, 15)
    color col2 = color.new(#b2b5be, 87)
    color col3 = color.new(#ffffff, 0)
    color col4 = color.new(#17ff00, 15)
    color col5 = color.new(#ff0000, 15)
    color col6 = color.new(#ff5252, 0)

    var matrix logs = matrix.new (5, 3)
    var line [] zLines = array.new_line (5)
    var line [] tLines = array.new_line (5)
    var line [] bLines = array.new_line (5)
    var label[] bullLb = array.new_label ()
    var label[] bearLb = array.new_label ()

    int timeStart = timestamp(“01 Jan 2000”)
    int timeEnd = timestamp(“01 Jan 2099”)

    // ══════════════════════════════════ //
    // —————————> User Input <——————————— // // ══════════════════════════════════ // string GRP1 = “════  Detection and Trade Parameters  ════” bool useStrat = input.bool (true , “Use Strategy” , group= GRP1, tooltip= useStratTip) bool dLong = input.bool (true , “Detect Bottoms” , group= GRP1, tooltip= dLongTip ) bool dShort = input.bool (true , “Detect Tops” , group= GRP1, tooltip= dShortTip ) bool FLIP = input.bool (true , “Flip Trades” , group= GRP1, tooltip= FLIPTip ) float tol = input.float (15 , “Pivot Tolerance” , group= GRP1, tooltip= tolTip , minval= 1) int len = input.int (50 , “Pivot Length” , group= GRP1, tooltip= lenTip , minval= 1) float fib = input.float (100 , “Target Fib” , group= GRP1, tooltip= fibTip , minval= 0) int stopPer = input.int (0 , “Stop Loss Fib” , group= GRP1, tooltip= stopPerTip ) int offset = input.int (30 , “Line Offset” , group= GRP1, tooltip= offsetTip , minval= 0) string GRP2 = “═══════════ Time Filter ═══════════” int startTime = input.time(timeStart , “Start Filter” , group= GRP2, tooltip= startTip) int endTime = input.time(timeEnd , “End Filter” , group= GRP2, tooltip= endTip ) string GRP3 = “══════════ Trailing Stop ══════════” bool atrStop = input.bool (false , “Use Trail Stop” , group= GRP3, tooltip= atrStopTip ) int atrLength = input.int (14 , “ATR Length” , group= GRP3, tooltip= atrLenTip , minval= 1) float atrMult = input.float (1 , “ATR Multiplier” , group= GRP3, tooltip= atrMultTip , minval= 0) int lookback = input.int (5 , “Swing Lookback” , group= GRP3, tooltip= lookbackTip, minval= 1) string GRP5 = “════════════ Colors ════════════” color col = input.color (col1 , “Lines        ” , group= GRP5, inline= “41”) color zCol = input.color (col3 , “Patterns       ” , group= GRP5, inline= “42”) int hWidth = input.int (1 , “” , group= GRP5, inline= “41”, minval= 1) int zWidth = input.int (1 , “” , group= GRP5, inline= “42”, minval= 1) color colf = input.color (col2 , “Stop Fill” , group= GRP5) color tCol = input.color (col4 , “Target Color” , group= GRP5) color sCol = input.color (col5 , “Stop Color” , group= GRP5) color trailCol = input.color (col6 , “Trail Color” , group= GRP5) string GRP6 = “═════════  Table and Label  ═════════” bool showTable = input.bool (true , “Show Table” , group= GRP6, tooltip= tableTip) bool setLab = input.bool (true , “Update Label” , group= GRP6, tooltip= labelTip) string labSize = input.string(“small” , “Label Text Size” , group= GRP6, options= [S1, S2, S3, S4, S5, S6]) string textSize = input.string(“normal” , “Table Text Size” , group= GRP6, options= [S1, S2, S3, S4, S5, S6]) string tableYpos = input.string(“bottom” , “Table Position” , group= GRP6, options= [P1, P2, P3]) string tableXpos = input.string(“right” , “” , group= GRP6, options= [P4, P5, P6]) string GRP7 = “══════════ Alert Strings ══════════” string thirdParty = input.string(A1 , “3rd Party” , group= GRP7, tooltip= thirdTip, options= [A1, A2, A3, A4, A5]) string pPhrase = input.string(“1234” , “Json Passphrase” , group= GRP7, tooltip= pPhraseTip ) string aTronKey = input.string(“myKeys” , “Alertatron Key” , group= GRP7, tooltip= aTronKeyTip) string tcTicker = input.string(“” , “TC Ticker” , group= GRP7, tooltip= tickerTip ) string c3Long = input.string(“” , “3Comma Long” , group= GRP7, tooltip= LongTip ) string c3LongEnd = input.string(“” , “3Comma Long End” , group= GRP7, tooltip= LongEndTip ) string c3Short = input.string(“” , “3Comma Short” , group= GRP7, tooltip= ShortTip ) string c3ShortEnd = input.string(“” , “3Comma Short End”, group= GRP7, tooltip= ShortEndTip) // ══════════════════════════════════ // // ————> Variable Calculations <————— // // ══════════════════════════════════ // bool dif = stopPer != 0 int set = sync + offset float atr = ta.atr (14) float sLow = ta.lowest (lookback) – (atr * atrMult) float sHigh = ta.highest (lookback) + (atr * atrMult) float pivHigh = ta.highest (len) float pivLows = ta.lowest (len) float hbar = ta.highestbars (len) float lbar = ta.lowestbars (len) // ══════════════════════════════════ // // ———> Functional Declarations <———— // // ══════════════════════════════════ // High(m) =>
    float result = (m == 1 ? high : low)

    Low(m) =>
    float result = (m == 1 ? low : high)

    perD(_p) =>
    float result = (_p – close) / close * 100

    _coords(_x, _i) =>
    x = matrix.get (_x, _i, 0)
    y = matrix.get (_x, _i, 1)
    [int(x), y]

    _arrayLoad(_x, _max, _val) =>
    array.unshift (_x, _val)
    if array.size (_x) > _max
    array.pop (_x)

    _matrixPush(_mx, _max, _row) =>
    matrix.add_row(_mx, matrix.rows (_mx), _row)
    if matrix.rows (_mx) > _max
    matrix.remove_row (_mx, 0)

    _mxLog(_cond, _x, _y) =>
    float[] _row = array.from (sync, _y, 0)
    if _cond
    _matrixPush (_x, 5, _row)

    _mxUpdate(_cond, _dir, _x, y) =>
    int m = _dir ? 1 : -1
    int _end = matrix.rows (_x) -1
    if _cond and y * m > matrix.get (_x, _end, 1) * m
    matrix.set (_x, _end, 0, sync)
    matrix.set (_x, _end, 1, y)

    _extend(_x, _len) =>
    for l in _x
    line.set_x2(l, _len)

    _hLine(_l, x2, y2, y3, y4, y5, _t) =>
    line l1 = line.new (x2 , y2, set, y2, color= col, width= hWidth)
    line l2 = line.new (x2 , y4, set, y4, color= col, width= hWidth)
    array.set (_l , 3, l1)
    array.set (_l , 2, l2)
    array.set (_l , 1, line.new (x2 , y3, set, y3, color= col, width= hWidth))
    array.set (_l , 0, line.new (sync-1, _t, set, _t, color= col, width= hWidth))
    linefill.new (l1 , l2, colf)
    if stopPer != 0
    array.set (_l, 4, line.new (sync-1, y5, set, y5, color= col, width= hWidth))

    _zLine(x1, y1, x2, y2, x3, y3, x4, y4) =>
    array.set (zLines, 3, line.new (x1, y1, x2 , y2 , color= zCol, width= zWidth))
    array.set (zLines, 2, line.new (x2, y2, x3 , y3 , color= zCol, width= zWidth))
    array.set (zLines, 1, line.new (x3, y3, x4 , y4 , color= zCol, width= zWidth))
    array.set (zLines, 0, line.new (x4, y4, sync, close, color= zCol, width= zWidth))

    _label(x, y, m) =>
    m > 0 ?
    _arrayLoad (bearLb, 1, label.new (x, y, dt, color= color(na), style= label.style_label_down, textcolor= col, size= labSize)) :
    _arrayLoad (bullLb, 1, label.new (x, y, db, color= color(na), style= label.style_label_up, textcolor= col, size= labSize))

    _labelUpdate(_x, _y, m) =>
    if (_x or _y) and setLab
    label lab = array.get (m > 0 ? bearLb : bullLb, 0)
    string oStr = (m > 0 ? dt : db)
    string nStr = oStr + (_x ? suc : fail)
    label.set_text (lab, nStr)
    label.set_textcolor (lab, _x ? tCol : sCol)

    _atrTrail(_cond, _lt, _s, m) =>
    var float _stop = na
    var bool _flag = na
    var bool _trail = na
    _flag := _cond
    _stop := _s
    _trail := _flag ? false : _trail
    if atrStop and useStrat
    if _lt
    _flag := false
    _trail := true
    _stop := m == -1 ? _lt ? sLow : math.max(_stop, sLow) : _stop
    _stop := m == 1 ? _lt ? sHigh : math.min(_stop, sHigh) : _stop
    if High(m) * m > _stop * m
    _flag := true
    _trail := false
    [_flag, _stop, _trail]

    _inTrade(_cond, _x, _e, m) =>
    var bool _flag = na
    var float _stop = na
    var float _limit = na
    line l1 = array.get (_x, 0)
    float lp = line.get_price(l1, sync)
    line l2 = array.get (_x, dif ? 4 : 2)
    float ls = line.get_price(l2, sync)
    bool win = Low (m) * m <= lp * m and not _e bool lose = High(m) * m >= ls * m and not _e
    _flag := _cond
    _stop := _e ? ls : _stop
    _limit := _e ? lp : _limit
    if win or lose
    _flag := true
    _extend (_x , sync)
    _labelUpdate (win , lose, m)
    line.set_color (win ? l1 : l2, win ? tCol : sCol)
    array.fill (_x , na)
    array.fill (zLines, na)
    [_f, _s, _t] = _atrTrail (_flag , win , _stop, m)
    _flag := atrStop ? _f : _flag
    _stop := _t and _s * m < _stop * m and confirm ? _s : _stop [_flag, _stop, _t, _limit] _double(_cond, _l, _x, m) =>
    var bool _flag = na
    int _rows = matrix.rows (_x)
    _flag := _cond
    if _flag
    [x1, y1] = _coords (_x , _rows – 5)
    [x2, y2] = _coords (_x , _rows – 4)
    [x3, y3] = _coords (_x , _rows – 3)
    [x4, y4] = _coords (_x , _rows – 2)
    bool traded = matrix.get (_x , _rows – 2, 2)
    float height = math.avg (y2 , y4) – y3
    float _high = y2 + height * (tol/ 100)
    float _low = y2 – height * (tol/ 100)
    float _t = y3 – height * (fib/ 100)
    float y5 = y2 * m < y4 * m ? y2 : y4 float y6 = y2 * m > y4 * m ? y2 : y4
    float y7 = y6 – height *(stopPer/100)
    bool result = y1*m < y3*m and y4*m <= _high*m and y4*m >= _low*m and close*m < y3*m and not (close[1]*m < y3*m) and not traded if result and _flag and (m > 0 ? dShort : dLong)
    _hLine (_l, x2, y5, y3, y6, y7, _t)
    _zLine (x1, y1, x2, y2, x3, y3, x4, y4)
    _label (x4, y6, m)
    matrix.set (_x, _rows – 2, 2, 1)
    _flag := false
    _flag

    _scan(_l, _x, m) =>
    var bool _cond = true
    _cond := _double (_cond, _l, _x, m)
    bool enter = _cond[1] and not _cond
    [f,s,t,l] = _inTrade (_cond, _l, enter, m)
    _cond := f
    _extend(_l, set)
    [f,s,t,l]

    _populate(_n, _x, _i, _col) =>
    for [i, _a] in _x
    if not na(_a)
    table.cell(table_id = _n, column = _i ,
    row = i, bgcolor = na ,
    text = _a, text_color = _col,
    text_size = textSize)

    // ══════════════════════════════════ //
    // ————————> Logical Order <————————— // // ══════════════════════════════════ // dir := not hbar ? 1 : not lbar ? 0 : dir bool dirUp = dir != dir[1] and dir bool dirDn = dir != dir[1] and not dir bool setUp = not hbar and dir bool setDn = not lbar and not dir _mxLog (dirUp or dirDn, logs, dirUp ? pivHigh : pivLows) _mxUpdate (setUp or setDn, dir, logs, setUp ? pivHigh : pivLows) [bear,ss,ts,sl] = _scan(tLines, logs, 1) [bull,ls,tl,ll] = _scan(bLines, logs, -1) bool st = SHORT ? ts : false bool lt = LONG ? tl : false bool sell = bear[1] and not bear bool buy = bull[1] and not bull color ssCol = st or st[1] ? trailCol : na color lsCol = lt or lt[1] ? trailCol : na bool longEntry = buy and (FLAT or (SHORT and FLIP)) bool shortEntry = sell and (FLAT or (LONG and FLIP)) bool dateFilter = time >= startTime and time <= endTime tradeId += longEntry or shortEntry ? 1 : 0 lmt := atrStop ? na : shortEntry ? sl : longEntry ? ll : lmt stp := shortEntry or SHORT and atrStop ? ss : longEntry or LONG and atrStop ? ls : stp plot (atrStop ? ss : na, “Short Stop”, ssCol, style= plot.style_linebr) plot (atrStop ? ls : na, “Long Stop”, lsCol, style= plot.style_linebr) bgcolor (not dateFilter ? color.new(color.red,80) : na, title= “Filter Color”) // ══════════════════════════════════ // // —————————> Data Display <————————— // // ══════════════════════════════════ // if showTable string tls = bull ? na : str.format(tabPerc, ls, perD(ls)) string tss = bear ? na : str.format(tabPerc, ss, perD(ss)) string tll = bull ? na : str.format(tabPerc, ll, perD(ll)) string tsl = bear ? na : str.format(tabPerc, sl, perD(sl)) string[] titles = array.from(na, bull ? na : “Bullish”, bear ? na : “Bearish”) string[] stops = array.from(“Stop” , tls, tss) string[] limtis = array.from(“Target”, tll, tsl) table bjTab = table.new(tableYpos + “_” + tableXpos, 3, 3, border_color= color.new(color.gray, 60), border_width= 1) if not bear or not bull _populate(bjTab, titles, 0, color.white) _populate(bjTab, stops, 1, color.red) if not (na(ll) or lt) or not (na(sl) or st) _populate(bjTab, limtis, 2, color.green) // ══════════════════════════════════ // // ——————> String Variables <———————— // // ══════════════════════════════════ // bool cSon = thirdParty == A1 bool tCon = thirdParty == A2 bool aTron = thirdParty == A3 bool c3 = thirdParty == A4 bool dCord = thirdParty == A5 if cSon and useStrat string json = “‘{‘ \n \”passphrase\”: \”{0}\”, \n \”time\”: ‘\”{{timenow}}\”‘, \n \”ticker\”: ‘\”{{ticker}}\”‘, \n \”plot\”: ‘{‘ \n \”stop_price\”: {1, number, #.########}, \n \”limit_price\”: {2, number, #.########} \n ‘}’, \n \”strategy\”: ‘{‘ \n \”position_size\”: ‘{{strategy.position_size}}’, \n \”order_action\”: ‘\”{{strategy.order.action}}\”‘, \n \”market_position\”: ‘\”{{strategy.market_position}}\”‘, \n \”market_position_size\”: ‘{{strategy.market_position_size}}’, \n \”prev_market_position\”: ‘\”{{strategy.prev_market_position}}\”‘, \n \”prev_market_position_size\”: ‘{{strategy.prev_market_position_size}}’ \n ‘}’ \n’}'” altStr := str.format(json, pPhrase, stp, lmt) if tCon and useStrat string tcTrade = “‘{{strategy.order.action}}’ tradesymbol={0} tradeid={1}” + (atrStop ? “” : ‘ tpprice={2, number, #.########}’) + ‘ slprice={3, number, #.########}’ altStr := str.format(tcTrade, tcTicker, tradeId, lmt, stp) tUp := str.format(tcStop, stp, tradeId) if aTron and useStrat string altEnt = aTronKey + ” ‘{‘\ncancel(which=all);\nmarket(position='{{strategy.position_size}}’);\n” string altEnd = “‘}’\n#bot” string altBrkt = (atrStop ? “stopOrder(” : “stopOrTakeProfit(“) + (atrStop ? “” : “tp=@{0, number, #.########}, “) + (atrStop ? “offset=@” : “sl=@”) + “{1, number, #.########}, position=0, reduceOnly=true” + (atrStop ? “, tag=trail” : “”) + “);\n” string enter = altEnt + altBrkt + altEnd string exit = altEnt + altEnd altStr := str.format(enter, lmt, stp) altExit := na(altExit) ? exit : altExit string stopUpdate = aTronKey + ” ‘{‘\ncancel(which=tagged, tag=trail);\n” + altBrkt + altEnd tUp := atrStop ? str.format(stopUpdate, lmt, stp) : tUp if dCord and useStrat tnB := longEntry ? db : shortEntry ? dt : tnB string postTrade = “‘{‘\”content\”: \”🚨 Bjorgum {0} detected 🚨\\n\\n\\t'{{ticker}}' '{{interval}}'\\n\\n\\t" + (atrStop ? "" : "🎯 Target: {1, number, #.########}\\n\\t") + "🛑 Stop: {2, number, #.########}\”‘}'” altStr := str.format(postTrade, tnB, lmt, stp) dCordWin := str.format(dExit, tnB, winStr) dCordLose := str.format(dExit, tnB, loseStr) if c3 and useStrat c3Long := SHORT and buy ? str.format(“[{0}, {1}]”, c3ShortEnd, c3Long) : c3Long c3Short := LONG and sell ? str.format(“[{0}, {1}]”, c3LongEnd, c3Short) : c3Short // ══════════════════════════════════ // // ——————> Strategy Execution <—————— // // ══════════════════════════════════ // strategy.entry(“Long” , strategy.long , comment= “Long”, when= useStrat and longEntry and dateFilter, alert_message= c3 ? c3Long : altStr) strategy.entry(“Short”, strategy.short, comment= “Short”, when= useStrat and shortEntry and dateFilter, alert_message= c3 ? c3Short : altStr) strategy.exit(“Long Exit”, “Long”, stop = stp, limit = lmt, comment = “L Exit”, alert_message = c3 ? c3LongEnd : aTron ? altExit : tCon ? “closelong” : dCord ? na : altStr, alert_profit = dCord ? dCordWin : na, alert_loss = dCord ? dCordLose : na) strategy.exit(“Short Exit”, “Short”, stop = stp, limit = lmt, comment = “S Exit”, alert_message = c3 ? c3ShortEnd : aTron ? altExit : tCon ? “closeshort” : dCord ? na : altStr, alert_profit = dCord ? dCordWin : na, alert_loss = dCord ? dCordLose : na) // ══════════════════════════════════ // // —————> Alert Functionality <—————— //
    // ══════════════════════════════════ //

    if (lt and ls != ls[1] or st and ss != ss[1]) and (tCon or aTron)
    alert(tUp, alert.freq_once_per_bar_close)

    if not useStrat and (buy or sell)
    alert((buy ? db : dt) + ‘ Detected’, alert.freq_once_per_bar)

    // ____ __ _ ____
    // ( __)( ( \( \
    // ) _) / / ) D (
    // (____)\_)__)(____/

    07/12/2024 at 3:18 PM #235171
    Iván

    Salut! Voici la traduction :

  • Author
    Posts
Viewing 2 posts - 1 through 2 (of 2 total)

Find exclusive trading pro-tools on ProRealCode Marketplace

Similar topics:
coloration d’un indic1 en fonction de la valeur d’un indic2
temps d’éxécution initial d’un indicateur
affichage données d’un indicateur dans échelle graphique
caracteristiques d’un bon logiciel d’autotrading
configuration d’un indicateur par l’utilisateur
conversion de l’indicateur b-xtrendern du logiciel tradingview
conversion indicateur tradingview
conversion indicateur tradingview
conversion indicateur tradingview / pinescript
conversion indicateur tradingview a prorealtime

Create your free account now and post your request to benefit from the help of the community
Register or Login