Aula 02 - Tipos Primitivos, Operadores Aritméticos, Relacionais e Lógicos

Navegação Rápida

📍 Disciplina: 01 Lógica de Programação | 🗺️ Área: 06 Computação e Telecomunicações | 🏠 Hub Principal

Metadados da Aula

• Área: 06 Computação e Telecomunicações
• Carga Horária Equivalente: 4 horas-aula teóricas e práticas
• Pré-requisitos: Aula 01 - Algoritmos e Arquitetura
• Palavras-chave: IEEE 754 Dupla Precisão, Mantissa, Épsilon da Máquina, Cancelamento Catastrófico, Números Complexos Nativos, Fasores, Operadores Bitwise, Máscara de Bits, Precedência de Operadores

---

📌 Sumário da Aula

1. 🧭 1. Contextualização e Objetivos de Aprendizagem
2. 📋 2. Sumário Executivo dos Tópicos
3. ⚡ 3. Fundamentação Teórica e Modelagem Matemática
   • 3.1 Sistema de Tipos do Python: Objetos, Referências e Tipagem Forte
   • 3.2 Representação Numérica de Ponto Flutuante IEEE 754 e Propagação de Erros
   • 3.3 Números Complexos Nativos e Análise Fasorial de Circuitos CA
   • 3.4 Operadores Bitwise e Manipulação de Palavras de Telemetria
   • 3.5 Aritmética Inteira de Precisão Arbitrária e Identidade da Divisão
4. 🖼️ 4. Diagrama Técnico Integrado
5. 💻 5. Implementação Prática em Engenharia Elétrica
   • 5.1 Decodificador Bitwise de Registradores de Telemetria de Subestação
   • 5.2 Calculadora Fasorial de Impedância e Potência com cmath
6. 📝 6. Banco de Questões de Fixação e Concursos Auditados
   • Questão 01 — Limites de Precisão IEEE 754 e Cancelamento Catastrófico em Matrizes de Admitância
   • Questão 02 — Álgebra Bitwise em Máscaras de Estado de Relé de Proteção (Protocolo Modbus)
   • Questão 03 — Aritmética de Piso (Floor Division) e Módulo com Operandos Negativos
7. 📚 7. Referências Bibliográficas e Normas Técnicas

---

🧭 1. Contextualização e Objetivos de Aprendizagem

O cálculo computacional aplicado à Engenharia Elétrica exige a manipulação de grandezas físicas com ordens de grandeza díspares: de capacitâncias parasitas na ordem de picofarads ($10^{-12}\text{ F}$) a potências de curto-circuito em gigavolt-amperes ($10^9\text{ VA}$), além de variáveis bidimensionais senoidais (fasores de tensão e corrente) e registradores binários de estado de chaves seccionadoras e disjuntores.

Esta aula estuda em profundidade a representação binária e a álgebra computacional dos tipos primitivos em Python 3. Analisa o padrão internacional IEEE 754 para números reais de dupla precisão, derivando formalmente as causas dos erros de arredondamento e o fenômeno de cancelamento catastrófico. Examina a aplicação dos números complexos nativos para circuitos elétricos em corrente alternada e a álgebra de operadores em nível de bit (bitwise) para decodificação de telemetrias industriais.

Ao término desta aula, o engenheiro será capaz de:

• Compreender a anatomia binária do padrão IEEE 754 de 64 bits (sinal, expoente com viés e mantissa) e aplicar funções seguras de comparação numérica com tolerância controlada (math.isclose).
• Manipular números complexos no plano de Argand-Gauss para cálculo direto de impedâncias, admitâncias e potências complexas em regime permanente senoidal.
• Projetar máscaras de bits eficientes utilizando operadores lógicos &, |, ^, ~, << e >> para leitura, configuração e alternância de flags em palavras de comunicação industrial (Modbus/DNP3).
• Avaliar a precedência rigorosa de operadores em expressões matemáticas complexas e dominar a aritmética de divisão inteira e resto com números negativos.

