QmVncmlwIHZhbiB2cmFhZyBlbiBhYW5ib2QgdmFuIGNyeXB0b2N1cnJlbmN5IEdlYnJ1aWsgdmFuIG1hcmt0d2FhcmRlIHZvb3IgZ2VyZWFsaXNlZXJkZSB3YWFyZGUgKE1WUlYp

<p><img src="https://gimg2.gateimg.com/image/article/1672904713交易指南.jpeg" alt=""></p>
<h2 id="h2-TL20DR447072"><a name="TL; DR" class="reference-link"></a><span class="header-link octicon octicon-link"></span>TL; DR</h2><p>De verhouding tussen marktwaarde en gerealiseerde waarde geeft aan wanneer een activum ondergewaardeerd of overgewaardeerd wordt.</p>
<p>Als de MVRV onder nul ligt, is er een marktbodem.</p>
<p>De piek van de markt top, meestal, treedt op wanneer de MVRV tussen 7,0 en 9,0 is.</p>
<p>Na een marktdieptepunt of -top zal er een prijsherstel plaatsvinden.</p>
<h2 id="h2-Introductie671253"><a name="Introductie" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Introductie</h2><p>Een belangrijk aspect van het handelen in cryptocurrency is het vermogen om het niveau van vraag en aanbod op de markt te schatten. De belangrijkste manieren om deze componenten te begrijpen, zijn onder meer het analyseren van de prijsactie en technische analyse-indicatoren. De marktwaarde ten opzichte van de gerealiseerde waarde (MVRV) is een belangrijke indicator, aangezien deze de crypto-marktpieken en -dalen schat. Als zodanig helpt het handelaren bij het vinden van medium- tot langetermijn instap- en uitstappunten.</p>
<h2 id="h2-Begrijpen20van20marktwaarde20tot20gerealiseerde20waarde20MVRZ36682"><a name="Begrijpen van marktwaarde tot gerealiseerde waarde (MVRZ)" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Begrijpen van marktwaarde tot gerealiseerde waarde (MVRZ)</h2><p>De marktwaarde ten opzichte van de gerealiseerde waarde, ontwikkeld door Murad Mahmudov en David Puell in 2018, is een handelsindicator die aangeeft of een cryptocurrency ondergewaardeerd of overgewaardeerd is op een specifiek moment.</p>
<p>Een variatie op de indicator van de marktwaarde tot de gerealiseerde waarde is de MVRV Z-score die de z-score toevoegt aan het oorspronkelijke concept. De Z-score geeft in feite de standaardafwijking onder of boven de gemiddelde waarde aan. De belangrijkste functie van de MVRV Z-score is om beleggers in staat te stellen het verschil te vinden tussen de gemiddelde prijs aller tijden en de huidige marktprijs.</p>
<p>Om te begrijpen wat marktwaarde ten opzichte van gerealiseerde waarde is, moeten we twee belangrijke termen begrijpen: marktwaarde en gerealiseerde waarde.</p>
<p>Marktkapitalisatie, ook wel marktwaarde genoemd, verwijst naar de totale waarde van een cryptocurrency tegen de huidige marktprijs. We gebruiken de volgende formule om het te berekenen.</p>
<p>Marktwaarde = Prijs x aantal munten in omloop</p>
<p>Aan de andere kant verwijst gerealiseerde waarde naar de daadwerkelijke waarde van het verwerven van de cryptocurrency. Met andere woorden, het is het totale bedrag dat mensen die de activa aanhouden hebben uitgegeven. Gewoonlijk krijgen we dit cijfer on-chain, aangezien het moeilijk is voor een individu om het te berekenen.</p>
<p>Laten we een voorbeeld bekijken om het gemakkelijk te begrijpen. In dit g berekenen we de gerealiseerde waarde van <a href="https://www.gate.io/trade/BTC_USDT" target="_blank">Tegen Bitcoin</a> die een investeerder op drie verschillende momenten heeft gekocht.</p>
<p>12 BTC tegen $15.000 per stuk<br>13 BTC tegen $12.000 per stuk<br>5 BTC tegen $20.000</p>
<p>We hebben de gerealiseerde waarde verkregen door de aanschafkosten van de BTC te berekenen.</p>
<p>12 X $15,000 + 13 X $12,000 + 5 X $20,000 = $436,000<br>In dit g is de gerealiseerde waarde van BTC $436,000 en de gemiddelde prijs is $14,533.33.</p>
<h2 id="h2-Wat20is20MVRV975053"><a name="Wat is MVRV?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Wat is MVRV?</h2><p>Eenvoudig gezegd is de MVRV de verhouding tussen de marktwaarde en gerealiseerde waarde van een activum zoals <a href="https://www.gate.io/trade/BTC_USDT" target="_blank">Bitcoin</a> Daarom geeft het de relatie aan tussen de huidige prijs van een activum en zijn gemiddelde prijs.</p>
<p>De investeerders zijn bereid om meer te kopen <a href="https://www.gate.io/trade/BTC_USDT" target="_blank">Bitcoin</a> Bijvoorbeeld wanneer de MVRV-waarde hoog is. Dit komt doordat als de MVRV hoog is, de investeerders hoge winsten maken. Daarom helpt deze index om het niveau van winst of verlies van een activum bij een bepaalde prijs te bepalen.</p>
<p>Bovendien wordt het verschil tussen de marktwaarde en de gerealiseerde waarde van een activum de fair value genoemd. Het is degene die handelaren gebruiken om te bepalen of het activum overgewaardeerd of ondergewaardeerd is.</p>
<h2 id="h2-Hoe20de20MVRV20te20berekenen494574"><a name="Hoe de MVRV te berekenen" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Hoe de MVRV te berekenen</h2><p>Zoals we eerder zeiden, zijn er slechts twee invoeren nodig om de MVRV te berekenen. Dit zijn de marktwaarde en de gerealiseerde waarde van een activum.</p>
<p>Hier is de formule voor het berekenen van de MVRV:</p>
<p>MVRV = Marktwaarde / Gerealiseerde waarde</p>
<h2 id="h2-Betekenis20van20de20MVRV20Zscore180252"><a name="Betekenis van de MVRV Z-score" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Betekenis van de MVRV Z-score</h2><p>Als de waarde van de MVRV Z-score hoger is dan 1, geeft dit aan dat de marktkapitalisatie groter is dan de gerealiseerde waarde. Wanneer de waarde lager is dan 1, betekent dit dat de gerealiseerde waarde groter is dan de marktkapitalisatie.</p>
<p>Analisten gebruiken het cijfer om het winstniveau te meten van <a href="https://www.gate.io/trade/BTC_USDT" target="_blank">Bitcoin</a> of een ander bezit. Bijvoorbeeld, als de MVRV-waarde 2,0 is, betekent dit dat de investeerders 100% winst zullen maken als ze hun <a href="https://www.gate.io/trade/BTC_USDT" target="_blank">Bitcoin</a> tegen de huidige marktprijs.</p>
<p>Een positieve waarde geeft aan dat beleggers winst kunnen maken als ze hun activa verkopen, terwijl een negatieve waarde aangeeft dat ze verlies zullen lijden als ze hun cryptocurrency tegen de huidige marktprijs afstoten.</p>
<h2 id="h2-Ondergewaardeerd20en20overgewaardeerd20actief46380"><a name="Ondergewaardeerd en overgewaardeerd actief" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Ondergewaardeerd en overgewaardeerd actief</h2><p>Een cryptocurrency kan ondergewaardeerd, neutraal of overgewaardeerd zijn. Het is ondergewaardeerd als de MVRV tussen 0 en 1 ligt. Dit betekent dat handelaren verlies zullen maken als ze hun activa tegen de marktprijs verkopen.</p>
<p>Aan de andere kant, als de waarde meer dan 3,7 is, is de cryptocurrency overgewaardeerd. De meeste beleggers verzamelen. <a href="https://www.gate.io/trade/BTC_USDT" target="_blank">Bitcoin</a> wanneer de MVRV-waarde minder is dan 1.0</p>
<h2 id="h2-Bitcoin2020boven20en20onder754777"><a name="Bitcoin  boven en onder" class="reference-link"></a><span class="header-link octicon octicon-link"></span><a href="https://www.gate.io/trade/BTC_USDT" target="_blank">Bitcoin</a> boven en onder</h2><p>Het is erg makkelijk te vertellen wanneer <a href="https://www.gate.io/trade/BTC_USDT" target="_blank">Bitcoin</a> is overgewaardeerd of ondergewaardeerd volgens de MVRV. Als de waarde van BTC onder 0 ligt, bevindt het zich op een marktdieptepunt. Daarentegen een <a href="https://www.gate.io/trade/BTC_USDT" target="_blank">Bitcoin</a> De top kan ontstaan wanneer de MVRV boven de 3,7 ligt. De piek van de markttop zal echter waarschijnlijk optreden wanneer de MVRV tussen 7 en 9 ligt.</p>
<p>In de berenmarkt van 2014 tot 2015 bedroeg de MVRV voor <a href="https://www.gate.io/trade/BTC_USDT" target="_blank">Tegen Bitcoin</a> was lager dan 1,0 gedurende 300 dagen. In 2018 tot 2019 bevond het zich ongeveer 134 dagen in de marktondersteuningszone. Momenteel bevindt het zich al in de huidige berenmarkt. <a href="https://www.gate.io/trade/BTC_USDT" target="_blank">Bitcoin</a> bevindt zich al meer dan 170 dagen op de bodem van de markt.</p>
<p>Bovendien toont CryptoQuant aan dat de MVRV-ratio rond half juni 2022 onder de 1,0 is gedaald, zoals blijkt uit het onderstaande diagram.</p>
<p><img src="https://gimg2.gateimg.com/image/article/1672905004MVRV 1.png" alt=""><br>MVRZ-verhouding - CryptoQuant</p>
<p>Zoals op de afbeelding te zien is, zakte de MVRV rond 13 juni 2022 onder de 1 en is daar sindsdien gebleven. Dit betekent dat BTC zich op de bodem van de markt bevindt. Volgens Macromicro was de BTC MVRV op 16 december -0,16.</p>
<p>Zoals je merkt, is er op die kaart een groene zone, onderaan. Daarom, zodra de MVRV zich binnen de groene zone bevindt, bevindt het actief zich op een marktbodem. Hoewel het moeilijk is om te voorspellen hoeveel dagen cryptocurrency op de marktbodem kan doorbrengen, zal er uiteindelijk een opwaartse prijsomkering zijn.</p>
<p>De MVRV kan ook in de roze of rode zone terechtkomen, zoals we bovenaan de grafiek zien. Na enige tijd binnen deze overgewaardeerde zone te hebben doorgebracht, zal er aan het einde een neerwaartse prijsommekeer zijn. Zodra de MVRV boven de 5,0 ligt, is de mogelijkheid van een prijsommekeer uiterst hoog. Het volgende diagram geeft bodems op de BTC-markt aan tussen 2014 en 2022.</p>
<p><img src="https://gimg2.gateimg.com/image/article/1672904983MVRV 2.png" alt=""><br>MVRV 2014 tot 2022- Binance</p>
<h2 id="h2-Conclusie969105"><a name="Conclusie" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Conclusie</h2><p>De MVRV is een indicator die marktbodems en -toppen van een actief laat zien. Als de MVRV stijgt tot meer dan 6,0, bevindt het actief zich op een marktop. Als het echter onder de 1,0 daalt, raakt de markt in een bodem. De marktop is een periode van distributie, terwijl de lage periode een periode van accumulatie is.</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 standpunten van de onderzoeker en vormt geen enkele beleggingsaanbevelingen.<br></em><div><em></em>Gate.io behoudt alle rechten op dit artikel. Het is toegestaan om het artikel opnieuw te plaatsen, mits Gate.io wordt vermeld. In alle glen zal juridische actie worden ondernomen wegens schending van het auteursrecht.<br></div><p></p><br></div></div></div>