VectorLib
4. VectorLib Funções e Rotinas: Uma Visão Curta
4.1 Geração, Inicialização e Desalocação de Vetores
Com o VectorLib, você pode usar matrizes estáticas (como, por exemplo, flutuador a [100];), bem como alocadas dinamicamente (ver chapter 2.3). Recomendamos, no entanto, que você use os tipos de vetores mais flexíveis definidos pelo VectorLib, usando alocação dinâmica.
As seguintes funções gerem vetores dinamicamente alocados:
| VF_vector | alocação de memória para um vetor |
| VF_vector0 | alocação de memória e inicialização de todos os elementos com 0 |
| V_free | Um vetor gratuito |
| V_nfree | vetores n gratuitos (apenas para C, não para Pascal) |
| V_freeAll | Todos os vetores gratuitos |
Você deve sempre cuidar adequadamente para desalocar a memória de vetores que não são mais necessários. Internamente, os vetores alocados são escritos em uma tabela para acompanhar a memória alocada. Se você tentar liberar um vetor que nunca foi ou não está mais alocado, você recebe uma mensagem de aviso e nada é liberado.
Dicas de desempenho:
- Os vetores alocados pelo VF_vector estão alinhados em limites de 64 bytes para uma correspondência de linha de cache ótima (Intel Pentium XX: 32 bytes, AMD Athlon e todos os processadores de 64 bits por AMD e Intel: 64 bytes). Por outro lado, matrizes estáticas, bem como vetores criados pelo operador novo ou pelas funções padrão, malloc, calloc, GetMem, LocalAlloc, GlobalAlloc etc. estão alinhados apenas em limites de 4 bytes. Conseqüentemente, para o melhor desempenho, você deve usar apenas vetores alocados pelo VF_vector etc.
- Os comandos SIMD empregados nas versões P6 e P7 exigem que os dados sejam alinhados em limites de 16 bytes. Mais uma vez o mesmo conselho: Use os vetores dinâmicos do OptiVec para garantir o alinhamento necessário. A penalidade por dados não devidamente alinhados pode representar 25%.
- Em vez de muitos vetores pequenos, considere alocar um vetor grande. Defina os vetores pequenos como partes do maior:
C/C++:
X = VF_vector( 3*size);
Z = (Y = X+size) + size; |
Pascal/Delphi:
X := VF_vector( 3*size );
Y := VF_Pelement( X, size );
Z := VF_Pelement( Y, size ); |
Certifique-se de que o tamanho seja arredondado de modo a tornar o tamanho * sizeof (tipo de dados) um múltiplo de 32 ou 64
- Evite alocação frequente e desalocação. Tente reutilizar vetores em vez disso.
As seguintes funções são usadas para inicializar ou reinicializar vetores que já foram criados:
| VF_equ0 | defina todos os elementos de um vetor igual a 0 |
| VF_equ1 | defina todos os elementos iguais a 1 |
| VF_equm1 | defina todos os elementos iguais a -1 |
| VF_equC | defina todos os elementos iguais a uma constante C |
| VF_equV | faça um vetor uma cópia de outro |
| VFx_equV | "Versão "expandida" da operação de igualdade: Yi = a * Xi + b |
| VF_ramp | "ramp": Xi = a * i + b. |
| VF_random | números aleatórios de alta qualidade |
| VF_noise | ruído branco |
| VF_comb | "pente": é igual a uma C constante em pontos equidistantes, em outro lugar 0 |
As seguintes funções geram janelas para uso na análise espectral:
Os vetores complexos podem ser inicializados por estas funções:
| VF_ReImtoC | merge two vectors, Re e Im, fundir dois vetores, Re e Im, em um vetor complexo cartesiano |
| VF_RetoC | substituir a parte real de um vetor complexo cartesiano |
| VF_ImtoC | substituir a parte imaginária de um vetor complexo cartesiano |
| VF_PolartoC | construir um vetor complexo cartesiano a partir de coordenadas polares, inserido como vetores separados Mag and Arg |
| VF_MagArgtoP | mesclar dois vetores, Mag e Arg em um vetor complexo polar |
| VF_MagArgtoPrincipal | fundir dois vetores, Mag e Arg em um vetor complexo polar, reduzindo o intervalothe Arg para o valor principal, -p < Arg <= +p |
| VF_MagtoP | substituir a parte Mag de um vetor complexo polar |
| VF_ArgtoP | substituir a parte Arg de um vetor complexo polar |
| VF_ReImtoP | construa um vetor complexo polar a partir de coordenadas cartesianas, inserido como vetores separados Re e Im |
4.2 Manipulações Orientadas para o Índice
| VF_rev | inverter o pedido de elementos |
| VF_reflect | defina a metade superior de um vetor igual à metade inferior invertida |
| VF_rotate | gire o pedido dos elementos |
| VF_rotate_buf | rotação eficiente, empregando memória tampão especificada pelo usuário |
| VF_insert | insira um elemento em um vetor |
| VF_delete | apague um elemento de um vetor |
| VF_sort | triagem rápida dos elementos (ordem ascendente ou decrescente) |
| VF_sortind | classificação de uma matriz de índice associada a um vetor |
| VF_subvector | extraia um subvector de um vetor (normalmente maior), usando um intervalo de amostragem constante. |
| VF_indpick | enche um vetor com elementos "escolhidos" de outro vetor de acordo com seus índices. |
| VF_indput | distribuir os elementos de um vetor para os sites de outro vetor especificados pelos seus índices. |
As operações realizadas apenas em um subconjunto amostrado de elementos de um vetor são fornecidas pela família VF_subvector_... onde a marca de omissão representa um sufixo denotando a operação desejada:
| VF_subvector_equC |
Xi*samp = C, i=0,...subsize-1 |
| VF_subvector_addC |
Xi*samp += C, i=0,...subsize-1 |
| VF_subvector_subC |
Xi*samp -= C, i=0,...subsize-1 |
| VF_subvector_subrC |
Xi*samp = C - Xi*samp, i=0,...subsize-1 |
| VF_subvector_mulC |
Xi*samp *= C, i=0,...subsize-1 |
| VF_subvector_divC |
Xi*samp /= C, i=0,...subsize-1 |
| VF_subvector_divrC |
Xi*samp = C / Xi*samp, i=0,...subsize-1 |
|
| VF_subvector_equV |
Yi*samp = Yi, i=0,...subsize-1 |
| VF_subvector_addV |
Xi*samp += Yi, i=0,...subsize-1 |
| VF_subvector_subV |
Xi*samp -= Yi, i=0,...subsize-1 |
| VF_subvector_subrV |
Xi*samp = Yi - Xi*samp, i=0,...subsize-1 |
| VF_subvector_mulV |
Xi*samp *= Yi, i=0,...subsize-1 |
| VF_subvector_divV |
Xi*samp /= Yi, i=0,...subsize-1 |
| VF_subvector_divrV |
Xi*samp = Yi / Xi*samp, i=0,...subsize-1 |
|
A pesquisa de tabelas para valores específicos é realizada po:
| VF_searchC |
procure o elemento de um vetor que é mais próximo de um valor predefinido C (o valor mais próximo, o mais próximo ou o mais próximo, menor ou igual, dependendo de um parâmetro "modo") |
| VF_searchV | the same, but for a whole array of pre-set values |
As interpolações são realizadas:
4.3 Interconversões de Tipos de Dados
A primeira coisa que deve ser dito sobre as interconversões de tipo de dados de ponto flutuante é: não as use demais. Decida qual precisão é apropriada para o seu aplicativo e, em seguida, use consistentemente a VF_, ou o VD_, ou o VE_ das funções que você precisa. No entanto, todos os tipos de dados podem ser convertidos em todos os outros, caso seja necessário. Apenas alguns exemplos são apresentados; o resto deve ser óbvio:
| V_FtoD | float para double |
| V_CDtoCF | complex<double> para complex<float> (with overflow protection) |
| V_PFtoPE | polar<float> para polar<extended> |
| VF_PtoC | polar<float> para complex<float> |
| V_ItoLI | int para long int |
| V_ULtoUS | unsigned long para unsigned short |
| V_ItoU | signed int para unsigned int. Interconversões entre tipos assinados e não assinados só podem ser realizadas com o mesmo nível de precisão. Funções como "V_UStoLI" não existem. |
| V_ItoF | int para float |
A conversão de números de ponto flutuante em números integer é realizada pelas seguintes funções, diferindo na forma como uma possível fração é tratada:
Essas operações são tratadas como funções matemáticas e são descritas adicionalmente no chapter 4.6.1.
4.4 Mais Sobre Integer Artiméticos
Embora as regras da aritmética inteira sejam bastante diretas, parece apropriado lembrar que todas as operações inteiras são executadas de forma implícita no módulo 2n, onde n é o número de bits com os quais os números estão representados. Isso significa que qualquer resultado, que se encontra fora do alcance do tipo de dados respectivo, é feito para cair dentro do alcance, perdendo os bits mais altos. O efeito é o mesmo que se várias vezes 2n tivessem sido adicionados (ou subtraídos) ao resultado "correto", conforme necessário, para alcançar o alcance legal.
Por exemplo, no tipo de dados short / SmallInt, o resultado da multiplicação 5 * 20000 é -31072. A razão para este resultado negativo aparentemente errado é que o resultado "correto", 100000, cai fora do intervalo de números short que é -32768 <= x <= +32767. short / SmallInt é um tipo de 16 bits, portanto n = 16 e 2n = 65536. Para tornar o resultado cair no intervalo especificado, o processador "subtrai" 2 * 65536 = 131072 de 100000, produzindo -31072.
Observe que os resultados intermediários transbordantes não podem ser "curados" por qualquer operação a seguir. Por exemplo, (5 * 20000) / 4 não é (como se poderia esperar) 25000, mas sim -7768.
4.5 Funções Básicas de Vetores Complexos
As seguintes funções estão disponíveis para o tratamento básico de vetores complexos cartesianos:
| VF_ReImtoC | formam um vetor complexo cartesiano de suas partes reais e imaginárias |
| VF_RetoC | substituir a parte real |
| VF_ImtoC | substituir a parte imaginária |
| VF_CtoReIm | extraia as partes reais e imaginárias |
| VF_CtoRe | extraia a parte real |
| VF_CtoIm | extraia a parte imaginária |
| VF_PolartoC | formam um vetor complexo cartesiano fora de coordenadas polares, inserido como vetores separados Mag e Arg |
| VF_CtoPolar | transformar o complexo cartesiano em coordenadas polares, retornadas nos vetores separados Mag e Arg |
| VF_CtoAbs | valor absoluto (magnitude do ponteiro no plano complexo) |
| VF_CtoArg | argumento (ângulo do ponteiro no plano complexo) |
| VF_CtoNorm | norma (aqui definida como o quadrado do valor absoluto) |
As funções correspondentes para coordenadas polares são:
| VF_MagArgtoP | mesclar dois vetores, Mag e Arg em um vetor complexo polar |
| VF_MagArgtoPrincipal | fundir dois vetores, Mag e Arg reduzindo o intervalo Arg reduzindo o intervalo, -p < Arg <= +p |
| VF_MagtoP | substituir a parte Mag de um vetor complexo polar |
| VF_ArgtoP | substituir a parte Arg de um vetor complexo polar |
| VF_PtoMagArg | extraia as peças Mag e Arg |
| VF_PtoMag | extraia a parte Mag |
| VF_PtoArg | extraia a parte Arg |
| VF_PtoNorm | norma (aqui definida como o quadrado da magnitude) |
| VF_ReImtoP | construa um vetor complexo polar a partir de coordenadas cartesianas, inserido como vetores separados Re e Im |
| VF_PtoReIm | transforme um vetor complexo polar em dois vetores reais, representando as coordenadas cartesianas correspondentes Re and Im |
| VF_PtoRe | Calcule a parte real dos números de entrada complexos polares |
| VF_PtoIm | calcular a parte imaginária dos números de entrada complexos polares |
| VPF_principal | calcule o valor principal. Você pode lembrar que cada número complexo tem um número infinito de representações em coordenadas polares, com os ângulos diferentes por um múltiplo inteiro de 2 p. A representação com -p < Arg <= +p é denominada valor principal. |
4.6 Funções Matemáticas
Faltando uma definição mais bem fundamentada, denotamos como "matemáticas" todas aquelas funções que calculam cada elemento de um vetor a partir do elemento correspondente de outro vetor por uma fórmula matemática mais ou menos simples:
Yi = f( Xi ).
Com exceção das funções "aritmética básica", elas são definidas apenas para os tipos de dados de ponto flutuante. A maioria dessas funções matemáticas são versões vetorizadas de funções escalares ANSI C ou Pascal ou derivadas delas. Em C/C ++, os erros são manipulados por _matherr e _matherrl. No Pascal / Delphi, o OptiVec permite ao usuário controlar o gerenciamento de erros por meio da função V_setFPErrorHandling.
Além deste tratamento de erro "por elemento", os valores de retorno das funções matemáticas VectorLib mostram se todos os elementos foram processados com sucesso. Em C/C ++, o valor de retorno é do tipo de dados int, no Pascal/Delphi, é IntBool. (Nós ainda não usamos o bool de tipo de dados recém-introduzido para este valor de retorno em C/C ++, para tornar o VectorLib compatível também com versões antigas de compiladores C.) Se uma função matemática funcionou sem erros, o valor de retorno é FALSO (0), caso contrário, é VERDADEIRO (qualquer número não-zero).
4.6.1 Arredondamento
Algumas das funções que convertem o ponto flutuante em vetores inteiros já foram observadas acima. O resultado dessas operações de arredondamento pode ser deixado no formato de ponto flutuante original, ou pode ser convertido em um dos tipos inteiros. As seguintes funções armazenam o resultado no formato original de ponto flutuante:
| VF_round | arredondar para o integer mais próximo |
| VF_chop | arredondar negligenciando ("cortando") a parte fracionada |
| VF_trunc | O mesmo que VF_chop |
| VF_ceil | Arredondar para o próximo inteiro maior ou igual |
| VF_floor | Arredondar para o próximo integer menor ou igual |
As seguintes funções armazenam o resultado como integers (tipo int):
O tipo de destino também pode ser qualquer um dos outros tipos de dados integer. Alguns exemplos devem ser suficientes:
| VF_choptoSI | negligencie a parte fracionada e armazene como short int |
| VF_ceiltoLI | Arredondar e armazenar como long int |
| VF_floortoQI | arredondar para baixo e armazenar como número integer quadrúplo, "quad" |
| VF_roundtoU | Arredondar e armazenar como unsigned |
| VF_ceiltoUS | Arredondar e armazenar como unsigned short |
| VD_choptoUL | negligencie a parte fracionada e armazene como unsigned long |
4.6.2 Comparações
As funções que realizam comparações são geralmente chamadas de VF_cmp... (onde outras letras e/ou números especificam o tipo de comparação desejado). Todo elemento de um vetor pode ser comparado com 0, ou com uma constante C, ou com o elemento correspondente de outro vetor. Existem duas possibilidades: seja a comparação realizada com as três respostas possíveis "maiores que", "iguais" ou "menores que". Nesse caso, os resultados são armazenados como números de ponto flutuante (0.0, 1.0 ou -1.0). Os exemplos são:
A outra possibilidade é testar se uma das seguintes condições é preenchida: "maior que", "maior ou igual a", "igual a", "não igual a", "menor que" ou "menor ou igual" para". Aqui, as respostas serão "VERDADEIRO" ou "FALSO" (1.0 ou 0.0). Exemplos são
Alternativamente, os índices dos elementos para os quais a resposta foi "VERDADEIRO" podem ser armazenados em uma matriz de índices, como em:
| VF_cmp_neCind | armazenar índices de elementos não iguais a uma constante C |
| VD_cmp_lt0ind | armazenar índices de elementos inferiores a 0 |
| VE_cmp_geVind | armazenar índices de elementos maiores ou iguais aos elementos vetoriais correspondentes |
Enquanto as funções de comparação básica verificarem contra um limite, há uma série de funções que verificam se um vetor de elementos cai em um certo intervalo:
As seguintes funções testam se um ou mais valores podem ser encontrados em um vetor:
| VF_iselementC |
retorna TRUE, se C é um elemento de um vetor |
| VF_iselementV |
Checadas por cada elemento de um vetor se ele estiver contido em uma tabela |
4.6.3 Manipulação Bit Direta
Para os tipos de dados integer, várias operações bit-wise estão disponíveis, que podem ser usadas, por exemplo, para multiplicações rápidas e divisões por potências integer de 2.
| VI_shl | Mude os bits para a esquerda |
| VI_shr | mude os bits para a direita |
| VI_or | aplicar uma máscara de bit em uma operação de OR |
| VI_xor | aplique um bit de máscara em uma operação XOR |
| VI_not | inverta todos os bits |
4.6.4 Aritmética Básica, Acumulações
Como antes, apenas a função VF_ é explicitamente chamada, mas as funções VD_ e VE_ também existem; Se faz sentido, o mesmo é verdadeiro para o complexo e para as versões de tipo integer:
Além dessas operações básicas, várias combinações de adição e divisão usadas com freqüência foram incluídas, para não esquecer a fórmula de Pitágoras:
Todas as funções na coluna direita das duas seções acima também existem em uma forma expandida (com o prefixo VFx_...) em que a função não é avaliada para o próprio Xi, mas para a expressão (a * Xi + b), e.
As funções algébricas simples também existem em outra forma especial, com o resultado escalado por algum fator arbitrário. Este formulário escalado obtém o prefixo VFs_:
Outras operações simples incluem:
| VF_maxC | ajuste Yi igual a Xi o que for maior |
| VF_minC | escolha o menor de Xi e C |
| VF_maxV | ajuste Zi igual a Xi ou Yi, o que for maior |
| VF_minV | definir Zi igual a Xi or Yi, o que for menor |
| VF_limit | Limite a gama de valores |
| VF_flush0 | ajuste todos os valores para zero que estão abaixo de um limite predefinido |
| VF_flushInv | ajuste todos os valores para zero que estão abaixo de um limite predefinido e tome o inverso de todos os outros valores |
| VF_intfrac | dividido em partes inteiras e fracionadas |
| VF_mantexp | dividido em mantissa e exponente |
Enquanto, em geral, todas as funções OptiVec são para vetores de entrada e saída do mesmo tipo, as funções aritméticas também existem para operações de tipo misto entre os tipos de ponto flutuante e os tipos inteiros. O resultado é sempre armazenado no tipo de ponto flutuante. Os exemplos são:
Da mesma forma, existe uma família de funções para a acumulação de dados no mesmo tipo ou em tipos de dados de maior precisão. Alguns exemplos são:
Additionally, within the floating-point data-types, you can accumulate two vectors at once:
| VF_acc2V | fVector Y += fVector X1 + fVector X2 |
| VD_acc2VF | dVector Y += fVector X1 + fVector X2 |
4.6.5 Geometrical Vector Arithmetics
In its geometrical interpretation, a vector is a pointer, with its elements representing the coordinates of a point in n-dimensional space. There are a few functions for geometrical vector arithmetics, namely
If, on the other hand, two real input vectors X and Y, or one complex input vector XY, define the coordinates of several points in a planar coordinate system, there is a function to rotate these coordinates:
| VF_rotateCoordinates |
counter-clockwise rotation of the input coordinates specified by the vectors X and Y; the result is returned in the vectors Xrot and Yrot. |
| VCF_rotateCoordinates |
counter-clockwise rotation of the input coordinates specified by the cartesian complex vector XY; the result is returned in the vector XYrot. |
4.6.6 Potências
As seguintes funções elevam números arbitrários a potências especificadas. As "versões desprotegidas" extra-rápidas podem ser empregadas em situações em que você tenha certeza absoluta de que todos os elementos de entrada produzam resultados válidos. Devido à vetorização muito mais eficiente permitida pela ausência de verificações de erro, as funções desprotegidas são até 1,8 vezes mais rápido que as versões protegidas. (Isso é verdade desde a CPU do Pentium, em computadores antigos, quase nada é ganho.) Seja, no entanto, consciente do preço que você tem que pagar por esse aumento de velocidade: em caso de erro de transbordamento, o programa falhará sem qualquer aviso.
O seguinte grupo de funções é usado para elevar números especificados para poderes arbitrários:
| VF_pow10 |
fractional powers of 10 |
| VF_ipow10 |
Potenciais integer de 10 (armazenados como números de ponto flutuante) |
| VF_pow2 |
potências fracionários de 2 |
| VF_ipow2 |
Potenciais integer de 2 (armazenados como números de ponto flutuante) |
| VF_exp |
exponential function |
| VF_exp10 |
função exponencial na base 10 (idêntico to VF_pow10) |
| VF_exp2 |
função exponencial na base 2 (idêntico to VF_pow2) |
| VF_expArbBase |
função exponencial de uma base arbitrária |
| VF_sqrt |
raiz quadrada (que corresponde ao potencial de 0.5) |
Todas essas funções também existem no formulário "VFx_" expandido,
VFx_square: Yi = (a * Xi + b)²
A forma expandida das funções desprotegidas tem o prefixo VFux_.
Os equivalentes de números complexos também estão disponíveis, tanto para coordenadas cartesianas como polares. Além disso, são abordados dois casos especiais:
| VCF_powReExpo |
Poderes reais, fracionários de números complexos |
| VCF_exptoP |
possui um vetor de entrada cartesiano, retornando sua função exponencial em coordenadas polares. |
4.6.7 Exponenciais e Funções Hiperbólicas
Uma variedade de funções são derivadas da função exponencial VF_exp (que já foi mencionada na última seção).
| VF_exp |
Função exponencial |
| VF_expc |
função exponencial complementar Yi = 1 - exp[Xi] |
| VF_expmx2 |
função exponencial do quadrado negativo do argumento,
Yi = exp( -Xi² ). Esta é uma função em forma de sino. |
| VF_powexp | n.a. | poderes fracionários, multiplicados pela função exponencial, Xirexp(Xi) |
| VF_Gauss |
Função de distribuição Gaussiana |
| VF_erf |
Função de erro (Integral over the Gaussian distribution) |
| VF_erfc |
função de erro complementar, 1 - erf( Xi ) |
As funções hiperbólicas vetorizadas estão disponíveis como:
4.6.8 Logaritmos
Mais uma vez, os equivalentes do complexo cartesiano também existem. As versões de complexo polar, no entanto, são especiais em que sua saída está sempre em coordenadas cartesianas:
Como uma forma especial do logaritmo decádico, a Densidade Óptica é disponibilizada por uma família de funções das quais alguns exemplos estão contidos na tabela a seguir:
| VF_OD | OD = log10( X0/X ) para fVector como entrada e como saída |
| VF_ODwDark | OD = log10( (X0-X0Dark) / (X-XDark) ) para fVector como entrada e como saída |
| VUS_ODtoF | OD, calculado em float precisão para entrada usVector |
| VUL_ODtoD | OD, calculado em precisão double para entrada ulVector |
| VQI_ODtoEwDark | OD with dark-current correction, calculado em precisão extended para entrada qiVector |
4.6.9 Funções Trigonométricas
As funções trigonométricas básicas estão disponíveis em duas variantes. A primeira variante segue as regras usuais de tratamento de erros para funções de matemática, enquanto a segunda é para situações em que você sabe de antemão que todos os argumentos de entrada estarão no intervalo de -2pi <= Xi <= + 2pi. Se você optar por empregar essas funções extra-rápidas de alcance reduzido, você precisa ter certeza absoluta sobre seus vetores de entrada, pois essas funções serão bloqueadas sem aviso prévio no caso de qualquer número de entrada fora do intervalo especificado acima. As funções de alcance reduzido estão disponíveis apenas para o seno e o co-seno, pois todas as outras funções trigonométricas precisam de verificação e tratamento de erros de qualquer maneira, mesmo nesta faixa.
As seguintes funções fornecem os quadrados das funções trigonométricas de uma forma mais eficiente do que pelo primeiro cálculo das funções básicas e quadrados depois:
Uma maneira muito eficiente de calcular as funções trigonométricas para argumentos representáveis como múltiplos racionais de pi (PI) é fornecida pelas funções trigonométricas com o sufixo "rpi" (que significa "múltiplo racional de pi"). Aqui, r = p / q, onde q é constante e p é dado pelos elementos do vetor de entrada::
Versões ainda mais eficientes usam tabelas para obter valores usados com freqüência; estas versões são denotadas pelos sufixos "rpi2" (múltiplos de p divididos por uma potência inteira de 2) e "rpi3" (múltiplos de p em um múltiplo integer de 3). Os exemplos são:
Mais duas funções trigonométricas especiais são:
| VF_sinc |
Função sinc, Yi = sin( Xi ) / Xi |
| VF_Kepler |
Função Kepler, calculando a posição angular dependente do tempo de um planeta ou uma cometa |
As funções trigonométricas inversas vetorizadas estão disponíveis como
4.7 Análise
Há várias funções que examinam as propriedades analíticas dos arrays de dados:
| VF_derivV |
derivado de uma matriz Y em relação a uma matriz X |
| VF_derivC |
o mesmo para intervalos constantes entre os valores X |
| VF_integralV |
valor da integral de uma matriz Y em uma matriz X |
| VF_runintegralV |
integral ponto-a-ponto ("executando") |
| VF_integralC |
integral sobre um eixo X igualmente espaçado |
| VF_runintegralC |
integral ponto-a-ponto sobre um eixo X igualmente espaçado |
| VF_ismonoton |
teste se uma matriz está subindo ou caindo de forma monótona |
| VF_iselementC |
teste, se um dado valor ocorrer dentro de um vetor |
| VF_searchC |
procure uma tabela ordenada para a entrada cujo valor se aproxima mais de um valor predefinido C |
| VF_localmaxima |
detectar maxima local (pontos cujos vizinhos direito e esquerdo são menores) |
| VF_localminima |
detectar mínimos locais (pontos cujos vizinhos direito e esquerdo são maiores) |
| VF_max |
detectar o máximo global |
| VF_min |
detectar o mínimo global |
| VF_maxind |
máximo global e seu índice |
| VF_minind |
mínimo global e seu índice |
| VF_absmax |
valor absoluto máximo global |
| VF_absmin |
valor absoluto mínimo global |
| VF_absmaxind |
valor absoluto máximo global e seu índice |
| VF_absminind |
valor absoluto mínimo global e seu índice |
| VF_maxexp |
expoente global máximo |
| VF_minexp |
Expoente mínimo global |
| VF_runmax |
"máximo "execução |
| VF_runmin |
"Mínimo “execução |
Os equivalentes complexos do último grupo de funções são:
Somas, produtos, etc. estão disponíveis por funções agrupadas como blocos de construção estatísticos e resumidas no capítulo 4.9.
Para determinar o centro de gravidade de um vetor, você tem a opção entre as duas funções a seguir
4.8 Processamento de Sinal:
Transformações Fourier e Tópicos Relacionados
A lista de funções a seguir está disponível para aplicativos de processamento de sina:
| VF_FFTtoC |
Transformação rápida de Fourier (FFT) de um vetor real; o resultado é um vetor complexo cartesiano |
| VF_FFT |
FFT de frente e para trás de um vetor real; o resultado do FFT dianteiro é empacotado em um vetor real do mesmo tamanho que o vetor de entrada |
| VCF_FFT |
FFT frente e verso de um vetor complexo |
| MF_Rows_FFT | FFT ao longo das linhas de uma matriz; esta função pode ser usada para o processamento em lote de vários vetores de tamanho idêntico, armazenados como as linhas de uma matriz |
| MF_Cols_FFT | FFT ao longo das colunas de uma matriz; esta função pode ser usada para o processamento em lote de vários vetores de tamanho idêntico, armazenados como as colunas de uma matriz |
| VF_convolve |
convolução com uma função de resposta dada |
| VF_deconvolve |
deconvolução, assumindo uma função de resposta dada |
| VF_filter |
filtragem espectral |
| VF_spectrum |
análise espectral |
| VF_autocorr |
Função de autocorrelação de uma matriz de dados |
| VF_xcorr |
http://www.optivec.com/vecfuncs/xcorr.htm |
| VF_setRspEdit |
definir o limite de edição para o filtro em convoluções e deconvoluções (decide sobre o tratamento das frequências "perdidas) |
| VF_getRspEdit |
recuperar o limite de edição atual |
Embora eles não usem métodos de transformação de Fourier, as funções VF_biquad (filtragem bi-quadrática de áudio) e VF_smooth (forma bruta de filtragem de freqüência que remove o ruído de alta freqüência) devem ser mencionadas aqui.
4.9 Funções Estatísticas e Blocos de Construção
A seguinte coleção de funções estatísticas é oferecida pela OptiVec:
| VF_sum |
soma de todos os elementos |
| VI_fsum |
soma de todos os elementos de um vetor inteiro, acumulado como um número de ponto flutuante em uma precisão dupla ou estendida |
| VF_prod |
produto de todos os elementos |
| VF_ssq |
soma de quadrados de todos os elementos |
| VF_sumabs |
soma de valores absolutos de todos os elementos |
| VF_rms |
raiz-do-meio-quadrado de todos os elementos |
| VF_runsum |
somatório |
| VF_runprod |
produto em execução |
| VF_sumdevC |
somar os desvios de uma constante predefinida, soma( |Xi-C| ) |
| VF_sumdevV |
somar os desvios de outro vetor, soma( |Xi-Yi| ) |
| VF_avdevC |
desvio médio de uma constante predefinida, 1 / N * soma( |Xi-C| ) |
| VF_avdevV |
desvio médio de outro vetor, 1 / N * soma( |Xi-Yi| ) |
| VF_ssqdevC |
soma de quadrados dos desvios de uma constante predefinida,
soma( (Xi - C)² ) |
| VF_ssqdevV |
soma dos quadrados dos desvios de outro vetor,
soma( (Xi - Yi)² ) |
| VF_chi2 |
função de mérito do qui-quadrado |
| VF_chiabs |
"Função de mérito "robusta", semelhante ao VF_chi2, mas com base em desvios absolutos em vez de quadrados |
| VF_mean |
média igualada (ou média) de todos os elementos |
| VF_meanwW |
"significado com pesos" de todos os elementos |
| VF_meanabs |
média igualada (ou média) dos valores absolutos de todos os elementos |
| VF_selected_mean |
mede apenas os elementos vetoriais que se enquadram em um intervalo especificado, permitindo assim excluir pontos extravagantes do cálculo da média |
| VF_varianceC |
variância de uma distribuição em relação a um valor constante predefinido |
| VF_varianceCwW |
o mesmo com ponderação não igual |
| VF_varianceV |
variância de uma distribuição em relação a outra |
| VF_varianceVwW |
o mesmo com ponderação não igual |
| VF_meanvar |
média e variância de uma distribuição simultaneamente |
| VF_meanvarwW |
o mesmo com ponderação não igual |
| VF_median |
mediana de uma distribuição |
| VF_corrcoeff |
coeficiente de correlação linear de duas distribuições |
| VF_distribution |
armazena dados em uma função discreta de distribuição unidimensional |
| VF_min_max_mean_stddev |
cálculo simultâneo do mínimo, máximo, médio e desvio padrão de uma distribuição unidimensional |
4.10 Data Fitting
Variando de uma regressão linear simples para problemas de montagem complexos envolvendo múltiplos conjuntos de dados e funções não-lineares com muitos parâmetros ajustáveis, o OptiVec oferece rotinas para praticamente todas as tarefas de montagem de dados que ocorrem praticamente. Como todos eles, com exceção da regressão linear simples, dependem de métodos de matriz, eles realmente fazem parte do #include <MFstd.h> (<MDstd.h>< MEstd.h>) ou a unidade MFstd, (MDstd, MEstd). Nos modelos de 16 bits do Borland C/C ++, você também deve incluir o arquivo MC ??. LIB para o modelo respectivo. Uma descrição detalhada dos vários conceitos de ajuste de dados é dada em outro lugar. Portanto, neste local, as funções de montagem X-Y disponíveis são resumidas apenas na tabela a seguir:
| VF_linregress |
Regressão linear ponderada igualmente em dados X-Y |
| VF_linregresswW |
o mesmo com ponderação não igual |
| VF_polyfit |
montagem de um conjunto de dados X-Y em um polinômio |
| VF_polyfitwW |
o mesmo para ponderação de ponto de dados não-igual |
| VF_linfit |
montagem de um conjunto de dados X-Y para uma função arbitrária linear em seus parâmetros |
| VF_linfitwW |
o mesmo para ponderação de ponto de dados não-igual |
| VF_setLinfitNeglect |
definir o limite para negligenciar (ou seja, definir igual a zero) um parâmetro de ajuste A [i], se sua significância for menor do que o limite |
| VF_getLinfitNeglect |
recuperar o limite de significância atual |
| VF_nonlinfit |
montagem de um conjunto de dados X-Y para uma função arbitrária, possivelmente não-linear |
| VF_nonlinfitwW |
o mesmo para ponderação de ponto de dados não-igual |
| VF_multiLinfit |
montagem de vários conjuntos de dados X-Y para uma função linear comum |
| VF_multiLinfitwW |
o mesmo para ponderação de ponto de dados não-igual |
| VF_multiNonlinfit |
montagem de vários conjuntos de dados X-Y para uma função não linear comum |
| VF_multiNonlinfitwW |
o mesmo para ponderação de ponto de dados não-igual |
4.11 Entrada e Saída
| VF_cprint |
imprima os elementos de um vetor na tela (ou "console" - daí o "c" no nome) na janela de texto atual, detectando automaticamente sua altura e largura. Depois de imprimir uma página, o usuário é solicitado a continuar. (Somente para DOS) |
| VF_print |
é semelhante a VF_cprint na medida em que a saída é direcionada para a tela, mas não há detecção automática dos dados da tela; é assumida uma largura de linha padrão de 80 caracteres, e nenhuma divisão em páginas é feita. (Somente para DOS e EasyWin) |
| VF_fprint |
imprima um vetor para um fluxo. |
| VF_write |
escreva dados em formato ASCII em um fluxo |
| VF_read |
leia um vetor de um arquivo ASCII |
| VF_nwrite |
write n escreva n vetores do mesmo tipo de dados que as colunas de uma tabela em um fluxo |
| VF_nread |
Leia as colunas de uma tabela em n vetores do mesmo tipo |
| VF_store |
armazenar dados em formato binário |
| VF_recall |
recuperar dados em formato binário |
As seguintes funções permitem modificar as configurações padrão de VF_write,
VF_nwrite e VI_read:
4.12 Gráficos
VectorLib inclui uma variedade de rotinas de traçado de dados. Antes de qualquer um deles ser usado, gráficos VectorLib devem ser inicializados:
| V_initPlot |
inicialize as funções de gráficos VectorLib (Windows e DOS). Para o Windows, nenhum fim é necessário no final, uma vez que as funções gráficas do Windows permanecem sempre acessíveis. V_initPlot reserva automaticamente uma parte da tela para as operações de traçado. Esta parte compreende cerca de 2/3 da tela do lado direito. Acima, uma linha é deixada para um título. Abaixo, algumas linhas ficam vazias. Para alterar esta região de traçado padrão, ligue para V_setPlotRegion após V_initPlot. |
| V_initGraph |
Inicialize simultaneamente a interface gráfica de Borland e as funções VectorLibplotting (somente DOS). |
| V_initPrint |
inicialize as funções gráficas do VectorLib e direcione-as para uma impressora (somente para Windows). Por padrão, uma página inteira é reservada para plotar. Para alterar isso, ligue para V_setPlotRegion after V_initPrint. |
| V_setPlotRegion |
defina uma região de traçado diferente do padrão |
VectorLib distingue dois tipos de funções de traçado, AutoPlot e DataPlot. Todas as funções AutoPlot (por exemplo, VF_xyAutoPlot) executam as seguintes etapas:
- defina uma viewport dentro da região de traçado (que é a região padrão ou a definida pelo chamado V_setPlotRegion)
- limpe a viewport
- gerar um sistema de coordenadas cartesianas com eixos adequadamente dimensionados e rotulados
- traçar os dados de acordo com os parâmetros passados para a função
Todas as funções do DataPlot executam apenas o último passo. Eles assumem que um sistema de coordenadas já existe de uma chamada anterior para qualquer uma das funções AutoPlot para V_findAxes, ou para V_drawAxes. O novo gráfico é adicionado ao existente.
Para todas as funções de traçado, os diferentes estilos de plotagem (símbolos, linhas e cores) são especificados como parâmetros, veja VF_xyAutoPlot. Aqui está uma lista das rotinas AutoPlot e DataPlot disponíveis:
| VF_xyAutoPlot |
exibe um gráfico de escala automática de um par de vetores |
| VF_yAutoPlot |
traçar um único Y-vector, usando o índice como eixo X |
| VF_xy2AutoPlot |
traçar dois pares de X-Y ao mesmo tempo, escalando os eixos de tal forma que ambos os vetores se encaixam no mesmo sistema de coordenadas |
| VF_y2AutoPlot |
o mesmo para dois vetores-Y, conspirados contra seus índices |
| VF_xyDataPlot |
traçar um conjunto adicional de dados X-Y |
| VF_yDataPlot |
traçar um vetor Y adicional sobre o índice |
As matrizes complexas cartesianas são impressas no plano complexo (as partes imaginárias versus as partes reais), usando
É possível desenhar mais de um sistema de coordenadas em uma determinada janela na tela. A posição de cada sistema de coordenadas deve ser especificada por V_setPlotRegion. "Hopping" entre os diferentes sistemas de coordenadas e adicionar novos DataPlots depois de definir novas viewports (por exemplo, para saída de texto) é possível pelas seguintes funções:
| V_continuePlot |
volte para a viewport da última parcela e restaure suas mudanças |
| V_getCoordSystem |
obtenha uma cópia dos escores e posição do sistema de coordenadas atual |
| V_setCoordSystem |
restaurar os escalões e a posição de um sistema de coordenadas; estes devem ter sido armazenados anteriormente, usando V_getCoordSystem |
| 