---

📋 2. Sumário Executivo dos Tópicos

• Sistema de Tipos do Python: Dinâmico (variáveis são ponteiros para objetos tipados no Heap), Forte (sem coerção implícita insegura de tipos incompatíveis) e Orientado a Objetos (todos os tipos primitivos são instâncias de classes derivadas de object).
• IEEE 754 Dupla Precisão (float): 64 bits divididos em 1 bit de sinal ($S$), 11 bits de expoente ($E$) com viés de 1023, e 52 bits de mantissa fracionária ($M$). Precisão decimal de 15 a 17 dígitos significativos.
• Épsilon da Máquina (${ϵ}_{\text{mach}}$): Menor incremento positivo tal que $1,0+ϵ\ne 1,0$. Em ponto flutuante de 64 bits, ${ϵ}_{\text{mach}}=2^{-52}\approx 2,2204\times 10^{-16}$.
• Números Complexos Nativos (complex): Estrutura interna em C formada por dois valores double consecutivos (128 bits total: parte real e parte imaginária). Sufixo literal j (ex.: 3.0 + 4.0j).
• Álgebra Bitwise: Operações em nível de bit sobre números inteiros: conjunção (&), disjunção (|), ou-exclusivo (^), negação binária (~), deslocamento à esquerda (<<) e à direita (>>).
• Divisão com Piso e Módulo: O operador // calcula rigorosamente $\lfloor a/b\rfloor$ (arredondamento em direção ao infinito negativo), preservando a identidade $a=(a//b)\cdot b+(a\%b)$.

---

⚡ 3. Fundamentação Teórica e Modelagem Matemática

3.1 Sistema de Tipos do Python: Objetos, Referências e Tipagem Forte

Diferente de linguagens com tipagem estática (como C ou Java), onde a variável é um contêiner de tamanho fixo em memória tipado no momento da compilação:

Propriedades Fundamentais:

1. Tipagem Dinâmica: O tipo é uma propriedade intrínseca do objeto em memória, e não do identificador. Uma variável pode apontar para um int e, no comando seguinte, apontar para uma str.
2. Tipagem Forte: O interpretador recusa categoricamente operações entre tipos que não compartilham compatibilidade semântica explícita. Tentar somar uma cadeia de caracteres com um número ("Tensão: " + 220) resulta imediatamente em TypeError, evitando conversões implícitas erráticas comuns em JavaScript ou PHP.

---

3.2 Representação Numérica de Ponto Flutuante IEEE 754 e Propagação de Erros

No Python padrão (CPython), o tipo primitivo float é implementado internamente como um número de ponto flutuante em conformidade com o padrão internacional IEEE 754-2008 de Dupla Precisão (binary64), ocupando exatamente 64 bits (8 bytes) de memória:

3.2.1 Formulação Analítica do Valor Real

Para um número normalizado ($1\le E\le 2046$), o valor decimal representado pelo padrão binário é calculado analiticamente por:

$x=(-1{)}^S\cdot \left(1+{\sum }_{i=1}^{52}{b}_{52-i}\cdot 2^{-i}\right)\cdot 2^{E-1023}$

Onde:

• $S\in \{0,1\}$ é o bit de sinal ($S=0$ indica positivo; $S=1$ indica negativo);
• $E$ é o expoente inteiro representado em código com viés (bias) de $1023$, variando no intervalo $0<E<2047$ (o expoente real é $e=E-1023$, cobrindo a faixa de $2^{-1022}\approx 2,2\times 10^{-308}$ a $2^{+1023}\approx 1,8\times 10^{+308}$);
• $M$ é a fração da mantissa (52 bits), assumindo um bit 1 implícito à esquerda da vírgula binária (hidden bit ou bit normalizado).

3.2.2 A Origem da Dízima Periódica Binária e Inexatidão Numérica

