Prompt para Desenvolvimento de Classe Python de Simulação de Economia Contexto: Você é…
- User
Prompt para Desenvolvimento de Classe Python de Simulação de Economia
Contexto: Você é um desenvolvedor de software encarregado de criar uma classe em Python capaz de simular uma pequena economia com comportamentos e interações realistas. Essa economia deve contemplar três tipos de atividades econômicas (chamadas “base”, “dinâmica” e “orgânica”) que interajam entre si, mantenham o sistema equilibrado automaticamente e reajam de forma plausível a diferentes ações ou eventos externos. O resultado final será utilizado para fins educacionais e experimentais, de modo que seja possível observar como variáveis como oferta, demanda, preços e recursos evoluem ao longo do tempo.
Objetivos Principais
-
Modelar três atividades econômicas distintas
- Atividade Base: Representa setores estáveis (por exemplo, produção primária ou indústrias de commodities), com demanda relativamente constante e variação lenta de parâmetros.
- Atividade Dinâmica: Abrange setores mais responsivos a choques de mercado (por exemplo, manufatura ou comércio), com flutuações moderadas em oferta e demanda conforme decisões internas e externas.
- Atividade Orgânica: Simula um setor fluido (por exemplo, serviços tecnológicos, inovação, economia criativa), com alta dinamização, investimentos variáveis e respostas rápidas a estímulos.
-
Criar uma estrutura de dados (classe) que mantenha o sistema auto-balanceado
-
O “auto-balanceamento” deve garantir que, sem intervenção externa, a economia não entre em colapso nem cresça indefinidamente:
- Ajuste automático de preços (por meio de mecanismos internos de oferta e demanda).
- Redistribuição de recursos (capital, mão de obra, matérias-primas) entre as três atividades, conforme indicadores de escassez ou superprodução.
- Geração de feedback loops que leve a estabilização de variáveis-chave ao longo de iterações (ticks/turnos).
-
-
Incorporar respostas realistas a ações e choques externos
-
Métodos para simular eventos como:
- Aumento ou queda repentina na demanda de um setor (ex.: booms de tecnologia, crises de commodities).
- Intervenção governamental (políticas fiscais ou subsídios).
- Mudanças em preço de insumos (gás, petróleo, tarifas).
- Evolução demográfica (crescimento populacional que impacta mão de obra e consumo).
-
A classe deve recalcular efeitos em cascata nas outras atividades, ajustando produção, estoques e preços.
-
-
Fornecer interface de operação mínima
-
Inicialização: Parâmetros iniciais ajustáveis (capital total, força de trabalho total, coeficientes de produtividade, estoques iniciais, elasticidades de demanda).
-
Passo de Simulação (tick): Método que avança o tempo em uma unidade discreta, atualizando:
- Produção e consumo de cada atividade.
- Preços de mercado.
- Estoques e balanço de recursos.
-
Ações Externas: Funções que permitem injetar choques ou políticas (ex.: alterar taxa de juros, aplicar subsídio a uma atividade, introduzir uma nova tecnologia).
-
Relatórios/Saídas: Métodos para obter, a cada tick, indicadores resumidos (PIB simulado, inflação, taxa de desemprego aproximada, nível de preços setoriais).
-
Requisitos Específicos
-
Estrutura da Classe
-
Nome Sugerido:
EconomiaSimulator(ou similar em português, comoSimuladorEconomia). -
Atributos Principais:
-
capital_total(float) -
trabalho_total(int) -
Para cada atividade (base, dinâmica, orgânica):
producao_atual(float)estoque(float)preco_unitario(float)demanda_esperada(float)coeficiente_produtividade(float)elasticidade_demanda(float)
-
-
Métodos Principais:
-
__init__(self, parametros_iniciais: dict) -
simular_tick(self)— avança uma unidade de tempo; executa:- Cálculo de produção de cada atividade (com base em insumos disponíveis e produtividade).
- Atualização de estoques (produção menos vendas).
- Ajuste de preços (mecanismo de oferta e demanda);
- Realocação de recursos entre atividades, se necessário (auto-balanceamento).
- Registro de indicadores setoriais e gerais.
-
aplicar_choque(self, choque: dict)— aplica evento externo (ex.:{"tipo": "demanda_setor", "setor": "dinamica", "variação_pct": -0.2}). -
get_indicadores(self) -> dict— retorna estado atual: PIB simulado, inflação, estoque médio, taxa de utilização de capacidade, etc.
-
-
-
Mecanismo de Auto-Balanceamento
-
Regra de Redirecionamento de Recursos: Se um setor estiver com estoque alto e baixa demanda, parte dos recursos (capital e trabalho) são redirecionados para setores com escassez.
-
Ajuste de Preços Automatizado:
- Se a demanda excede oferta → aumenta preço em x% (definido pela elasticidade).
- Se oferta excede demanda → abaixa preço em y%.
-
Limites de Produção: Cada atividade não pode ultrapassar
capacidade_maxima(definida no início), e não pode operar abaixo decapacidade_minimasem incorrer em penalidade (desemprego, custos fixos).
-
-
Modelagem de Respostas Realistas
- Curvas de Demanda e Oferta: Em cada setor, use fórmulas simples (e.g., demanda =
demanda_base * (preco_referencia / preco_atual) ** elasticidade_demanda). - Choques Exógenos: Permitir variação súbita de parâmetros (ex.: custo de matéria-prima em setor “base” aumenta 10% → recalcula custos de produção nos outros setores).
- Retroalimentação Multi-Setorial: Exemplo: queda de produção na “base” afeta matéria-prima para a “dinâmica”, que por sua vez influi em insumos para a “orgânica”. Todos devem reagir automaticamente à mudança.
- Estocagem e Backorders: Se a demanda não for completamente atendida, registra “backorder” que pode influenciar demanda futura (efeito de expectativa de escassez).
- Curvas de Demanda e Oferta: Em cada setor, use fórmulas simples (e.g., demanda =
-
Critérios de Realismo e Estabilidade
- Sem Explosões Numéricas: Garantir que, se não houver choques, o sistema converge a um estado de equilíbrio estável (por exemplo, variação de preços próxima de zero após certo número de ticks).
- Parâmetros Calibráveis: Elasticidades, taxas de reposição, custos fixos, margem de lucro mínima, para permitir ajuste fino e evitar cenários irreais (preços negativos, estoques infinitos).
- Registro Histórico: Armazenar, em listas ou dicionários, valores históricos de variáveis-chave (para posterior análise ou plotagem).
-
Documentação e Exemplos de Uso
-
Incluir docstrings em todos os métodos explicando entradas, saídas e efeitos colaterais.
-
Fornecer um script de exemplo (
if __name__ == "__main__":) que:- Inicializa o simulador com parâmetros-padrão (por exemplo, capital_total = 1 000 000, trabalho_total = 1 000, coeficientes de produtividade definidos).
- Roda 100 ticks consecutivos, imprimindo a cada 10 ticks os indicadores principais.
- Aplica um choque (ex.: queda de 15% na demanda do setor orgânico no tick 50) e demonstra como o sistema reage nos seguintes 20 ticks.
-
Formato Esperado do Entregável
Entrega-se um único arquivo
economia_simulator.pycontendo:- A definição completa da classe
EconomiaSimulator(ou nome equivalente em português). - Métodos implementados conforme descrito.
- Docstrings e comentários suficientes para tornar o código legível.
- Bloco de demonstração no final do arquivo que roda um ciclo de simulação simples e imprime resultados resumidos no console.
Não é necessário interface gráfica nem persistência em banco de dados. A ênfase está na lógica de simulação e na corretude do auto-balanceamento e das respostas realistas a eventos.
Pontos de Avaliação
- Coerência Lógica: O modelo de oferta e demanda e o mecanismo de realocação de recursos devem fazer sentido e gerar equilíbrios estáveis.
- Modularidade do Código: Métodos bem separados (cálculo de produção, ajuste de preços, realocação, aplicação de choques).
- Flexibilidade: Permitir que parâmetros (elasticidades, coeficientes de produtividade, taxas de reposição) sejam facilmente alterados sem reescrever a lógica.
- Clareza da Documentação: Cada classe, método e atributo deve possuir docstrings claras.
- Exemplo Funcional: O bloco
__main__deve demonstrar claramente o funcionamento, com saídas concisas que permitam verificar o auto-balanceamento e a reação a choques.
Observação Final: Ao implementar a classe, assegure que, mesmo sem eventos externos, o sistema alcance um ponto de equilíbrio (variações de preços e estoques tendendo a zero entre ticks sucessivos). Ao aplicar choques, verifique no exemplo que as três atividades se ajustam unas às outras, retornando a um novo equilíbrio ou mostrando ciclos econômicos plausíveis (como breve recessão seguida de recuperação).
-
- Assistant
Simulador de Economia em Python
Abaixo está a implementação da classe
SimuladorEconomiaque atende aos requisitos especificados:import random from typing import Dict, List, Tuple class SimuladorEconomia: """ Classe para simular uma economia com três setores (base, dinâmica e orgânica) que interagem entre si. O sistema possui mecanismos de auto-balanceamento e responde a choques externos de forma realista. Atributos: capital_total (float): Capital total disponível na economia trabalho_total (int): Força de trabalho total disponível setores (Dict): Dicionário com informações de cada setor econômico historico (Dict): Registro histórico de indicadores econômicos tick_atual (int): Contador de unidades de tempo simuladas parametros (Dict): Parâmetros de configuração da simulação """ def __init__(self, parametros_iniciais: Dict): """ Inicializa o simulador com os parâmetros fornecidos. Args: parametros_iniciais (Dict): Dicionário com parâmetros iniciais da simulação. Deve conter: - capital_total (float) - trabalho_total (int) - parametros_setores (Dict): Parâmetros específicos para cada setor - outros parâmetros de configuração """ self.capital_total = parametros_iniciais['capital_total'] self.trabalho_total = parametros_iniciais['trabalho_total'] self.tick_atual = 0 # Inicializa os setores econômicos self.setores = { 'base': self._inicializar_setor(parametros_iniciais['parametros_setores']['base']), 'dinamica': self._inicializar_setor(parametros_iniciais['parametros_setores']['dinamica']), 'organica': self._inicializar_setor(parametros_iniciais['parametros_setores']['organica']) } # Parâmetros de configuração self.parametros = { 'taxa_depreciacao_capital': parametros_iniciais.get('taxa_depreciacao_capital', 0.05), 'taxa_crescimento_populacao': parametros_iniciais.get('taxa_crescimento_populacao', 0.01), 'elasticidade_cross': parametros_iniciais.get('elasticidade_cross', 0.3), 'velocidade_ajuste_precos': parametros_iniciais.get('velocidade_ajuste_precos', 0.1), 'velocidade_ajuste_recursos': parametros_iniciais.get('velocidade_ajuste_recursos', 0.15) } # Histórico de simulação self.historico = { 'pib': [], 'inflacao': [], 'desemprego': [], 'precos': {'base': [], 'dinamica': [], 'organica': []}, 'producoes': {'base': [], 'dinamica': [], 'organica': []}, 'demandas': {'base': [], 'dinamica': [], 'organica': []} } def _inicializar_setor(self, parametros: Dict) -> Dict: """ Método auxiliar para inicializar um setor econômico com os parâmetros fornecidos. Args: parametros (Dict): Parâmetros específicos do setor Returns: Dict: Dicionário com o estado inicial do setor """ return { 'producao_atual': parametros.get('producao_inicial', 100), 'estoque': parametros.get('estoque_inicial', 500), 'preco_unitario': parametros.get('preco_inicial', 1.0), 'demanda_esperada': parametros.get('demanda_inicial', 100), 'coeficiente_produtividade': parametros.get('coeficiente_produtividade', 1.0), 'elasticidade_demanda': parametros.get('elasticidade_demanda', 1.0), 'capital_alocado': parametros.get('capital_inicial', 0.3), 'trabalho_alocado': parametros.get('trabalho_inicial', 0.3), 'capacidade_maxima': parametros.get('capacidade_maxima', 2.0), 'capacidade_minima': parametros.get('capacidade_minima', 0.3), 'custo_fixo': parametros.get('custo_fixo', 0.1), 'preco_referencia': parametros.get('preco_inicial', 1.0), 'demanda_base': parametros.get('demanda_inicial', 100), 'backorder': 0, 'historico_produtividade': [parametros.get('coeficiente_produtividade', 1.0)] } def simular_tick(self): """ Avança a simulação em uma unidade de tempo (tick), realizando todas as etapas: 1. Atualiza fatores externos (população, depreciação) 2. Calcula produção de cada setor 3. Atualiza estoques 4. Calcula demanda para cada setor 5. Ajusta preços 6. Realoca recursos entre setores 7. Registra indicadores """ self.tick_atual += 1 # 1. Atualização de fatores externos self._atualizar_fatores_externos() # 2. Calcular produção em cada setor for setor in self.setores.values(): self._calcular_producao(setor) # 3. Atualizar estoques e calcular vendas for setor in self.setores.values(): self._atualizar_estoques(setor) # 4. Calcular demanda para cada setor for nome, setor in self.setores.items(): self._calcular_demanda(nome, setor) # 5. Ajustar preços for setor in self.setores.values(): self._ajustar_precos(setor) # 6. Realocar recursos entre setores self._realocar_recursos() # 7. Registrar indicadores self._registrar_indicadores() def _atualizar_fatores_externos(self): """Atualiza fatores externos como crescimento populacional e depreciação do capital""" # Crescimento populacional self.trabalho_total *= (1 + self.parametros['taxa_crescimento_populacao']) # Depreciação do capital self.capital_total *= (1 - self.parametros['taxa_depreciacao_capital']) # Pequenas variações aleatórias na produtividade para simular inovações for setor in self.setores.values(): variacao = random.uniform(-0.01, 0.02) novo_valor = setor['coeficiente_produtividade'] * (1 + variacao) setor['coeficiente_produtividade'] = max(0.5, min(2.0, novo_valor)) setor['historico_produtividade'].append(setor['coeficiente_produtividade']) def _calcular_producao(self, setor: Dict): """Calcula a produção atual do setor com base nos recursos alocados""" capital_disponivel = self.capital_total * setor['capital_alocado'] trabalho_disponivel = self.trabalho_total * setor['trabalho_alocado'] # Função de produção Cobb-Douglas simplificada setor['producao_atual'] = ( setor['coeficiente_produtividade'] * (capital_disponivel ** 0.3) * (trabalho_disponivel ** 0.7) ) def _atualizar_estoques(self, setor: Dict): """Atualiza os estoques do setor com base na produção e demanda""" # Calcula quanto pode ser vendido (não mais que a demanda + backorder) vendas_possiveis = min(setor['demanda_esperada'] + setor['backorder'], setor['producao_atual'] + setor['estoque']) # Atualiza estoque setor['estoque'] = setor['estoque'] + setor['producao_atual'] - vendas_possiveis # Atualiza backorder (demanda não atendida) demanda_total = setor['demanda_esperada'] + setor['backorder'] setor['backorder'] = max(0, demanda_total - vendas
Other models, same or similar prompt
Responses were produced in different, uncontrolled contexts (system prompts, settings, prior turns). This is not a benchmark.