Execução de ordens

Os participantes no mercado raramente colocam uma ordem e conseguem a sua execução no mesmo instante. O percurso que os preços descrevem entre o momento em que uma ordem é colocada e o momento em que é executada determina se uma ordem é accionada imediatamente, se aguarda pacientemente ou se nunca chega a ser executada. Esta página demonstra como cinco tipos comuns de ordens se comportam à medida que o mercado se desenrola.

Tipos de ordens num relance

• Ordem de mercado: executa-se imediatamente ao melhor preço disponível.
• Ordem limitada: aguarda por um preço específico ou melhor.
• Ordem stop: torna-se uma ordem de mercado assim que o preço se move para um nível menos favorável.
• Ordem stop-limit: despoleta-se ao preço stop e, em seguida, torna-se uma ordem limitada com um preço de execução condicionado.
• Ordem market-if-touched: torna-se uma ordem de mercado assim que o preço se move para um nível mais favorável.

Laboratório interactivo de execução de ordens

Configure as ordens e, em seguida, revele o percurso do preço um dia de cada vez para ver quando cada ordem é activada e como é executada. O percurso do preço segue um movimento browniano geométrico (GBM) volátil, permitindo-lhe explorar diferentes relações de preços.

Tip

Como experimentar

1. Escolha o tipo de ordem e o lado (compra ou venda).
2. Insira os níveis de preço relevantes para a ordem (preço limite, preço stop, etc.).
3. Clique em Colocar ordem na fila para preparar quantas ordens desejar.
4. Arraste o controlo de deslize do dia para revelar o percurso e observar cada ordem ser activada, executada ou expirar.
5. Remova ou limpe as ordens a qualquer momento para testar um novo cenário.

orderTypeOptions = [
  { value: "market", label: "Ordem de Mercado" },
  { value: "limit", label: "Ordem Limitada" },
  { value: "stop", label: "Ordem Stop" },
  { value: "stop-limit", label: "Ordem Stop-Limit" },
  { value: "mit", label: "Ordem Market-if-Touched" }
]

viewof orderType = Inputs.radio(orderTypeOptions.map(d => d.value), {
  label: "Tipo de Ordem",
  value: "limit",
  format: value => orderTypeOptions.find(d => d.value === value).label
})

viewof orderSide = Inputs.radio(["Compra", "Venda"], {
  label: "Lado da Ordem",
  value: "Compra"
})

formatCurrency = (value, digits = 2) =>
  new Intl.NumberFormat("pt-PT", {
    style: "currency",
    currency: "USD",
    minimumFractionDigits: digits,
    maximumFractionDigits: digits
  }).format(value)

formatNumber = (value, digits = 2) =>
  Number(value).toLocaleString("pt-PT", {
    minimumFractionDigits: digits,
    maximumFractionDigits: digits
  })

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)
}

mutable randomSeed = 202410

startPrice = 48
simulationSteps = 180
rng = mulberry32(randomSeed)
mu = 0.06
sigma = 0.32

timeUnit = 1 / simulationSteps

pricePath = {
  const path = Array.from({ length: simulationSteps + 1 }, (_, step) => ({ step, price: null, time: step }))
  path[0].price = startPrice
  for (let step = 1; step <= simulationSteps; step++) {
    const prev = path[step - 1].price
    const drift = (mu - 0.5 * sigma ** 2) * timeUnit
    const diffusion = sigma * Math.sqrt(timeUnit) * randomNormal(rng)
    const nextPrice = prev * Math.exp(drift + diffusion)
    path[step].price = Number(nextPrice.toFixed(2))
  }
  return path
}

priceDomain = [
  Math.min(...pricePath.map(d => d.price)) - 2,
  Math.max(...pricePath.map(d => d.price)) + 2
]

mutable orders = []
mutable orderCounter = 1