Um número racional possui representação finita em uma determinada base se e somente se os fatores primos do seu denominador forem fatores da base. Na base decimal ($10=2\times 5$), frações como $1/2=0,5$, $1/4=0,25$ e $1/10=0,1$ são finitas.

Contudo, na base binária (base 2), os únicos fatores primos possíveis são potências de 2. A fração decimal $1/10=0,1_{10}$ expandida em base binária torna-se uma dízima periódica infinita:

$0,1_{10}=\frac{1}{16}+\frac{1}{32}+\frac{1}{256}+\frac{1}{512}+\cdots =0,00011001100110011{\dots }_2$

Como o registrador IEEE 754 dispõe de apenas 52 bits para a mantissa, a expansão deve ser truncada e arredondada no 53º bit, resultando no valor efetivamente armazenado:

$0,1000000000000000055511151231257827021181583404541015625$

Analogamente, $0,2_{10}$ sofre o mesmo truncamento. Quando o processador executa a soma binária de $0,1+0,2$:

$0,1+0,2=0,3000000000000000444089209850062616169452667236328125$

Aplicações Canônicas em Engenharia:

1. Leitura de um Bit Específico (Teste de Alarme com Máscara AND): Para testar se o bit na posição $k$ está ativo: $\text{is\_ativo}=(\text{palavra\_status}\&(1\ll k))\ne 0$
2. Ativação Forçada de um Bit (Ligar Carga com Máscara OR): Para forçar o bit $k$ para nível 1 sem alterar os demais: $\text{palavra\_status}=\text{palavra\_status}|(1\ll k)$
3. Desativação Forçada de um Bit (Desligar Carga com Máscara AND-NOT): Para forçar o bit $k$ para nível 0 sem alterar os demais: $\text{palavra\_status}=\text{palavra\_status}\&\sim (1\ll k)$
4. Alternância de Estado (Toggle com Máscara XOR): Para inverter o bit $k$ ($0\to 1$ ou $1\to 0$): $\text{palavra\_status}=\text{palavra\_status}\wedge (1\ll k)$

---

3.5 Aritmética Inteira de Precisão Arbitrária e Identidade da Divisão

3.5.1 Inteiros com Precisão Arbitrária (Bignum)

Em Python 3, o tipo int não possui limite superior ou inferior fixado em 32 ou 64 bits. O CPython implementa inteiros como uma matriz dinâmica de dígitos em base $2^{30}$ (em plataformas de 64 bits). Operações como $2^{1000}$ executam com exatidão matemática irrestrita, alocando memória dinamicamente no Heap.

