O Filtro de Kalman para Estratégias de Reversão à Média no Forex

Introdução

O filtro de Kalman é um algoritmo recursivo utilizado em trading algorítmico para estimar o verdadeiro estado de uma série temporal financeira ao filtrar o ruído dos movimentos de preço. Ele atualiza dinamicamente as previsões com base em novos dados de mercado, tornando-se valioso para estratégias adaptativas como reversão à média. Este artigo primeiro apresenta o filtro de Kalman, abordando seu cálculo e implementação. Em seguida, aplicamos o filtro a uma estratégia clássica de reversão à média no forex como exemplo. Por fim, realizamos diversas análises estatísticas comparando o filtro com uma média móvel em diferentes pares de forex.

O Filtro de Kalman

O filtro de Kalman, introduzido por Rudolf E. Kalman em 1960, é um estimador recursivo ótimo utilizado para rastrear e prever sistemas dinâmicos. Originalmente desenvolvido para sistemas aeroespaciais e de controle, ele foi amplamente aplicado em finanças, robótica e processamento de sinais. O filtro opera em duas etapas: uma etapa de previsão, na qual estima o próximo estado do sistema, e uma etapa de atualização, na qual refina a estimativa com base em novas observações enquanto minimiza o ruído. 

No campo do trading algorítmico, ele pode ser visto simplesmente como um filtro de regime comum que traders utilizam, semelhante a modelos de média móvel ou regressão linear. O filtro de Kalman adapta-se dinamicamente a novos dados, reduz ruído e atualiza estimativas de forma eficiente em tempo real, tornando-o eficaz para detectar mudanças de regime de mercado. No entanto, ele assume dinâmicas lineares, requer ajuste cuidadoso de parâmetros, pode apresentar atraso na detecção de mudanças abruptas e é computacionalmente mais complexo do que filtros mais simples como médias móveis.

Alguns usos comuns do filtro de Kalman no trading algorítmico:

• Reversão à Média: Utilizar o preço atual comparado ao preço estimado como filtro de entrada.
• Pairs Trading: Estimar dinamicamente o spread entre ativos correlacionados e ajustar proporções de hedge conforme as condições de mercado mudam.
• Trend Following: Filtrar o ruído de curto prazo para detectar tendências de preço de longo prazo com maior precisão.
• Estimativa de Volatilidade: Fornecer estimativas adaptativas da volatilidade do mercado para gestão de risco e dimensionamento de posições.

A fórmula para calcular o valor do filtro de Kalman é a seguinte:

Para compreender essa fórmula complexa de forma simples, vamos observar um exemplo de visualização.

O filtro de Kalman funciona atualizando sua estimativa do preço real com base em medições ruidosas e previsões. Ele geralmente é obtido em três etapas:

1. Previsão: O filtro começa com uma estimativa inicial para o preço (preço previsto) e sua incerteza (covariância prevista). Isso é mostrado pela zona laranja Predicted Zone — o intervalo dentro do qual o filtro espera que o preço real esteja, considerando tanto a estimativa anterior quanto o ruído do processo.

2. Atualização: Quando novos dados de preço (preços medidos) ficam disponíveis, o filtro de Kalman os compara com o preço previsto. Ele então calcula algo chamado Kalman Gain (linha roxa) para decidir quanto peso dar à nova medição em comparação com a previsão. Se a medição for muito ruidosa, o filtro confiará mais em sua previsão. 

3. Estimativa: O filtro atualiza o preço previsto incorporando a nova medição. O preço atualizado (mostrado pela zona azul Estimate Zone) possui incerteza reduzida em relação à previsão. Essa zona diminui conforme o filtro refina sua estimativa. 

Aqui, a incerteza da previsão é definida pela covariância entre a medição e a previsão.Uma covariância maior significa uma estimativa menos confiável, enquanto uma covariância menor significa que o filtro está mais confiante em sua estimativa. Se a medição for confiável, o ganho de Kalman é alto e o filtro confia mais nos novos dados (reduzindo a incerteza). Se a medição for ruidosa, o ganho é menor e o filtro depende mais da previsão anterior.

O nível de ruído é definido pela variância, especificamente pela variância da medição e pela variância do processo. Essas variâncias não se ajustam automaticamente como a covariância; elas são definidas desde o início com base no quão suave você deseja que seja o filtro de Kalman.