orderFieldConfig = new Map([
  ["market", []],
  ["limit", [
    { key: "limitPrice", label: "Preço limite", help: "Executa a este preço ou melhor." }
  ]],
  ["stop", [
    { key: "stopPrice", label: "Preço stop", help: "Activa quando o preço atinge este nível." }
  ]],
  ["stop-limit", [
    { key: "stopPrice", label: "Preço stop", help: "Prepara a ordem quando atingido." },
    { key: "limitPrice", label: "Preço limite", help: "Preço de execução uma vez preparada (pode ser ignorado)." }
  ]],
  ["mit", [
    { key: "touchPrice", label: "Preço de toque", help: "Torna-se uma ordem de mercado quando atingido." }
  ]]
])

defaultFieldValues = (orderType, orderSide, start) => {
  // Standard adjustment: Compra lower (-), Venda higher (+)
  const standardAdjust = (up, down) => (orderSide === "Compra" ? down : up)
  // Stop adjustment: Compra higher (+), Venda lower (-)
  const stopAdjust = (up, down) => (orderSide === "Compra" ? up : down)

  switch (orderType) {
    case "market":
      return {}
    case "limit":
      return { limitPrice: Number((start + standardAdjust(2, -2)).toFixed(2)) }
    case "stop":
      return { stopPrice: Number((start + stopAdjust(2, -2)).toFixed(2)) }
    case "stop-limit": {
      const stopPrice = Number((start + stopAdjust(2, -2)).toFixed(2))
      // If Buy Stop (higher), Limit usually slightly higher or same.
      // If Sell Stop (lower), Limit usually slightly lower or same.
      const limitOffset = orderSide === "Compra" ? 0.5 : -0.5
      return {
        stopPrice,
        limitPrice: Number((stopPrice + limitOffset).toFixed(2))
      }
    }
    case "mit":
      return { touchPrice: Number((start + standardAdjust(2, -2)).toFixed(2)) }
    default:
      return {}
  }
}

appendOrder = order => {
  const nextId = orderCounter ?? 1
  mutable orderCounter = nextId + 1

  const newOrder = { ...order, id: nextId }
  mutable orders = [...(orders ?? []), newOrder]
  return newOrder
}

removeOrder = id => {
  mutable orders = (orders ?? []).filter(order => order.id !== id)
}

clearOrders = () => {
  mutable orders = []
  mutable orderCounter = 1
}

orderSummary = order => {
  switch (order.type) {
    case "market":
      return `${order.side} a mercado`
    case "limit":
      return `${order.side} limitada ${formatCurrency(order.limitPrice)}`
    case "stop":
      return `${order.side} stop ${formatCurrency(order.stopPrice)}`
    case "stop-limit":
      return `${order.side} stop-limit (stop ${formatCurrency(order.stopPrice)}, limite ${formatCurrency(order.limitPrice)})`
    case "mit":
      return `${order.side} MIT ${formatCurrency(order.touchPrice)}`
    default:
      return `${order.side} ${order.type}`
  }
}

