Contas Margem

html`<style>
  .plot-title-small {
    font-size: 13px;
    font-weight: 600;
  }
  .plot-subtitle-small {
    font-size: 11px;
    font-weight: 400;
  }
</style>`

plotTitle = text => html`<span class="plot-title-small">${text}</span>`;
plotSubtitle = text => html`<br><span class="plot-subtitle-small">${text}</span>`;

Esta simulação interactiva demonstra o funcionamento das contas margem tanto para compra com margem como para venda a descoberto.

Simulação Interactiva

Escolha a sua estratégia e mova a barra deslizante para ver como a evolução do preço das acções afecta a sua conta margem ao longo de 63 dias.

Note

Pressupostos:

• Preço Inicial da Acção: $100
• Número de Acções: 100
• Requisito de Margem Inicial: 50%
• Margem de Manutenção: 30%
• Taxa de Juro Anual do Empréstimo (Compra com Margem): 8%
• Juros sobre a receita da Venda a Descoberto: 0%
• Dividendos da Acção: Nenhum
• Horizonte Temporal: 63 dias (aprox. 3 meses)
• Ano: 365 dias

viewof strategy = Inputs.radio(new Map([["Compra com Margem", "Buy on Margin"], ["Venda a Descoberto", "Short Sale"]]), {label: "Estratégia", value: "Buy on Margin"})
viewof muInput = Inputs.range([0.07, 0.25], {label: "Rendibilidade Esperada (anual)", step: 0.01, value: 0.10})
viewof sigmaInput = Inputs.range([0.1, 0.8], {label: "Volatilidade (anual)", step: 0.05, value: 0.4})
viewof days = Inputs.range([0, 63], {label: "Dia", step: 1, value: 0})

viewof newSim = {
  const btn = html`<button style="background: #2f71d5; color: white; border: none; border-radius: 10px; padding: 0.55rem 1.3rem; font-weight: 600; cursor: pointer;">Nova Simulação</button>`;
  btn.value = 0;
  btn.onclick = () => {
    btn.value++;
    btn.dispatchEvent(new Event("input", {bubbles: true}));
  };
  return btn;
}

initialPrice = 100
nShares = 100
initialMarginReq = 0.5
maintenanceMargin = 0.3
interestRate = 0.08
daysInYear = 365
sigma = sigmaInput
mu = muInput

mulberry32 = seed => {
  return function () {
    let t = seed += 0x6D2B79F5
    t = Math.imul(t ^ t >>> 15, t | 1)
    t ^= t + Math.imul(t ^ t >>> 7, t | 61)
    return ((t ^ t >>> 14) >>> 0) / 4294967296
  }
}

randomNormal = rng => {
  let u = 0, v = 0
  while (u === 0) u = rng()
  while (v === 0) v = rng()
  return Math.sqrt(-2.0 * Math.log(u)) * Math.cos(2.0 * Math.PI * v)
}

simSeed = {
  newSim; // Update seed only when button is clicked
  return Math.floor(Math.random() * 1000000);
}

// Generate Price Path
path = {
  const rng = mulberry32(simSeed);
  const dt = 1/daysInYear;
  
  let prices = [{day: 0, price: initialPrice}];
  let currentPrice = initialPrice;
  
  for(let i=1; i<=63; i++) {
    const drift = (mu - 0.5 * sigma * sigma) * dt;
    const diffusion = sigma * Math.sqrt(dt) * randomNormal(rng);
    currentPrice = currentPrice * Math.exp(drift + diffusion);
    prices.push({day: i, price: currentPrice});
  }
  return prices;
}

currentPath = path.slice(0, days + 1)

