SGV0IGdlYnJ1aWsgdmFuIGRlIENoYW5kZSBLcm9sbCBTdG9wOiBEZSBTdG9wLUxvc3MgZW4gVGFrZS1Qcm9maXQgU3RyYXRlZ2ll

2023-01-05, 08:01

<p><img src="https://gimg2.gateimg.com/image/article/1672905360交易指南.jpeg" alt=""></p>
<h2 id="h2-Te20lang20niet20gelezen445964"><a name="Te lang; niet gelezen" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Te lang; niet gelezen</h2><p>Deze indicator berekent en toont de stop-loss en take-profit punten van een activum.</p>
<p>De handelaren kunnen de Chande Kroll Stop Indicator gebruiken om trendomkeringen te signaleren, evenals handelsinstap- en uitstappunten.</p>
<p>De twee Chande Kroll Stop-indicatielijnen duiden op een belangrijk weerstandsniveau aan de bovenkant en een ondersteuningsniveau aan de onderkant van de prijs van een activum.</p>
<h2 id="h2-Kennismaking863312"><a name="Kennismaking" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Kennismaking</h2><p>Veel handelaren gebruiken verschillende candlestickpatronen, indicatoren en tools bij het handelen om snelle en betrouwbare beslissingen te nemen. De meeste van deze handelaren combineren verschillende indicatoren om de beste signalen te krijgen. Natuurlijk zijn er verschillende soorten technische indicatoren, waaronder oscillatoren en volume-indicatoren. De Chande Kroll Stop is echter een indicator die elke handelaar zou moeten combineren met andere indicatoren. Dit artikel zal u helpen begrijpen waarom u de Chande Kroll Stop-indicator zou moeten gebruiken en hoe u deze moet gebruiken.</p>
<h2 id="h2-Wat20is20de20Chande20Kroll20Stopindicator896649"><a name="Wat is de Chande Kroll Stop-indicator?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Wat is de Chande Kroll Stop-indicator?</h2><p>De Chande Kroll Stop-indicator berekent de take-profit en stop-loss prijzen van verschillende cryptocurrencies zoals. <a href="https://www.gate.io/trade/BTC_USDT" target="_blank">Bitcoin</a> en Ether (ETH). Het is ook nuttig op andere markten, waaronder de forex- en grondstoffenmarkten. Handelaren gebruiken deze indicator op verschillende handelstijdschema’s, zoals 1M, 1W, 1D, 6H. Het geeft echter de beste signalen wanneer het wordt gebruikt met middellange tot lange tijdframes.</p>
<p>Het is ook belangrijk om op te merken dat de Chande Kroll Stop een trendvolgende indicator is die inzicht biedt in de volatiliteit van de markt in real time op basis van de prijsbewegingen van het activum. Het berekent ook de take-profit en stop-loss niveaus met behulp van het gemiddelde ware volatiliteitsbereik van de beveiliging.</p>
<h2 id="h2-De20geschiedenis20van20de20Chande20Kroll20Stop20Indicator284194"><a name="De geschiedenis van de Chande Kroll Stop Indicator" class="reference-link"></a><span class="header-link octicon octicon-link"></span>De geschiedenis van de Chande Kroll Stop Indicator</h2><p>Twee Canadese bankiers, Tushar Chande en Stanely Kroll, hebben de Chande Kroll Stop-indicator ontwikkeld. Zoals u opmerkt, komt de naam van deze indicator van hun achternaam. Het werd gepubliceerd in hun boek, ‘The New Technical Trader - Boost Your Profit by Plugging into the Latest Indicators’, in 1994.</p>
<p>De twee technische analisten, Chande en Kroll, hebben ook verschillende indicatoren ontwikkeld, waaronder Chande Momentum Oscillator, Aroon, StochRSI en VIDYA. De volgende diagram toont hoe de Chande Kroll Stop indicator eruit ziet.</p>
<p><img src="https://gimg2.gateimg.com/image/article/1672905445Chande 1.png" alt=""><br>Chande Kroll Stop- Lizardindicators</p>
<h2 id="h2-Hoe20de20Chande20Kroll20Stop20Indicator20te20berekenen775654"><a name="Hoe de Chande Kroll Stop Indicator te berekenen" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Hoe de Chande Kroll Stop Indicator te berekenen</h2><p>De stoppunten zijn afgeleid van de hoge en lage bereiken van de indicator die worden vergeleken met de gemiddelde stopverliezen van het activum. We gebruiken de volgende formules:</p>
<p>Hoge Stop = Hoogste (N) x <em> Gemiddelde ware bereik (N)<br>Lage Stop = Laagste (N) + x </em> Gemiddelde ware bereik (N)</p>
<p>Er is echter geen noodzaak voor de handelaar om deze berekeningen te maken, aangezien de meeste handelsplatformen software hebben die het berekent.</p>
<p>In de meeste glen moeten de handelaren echter de drie variabelen P, Q en X instellen.</p>
<p>P staat voor de gemiddelde ware reeks waarvan de standaardperiode 10 is.</p>
<p>Q scheidt de lijnen van de marktprijs. De standaardinstelling is 9, wat het 9 keer meer maakt dan de volatiliteit. X vertegenwoordigt de gemiddelde tijd en scheidt ook de lijnen van de prijs. De standaardinstelling is 1.</p>
<h2 id="h2-Hoe20werkt20de20Chande20Kroll20Stop236604"><a name="Hoe werkt de Chande Kroll Stop?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Hoe werkt de Chande Kroll Stop?</h2><p>Het belangrijkste doel van de Chande Kroll Stop is om uw winst te beschermen door de transactie open te houden zolang de prijs in de juiste richting beweegt. Het geeft de stop-losses aan voor zowel korte als lange posities.</p>
<p>De indicator heeft twee lijnen. Een van de lijnen geeft de stop-loss en take-profit niveaus aan voor longposities, terwijl de andere de stop-loss en take-profit niveaus aangeeft voor shortposities. Bij de meeste handelsplatforms is de rode lijn het stopniveau voor shortposities, terwijl de groene lijn voor de longpositie is.</p>
<p>Daarom wordt de groene of blauwe lijn ook wel de lange stoplijn genoemd, terwijl de rode lijn de korte stoplijn wordt genoemd. Kortom, de twee lijnen volgen de veranderingen in de prijzen van de activa en identificeren stop-loss en take-profit niveaus.</p>
<p>Voor longposities stijgt het stop-lossniveau wanneer de prijs stijgt. Wanneer de prijs daalt, blijft het stop loss-niveau echter op dat niveau vast. Als zodanig hoeven de handelaren de trailing stop-losses niet steeds aan te passen.</p>
<p><img src="https://gimg2.gateimg.com/image/article/1672905510Chande 2.png" alt=""><br>Lang stop en kort stop- Lizard-indicator</p>
<h2 id="h2-Hoe20de20Chande20Kroll20Stopindicator20te20gebruiken549778"><a name="Hoe de Chande Kroll Stop-indicator te gebruiken" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Hoe de Chande Kroll Stop-indicator te gebruiken</h2><p>De Chande Kroll helpt handelaren bij het identificeren van handelsinstap- en uitstappunten. In feite kunnen handelaren handelsposities openen wanneer de prijs van het actief onder of boven beide indicatorlijnen ligt.</p>
<p>Bijvoorbeeld, de indicator genereert een koopsignaal wanneer de groene of blauwe lijn boven de rode lijn kruist. In dit g moet de prijs boven de trendlijn liggen. Dit duidt op een aankomende opwaartse trend. Daarom kunnen traders, zodra ze bevestigingen krijgen, long posities openen. Let op dat het stoppunt op het hoogste niveau ligt dat de blauwe of groene lijn heeft bereikt.</p>
<p>Daarentegen genereert de indicator een verkoopsignaal wanneer de rode lijn onder de blauwe of groene lijn kruist. In dit g zou de prijs onder de trendlijn moeten zijn. Het is ook belangrijk op te merken dat het laagste punt waarop de rode lijn is gekomen, fungeert als een stop-loss niveau.</p>
<p><img src="https://gimg2.gateimg.com/image/article/1672905587Chande 3.png" alt=""><br>Koop signaal en verkoopsignaal - indicatorspot</p>
<p>In de bovenstaande diagram kunnen we de blauwe lijn zien die boven de rode lijn kruist, wat een koopsignaal is. We zien ook de rode lijn die onder de groene of blauwe lijn kruist, wat een verkoopsignaal is.</p>
<h2 id="h2-Bullish20divergentie468633"><a name="Bullish divergentie" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Bullish divergentie</h2><p>Een bullish divergentie kan ook voorkomen op de Chande Kroll Stop-indicator. Dit gebeurt wanneer de rode lijn onder de groene lijn kruist en er weer boven kruist.</p>
<h2 id="h2-Trendidentificatie236598"><a name="Trendidentificatie" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Trendidentificatie</h2><p>Sommige handelaren gebruiken de Chande Kroll Stop-indicator om trendomkeringen te identificeren. Wanneer de groene of blauwe lijn boven de rode lijn kruist, is dit een bullish signaal voor prijsomkering. Aan de andere kant, als de rode lijn onder de groene of blauwe lijn kruist, duidt dit op een aanstaande bearish prijsomkering.</p>
<h2 id="h2-Conclusie770040"><a name="Conclusie" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Conclusie</h2><p>De Chande Kroll Stop-indicator bestaat uit twee lijnen, een blauwe of groene lijn en de rode. Deze indicator maakt gebruik van vergelijkbare berekeningen die worden gebruikt om de automatische stop-loss- en take-profitniveaus aan te geven. Het is echter belangrijk om de Chande Kroll Stop te gebruiken in combinatie met andere technische indicatoren zoals RSI en MACD.</p>
<div class="blog-details-info"><br><div>Auteur:<strong> Mashell C.</strong>, Gate.io onderzoeker<br><div class="info-tips"><em>Dit artikel vertegenwoordigt alleen de opvattingen van de onderzoeker en vormt geen enkele beleggingsaanbeveling.<br></em><div><em></em>Gate.io behoudt alle rechten op dit artikel. Het opnieuw plaatsen van het artikel zal worden toegestaan mits Gate.io wordt vermeld. In alle glen zal juridische actie worden ondernomen vanwege schending van het auteursrecht.<br></div><p></p><br></div></div></div>