viewof orderBuilder = {
  const currentPrice = currentPoint.price
  const currentDay = simulationStep
  const fields = orderFieldConfig.get(orderType) ?? []
  const defaults = defaultFieldValues(orderType, orderSide, currentPrice)
  const state = { ...defaults }

  const container = html`<div class="order-builder" style="margin: 1rem 0; padding: 1.1rem 1.5rem; border: 1px solid #d0d7de; border-radius: 14px; background: #f8f9fb; display: flex; flex-direction: column; gap: 0.9rem;">
    <div style="display: flex; justify-content: space-between; align-items: center;">
      <div style="font-weight: 600;">Configurar ordem no dia ${currentDay}</div>
      <span style="background: linear-gradient(135deg, rgba(47,113,213,0.18), rgba(47,113,213,0.32)); color: #0b3d91; border-radius: 999px; padding: 0.25rem 0.75rem; font-weight: 700; font-size: 0.85rem; letter-spacing: 0.02em; text-transform: uppercase;">Actual ${formatCurrency(currentPrice)}</span>
    </div>
  </div>`

  const fieldBlock = html`<div class="order-builder__fields" style="display: grid; gap: 0.75rem;"></div>`
  container.append(fieldBlock)

  if (fields.length === 0) {
    fieldBlock.append(html`<div style="font-size: 0.92rem; color: #495057;">As ordens de mercado utilizam o preço actual e são executadas imediatamente.</div>`)
  } else {
    fields.forEach(field => {
      const wrapper = html`<label style="display: flex; flex-direction: column; gap: 0.35rem; font-size: 0.92rem;">
        <span style="font-weight: 600;">${field.label}</span>
        <input type="number" step="0.25" value="${state[field.key]}" style="padding: 0.4rem 0.6rem; border-radius: 8px; border: 1px solid #c4cdd5; font-size: 0.95rem;" />
        ${field.help ? html`<span style="font-size: 0.8rem; color: #6c757d;">${field.help}</span>` : null}
      </label>`

      const input = wrapper.querySelector("input")
      input.addEventListener("input", () => {
        const parsed = Number(input.value)
        state[field.key] = Number.isFinite(parsed) ? parsed : null
      })

      fieldBlock.append(wrapper)
    })
  }

  const actionRow = html`<div style="display: flex; gap: 0.75rem; flex-wrap: wrap; align-items: center;"></div>`
  const addButton = html`<button style="background: #2f71d5; color: white; border: none; border-radius: 10px; padding: 0.55rem 1.3rem; font-weight: 600; cursor: pointer;">Colocar ordem na fila no dia ${currentDay}</button>`
  const newPathButton = html`<button style="background: white; color: #495057; border: 1px solid #adb5bd; border-radius: 10px; padding: 0.5rem 1rem; font-weight: 600; cursor: pointer;">Novo percurso de preço</button>`
  const clearButton = html`<button style="background: white; color: #d00000; border: 1px solid #d00000; border-radius: 10px; padding: 0.5rem 1rem; font-weight: 600; cursor: pointer;">Limpar tudo</button>`
  actionRow.append(addButton, newPathButton, clearButton)
  container.append(actionRow)

  const statusBox = html`<div style="font-size: 0.9rem; color: #495057;">Defina os níveis de preço e adicione a ordem à fila.</div>`
  container.append(statusBox)

  const orderCount = orders.length
  if (orderCount > 0) {
    const countBadge = html`<div style="display: flex; align-items: center; gap: 0.5rem; font-size: 0.85rem; color: #1b4332; background: #d2f4ea; padding: 0.3rem 0.7rem; border-radius: 8px; width: fit-content; margin-top: -0.4rem; font-weight: 500;">
      <span style="display: inline-block; width: 8px; height: 8px; background: #1b4332; border-radius: 50%;"></span>
      Actualmente ${orderCount} ${orderCount === 1 ? "ordem" : "ordens"} na fila
    </div>`
    container.append(countBadge)
  }

  newPathButton.onclick = () => {
    clearOrders()
    mutable randomSeed = Math.floor(Math.random() * 1000000)
    statusBox.textContent = "Novo percurso de preço aleatório gerado. Ordens na fila removidas."
    statusBox.style.color = "#495057"
  }

  clearButton.onclick = () => {
    clearOrders()
    statusBox.textContent = "Todas as ordens na fila foram removidas."
    statusBox.style.color = "#6c757d"
  }

  addButton.onclick = () => {
    if (fields.some(field => state[field.key] == null || !Number.isFinite(Number(state[field.key])))) {
      statusBox.textContent = "Insira um preço válido para cada campo antes de colocar a ordem na fila."
      statusBox.style.color = "#d00000"
      return
    }

    let validationError = null
    switch (orderType) {
      case "limit":
        if (orderSide === "Compra" && state.limitPrice >= currentPrice) {
          validationError = "O preço de Compra Limite deve ser inferior ao preço de mercado actual."
        } else if (orderSide === "Venda" && state.limitPrice <= currentPrice) {
          validationError = "O preço de Venda Limite deve ser superior ao preço de mercado actual."
        }
        break
      case "stop":
      case "stop-limit":
        if (orderSide === "Compra" && state.stopPrice <= currentPrice) {
          validationError = "O preço de Compra Stop deve ser superior ao preço de mercado actual."
        } else if (orderSide === "Venda" && state.stopPrice >= currentPrice) {
          validationError = "O preço de Venda Stop deve ser inferior ao preço de mercado actual."
        }
        break
      case "mit":
        if (orderSide === "Compra" && state.touchPrice >= currentPrice) {
          validationError = "O preço de Compra MIT deve ser inferior ao preço de mercado actual."
        } else if (orderSide === "Venda" && state.touchPrice <= currentPrice) {
          validationError = "O preço de Venda MIT deve ser superior ao preço de mercado actual."
        }
        break
    }

    if (validationError) {
      statusBox.textContent = validationError
      statusBox.style.color = "#d00000"
      return
    }

    const orderDetails = (() => {
      switch (orderType) {
        case "market":
          return { triggerPrice: currentPrice }
        case "limit":
          return {
            limitPrice: Number(state.limitPrice),
            triggerPrice: Number(state.limitPrice)
          }
        case "stop":
          return {
            stopPrice: Number(state.stopPrice),
            triggerPrice: Number(state.stopPrice)
          }
        case "stop-limit":
          return {
            stopPrice: Number(state.stopPrice),
            limitPrice: Number(state.limitPrice),
            triggerPrice: Number(state.stopPrice)
          }
        case "mit":
          return {
            touchPrice: Number(state.touchPrice),
            triggerPrice: Number(state.touchPrice)
          }
        default:
          return {}
      }
    })()

    const newOrder = {
      type: orderType,
      side: orderSide,
      placedAt: currentDay,
      createdAt: Date.now(),
      ...orderDetails
    }

    const queued = appendOrder({ ...newOrder, description: orderSummary(newOrder) })
    statusBox.textContent = `Ordem #${queued.id} adicionada no dia ${currentDay}: ${orderSummary(newOrder)}.`
    statusBox.style.color = "#1b4332"
  }

  container.value = null
  return container
}