Aqui estão alguns exemplos de como as variâncias afetam a suavidade da curva:

Em geral, a variância do processo (Q) representa o quanto o modelo espera que o estado real mude ao longo do tempo, enquanto a variância da medição (R) reflete a confiança nos dados observados. Uma Q mais alta torna o filtro mais sensível a mudanças repentinas, mas aumenta a volatilidade. Uma R mais alta suaviza as previsões ao confiar mais nas estimativas anteriores, ao custo de ajustes mais lentos. Q baixo e R moderado produzem previsões estáveis, enquanto Q alto e R baixo tornam o filtro mais reativo, porém mais ruidoso.

Codificando a Estratégia

Estratégias de reversão à média geralmente seguem a abordagem de comprar quando o mercado está sobrevendido, vender quando está sobrecomprado e sair da posição quando o preço retorna à média. Essa estratégia baseia-se na suposição de que os dados de preço são geralmente estáveis e não tendem a atingir níveis extremos. Quando o preço está em um extremo, espera-se que eventualmente retorne ao ponto de equilíbrio. Essa teoria é especialmente válida para dados semi-estacionários como o forex, onde estratégias de reversão à média têm sido lucrativas ao longo dos anos.

Quantificaremos nossa abordagem utilizando Bandas de Bollinger de 100 períodos com um desvio de 2.0. O plano detalhado é o seguinte:

• Comprar quando o último preço de fechamento estiver abaixo da banda inferior.
• Vender quando o último preço de fechamento estiver acima da banda superior.
• Fechar a posição sempre que o preço cruzar a banda do meio.
• Apenas uma posição por vez para evitar over-trading.
• Definir a distância do stop loss em 1% do preço para evitar fat tail risk, que é comum em estratégias de reversão à média.

Planejamos negociar pares de forex no timeframe de 15 minutos, um timeframe comum que oferece quantidade suficiente de operações mantendo uma qualidade razoável de trades.

Sempre começamos definindo primeiro as funções necessárias, pois isso facilita a codificação da lógica de negociação posteriormente. Neste caso, precisamos apenas programar as funções de compra e venda da seguinte forma:

#include <Trade/Trade.mqh>
CTrade trade;
//+------------------------------------------------------------------+
//| Buy Function                                                     |
//+------------------------------------------------------------------+
void executeBuy(string symbol) {
       double ask = SymbolInfoDouble(symbol, SYMBOL_ASK);
       double lots=0.01;
       double sl = ask*(1-0.01);
       trade.Buy(lots,symbol,ask,sl);
}

//+------------------------------------------------------------------+
//| Sell Function                                                    |
//+------------------------------------------------------------------+
void executeSell(string symbol) {      
       double bid = SymbolInfoDouble(symbol, SYMBOL_BID);
       double lots=0.01;
       double sl = bid*(1+0.01);
       trade.Sell(lots,symbol,bid,sl);     
}

Em seguida, inicializamos as variáveis globais e o inicializador. Isso inicializa o magic number do expert advisor, bem como o handle das Bandas de Bollinger que utilizaremos posteriormente.

input int Magic = 0;
input int bbPeriod = 100;
input double d = 2.0;

int barsTotal = 0;
int handleMa;

//+------------------------------------------------------------------+
//| Initialization                                                   |
//+------------------------------------------------------------------+
int OnInit()
{   handleBb = iBands(_Symbol,PERIOD_CURRENT,bbPeriod,0,d,PRICE_CLOSE);  
    trade.SetExpertMagicNumber(Magic);
    return INIT_SUCCEEDED;
}

Por fim, na função OnTick(), utilizamos essa lógica para garantir que o processamento da estratégia ocorra apenas a cada candle e não a cada tick:

int bars = iBars(_Symbol,PERIOD_CURRENT);
  
