Como testar uma implementação numérica do ODE Solver?

Estou prestes a começar a trabalhar em uma biblioteca de software de solucionadores numéricos de ODE e estou tendo dificuldades em formular testes para as implementações do solucionador. Minha ambição é que a biblioteca, finalmente, irá incluir solucionadores para ambos os problemas nonstiff e rígido, e pelo menos um solver implícita (mais ou menos a par com as capacidades das oderotinas em Matlab ), de modo que as necessidades metodologia de teste para refletir os vários tipos de problemas e critérios para diferentes solucionadores.

Meu problema agora é que não sei por onde começar com este teste. Posso pensar em algumas maneiras diferentes de testar a saída de um algoritmo:

• Teste um problema que tenha uma solução analítica e verifique se a solução numérica está dentro dos níveis de tolerância para todos os pontos de dados retornados. Isso requer o conhecimento de vários problemas analíticos que exibem todas as propriedades com as quais eu quero que os diferentes solucionadores trabalhem (rigidez, problemas implícitos, etc.), os quais não tenho, pelo menos não da cabeça.

  Este método testa os resultados de um método solucionador. Portanto, não há garantia de que o solucionador realmente funcione, apenas que funcione para o problema de teste especificado . Portanto, suspeito que seja necessário um grande número de problemas de teste para verificar com segurança se o solucionador funciona.

• Calcule manualmente a solução por algumas etapas, usando os algoritmos que pretendo implementar, e faça o mesmo com os solucionadores e verifique se os resultados são os mesmos. Isso não requer conhecimento da verdadeira solução para o problema, mas, por sua vez, exige bastante trabalho prático.

  Este método, por outro lado, apenas testa o algoritmo , que é bem por mim - se alguém tem provado que 4 ^ª ordem de Runge-Kutta funciona, eu não sinto uma necessidade desesperada de. No entanto, receio que seja muito complicado formular casos de teste, pois não conheço um bom método para gerar os dados de teste (exceto talvez manualmente, o que dará muito trabalho ...).

Ambos os métodos acima têm sérias limitações para mim com meu conhecimento atual - não conheço um bom conjunto de problemas de teste para o primeiro e não conheço um bom método de gerar dados de teste para o segundo.

Existem outras maneiras de verificar os resolvedores numéricos de ODE? Existem outros critérios nas implementações que devem ser verificados? Existem bons recursos (gratuitos) para testar os solucionadores de ODE existentes ¹ ?

EDIT:
Como essa pergunta é muito ampla, quero esclarecer um pouco. O conjunto de testes que eu quero criar preencherá dois propósitos principais:

1. Verificando se os solucionadores funcionam conforme o esperado, para os problemas que eles pretendem resolver. Em outras palavras, um solucionador de problemas não-rígidos pode banir-se com um problema rígido, mas deve ter um bom desempenho em problemas não-rígidos. Além disso, se houver outros solucionadores na biblioteca que ofereçam maior precisão, talvez não seja necessário aplicar resultados muito precisos - apenas "suficientemente precisos". Assim, parte da minha pergunta é quais testes devem ser usados ​​para quais solucionadores; ou, pelo menos, como alguém deve raciocinar para decidir isso.

2. Teste de sanidade após a instalação da biblioteca. Esses testes não precisam (não devem) ser elaborados ou demorados; apenas os princípios básicos que podem ser executados em menos de 5 segundos, mas que alertarão o usuário se algo for estranho. Portanto, também preciso de uma maneira de construir testes muito simples, mas que ainda me digam algo sobre o estado da biblioteca.

^{1 Sim, tenho pesquisado no Google, mas quase tudo o que encontro são notas de aula com exemplos muito triviais, com a exceção notável do conjunto de testes CWI ODE de Bari, que eu não sei se, ou como, eu poderia usar para meus propósitos, pois trata solucionadores muito mais sofisticados do que os que eu quero testar ...}

Essa é uma pergunta muito ampla e eu vou lhe dar algumas considerações (algumas já estão incluídas no seu post, mas são repetidas aqui por completo).

Escopo dos problemas