viewof simulationStep = {
  randomSeed; // Depend on randomSeed to reset
  return Inputs.range([0, pricePath.length - 1], {
    step: 1,
    value: 0,
    label: "Dia da simulação",
    play: true,
    speed: 0.4,
    loop: false
  });
}

currentPoint = pricePath[simulationStep]
visiblePath = pricePath.slice(0, simulationStep + 1)

orderColors = new Map([
  ["market", "#2f71d5"],
  ["limit", "#2b8a3e"],
  ["stop", "#f08c00"],
  ["stop-limit", "#d00000"],
  ["mit", "#845ef7"]
])

evaluateOrder = (order, path, step) => {
  if (!order) return null
  const currentStep = Math.min(step, path.length - 1)
  if (currentStep < order.placedAt) {
    return { ...order, status: "Na fila", triggeredAt: null, executedAt: null, executedPrice: null }
  }

  const side = order.side
  const priceAt = s => path[Math.min(s, path.length - 1)].price

  let triggeredAt = null
  let executedAt = null
  let executedPrice = null
  let status = "A aguardar"

  const start = order.placedAt

  const meetsTrigger = price => {
    switch (order.type) {
      case "stop":
      case "stop-limit":
        return side === "Compra" ? price >= order.stopPrice : price <= order.stopPrice
      case "mit":
        return side === "Compra" ? price <= order.touchPrice : price >= order.touchPrice
      default:
        return true
    }
  }

  const meetsLimit = price => {
    if (order.type === "limit") {
      return side === "Compra" ? price <= order.limitPrice : price >= order.limitPrice
    }
    if (order.type === "stop-limit") {
      if (order.limitPrice == null) return false
      return side === "Compra" ? price <= order.limitPrice : price >= order.limitPrice
    }
    return true
  }

  if (order.type === "market") {
    executedAt = start
    executedPrice = priceAt(start)
    status = currentStep >= start ? "Executada" : "Na fila"
    return { ...order, status, triggeredAt, executedAt, executedPrice }
  }

  let armed = false
  for (let s = start; s <= currentStep; s++) {
    const price = priceAt(s)

    if (order.type === "limit") {
      if (meetsLimit(price)) {
        executedAt = s
        executedPrice = side === "Compra" ? Math.min(order.limitPrice, price) : Math.max(order.limitPrice, price)
        status = "Executada"
        break
      }
      continue
    }

    if (order.type === "stop") {
      if (meetsTrigger(price)) {
        triggeredAt = s
        executedAt = s
        executedPrice = price
        status = "Executada"
        break
      }
      continue
    }

    if (order.type === "stop-limit") {
      if (!armed && meetsTrigger(price)) {
        armed = true
        triggeredAt = s
      }
      if (armed && meetsLimit(price)) {
        executedAt = s
        executedPrice = side === "Compra" ? Math.min(order.limitPrice, price) : Math.max(order.limitPrice, price)
        status = "Executada"
        break
      }
      continue
    }

    if (order.type === "mit") {
      if (meetsTrigger(price)) {
        triggeredAt = s
        executedAt = s
        executedPrice = price
        status = "Executada"
        break
      }
    }
  }

  if (executedAt === null) {
    if (order.type === "stop-limit" && triggeredAt !== null) {
      status = "Preparada (aguardando limite)"
    } else {
      status = "A aguardar"
    }
  }

  if (currentStep === path.length - 1 && executedAt === null) {
    status = status === "Preparada (aguardando limite)" ? "Expirada sem execução" : "Não executada"
  }

  return { ...order, status, triggeredAt, executedAt, executedPrice }
}