3.5.2 Aritmética de Piso (//) e Módulo (%)

Na maioria das linguagens com raízes no C clássico, a divisão inteira é truncada em direção ao zero (truncamento). No Python, a divisão inteira a // b é definida formalmente pelo piso matemático ($\lfloor a/b\rfloor$), que arredonda sempre em direção ao infinito negativo:

$\boxed{q=a//b=\lfloor a/b\rfloor }$

O operador de resto % obedece rigorosamente à identidade da divisão euclidiana:

$\boxed{a=(a//b)\cdot b+(a\%b)}$

Essa definição garante propriedades algébricas consistentes para operandos negativos:

• Exemplo: $-7//2$: $-7/2=-3,5⟹\lfloor -3,5\rfloor =-4$.
• Resto correspondente $-7\%2$: $-7=(-4)\cdot 2+r⟹r=-7-(-8)=+1$

Em computação de engenharia, o fato de $(a\%b)$ manter sempre o sinal do divisor $b$ simplifica o cálculo de deslocamentos circulares de fase e indexação de buffers cíclicos sem necessitar de correções condicionais para valores negativos.

---

🖼️ 4. Diagrama Técnico Integrado

O diagrama técnico completo a seguir sintetiza a arquitetura binária dos dados: a representação de 64 bits do padrão IEEE 754 de ponto flutuante, as operações bitwise fundamentais com registradores de telemetria e o sistema de tipagem dinâmica forte do Python:

---

💻 5. Implementação Prática em Engenharia Elétrica

5.1 Decodificador Bitwise de Registradores de Telemetria de Subestação

O módulo a seguir decodifica uma palavra de status de 16 bits recebida de um IED (Dispositivo Eletrônico Inteligente) de subestação via protocolo Modbus, aplicando máscaras bitwise para isolar alarmes e estados operacionais:

"""
Decodificador de Registrador de Telemetria de Subestacao (Protocolo Industrial).
 
Mapeamento da Palavra de 16 bits (Word):
- Bit 0: Disjuntor 52-1 Fechado (1) / Aberto (0)
- Bit 1: Seccionadora 89-1 Fechada (1) / Aberta (0)
- Bit 2: Alarme de Sobretemperatura no Trafo (ANSI 49)
- Bit 3: Disparo por Sobrecorrente Instantanea (ANSI 50)
- Bit 4: Disparo por Sobrecorrente Temporizada (ANSI 51)
- Bit 5: Alarme de Nivel Baixo de Oleo Isolante
- Bits 6-7: Modo Operacional (00: Local, 01: Remoto Supervisorio, 10: Bloqueado)
"""
 
# Definicao de mascaras de bits usando literais binarios
MASK_DISJUNTOR   = 1 << 0  # 0b00000001
MASK_SECCIONADORA = 1 << 1  # 0b00000010
MASK_SOBRETEMP   = 1 << 2  # 0b00000100
MASK_TRIP_50     = 1 << 3  # 0b00001000
MASK_TRIP_51     = 1 << 4  # 0b00010000
MASK_NIVEL_OLEO  = 1 << 5  # 0b00100000
MASK_MODO_OP     = 0b11 << 6 # Bits 6 e 7
 
 
def decodificar_telemetria(registro_raw: int) -> dict:
    """Decodifica palavra binaria de 16 bits em um dicionario estruturado."""
    # Leitura individual de bits com operador AND (&)
    disjuntor_fechado = bool(registro_raw & MASK_DISJUNTOR)
    seccionadora_fechada = bool(registro_raw & MASK_SECCIONADORA)
    alarme_sobretemp = bool(registro_raw & MASK_SOBRETEMP)
    trip_instantaneo = bool(registro_raw & MASK_TRIP_50)
    trip_temporizado = bool(registro_raw & MASK_TRIP_51)
    alarme_oleo = bool(registro_raw & MASK_NIVEL_OLEO)
 
    # Extrai campo de modo operacional com deslocamento a direita
    modo_raw = (registro_raw & MASK_MODO_OP) >> 6
    modos_tabela = {
        0b00: "LOCAL (Comando em Painel)",
        0b01: "REMOTO (Centro de Operacoes SCADA)",
        0b10: "BLOQUEADO (Manutencao)",
        0b11: "INDEFINIDO / FALHA",
    }
    modo_operacao = modos_tabela.get(modo_raw, "ERRO")
 
    return {
        "registro_hex": f"0x{registro_raw:04X}",
        "disjuntor_fechado": disjuntor_fechado,
        "seccionadora_fechada": seccionadora_fechada,
        "alarme_sobretemp": alarme_sobretemp,
        "trip_protecao": trip_instantaneo or trip_temporizado,
        "alarme_oleo": alarme_oleo,
        "modo_operacao": modo_operacao,
    }
 
 
def main():
    # Simula palavra recebida de telemetria: 0b01001101 = 0x004D
    # (Disjuntor Fechado, Sobretemperatura Ativa, Trip 50 Ativo, Modo Remoto)
    telemetria_exemplo = 0x004D
    dados = decodificar_telemetria(telemetria_exemplo)
 
    print("=====================================================")
    print(f"   DIAGNOSTICO DE TELEMETRIA: REGISTRO {dados['registro_hex']}   ")
    print("=====================================================")
    print(f"Estado do Disjuntor 52-1     : {'FECHADO' if dados['disjuntor_fechado'] else 'ABERTO'}")
    print(f"Estado da Seccionadora 89-1  : {'FECHADA' if dados['seccionadora_fechada'] else 'ABERTA'}")
    print(f"Alarme Termico (ANSI 49)     : {'[ATIVO - RISCO]' if dados['alarme_sobretemp'] else 'NORMAL'}")
    print(f"Disparo de Protecao (ANSI 50): {'[TRIP DETECTADO]' if dados['trip_protecao'] else 'NORMAL'}")
    print(f"Nivel de Oleo Isolante       : {'[CRITICO]' if dados['alarme_oleo'] else 'NORMAL'}")
    print(f"Modo de Controle             : {dados['modo_operacao']}")
    print("=====================================================")
 
 
if __name__ == "__main__":
    main()

---

5.2 Calculadora Fasorial de Impedância e Potência com cmath

A aplicação a seguir resolve de forma analítica e nativa as correntes e o triângulo de potências de um circuito RLC paralelo excitado por fonte de tensão alternada:

"""
Calculadora Fasorial de Circuitos em Regime Permanente Senoidal.
Utiliza os tipos complex nativos e a biblioteca padrao cmath.
"""
 
import cmath
import math
 
 
def analisar_circuito_rlc_serie(v_rms: float, freq_hz: float, r: float, l_henry: float, c_farad: float):
    """
    Calcula os parametros fasoriais completos de um ramo RLC serie.
    """
    omega = 2.0 * math.pi * freq_hz
 
    # Reatancias indutiva e capacitiva
    x_l = omega * l_henry
    x_c = 1.0 / (omega * c_farad)
 
    # Impedancia complexa Z = R + j(XL - XC)
    z_complexo = complex(r, x_l - x_c)
 
    # Fasor de tensao com angulo zero de referencia (V = V_rms + 0j)
    v_fasor = complex(v_rms, 0.0)
 
    # Corrente fasorial pela Lei de Ohm: I = V / Z
    i_fasor = v_fasor / z_complexo
 
    # Potencia complexa: S = V * conj(I)
    s_complexo = v_fasor * i_fasor.conjugate()
 
    # Modulo e fase da corrente
    i_modulo, i_fase_rad = cmath.polar(i_fasor)
    z_modulo, z_fase_rad = cmath.polar(z_complexo)
 
    p_ativa = s_complexo.real
    q_reativa = s_complexo.imag
    s_aparente = abs(s_complexo)
    fator_potencia = p_ativa / s_aparente
 
    return {
        "omega_rad_s": omega,
        "z_complexo": z_complexo,
        "z_modulo": z_modulo,
        "z_fase_graus": math.degrees(z_fase_rad),
        "i_fasor": i_fasor,
        "i_modulo": i_modulo,
        "i_fase_graus": math.degrees(i_fase_rad),
        "potencia_ativa_w": p_ativa,
        "potencia_reativa_var": q_reativa,
        "potencia_aparente_va": s_aparente,
        "fator_potencia": fator_potencia,
        "natureza": "INDUTIVA" if q_reativa > 0 else "CAPACITIVA" if q_reativa < 0 else "RESISTIVA PURA",
    }
 
 
def main():
    # Ensaio de circuito industrial: V = 380V, 60Hz, R = 12 Ohm, L = 45mH, C = 150uF
    resultado = analisar_circuito_rlc_serie(
        v_rms=380.0,
        freq_hz=60.0,
        r=12.0,
        l_henry=0.045,
        c_farad=150e-6
    )
 
    print("=====================================================")
    print("         ANALISE FASORIAL DE CIRCUITO RLC SERIE      ")
    print("=====================================================")
    print(f"Frequencia Angular (Omega) : {resultado['omega_rad_s']:.2f} rad/s")
    print(f"Impedancia Complexa (Z)    : {resultado['z_complexo']:.3f} Ohms")
    print(f"Modulo da Impedancia |Z|   : {resultado['z_modulo']:.3f} Ohms (Fase: {resultado['z_fase_graus']:.2f}°)")
    print(f"Corrente Fasorial Eficaz   : {resultado['i_modulo']:.2f} A (Angulo: {resultado['i_fase_graus']:.2f}°)")
    print("-----------------------------------------------------")
    print(f"Potencia Ativa (P)         : {resultado['potencia_ativa_w']:.2f} W")
    print(f"Potencia Reativa (Q)       : {resultado['potencia_reativa_var']:.2f} VAr")
    print(f"Potencia Aparente (|S|)    : {resultado['potencia_aparente_va']:.2f} VA")
    print(f"Fator de Potencia (FP)     : {resultado['fator_potencia']:.4f} ({resultado['natureza']})")
    print("=====================================================")
 
 
if __name__ == "__main__":
    main()

---

📝 6. Banco de Questões de Fixação e Concursos Auditados

Questão 01 — Limites de Precisão IEEE 754 e Cancelamento Catastrófico em Matrizes de Admitância

(Petrobras — Engenharia Elétrica / Concurso Público)
Em algoritmos de fluxo de carga para sistemas interligados de grande porte, a admitância de ramo entre duas barras elétricas $k$ e $m$ é dada pelo inverso da impedância de linha: $y_{km}=\frac{1}{z_{km}}=\frac{1}{r_{km}+j{x}_{km}}$ Considere uma linha de transmissão curta de extra-alta tensão ($500\text{ kV}$) em que a resistência ôhmica é extremamente baixa: $r_{km}=1,0\times 10^{-5}\text{ pu}$ e a reatância indutiva é $x_{km}=0,05\text{ pu}$.
Ao calcular a condutância de ramo $g_{km}=\Re \{y_{km}\}$ através da fórmula: $g_{km}=\frac{r_{km}}{r_{km}^2+x_{km}^2}$ um algoritmo computacional executado em precisão simples (IEEE 754 de 32 bits, com mantissa de 23 bits e ${ϵ}_{\text{mach}}\approx 1,19\times 10^{-7}$) sofre com severa degradação numérica.
a) Calcule o valor analítico exato de $g_{km}$.
b) Explique o fenômeno de Cancelamento Catastrófico e avalie se o termo $r_{km}^2$ pode ser desprezado frente a $x_{km}^2$ sem gerar instabilidade na inversão matricial em precisão dupla de 64 bits.

💡 Resolução Analítica Passo a Passo:

a) Cálculo Analítico Exato de $g_{km}$: Substituindo os valores nominais: $r_{km}^2=(1,0\cdot 10^{-5}{)}^2=1,0\cdot 10^{-10}{\text{ pu}}^2$ $x_{km}^2=(0,05{)}^2=2,5\cdot 10^{-3}=2,5000000000\cdot 10^{-3}{\text{ pu}}^2$ A soma no denominador resulta em: $r_{km}^2+x_{km}^2=1,0\cdot 10^{-10}+2,5\cdot 10^{-3}=0,0025000001{\text{ pu}}^2$ A condutância teórica exata é: $g_{km}=\frac{1,0\cdot 10^{-5}}{0,0025000001}\approx \boxed{3,99999984\cdot 10^{-3}\text{ pu}}$

b) Fenômeno do Cancelamento Catastrófico e Análise em 64 bits:
O cancelamento catastrófico ocorre na aritmética de ponto flutuante quando dois números quase iguais são subtraídos (eliminando os dígitos significativos mais relevantes e promovendo o ruído de truncamento para as posições de maior peso), ou quando somam-se dois números cujas ordens de grandeza diferem em mais do que a resolução da mantissa.

