# API Parser - Análise de Expressões

A classe `Parser` é o ponto de entrada principal da biblioteca Reductio, responsável por converter strings de expressões matemáticas em árvores sintáticas abstratas (AST).

## 📋 Visão Geral

```java
package com.reductio;

public final class Parser {
    // Métodos estáticos para análise de expressões
}
```

A classe Parser é uma classe utilitária final que fornece métodos estáticos para:
- Análise de expressões matemáticas
- Validação de sintaxe
- Obtenção de informações sobre funções suportadas

## 🔧 Métodos Principais

### `parse(String expression)`

Converte uma string de expressão matemática em uma árvore de expressão.

**Assinatura:**
```java
public static Expr parse(String expression) throws ParseException
```

**Parâmetros:**
- `expression` - A expressão matemática como string

**Retorna:**
- `Expr` - A árvore de expressão analisada

**Exceções:**
- `ParseException` - Se a expressão for inválida

**Exemplos:**

```java
// Expressões aritméticas básicas
Expr expr1 = Parser.parse("2 + 3 * 4");
Expr expr2 = Parser.parse("(a + b) * (c - d)");

// Expressões com variáveis
Expr expr3 = Parser.parse("2x + 3y - 5");
Expr expr4 = Parser.parse("x^2 + 2x + 1");

// Expressões com funções
Expr expr5 = Parser.parse("sin(x) + cos(y)");
Expr expr6 = Parser.parse("ln(x) + log(y)");
Expr expr7 = Parser.parse("sqrt(x^2 + y^2)");

// Expressões complexas
Expr expr8 = Parser.parse("(x^2 + 2x + 1) / (x + 1)");
Expr expr9 = Parser.parse("2^(3x + 1) - e^x");
```

### `isValid(String expression)`

Verifica se uma string de expressão é sintaticamente correta.

**Assinatura:**
```java
public static boolean isValid(String expression)
```

**Parâmetros:**
- `expression` - A expressão para validar

**Retorna:**
- `boolean` - `true` se a expressão for válida

**Exemplos:**

```java
// Expressões válidas
System.out.println(Parser.isValid("2 + 3"));         // true
System.out.println(Parser.isValid("x^2 + 1"));       // true
System.out.println(Parser.isValid("sin(x)"));        // true

// Expressões inválidas
System.out.println(Parser.isValid("2 + + 3"));       // false
System.out.println(Parser.isValid("(2 + 3"));        // false
System.out.println(Parser.isValid("sin(cos())"));    // false
```

### `getSupportedFunctions()`

Retorna o conjunto de nomes de funções suportadas.

**Assinatura:**
```java
public static Set<String> getSupportedFunctions()
```

**Retorna:**
- `Set<String>` - Conjunto imutável de nomes de funções

**Exemplo:**

```java
Set<String> funcoes = Parser.getSupportedFunctions();
System.out.println("Funções suportadas: " + funcoes);

// Verificar se uma função é suportada
if (funcoes.contains("sin")) {
    System.out.println("Função seno é suportada");
}
```

## 📝 Sintaxe Suportada

### Operadores Aritméticos

| Operador | Descrição | Precedência | Exemplo |
|----------|-----------|-------------|---------|
| `+` | Adição | 1 | `2 + 3` |
| `-` | Subtração | 1 | `5 - 2` |
| `*` | Multiplicação | 2 | `3 * 4` |
| `/` | Divisão | 2 | `8 / 2` |
| `^` | Potenciação | 3 | `2^3` |
| `()` | Parênteses | 4 | `(2 + 3) * 4` |

### Funções Matemáticas

#### Trigonométricas
- `sin(x)` - Seno
- `cos(x)` - Cosseno  
- `tan(x)` - Tangente
- `sec(x)` - Secante
- `csc(x)` - Cossecante
- `cot(x)` - Cotangente

#### Hiperbólicas
- `sinh(x)` - Seno hiperbólico
- `cosh(x)` - Cosseno hiperbólico
- `tanh(x)` - Tangente hiperbólica

#### Logarítmicas
- `ln(x)` - Logaritmo natural
- `log(x)` - Logaritmo base 10

#### Outras
- `sqrt(x)` - Raiz quadrada
- `abs(x)` - Valor absoluto

### Multiplicação Implícita

O parser suporta multiplicação implícita em vários casos:

```java
// Número seguido de variável
Parser.parse("2x");        // Interpretado como "2 * x"
Parser.parse("3x^2");      // Interpretado como "3 * x^2"

// Parênteses adjacentes
Parser.parse("(a + b)(c + d)"); // Interpretado como "(a + b) * (c + d)"

// Número seguido de função
Parser.parse("2sin(x)");   // Interpretado como "2 * sin(x)"

// Variável seguida de parênteses
Parser.parse("x(y + z)");  // Interpretado como "x * (y + z)"
```

### Constantes e Variáveis

```java
// Números inteiros e decimais
Parser.parse("42");
Parser.parse("3.14159");
Parser.parse("-2.5");

// Notação científica
Parser.parse("1.5e-3");
Parser.parse("2.1E+4");

// Variáveis (letras seguidas opcionalmente por dígitos)
Parser.parse("x");
Parser.parse("var1");
Parser.parse("alpha");
Parser.parse("x1y2");
```