ordersWithState = (Array.isArray(orders) ? orders : []).map(order =>
  evaluateOrder(order, pricePath, simulationStep)
)

orderGuides = ordersWithState.flatMap(order => {
  if (!order) return []
  const color = orderColors.get(order.type) ?? "#495057"
  const guides = []

  const addGuide = (price, kind) => {
    if (price == null) return
    guides.push({ price, color, kind, id: order.id })
  }

  switch (order.type) {
    case "limit":
      addGuide(order.limitPrice, "limit")
      break
    case "stop":
      addGuide(order.stopPrice, "stop")
      break
    case "stop-limit":
      addGuide(order.stopPrice, "stop")
      addGuide(order.limitPrice, "limit")
      break
    case "mit":
      addGuide(order.touchPrice, "mit")
      break
    default:
      break
  }

  return guides
})

executionMarkers = ordersWithState
  .filter(order => order && order.executedAt !== null && order.executedAt <= simulationStep)
  .map(order => ({
    id: order.id,
    step: order.executedAt,
    price: order.executedPrice,
    color: orderColors.get(order.type) ?? "#495057"
  }))

html`<div style="display: flex; justify-content: center; align-items: center; gap: 0.8rem; margin-top: 0.5rem; margin-bottom: 1rem; font-family: sans-serif;">
  <div style="font-size: 0.85rem; color: #495057;">Preço à vista no dia ${simulationStep}:</div>
  <div style="font-weight: 700; font-size: 1.0rem; color: #0b3d91; background: rgba(47,113,213,0.18); border-radius: 999px; padding: 0.25rem 0.8rem;">${formatCurrency(currentPoint.price)}</div>
</div>`