• Em precisão simples (32 bits), a mantissa tem 23 bits ($\approx 7\text{ dıˊgitos decimais}$). Como $x_{km}^2=2,5\cdot 10^{-3}$ e $r_{km}^2=1,0\cdot 10^{-10}$, a razão entre eles é: $\frac{x_{km}^2}{r_{km}^2}=\frac{2,5\cdot 10^{-3}}{1,0\cdot 10^{-10}}=2,5\cdot 10^7$ Como $2,5\cdot 10^7>10^7$ (capacidade de dígitos do float32), o termo $r_{km}^2$ desaparece completamente por perda de precisão (swamping numérico) na soma em 32 bits, resultando em: $(r_{km}^2+x_{km}^2{)}_{\text{float32}}=2,5\cdot 10^{-3}$ o que equivale a forçar $r_{km}^2=0$.
• Em precisão dupla (64 bits - float em Python), a mantissa possui 52 bits ($\approx 15\text{ a }17\text{ dıˊgitos decimais}$, ${ϵ}_{\text{mach}}\approx 2,22\times 10^{-16}$). A diferença de 7 ordens de grandeza entre $2,5\cdot 10^{-3}$ e $1,0\cdot 10^{-10}$ está perfeitamente contida dentro da janela de 16 dígitos significativos do binary64. A soma preserva integralmente ambos os termos, garantindo a simetria estrita e a definitude positiva da matriz de admitância nodal $Y_{\text{bus}}$, eliminando qualquer risco de instabilidade numérica no método de Newton-Raphson.