if (barsTotal!= bars){
   barsTotal = bars;

Obtemos os valores atuais das Bandas de Bollinger criando arrays de buffer capazes de armazenar os valores atuais copiando-os do handle.

double bbLower[], bbUpper[], bbMiddle[];
CopyBuffer(handleBb,UPPER_BAND,1,1,bbUpper);
CopyBuffer(handleBb,LOWER_BAND,1,1,bbLower);
CopyBuffer(handleBb,0,1,1,bbMiddle);

Essa verificação percorre todas as posições atualmente abertas na conta de trading para verificar se a posição foi aberta por este EA específico. Se já houver uma posição aberta por este EA, definimos a variável NotInPosition como false. Para cada posição aberta que tenha retornado à banda central, nós a fechamos.

bool NotInPosition = true;
for(int i = 0; i<PositionsTotal(); i++){
    ulong pos = PositionGetTicket(i);
    string symboll = PositionGetSymbol(i);
    if(PositionGetInteger(POSITION_MAGIC) == Magic&&symboll== _Symbol){
       NotInPosition = false;
       if((PositionGetInteger(POSITION_TYPE) == POSITION_TYPE_BUY&&price>bbMiddle[0])
       ||(PositionGetInteger(POSITION_TYPE) == POSITION_TYPE_SELL&&price<bbMiddle[0]))trade.PositionClose(pos);  
  }
}  

A lógica final de negociação será executada da seguinte forma:

if(price<bbLower[0]&&NotInPosition) executeBuy(_Symbol);
if(price>bbUpper[0]&&NotInPosition) executeSell(_Symbol);

Compile o EA e vá até o visualizador do Strategy Tester para verificar se o EA está funcionando conforme esperado.

Uma operação típica no visualizador deve se parecer com isto:

Depois retornamos ao MetaEditor e programamos os filtros de regime.

Primeiro, para a EMA de 500 períodos, queremos que a estratégia de reversão à média esteja alinhada com a tendência ao entrar no mercado, como uma confirmação adicional. Adicionamos essas linhas ao EA original:

int handleMa;
handleMa = iMA(_Symbol,PERIOD_CURRENT,maPeriod,0,MODE_EMA,PRICE_CLOSE);
 
double ma[];
CopyBuffer(handleMa,0,1,1,ma);
    
if(price<bbLower[0]&&price>ma[0]&&NotInPosition) executeBuy(_Symbol);
if(price>bbUpper[0]&&price<ma[0]&&NotInPosition) executeSell(_Symbol);

 Depois disso, programamos a função para obter o valor do filtro de Kalman:

//+------------------------------------------------------------------+
//| Kalman Filter Function                                           |
//+------------------------------------------------------------------+
double KalmanFilter(double price,double measurement_variance,double process_variance)
{
    // Prediction step (state does not change)
    double predicted_state = prev_state;
    double predicted_covariance = prev_covariance + process_variance;

    // Kalman gain calculation
    double kalman_gain = predicted_covariance / (predicted_covariance + measurement_variance);

    // Update step (incorporate new price observation)
    double updated_state = predicted_state + kalman_gain * (price - predicted_state);
    double updated_covariance = (1 - kalman_gain) * predicted_covariance;

    // Store updated values for next iteration
    prev_state = updated_state;
    prev_covariance = updated_covariance;

    return updated_state;
}

A função segue o procedimento recursivo como mostrado neste diagram:

Para implementar o filtro de regime de Kalman no EA, adicionamos essas linhas à função OnTick():

double kalman = KalmanFilter(price,mv,pv);
if(price<bbLower[0]&&price>kalman&&NotInPosition) executeBuy(_Symbol);
if(price>bbUpper[0]&&price<kalman&&NotInPosition) executeSell(_Symbol);

O filtro de Kalman funciona atualizando continuamente sua estimativa do preço real, suavizando o ruído e adaptando-se aos movimentos do preço ao longo do tempo. Ele atua essencialmente como um preditor de preço. Quando o preço cai abaixo da banda inferior das Bandas de Bollinger, isso sinaliza que o mercado está sobrevendido e espera-se que retorne à média. Aqui utilizamos o filtro de Kalman como confirmação da reversão. No cenário de sobrevenda, se o preço estiver acima da estimativa do Kalman, isso sugere que o preço já mostrou sinais de possível movimento de alta. No cenário de venda, ocorre o inverso.

No entanto, embora a média móvel também seja um filtro de regime comum, seu propósito é ligeiramente diferente do filtro de Kalman. As médias móveis funcionam como indicadores de tendência, onde a posição do preço em relação à média móvel indica a direção atual da tendência.

O código completo é o seguinte:

#include <Trade/Trade.mqh>
CTrade trade;

input double mv = 10;
input double pv = 1.0;
input int Magic = 0;
input int bbPeriod = 100;
input double d = 2.0;
input int maPeriod = 500;

double prev_state;       // Previous estimated price
double prev_covariance = 1;  // Previous covariance (uncertainty)
int barsTotal = 0;
int handleMa;
int handleBb;

//+------------------------------------------------------------------+
//| Initialization                                                   |
//+------------------------------------------------------------------+
int OnInit()
{   handleMa = iMA(_Symbol,PERIOD_CURRENT,maPeriod,0,MODE_EMA,PRICE_CLOSE);
    handleBb = iBands(_Symbol,PERIOD_CURRENT,bbPeriod,0,d,PRICE_CLOSE);
    prev_state = iClose(_Symbol,PERIOD_CURRENT,1);  
    trade.SetExpertMagicNumber(Magic);
    return INIT_SUCCEEDED;
}

//+------------------------------------------------------------------+
//| Deinitializer function                                           |
//+------------------------------------------------------------------+
void OnDeinit(const int reason)
  {
  }

//+------------------------------------------------------------------+
//| OnTick Function                                                  |
//+------------------------------------------------------------------+
void OnTick()
{
  int bars = iBars(_Symbol,PERIOD_CURRENT);
  
  if (barsTotal!= bars){
     barsTotal = bars;
     bool NotInPosition = true;
     double price = iClose(_Symbol,PERIOD_CURRENT,1); 
     double bbLower[], bbUpper[], bbMiddle[];
     double ma[];
     double kalman = KalmanFilter(price,mv,pv);
     
     CopyBuffer(handleMa,0,1,1,ma);
     CopyBuffer(handleBb,UPPER_BAND,1,1,bbUpper);
     CopyBuffer(handleBb,LOWER_BAND,1,1,bbLower);
     CopyBuffer(handleBb,0,1,1,bbMiddle);
     
     for(int i = 0; i<PositionsTotal(); i++){
         ulong pos = PositionGetTicket(i);
         string symboll = PositionGetSymbol(i);
         if(PositionGetInteger(POSITION_MAGIC) == Magic&&symboll== _Symbol){
            NotInPosition = false;
            if((PositionGetInteger(POSITION_TYPE) == POSITION_TYPE_BUY&&price>bbMiddle[0])
            ||(PositionGetInteger(POSITION_TYPE) == POSITION_TYPE_SELL&&price<bbMiddle[0]))trade.PositionClose(pos);  
      }
    }  
    
     if(price<bbLower[0]&&price>kalman&&NotInPosition) executeBuy(_Symbol);
     if(price>bbUpper[0]&&price<kalman&&NotInPosition) executeSell(_Symbol);
    }
}

//+------------------------------------------------------------------+
//| Kalman Filter Function                                           |
//+------------------------------------------------------------------+
double KalmanFilter(double price,double measurement_variance,double process_variance)
{
    // Prediction step (state does not change)
    double predicted_state = prev_state;
    double predicted_covariance = prev_covariance + process_variance;

    // Kalman gain calculation
    double kalman_gain = predicted_covariance / (predicted_covariance + measurement_variance);

    // Update step (incorporate new price observation)
    double updated_state = predicted_state + kalman_gain * (price - predicted_state);
    double updated_covariance = (1 - kalman_gain) * predicted_covariance;

    // Store updated values for next iteration
    prev_state = updated_state;
    prev_covariance = updated_covariance;

    return updated_state;
}

//+------------------------------------------------------------------+
//| Buy Function                                                     |
//+------------------------------------------------------------------+
void executeBuy(string symbol) {
       double ask = SymbolInfoDouble(symbol, SYMBOL_ASK);
       double lots=0.01;
       double sl = ask*(1-0.01);
       trade.Buy(lots,symbol,ask,sl);
}

//+------------------------------------------------------------------+
//| Sell Function                                                    |
//+------------------------------------------------------------------+
void executeSell(string symbol) {      
       double bid = SymbolInfoDouble(symbol, SYMBOL_BID);
       double lots=0.01;
       double sl = bid*(1+0.01);
       trade.Sell(lots,symbol,bid,sl);     
} 

Para alterar o filtro de regime, basta ajustar os critérios finais de compra/venda.

Análise Estatística

Compile o EA e vá até o terminal MetaTrader 5; no canto superior esquerdo clique em View → Symbols → Forex e selecione "Show Symbol" para todos os pares principais e pares secundários. Isso os colocará na sua lista de Market Watch para posterior análise de mercado.

Em seguida, vamos ao Market Scanner na seção Strategy Tester e realizamos o backtest da estratégia utilizando dados dos últimos 3 anos. Isso nos ajudará a avaliar se os filtros de regime melhoram a lucratividade para a maioria dos pares de forex que podemos negociar.

Naturalmente, o número de trades filtrados depende dos parâmetros dos indicadores. Neste estudo utilizamos valores de parâmetros comumente aplicados que filtram um número semelhante de trades: uma média móvel exponencial de 500 períodos e uma variância de medição de 10 e variância de processo de 1 para o filtro de Kalman. Os leitores são encorajados a ajustar os parâmetros para obter os resultados mais eficazes.

Primeiro testamos o resultado sem filtros de regime envolvidos como linha de base. Esperamos que, em média, o EA com filtros de regime supere a maioria dos resultados da linha de base.

O resultado dos pares de forex com melhor desempenho apresenta algo como isto:

Observamos que, em média, a estratégia executa mais de 800 operações nos últimos 3 anos para cada par, fornecendo amostras suficientes para sugerir generalidade nas conclusões. A distribuição está principalmente dispersa em torno de um profit factor entre 0.8–1.1, o que é razoável, mas nenhum par ultrapassa o profit factor de 1.1 ou a marca de Sharpe ratio de 1. De modo geral, a estratégia bruta funciona em muitos pares de forex nos últimos anos, mas a lucratividade não é particularmente impressionante. Tenha isso em mente ao compararmos com o desempenho quando filtros são aplicados.

Em seguida, realizamos o backtest da estratégia com o filtro de média móvel aplicado. Aqui estão os resultados:

Observamos que, ao utilizar o filtro de média móvel, filtramos cerca de 70% das operações originais, restando aproximadamente 250 operações para cada par. Além disso, as operações filtradas são, em média, de qualidade superior em comparação com a linha de base. A maioria dos pares de forex permanece entre um profit factor de 0.9 e 1.2, com o par de melhor desempenho alcançando um profit factor de 1.33 e um Sharpe ratio de 2.34. Isso sugere que utilizar a média móvel como filtro melhorou, no geral, a lucratividade dessa estratégia clássica de reversão à média.

Agora, vamos abordar a questão principal e verificar como a estratégia se comporta com o filtro de Kalman.

O filtro de Kalman filtrou cerca de 60% das operações originais, restando aproximadamente 350 operações para cada par. Pela distribuição, vemos que a maioria dos profit factors permanece entre 0.85 e 1.2, o que é semelhante ao desempenho da média móvel e melhor do que o desempenho da linha de base. Além disso, considerando o número total de pares de forex com profit factor acima de 1.0 e acima de 1.2, podemos concluir que tanto a média móvel quanto o filtro de Kalman são semelhantes em termos de melhoria da qualidade média das operações dessa estratégia. O filtro de Kalman não é superior à média móvel neste cenário, sugerindo que maior complexidade nem sempre resulta em melhor desempenho.

Mencionamos que o uso do filtro de Kalman difere ligeiramente do uso da média móvel em termos de lógica de filtragem. No entanto, neste caso, ambos parecem ter desempenho semelhante na filtragem de operações ruins. Para investigar se eles estão filtrando operações semelhantes, analisaremos as diferenças entre as operações filtradas para determinar se o efeito do filtro de Kalman é apenas equivalente ao da EMA.

Como referência, escolheremos o par forex AUDUSD, pois ele apresentou o melhor desempenho entre as duas condições mencionadas acima.

O resultado do backtest da linha de base:

O resultado do backtest do filtro de média móvel exponencial:

O resultado do filtro de Kalman:

A primeira coisa que podemos observar é que a taxa de acerto da versão com média móvel é significativamente maior do que a da versão base ou da versão com Kalman, enquanto seu lucro médio é menor e sua perda média é maior do que as outras. Isso já sugere que a versão com média móvel está realizando operações muito diferentes da versão com Kalman. Para investigar mais profundamente, obtemos o relatório Excel do backtest clicando com o botão direito na página de resultados do backtest:

Para cada relatório, anotamos o número da linha do indicador "Deals":

Em seguida, abrimos Python ou Jupyter Notebook. Copiamos e colamos o código a seguir, alteramos o número de skiprow para o número da linha "Deals" de cada relatório Excel, e pronto.

import pandas as pd
import matplotlib.pyplot as plt
from matplotlib_venn import venn3
df1 = pd.read_excel("baseline.xlsx", skiprows=1805)
df2 = pd.read_excel("ma.xlsx", skiprows =563 )
df3 = pd.read_excel("kalman.xlsx",skiprows = 751)
df1 = df1[['Time']][1:-1]
df1 = df1[df1.index % 2 == 0]  # Filter for rows with odd indices
df2 = df2[['Time']][1:-1]
df2 = df2[df2.index % 2 == 0]
df3 = df3[['Time']][1:-1]
df3 = df3[df3.index % 2 == 0]

# Convert "Time" columns to datetime
df1['Time'] = pd.to_datetime(df1['Time'])
df2['Time'] = pd.to_datetime(df2['Time'])
df3['Time'] = pd.to_datetime(df3['Time'])

# Find intersections
set1 = set(df1['Time'])
set2 = set(df2['Time'])
set3 = set(df3['Time'])

# Create the Venn diagram
venn_labels = {
    '100': len(set1 - set2 - set3),  # Only in df1
    '010': len(set2 - set1 - set3),  # Only in df2
    '001': len(set3 - set1 - set2),  # Only in df3
    '110': len(set1 & set2 - set3),  # In df1 and df2
    '011': len(set2 & set3 - set1),  # In df2 and df3
    '101': len(set1 & set3 - set2),  # In df1 and df3
    '111': len(set1 & set2 & set3)   # In all three
}

# Plot the Venn diagram
plt.figure(figsize=(8, 8))
venn3(subsets=venn_labels, set_labels=('Baseline', 'EMA', 'Kalman'))
plt.title("Venn Diagram of Time Overlap")
plt.show()

A lógica desse código é basicamente armazenar os horários de saída das posições em três dataframes para cada versão, ignorando linhas e selecionando linhas com índices pares. Depois armazenamos cada dataframe em um conjunto e obtemos o diagrama de Venn comparando se os horários se sobrepõem. O gráfico mostrará o número de operações em cada região, separadas por cores diferentes. Observe que mesmo a versão base não conterá todas as operações que as versões EMA e Kalman possuem, pois definimos a estratégia para operar apenas uma posição por vez, o que faz com que ela perca algumas operações que as outras versões possuem.

Aqui está o diagrama de Venn gerado:

Observando a área onde Kalman e MA se sobrepõem, encontramos que entre centenas de operações realizadas por cada versão, apenas 71 operações foram iguais. Isso sugere que os efeitos de filtragem desses dois métodos são bastante diferentes, apesar de filtrarem uma quantidade semelhante de operações da estratégia original. Isso reforça ainda mais a importância de estudar e utilizar o filtro de Kalman, pois ele fornece uma opção de filtragem única que difere dos filtros de tendência comuns.

Conclusão

Neste artigo apresentamos um algoritmo recursivo avançado para trading algorítmico chamado filtro de Kalman. Começamos explicando seus mecanismos e implementações, fornecendo visualizações e fórmulas. Em seguida, percorremos todo o processo de desenvolvimento de uma estratégia de reversão à média para forex e implementamos o filtro de Kalman em MQL5. Por fim, realizamos diversas análises estatísticas, incluindo market scanning, backtesting e comparações de sobreposição, para avaliar sua capacidade de filtragem em comparação com a média móvel e a linha de base.

No trading real, o filtro de Kalman é amplamente utilizado por grandes instituições quantitativas, mas ainda é pouco conhecido no trading de varejo. Este artigo busca fornecer insights e implementação prática para a comunidade MQL5, oferecendo uma abordagem para avaliar a capacidade de filtragem do filtro de Kalman, permitindo que ele seja melhor integrado ao desenvolvimento de estratégias futuras. Os leitores são incentivados a experimentar esse framework por conta própria e incorporá-lo ao seu arsenal de trading.

Tabela de Arquivos

Nome do Arquivo	Uso dos Arquivos
Visualizações de Kalman.ipynb	O código em Python para as visualizações utilizadas neste artigo
MR-Kalman.mq5	O código do Expert Advisor