viewof priceChart = Plot.plot({
  height: 360,
  marginLeft: 70,
  grid: true,
  style: { background: "linear-gradient(180deg, rgba(47,113,213,0.08), rgba(47,113,213,0))" },
  x: {
    label: "Dias",
    domain: [0, pricePath.length - 1]
  },
  y: {
    label: "Preço ($)",
    domain: priceDomain,
    grid: true
  },
  marks: [
    Plot.line(visiblePath, { x: "step", y: "price", stroke: "#2f71d5", strokeWidth: 1.6 }),
    Plot.dot(visiblePath, { x: "step", y: "price", r: 2.6, fill: "#2f71d5" }),
    Plot.ruleX([simulationStep], { stroke: "#343a40", strokeDasharray: "4,4" }),
    Plot.dot([currentPoint], { x: "step", y: "price", r: 6, fill: "#1b1b1b", stroke: "white", strokeWidth: 1.5 }),
    orderGuides.length
      ? Plot.ruleY(orderGuides, {
          y: "price",
          stroke: d => d.color,
          strokeDasharray: d => (d.kind === "stop" ? "6,4" : d.kind === "mit" ? "2,6" : null),
          strokeWidth: 1.6,
          opacity: 0.85
        })
      : null,
    executionMarkers.length
      ? Plot.dot(executionMarkers, {
          x: "step",
          y: "price",
          fill: d => d.color,
          stroke: "white",
          strokeWidth: 1.5,
          r: 6
        })
      : null
  ].filter(Boolean)
})

Registo de ordens

orderLegend = html`<div class="order-legend" style="display: flex; gap: 1.5rem; flex-wrap: wrap; margin: 0.75rem 0;">
  ${orderTypeOptions.map(o => {
    const swatch = html`<span style="display: inline-flex; align-items: center; gap: 0.35rem; font-size: 0.9rem;">
      <span style="display: inline-block; width: 14px; height: 14px; border-radius: 4px; background: ${orderColors.get(o.value)};"></span>
      ${o.label}
    </span>`
    return swatch
  })}
</div>`

html`${orderLegend}`

orderTableRows = ordersWithState.map(order => {
  if (!order) return null
  const prices = (() => {
    switch (order.type) {
      case "limit":
        return `Limite ${formatCurrency(order.limitPrice)}`
      case "stop":
        return `Stop ${formatCurrency(order.stopPrice)}`
      case "stop-limit":
        return `Stop ${formatCurrency(order.stopPrice)} / Limite ${formatCurrency(order.limitPrice)}`
      case "mit":
        return `Toque ${formatCurrency(order.touchPrice)}`
      default:
        return `—`
    }
  })()

  return {
    id: order.id,
    typeLabel: orderTypeOptions.find(o => o.value === order.type)?.label ?? order.type,
    side: order.side,
    placedAt: order.placedAt,
    prices,
    status: order.status,
    triggeredAt: order.triggeredAt ?? "—",
    executedAt: order.executedAt ?? "—",
    executedPrice: order.executedPrice != null ? formatCurrency(order.executedPrice) : "—",
    color: orderColors.get(order.type) ?? "#495057"
  }
}).filter(Boolean)

removeOrderButton = id => {
  const btn = html`<button style="background: none; border: 1px solid #adb5bd; border-radius: 8px; padding: 0.3rem 0.7rem; font-size: 0.8rem; cursor: pointer;">Remover</button>`
  btn.onclick = () => removeOrder(id)
  return btn
}