---

Questão 02 — Álgebra Bitwise em Máscaras de Estado de Relé de Proteção (Protocolo Modbus)

(Marinha do Brasil — Corpo de Engenheiros / Eletrônica — Adaptada)
Um sistema de supervisão industrial lê um registrador de 16 bits contendo o estado de sensores de uma usina termelétrica. O valor lido em formato hexadecimal é: $\text{REG}=\text{0x2A3C}$ Deseja-se realizar duas operações de automação:

1. Isolar e verificar o estado do bit 5 (Alarme de Baixa Pressão de Óleo) e do bit 11 (Válvula de Alívio Operante);
2. Emitir um comando de escrita que force o bit 3 (Ventilação Forçada) para nível alto ($1$) e simultaneamente force o bit 2 (Aquecedor Auxiliar) para nível baixo ($0$), mantendo todos os demais 14 bits inalterados.
   Apresente as expressões lógicas em Python e calcule os valores hexadecimais resultantes.

💡 Resolução Analítica Passo a Passo:

1. Verificação dos Bits 5 e 11:
Convertendo 0x2A3C para representação binária de 16 bits: $\text{0x2A3C}=0010101000111100_2$

• Mapeamento de posições (bit 0 à direita, bit 15 à esquerda):
  • Bit 5: Corresponde ao 6º dígito a partir da direita. Observando a palavra binária: $\text{Bit 5}=1$ Expressão em Python: bool(REG & (1 << 5)) resulta em True (Alarme de Baixa Pressão Ativo).
  • Bit 11: Corresponde ao 12º dígito a partir da direita: $\text{Bit 11}=1$ Expressão em Python: bool(REG & (1 << 11)) resulta em True (Válvula Operante).