data = {
  let computed = [];
  let currentLoan = initialPrice * nShares * (1 - initialMarginReq);
  let currentCash = initialPrice * nShares * (1 + initialMarginReq); // For short sale
  let initialEquity = initialPrice * nShares * initialMarginReq;
  
  let prevPrice = initialPrice;
  let prevEquityPostCall = initialEquity; // Tracks equity after margin call top-up
  
  // Daily interest factor
  let dailyFactor = Math.pow(1 + interestRate, 1/daysInYear);

  for (let i = 0; i < path.length; i++) {
    let d = path[i];
    let equityBeforeCall, equityAfterCall, marginPercentBeforeCall, marginPercentAfterCall;
    let marginCall, liability, assets, callPrice, callAmount = 0;
    
    if (strategy === "Buy on Margin") {
        if (i > 0) currentLoan = currentLoan * dailyFactor;
        
        assets = d.price * nShares;
        liability = currentLoan;
        equityBeforeCall = assets - liability;
        marginPercentBeforeCall = equityBeforeCall / assets;
        
        if (marginPercentBeforeCall < maintenanceMargin) {
            marginCall = true;
            callAmount = assets * initialMarginReq - equityBeforeCall;
            currentLoan = currentLoan - callAmount;
        } else {
            marginCall = false;
        }
        
        equityAfterCall = equityBeforeCall + callAmount;
        marginPercentAfterCall = equityAfterCall / assets;
        
        callPrice = currentLoan / (nShares * (1 - maintenanceMargin));

    } else {
        // Short Sale
        liability = d.price * nShares;
        assets = currentCash; 
        equityBeforeCall = assets - liability;
        marginPercentBeforeCall = equityBeforeCall / liability;
        
        if (marginPercentBeforeCall < maintenanceMargin) {
            marginCall = true;
            callAmount = liability * initialMarginReq - equityBeforeCall; 
            currentCash = currentCash + callAmount;
        } else {
            marginCall = false;
        }
        
        equityAfterCall = equityBeforeCall + callAmount;
        marginPercentAfterCall = equityAfterCall / liability;
        
        callPrice = currentCash / (nShares * (1 + maintenanceMargin));
    }
    
    let stockReturn = 0;
    let accountReturn = 0;
    
    if (i > 0) {
        stockReturn = (d.price - prevPrice) / prevPrice;
        accountReturn = (equityBeforeCall - prevEquityPostCall) / prevEquityPostCall;
    }
    
    prevPrice = d.price;
    prevEquityPostCall = equityAfterCall; // Next day starts with this equity base

    computed.push({
        ...d,
        equity: equityAfterCall,
        marginPercent: marginPercentAfterCall * 100,
        marginCall: marginCall,
        callAmount: callAmount,
        liability: liability,
        assets: assets,
        callPrice: callPrice,
        equityBeforeCall: equityBeforeCall,
        marginPercentBeforeCall: marginPercentBeforeCall * 100,
        stockReturn: stockReturn * 100,
        accountReturn: accountReturn * 100
    });
  }
  return computed;
}

currentData = data.slice(0, days + 1)
lastPoint = currentData[currentData.length - 1]
callPriceCurrent = lastPoint.callPrice

accountDataTidy = currentData.flatMap(d => [
  {day: d.day, value: d.assets, type: "Activos"},
  {day: d.day, value: d.liability, type: "Passivo"},
  {day: d.day, value: d.equity, type: "Capital Próprio"}
])

priceDataTidy = currentData.flatMap(d => [
  {day: d.day, value: d.price, type: "Preço da Acção"},
  {day: d.day, value: d.callPrice, type: "Preço de Chamada de Margem"}
])

Plot.plot({
  title: plotTitle("Preço da Acção e Limite de Chamada de Margem"),
  grid: true,
  color: {legend: true, domain: ["Preço da Acção", "Preço de Chamada de Margem"], range: ["#2f71d5", "#d00000"]},
  x: {label: "Dia", domain: [0, 63]},
  y: {label: "Preço ($)", domain: [Math.min(...path.map(d => d.price), callPriceCurrent) * 0.9, Math.max(...path.map(d => d.price), callPriceCurrent) * 1.1]},
  marks: [
    Plot.line(currentData, {x: "day", y: "price", stroke: "#2f71d5", strokeWidth: 2}),
    Plot.line(currentData, {x: "day", y: "callPrice", stroke: "#d00000", strokeDasharray: "4", strokeWidth: 1.5}),
    Plot.ruleX([days], {stroke: "gray", strokeDasharray: "4"}),
    Plot.dot(currentData.filter(d => d.marginCall), {x: "day", y: "price", stroke: "red", r: 6, title: "Chamada de Margem"}),
    
    Plot.tip(priceDataTidy, Plot.pointerX({x: "day", y: "value", stroke: "type", title: d => `Dia ${d.day}
${d.type}: $${d.value.toFixed(2)}`}))
  ]
})

Plot.plot({
  title: plotTitle("Evolução do Valor da Conta"),
  grid: true,
  color: {legend: true, domain: ["Activos", "Passivo", "Capital Próprio"], range: ["#2b8a3e", "#c92a2a", "#1c7ed6"]},
  x: {label: "Dia", domain: [0, 63]},
  y: {label: "Valor ($)"},
  marks: [
    Plot.line(currentData, {x: "day", y: "assets", stroke: "#2b8a3e", strokeWidth: 2}),
    Plot.line(currentData, {x: "day", y: "liability", stroke: "#c92a2a", strokeWidth: 2}),
    Plot.line(currentData, {x: "day", y: "equity", stroke: "#1c7ed6", strokeWidth: 2}),
    Plot.ruleX([days], {stroke: "gray", strokeDasharray: "4"}),
    Plot.dot(currentData.filter(d => d.marginCall), {x: "day", y: "equity", stroke: "red", r: 6, title: "Chamada de Margem"}),
    
    Plot.tip(accountDataTidy, Plot.pointerX({x: "day", y: "value", stroke: "type", title: d => `Dia ${d.day}
${d.type}: $${d.value.toFixed(2)}`}))
  ]
})