## ⚠️ Tratamento de Erros

### ParseException

A classe `ParseException` é lançada quando ocorrem erros de análise:

```java
public class ParseException extends RuntimeException {
    public ParseException(String message);
    public ParseException(String message, Throwable cause);
}
```

**Casos comuns de erro:**

```java
try {
    Expr expr = Parser.parse("2 + + 3");
} catch (ParseException e) {
    System.out.println("Erro: " + e.getMessage());
    // Erro: Failed to parse expression: 2 + + 3
}
```

### Validação Preventiva

```java
public static Expr parseComValidacao(String expressao) {
    if (!Parser.isValid(expressao)) {
        throw new IllegalArgumentException("Expressão inválida: " + expressao);
    }
    return Parser.parse(expressao);
}
```

## 🔍 Normalização de Expressões

O parser aplica automaticamente várias normalizações:

### 1. Remoção de Espaços
```java
Parser.parse("2 + 3 * 4");    // Normalizado para "2+3*4"
Parser.parse("sin( x )");     // Normalizado para "sin(x)"
```

### 2. Inserção de Multiplicação Implícita
```java
Parser.parse("2x");           // Normalizado para "2*x"
Parser.parse("(a+b)(c+d)");   // Normalizado para "(a+b)*(c+d)"
```

### 3. Tratamento de Sinal Negativo
```java
Parser.parse("-2x + 3");      // Maneja corretamente o sinal negativo
Parser.parse("x + -3");       // Normalizado adequadamente
```

## 💡 Padrões de Uso

### 1. Parser com Tratamento de Erro

```java
public class SafeParser {
    public static Optional<Expr> tryParse(String expression) {
        try {
            return Optional.of(Parser.parse(expression));
        } catch (ParseException e) {
            System.err.println("Erro ao analisar: " + e.getMessage());
            return Optional.empty();
        }
    }
}
```

### 2. Validador de Entrada

```java
public class ExpressionValidator {
    public static List<String> validateExpressions(List<String> expressions) {
        return expressions.stream()
            .filter(Parser::isValid)
            .collect(Collectors.toList());
    }
}
```

### 3. Parser em Lote

```java
public class BatchParser {
    public static List<Expr> parseMultiple(String... expressions) {
        return Arrays.stream(expressions)
            .map(Parser::parse)
            .collect(Collectors.toList());
    }
}
```

## 🎯 Exemplos Avançados

### Expressões Matemáticas Complexas

```java
// Funções compostas
Expr expr1 = Parser.parse("sin(cos(x))");
Expr expr2 = Parser.parse("ln(sqrt(x^2 + 1))");

// Expressões racionais
Expr expr3 = Parser.parse("(x^2 + 1) / (x - 1)");
Expr expr4 = Parser.parse("(2x + 3) / (x^2 + x + 1)");

// Expressões trigonométricas
Expr expr5 = Parser.parse("sin(2x) + cos(3x + 1)");
Expr expr6 = Parser.parse("tan(x/2) - cot(2x)");

// Expressões exponenciais
Expr expr7 = Parser.parse("2^(x+1) + 3^(2x-1)");
Expr expr8 = Parser.parse("e^(sin(x)) + ln(cos(x))");
```

### Tratamento de Casos Especiais

```java
public class RobustParser {
    public static Expr parseWithDefaults(String expression, Expr defaultExpr) {
        if (expression == null || expression.trim().isEmpty()) {
            return defaultExpr;
        }
        
        try {
            return Parser.parse(expression);
        } catch (ParseException e) {
            System.err.println("Usando expressão padrão devido a erro: " + e.getMessage());
            return defaultExpr;
        }
    }
    
    public static List<String> getParseErrors(List<String> expressions) {
        List<String> errors = new ArrayList<>();
        
        for (String expr : expressions) {
            try {
                Parser.parse(expr);
            } catch (ParseException e) {
                errors.add("Erro em '" + expr + "': " + e.getMessage());
            }
        }
        
        return errors;
    }
}
```

## 🔗 Classes Relacionadas

- [`Expr`](API-Expr.md) - Classe base para todas as expressões
- [`Function`](API-Function.md) - Identificação automática de funções
- [`BinaryOp`](API-BinaryOp.md) - Operações binárias
- [`Constant`](API-Constant.md) - Valores constantes
- [`Variable`](API-Variable.md) - Variáveis

## 📚 Próximos Passos

- 📖 Explore a [API Expr](API-Expr.md) para trabalhar com expressões analisadas
- 🔍 Aprenda sobre [Identificação de Funções](API-Function.md)
- 💡 Veja [Exemplos de Uso](Exemplos-de-Uso.md) práticos
- 🎯 Confira [Casos de Estudo](Casos-de-Estudo.md) reais

---

[← Voltar: Guia de Início Rápido](Guia-Inicio-Rapido.md) | [Home](Home.md) | [Próximo: API Expr →](API-Expr.md)