2. Manipulação dos Bits 3 e 2:

• Passo A: Forçar bit 3 para 1:
  Aplica-se máscara OR com $(1\ll 3)=0000000000001000_2=\text{0x0008}$: ${\text{REG}}_A=\text{0x2A3C}|\text{0x0008}=0010101000111100_2|0000000000001000_2=0010101000111100_2=\text{0x2A3C}$ (O bit 3 já se encontrava em nível 1).
• Passo B: Forçar bit 2 para 0:
  Aplica-se máscara AND com o complemento de $(1\ll 2)$: $\sim (1\ll 2)=\sim (0000000000000100_2)=1111111111111011_2=\text{0xFFFB}$ ${\text{REG}}_{\text{final}}={\text{REG}}_A\&\text{0xFFFB}=0010101000111100_2\&1111111111111011_2$ ${\text{REG}}_{\text{final}}=0010101000111000_2=\boxed{\text{0x2A38}}$ Expressão consolidada em Python:

  reg_final = (reg | (1 << 3)) & ~(1 << 2)
  # reg_final resulta exatamente em 0x2A38 (10808 decimal)

---

Questão 03 — Aritmética de Piso (Floor Division) e Módulo com Operandos Negativos

(ENADE — Engenharia de Controle e Automação)
Em processamento digital de sinais para filtros elétricos adaptativos, buffers circulares de tamanho $N=8$ posições (índices $0$ a $7$) são utilizados para armazenar o histórico de amostras. Para implementar um atraso de $k$ passos temporais, calcula-se o novo índice através de: $\text{idx}=(i-k)(\mathrm{mod}N)$ Considere que o ponteiro atual é $i=2$ e o algoritmo exige um retrocesso de $k=5$ passos.
a) Calcule o valor da expressão em Python: (2 - 5) // 8 e (2 - 5) % 8.
b) Compare com o resultado que seria obtido na linguagem C padrão (C99) e fundamente a superioridade do modelo Python para indexação circular de matrizes e buffers temporais.