html`<table class="order-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;">#</th>
      <th style="padding: 0.5rem;">Tipo</th>
      <th style="padding: 0.5rem;">Lado</th>
      <th style="padding: 0.5rem;">Dia de colocação</th>
      <th style="padding: 0.5rem;">Níveis de preço</th>
      <th style="padding: 0.5rem;">Estado no dia ${simulationStep}</th>
      <th style="padding: 0.5rem;">Dia de activação</th>
      <th style="padding: 0.5rem;">Dia de execução</th>
      <th style="padding: 0.5rem;">Preço de execução</th>
      <th style="padding: 0.5rem;">Acções</th>
    </tr>
  </thead>
  <tbody>
    ${orderTableRows.length === 0
      ? html`<tr><td colspan="10" style="padding: 0.75rem; text-align: center; color: #6c757d;">Ainda não existem ordens na fila. Configure uma ordem acima para começar.</td></tr>`
      : orderTableRows.map(row => {
          const removeBtn = removeOrderButton(row.id)
          return html`<tr style="border-bottom: 1px solid #e5e7eb;">
            <td style="padding: 0.5rem; font-weight: 600; color: ${row.color};">${row.id}</td>
            <td style="padding: 0.5rem;">${row.typeLabel}</td>
            <td style="padding: 0.5rem;">${row.side}</td>
            <td style="padding: 0.5rem;">${row.placedAt}</td>
            <td style="padding: 0.5rem;">${row.prices}</td>
            <td style="padding: 0.5rem; font-weight: 600;">${row.status}</td>
            <td style="padding: 0.5rem;">${row.triggeredAt}</td>
            <td style="padding: 0.5rem;">${row.executedAt}</td>
            <td style="padding: 0.5rem;">${row.executedPrice}</td>
            <td style="padding: 0.5rem;">${removeBtn}</td>
          </tr>`
        })}
  </tbody>
</table>`

O que observar

• As ordens de mercado são executadas instantaneamente após a colocação, pelo que pode utilizá-las como referência comparativa para ordens condicionais.
• As ordens limitadas aguardam que o mercado atinja o seu preço; se o percurso revelado nunca o tocar, expiram sem execução.
• As ordens stop convertem-se em ordens de mercado ao preço stop, sublinhando como a protecção pode ser activada durante movimentos adversos.
• As ordens stop-limit revelam o risco de “gap”: uma vez despoletada, o preço limite pode nunca negociar, deixando a ordem pendente indefinidamente.
• As ordens market-if-touched invertem a lógica dos stops; utilize-as para explorar níveis de realização de lucro que executam com liquidez de mercado.

Conclusões

Colocar ordens enquanto se revela gradualmente o percurso do preço sublinha a diferença entre preço de activação e preço de execução. As ordens de mercado são executadas ao preço do dia no momento em que são colocadas, as ordens limitadas exigem níveis favoráveis, as ordens da família stop protegem contra movimentos desfavoráveis (mas podem sofrer derrapagem ou slippage) e as ordens market-if-touched garantem lucros assim que um alvo é atingido. Experimente várias ordens em simultâneo, como emparelhar um stop-limit de protecção com uma MIT de realização de lucro, para ver como estratégias combinadas respondem ao mesmo percurso de preço.

Ressalvas e Simplificações

Esta simulação assume várias simplificações para fins pedagógicos:

• Preços Diários: A simulação utiliza um único ponto de preço para cada dia (semelhante a um preço de fecho). Não considera flutuações de preço intradiárias (máximos e mínimos), que num mercado real poderiam activar uma ordem.
• Execuções Garantidas: Assume-se que as ordens limitadas são executadas assim que o preço de mercado cumpre a condição de limite. Na realidade, a execução não é garantida e depende de factores como a profundidade do livro de ordens e a prioridade na fila.
• Sem Slippage: As ordens de mercado, incluindo as activadas por ordens stop e MIT, são assumidas como sendo executadas ao preço exacto do passo temporal desse dia. Em mercados reais, especialmente os de movimento rápido, podem sofrer slippage (derrapagem), ou seja, a diferença entre o preço no momento em que a ordem é submetida e o preço final de execução.
• Regras Específicas das Bolsas: Os tipos de ordens e a lógica de validação aqui apresentados (como a relação entre os preços stop e limite) são comuns, mas não universais. Diferentes bolsas e corretoras podem suportar diferentes conjuntos de ordens ou aplicar as suas próprias restrições específicas.