Sayfa 189/310 İlkİlk ... 89139179187188189190191199239289 ... SonSon
Arama sonucu : 2475 madde; 1,505 - 1,512 arası.

Konu: Tradingview



  1. https://tr.tradingview.com/script/Sl...gression-LSMA/

    sar kodu...uzunluk kullanılarak trend hesaplaması gibi düşünün...

    grafiğe 3 tane ekleyin....

    60-240-720 uzunluk yapın....kısa-orta uzun gibi.....

    hareketli ortalama mantığıyla kullanıldığını düşünün....

    ister tek koda birleştirin....isterseniz...kesişimlere sinyal ekleyin......
    https://www.tradingview.com/x/FvCPM1z3/

  2. şu an için kullandığım sistemvari kodların görüntüsü böyle.....
    ayarların çoğu 1-5-15 dakkalık kullanmak için...
    https://www.tradingview.com/x/yC0lrXwp/

    tatil arası veriyorum.....

    ara vermeden önce...deneyip...yorumlamanız....
    hatalarımı bildirmeniz.......önerileriniz için....

    kodlar

    1. kod.....
    PHP Code:
     //@version=5
    indicator('Risk-Adjusted Return Oscillator'shorttitle='*'scale=scale.leftoverlay=true)

    //@version=5

    ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    ///                                                            Tooltips                                                                                 ///
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

    t1 "Determines the Length of Z-Score Assessment. Defaults to a 75 lookback period" 
    t2 "Determines the length of the SMA if the user selects Show SMA. Default is 75, but for a more responsive SMA you can reduce it to 14. Optional."
    t3 "Shows the probability zones in colour." 
    t4 "Will Display a summarized Z-Table." 
    t5 "Display's the SMA."  

    ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    ///                                                            User Inputs                                                                              ///
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    len input.int(20"Lookback Length"tooltip=t1)
    smalen input.int(20"SMA Length"tooltip=t2
    //probfill = input.bool(true, "Distribution Probaiblity Fills", tooltip=t3) 
    //showztable = input.bool(true, "Show Z-Table", tooltip=t4) 
    showsma input.bool(true"Show SMA"tooltip=t5

    ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    ///                                                            Z-Score/SMA Calculations                                                                  ///
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    = (close ta.sma(closelen)) / ta.stdev(closelen

    cl_sma ta.sma(closelen
    cl_sd ta.stdev(closelen

    // SMA 
    var float z_sma 0.0 

    if showsma 
        z_sma 
    := ta.sma(zsmalen

    ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    ///                                                           Colours                                                                                  ///
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    //color red = color.red 
    //color green = color.green 
    //color orange = color.orange 
    //color yellow = color.yellow 
    color labelcolor color.new(color.white100
    //color gray = color.new(color.gray, 25) 
    //color white = color.white 
    // Colour for Probability Distribution 
    //color greenfill = color.new(color.green, 75) 
    //color yellowfill = color.new(color.yellow, 75) 
    //color redfill = color.new(color.red, 75) 


    ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    ///                                                            Logical Assessments                                                                      ///
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    bool zero_one >= and 
    bool one_two 
    >= and 2.01 
    bool two_three 
    >= and 3.01 
    bool three 
    >= 
    bool zero 
    >= 0.99 and <= -0.99 
    bool neg_zero_one 
    and > -
    bool neg_one_two 
    <= -and > -
    bool neg_two_three 
    <= -and > -
    bool neg_three 
    <= -
    falling 
    ta.falling(z_sma3
    rising ta.rising(z_sma3


    ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    ///                                                         Plots                                                                                        ///
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    //color z_color_plot = z > 0 ? green : z <= 0 ? red : orange 
    //plot(z, "Z-Score", color=z_color_plot, style=plot.style_area) 
    //plot(z_sma, "Z-SMA", color=showsma ? white : labelcolor, linewidth=2) 

    neutral 
    onesd 

    twosd 

    threesd 

    neg_onesd 
    = -
    neg_twosd 
    = -
    neg_threesd 
    = -


    ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    ///                                                           Price Level Calculations                                                                  ///
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

    neutral_price = (cl_sma) + (cl_sd
    onesd_price = (cl_sma) + (cl_sd
    twosd_price = (cl_sma) + (cl_sd
    threesd_price = (cl_sma) + (cl_sd
    neg_onesd_price = (cl_sma) + (-cl_sd
    neg_twosd_price = (cl_sma) + (-cl_sd
    neg_threesd_price = (cl_sma) + (-cl_sd

    ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    ///                                                            Line Plots                                                                              ///
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////


    var label neutral_price_line na 
    var label onesd_price_line na
    var label twosd_price_line na 
    var label threesd_price_line na 
    var label neg_onesd_price_line na 
    var label neg_twosd_price_line na 
    var label neg_threesd_price_line na


    if bar_index >= 75 
        label
    .delete(neutral_price_line
        
    label.delete(onesd_price_line
        
    label.delete(twosd_price_line)
        
    label.delete(threesd_price_line
        
    label.delete(neg_onesd_price_line
        
    label.delete(neg_twosd_price_line)
        
    label.delete(neg_threesd_price_line
        
    neutral_price_line := label.new(bar_indexy=neutraltext=str.tostring(math.round(neutral_price,2)), color=labelcolorstyle=label.style_label_lefttextcolor color.whitesize=size.normaltextalign text.align_right)
        
    onesd_price_line := label.new(bar_index 5onesdstr.tostring(math.round(onesd_price,2)), color=labelcolorstyle=label.style_label_lefttextcolor color.whitesize=size.normaltextalign text.align_right
        
    twosd_price_line := label.new(bar_index 5twosdstr.tostring(math.round(twosd_price,2)), color=labelcolorstyle=label.style_label_lefttextcolor color.whitesize=size.normaltextalign text.align_right
        
    threesd_price_line := label.new(bar_index 5threesdstr.tostring(math.round(threesd_price,2)), color=labelcolorstyle=label.style_label_lefttextcolor color.whitesize=size.normaltextalign text.align_right
        
    neg_onesd_price_line := label.new(bar_index 5neg_onesdstr.tostring(math.round(neg_onesd_price,2)), color=labelcolorstyle=label.style_label_lefttextcolor color.whitesize=size.normaltextalign text.align_right
        
    neg_twosd_price_line := label.new(bar_index 5neg_twosdstr.tostring(math.round(neg_twosd_price,2)), color=labelcolorstyle=label.style_label_lefttextcolor color.whitesize=size.normaltextalign text.align_right
        
    neg_threesd_price_line := label.new(bar_index 5neg_threesdstr.tostring(math.round(neg_threesd_price,2)), color=labelcolorstyle=label.style_label_lefttextcolor color.whitesize=size.normaltextalign text.align_right


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

    //@version=5
    import jdehorty/KernelFunctions/as k

    threshold 
    input.int(20,"Range Threshold",minval=0,maxval=100,
     
    tooltip="Stochastic threshold (0-100) to identify ranging markets. A higher threshold will identify more ranges but will be slower at catching the trend.",
      
    group="General")
    input.int(14,"ATR Length",group="Stoch ATR")
    lengthStoch input.int(14"Stochastic Length"minval=1,group="Stoch ATR")
    lb input.int(14,"Lookback",group="Stoch ATR",tooltip="The number of bars used for the estimation of the rational quadratic kernel.")
    rw input.int(1,"Relative Weighting",group="Stoch ATR")
    smoothK input.int(3"Stochastic Smoothing"minval=1,group="Stoch ATR")

    rsisrc input.source(close,"RSI Source",group="RSI")
    rsilen input.int(14,"RSI Length",group="RSI")

    stochatr(atr,smoothK,lookback,weighting,lengthStoch)=>
        
    k.rationalQuadratic(ta.stoch(atr,atr,atr,lengthStoch),lookback,weighting,smoothK)
        
    y

    atr 
    ta.atr(l)
    stochatr(atr,smoothK,lb,rw,lengthStoch)
    rsi ta.rsi(rsisrc,rsilen)
    bull math.sqrt(rsi k)
    bear math.sqrt((100 rsi) * k)

    barcolor(bull bear and math.min(bull,bear) > threshold color.lime bear bull and math.min(bull,bear) > threshold color.red color.rgb(23022614))

    /////////////////////////////////////////////////////////////////////////////////////////////////////
    //@version=5
    len22=input(1)
    o22=ta.ema(open,len22)
    c22=ta.ema(close,len22)
    h22=ta.ema(high,len22)
    l22=ta.ema(low,len22)
    haclose = (o22+h22+l22+c22)/4
    haopen 
    o22 // initialize haopen variable
    haopen := na(haopen[1]) ? (o22 c22)/: (haopen[1] + haclose[1]) / 2
    hahigh 
    math.max (h22math.max(haopen,haclose))
    halow math.min (l22math.min(haopen,haclose))
    len233=input(1)
    o233=ta.ema(haopenlen233)
    c233=ta.ema(hacloselen233)
    h233=ta.ema(hahighlen233)
    l233=ta.ema(halowlen233)

    // calculate Sancho indicator
    sebastine = ((c233 o233) - 1) * 200

    // plot the Sebastine, signal, upper and lower bands
    color_sebastine sebastine >= color.rgb(21322811) : color.red

    plot
    (sebastinecolor=color_sebastinelinewidth=2title="TR",style=plot.style_cross)
    hline(0title="Zero Line"color=color.rgb(12212112152), linestyle=hline.style_dashedlinewidth=1)
    ////////////////////////////// 

    2.kod...
    PHP Code:
     //@version=5
    indicator("*"overlay truemax_lines_count 100max_labels_count 100format=format.price)
    ////////////////////////////////////////
    // This source code is subject to the terms of the Mozilla Public License 2.0 at https://mozilla.org/MPL/2.0/
    // © peacefulLizard50262

    //@version=5

    // Custom cosh function
    cosh(float x) =>
        (
    math.exp(x) + math.exp(-x)) / 2

    // Custom acosh function
    acosh(float x) =>
        
    na math.log(math.sqrt(1))

    // Custom sinh function
    sinh(float x) =>
        (
    math.exp(x) - math.exp(-x)) / 2

    // Custom asinh function
    asinh(float x) =>
        
    math.log(math.sqrt(1))

    // Custom inverse tangent function
    atan(float x) =>
        
    math.pi math.atan(x)

    // Chebyshev Type I Moving Average
    chebyshevI(float srcfloat lenfloat ripple) =>
        
    0.
        b 
    0.
        g 
    0.
        chebyshev 
    0.
        
        a 
    := cosh(len acosh(/ (ripple)))
        
    := sinh(len asinh(ripple))
        
    := (b) / (b)
        
    chebyshev := (g) * src nz(chebyshev[1])
        
    chebyshev

    // Chebyshev Type II Moving Average
    chebyshevII(float srcfloat lenfloat ripple) =>
        
    0.
        b 
    0.
        g 
    0.
        chebyshev 
    0.
        
        a 
    := cosh(len acosh(ripple))
        
    := sinh(len asinh(ripple))
        
    := (b) / (b)
        
    chebyshev := (g) * src nz(chebyshev[1], src)
        
    chebyshev

    chebyshev
    (float srcfloat lengthfloat ripplebool style) =>
        
    style ?
         
    chebyshevI(srclengthripple) :
         
    chebyshevII(srclengthripple)

    source44 input.source(hl2"Source")
    up_color input.color(color.new(color.green20), "Up Color")
    down_color input.color(color.new(color.red20), "Down Color")
    text_color input.color(color.black"Text Color")
    mean_length input.float(24"Mean Length"510000.5)
    mean_ripple input.float(0.5"Mean Ripple"0.010.990.01)
    style44 input.bool(false"True Chebyshev I | False : Chebyshev II")
    atr_style input.bool(true"True: |Open-Close|  False: High-Low")
    atr_length input.float(64"ATR Length"610000.5)
    atr_ripple input.float(0.05"Mean Ripple"0.010.990.01)
    multiplier input.float(1.5"Multiplier"0.125100.125)
    alerts input.bool(false"Alerts")
    labels input.bool(true"Labels")

    atr chebyshev(atr_style high low math.abs(open close), atr_lengthatr_ripplestyle44)
    mean chebyshevI(source44mean_lengthmean_ripple)

    var 
    float offset 0.0
    var bool state na
    var float newOffset 0.0

    crossover 
    ta.crossover(source44offset)
    position source44 offset
    crossunder 
    ta.crossunder(source44offset)

    prevOffset nz(offset[1])

    if 
    crossover[2] and position[1] and position or (position and position[1] and position[2]) 
        
    newOffset := mean atr multiplier
        offset 
    := newOffset nz(prevOffset) or close[1] > nz(prevOffset) ? newOffset nz(prevOffset)
        
    state := true

    if crossunder[2] and not position[1] and not position or (not position and not position[1] and not position[2]) 
        
    newOffset := mean atr multiplier
        offset 
    := newOffset nz(prevOffset) or close[1] < nz(prevOffset) ? newOffset nz(prevOffset)
        
    state := false

    cross 
    ta.cross(closeoffset)

    down_trend not state and not state[1]
    up_trend state and state[1]

    colour up_trend up_color down_trend down_color color.new(color.white100

    if 
    up_trend and not up_trend[1] and labels
        label
    .new(bar_indexoffset"Up Trend \n" str.tostring(close), color up_colorstyle label.style_label_uptextcolor text_color)
        
    alert("Up Trend at " str.tostring(close))
    else
        
    alert("Up Trend at " str.tostring(close))

    if 
    down_trend and not down_trend[1] and labels
        label
    .new(bar_indexoffset"Down Trend \n" str.tostring(close), color down_colorstyle label.style_label_downtextcolor text_color)
        
    alert("Down Trend at " str.tostring(close))
    else
        
    alert("Down Trend at " str.tostring(close))
        
    plot(offset"Trend"colourstyle plot.style_stepline_diamond)

    //plotshape(cross, "Trend Is Getting Ready To Change", shape.xcross, location.belowbar, color = close > offset ? up_color : down_color)
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    // This source code is subject to the terms of the Mozilla Public License 2.0 at https://mozilla.org/MPL/2.0/
    // © Gedhusek

    //@version=5

    BackStep input.int(27,"Analysis Period")
    lowerValue input.float(0.382,"Lower Fibonacci Level",options=[0.2360.3820.500.6180.786])
    upperValue input.float(0.618,"Upper Fibonacci Level",options=[0.2360.3820.500.6180.786])
    showFill input.bool(true,"Show Filling")
    changeCandle input.bool(true,"Change Candle Color")
    atr77 ta.atr(200)
    max ta.highest(close,BackStep)
    min ta.lowest(close,BackStep)


    lowerFib min + (max-min)*lowerValue
    upperFib 
    min + (max-min)*upperValue
    ma 
    ta.wma(close,6)

    float closeVal ma
    float openVal 
    ma
    color clrToUse 
    closeVal>upperFib and openVal>upperFib?color.green:closeVal<lowerFib and openVal<lowerFib?color.red:color.yellow

    LowerFibLine 
    plot(lowerFib,title="0.382",color=color.rgb(1897525520))
    UpperFibLine plot(upperFib,title="0.618",color=color.rgb(1897525520))

    float LowerRetracement = (max-min)*0.318
    float UpperRetracement 
    = (max-min)*0.618
    //////////////////////////////////////////////////////
    //@version=5
    ////////////////////////////////
    length1=(1)
    src1=close
    start1 
    input(0)
    increment1 input(0.001)
    maximum1 input(1"Max Value")
    out1 ta.sar(start1increment1maximum1)
    momo1 src1 src1[length1]
    smdo1 out1 momo1
    //plot(smdo1, "1.Döngü", style=plot.style_line, color=#f0ce0e)

    color33 smdo1 >= out1 color.red color.lime
    plot
    (smdo1color=color33linewidth=2title="0",style=plot.style_stepline)
    //////////////////////////////////////////////////////////////////////////////////////
    start21 input(0)
    increment21 input(0.001)
    maximum21 input(1"Max Value")
    out21 ta.sar(start21increment21maximum21)
    //plot(out21, "Döngü", style=plot.style_line, color=#f0ce0e)
    plot(out21color=color33linewidth=2title="1",style=plot.style_stepline)
    //////////////////////////////////////////////////////////////////////////////////////////
    //@version=5
    import jdehorty/KernelFunctions/as kernel

    DFT
    (xyNx_dir) =>
        
    float _arg 0.0
        float _cos 
    0.0
        float _sin 
    0.0
        float xArr_i 
    0.0
        float yArr_i 
    0.0
        xArr 
    = array.new_float(array.size(x))
        
    yArr = array.new_float(array.size(y))

        for 
    0 to Nx 1 by 1
            xArr_i 
    := 0.0
            yArr_i 
    := 0.0
            kx 
    float(i) / float(Nx)
            
    _arg := -_dir math.pi kx
            
    for 0 to Nx 1 by 1
                _cos 
    := math.cos(_arg)
                
    _sin := math.sin(_arg)
                
    xArr_i += array.get(xk) * _cos - array.get(yk) * _sin
                yArr_i 
    += array.get(xk) * _sin + array.get(yk) * _cos
                yArr_i
            
    array.set(xArrixArr_i)
            array.
    set(yArriyArr_i)

        if 
    _dir == 1
            
    for 0 to Nx 1 by 1
                
    array.set(xi, array.get(xArri) / float(Nx))
                array.
    set(yi, array.get(yArri) / float(Nx))
        else
            for 
    0 to Nx 1 by 1
                
    array.set(xi, array.get(xArri))
                array.
    set(yi, array.get(yArri))

    //======================================================================================================================
    //                                                  INPUTS
    //======================================================================================================================

    input.int(1,"Fourier Period")
    xval input.source(close,"Fourier X Series",tooltip "i.e. the source of the discrete Fourier"+
     
    " transform (with the Y Series being the bars through time.)")
    highlighting input.bool(true,"Highlighting")
    smoothing input.int(10,"Kernel Smoothing")


    //======================================================================================================================
    //                                                  CALCULATIONS
    //======================================================================================================================

    // Fourier transform
    = array.new_float(N0.0)
    = array.new_float(N0.0)
    for 
    0 to N 1
        
    array.set(xixval[i])
        array.
    set(yi0.0)

    DFT(xyN1)

    mag = array.new_float(N0.0)
    for 
    0 to N 1
        mag_i 
    math.sqrt(math.pow(array.get(xi), 2) + math.pow(array.get(yi), 2))
        array.
    set(magimag_i)

    dft = array.get(mag,0)
    dfts kernel.rationalQuadratic(dft,25,1,smoothing)

    //======================================================================================================================
    //                                                  DISPLAY
    //======================================================================================================================

    plot(dfts"Stop"color dfts dft color.rgb(2558282100) : color.rgb(0230119100))

    //////////////////////////////////////////////////////////////// 
    3.kod....
    PHP Code:
     // This source code is subject to the terms of the Mozilla Public License 2.0 at https://mozilla.org/MPL/2.0/
    // © BobRivera990
     
    //@version=4
    study(title "Trend Type Indicator by BobRivera990"overlay falsescale=scale.left,format=format.priceprecision=2max_bars_back 200)
    //==========================================================================[Inputs]==========================================================================
    useAtr input(truetitle "Use ATR to detect Sideways Movements")            // Use Average True Range (ATR) to detect Sideways Movements

    atrLen input(14minval 1title "ATR Length")                            // length of the Average True Range (ATR) used to detect Sideways Movements

    atrMaType input("EMA"options = ["SMA""EMA"], 
         
    title "ATR Moving Average Type")                                         // Type of the moving average of the ATR used to detect Sideways Movements
    atrMaLen input(27minval 1title "ATR MA Length")                       // length of the moving average of the ATR used to detect Sideways Movements

    useAdx input(truetitle "Use ADX to detect Sideways Movements")            // Use Average Directional Index (ADX) to detect Sideways Movements

    adxLen input(14minval 1maxval 50title "ADX Smoothing")            // length of the Average Directional Index (ADX) used to detect Sideways Movements
    diLen input(14minval 1title "DI Length")                              // length of the Plus and Minus Directional Indicators (+DI & -DI) used to determine the direction of the trend
    adxLim input(25minval 1title "ADX Limit")                             // A level of ADX used as the boundary between Trend Market and Sideways Market

    smooth input(3minval 1maxval 5title "Smoothing Factor")           // Factor used for smoothing the oscillator
    lag input(8minval 0maxval 15title "Lag")                          // lag used to match indicator and chart
    //============================================================================================================================================================
    //===================================================================[Initial Calculations]===================================================================

    atr atr(atrLen)                                                               // Calculate the Average True Range (ATR)
    atrMa atrMaType == "EMA" ema(atratrMaLen) : sma(atratrMaLen)            // Calculate the moving average of the ATR

    up change(high)                                                               // Calculate parameter related to ADX, +DI and -DI
    down = -change(low)                                                             // Calculate parameter related to ADX, +DI and -DI          
    plusDM na(up) ? na : (up down and up up 0)                          // Calculate parameter related to ADX, +DI and -DI
    minusDM na(down) ? na : (down up and down down 0)                   // Calculate parameter related to ADX, +DI and -DI
    trur rma(trdiLen)                                                           // Calculate parameter related to ADX, +DI and -DI
    plus fixnan(100 rma(plusDMdiLen) / trur)                                  // Calculate Plus Directional Indicator (+DI)
    minus fixnan(100 rma(minusDMdiLen) / trur)                                // Calculate Minus Directional Indicator (-DI)
    sum plus minus                                                              // Calculate parameter related to ADX

    adx 100 rma(abs(plus minus) / (sum == sum), adxLen)               // Calculate Average Directional Index (ADX)
    //============================================================================================================================================================
    //========================================================================[Conditions]========================================================================

    cndNa na(atr) or na(adx) or na(plus) or na(minus) or na(atrMaLen)             // Conditions for lack of sufficient data for calculations

    cndSidwayss1 useAtr and atr <= atrMa                                                     // Sideways Movement condition (based on ATR)
    cndSidwayss2 useAdx and adx <= adxLim                                                    // Sideways Movement condition (based on ADX)
    cndSidways cndSidwayss1 or cndSidwayss2                                       // General Sideways Movement condition

    cndUp plus minus                                                            // uptrend condition
    cndDown minus >= plus                                                         // downtrend condition

    trendType  cndNa na cndSidways cndUp : -2                       // Determine the type of trend
    smoothType na(trendType) ? na round(sma(trendTypesmooth) / 2) * 2         // Calculate the smoothed trend type oscillator
    //============================================================================================================================================================
    //=========================================================================[Drawing]==========================================================================

    colGreen30 color.new(color.green30)                                         // Define the color used in the drawings
    colGreen90 color.new(color.green90)                                         // Define the color used in the drawings
    colGray color.new(color.gray20)                                             // Define the color used in the drawings      
    colWhite90 color.new(color.white90)                                         // Define the color used in the drawings
    colRed30 color.new(color.red30)                                             // Define the color used in the drawings
    colRed90 color.new(color.red90)                                             // Define the color used in the drawings

    band3 plot(+3title "3"color=color.black,transp=100)                           // Draw the upper limit of the uptrend area
    band2 plot(+1title "2"color=color.black,transp=100)                           // Draw the boundary between Sideways and Uptrend areas
    band1 plot(-1title "1"color=color.black,transp=100)                           // Draw the boundary between Sideways and Downtrend areas
    band0 plot(-3title "0"color=color.black,transp=100)                           // Draw the lower limit of the downtrend area

    fill(band2band3title "Uptrend area"color colGreen90)                  // Highlight the Uptrend area
    fill(band1band2title "Sideways area"color colWhite90)                 // Highlight the Sideways area
    fill(band0band1title "Downtrend area"color colRed90)                  // Highlight the Downtrend area

    var label lblUp na
    label
    .delete(lblUp)
    lblUp := label.new(time2text "Trend  POZİTİF"
         
    color color.new(color.green100), textcolor color.black
         
    style label.style_label_leftxloc xloc.bar_time
         
    yloc yloc.pricesize=size.normaltextalign text.align_left)          // Show Uptrend area label

    var label lblSideways na
    label
    .delete(lblSideways)
    lblSideways := label.new(time0text "Trend YOK"
         
    color color.new(color.green100), textcolor color.black
         
    style label.style_label_leftxloc xloc.bar_time
         
    yloc yloc.pricesize size.normaltextalign text.align_left)        // Show Sideways area label
         
    var label lblDown na
    label
    .delete(lblDown)
    lblDown := label.new(time= -2text "Trend NEGATİF"
         
    color color.new(color.green100), textcolor color.black
         
    style label.style_label_leftxloc xloc.bar_time
         
    yloc yloc.pricesize size.normaltextalign text.align_left)        // Show Downtrend area label

    var label lblCurrentType na
    label
    .delete(lblCurrentType)
    lblCurrentType := label.new(timesmoothType
         
    color color.new(color.blue30), style label.style_label_right,
         
    xloc xloc.bar_timeyloc yloc.pricesize size.small)                // Show the latest status label

    trendCol smoothType == colGreen30 smoothType == colGray colRed30  // Determine the color of the oscillator in different conditions

    plot(smoothTypetitle "Tr"color trendCol
         
    linewidth 3offset = -lagstyle plot.style_stepline)                 // Draw the trend type oscillator
    ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////// 

    altta gözüken kodları...fiyat grafiğinin üstüne sürükleyin geçin....

    selamlar....bol nasipler.......


  3. Tradingview indikatörleri : https://borsarazzi.blogspot.com/2023...sturulmus.html

    Teknik analiz ücretsiz video eğitimleri : https://borsarazzi.blogspot.com/p/oneri.html

    Tarama yöntemleri : https://borsarazzi.blogspot.com/search/label/tarama



    ✅ İyi traderler stresle nasıl başa çıkar.
    ✅ Traderin kalp atış hızı dakikada 60 dan, Fed kararı sonrası 100'e çıkıyor.




  4. ATR temelli en beğendiğiniz indikatörler hangileri?


    ATR kullanarak stop loss seviyesi nasıl hesaplanır?
    Klasik yöntemle hesabı gösterdik. Çok şükür bun için otomatik hesap eden indikatörler var











Sayfa 189/310 İlkİlk ... 89139179187188189190191199239289 ... SonSon

Yer İmleri

Yer İmleri

Gönderi Kuralları

  • Yeni konu açamazsınız
  • Konulara cevap yazamazsınız
  • Yazılara ek gönderemezsiniz
  • Yazılarınızı değiştiremezsiniz
  •