Detalhes da Conta

html`
<table style="width: 100%; border-collapse: collapse; font-size: 0.92rem;">
  <thead>
    <tr style="text-align: left; border-bottom: 2px solid #adb5bd;">
      <th style="padding: 0.5rem;">Dia</th>
      <th style="padding: 0.5rem;">Preço da Acção</th>
      <th style="padding: 0.5rem;">Rendibilidade da Acção</th>
      <th style="padding: 0.5rem;">Capital Próprio /<br>Conta Margem (pós-chamada)</th>
      <th style="padding: 0.5rem;">Capital Próprio (pré-chamada)</th>
      <th style="padding: 0.5rem;">Rendibilidade da Conta</th>
      <th style="padding: 0.5rem;">Nível de Margem (pós-chamada)</th>
      <th style="padding: 0.5rem;">Margem Pré-chamada</th>
      <th style="padding: 0.5rem;">Chamada de Margem</th>
      <th style="padding: 0.5rem;">Montante da Chamada</th>
    </tr>
  </thead>
  <tbody>
    ${currentData.map(d => html`
      <tr style="border-bottom: 1px solid #e5e7eb;">
        <td style="padding: 0.5rem;">${d.day}</td>
        <td style="padding: 0.5rem;">${d.price.toFixed(2)}</td>
        <td style="padding: 0.5rem; color: ${d.day === 0 ? 'inherit' : (d.stockReturn >= 0 ? 'green' : 'red')};">
          ${d.day === 0 ? '-' : d.stockReturn.toFixed(2) + '%'}
        </td>
        <td style="padding: 0.5rem;">${d.equity.toFixed(2)}</td>
        <td style="padding: 0.5rem;">${d.equityBeforeCall.toFixed(2)}</td>
        <td style="padding: 0.5rem; color: ${d.day === 0 ? 'inherit' : (d.accountReturn >= 0 ? 'green' : 'red')};">
          ${d.day === 0 ? '-' : d.accountReturn.toFixed(2) + '%'}
        </td>
        <td style="padding: 0.5rem;">${d.marginPercent.toFixed(2)}%</td>
        <td style="padding: 0.5rem;">${d.marginPercentBeforeCall.toFixed(2)}%</td>
        <td style="padding: 0.5rem;">${d.marginCall ? "⚠️ SIM" : "Não"}</td>
        <td style="padding: 0.5rem;">${d.marginCall ? d.callAmount.toFixed(2) : "-"}</td>
      </tr>
    `)}
  </tbody>
</table>
`

Note

Notas:

• Rendibilidade da Acção: Variação percentual diária: \((P_t - P_{t-1}) / P_{t-1}\). Recorde-se que a acção não paga dividendos nesta simulação.
• Rendibilidade da Conta: Rendibilidade diária sobre o valor da conta: \((Equity_t - \text{PrevEquity}^*) / \text{PrevEquity}^*\), onde \(\text{PrevEquity}^*\) é o capital próprio no final do dia anterior mais qualquer depósito por chamada de margem.
• Capital Próprio / Conta Margem: Reportado após a adição de qualquer depósito por chamada de margem para o dia.
• Capital Próprio (pré-chamada): Capital próprio antes de qualquer depósito por chamada de cobertura da margem.
• Nível de Margem (Compra): \(\frac{\text{Capital Próprio}}{\text{Valor de Mercado da Acção}}\).
• Nível de Margem (Venda): \(\frac{\text{Capital Próprio}}{\text{Valor de Mercado da Acção}} = \frac{\text{Dinheiro Total} - \text{Valor da Acção}}{\text{Valor de Mercado da Acção}}\).
• Margem Pré-chamada: Nível de margem antes de qualquer depósito por chamada de cobertura da margem.
• Alavancagem: Tanto a compra com margem como a venda a descoberto são posições alavancadas, pelo que as rendibilidades da conta podem ser amplificadas em relação às rendibilidades da acção, aumentando tanto o potencial de ganhos como o risco de perda.

Para mais detalhes sobre como estes cálculos são feitos, consulte as páginas sobre compra com margem e vendas a descoberto.