• Você precisa definir a interface de como especificar problemas.
• Você permitirá parâmetros que podem ser corrigidos ou podem variar para soluções?
• Você permitirá que os parâmetros de perturbação perturbem levemente os problemas e veja se eles ainda são solucionáveis ​​(por exemplo, um parâmetro a ser definido em qualquer lugar) em um problema específico?$\epsilon$
• Você vai permitir precisão infinita?
• Você vai testar a velocidade e a sensibilidade à precisão numérica?
• Você escolheu duas (talvez mais) bibliotecas que já existem para comparar resultados?
• Como você escolherá os critérios de parada, usará vários métodos e permitirá que o usuário selecione ou defina seus próprios?
• Você medirá o erro usando várias medidas e permitirá que o usuário as ligue e desligue?
• Você já olhou para os pacotes profissionais como Computer-Algebra-Systems (CAS) e entendeu todas as opções que eles permitem?
• Você permitirá a exibição de resultados e / ou comparações e / ou gráficos?

Recomendações de Problemas

• Você precisa escrever uma especificação de teste que defina a fonte dos problemas, o escopo de como os problemas foram testados, capturando resultados e métricas da execução das rotinas.
• Eu certamente procuraria em outras bibliotecas já disponíveis os problemas que estão usando (talvez arquivos de teste).
• Eu frequentava bibliotecas de faculdades, folheava livros sobre ODEs e retirava problemas de todos os tipos, aqueles com soluções fechadas conhecidas ou soluções apenas numéricas.
• Caso 1: queremos o maior número possível de variações de problemas de solução de formulário fechado para comparar os resultados exatos versus numéricos.
• Caso 2: Eu iria a todos os livros de análise numérica que eu pudesse encontrar e capturar os exemplos trabalhados e duplicá-los. Além disso, eu capturaria os conjuntos de problemas, particularmente aqueles que possuem alguma patologia que existe na maioria dos livros (sensibilidade a esse ou aquele tipo).
• Caso 3: Eu iria para diferentes ramos da matemática aplicada, como Física, Ecologia, Biologia, Economia, etc. e capture problemas de cada um desses domínios para validar que sua linguagem de especificação para problemas permita esses exemplos.
• Caso 4: Eu pesquisaria artigos / revistas que contêm os exemplos mais úteis em que o autor em particular teve que modificar uma abordagem específica para explicar alguma patologia, estranheza ou dureza.
• Caso 5: pesquise na web exemplos adicionais. Para rigidez , consulte as referências aqui e examine-as TODAS para descobrir problemas de teste. Aqui estão alguns exemplos do MATLAB para ler.

Isto não é único. Se você olhar o livro "Métodos Numéricos para Otimização Irrestrita e Equações Não Lineares", de Dennis e Schnabel, Apêndice B, "Problemas de Teste", poderá ver como eles o fizeram. Depois de desenvolver um dos mais belos conjuntos de algoritmos que eu já vi, eles lançaram uma coleção de problemas que o deixaram louco. Você tinha que ajustar aqui e ali! Eles incluíram cinco problemas muito diferentes e patológicos que sobrecarregavam as capacidades dos solucionadores. Isso me ensinou que podemos continuar lançando problemas em algoritmos que eles são incapazes de lidar por várias razões. Observe que eles até pegaram emprestado esse conjunto de problemas de More ', Garbow e Hillstrom (você também pode procurar essa referência e talvez haja outras que possa usar como guia).

Em outras palavras, essa não é uma tarefa trivial. Você precisa de casos de teste de resposta conhecida que sempre permitem testar a validade das atualizações e não quebram as coisas. Ou seja, um conjunto repetitivo e extenso de problemas de baixo a alto, de fácil a difícil, de possível a impossível ... Você também precisa de uma coleção de problemas que seus solucionadores não conseguem resolver para realmente entender suas limitações.

Uma verificação de sanidade que eu corro contra meus solucionadores de ODE é simplesmente verificá-la em sistemas lineares menores, calculando exatamente o exponencial da matriz do sistema. ou seja, dado

verifique o erro em

$\hat{\mathbf{u}}(t)$

Apenas não calcule o exponencial com um dos seus colaboradores (por exemplo, método duvidoso número 6 :) http://www.cs.cornell.edu/cv/researchpdf/19ways+.pdf )

Você pode tentar investigar o "Método de soluções fabricadas", que é uma metodologia geral usada para testar a implementação de códigos que resolvem PDEs (ela pode ser usada para encontrar erros matemáticos e de codificação). Eu imagino que poderia ser adaptado para trabalhar na solução de EDOs, se a metodologia da sua solução for suficientemente geral.

http://prod.sandia.gov/techlib/access-control.cgi/2000/001444.pdf