💡 Resolução Analítica Passo a Passo:

a) Avaliação no Python:
A expressão inicial é $a=(2-5)=-3$ com divisor $b=8$.

• Divisão Inteira (//): $(-3)//8=\lfloor -3/8\rfloor =\lfloor -0,375\rfloor =\boxed{-1}$
• Módulo (%): Pela identidade fundamental $a=(a//b)\cdot b+(a\%b)$: $-3=(-1)\cdot 8+r⟹-3=-8+r⟹r=-3+8=\boxed{5}$ Portanto, o índice obtido é diretamente $\text{idx}=5$.

b) Comparação com a Linguagem C99 e Conclusão de Engenharia:

• Em Linguagem C (C99): O padrão estipula o truncamento em direção a zero (truncation toward zero). Logo: $(-3)/8=0,(-3)\%8=-3$ O operador % em C retorna um índice negativo ($-3$). Como matrizes e buffers de memória não possuem endereços físicos negativos, o acesso direto buffer[-3] resulta em corrupção de memória (buffer underflow / falha de segmentação). O engenheiro em C é obrigado a inserir código adicional com branches condicionais:

  int idx = (i - k) % N;
  if (idx < 0) idx += N; // Codigo defensivo obrigatorio em C

• No Python: Como o operador % segue a definição de Euclides-Knuth, o resto assume invariavelmente o sinal do divisor $b$. Como o tamanho do buffer $N=8$ é sempre positivo, o resultado de (-3) % 8 é garantidamente um índice válido no intervalo $[0,N-1]$, eliminando a necessidade de testes condicionais if e acelerando laços de processamento de sinais de áudio e telemetria.

---

📚 7. Referências Bibliográficas e Normas Técnicas

1. IEEE Std 754-2008: IEEE Standard for Floating-Point Arithmetic. New York: IEEE Computer Society, 2008.
2. GOLDBERG, David. What Every Computer Scientist Should Know About Floating-Point Arithmetic. ACM Computing Surveys, v. 23, n. 1, p. 5-48, 1991.
3. KAHAN, William. IEEE Standard 754 for Binary Floating-Point Arithmetic. Lecture Notes, University of California, Berkeley, 1996.
4. BOYLESTAD, Robert L.; NASHELSKY, Louis. Dispositivos Eletrônicos e Teoria de Circuitos. 11. ed. São Paulo: Pearson, 2013.
5. ALEXANDER, Charles K.; SADIKU, Matthew N. O. Fundamentos de Circuitos Elétricos. 5. ed. Porto Alegre: AMGH, 2013.
6. PYTHON SOFTWARE FOUNDATION. The Python Language Reference: Data Model and Built-in Types. Python 3.12 Documentation, 2024.
7. HETTINGER, Raymond. PEP 485 – A Function for Testing Approximate Equality. Python Enhancement Proposals, 2015.