VectorLib
5. Manipulação de Erros
5.1 Observações Gerais
Existem dois tipos gerais de tratamento de erros: pelo hardware ou pelo software. Para evitar choque descontrolado do programa, é altamente desejável que as condições, que conduzam a erros de hardware, sejam reconhecidas antes que os erros realmente ocorram. Todos os idiomas de computador de alto nível suportam esse manipulação de erros de software em vários graus de perfeição. Dentro das funções e rotinas bem definidas deste pacote OptiVec, muitas vezes um tratamento de erros ainda mais eficiente pelo próprio programa é possível do que fornecido pelos compiladores para o código escrito pelo usuário..No entanto, deve notar-se que nenhuma proteção de transbordamento absoluto é possível para as versões de precisão estendida. Eles não têm uma "margem de segurança", como nas versões de precisão única e dupla, onde internamente todos os cálculos são realizados com precisão estendida. Especialmente as versões VEx_ e VCEx_ podem falhar se os parâmetros constantes forem muito grandes ou se os próprios elementos do vetor X já estiverem perto do limite de transbordamento. Para estar no lado seguro, os parâmetros constantes não devem exceder cerca de 1.E32 para flutuador, 1.E150 para o dobro e 1.E2000 para parâmetros estendidos.
Nas versões "expandidas" de todas as funções com precisão estendida (aqueles com os prefixos VEx_ e VCEx_; por exemplo VEx_exp), geralmente não há proteção de transbordamento para o cálculo de A*Xi + B, mas apenas para o núcleo da função em si e para a multiplicação final por C.
Uma série de erros idênticos que ocorrem dentro de uma mesma função OptiVec leva apenas a uma mensagem de erro. As mensagens idênticas subsequentes são suprimidas.
Existe uma diferença fundamental entre os números de ponto flutuante e os números inteiros em relação aos erros de OVERFLOW e DOMAIN: para números de ponto flutuante, estes são sempre erros sérios, enquanto que para números inteiros, em virtude do implícito modulo-2n em artimética, isso não é necessariamente o caso. Nos dois parágrafos seguintes, os detalhes são fornecidos no tratamento de erros de números integer e de ponto flutuante, respectivamente.
5.2 Erros Integer
Os únicos erros integer genuínos são os erros de ZERODIVIDE (se for tentada uma divisão por 0). Outros erros integer são negligenciados devido à definição implícita de operações inteiras como sendo executadas em módulo da potência respectiva de 2 (ver chapter 4.4). Para as situações nas quais o módulo implícito 2n aritmética não é apropriado, a OptiVec oferece a possibilidade de atrapalhar esses erros e imprimir uma mensagem de erro e / ou abortar o programa. Podem ocorrer todas as funções onde INTEGER OVERFLOW (por exemplo, em VI_ramp, VI_mulV, etc.) ou INTEGER DOMAIN erros (por exemplo, em V_ItoU para valores X negativos) existem em duas versões: a versão "normal" emprega aritmética e intercâmbio de módulo 2n de tipos de dados assinados e não assinados de acordo com seu padrão de bits. Para os tipos inteiros de 16 bits e 32 bits (mas não para 8 bits e 64 bits), existe uma segunda versão que também emprega aritmética de módulo 2n, mas detecta os erros. Esta segunda variante é denotada pela letra "o" (para "detecção de transbordamento") no prefixo: VIo_, VSIo_, VULo_, etc. (para as funções de interconversão do tipo de dados, o prefixo V_ é alterado para Vo_). Aqui, a ação a ser tomada no caso dos erros INTEGER OVERFLOW ou INTEGER DOMAIN deve ser definida chamando V_setIntErrorHandling em algum lugar antes da chamada para a função VIo_. V_setIntErrorHandling leva um argumento do tipo V_ihand (definido em| ierrNote | imprimir uma mensagem de erro |
| ierrAbort | imprima uma mensagem de erro e saia do programa |
| ierrIgnore | ignore o problema. Com esta última opção, o tratamento de erros pode ser desligado de forma intermediária. |
Embora você possa usar uma chamada para
V_setIntErrorHandling( ierrIgnore );
para desligar o tratamento de erros, é sempre melhor usar a versão VI_ "normal" em vez da versão VIo_ com o short-cut de tratamento de erros, já que a versão normal é sempre muito mais rápida.
C/C++ apenas:
Para escolher a versão de detecção de transbordamento não apenas para chamadas de função única, mas em todos os lugares, a maneira mais fácil é definir a constante simbólica V_trapIntError no cabeçalho do programa antes (!) <VecLib.h> esta incluido:
Example:
#define V_trapIntError 1
#include <VIstd.h>
#include <VImath.h>
.....
main() /* or WinMain(), or OwlMain() */
{
iVector I1, I2;
I1 = VI_vector( 1000 ); I2 = VI_vector( 1000 );
V_setIntErrorHandling( ierrNote );
VI_ramp( I1, 1000, 0, 50 ); /* an overflow will occur here! */
V_setIntErrorHandling( ierrIgnore );
VI_mulC( I2, I1, 1000, 5 );
/* here, even a whole series of overflows will occur;
they are all ignored. */
....
}
5.3 Erros de Ponto Flutuante
5.3.1 C/C++ especifico
Para entender os detalhes do tratamento de erros de ponto flutuante delineados nas seções a seguir, você pode referir-se à descrição das funções _matherr e signal e sinal na documentação do seu compilador C++.(Borland C ++ apenas: antes da versão 4.0, em vez de _matherr() a função matherr() - sem o underbar principal - foi usada, veja abaixo).
Tenha em mente que _matherr e _matherrl são os pontos focais definíveis pelo usuário para o tratamento de todos os erros detectados pelo software, enquanto o sinal é usado para instalar um manipulador por erros detectados por hardware (o que melhor deve ser evitado em primeiro lugar). Dentro das funções VectorLib, _matherrl é usado para o tratamento de erros nas versões VF_, VCF_, VD_ e VCD_. _matherrl é usado nas versões VE_ e VCE_ (somente Embarcadero/Borland C ++ de 32 bits, já que nem o Visual C ++ nem o RAD Studio de 64 bits suportam números reais de 80 bits).
Se a função na qual ocorre um erro tenha um argumento de valor real, apenas o parâmetro x> x é definido na chamada _matherr e e-> y é deixado indefinido. Somente se houver dois argumentos (como em VF_atan2 ou em VF_cotrpi), são necessários ambos e-> x e e-> y para manter esses argumentos. Para argumentos complexos, a parte real é armazenada em e-> x e a parte imaginária em e-> y.
<5.3.2 Pascal/Delphi específicos
Os tipos de erros que ocorrem em funções matemáticas são descritos em detalhes abaixo. Como OptiVec lida com cada tipo de erro é definido por uma chamada para V_setFPErrorHandling. As opções possíveis são definidas pelas constantes fperrXXX descritas com V_setFPErrorHandling. Ao chamar V_setFPErrorHandling, combine essas constantes pelo operador OR. Observe que isso influencia apenas a maneira como os erros são tratados nas funções OptiVec Isso não afeta a maneira como as funções padrão do Borland Pascal/Delphi manipulam erros.Além do tratamento de erros "por elemento", os valores de retorno das funções matemáticas mostram se todos os elementos foram processados sem erros (valor de retorno FALSE) ou se ocorreu um erro e foi tratado (valor de retorno VERDADEIRO).
5.3.3 Tipos de Erros (Ambos C/C++ e Pascal/Delphi)
Para cada função VectorLib, os tipos de erros detectados e manipulados são anotados nas descrições individuais. Todas as funções derivadas das funções matemáticas ANSI C ou Pascal (aqueles cujas declarações são encontradas em < V? Math.h> ou as unidades V? Matemática) contêm um tratamento matemático de erros de pleno direito. Além do tratamento de erros "por elemento", seu valor de retorno mostra se todos os elementos foram processados sem erros (valor de retorno FALSE ou 0) ou se um erro ocorreu e foi tratado (valor de retorno VERDADEIRO ou diferente de 0).
Na descrição a seguir de todos os tipos de erro de ponto flutuante, damos por "HUGE_VAL" o maior número possível no respectivo tipo de dados. Da mesma forma, "TINY_VAL" é o menor número denormal representável no respectivo tipo de dados; Isso não é o mesmo que "MIN_VAL", que é o menor número de precisão total do respectivo tipo de dados.
- Os erros DOMAIN geralmente levam ao resultado NAN ("não-um-número"). Mesmo que nada aconteça dentro da própria função que detecta um erro DOMAIN, uma falha de programa descontrolada pode resultar se as operações subseqüentes forem realizadas no elemento vetorial definido como NAN. Para C/C ++, recomendamos modificar _matherr e _matherrl de forma que o programa seja abortado se ocorrer um erro de DOMÍNIO (para um exemplo, veja abaixo, em alternativa, o estilo UNIX pode ser adotado, veja o arquivo MATHERR.C fornecido com o compilador C/C ++). Alterar o valor de retorno de _matherr é outra possivel, mas a melhor maneira é claramente evitar quaisquer erros de DOMAIN, realizando verificações apropriadas antes de chamar funções como VF_sqrt, VF_log, VF_atan2 etc.
Para Pascal/Delphi, recomendamos não alterar a configuração padrão de V_FPErrorHandlingMode ou incluir "fperrAbortDOMAIN" em qualquer alteração.
Nota: os pseudo-números INF e NAN não são permitidos como entrada para quaisquer funções do OptiVec. Eles não são testados; Sua presença normalmente resultará em uma interrupção de hardware. - Os erros de SING são tratados como um caso extremo de OVERFLOW (veja abaixo). Na maioria dos casos, eles surgem de uma divisão implícita por zero ou de tomar o logaritmo de zero. O resultado proposto nunca é NAN, mas sempre um "número", na maioria dos casos ± HUGE_VAL. Embora seja recomendado também no caso de erros de SING para abortar o programa e tomar as medidas necessárias para evitá-los, você pode optar por continuar a execução do programa.
- Os erros de OVERFLOW são a forma mais abundante de erros de ponto flutuante. Eles são sempre tratados propondo + HUGE_VAL ou -HUGE_VAL como resultado. Dentro de muitos algoritmos de usuário, podem ocorrer erros de OVERFLOW para resultados intermediários; Se as etapas subseqüentes executam operações como tomar o inverso, o resultado final pode ser aceitável apesar do erro. Portanto, recomendamos aceitar a proposta de valor de retorno e não abortar o programa..
C/C++ somente: Em princípio, você pode decidir não aceitar a proposta de valor de retorno de _matherr, mas substituir outro. No entanto, por várias razões, você está desanimado de fazer isso: o sinal correto do resultado é definido pela função de chamada ("queixa") em muitos casos somente depois de retornar de _matherr; o valor x passado para _matherr (que deve ser inspecionado antes do valor de retorno ser modificado) pode ser Xi ou (como em algumas das funções matemáticas complexas expandidas da família VCEx _...) o resultado intermediário x '= Axe + B. Note, além disso, que todos os valores de x são passados para _matherr como números de ponto flutuante de dupla precisão, também no caso de números de entrada inteiros (como em VF_tanrpi, onde Pi onde Pi e q são passados como x e y para _matherr). - Os erros de TLOSS ("perda total de precisão") são detectados apenas se ocorrer um erro mais grave na respectiva função. Por exemplo, a função seno assume valores entre -1 e +1 para todos os argumentos. Então, no caso de um argumento muito grande para que a função seno seja avaliada com qualquer precisão, o resultado pode, no entanto, ser "tacitamente" configurado para 0.0 e nenhuma chamada para o manipulador de erro OptiVec é gerada (enquanto o Borland C++ escolhe a NAN, "não um número ", como resultado, o que certamente é ainda menos correto do que escolher arbitrariamente 0,0).
Por outro lado, o cosecante, ou seja, o inverso do seno, não está definido para argumentos de múltiplos inteiros de p. Portanto, um erro mais grave (neste caso um SING ou um erro OVERFLOW) pode estar escondido sob o TLOSS para argumentos muito grandes. Essa possibilidade é levada em consideração ao chamar o manipulador de erros, embora o resultado proposto seja novamente configurado para 0.0 (que é a média dos dois extremos + HUGE_VAL e -HUGE_VAL). Geralmente, o resultado padrão no caso de um erro TLOSS é a média dos resultados para argumentos de +0.0 e -0.0. - Os erros UNDERFLOW nunca são detectados; Os resultados ‘’underflowing’’ são sempre "tacitamente" configurados para números negativos ou, finalmente, para 0,0 pelo próprio processador de ponto flutuante. Na verdade, muito raramente você vai desejar fazer outra coisa neste caso.
- Como em todas as funções matemáticas não vetadas dos compiladores Borland e do Visual C++, os erros PLOSS ("perda parcial de precisão") nunca são detectados e os problemas de precisão simplesmente ignorados.
5.4 O Tratamento dos Números de Denormal
"Denormal" são números muito pequenos entre zero e o menor número de precisão total disponível no respectivo tipo de dados. Você pode entender o princípio subjacente de um exemplo simplificado: 1.175494E-38 é o menor flutuador "normal", com precisão de 7 dígitos. E quanto a 1/1024 desse valor? Isso só pode ser representado como 0.001145E-38, que é preciso apenas quatro dígitos, uma vez que os três primeiros dígitos são necessários para manter os zeros. Assim, os números denormais fornecem uma transição suave entre os números normais representáveis mais pequenos e zero.Em geral, eles podem ser tratados exatamente como números comuns. Em alguns casos, no entanto, como tomar o inverso, podem ocorrer erros de transbordamento. Nesses casos, a distinção um tanto acadêmica entre os erros SING e OVERFLOW é descartada e um erro SING sinalizou (como se fosse uma divisão exatamente 0).
Por outro lado, para funções como os logaritmos, números de entrada muito pequenos podem dar resultados perfeitamente razoáveis, embora o número exato 0,0 seja um argumento ilegal, levando a um erro SING. Aqui, a possível perda de precisão é negligenciada e as denormais são consideradas argumentos válidos. (Este tratamento é bastante diferente do escolhido para as funções matemáticas da maioria dos compiladores, onde argumentos denormais levam a erros SING também nesses casos, o que parece menos apropriado para nós.)
5.5 Manipulação Avançada de Erros: armazenando mensagens em um arquivo
Em geral, as bibliotecas enviadas com compiladores não oferecem ao programador muito controle sobre a forma como as mensagens de erro são impressas. Embora isso seja bom na maioria dos casos, pode haver situações em que você pode, por exemplo, desejar que as mensagens de erro não sejam impressas na tela, mas sim em um arquivo, para que você possa verificar mais tarde o que deu errado. Uma motivação adicional pode vir do fato de que, por qualquer erro que ocorra em um programa do Windows, uma caixa de mensagem é exibida e a execução do programa interrompida até que você reconheça ter percebido o erro.Você pode desejar contornar isso. Para este fim, o OptiVec fornece a função V_setErrorEventFile. Esta função precisa como argumentos o nome desejado do seu arquivo de evento e um switch chamado ScreenAndFile que decide se a mensagem de erro é impressa somente no arquivo, ou adicionalmente à tela também.
Observe que esse redirecionamento de mensagens de erro é válido apenas para erros que ocorrem nas rotinas OptiVec. Se desejar fazê-lo, no entanto, existe uma maneira em C/C ++ para estender o redirecionamento também para as funções "não-OptiVec": você pode modificar _matherr e _matherrl de tal forma que a declaração
return 0;
(que sinaliza um erro não resolvido) é substituído pela seqüência
V_noteError( e->name, e->type ); return 1;
Por isso, a tarefa de imprimir a mensagem de erro para erros não resolvidos é passada para a função OptiVec V_noteError. Tenha em mente que é o valor de retorno de _matherr que decide se uma mensagem de erro é impressa pelo manipulador de erros padrão do seu compilador. Assim, após a chamada para V_noteError, a impressão das mensagens de erro padrão é ignorada retornando "1". (Além disso, não esqueça que o OptiVec usa sua _matherr rotina _matherr para determinar quais erros você aceita e quais não!)
Ambos C/C ++ e Pascal/Delphi: A impressão padrão de mensagens de erro somente na tela é restaurada por V_closeErrorEventFile.
5.6 Mensagens de Erro OptiVec
Assim como com qualquer programa C/C ++ ou Pascal, os erros que ocorrem dentro de funções matemáticas levam a mensagens de erro apropriadas. Consulte o paragraph 5.3.3 para obter detalhes.Além dos erros de matemática, existem alguns erros de tempo de execução específicos das rotinas OptiVec. Esses erros levam às mensagens indicadas abaixo. O nome da função onde o erro ocorreu nem sempre é exatamente o nome que você escreveu em seu programa. Em vez do prefixo VI_, a mensagem irá ler VLI_ ou VSI_, dependendo do modelo de memória usado. Da mesma forma, em vez de VU_, você encontrará VUL_ ou VUS_.
VFs_FFT or VFl_FFT serão substituídos por VF_FFT, novamente dependendo do modelo de memória. A razão para esse comportamento é que muitas funções compartilham códigos e até mesmo nomes.
|
Ou você tentou instalar o OptiVec descompactando o pacote manualmente, sem usar INSTALL.EXE. Isso não é possível, pois INSTALL.EXE também inicia o relógio para o período de teste.
|
|
* Procure por vetores que podem não ser mais necessários e liberá-los o mais rápido possível. Certifique-se de que quaisquer vetores alocados nas sub-rotinas sejam liberados antes de deixar a sub-rotina.
* Você ainda está trabalhando com modelos de 16 bits? Se você precisa trabalhar com grandes quantidades de dados, o modelo de memória FLAT deve ser usado, trabalhando com Win32, WindowsNT ou Windows95 / 98.
* Armazene os dados intermediariamente no disco, usando o VF_store, e recupere-os usando VF_recall, quando necessário. Este método é lento e deve ser usado apenas se for inevitável.
|
* Ou você está tentando alocar um vetor cujo tamanho exceda o máximo de 4 GB (32 bits) ou 64 kB (16 bits, exceto HUGE).
* Ou você está no modelo ENORME e tenta processar um vetor enorme em uma função onde o tamanho é limitado a 64 kB mesmo neste modelo. Isso pode acontecer, por exemplo, se a tabela for muito grande em uma das rotinas de interpolação. Nesse caso, você deve usar o modelo FLAT ou dividir seu problema em vetores menores.
|
|
|
|
|
|
|
|
|
6. Solução de Problemas
Em caso de problemas, verifique primeiro se o OptiVec está instalado corretamente. Se for esse o caso, verifique cuidadosamente os seguintes pontos, cuja violação inevitavelmente levará a falha.- A escolha da biblioteca OptiVec deve corresponder à sua seleção de modelo de memória, processador e ambiente. Com o Borland C++, você não vai se divertir muito com as bibliotecas projetadas para o Visual C++ e vice-versa.
- Você não deve usar vetores com um tamanho de 0. Todas as funções assumem tacitamente que os vetores têm pelo menos um elemento e não desperdiçam o tempo de teste do computador para isso.
- Você não deve usar vetores que são declarados apenas, mas sem memória alocada (veja a descrição do VF_vector). Se você não desligou avisos, você pode ser avisado também pelo compilador para não fazer isso ("uso possível de xxx antes da definição").
- Os parâmetros constantes não devem exceder 1.E32 para flutuadores, 1.E150 para duplos ou 1.E2000 para duplos longos. Normalmente, essas gamas devem ser suficientes para qualquer aplicação...
7. Arquivos de Inclusão e Unidades de OptiVec
Todos os arquivos de inclusão OptiVec C/C ++ têm os mesmos nomes que as unidades Pascal/Delphi correspondentes. Naturalmente, a extensão é diferente: ".H" para os arquivos de inclusão C/C ++, ".DCU" para unidades Delphi. Abaixo, apenas os nomes estão listados, sem a extensão.C/C++ apenas: declare o uso de funções OptiVec com instruções #include Se você estiver usando MFC (Microsoft Foundation Classes) ou o OWL (ObjectWindows Library) com compiladores Borland antigos, os arquivos de inclusão MFC ou OWL devem ser #incluídos antes (!) Os arquivos de inclusão OptiVec.
Pascal/Delphi apenas: Declare o uso das funções do OptiVec com a cláusula de uso.
| Arquivo de Inclusão (add sufixo .H) ou unidade | Conteúdo |
| VecLib | Definições básicas dos tipos de dados, juntamente com as funções comuns a todos os tipos de dados (prefixo V_) exceto para as funções de inicialização de gráficos. |
| VFstd, VDstd, VEstd | Operações padrão de "ponto flutuante": "geração e inicialização de vetores, manipulações orientadas a índices, interconversões de dados, estatísticas, análises, aritmética vetorial geométrica, funções relacionadas com transformadas de Fourier, operações de I/O. |
| VCFstd, VCDstd, VCEstd, VPFstd, VPDstd, VPEstd | Operações padrão para vetores vetoriais cartesianos e polares |
| VIstd, VBIstd, VSIstd, VLIstd, VQIstd | Operações padrão para vetores inteiros assinados |
| VUstd, VUBstd, VUSstd, VULstd, VUIstd | Operações padrão para vetores inteiros não assinados (VUIstd somente para C/C++) |
| VFmath, VDmath, VEmath | Algebraic, arithmetical and Funções algébricas, aritméticas e matemáticas para vetores de ponto flutuante |
| VCFmath, VCDmath, VCEmath, VPFmath, VPDmath, VPEmath | Funções aritméticas e matemáticas para vetores complexos |
| VImath, VBImath, VSImath, VLImath, VQImath | Funções aritméticas e matemáticas para vetores inteiros assinados |
| VUmath, VUBmath, VUSmath, VULmath, VUImath | Funções aritméticas e matemáticas para vetores inteiros não assinados (VUImath apenas para C/C++) |
| Vgraph | Funções gráficas para todos os tipos de dados |
| VFNLFIT, VDNLFIT, VENLFIT | Funções de montagem não linear (apenas Pascal/Delphi, em C/C++, estão em M?std) |
| VFMNLFIT, VDMNLFIT, VEMNLFIT | Funções de montagem não-linear para vários conjuntos de dados (apenas Pascal/Delphi, em C/C++, estão em M?std) |
| MFstd, MDstd, MEstd | Operações matriciais para matrizes de valor real |
| MCFstd, MCDstd, MCEstd | Operações matriciais para matrizes complexas cartesianas |
| Mgraph | Funções de gráficos de matriz para todos os tipos de dados |
| MFNLFIT, MDNLFIT, MENLFIT | Funções de montagem não-linear para dados Z = f (X, Y) (apenas Pascal/Delphi, em C/C++, estão em M?std) |
| MFMNLFIT, MDMNLFIT, MEMNLFIT | Funções de montagem não linear para vários conjuntos de dados Z = f (X, Y) (apenas Pascal/Delphi, em C/C++, estão M?std) |
| NEWCPLX | Biblioteca de classe complexa CMATH; Apenas C++ |
| CMATH | Biblioteca complexa CMATH para Pascal/Delphi e C simples |
| CFMATH, CDMATH, CEMATH | Biblioteca complexa CMATH para Pascal/Delphi e C simples |
| XMATH | Algumas funções de matemática não vetorizadas necessárias internamente por outras funções do OptiVec; eles são publicamente acessíveis. C / C ++: declara também as tabelas seno, cosec e tangente para VF_sinrpi2 etc. |
| FSINTAB2, DSINTAB2, ESINTAB3, FSINTAB3, DSINTAB3, ESINTAB3 | tabelas sinusoidal (apenas Pascal/Delphi, para C/C++, estão em XMATH) |
| FCSCTAB2, DCSCTAB2, ECSCTAB3, FCSCTAB3, DCSCTAB3, ECSCTAB3 | tabelas cosecant (apenas Pascal/Delphi, para C/C++, estão em XMATH) |
| FTANTAB2, DTANTAB2, ETANTAB3, FTANTAB3, DTANTAB3, ETANTAB3 | tabelas tangentes (apenas Pascal/Delphi, para C/C++, estão em XMATH) |
| VecObj | definições básicas para VecObj, a interface orientada a objetos para C ++ |
| fVecObj, dVecObj, eVecObj | VecObj Funções do membro VecObj para objetos vetoriais de valor real (apenas C ++) |
| cfVecObj, cdVecObj, ceVecObj pfVecObj, pdVecObj, peVecObj | Funções do membro VecObj para objetos vetoriais complexos (somente C ++) |
| iVecObj, biVecObj, siVecObj, liVecObj, qiVecObj | Funções do membro VecObj para objetos vetoriais integer não assinados (somente C ++) |
| uVecObj, ubVecObj, usVecObj, ulVecObj, uiVecObj | Funções do membro VecObj para objetos vetoriais inteiros não assinados (somente C ++) |
| OptiVec | inclui todo o pacote OptiVec (somente C ++) |
| VecAll | inclui todas as funções VectorLib e CMATH (apenas C ou C ++) |
| MatAll | inclui todas as funções MatrixLib (apenas C ou C ++ |